chapterhouse 0.3.8 → 0.3.10

package/dist/config.js

@@ -47,6 +47,7 @@ const configSchema = z.object({
     API_RATE_LIMIT_SSE_MAX_CONNECTIONS: z.string().optional(),
     ENABLE_SQUAD: z.string().optional(),
     CHAPTERHOUSE_WORKIQ_AUTO_INSTALL: z.string().optional(),
+    CHAPTERHOUSE_CHAT_SSE: z.string().optional(),
 });
 export const DEFAULT_MODEL = "claude-sonnet-4.6";
 export const DEFAULT_TEAM_WIKI_CACHE_TTL_MINUTES = 60;
@@ -221,6 +222,7 @@ export function parseRuntimeConfig(env, options = {}) {
         apiRateLimitSseMaxConnections,
         squadEnabled: raw.ENABLE_SQUAD === "1",
         workiqAutoInstall: parseBooleanEnv("CHAPTERHOUSE_WORKIQ_AUTO_INSTALL", raw.CHAPTERHOUSE_WORKIQ_AUTO_INSTALL, true),
+        chatSseEnabled: raw.CHAPTERHOUSE_CHAT_SSE === "1",
     };
 }
 const runtimeConfig = parseRuntimeConfig(process.env);
@@ -261,6 +263,7 @@ export const config = {
     apiRateLimitSseMaxConnections: runtimeConfig.apiRateLimitSseMaxConnections,
     squadEnabled: runtimeConfig.squadEnabled,
     workiqAutoInstall: runtimeConfig.workiqAutoInstall,
+    chatSseEnabled: runtimeConfig.chatSseEnabled,
     copilotAuthToken: runtimeConfig.copilotAuthToken,
     get copilotModel() {
         return _copilotModel;

package/dist/copilot/orchestrator.js

@@ -19,6 +19,8 @@ import { normalizeProjectPath, setChannelProject } from "../squad/context.js";
 import { getSquadCoordinatorSystemMessage } from "../squad/charter.js";
 import { childLogger } from "../util/logger.js";
 import { squadEventBus } from "./squad-event-bus.js";
+import { initTaskEventLog } from "./task-event-log.js";
+import { emitTurnEvent, persistTurnEvents, scheduleClearTurnLog, } from "./turn-event-log.js";
 import { SessionManager, SessionRegistry, SESSION_IDLE_TTL_MS, SESSION_MAX_ACTIVE, } from "./session-manager.js";
 const log = childLogger("orchestrator");
 const MAX_RETRIES = 3;
@@ -299,6 +301,8 @@ export async function initOrchestrator(client) {
     copilotClient = client;
     // Initialize governance hook pipeline before any session is created.
     initHookPipeline();
+    // Initialize per-task ring buffer — subscribes to squadEventBus for session:tool_call events.
+    initTaskEventLog();
     // (Re-)create the registry — supports multiple initOrchestrator calls in tests
     if (registry) {
         await registry.shutdown();
@@ -388,15 +392,15 @@ async function executeOnSession(manager, item) {
         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;
             if (item.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;
                 item.onActivity({
                     kind: "tool_complete",
                     toolCallId: data.toolCallId,
@@ -405,6 +409,16 @@ async function executeOnSession(manager, item) {
                     detailedContent,
                 }, item.turnId);
             }
+            // Emit turn:delta with tool-call part (coexistence — #130)
+            const toolPart = {
+                type: "tool-call",
+                toolCallId: String(data.toolCallId ?? ""),
+                toolName: String(data.toolName ?? "unknown"),
+                status: data.success !== false ? "done" : "failed",
+                resultPreview,
+                detailedContent,
+            };
+            emitTurnEvent(sessionKey, { type: "turn:delta", turnId: item.turnId, sessionKey, part: toolPart });
         });
         const unsubToolStart = item.onActivity
             ? session.on("tool.execution_start", (event) => {
@@ -472,6 +486,29 @@ async function executeOnSession(manager, item) {
             })
             : () => { };
         // 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();
@@ -494,6 +531,17 @@ async function executeOnSession(manager, item) {
                     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 */ }
         });
@@ -511,6 +559,17 @@ async function executeOnSession(manager, item) {
                     payload: { agentName: taskRow?.agent_slug ?? "", reason: "complete" },
                     timestamp: new Date(),
                 });
+                // Emit turn:delta with subagent completed part (coexistence — #130)
+                const doneData = event.data;
+                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 */ }
         });
