chapterhouse 0.1.1

package/dist/copilot/orchestrator.js

@@ -0,0 +1,685 @@
+import { approveAll } from "@github/copilot-sdk";
+import { createTools } from "./tools.js";
+import { getOrchestratorSystemMessage } from "./system-message.js";
+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 } from "../store/db.js";
+import { maybeWriteEpisode } from "./episode-writer.js";
+import { getWikiSummary } from "../wiki/context.js";
+import { SESSIONS_DIR } from "../paths.js";
+import { resolveModel } from "./router.js";
+import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, } from "./agents.js";
+import { normalizeProjectPath, setChannelProject } from "../squad/context.js";
+import { getSquadCoordinatorSystemMessage } from "../squad/charter.js";
+/**
+ * Permission handler for the orchestrator session.
+ * Approves all tool requests so @chapterhouse has full access to all tools.
+ */
+const orchestratorPermissionHandler = approveAll;
+const MAX_RETRIES = 3;
+const RECONNECT_DELAYS_MS = [1_000, 3_000, 10_000];
+const HEALTH_CHECK_INTERVAL_MS = 30_000;
+const ORCHESTRATOR_SESSION_KEY = "orchestrator_session_id";
+const LAST_AUTHENTICATED_USER_KEY = "last_authenticated_user";
+let logMessage = () => { };
+export function setMessageLogger(fn) {
+    logMessage = fn;
+}
+let proactiveNotifyFn;
+export function setProactiveNotify(fn) {
+    proactiveNotifyFn = fn;
+}
+let copilotClient;
+let healthCheckTimer;
+let currentUserContext;
+let currentAuthenticatedUser;
+let currentAuthorizationHeader;
+// Router state
+let recentTiers = [];
+let lastRouteResult;
+export function getLastRouteResult() {
+    return lastRouteResult;
+}
+// Session map — one entry per session key ("default" or "project:{normalizedRoot}")
+const sessionMap = new Map();
+const sessionModelMap = new Map();
+const sessionCreatePromises = new Map();
+// Track which session key the currently-executing turn belongs to (for abort + task routing)
+let currentProcessingSessionKey;
+export function getCurrentSessionKey() {
+    return currentProcessingSessionKey ?? "default";
+}
+const messageQueue = [];
+let processing = false;
+let currentCallback;
+/** The channel currently being processed — tools use this to tag new workers. */
+let currentSourceChannel;
+/** Get the channel that originated the message currently being processed. */
+export function getCurrentSourceChannel() {
+    return currentSourceChannel;
+}
+let currentChannelKey;
+export function getCurrentChannelKey() {
+    return currentChannelKey;
+}
+/**
+ * The activity callback for the message currently being processed. Tool handlers
+ * (notably `delegate_to_agent`) read this to forward child-session events back
+ * to the parent's SSE connection.
+ */
+let currentActivityCallback;
+export function getCurrentActivityCallback() {
+    return currentActivityCallback;
+}
+export function getCurrentAuthenticatedUser() {
+    return currentAuthenticatedUser;
+}
+export function getLastAuthenticatedUser() {
+    const raw = getState(LAST_AUTHENTICATED_USER_KEY);
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed?.id || !parsed?.name || !parsed?.email || !parsed?.role) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function getCurrentAuthorizationHeader() {
+    return currentAuthorizationHeader;
+}
+function getSessionConfig() {
+    const tools = createTools({
+        client: copilotClient,
+        onAgentTaskComplete: feedAgentResult,
+    });
+    const mcpServers = loadMcpConfig();
+    const skillDirectories = getSkillDirectories();
+    return { tools, mcpServers, skillDirectories };
+}
+function getSystemMessageOptions(memorySummary, projectRoot) {
+    return {
+        selfEditEnabled: config.selfEditEnabled,
+        memorySummary: memorySummary || undefined,
+        agentRoster: buildAgentRoster(projectRoot),
+        userContext: currentUserContext,
+    };
+}
+function sameUserContext(a, b) {
+    return a?.name === b?.name && a?.role === b?.role;
+}
+function updateUserContext(source) {
+    if (source.type !== "web") {
+        return;
+    }
+    const nextContext = source.user
+        ? { name: source.user.name, role: source.user.role }
+        : undefined;
+    if (sameUserContext(currentUserContext, nextContext)) {
+        return;
+    }
+    currentUserContext = nextContext;
+    sessionMap.delete("default");
+}
+function updateRequestContext(source) {
+    if (source.type !== "web") {
+        currentAuthenticatedUser = undefined;
+        currentAuthorizationHeader = undefined;
+        return;
+    }
+    currentAuthenticatedUser = source.user;
+    currentAuthorizationHeader = source.authorizationHeader?.trim() || undefined;
+    if (source.user) {
+        setState(LAST_AUTHENTICATED_USER_KEY, JSON.stringify(source.user));
+    }
+}
+/** Feed an agent task result into the orchestrator as a new turn. */
+export function feedAgentResult(taskId, agentSlug, result) {
+    const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}:\n\n${result}`;
+    const sessionKey = getTaskSessionKey(taskId);
+    sendToOrchestrator(prompt, { type: "background", sessionKey }, (text, done) => {
+        if (done && proactiveNotifyFn) {
+            proactiveNotifyFn(text);
+        }
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Ensure the SDK client is connected, resetting if necessary. Coalesces concurrent resets. */
+let resetPromise;
+async function ensureClient() {
+    if (copilotClient && copilotClient.getState() === "connected") {
+        return copilotClient;
+    }
+    if (!resetPromise) {
+        console.log(`[chapterhouse] Client not connected (state: ${copilotClient?.getState() ?? "null"}), resetting…`);
+        resetPromise = resetClient().then((c) => {
+            console.log(`[chapterhouse] Client reset successful, state: ${c.getState()}`);
+            copilotClient = c;
+            return c;
+        }).finally(() => { resetPromise = undefined; });
+    }
+    return resetPromise;
+}
+/** Start periodic health check that proactively reconnects the client. */
+function startHealthCheck() {
+    if (healthCheckTimer)
+        return;
+    healthCheckTimer = setInterval(async () => {
+        if (!copilotClient)
+            return;
+        try {
+            const state = copilotClient.getState();
+            if (state !== "connected") {
+                console.log(`[chapterhouse] Health check: client state is '${state}', resetting…`);
+                await ensureClient();
+                // Session may need recovery after client reset
+                sessionMap.clear();
+                sessionModelMap.clear();
+            }
+        }
+        catch (err) {
+            console.error(`[chapterhouse] Health check error:`, err instanceof Error ? err.message : err);
+        }
+    }, HEALTH_CHECK_INTERVAL_MS);
+}
+/** Ensure a session exists for the given key, creating/resuming as needed. Concurrency-safe. */
+async function ensureOrchestratorSession(sessionKey, projectRoot) {
+    const existing = sessionMap.get(sessionKey);
+    if (existing)
+        return existing;
+    // Coalesce concurrent callers for the same key
+    const inFlight = sessionCreatePromises.get(sessionKey);
+    if (inFlight)
+        return inFlight;
+    const promise = createOrResumeSession(sessionKey, projectRoot);
+    sessionCreatePromises.set(sessionKey, promise);
+    try {
+        const session = await promise;
+        sessionMap.set(sessionKey, session);
+        return session;
+    }
+    finally {
+        sessionCreatePromises.delete(sessionKey);
+    }
+}
+/** Internal: actually create or resume a session (not concurrency-safe — use ensureOrchestratorSession). */
+async function createOrResumeSession(sessionKey, projectRoot) {
+    const client = await ensureClient();
+    const { tools, mcpServers, skillDirectories } = getSessionConfig();
+    const isProjectSession = sessionKey.startsWith("project:");
+    const infiniteSessions = {
+        enabled: true,
+        backgroundCompactionThreshold: 0.80,
+        bufferExhaustionThreshold: 0.95,
+    };
+    // Build the correct system message for this session mode
+    let systemMessageContent;
+    if (isProjectSession && projectRoot) {
+        systemMessageContent = await getSquadCoordinatorSystemMessage(projectRoot);
+    }
+    else {
+        const memorySummary = getWikiSummary();
+        systemMessageContent = getOrchestratorSystemMessage({
+            ...getSystemMessageOptions(memorySummary, isProjectSession ? projectRoot : undefined),
+        });
+    }
+    // Try to resume from copilot_sessions; fall back to legacy max_state key for the default session
+    const stored = getCopilotSession(sessionKey);
+    const savedSessionId = stored?.copilotSessionId ?? (sessionKey === "default" ? getState(ORCHESTRATOR_SESSION_KEY) : undefined);
+    if (savedSessionId) {
+        try {
+            console.log(`[chapterhouse] Resuming session [${sessionKey}] ${savedSessionId.slice(0, 8)}…`);
+            const session = await client.resumeSession(savedSessionId, {
+                model: config.copilotModel,
+                configDir: SESSIONS_DIR,
+                streaming: true,
+                systemMessage: { content: systemMessageContent },
+                tools,
+                mcpServers,
+                skillDirectories,
+                onPermissionRequest: orchestratorPermissionHandler,
+                infiniteSessions,
+            });
+            console.log(`[chapterhouse] Resumed session [${sessionKey}] successfully`);
+            upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
+            sessionModelMap.set(sessionKey, config.copilotModel);
+            return session;
+        }
+        catch (err) {
+            console.log(`[chapterhouse] Could not resume session [${sessionKey}]: ${err instanceof Error ? err.message : err}. Creating new.`);
+            if (sessionKey === "default")
+                deleteState(ORCHESTRATOR_SESSION_KEY);
+        }
+    }
+    // Create a fresh session
+    console.log(`[chapterhouse] Creating new session [${sessionKey}]`);
+    const session = await client.createSession({
+        model: config.copilotModel,
+        configDir: SESSIONS_DIR,
+        streaming: true,
+        systemMessage: { content: systemMessageContent },
+        tools,
+        mcpServers,
+        skillDirectories,
+        onPermissionRequest: orchestratorPermissionHandler,
+        infiniteSessions,
+    });
+    console.log(`[chapterhouse] Created session [${sessionKey}] ${session.sessionId.slice(0, 8)}…`);
+    upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
+    // Backward compat: also persist the default session to the legacy state key
+    if (sessionKey === "default")
+        setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
+    sessionModelMap.set(sessionKey, config.copilotModel);
+    return session;
+}
+export async function initOrchestrator(client) {
+    copilotClient = client;
+    const { mcpServers, skillDirectories } = getSessionConfig();
+    // Initialize agent system
+    ensureDefaultAgents();
+    const agents = loadAgents();
+    console.log(`[chapterhouse] Loaded ${agents.length} agent(s): ${agents.map((a) => `@${a.slug}`).join(", ") || "(none)"}`);
+    // Validate configured model against available models
+    try {
+        const models = await client.listModels();
+        const configured = config.copilotModel;
+        const isAvailable = models.some((m) => m.id === configured);
+        if (!isAvailable) {
+            console.log(`[chapterhouse] ⚠️ Configured model '${configured}' is not available. Falling back to '${DEFAULT_MODEL}'.`);
+            config.copilotModel = DEFAULT_MODEL;
+        }
+    }
+    catch (err) {
+        console.log(`[chapterhouse] Could not validate model (will use '${config.copilotModel}' as-is): ${err instanceof Error ? err.message : err}`);
+    }
+    console.log(`[chapterhouse] Loading ${Object.keys(mcpServers).length} MCP server(s): ${Object.keys(mcpServers).join(", ") || "(none)"}`);
+    console.log(`[chapterhouse] Skill directories: ${skillDirectories.join(", ") || "(none)"}`);
+    console.log(`[chapterhouse] Persistent session mode — conversation history maintained by SDK`);
+    startHealthCheck();
+    // Eagerly create/resume the default orchestrator session
+    try {
+        await ensureOrchestratorSession("default");
+    }
+    catch (err) {
+        console.error(`[chapterhouse] Failed to create initial session (will retry on first message):`, err instanceof Error ? err.message : err);
+    }
+}
+/** How long to wait for the orchestrator to finish a turn (10 min). */
+const ORCHESTRATOR_TIMEOUT_MS = 600_000;
+/** Send a prompt on a session identified by sessionKey, return the response. */
+async function executeOnSession(sessionKey, prompt, callback, attachments, onActivity) {
+    const projectRoot = sessionKey.startsWith("project:") ? sessionKey.slice("project:".length) : undefined;
+    const session = await ensureOrchestratorSession(sessionKey, projectRoot);
+    currentProcessingSessionKey = sessionKey;
+    currentCallback = callback;
+    currentActivityCallback = onActivity;
+    let accumulated = "";
+    let toolCallExecuted = false;
+    let toolCallCount = 0;
+    const unsubToolDone = session.on("tool.execution_complete", (event) => {
+        toolCallExecuted = true;
+        toolCallCount++;
+        if (onActivity) {
+            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;
+            onActivity({
+                kind: "tool_complete",
+                toolCallId: data.toolCallId,
+                success: data.success,
+                resultPreview,
+                detailedContent,
+            });
+        }
+    });
+    const unsubToolStart = onActivity
+        ? session.on("tool.execution_start", (event) => {
+            const data = event.data;
+            onActivity({
+                kind: "tool_start",
+                toolCallId: data.toolCallId,
+                toolName: data.toolName,
+                mcpServerName: data.mcpServerName,
+                arguments: data.arguments,
+            });
+        })
+        : () => { };
+    const unsubReasoning = onActivity
+        ? session.on("assistant.reasoning_delta", (event) => {
+            onActivity({
+                kind: "thinking_delta",
+                reasoningId: event.data.reasoningId,
+                deltaContent: event.data.deltaContent,
+            });
+        })
+        : () => { };
+    const unsubSubStart = onActivity
+        ? session.on("subagent.started", (event) => {
+            const data = event.data;
+            onActivity({
+                kind: "subagent_started",
+                toolCallId: data.toolCallId,
+                agentName: data.agentName,
+                agentDisplayName: data.agentDisplayName,
+                agentDescription: data.agentDescription,
+            });
+        })
+        : () => { };
+    const unsubSubDone = onActivity
+        ? session.on("subagent.completed", (event) => {
+            const data = event.data;
+            onActivity({
+                kind: "subagent_completed",
+                toolCallId: data.toolCallId,
+                agentName: data.agentName,
+                agentDisplayName: data.agentDisplayName,
+                durationMs: data.durationMs,
+            });
+        })
+        : () => { };
+    const unsubSubFail = onActivity
+        ? session.on("subagent.failed", (event) => {
+            const data = event.data;
+            onActivity({
+                kind: "subagent_failed",
+                toolCallId: data.toolCallId,
+                agentName: data.agentName,
+                agentDisplayName: data.agentDisplayName,
+                error: data.error,
+            });
+        })
+        : () => { };
+    const unsubDelta = session.on("assistant.message_delta", (event) => {
+        // After a tool call completes, ensure a line break separates the text blocks
+        // so they don't visually run together in the rendered chat.
+        if (toolCallExecuted && accumulated.length > 0 && !accumulated.endsWith("\n")) {
+            accumulated += "\n";
+        }
+        toolCallExecuted = false;
+        accumulated += event.data.deltaContent;
+        callback(accumulated, false);
+    });
+    try {
+        const result = await session.sendAndWait({ prompt, ...(attachments && attachments.length > 0 ? { attachments } : {}) }, ORCHESTRATOR_TIMEOUT_MS);
+        const finalContent = result?.data?.content || accumulated || "(No response)";
+        return finalContent;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        // On timeout, never throw — the message was already sent to the persistent
+        // session and may have been (partially) processed. Return what we have.
+        if (/timeout/i.test(msg)) {
+            if (accumulated.length > 0) {
+                console.log(`[chapterhouse] Timeout after ${ORCHESTRATOR_TIMEOUT_MS / 1000}s but have ${accumulated.length} chars — returning partial response`);
+                return accumulated;
+            }
+            // No text yet but tool calls ran — the session is working in the background
+            // (e.g. delegate_to_agent dispatched). Don't error out.
+            if (toolCallCount > 0) {
+                console.log(`[chapterhouse] Timeout after ${ORCHESTRATOR_TIMEOUT_MS / 1000}s — ${toolCallCount} tool call(s) executed but no text yet. Session is still working.`);
+                return "I'm still working on this — I've started processing but it's taking longer than expected. I'll send you the results when I'm done.";
+            }
+            // No text, no tool calls — the session is truly stuck
+            console.log(`[chapterhouse] Timeout after ${ORCHESTRATOR_TIMEOUT_MS / 1000}s with no activity. Session may be stuck.`);
+            return "Sorry, that request timed out before I could start working on it. Try again or break it into smaller pieces?";
+        }
+        // If the session is broken, invalidate it so it's recreated on next attempt
+        if (/closed|destroy|disposed|invalid|expired|not found/i.test(msg)) {
+            console.log(`[chapterhouse] Session [${sessionKey}] appears dead, will recreate: ${msg}`);
+            sessionMap.delete(sessionKey);
+            sessionModelMap.delete(sessionKey);
+            if (sessionKey === "default")
+                deleteState(ORCHESTRATOR_SESSION_KEY);
+        }
+        throw err;
+    }
+    finally {
+        unsubDelta();
+        unsubToolDone();
+        unsubToolStart();
+        unsubReasoning();
+        unsubSubStart();
+        unsubSubDone();
+        unsubSubFail();
+        currentCallback = undefined;
+        currentActivityCallback = undefined;
+        currentProcessingSessionKey = undefined;
+    }
+}
+/** Process the message queue one at a time. */
+async function processQueue() {
+    if (processing) {
+        if (messageQueue.length > 0) {
+            console.log(`[chapterhouse] Message queued (${messageQueue.length} waiting — orchestrator is busy)`);
+        }
+        return;
+    }
+    processing = true;
+    while (messageQueue.length > 0) {
+        const item = messageQueue.shift();
+        currentSourceChannel = item.sourceChannel;
+        currentChannelKey = item.channelKey;
+        const { sessionKey } = item;
+        try {
+            let result;
+            if (item.targetAgent && item.targetAgent !== "chapterhouse") {
+                // @mention switches the active agent — route through the session
+                setActiveAgent(item.channelKey || "default", item.targetAgent);
+                result = await executeOnSession(sessionKey, item.prompt, item.callback, item.attachments, item.onActivity);
+            }
+            else {
+                // Route the model before executing
+                const currentModel = sessionModelMap.get(sessionKey) ?? config.copilotModel;
+                const routeResult = await resolveModel(item.prompt, currentModel, recentTiers);
+                if (routeResult.switched) {
+                    console.log(`[chapterhouse] Auto: switching to ${routeResult.model} (${routeResult.overrideName || routeResult.tier})`);
+                    config.copilotModel = routeResult.model;
+                    const existingSession = sessionMap.get(sessionKey);
+                    if (existingSession) {
+                        try {
+                            await existingSession.setModel(routeResult.model);
+                            sessionModelMap.set(sessionKey, routeResult.model);
+                            console.log(`[chapterhouse] Model switched in-place via setModel() for [${sessionKey}]`);
+                        }
+                        catch (err) {
+                            console.log(`[chapterhouse] setModel() failed for [${sessionKey}], will recreate: ${err instanceof Error ? err.message : err}`);
+                            sessionMap.delete(sessionKey);
+                            if (sessionKey === "default")
+                                deleteState(ORCHESTRATOR_SESSION_KEY);
+                        }
+                    }
+                }
+                if (routeResult.tier) {
+                    recentTiers.push(routeResult.tier);
+                    if (recentTiers.length > 5)
+                        recentTiers = recentTiers.slice(-5);
+                }
+                lastRouteResult = routeResult;
+                result = await executeOnSession(sessionKey, item.prompt, item.callback, item.attachments, item.onActivity);
+            }
+            item.resolve(result);
+        }
+        catch (err) {
+            item.reject(err);
+        }
+        currentSourceChannel = undefined;
+        currentChannelKey = undefined;
+    }
+    processing = false;
+}
+function isRecoverableError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    // Timeouts are NOT retryable on a persistent session — the message was already
+    // sent and likely processed; re-sending creates "duplicate" responses.
+    if (/timeout/i.test(msg))
+        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) {
+    updateUserContext(source);
+    updateRequestContext(source);
+    const sourceLabel = source.type === "web" ? "web" : "background";
+    logMessage("in", sourceLabel, prompt);
+    // Derive the session key: project sessions come from web messages with a projectPath;
+    // background completions carry their own sessionKey; everything else is "default".
+    let sessionKey;
+    if (source.type === "web" && source.projectPath && config.squadEnabled) {
+        sessionKey = "project:" + normalizeProjectPath(source.projectPath);
+        // Keep the legacy channel-project map in sync for tools that read it
+        setChannelProject(source.connectionId, normalizeProjectPath(source.projectPath));
+    }
+    else if (source.type === "background" && source.sessionKey) {
+        sessionKey = source.sessionKey;
+    }
+    else {
+        sessionKey = "default";
+    }
+    const channelKey = source.type === "web" ? source.connectionId : "default";
+    // Pass projectRoot to parseAtMention only for project sessions so the default
+    // chat does not get Squad roster injection.
+    const projectRoot = sessionKey.startsWith("project:") ? sessionKey.slice("project:".length) : undefined;
+    // Parse @mention routing (e.g., "@coder fix the bug" → target "coder")
+    const mention = parseAtMention(prompt, projectRoot);
+    const targetAgent = mention?.agentSlug;
+    const routedPrompt = mention ? mention.message : prompt;
+    // Tag the prompt with its source channel
+    const taggedPrompt = source.type === "background"
+        ? routedPrompt
+        : `[via ${sourceLabel}] ${routedPrompt}`;
+    // Log role: background events are "system", user messages are "user"
+    const logRole = source.type === "background" ? "system" : "user";
+    // Determine the source channel for agent origin tracking
+    const sourceChannel = source.type === "web" ? "web" : undefined;
+    // Enqueue and process
+    void (async () => {
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const finalContent = await new Promise((resolve, reject) => {
+                    messageQueue.push({ prompt: taggedPrompt, attachments, callback, onActivity, sourceChannel, targetAgent, channelKey, sessionKey, resolve, reject });
+                    processQueue();
+                });
+                // Deliver response to user FIRST, then log best-effort
+                callback(finalContent, true);
+                try {
+                    logMessage("out", sourceLabel, finalContent);
+                }
+                catch { /* best-effort */ }
+                // Log both sides of the conversation, scoped to the session
+                try {
+                    logConversation(logRole, prompt, sourceLabel, sessionKey);
+                }
+                catch { /* best-effort */ }
+                try {
+                    logConversation("assistant", finalContent, sourceLabel, sessionKey);
+                }
+                catch { /* best-effort */ }
+                // Episodic memory: if enough turns have accumulated since the last
+                // summary, kick off a background write. Fire-and-forget — never blocks
+                // the user reply path.
+                if (copilotClient) {
+                    maybeWriteEpisode(copilotClient).catch((err) => {
+                        console.error("[chapterhouse] Episode write failed (non-fatal):", err instanceof Error ? err.message : err);
+                    });
+                }
+                return;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // Don't retry cancelled messages
+                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)];
+                    console.error(`[chapterhouse] Recoverable error: ${msg}. Retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms…`);
+                    await sleep(delay);
+                    // Reset client before retry in case the connection is stale
+                    try {
+                        await ensureClient();
+                    }
+                    catch { /* will fail again on next attempt */ }
+                    continue;
+                }
+                console.error(`[chapterhouse] Error processing message: ${msg}`);
+                callback(`Error: ${msg}`, true);
+                return;
+            }
+        }
+    })();
+}
+/** Cancel the in-flight message and drain the queue. */
+export async function cancelCurrentMessage() {
+    // Drain any queued messages
+    const drained = messageQueue.length;
+    while (messageQueue.length > 0) {
+        const item = messageQueue.shift();
+        item.reject(new Error("Cancelled"));
+    }
+    // Abort the active session request
+    const activeSession = currentProcessingSessionKey ? sessionMap.get(currentProcessingSessionKey) : undefined;
+    if (activeSession && currentCallback) {
+        try {
+            await activeSession.abort();
+            console.log(`[chapterhouse] Aborted in-flight request on [${currentProcessingSessionKey}]`);
+            return true;
+        }
+        catch (err) {
+            console.error(`[chapterhouse] Abort failed:`, err instanceof Error ? err.message : err);
+        }
+    }
+    return drained > 0;
+}
+/** Switch the model on the live default orchestrator session without destroying it. */
+export function switchSessionModel(newModel) {
+    const session = sessionMap.get("default");
+    if (session) {
+        return session.setModel(newModel).then(() => {
+            sessionModelMap.set("default", newModel);
+        });
+    }
+    return Promise.resolve();
+}
+/** Return a snapshot of currently running workers for API/UI consumers. */
+export function getAgentInfo() {
+    const allTasks = getActiveTasks().filter((t) => t.status === "running");
+    const registry = getAgentRegistry();
+    return allTasks.map((t) => {
+        const agent = registry.find((a) => a.slug === t.agentSlug);
+        return {
+            slug: t.agentSlug,
+            name: agent?.name || t.agentSlug,
+            model: agent?.model || "unknown",
+            taskId: t.taskId,
+            description: t.description,
+        };
+    });
+}
+/** Clean up on shutdown/restart. */
+export async function shutdownAgents() {
+    for (const [key, session] of sessionMap) {
+        try {
+            await session.disconnect();
+        }
+        catch (err) {
+            console.error(`[orchestrator] Error disconnecting session "${key}" during shutdown:`, err instanceof Error ? err.message : err);
+        }
+    }
+    sessionMap.clear();
+    sessionModelMap.clear();
+    await clearActiveTasks();
+}
+//# sourceMappingURL=orchestrator.js.map