@newsails/veil-studio 1.0.1 → 2.0.0

package/server/socket.js

@@ -1,17 +1,30 @@
 'use strict'
 
+const terminalManager = require('./utils/terminal-manager.js')
 const boardState = require('./utils/board-state.js')
 const { isVeilConnected } = require('./utils/veil-ws.js')
 const { getAllTypes, getElementType, reloadCustomElements } = require('./utils/element-registry.js')
 const { getInstance, invokeAction, initAllInstances, destroyInstance, createInstance, getViewData, getPorts } = require('./utils/element-instances.js')
 const { getIO } = require('./utils/socket-io.js')
 const {
-  veilGet, veilPost, veilPut, veilDelete, veilStreamChat,
+  veilGet, veilPost, veilPut, veilPatch, veilDelete, veilStreamChat, veilStreamTerminalAi, veilStreamGitCommitAi, veilCancelSession, veilGetStreaming,
 } = require('./utils/veil-client.js')
 const { setActiveStreamsRef, setElementStreamingRef } = require('./utils/veil-ws.js')
 const { touchSession } = require('./utils/session-watcher.js')
+const { orchestrationGraph, initOrchestrationGraph } = require('./utils/orchestration-graph.js')
 
 const _activeStreams = new Map() // sessionId → { stopped: boolean } — shared across all socket connections
+
+// Extension connection handlers — called for every new socket connection
+const _extConnectionHandlers = []
+
+function registerExtensionConnectionHandler(fn) {
+  _extConnectionHandlers.push(fn)
+  return () => {
+    const idx = _extConnectionHandlers.indexOf(fn)
+    if (idx !== -1) _extConnectionHandlers.splice(idx, 1)
+  }
+}
 setActiveStreamsRef(_activeStreams)
 setElementStreamingRef(_setElementStreaming)
 
