chapterhouse 0.9.2 → 0.11.0

package/dist/copilot/orchestrator.js

@@ -11,7 +11,7 @@ import { config, DEFAULT_MODEL } from "../config.js";
 import { loadMcpConfig } from "./mcp-config.js";
 import { getSkillDirectories } from "./skills.js";
 import { resetClient } from "./client.js";
-import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, getTaskSessionKey, getDb, appendTaskEvent } from "../store/db.js";
+import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, deleteCopilotSession, getTaskSessionKey, getDb, appendTaskEvent } from "../store/db.js";
 import { maybeWriteEpisode } from "./episode-writer.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { resolveModel } from "./router.js";
@@ -27,14 +27,17 @@ import { detectProjectRuleWarnings } from "./project-rule-warnings.js";
 import { loadRegistry } from "../wiki/project-registry.js";
 import { loadProjectRules } from "../wiki/project-rules.js";
 import { resolveProject } from "./project-resolution.js";
+import { stopClassifier } from "./classifier.js";
 const log = childLogger("orchestrator");
 const MAX_RETRIES = 3;
-const RECONNECT_DELAYS_MS = [1_000, 3_000, 10_000];
+const RECONNECT_BASE_DELAY_MS = 1_000;
+const RECONNECT_MAX_DELAY_MS = 10_000;
 const HEALTH_CHECK_INTERVAL_MS = 30_000;
 const AGENT_REPLY_CHUNK_SIZE = 500;
 const AGENT_REPLY_CHUNK_THRESHOLD = 8 * 1024;
 const ORCHESTRATOR_SESSION_KEY = "orchestrator_session_id";
 const LAST_AUTHENTICATED_USER_KEY = "last_authenticated_user";