@@ -528,6 +587,16 @@ async function executeOnSession(manager, item) {
                     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",
+                    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 */ }
         });
@@ -581,8 +650,16 @@ async function executeOnSession(manager, item) {
                 accumulated += "\n";
             }
             toolCallExecuted = false;
-            accumulated += event.data.deltaContent;
+            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 },
+            });
         });
         try {
             const result = await session.sendAndWait({ prompt: item.prompt, ...(item.attachments && item.attachments.length > 0 ? { attachments: item.attachments } : {}) }, ORCHESTRATOR_TIMEOUT_MS);
@@ -625,6 +702,8 @@ async function executeOnSession(manager, item) {
             unsubSubFailDb();
             unsubNestedToolStart();
             unsubNestedToolDone();
+            unsubTurnToolStart();
+            unsubTurnReasoning();
         }
     });
 }
@@ -773,6 +852,147 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
         }
     })();
 }
+/**
+ * Abort the active turn on `sessionKey` and immediately start a new turn with `newPrompt`.
+ * Uses the zero-gap technique: enqueue the replacement BEFORE awaiting abort so the
+ * drain loop picks it up on its next iteration without any processing gap.
+ *
+ * If no session is currently active for `sessionKey`, falls back to a normal
+ * sendToOrchestrator call.
+ *
+ * @param onInterrupted Called with the aborted turn's ID immediately before the
+ *   replacement turn starts. Use to emit a `turn-interrupted` SSE event so the
+ *   frontend can drop the partial in-flight bubble.
+ */
+export async function interruptCurrentTurn(sessionKey, newPrompt, source, callback, attachments, onActivity, onInterrupted) {
+    const manager = registry?.get(sessionKey);
+    // If no session exists or it isn't processing, fall back to a normal send.
+    if (!manager || !manager.isProcessing) {
+        return sendToOrchestrator(newPrompt, source, callback, attachments, onActivity);
+    }
+    updateUserContext(source);
+    updateRequestContext(source);
+    const turnId = randomUUID();
+    const sourceLabel = source.type === "web" ? "web" : "background";
+    const sourceChannel = source.type === "web" ? "web" : undefined;
+    const authUser = source.type === "web" ? source.user : undefined;
+    const authHeader = source.type === "web" ? source.authorizationHeader?.trim() || undefined : undefined;
+    const taggedPrompt = source.type === "background"
+        ? newPrompt
+        : `[via ${sourceLabel}] ${newPrompt}`;
+    // Clear any messages already waiting in the queue behind the in-flight turn —
+    // their context is stale once we interrupt.
+    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 () => {
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const finalContent = await new Promise((resolve, reject) => {
+                    manager.enqueue({
+                        prompt: taggedPrompt,
+                        attachments,
+                        callback,
+                        onActivity: onActivity,
+                        turnId,
+                        isInterrupt: true,
+                        onInterrupted,
+                        sourceChannel,
+                        sessionKey,
+                        authUser,
+                        authHeader,
+                        resolve,
+                        reject,
+                    });
+                });
+                callback(finalContent, true, turnId);
+                try {
+                    logMessage("out", sourceLabel, finalContent);
+                }
+                catch { /* best-effort */ }
+                try {
+                    logConversation("user", newPrompt, sourceLabel, sessionKey);
+                }
+                catch { /* best-effort */ }
+                try {
+                    logConversation("assistant", finalContent, sourceLabel, sessionKey);
+                }
+                catch { /* best-effort */ }
+                if (copilotClient) {
+                    maybeWriteEpisode(copilotClient).catch((err) => {
+                        log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
+                    });
+                }
+                return;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                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)];
+                    log.warn({ msg, attempt: attempt + 1, maxRetries: MAX_RETRIES, delayMs: delay }, "Recoverable error on interrupt turn, retrying");
+                    await sleep(delay);
+                    try {
+                        await ensureClient();
+                    }
+                    catch { /* will fail again on next attempt */ }
+                    continue;
+                }
+                log.error({ msg }, "Error processing interrupt turn");
+                callback(`Error: ${msg}`, true, turnId);
+                return;
+            }
+        }
+    })();
+    // 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.
+    await manager.abortCurrentTurn();
+    log.info({ sessionKey, replacementTurnId: turnId }, "turn.interrupted");
+}
+/**
+ * Enqueue a turn for the new POST→SSE chat path (#130).
+ *
+ * Unlike `sendToOrchestrator`, this function:
+ *  - Returns the `turnId` immediately without waiting for the turn to complete.
+ *  - Emits turn:started, turn:complete, and turn:error events to the turn event log.
+ *  - Does NOT write to sseClients — the SSE channel delivers events via subscribeSession().
+ *  - Supports interrupt: true which calls interruptCurrentTurn under the hood.
+ *
+ * @returns turnId (UUID)
+ */
+export function enqueueForSse(opts) {
+    const { sessionKey, prompt, attachments, authUser, authHeader, interrupt } = opts;
+    const turnId = randomUUID();
+    const source = { type: "background", sessionKey };
+    const taggedPrompt = `[via sse] ${prompt}`;
+    // Emit turn:started immediately so the SSE client sees it before any delta
+    emitTurnEvent(sessionKey, { type: "turn:started", turnId, sessionKey, prompt, attachments });
+    const callback = (text, done, tid) => {
+        if (done) {
+            emitTurnEvent(sessionKey, { type: "turn:complete", turnId: tid, sessionKey, finalMessage: text });
+            persistTurnEvents(tid, sessionKey);
+            scheduleClearTurnLog(tid);
+        }
+        // Note: mid-turn text deltas are emitted by executeOnSession's delta handler
+    };
+    const onQueued = (position, tid) => {
+        emitTurnEvent(sessionKey, { type: "turn:queued", turnId: tid, sessionKey, position });
+    };
+    const onInterrupted = (abortedTurnId) => {
+        emitTurnEvent(sessionKey, { type: "turn:interrupted", turnId: abortedTurnId, sessionKey });
+        persistTurnEvents(abortedTurnId, sessionKey);
+        scheduleClearTurnLog(abortedTurnId);
+    };
+    if (interrupt) {
+        void interruptCurrentTurn(sessionKey, taggedPrompt, source, callback, attachments, undefined, onInterrupted);
+    }
+    else {
+        void sendToOrchestrator(taggedPrompt, source, callback, attachments, undefined, onQueued);
+    }
+    return turnId;
+}
 /** Cancel all queued and in-flight messages across all active sessions. */
 export async function cancelCurrentMessage() {
     if (!registry)

package/dist/copilot/orchestrator.test.js

@@ -870,4 +870,46 @@ test("#86: subagent.completed removes task from activeSubagentTaskIds — subseq
     assert.equal(events.length, 0, "No task events must be recorded after subagent completes");
     state.pendingReject?.(new Error("test teardown"));
 });