@@ -39,6 +52,16 @@ function registerSocketHandlers(io) {
     socket.emit('board:init', { snapshot: boardState.getSnapshot() })
     socket.emit('veil:status', { connected: isVeilConnected() })
     socket.emit('element-types:update', { types: getAllTypes() })
+    socket.emit('orchestration:graph', orchestrationGraph.getFullGraph())
+
+    // PR-1 item 2A: best-effort fetch of Veil's authoritative active-streams
+    // list and emit to THIS socket only. Replaces the client's old
+    // `clearAllStreaming()` sledgehammer with a selective restoration. Any
+    // failure swallowed in `veilGetStreaming` → returns []; we still emit
+    // the empty list so the client knows to flip stale `isStreaming` flags off.
+    veilGetStreaming().then(streams => {
+      if (Array.isArray(streams)) socket.emit('streaming:active', streams)
+    }).catch(() => {})
 
     // Send initial element view data + ports for all elements
     for (const el of boardState.getElements()) {
@@ -85,7 +108,7 @@ function registerSocketHandlers(io) {
         const res = await veilPost('/sessions', { agentName })
         const sessionId = res.sessionId || res.id || res.session_id
         if (!sessionId) throw new Error('No sessionId returned from Veil API')
-        const el = boardState.createElement({ type: 'agent-instance', x: x ?? 200, y: y ?? 200, width: 180, height: 120, data: { agentName, sessionId } })
+        const el = boardState.createElement({ type: 'agent-instance', x: x ?? 200, y: y ?? 200, data: { agentName, sessionId } })
         _createInstanceAndBroadcast(el)
         if (typeof ack === 'function') ack({ ok: true, elementId: el.id, sessionId })
       } catch (err) {
@@ -135,33 +158,80 @@ function registerSocketHandlers(io) {
 
     // ─── Chat Streaming ─────────────────────────────────────────────────────
 
-    socket.on('chat:send', async ({ agentName, sessionId, message } = {}) => {
-      const ctrl = { stopped: false }
+    socket.on('chat:send', async ({ agentName, sessionId, message, attachments, continue: continueResume } = {}) => {
+      // PR-3 item 2: outbound structured attachments. Additive destructure —
+      // `attachments` is `undefined` when absent (legacy callers / continue
+      // emits at `useChat.continueSession`). When present, it MUST be an array
+      // of `Attachment` objects (`{kind, url, mime_type?, name?}`) per
+      // `nuxt-app/types/index.ts`. We do NOT pre-flight-validate at the Studio
+      // layer (Med4 dropped the 8MB cap pre-check) — Veil's own
+      // per-attachment validator is authoritative; PR-1 item 7 preserves any
+      // structured error envelope back to the client. Defensive: a non-array
+      // value is silently dropped (treated as if absent).
+      const _atts = Array.isArray(attachments) && attachments.length ? attachments : undefined
+      // Mid-turn sends: do NOT cancel a prior active stream. Veil's
+      // pushToExistingSession buffers the new message into _pendingInjections
+      // and processes it after the current turn/tool completes. The new POST
+      // returns immediately with content:null; the buffered message's events
+      // flow through the original runtime's stream callbacks.
+      const ctrl = { abortController: new AbortController(), stopped: false }
       _activeStreams.set(sessionId, ctrl)
       // Broadcast user message to all clients immediately so every tab sees it
-      getIO().to('board').emit('chat:user-message', { sessionId, agentName, message })
+      getIO().to('board').emit('chat:user-message', { sessionId, agentName, message, attachments: _atts })
       // Mark element as streaming so all clients can reflect the loading state
       _setElementStreaming(sessionId, true)
+      // Register the active session in the orchestration graph with its real
+      // agentName before any agent_spawn fires. Veil does not emit
+      // session.created for top-level sessions, so without this registration
+      // the parent shows up as a stub with empty agentName when its first
+      // sub-session is spawned. Idempotent — returns null on repeat calls.
+      const _stamp = orchestrationGraph._ensureNode(sessionId, null, agentName || '', 'active')
+      if (_stamp) orchestrationGraph._emitDeltas([_stamp])
       try {
         let lastMessage = null
         let tokenUsage = null
         const io = getIO()
-        for await (const chunk of veilStreamChat(agentName, message, sessionId)) {
-          if (ctrl.stopped) break
+        for await (const chunk of veilStreamChat(agentName, message, sessionId, { signal: ctrl.abortController.signal, attachments: _atts, continueResume })) {
+          if (ctrl.stopped) {
+            try { ctrl.abortController.abort() } catch (_) {}
+            break
+          }
+          // Mid-stream structured error from Veil (SSE `event: error`). Preserve
+          // the full envelope to the client and stop consuming the stream — see
+          // PR-1 item 7 (server-side error preservation).
+          if (chunk.eventType === 'error') {
+            io.to('board').emit('chat:error', { sessionId, error: chunk.data })
+            break
+          }
           io.to('board').emit('chat:stream', { sessionId, eventType: chunk.eventType, data: chunk.data })
-          if (chunk.eventType === 'message') lastMessage = chunk.data
+          if (chunk.eventType === 'message') {
+            lastMessage = chunk.data
+            // Feed orchestration graph (Studio-initiated streams bypass veil-ws.js)
+            const oDeltas = orchestrationGraph.processMessage(sessionId, chunk.data, agentName)
+            if (oDeltas) orchestrationGraph._emitDeltas(oDeltas)
+          }
           if (chunk.data && chunk.data.token_usage) tokenUsage = chunk.data.token_usage
         }
         if (!ctrl.stopped) {
           io.to('board').emit('chat:done', { sessionId, message: lastMessage, tokenUsage })
         } else {
-          io.to('board').emit('chat:done', { sessionId, message: null, tokenUsage: null })
+          io.to('board').emit('chat:done', { sessionId, message: null, tokenUsage: null, cancelled: true })
         }
       } catch (err) {
-        console.error('[chat:send] Error:', err.message)
-        getIO().to('board').emit('chat:error', { sessionId, error: err.message })
+        // AbortError or stopped flag → treat as cancelled, NOT an error. The
+        // upstream Veil generation has been instructed to halt via
+        // veilCancelSession (fired by chat:stop). Emit a `chat:done` with
+        // cancelled:true so the client preserves the partial buffer.
+        if (err && (err.name === 'AbortError' || ctrl.stopped)) {
+          getIO().to('board').emit('chat:done', { sessionId, message: null, tokenUsage: null, cancelled: true })
+        } else {
+          console.error('[chat:send] Error:', err.message)
+          getIO().to('board').emit('chat:error', { sessionId, error: { code: err.code || 'STUDIO_ERROR', message: err.message, details: err.details, phase: err.phase } })
+        }
       } finally {
-        _activeStreams.delete(sessionId)
+        // Only clear the entry if it's still ours — a concurrent chat:send for
+        // the same sessionId may have replaced the controller above.
+        if (_activeStreams.get(sessionId) === ctrl) _activeStreams.delete(sessionId)
         // Mark element as no longer streaming
         _setElementStreaming(sessionId, false)
         // Advance message baseline so the next external syncSession skips these messages
@@ -171,7 +241,14 @@ function registerSocketHandlers(io) {
 
     socket.on('chat:stop', ({ sessionId } = {}) => {
       const ctrl = _activeStreams.get(sessionId)
-      if (ctrl) ctrl.stopped = true
+      if (ctrl) {
+        ctrl.stopped = true
+        try { ctrl.abortController?.abort() } catch (_) {}
+      }
+      // Fire-and-forget upstream cancel — idempotent, 404-tolerant. Even if
+      // the local controller is already gone (race with `finally` above),
+      // the upstream call is safe to issue.
+      veilCancelSession(sessionId).catch(() => {})
     })
 
     // ─── VeilCLI Proxy Events ─────────────────────────────────────────────
@@ -216,9 +293,10 @@ function registerSocketHandlers(io) {
     })
 
     // Sessions
-    socket.on('veil:get-sessions', async ({ agentName } = {}, ack) => {
+    socket.on('veil:get-sessions', async ({ agentName, limit } = {}, ack) => {
       try {
-        const q = agentName ? { agent: agentName } : {}
+        const q = { limit: limit ?? 200 }
+        if (agentName) q.agentName = agentName
         ack({ sessions: await veilGet('/sessions', q) })
       } catch (err) { ack({ error: err.message }) }
     })
@@ -231,20 +309,50 @@ function registerSocketHandlers(io) {
     })
 
     socket.on('veil:get-session', async ({ id } = {}, ack) => {
-      try { ack({ session: await veilGet(`/sessions/${encodeURIComponent(id)}`) }) }
+      try {
+        const raw = await veilGet(`/sessions/${encodeURIComponent(id)}`)
+        ack({ session: raw.session ?? raw })
+      }
       catch (err) { ack({ error: err.message }) }
     })
 
+    // PR-4 item 1: per-session effective-config proxy. Reads
+    // `GET /sessions/:id/config` (audit §B) and forwards the
+    // `{ effective, overrides, agentDefaults }` envelope to the client as
+    // `{ ok: true, config }`. Used by `useVeil.getSessionConfig` to drive
+    // inheritance hints in the session-config drawer (model + thinking).
+    socket.on('veil:get-session-config', async ({ sessionId } = {}, ack) => {
+      try {
+        const raw = await veilGet(`/sessions/${encodeURIComponent(sessionId)}/config`)
+        ack({ ok: true, config: raw })
+      } catch (err) {
+        ack({ ok: false, error: err && err.message })
+      }
+    })
+
     socket.on('veil:delete-session', async ({ id } = {}, ack) => {
-      try { ack({ ok: true, result: await veilDelete(`/sessions/${encodeURIComponent(id)}`) }) }
+      try {
+        const result = await veilDelete(`/sessions/${encodeURIComponent(id)}`)
+        const oDeltas = orchestrationGraph.handleSessionDeleted(id)
+        if (oDeltas) orchestrationGraph._emitDeltas(oDeltas)
+        ack({ ok: true, result })
+      }
       catch (err) { ack({ error: err.message }) }
     })
 
-    socket.on('veil:get-session-messages', async ({ id } = {}, ack) => {
+    // PR-11: forward optional `limit` + `offset` to Veil's
+    // `GET /sessions/:id/messages?limit=N&offset=M`. Veil defaults are
+    // `limit=100, offset=0` (id ASC). `Number.isFinite(0)` is true so
+    // offset=0 round-trips correctly.
+    socket.on('veil:get-session-messages', async ({ id, limit, offset } = {}, ack) => {
       try {
+        const params = new URLSearchParams()
+        if (Number.isFinite(limit))  params.set('limit',  String(limit))
+        if (Number.isFinite(offset)) params.set('offset', String(offset))
+        const qs = params.toString()
         const [msgRes, sessionRes] = await Promise.all([
-          veilGet(`/sessions/${encodeURIComponent(id)}/messages`),
-          veilGet(`/sessions/${encodeURIComponent(id)}`).catch(() => null),
+          veilGet(`/sessions/${encodeURIComponent(id)}/messages${qs ? '?' + qs : ''}`),
+          veilGet(`/sessions/${encodeURIComponent(id)}`).then(r => r.session ?? r).catch(() => null),
         ])
         ack({
           messages: Array.isArray(msgRes) ? msgRes : (msgRes.messages ?? []),
@@ -254,11 +362,124 @@ function registerSocketHandlers(io) {
       catch (err) { ack({ error: err.message }) }
     })
 
+    socket.on('veil:patch-session', async ({ id, data } = {}, ack) => {
+      try {
+        const session = await veilPatch(`/sessions/${encodeURIComponent(id)}`, data)
+        const oDeltas = orchestrationGraph.handleSessionUpdated(id, session?.session ?? session ?? {})
+        if (oDeltas) orchestrationGraph._emitDeltas(oDeltas)
+        ack({ session })
+      }
+      catch (err) {
+        // Forward the structured Veil error envelope (code/details/phase) so
+        // client-side error-mapper can branch on it. Required for SESSION_BUSY
+        // / VALIDATION_ERROR detection on the agent-swap path.
+        ack({ error: err.message, code: err.code, details: err.details, phase: err.phase })
+      }
+    })
+
+    // Mid-session agent-swap pre-flight (Decision-4): client checks
+    // `GET /sessions/streaming` before submitting a swap to avoid hitting
+    // a 409 SESSION_BUSY race. Veil's response shape is
+    // `{ streams: [{ sessionId, agentName, startedAt }, ...] }` — we forward
+    // it under the same key for client consumption.
+    socket.on('veil:get-streaming-sessions', async (_payload = {}, ack) => {
+      try {
+        const result = await veilGet('/sessions/streaming')
+        ack({ ok: true, streams: Array.isArray(result?.streams) ? result.streams : [] })
+      }
+      catch (err) {
+        ack({ ok: false, error: err.message, code: err.code, details: err.details, phase: err.phase })
+      }
+    })
+
+    // PR-6: 4 message-edit/trim/fork/continue handlers — these were missing
+    // from PR-1..PR-5 and the four `useVeil` helpers (patchMessage,
+    // deleteMessagesAfter, deleteSessionMessage, forkSession) emitted socket
+    // events with NO server consumer. Studio's pre-PR-6 Rewind/Delete/Fork
+    // actions silently no-op'd on Veil while mutating Pinia locally — next
+    // `loadMessages` reverted them. PR-6 closes this latent silent-desync bug.
+
+    // PR-6 item 1: edit a (user) message via PATCH /sessions/:id/messages/:msgId
+    socket.on('veil:patch-message', async ({ sessionId, msgId, content } = {}, ack) => {
+      try {
+        const res = await veilPatch(
+          `/sessions/${encodeURIComponent(sessionId)}/messages/${encodeURIComponent(msgId)}`,
+          { content },
+        )
+        ack({ ok: true, message: res?.message ?? res })
+      } catch (err) {
+        ack({ error: err.message, code: err.code, details: err.details, phase: err.phase })
+      }
+    })
+
+    // PR-6 item 2: trim "from here" — DELETE /messages/after/:msgId then
+    // DELETE /messages/:msgId. Two-call chain (NOT atomic). Client surfaces
+    // any failure + force-resyncs via loadMessages (architect Q3).
+    socket.on('veil:delete-messages-after', async ({ sessionId, afterMsgId } = {}, ack) => {
+      try {
+        await veilDelete(`/sessions/${encodeURIComponent(sessionId)}/messages/after/${encodeURIComponent(afterMsgId)}`)
+        ack({ ok: true })
+      } catch (err) {
+        ack({ error: err.message, code: err.code, details: err.details, phase: err.phase })
+      }
+    })
+
+    socket.on('veil:delete-message', async ({ sessionId, msgId } = {}, ack) => {
+      try {
+        await veilDelete(`/sessions/${encodeURIComponent(sessionId)}/messages/${encodeURIComponent(msgId)}`)
+        ack({ ok: true })
+      } catch (err) {
+        ack({ error: err.message, code: err.code, details: err.details, phase: err.phase })
+      }
+    })
+
+    // PR-6 item 3: fork a session via POST /sessions/:id/fork. Body carries
+    // `upToMessageId` only when defined — Veil defaults to whole-session
+    // fork when the body is empty. Response shape per audit: `{ session }`
+    // with snake-case fields (`agent_name`, `parent_session_id`, …).
+    socket.on('veil:fork-session', async ({ sessionId, upToMessageId } = {}, ack) => {
+      try {
+        const body = (upToMessageId !== undefined && upToMessageId !== null)
+          ? { upToMessageId }
+          : {}
+        const res = await veilPost(`/sessions/${encodeURIComponent(sessionId)}/fork`, body)
+        ack({ ok: true, session: res?.session ?? res })
+      } catch (err) {
+        ack({ error: err.message, code: err.code, details: err.details, phase: err.phase })
+      }
+    })
+
+    // PR-7: forward optional { instructions, compactSize } body to Veil's
+    // POST /sessions/:id/compact endpoint. Body is omitted-when-empty so the
+    // existing zero-friction menu-item path (no body) keeps identical wire
+    // shape; the modal-driven prominent compact button populates these fields.
+    socket.on('veil:compact-session', async ({ id, instructions, compactSize } = {}, ack) => {
+      try {
+        const body = {}
+        if (typeof instructions === 'string' && instructions.trim().length > 0) {
+          body.instructions = instructions
+        }
+        if (typeof compactSize === 'number' && Number.isFinite(compactSize) && compactSize > 0) {
+          body.compactSize = compactSize
+        }
+        const session = Object.keys(body).length > 0
+          ? await veilPost(`/sessions/${encodeURIComponent(id)}/compact`, body)
+          : await veilPost(`/sessions/${encodeURIComponent(id)}/compact`)
+        ack({ session })
+      }
+      catch (err) { ack({ error: err.message }) }
+    })
+
     socket.on('veil:reset-session', async ({ id } = {}, ack) => {
       try { ack({ ok: true, result: await veilPost(`/sessions/${encodeURIComponent(id)}/reset`) }) }
       catch (err) { ack({ error: err.message }) }
     })
 
+    // Orchestration graph
+    socket.on('orchestration:get-graph', (_, ack) => {
+      if (typeof ack === 'function') ack(orchestrationGraph.getFullGraph())
+    })
+
     // Tasks
     socket.on('veil:create-task', async ({ agentName, prompt } = {}, ack) => {
       try { ack({ task: await veilPost('/tasks', { agent: agentName, prompt }) }) }
@@ -368,6 +589,20 @@ function registerSocketHandlers(io) {
       } catch (err) { ack({ error: err.message }) }
     })
 
+    socket.on('veil:get-agent-soul', async ({ name } = {}, ack) => {
+      try {
+        const fs   = require('fs')
+        const path = require('path')
+        const agentRes = await veilGet(`/agents/${encodeURIComponent(name)}`)
+        const agentData = agentRes.agent ?? agentRes
+        const folder = agentData.agentFolder
+        if (!folder) { ack({ content: '' }); return }
+        const soulPath = path.join(folder, 'SOUL.md')
+        const content = fs.existsSync(soulPath) ? fs.readFileSync(soulPath, 'utf8') : ''
+        ack({ content })
+      } catch (err) { ack({ error: err.message }) }
+    })
+
     // Settings
     socket.on('veil:get-settings', async (_, ack) => {
       try { ack({ settings: await veilGet('/settings') }) }
@@ -378,6 +613,157 @@ function registerSocketHandlers(io) {
       try { ack({ ok: true, result: await veilPut('/settings', settings) }) }
       catch (err) { ack({ error: err.message }) }
     })
+
+    // ─── Terminal ────────────────────────────────────────────────────────────
+
+    socket.on('terminal:create', ({ terminalId, cols, rows, cwd, shell } = {}, ack) => {
+      if (!terminalId) return
+
+      terminalManager.subscribe(terminalId, socket.id)
+
+      let replay = ''
+      if (terminalManager.hasPTY(terminalId)) {
+        // Live session — return replay buffer via ack so only the requesting
+        // view receives it (avoids corrupting other views of the same terminal).
+        replay = terminalManager.getReplayBuffer(terminalId)
+      } else {
+        // No live PTY (first viewer, or respawn after exit)
+        terminalManager.createPTY(terminalId, {
+          cols:  cols  ?? 80,
+          rows:  rows  ?? 24,
+          cwd:   cwd   || process.cwd(),
+          shell: shell || undefined,
+        })
+      }
+
+      if (typeof ack === 'function') ack({ replay })
+    })
+
+    socket.on('terminal:keystroke', ({ terminalId, data } = {}) => {
+      if (!terminalId || typeof data !== 'string') return
+      terminalManager.write(terminalId, data)
+    })
+
+    socket.on('terminal:resize', ({ terminalId, cols, rows } = {}) => {
+      if (!terminalId || !cols || !rows) return
+      terminalManager.resize(terminalId, cols, rows)
+    })
+
+    socket.on('terminal:destroy', ({ terminalId } = {}) => {
+      if (!terminalId) return
+      terminalManager.destroyPTY(terminalId)
+    })
+
+    socket.on('terminal:list', (_, ack) => {
+      if (typeof ack === 'function') ack({ sessions: terminalManager.listSessions() })
+    })
+
+    // ─── Terminal AI (Ctrl+I) ─────────────────────────────────────────────────
+    // Requests are scoped to the requesting socket only — never broadcast.
+
+    const _aiRequests = new Map() // `${terminalId}` → AbortController
+
+    socket.on('terminal:ai-request', async ({ terminalId, prompt, cwd, model } = {}) => {
+      if (!terminalId || !prompt || !model) {
+        socket.emit('terminal:ai-error', { terminalId, error: 'Missing terminalId, prompt, or model.' })
+        return
+      }
+
+      // Abort any existing request for this terminal
+      _aiRequests.get(terminalId)?.abort()
+
+      const ctrl = new AbortController()
+      _aiRequests.set(terminalId, ctrl)
+
+      let fullText = ''
+      try {
+        for await (const chunk of veilStreamTerminalAi(prompt, { model, cwd, signal: ctrl.signal })) {
+          fullText += chunk
+          socket.emit('terminal:ai-chunk', { terminalId, text: chunk })
+        }
+        socket.emit('terminal:ai-done', { terminalId, text: fullText.trim() })
+      } catch (err) {
+        if (err.name !== 'AbortError') {
+          socket.emit('terminal:ai-error', { terminalId, error: err.message })
+        }
+      } finally {
+        _aiRequests.delete(terminalId)
+      }
+    })
+
+    socket.on('terminal:ai-cancel', ({ terminalId } = {}) => {
+      _aiRequests.get(terminalId)?.abort()
+      _aiRequests.delete(terminalId)
+    })
+
+    // ─── Git commit message AI ────────────────────────────────────────────────
+    // Single in-flight request per socket — keyed by a fixed string.
+
+    const GIT_AI_KEY = '__git_commit__'
+    const _gitAiRequests = new Map() // GIT_AI_KEY → AbortController
+
+    socket.on('git:ai-commit-request', async ({ model } = {}) => {
+      if (!model) {
+        socket.emit('git:ai-commit-error', { error: 'No AI model configured — set one in Settings → Git.' })
+        return
+      }
+
+      // Abort any existing request
+      _gitAiRequests.get(GIT_AI_KEY)?.abort()
+
+      const ctrl = new AbortController()
+      _gitAiRequests.set(GIT_AI_KEY, ctrl)
+
+      // Fetch diff + recent commits server-side
+      const git           = require('./utils/git.js')
+      let diff            = ''
+      let diffSource      = 'staged'
+      let recentCommits   = []
+      try { diff = git.getStagedDiff() } catch { /* no diff */ }
+      if (!diff.trim()) {
+        // Nothing explicitly staged — use comprehensive diff:
+        // tracked modifications + deletions (git diff HEAD) + untracked new files
+        try { diff = git.getComprehensiveDiff(); diffSource = 'working-tree' } catch { /* no diff */ }
+      }
+      try { recentCommits = git.getLog(10) } catch { /* no log */ }
+
+      let fullText = ''
+      try {
+        for await (const chunk of veilStreamGitCommitAi(diff, recentCommits, { model, diffSource, signal: ctrl.signal })) {
+          fullText += chunk
+          socket.emit('git:ai-commit-chunk', { text: chunk })
+        }
+        socket.emit('git:ai-commit-done', { text: fullText.trim() })
+      } catch (err) {
+        if (err.name !== 'AbortError') {
+          socket.emit('git:ai-commit-error', { error: err.message })
+        }
+      } finally {
+        _gitAiRequests.delete(GIT_AI_KEY)
+      }
+    })
+
+    socket.on('git:ai-commit-cancel', () => {
+      _gitAiRequests.get(GIT_AI_KEY)?.abort()
+      _gitAiRequests.delete(GIT_AI_KEY)
+    })
+
+    // ─── Disconnect cleanup ──────────────────────────────────────────────────
+    // PTYs are NOT killed on disconnect — they keep running for reconnect recovery.
+
+    // ─── Extension connection handlers ──────────────────────────────────────
+    for (const fn of _extConnectionHandlers) {
+      try { fn(socket, io) } catch (err) { console.error('[ext socket]', err.message) }
+    }
+
+    // ─── Disconnect cleanup ──────────────────────────────────────────────────
+    socket.on('disconnect', () => {
+      terminalManager.unsubscribeSocket(socket.id)
+      for (const ctrl of _aiRequests.values()) ctrl.abort()
+      _aiRequests.clear()
+      for (const ctrl of _gitAiRequests.values()) ctrl.abort()
+      _gitAiRequests.clear()
+    })
   })
 }
 
@@ -504,4 +890,8 @@ function _createInstanceAndBroadcast(el) {
   }
 }
 
-module.exports = { registerSocketHandlers }
+// AI-dev hook: read-only accessor for the in-memory active-streams map.
+// Used by `server/routes/ai-dev/index.js` (only mounted when STUDIO_AI_DEV=1).
+function getActiveStreams() { return _activeStreams }
+
+module.exports = { registerSocketHandlers, registerExtensionConnectionHandler, getActiveStreams }

package/server/utils/board-hooks.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { EventEmitter } = require('events')
+
+/**
+ * Board mutation hooks — emitted before/after every board-state mutation.
+ *
+ * Events:
+ *   beforeElementCreate(partial)         afterElementCreate(element)
+ *   beforeElementUpdate(id, changes)     afterElementUpdate(id, updated)
+ *   beforeElementRemove(id)              afterElementRemove(id, item)
+ *   beforeElementArchive(id)             afterElementArchive(id, item)
+ *   beforeElementStateChange(id, state)  afterElementStateChange(id, state)
+ *   beforeLinkCreate(partial)            afterLinkCreate(link)
+ *   beforeLinkRemove(id)                 afterLinkRemove(id)
+ *   beforeZoneCreate(partial)            afterZoneCreate(zone)
+ *   beforeZoneUpdate(id, changes)        afterZoneUpdate(id, updated)
+ *   beforeZoneRemove(id)                 afterZoneRemove(id)
+ *   beforeViewCreate(partial)            afterViewCreate(view)
+ *   beforeViewRemove(id)                 afterViewRemove(id)
+ *   beforeShapeCreate(partial)           afterShapeCreate(shape)
+ *   beforeShapeUpdate(id, changes)       afterShapeUpdate(id, updated)
+ *   beforeShapeRemove(id)                afterShapeRemove(id)
+ *
+ * beforeX hooks can throw to cancel the mutation.
+ */
+const hooks = new EventEmitter()
+hooks.setMaxListeners(50)
+
+module.exports = hooks