refactor: unify hook notification system, remove duplicate broadcasts

- Replace forward-hook.ps1 with notify.ps1 (now accepts optional agent param)
- Remove ejecutor settings.local.json (redundant status hooks, deriveStatus covers it)
- Remove legacy claude-permission system (route, store methods, terminal broadcast)
- Remove redundant deriveStatus + /claude-status POST from claude-hook.ts
  (broadcastClaudeHook → processHookEvent already handles status derivation)
- Clean up HookNotifications.vue permission buttons (dead code)

server/routes/claude-hook.ts

@@ -2,7 +2,7 @@ import { jsonResponse, errorResponse } from '../utils/cors'
 import { PORT_TERMINAL } from '../config'
 import { existsSync, readFileSync } from 'fs'
 import { setActiveSession, getIncrementalMessages } from '../services/transcript-engine'
-import { deriveStatus, sessionState, type HookPayload } from '../services/session-state'
+import { sessionState, type HookPayload } from '../services/session-state'
 
 export async function handleClaudeHook(req: Request): Promise<Response | null> {
   if (req.method !== 'POST') return null
@@ -68,34 +68,7 @@ export async function handleClaudeHook(req: Request): Promise<Response | null> {
       console.error('[claude-hook] Failed to forward hook to terminal server:', e)
     }
 
-    // 2. Forward PermissionRequest to /claude-permission for hooks approval system
-    if (body.hook_event_name === 'PermissionRequest') {
-      try {
-        await fetch(`http://localhost:${PORT_TERMINAL}/claude-permission`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(hookData)
-        })
-      } catch (e) {
-        console.error('[claude-hook] Failed to forward permission to terminal server:', e)
-      }
-    }
-
-    // 3. Derive status and broadcast via WebSocket
-    const derived = deriveStatus(body)
-    if (derived) {
-      try {
-        await fetch(`http://localhost:${PORT_TERMINAL}/claude-status`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ status: derived.status, tool: derived.tool, agent })
-        })
-      } catch (e) {
-        console.error('[claude-hook] Failed to forward status to terminal server:', e)
-      }
-    }
-
-    // 4. Incremental transcript reading for real-time chat
+    // 2. Incremental transcript reading for real-time chat
     if (body.session_id && body.transcript_path) {
       setActiveSession(agent, body.session_id, body.transcript_path as string)
 

server/routes/claude-permission.ts

@@ -1,111 +0,0 @@
-import { jsonResponse, errorResponse } from '../utils/cors'
-import { PORT_TERMINAL } from '../config'
-
-interface PermissionPayload {
-  hook_event_name?: string
-  session_id?: string
-  tool_name?: string
-  tool_input?: unknown
-  cwd?: string
-  [key: string]: unknown
-}
-
-interface PendingPermission {
-  resolve: (decision: string) => void
-  timer: ReturnType<typeof setTimeout>
-  payload: PermissionPayload
-}
-
-// Map of requestId -> pending permission promise resolver
-const pendingPermissions = new Map<string, PendingPermission>()
-
-const PERMISSION_TIMEOUT_MS = 60_000
-
-export async function handleClaudePermission(req: Request): Promise<Response | null> {
-  if (req.method !== 'POST') return null
-
-  try {
-    const body = await req.json() as PermissionPayload
-    const requestId = `perm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
-
-    // Broadcast permission request to UI via WebSocket
-    try {
-      await fetch(`http://localhost:${PORT_TERMINAL}/claude-permission`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ requestId, ...body })
-      })
-    } catch (e) {
-      console.error('[claude-permission] Failed to broadcast to terminal server:', e)
-    }
-
-    // Also broadcast claude-status for backward compat (animations)
-    try {
-      await fetch(`http://localhost:${PORT_TERMINAL}/claude-status`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ status: 'permissionRequest', tool: body.tool_name })
-      })
-    } catch (e) {
-      console.error('[claude-permission] Failed to forward status:', e)
-    }
-
-    // Wait for UI decision (or timeout)
-    const decision = await new Promise<string>((resolve) => {
-      const timer = setTimeout(() => {
-        pendingPermissions.delete(requestId)
-        resolve('ask')
-      }, PERMISSION_TIMEOUT_MS)
-
-      pendingPermissions.set(requestId, { resolve, timer, payload: body })
-    })
-
-    return jsonResponse({ decision, requestId })
-  } catch (e) {
-    return errorResponse('Invalid JSON body', 400)
-  }
-}
-
-export async function handleClaudePermissionRespond(req: Request): Promise<Response | null> {
-  if (req.method !== 'POST') return null
-
-  try {
-    const body = await req.json() as { requestId: string, decision: 'allow' | 'deny' }
-
-    if (!body.requestId || !body.decision) {
-      return errorResponse('Missing requestId or decision', 400)
-    }
-
-    if (!['allow', 'deny'].includes(body.decision)) {
-      return errorResponse('Decision must be "allow" or "deny"', 400)
-    }
-
-    const pending = pendingPermissions.get(body.requestId)
-    if (!pending) {
-      return errorResponse('Permission request not found or already expired', 404)
-    }
-
-    // Resolve the pending promise
-    clearTimeout(pending.timer)
-    pendingPermissions.delete(body.requestId)
-    pending.resolve(body.decision)
-
-    return jsonResponse({ success: true, requestId: body.requestId, decision: body.decision })
-  } catch (e) {
-    return errorResponse('Invalid JSON body', 400)
-  }
-}
-
-// List pending permissions (useful for UI to recover state)
-export async function handleClaudePermissionList(req: Request): Promise<Response | null> {
-  if (req.method !== 'GET') return null
-
-  const pending = Array.from(pendingPermissions.entries()).map(([id, p]) => ({
-    requestId: id,
-    tool_name: p.payload.tool_name,
-    tool_input: p.payload.tool_input,
-    session_id: p.payload.session_id
-  }))
-
-  return jsonResponse({ pending })
-}