+// ---------------------------------------------------------------------------
+// #98 — interruptCurrentTurn
+// ---------------------------------------------------------------------------
+test("#98: interruptCurrentTurn aborts active turn and starts replacement turn", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    const firstResults = [];
+    const secondResults = [];
+    let interruptedTurnId;
+    // Start a long-running first turn
+    orchestrator.sendToOrchestrator("first long request", { type: "background" }, (text, done) => { if (done)
+        firstResults.push(text); });
+    // Let the first turn get in-flight
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.abortCalls === 0, "no abort yet");
+    // Interrupt with a replacement turn
+    await orchestrator.interruptCurrentTurn("default", "replacement request", { type: "background" }, (text, done) => { if (done)
+        secondResults.push(text); }, undefined, undefined, (abortedId) => { interruptedTurnId = abortedId; });
+    assert.equal(state.abortCalls, 1, "abort must be called exactly once");
+    // Resolve the pending session so the replacement turn can complete
+    state.pendingReject?.(new Error("aborted"));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+});
+test("#98: interruptCurrentTurn falls back to normal send when no session is active", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "fallback response",
+    });
+    await orchestrator.initOrchestrator(client);
+    const results = [];
+    // No active turn — should fall back to sendToOrchestrator
+    await new Promise((resolve) => {
+        orchestrator.interruptCurrentTurn("default", "normal prompt", { type: "background" }, (text, done) => { if (done) {
+            results.push(text);
+            resolve();
+        } });
+    });
+    assert.equal(results.length, 1, "fallback turn must complete");
+    assert.equal(results[0], "fallback response");
+    assert.equal(state.abortCalls, 0, "no abort when session is idle");
+});
 //# sourceMappingURL=orchestrator.test.js.map