+let taskEventLogCleanup;
 function getWikiSummary() {
     try {
         const db = getDb();
@@ -75,14 +78,6 @@ const turnContextStorage = new AsyncLocalStorage();
 let copilotClient;
 let healthCheckTimer;
 let currentUserContext;
-/**
- * Last-seen auth context — persists after a turn completes so that callers
- * which inspect it outside of an active turn (e.g. /api/cancel) still see the
- * most recent values. Tools that run DURING a turn should use the per-turn
- * AsyncLocalStorage context for safety in concurrent-session scenarios.
- */
-let currentAuthenticatedUser;
-let currentAuthorizationHeader;
 let lastRouteResult;
 let memoryCoordinator;
 export function getLastRouteResult() {
@@ -155,7 +150,7 @@ export function getCurrentActiveProjectRules() {
     return turnContextStorage.getStore()?.activeProjectRules ?? null;
 }
 export function getCurrentAuthenticatedUser() {
-    return turnContextStorage.getStore()?.authUser ?? currentAuthenticatedUser;
+    return turnContextStorage.getStore()?.authUser;
 }
 export function getLastAuthenticatedUser() {
     const raw = getState(LAST_AUTHENTICATED_USER_KEY);
@@ -172,7 +167,7 @@ export function getLastAuthenticatedUser() {
     }
 }
 export function getCurrentAuthorizationHeader() {
-    return turnContextStorage.getStore()?.authHeader ?? currentAuthorizationHeader;
+    return turnContextStorage.getStore()?.authHeader;
 }
 // ---------------------------------------------------------------------------
 // Internal helpers
@@ -238,14 +233,9 @@ function updateUserContext(source) {
 export function invalidateOrchestratorSession(sessionKey) {
     registry?.get(sessionKey)?.invalidateSession();
 }
-function updateRequestContext(source) {
-    if (source.type !== "web" && source.type !== "sse-web") {
-        currentAuthenticatedUser = undefined;
-        currentAuthorizationHeader = undefined;
+function recordLastAuthenticatedUser(source) {
+    if (source.type !== "web" && source.type !== "sse-web")
         return;
-    }
-    currentAuthenticatedUser = source.user;
-    currentAuthorizationHeader = source.authorizationHeader?.trim() || undefined;
     if (source.user) {
         setState(LAST_AUTHENTICATED_USER_KEY, JSON.stringify(source.user));
     }
@@ -290,7 +280,7 @@ export function feedAgentResult(taskId, agentSlug, result) {
     catch (err) {
         log.warn({ err: err instanceof Error ? err.message : err, taskId, agentSlug }, "Failed to persist agent completion");
     }
-    void (async () => {
+    const ackPromise = (async () => {
         await new Promise((resolve) => setImmediate(resolve));
         const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}. The user has already seen this reply in the agent's own bubble. Acknowledge briefly without restating content.`;
         sendToOrchestrator(prompt, { type: "background", sessionKey }, (text, done) => {
@@ -299,6 +289,9 @@ export function feedAgentResult(taskId, agentSlug, result) {
             }
         }, undefined, undefined, undefined, undefined, undefined, { suppressPromptLog: true });
     })();
+    void ackPromise.catch((err) => {
+        log.error({ err, taskId, agentSlug, sessionKey }, "unhandled rejection in feedAgentResult");
+    });
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -407,6 +400,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         }
         catch (err) {
             log.warn({ sessionKey, err: err instanceof Error ? err.message : err }, "Could not resume session, creating new");
+            deleteCopilotSession(sessionKey);
             if (sessionKey === "default")
                 deleteState(ORCHESTRATOR_SESSION_KEY);
         }
@@ -443,7 +437,8 @@ export async function initOrchestrator(client) {
         resolveScopeForSession: getMemoryScopeForSession,
     });
     // Initialize per-task ring buffer — subscribes to agentEventBus for session:tool_call events.
-    initTaskEventLog();
+    taskEventLogCleanup?.();
+    taskEventLogCleanup = initTaskEventLog();
     // (Re-)create the registry — supports multiple initOrchestrator calls in tests
     if (registry) {
         await registry.shutdown();
@@ -485,16 +480,7 @@ export async function initOrchestrator(client) {
  *  Override with CHAPTERHOUSE_ORCHESTRATOR_TIMEOUT_MS env var (parsed as integer ms).
  *  Applies per-session-turn; concurrent sessions each have their own independent timeout.
  *  Part of the 3-layer timing contract — see systemd unit TimeoutStopSec comment. */
-const DEFAULT_ORCHESTRATOR_TIMEOUT_MS = 1_800_000;
-export const ORCHESTRATOR_TIMEOUT_MS = (() => {
-    const env = process.env.CHAPTERHOUSE_ORCHESTRATOR_TIMEOUT_MS;
-    if (env) {
-        const parsed = parseInt(env, 10);
-        if (!isNaN(parsed) && parsed > 0)
-            return parsed;
-    }
-    return DEFAULT_ORCHESTRATOR_TIMEOUT_MS;
-})();
+export const ORCHESTRATOR_TIMEOUT_MS = config.orchestratorTimeoutMs;
 /**
  * Execute a single queued item on its session.
  * Wraps the entire turn in AsyncLocalStorage so all tool handlers (e.g. delegate_to_agent,
@@ -512,9 +498,6 @@ async function executeOnSession(manager, item) {
     const sessionPrompt = activeProjectRules
         ? `${warningBlock}${renderActiveProjectRulesBlock(activeProjectRules.project.slug, activeProjectRules.project.path, activeProjectRules.rules.path, activeProjectRules.rules.hard, activeProjectRules.rules.soft)}\n\n${item.prompt}`
         : item.prompt;
-    // Update last-seen globals (backwards compat — for callers that inspect after a turn ends)
-    currentAuthenticatedUser = item.authUser;
-    currentAuthorizationHeader = item.authHeader;
     const runTurn = () => turnContextStorage.run({
         sessionKey,
         sourceChannel: item.sourceChannel,
@@ -532,327 +515,332 @@ async function executeOnSession(manager, item) {
         // actual spawn parameters (name, description) passed to the task() tool call.
         const spawnArgsMap = new Map();
         const toolStartDetails = new Map();
-        // Unconditional capture — must fire even when onActivity is absent so the DB handler can resolve names.
-        const unsubSpawnCapture = session.on("tool.execution_start", (event) => {
-            const data = event.data;
-            if (data.toolCallId) {
-                toolStartDetails.set(data.toolCallId, {
-                    toolName: String(data.toolName ?? "unknown"),
-                    mcpServerName: typeof data.mcpServerName === "string" ? data.mcpServerName : undefined,
-                    arguments: data.arguments,
-                });
-            }
-            if (data.toolName === "task" && data.toolCallId) {
-                const args = (data.arguments ?? {});
-                spawnArgsMap.set(data.toolCallId, {
-                    name: typeof args.name === "string" ? args.name : undefined,
-                    description: typeof args.description === "string" ? args.description : undefined,
-                    prompt: typeof args.prompt === "string"
-                        ? args.prompt
-                        : typeof args.task === "string"
-                            ? args.task
-                            : undefined,
-                });
-            }
-        });
-        const unsubToolDone = session.on("tool.execution_complete", (event) => {
-            toolCallExecuted = true;
-            toolCallCount++;
-            const data = event.data;
-            const result = data.result;
-            const resultPreview = typeof result?.content === "string" ? result.content.slice(0, 400) : undefined;
-            const detailedContent = typeof result?.detailedContent === "string"
-                ? result.detailedContent
-                : typeof result?.content === "string"
-                    ? result.content
-                    : undefined;
-            const toolCallId = String(data.toolCallId ?? "");
-            const startDetails = toolStartDetails.get(toolCallId);
-            const completionToolName = data.toolName;
-            if (item.onActivity) {
-                item.onActivity({
-                    kind: "tool_complete",
-                    toolCallId: data.toolCallId,
-                    success: data.success,
-                    resultPreview,
-                    detailedContent,
-                }, item.turnId);
-            }
-            // Emit turn:delta with tool-call part (coexistence — #130)
-            const toolPart = {
-                type: "tool-call",
-                toolCallId,
-                toolName: typeof completionToolName === "string" && completionToolName.length > 0
-                    ? completionToolName
-                    : (startDetails?.toolName ?? "unknown"),
-                mcpServerName: startDetails?.mcpServerName,
-                arguments: startDetails?.arguments,
-                status: data.success !== false ? "done" : "failed",
-                resultPreview,
-                detailedContent,
-            };
-            emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: toolPart });
-            if (toolCallId) {
-                toolStartDetails.delete(toolCallId);
-            }
-        });
-        const unsubToolStart = item.onActivity
-            ? session.on("tool.execution_start", (event) => {
-                const data = event.data;
-                item.onActivity({
-                    kind: "tool_start",
-                    toolCallId: data.toolCallId,
-                    toolName: data.toolName,
-                    mcpServerName: data.mcpServerName,
-                    arguments: data.arguments,
-                }, item.turnId);
-            })
-            : () => { };
-        const unsubReasoning = item.onActivity
-            ? session.on("assistant.reasoning_delta", (event) => {
-                item.onActivity({
-                    kind: "thinking_delta",
-                    reasoningId: event.data.reasoningId,
-                    deltaContent: event.data.deltaContent,
-                }, item.turnId);
-            })
-            : () => { };
-        const unsubSubStart = item.onActivity
-            ? session.on("subagent.started", (event) => {
-                const data = event.data;
-                const spawnArgs = spawnArgsMap.get(data.toolCallId);
-                const agentSlug = (typeof spawnArgs?.name === "string" ? spawnArgs.name : (data.agentName || "unknown"))
-                    .toLowerCase()
-                    .replace(/\s+/g, "-");
-                const resolvedDescription = (typeof spawnArgs?.description === "string"
-                    ? spawnArgs.description
-                    : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
-                item.onActivity({
-                    kind: "subagent_started",
-                    toolCallId: data.toolCallId,
-                    agentName: data.agentName,
-                    agentDisplayName: data.agentDisplayName,
-                    agentDescription: resolvedDescription,
-                    agentSlug,
-                }, item.turnId);
-            })
-            : () => { };
-        const unsubSubDone = item.onActivity
-            ? session.on("subagent.completed", (event) => {
-                const data = event.data;
-                item.onActivity({
-                    kind: "subagent_completed",
-                    toolCallId: data.toolCallId,
-                    agentName: data.agentName,
-                    agentDisplayName: data.agentDisplayName,
-                    durationMs: data.durationMs,
-                }, item.turnId);
-            })
-            : () => { };
-        const unsubSubFail = item.onActivity
-            ? session.on("subagent.failed", (event) => {
-                const data = event.data;
-                item.onActivity({
-                    kind: "subagent_failed",
-                    toolCallId: data.toolCallId,
-                    agentName: data.agentName,
-                    agentDisplayName: data.agentDisplayName,
-                    error: data.error,
-                }, item.turnId);
-            })
-            : () => { };
-        // Always persist SDK subagent dispatches to agent_tasks so Workers tab shows them.
-        // Also emit turn events unconditionally alongside existing callback path (#130).
-        const unsubTurnToolStart = session.on("tool.execution_start", (event) => {
-            const data = event.data;
-            // Skip nested subagent tool calls (handled via subagent.started/completed)
-            const part = {
-                type: "tool-call",
-                toolCallId: String(data.toolCallId ?? ""),
-                toolName: String(data.toolName ?? "unknown"),
-                mcpServerName: typeof data.mcpServerName === "string" ? data.mcpServerName : undefined,
-                arguments: data.arguments,
-                status: "running",
-            };
-            emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part });
-        });
-        const unsubTurnReasoning = session.on("assistant.reasoning_delta", (event) => {
-            const part = {
-                type: "thinking",
-                reasoningId: event.data.reasoningId,
-                text: event.data.deltaContent,
-                active: true,
-            };
-            emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part });
-        });
         const db = getDb();
         // Set of task IDs for subagents spawned in THIS turn — used to filter nested tool events.
         const activeSubagentTaskIds = new Set();
-        const unsubSubStartDb = session.on("subagent.started", (event) => {
-            try {
+        let unsubSpawnCapture = () => { };
+        let unsubToolDone = () => { };
+        let unsubToolStart = () => { };
+        let unsubReasoning = () => { };
+        let unsubSubStart = () => { };
+        let unsubSubDone = () => { };
+        let unsubSubFail = () => { };
+        let unsubTurnToolStart = () => { };
+        let unsubTurnReasoning = () => { };
+        let unsubSubStartDb = () => { };
+        let unsubSubDoneDb = () => { };
+        let unsubSubFailDb = () => { };
+        let unsubNestedToolStart = () => { };
+        let unsubNestedToolDone = () => { };
+        let unsubDelta = () => { };
+        try {
+            // Unconditional capture — must fire even when onActivity is absent so the DB handler can resolve names.
+            unsubSpawnCapture = session.on("tool.execution_start", (event) => {
                 const data = event.data;
-                const spawnArgs = spawnArgsMap.get(data.toolCallId);
-                const agentSlug = (typeof spawnArgs?.name === "string" ? spawnArgs.name : (data.agentName || "unknown"))
-                    .toLowerCase()
-                    .replace(/\s+/g, "-");
-                const description = (typeof spawnArgs?.description === "string"
-                    ? spawnArgs.description
-                    : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
-                const prompt = typeof spawnArgs?.prompt === "string" ? spawnArgs.prompt : null;
-                db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
-             VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(data.toolCallId, agentSlug, description, prompt, item.sourceChannel || null, sessionKey);
-                if (prompt) {
-                    db.prepare(`UPDATE agent_tasks SET prompt = COALESCE(prompt, ?) WHERE task_id = ?`).run(prompt, data.toolCallId);
+                if (data.toolCallId) {
+                    toolStartDetails.set(data.toolCallId, {
+                        toolName: String(data.toolName ?? "unknown"),
+                        mcpServerName: typeof data.mcpServerName === "string" ? data.mcpServerName : undefined,
+                        arguments: data.arguments,
+                    });
                 }
-                activeSubagentTaskIds.add(data.toolCallId);
-                void agentEventBus.emit({
-                    type: "session:created",
-                    sessionId: data.toolCallId,
-                    agentName: agentSlug,
-                    payload: { agentName: agentSlug, priority: "normal" },
-                    timestamp: new Date(),
-                });
-                // Emit turn:delta with subagent part (coexistence — #130)
-                const subPart = {
-                    type: "subagent",
-                    toolCallId: String(data.toolCallId ?? ""),
-                    agentName: data.agentName ?? agentSlug,
-                    agentDisplayName: data.agentDisplayName ?? agentSlug,
-                    agentDescription: description,
-                    agentSlug,
-                    status: "running",
-                };
-                emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: subPart });
-            }
-            catch { /* non-fatal */ }
-        });
-        const unsubSubDoneDb = session.on("subagent.completed", (event) => {
-            try {
-                const doneData = event.data;
-                const taskId = String(doneData.toolCallId ?? "");
-                const finalResult = typeof doneData.result?.detailedContent === "string"
-                    ? doneData.result.detailedContent
-                    : typeof doneData.result?.content === "string"
-                        ? doneData.result.content
-                        : null;
-                spawnArgsMap.delete(taskId);
-                activeSubagentTaskIds.delete(taskId);
-                db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(finalResult?.slice(0, 10000) ?? null, taskId);
-                if (finalResult) {
-                    void memoryCoordinator?.onAgentTaskComplete(taskId, finalResult).catch((error) => {
-                        log.error({ err: error, taskId }, "memory.eot.error");
+                if (data.toolName === "task" && data.toolCallId) {
+                    const args = (data.arguments ?? {});
+                    spawnArgsMap.set(data.toolCallId, {
+                        name: typeof args.name === "string" ? args.name : undefined,
+                        description: typeof args.description === "string" ? args.description : undefined,
+                        prompt: typeof args.prompt === "string"
+                            ? args.prompt
+                            : typeof args.task === "string"
+                                ? args.task
+                                : undefined,
                     });
                 }
-                const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(taskId);
-                void agentEventBus.emit({
-                    type: "session:destroyed",
-                    sessionId: taskId,
-                    agentName: taskRow?.agent_slug,
-                    payload: { agentName: taskRow?.agent_slug ?? "", reason: "complete" },
-                    timestamp: new Date(),
-                });
-                // Emit turn:delta with subagent completed part (coexistence — #130)
-                const donePart = {
-                    type: "subagent",
-                    toolCallId: String(doneData.toolCallId ?? ""),
-                    agentName: doneData.agentName ?? taskRow?.agent_slug ?? "agent",
-                    agentDisplayName: doneData.agentDisplayName ?? taskRow?.agent_slug ?? "agent",
-                    status: "done",
-                    durationMs: typeof doneData.durationMs === "number" ? doneData.durationMs : undefined,
+            });
+            unsubToolDone = session.on("tool.execution_complete", (event) => {
+                toolCallExecuted = true;
+                toolCallCount++;
+                const data = event.data;
+                const result = data.result;
+                const resultPreview = typeof result?.content === "string" ? result.content.slice(0, 400) : undefined;
+                const detailedContent = typeof result?.detailedContent === "string"
+                    ? result.detailedContent
+                    : typeof result?.content === "string"
+                        ? result.content
+                        : undefined;
+                const toolCallId = String(data.toolCallId ?? "");
+                const startDetails = toolStartDetails.get(toolCallId);
+                const completionToolName = data.toolName;
+                if (item.onActivity) {
+                    item.onActivity({
+                        kind: "tool_complete",
+                        toolCallId: data.toolCallId,
+                        success: data.success,
+                        resultPreview,
+                        detailedContent,
+                    }, item.turnId);
+                }
+                const toolPart = {
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: typeof completionToolName === "string" && completionToolName.length > 0
+                        ? completionToolName
+                        : (startDetails?.toolName ?? "unknown"),
+                    mcpServerName: startDetails?.mcpServerName,
+                    arguments: startDetails?.arguments,
+                    status: data.success !== false ? "done" : "failed",
+                    resultPreview,
+                    detailedContent,
                 };
-                emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: donePart });
-            }
-            catch { /* non-fatal */ }
-        });
-        const unsubSubFailDb = session.on("subagent.failed", (event) => {
-            try {
+                emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: toolPart });
+                if (toolCallId) {
+                    toolStartDetails.delete(toolCallId);
+                }
+            });
+            unsubToolStart = item.onActivity
+                ? session.on("tool.execution_start", (event) => {
+                    const data = event.data;
+                    item.onActivity({
+                        kind: "tool_start",
+                        toolCallId: data.toolCallId,
+                        toolName: data.toolName,
+                        mcpServerName: data.mcpServerName,
+                        arguments: data.arguments,
+                    }, item.turnId);
+                })
+                : () => { };
+            unsubReasoning = item.onActivity
+                ? session.on("assistant.reasoning_delta", (event) => {
+                    item.onActivity({
+                        kind: "thinking_delta",
+                        reasoningId: event.data.reasoningId,
+                        deltaContent: event.data.deltaContent,
+                    }, item.turnId);
+                })
+                : () => { };
+            unsubSubStart = item.onActivity
+                ? session.on("subagent.started", (event) => {
+                    const data = event.data;
+                    const spawnArgs = spawnArgsMap.get(data.toolCallId);
+                    const agentSlug = (typeof spawnArgs?.name === "string" ? spawnArgs.name : (data.agentName || "unknown"))
+                        .toLowerCase()
+                        .replace(/\s+/g, "-");
+                    const resolvedDescription = (typeof spawnArgs?.description === "string"
+                        ? spawnArgs.description
+                        : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
+                    item.onActivity({
+                        kind: "subagent_started",
+                        toolCallId: data.toolCallId,
+                        agentName: data.agentName,
+                        agentDisplayName: data.agentDisplayName,
+                        agentDescription: resolvedDescription,
+                        agentSlug,
+                    }, item.turnId);
+                })
+                : () => { };
+            unsubSubDone = item.onActivity
+                ? session.on("subagent.completed", (event) => {
+                    const data = event.data;
+                    item.onActivity({
+                        kind: "subagent_completed",
+                        toolCallId: data.toolCallId,
+                        agentName: data.agentName,
+                        agentDisplayName: data.agentDisplayName,
+                        durationMs: data.durationMs,
+                    }, item.turnId);
+                })
+                : () => { };
+            unsubSubFail = item.onActivity
+                ? session.on("subagent.failed", (event) => {
+                    const data = event.data;
+                    item.onActivity({
+                        kind: "subagent_failed",
+                        toolCallId: data.toolCallId,
+                        agentName: data.agentName,
+                        agentDisplayName: data.agentDisplayName,
+                        error: data.error,
+                    }, item.turnId);
+                })
+                : () => { };
+            unsubTurnToolStart = session.on("tool.execution_start", (event) => {
                 const data = event.data;
-                spawnArgsMap.delete(data.toolCallId);
-                activeSubagentTaskIds.delete(data.toolCallId);
-                db.prepare(`UPDATE agent_tasks SET status = 'error', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(data.error || "Subagent failed", data.toolCallId);
-                const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(data.toolCallId);
-                void agentEventBus.emit({
-                    type: "session:error",
-                    sessionId: data.toolCallId,
-                    agentName: taskRow?.agent_slug,
-                    payload: { agentName: taskRow?.agent_slug ?? "", error: data.error ?? "Subagent failed" },
-                    timestamp: new Date(),
-                });
-                // Emit turn:delta with subagent failed part (coexistence — #130)
-                const failPart = {
-                    type: "subagent",
+                const part = {
+                    type: "tool-call",
                     toolCallId: String(data.toolCallId ?? ""),
-                    agentName: data.agentName ?? taskRow?.agent_slug ?? "agent",
-                    agentDisplayName: data.agentDisplayName ?? taskRow?.agent_slug ?? "agent",
-                    status: "failed",
-                    error: data.error,
+                    toolName: String(data.toolName ?? "unknown"),
+                    mcpServerName: typeof data.mcpServerName === "string" ? data.mcpServerName : undefined,
+                    arguments: data.arguments,
+                    status: "running",
                 };
-                emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: failPart });
-            }
-            catch { /* non-fatal */ }
-        });
-        // ---------------------------------------------------------------------------
-        // Nested tool-call streaming — capture tool.execution_start / _complete events
-        // whose parentToolCallId matches a known subagent task id, persist them to
-        // agent_task_events, and broadcast to per-task SSE subscribers.
-        // ---------------------------------------------------------------------------
-        const unsubNestedToolStart = session.on("tool.execution_start", (event) => {
-            try {
-                const data = event.data;
-                const parentId = data.parentToolCallId;
-                if (!parentId || !activeSubagentTaskIds.has(parentId))
-                    return;
-                const toolName = data.toolName ?? null;
-                const args = data.arguments ?? {};
-                let summary = null;
-                if (typeof args.command === "string")
-                    summary = args.command.slice(0, 120);
-                else if (typeof args.path === "string")
-                    summary = args.path.slice(0, 120);
-                else if (typeof args.query === "string")
-                    summary = args.query.slice(0, 120);
-                else if (typeof args.prompt === "string")
-                    summary = args.prompt.slice(0, 120);
-                const ev = appendTaskEvent(parentId, "tool_start", toolName, summary);
-                if (ev)
-                    emitTaskEvent(parentId, ev);
-            }
-            catch { /* non-fatal */ }
-        });
-        const unsubNestedToolDone = session.on("tool.execution_complete", (event) => {
-            try {
-                const data = event.data;
-                const parentId = data.parentToolCallId;
-                if (!parentId || !activeSubagentTaskIds.has(parentId))
-                    return;
-                const success = data.success !== false;
-                const resultContent = data.result?.content ?? data.result?.detailedContent;
-                const summary = typeof resultContent === "string"
-                    ? (success ? resultContent.slice(0, 120) : `error: ${resultContent.slice(0, 100)}`)
-                    : (success ? "ok" : "error");
-                const ev = appendTaskEvent(parentId, "tool_complete", null, summary);
-                if (ev)
-                    emitTaskEvent(parentId, ev);
-            }
-            catch { /* non-fatal */ }
-        });
-        const unsubDelta = session.on("assistant.message_delta", (event) => {
-            if (toolCallExecuted && accumulated.length > 0 && !accumulated.endsWith("\n")) {
-                accumulated += "\n";
-            }
-            toolCallExecuted = false;
-            const delta = event.data.deltaContent;
-            accumulated += delta;
-            item.callback(accumulated, false, item.turnId);
-            // Emit alongside existing callback path (coexistence — #130)
-            emitTurnEvent(sessionKey, {
-                type: "turn:delta",
-                turnId: item.turnId,
-                sessionKey,
-                part: { type: "text", text: delta },
+                emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part });
+            });
+            unsubTurnReasoning = session.on("assistant.reasoning_delta", (event) => {
+                const part = {
+                    type: "thinking",
+                    reasoningId: event.data.reasoningId,
+                    text: event.data.deltaContent,
+                    active: true,
+                };
+                emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part });
+            });
+            unsubSubStartDb = session.on("subagent.started", (event) => {
+                try {
+                    const data = event.data;
+                    const spawnArgs = spawnArgsMap.get(data.toolCallId);
+                    const agentSlug = (typeof spawnArgs?.name === "string" ? spawnArgs.name : (data.agentName || "unknown"))
+                        .toLowerCase()
+                        .replace(/\s+/g, "-");
+                    const description = (typeof spawnArgs?.description === "string"
+                        ? spawnArgs.description
+                        : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
+                    const prompt = typeof spawnArgs?.prompt === "string" ? spawnArgs.prompt : null;
+                    db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
+               VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(data.toolCallId, agentSlug, description, prompt, item.sourceChannel || null, sessionKey);
+                    if (prompt) {
+                        db.prepare(`UPDATE agent_tasks SET prompt = COALESCE(prompt, ?) WHERE task_id = ?`).run(prompt, data.toolCallId);
+                    }
+                    activeSubagentTaskIds.add(data.toolCallId);
+                    void agentEventBus.emit({
+                        type: "session:created",
+                        sessionId: data.toolCallId,
+                        agentName: agentSlug,
+                        payload: { agentName: agentSlug, priority: "normal" },
+                        timestamp: new Date(),
+                    });
+                    const subPart = {
+                        type: "subagent",
+                        toolCallId: String(data.toolCallId ?? ""),
+                        agentName: data.agentName ?? agentSlug,
+                        agentDisplayName: data.agentDisplayName ?? agentSlug,
+                        agentDescription: description,
+                        agentSlug,
+                        status: "running",
+                    };
+                    emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: subPart });
+                }
+                catch { /* non-fatal */ }
+            });
+            unsubSubDoneDb = session.on("subagent.completed", (event) => {
+                try {
+                    const doneData = event.data;
+                    const taskId = String(doneData.toolCallId ?? "");
+                    const finalResult = typeof doneData.result?.detailedContent === "string"
+                        ? doneData.result.detailedContent
+                        : typeof doneData.result?.content === "string"
+                            ? doneData.result.content
+                            : null;
+                    spawnArgsMap.delete(taskId);
+                    activeSubagentTaskIds.delete(taskId);
+                    if (finalResult && finalResult.length > 10_000) {
+                        log.warn({ taskId, length: finalResult.length, limit: 10_000 }, "subagent result truncated before persistence");
+                    }
+                    db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(finalResult?.slice(0, 10000) ?? null, taskId);
+                    if (finalResult) {
+                        void memoryCoordinator?.onAgentTaskComplete(taskId, finalResult).catch((error) => {
+                            log.error({ err: error, taskId }, "memory.eot.error");
+                        });
+                    }
+                    const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(taskId);
+                    void agentEventBus.emit({
+                        type: "session:destroyed",
+                        sessionId: taskId,
+                        agentName: taskRow?.agent_slug,
+                        payload: { agentName: taskRow?.agent_slug ?? "", reason: "complete" },
+                        timestamp: new Date(),
+                    });
+                    const donePart = {
+                        type: "subagent",
+                        toolCallId: String(doneData.toolCallId ?? ""),
+                        agentName: doneData.agentName ?? taskRow?.agent_slug ?? "agent",
+                        agentDisplayName: doneData.agentDisplayName ?? taskRow?.agent_slug ?? "agent",
+                        status: "done",
+                        durationMs: typeof doneData.durationMs === "number" ? doneData.durationMs : undefined,
+                    };
+                    emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: donePart });
+                }
+                catch { /* non-fatal */ }
+            });
+            unsubSubFailDb = session.on("subagent.failed", (event) => {
+                try {
+                    const data = event.data;
+                    spawnArgsMap.delete(data.toolCallId);
+                    activeSubagentTaskIds.delete(data.toolCallId);
+                    db.prepare(`UPDATE agent_tasks SET status = 'error', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(data.error || "Subagent failed", data.toolCallId);
+                    const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(data.toolCallId);
+                    void agentEventBus.emit({
+                        type: "session:error",
+                        sessionId: data.toolCallId,
+                        agentName: taskRow?.agent_slug,
+                        payload: { agentName: taskRow?.agent_slug ?? "", error: data.error ?? "Subagent failed" },
+                        timestamp: new Date(),
+                    });
+                    const failPart = {
+                        type: "subagent",
+                        toolCallId: String(data.toolCallId ?? ""),
+                        agentName: data.agentName ?? taskRow?.agent_slug ?? "agent",
+                        agentDisplayName: data.agentDisplayName ?? taskRow?.agent_slug ?? "agent",
+                        status: "failed",
+                        error: data.error,
+                    };
+                    emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: failPart });
+                }
+                catch { /* non-fatal */ }
+            });
+            unsubNestedToolStart = session.on("tool.execution_start", (event) => {
+                try {
+                    const data = event.data;
+                    const parentId = data.parentToolCallId;
+                    if (!parentId || !activeSubagentTaskIds.has(parentId))
+                        return;
+                    const toolName = data.toolName ?? null;
+                    const args = data.arguments ?? {};
+                    let summary = null;
+                    if (typeof args.command === "string")
+                        summary = args.command.slice(0, 120);
+                    else if (typeof args.path === "string")
+                        summary = args.path.slice(0, 120);
+                    else if (typeof args.query === "string")
+                        summary = args.query.slice(0, 120);
+                    else if (typeof args.prompt === "string")
+                        summary = args.prompt.slice(0, 120);
+                    const ev = appendTaskEvent(parentId, "tool_start", toolName, summary);
+                    if (ev)
+                        emitTaskEvent(parentId, ev);
+                }
+                catch { /* non-fatal */ }
+            });
+            unsubNestedToolDone = session.on("tool.execution_complete", (event) => {
+                try {
+                    const data = event.data;
+                    const parentId = data.parentToolCallId;
+                    if (!parentId || !activeSubagentTaskIds.has(parentId))
+                        return;
+                    const success = data.success !== false;
+                    const resultContent = data.result?.content ?? data.result?.detailedContent;
+                    const summary = typeof resultContent === "string"
+                        ? (success ? resultContent.slice(0, 120) : `error: ${resultContent.slice(0, 100)}`)
+                        : (success ? "ok" : "error");
+                    const ev = appendTaskEvent(parentId, "tool_complete", null, summary);
+                    if (ev)
+                        emitTaskEvent(parentId, ev);
+                }
+                catch { /* non-fatal */ }
+            });
+            unsubDelta = session.on("assistant.message_delta", (event) => {
+                if (toolCallExecuted && accumulated.length > 0 && !accumulated.endsWith("\n")) {
+                    accumulated += "\n";
+                }
+                toolCallExecuted = false;
+                const delta = event.data.deltaContent;
+                accumulated += delta;
+                item.callback(accumulated, false, item.turnId);
+                emitTurnEvent(sessionKey, {
+                    type: "turn:delta",
+                    turnId: item.turnId,
+                    sessionKey,
+                    part: { type: "text", text: delta },
+                });
             });
-        });
-        try {
             if (warningBlock) {
                 accumulated = warningBlock;
                 item.callback(accumulated, false, item.turnId);
@@ -1008,9 +996,12 @@ function isRecoverableError(err) {
         return false;
     return /disconnect|connection|EPIPE|ECONNRESET|ECONNREFUSED|socket|closed|ENOENT|spawn|not found|expired|stale/i.test(msg);
 }
-export async function sendToOrchestrator(prompt, source, callback, attachments, onActivity, onQueued, onAdvance, externalTurnId, options) {
+function reconnectDelayMs(attempt) {
+    return Math.min(RECONNECT_BASE_DELAY_MS * (2 ** attempt), RECONNECT_MAX_DELAY_MS);
+}
+export function sendToOrchestrator(prompt, source, callback, attachments, onActivity, onQueued, onAdvance, externalTurnId, options) {
     updateUserContext(source);
-    updateRequestContext(source);
+    recordLastAuthenticatedUser(source);
     // Use the externally-supplied turnId if provided (POST→SSE path needs the ID
     // returned to the client to match every emitted event — Fix 1 root cause).
     const turnId = externalTurnId ?? randomUUID();
@@ -1040,13 +1031,16 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
     const authUser = (source.type === "web" || source.type === "sse-web") ? source.user : undefined;
     const authHeader = (source.type === "web" || source.type === "sse-web") ? source.authorizationHeader?.trim() || undefined : undefined;
     const emitSessionLifecycle = usesSessionTurnLifecycle(source);
+    const manager = registry?.getOrCreate(sessionKey);
     if (emitSessionLifecycle) {
         emitTurnEvent(sessionKey, { type: "turn:started", turnId, sessionKey, prompt, attachments });
     }
-    const manager = registry.getOrCreate(sessionKey);
-    void (async () => {
+    const sendPromise = (async () => {
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
             try {
+                if (!manager) {
+                    throw new Error("Orchestrator is not initialized");
+                }
                 const finalContent = await new Promise((resolve, reject) => {
                     manager.enqueue({
                         prompt: taggedPrompt,
@@ -1106,7 +1100,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     return;
                 }
                 if (isRecoverableError(err) && attempt < MAX_RETRIES) {
-                    const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
+                    const delay = reconnectDelayMs(attempt);
                     log.warn({ msg, attempt: attempt + 1, maxRetries: MAX_RETRIES, delayMs: delay }, "Recoverable error, retrying");
                     await sleep(delay);
                     try {
@@ -1124,6 +1118,10 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
             }
         }
     })();
+    void sendPromise.catch((err) => {
+        log.error({ err, sessionKey, turnId }, "unhandled rejection in sendToOrchestrator");
+    });
+    return Promise.resolve();
 }
 /**
  * Abort the active turn on `sessionKey` and immediately start a new turn with `newPrompt`.
@@ -1144,8 +1142,9 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
         return sendToOrchestrator(newPrompt, source, callback, attachments, onActivity, undefined, undefined, externalTurnId);
     }
     updateUserContext(source);
-    updateRequestContext(source);
+    recordLastAuthenticatedUser(source);
     const turnId = externalTurnId ?? randomUUID();
+    const abortedTurnId = manager.currentTurnId;
     const sourceLabel = source.type === "background" ? "background" : "web";
     const sourceChannel = source.type === "web" ? "web" : undefined;
     const authUser = (source.type === "web" || source.type === "sse-web") ? source.user : undefined;
@@ -1158,7 +1157,7 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
     manager.cancelQueued();
     // Enqueue the replacement BEFORE awaiting abort. When sendAndWait resolves on
     // abort, the drain loop immediately finds the replacement in the queue — zero gap.
-    void (async () => {
+    const interruptPromise = (async () => {
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
             try {
                 const finalContent = await new Promise((resolve, reject) => {
@@ -1170,7 +1169,7 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                         onActivity: onActivity,
                         turnId,
                         isInterrupt: true,
-                        onInterrupted,
+                        onInterrupted: undefined,
                         sourceChannel,
                         sessionKey,
                         authUser,
@@ -1207,7 +1206,7 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                 if (/cancelled|abort/i.test(msg))
                     return;
                 if (isRecoverableError(err) && attempt < MAX_RETRIES) {
-                    const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
+                    const delay = reconnectDelayMs(attempt);
                     log.warn({ msg, attempt: attempt + 1, maxRetries: MAX_RETRIES, delayMs: delay }, "Recoverable error on interrupt turn, retrying");
                     await sleep(delay);
                     try {
@@ -1222,6 +1221,12 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
             }
         }
     })();
+    void interruptPromise.catch((err) => {
+        log.error({ err, sessionKey, turnId }, "unhandled rejection in interruptCurrentTurn");
+    });
+    if (abortedTurnId) {
+        onInterrupted?.(abortedTurnId);
+    }
     // Abort the in-flight turn AFTER enqueueing the replacement — SDK sends the
     // abort RPC; server emits session.idle; sendAndWait resolves; drain loop picks
     // up the replacement immediately.
@@ -1364,6 +1369,7 @@ export function getAgentInfo() {
 }
 /** Clean up on shutdown/restart. */
 export async function shutdownAgents() {
+    stopClassifier();
     memoryCoordinator?.shutdown();
     memoryCoordinator = undefined;
     if (!registry) {