server/routes/index.ts

@@ -12,7 +12,6 @@ import { handleWhisperRoutes } from './whisper'
 import { handleRecordingsRoutes } from './recordings'
 import { handleClaudeStatus } from './claude-status'
 import { handleClaudeHook } from './claude-hook'
-import { handleClaudePermission, handleClaudePermissionRespond, handleClaudePermissionList } from './claude-permission'
 import { handleSnapshots, handleSnapshotById } from './snapshots'
 import { handleGitStatus, handleGitDiff, handleGitLog, handleGitLogCommit, handleGitCompare, handleGitBranches, handleGitCurrentBranch, handleGitTree, handleGitFile } from './git'
 import {
@@ -81,22 +80,6 @@ export async function handleRequest(req: Request): Promise<Response> {
     if (res) return res
   }
 
-  // Claude Code permission request/respond
-  if (path === '/api/claude-permission') {
-    if (req.method === 'GET') {
-      const res = await handleClaudePermissionList(req)
-      if (res) return res
-    } else {
-      const res = await handleClaudePermission(req)
-      if (res) return res
-    }
-  }
-
-  if (path === '/api/claude-permission-respond') {
-    const res = await handleClaudePermissionRespond(req)
-    if (res) return res
-  }
-
   // Components
   if (path === '/api/components') {
     const res = await handleComponents(req)

server/services/terminal.ts

@@ -257,6 +257,7 @@ export async function startAgentInSession(agentId: string, force = false): Promi
 
 export function startTerminalServer() {
   const server = Bun.serve({
+    hostname: '0.0.0.0',
     port: PORT_TERMINAL,
     async fetch(req, server) {
       const url = new URL(req.url)
@@ -316,17 +317,6 @@ export function startTerminalServer() {
         }
       }
 
-      // Claude permission request broadcast endpoint
-      if (url.pathname === '/claude-permission' && req.method === 'POST') {
-        try {
-          const body = await req.json()
-          broadcastPermissionRequest(body)
-          return Response.json({ success: true }, { headers: corsHeaders })
-        } catch {
-          return Response.json({ error: 'Invalid JSON' }, { status: 400, headers: corsHeaders })
-        }
-      }
-
       // Agent sessions info
       if (url.pathname === '/agent-sessions' && req.method === 'GET') {
         const result: Record<string, any> = {}
@@ -762,8 +752,6 @@ export function broadcastClaudeStatus(status: ClaudeStatus, tool?: string, agent
   console.log(`[Terminal] Claude status broadcast: ${status}${tool ? ` (${tool})` : ''} → ${clientCount} clients`)
 
   // Note: session state is updated via broadcastClaudeHook which has full payload context.
-  // Direct /claude-status POSTs (from ejecutor's settings.local.json) are lightweight
-  // and don't carry enough context to update full session state.
 }
 
 // Broadcast full Claude hook data to ALL clients
@@ -783,18 +771,6 @@ export function broadcastClaudeHook(data: Record<string, unknown>) {
   console.log(`[Terminal] Claude hook broadcast: ${data.hook_event_name || 'unknown'}${data.tool_name ? ` (${data.tool_name})` : ''} → ${clientCount} clients`)
 }
 
-// Broadcast permission request to ALL clients
-export function broadcastPermissionRequest(data: Record<string, unknown>) {
-  const message = JSON.stringify({
-    type: 'claude-permission',
-    ...data,
-    timestamp: Date.now()
-  })
-
-  const clientCount = broadcastToAll(message)
-  console.log(`[Terminal] Permission request broadcast: ${data.tool_name || 'unknown'} (${data.requestId}) → ${clientCount} clients`)
-}
-
 // Broadcast transcript updates to ALL clients
 export function broadcastTranscriptUpdate(data: Record<string, unknown>) {
   const message = JSON.stringify({