package/dist/copilot/ring-buffer.js

@@ -0,0 +1,34 @@
+/**
+ * Shared generic ring buffer — extracted from task-event-log.ts (#116) for #130.
+ *
+ * Fixed-capacity FIFO: when capacity is reached, the oldest item is evicted
+ * before the new one is pushed.
+ *
+ * @module copilot/ring-buffer
+ */
+export class RingBuffer {
+    _capacity;
+    _items;
+    constructor(capacity) {
+        if (capacity < 1)
+            throw new RangeError("RingBuffer capacity must be >= 1");
+        this._capacity = capacity;
+        this._items = [];
+    }
+    push(item) {
+        if (this._items.length >= this._capacity) {
+            this._items.shift(); // evict oldest
+        }
+        this._items.push(item);
+    }
+    getAll() {
+        return this._items.slice();
+    }
+    get size() {
+        return this._items.length;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+}
+//# sourceMappingURL=ring-buffer.js.map

package/dist/copilot/ring-buffer.test.js

@@ -0,0 +1,82 @@
+/**
+ * Unit tests for src/copilot/ring-buffer.ts — #130
+ *
+ * Covers:
+ *  1. Basic push and getAll
+ *  2. Capacity enforcement (evicts oldest)
+ *  3. getAll returns a copy (not a reference)
+ *  4. size and capacity getters
+ *  5. RangeError on capacity < 1
+ *  6. Single-item buffer
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { RingBuffer } from "./ring-buffer.js";
+describe("RingBuffer", () => {
+    it("stores and retrieves items in insertion order", () => {
+        const buf = new RingBuffer(5);
+        buf.push(1);
+        buf.push(2);
+        buf.push(3);
+        assert.deepEqual(buf.getAll(), [1, 2, 3]);
+    });
+    it("evicts the oldest item when at capacity", () => {
+        const buf = new RingBuffer(3);
+        buf.push(1);
+        buf.push(2);
+        buf.push(3);
+        buf.push(4); // evicts 1
+        assert.deepEqual(buf.getAll(), [2, 3, 4]);
+    });
+    it("evicts multiple items correctly", () => {
+        const buf = new RingBuffer(3);
+        for (let i = 1; i <= 6; i++)
+            buf.push(i);
+        assert.deepEqual(buf.getAll(), [4, 5, 6]);
+    });
+    it("getAll returns a copy — mutations do not affect the buffer", () => {
+        const buf = new RingBuffer(5);
+        buf.push(10);
+        buf.push(20);
+        const snapshot = buf.getAll();
+        snapshot.push(999);
+        assert.deepEqual(buf.getAll(), [10, 20], "internal array was mutated unexpectedly");
+    });
+    it("size reflects the number of stored items", () => {
+        const buf = new RingBuffer(10);
+        assert.equal(buf.size, 0);
+        buf.push("a");
+        assert.equal(buf.size, 1);
+        buf.push("b");
+        assert.equal(buf.size, 2);
+    });
+    it("size does not exceed capacity after overfill", () => {
+        const buf = new RingBuffer(3);
+        for (let i = 0; i < 100; i++)
+            buf.push(i);
+        assert.equal(buf.size, 3);
+    });
+    it("capacity getter returns the constructor value", () => {
+        const buf = new RingBuffer(42);
+        assert.equal(buf.capacity, 42);
+    });
+    it("throws RangeError for capacity < 1", () => {
+        assert.throws(() => new RingBuffer(0), RangeError);
+        assert.throws(() => new RingBuffer(-5), RangeError);
+    });
+    it("works for a single-item capacity buffer", () => {
+        const buf = new RingBuffer(1);
+        buf.push("first");
+        buf.push("second"); // evicts first
+        assert.deepEqual(buf.getAll(), ["second"]);
+        assert.equal(buf.size, 1);
+    });
+    it("stores objects by reference (shallow copy behaviour)", () => {
+        const obj = { x: 1 };
+        const buf = new RingBuffer(5);
+        buf.push(obj);
+        obj.x = 42;
+        assert.equal(buf.getAll()[0].x, 42, "RingBuffer should not deep-clone items");
+    });
+});
+//# sourceMappingURL=ring-buffer.test.js.map

package/dist/copilot/session-manager.js

@@ -53,6 +53,8 @@ export class SessionManager {
     _currentModel;
     _recentTiers = [];
     _lastActivityAt = Date.now();
+    /** turnId of the turn currently being processed by the worker. Set before worker entry, cleared after. */
+    _currentTurnId;
     /** Set by registry.close() when the session is busy at close time. The drain loop
      * honors this after the queue fully empties — evicting without violating the
      * never-evict-mid-turn invariant. */
@@ -77,6 +79,10 @@ export class SessionManager {
     get lastActivityAt() {
         return this._lastActivityAt;
     }
+    /** turnId of the turn currently in-flight (being processed by the worker). Undefined when idle. */
+    get currentTurnId() {
+        return this._currentTurnId;
+    }
     /** True when an explicit close was requested while the session was busy. */
     get pendingClose() {
         return this._pendingClose;
@@ -146,11 +152,17 @@ export class SessionManager {
         this._processing = true;
         while (this._queue.length > 0) {
             const item = this._queue.shift();
+            // If this item is an interrupt, notify before starting — lets the frontend drop
+            // the partial in-flight bubble before the replacement turn begins.
+            if (item.isInterrupt && this._currentTurnId) {
+                item.onInterrupted?.(this._currentTurnId);
+            }
             // Notify before the worker starts — closing the window where backend queue
             // length has dropped but the frontend still shows stale "N ahead" counts.
             item.onAdvance?.(this._queue.length);
+            this._currentTurnId = item.turnId;
             const start = Date.now();
-            log.info({ sessionKey: this.sessionKey, sourceChannel: item.sourceChannel }, "session.turn.started");
+            log.info({ sessionKey: this.sessionKey, sourceChannel: item.sourceChannel, isInterrupt: item.isInterrupt ?? false }, "session.turn.started");
             try {
                 const result = await this.worker(item, this);
                 const durationMs = Date.now() - start;
@@ -164,6 +176,7 @@ export class SessionManager {
             }
             this._lastActivityAt = Date.now();
         }
+        this._currentTurnId = undefined;
         this._processing = false;
         // Honor deferred explicit-close: evict now that the queue is empty.
         if (this._pendingClose && this._queue.length === 0) {