chapterhouse 0.3.19 → 0.3.20

package/dist/copilot/orchestrator.js

@@ -33,6 +33,19 @@ let proactiveNotifyFn;
 export function setProactiveNotify(fn) {
     proactiveNotifyFn = fn;
 }
+function usesSessionTurnLifecycle(source) {
+    return source.type === "background" || source.type === "sse-web";
+}
+function finalizeTurnEvent(sessionKey, event) {
+    if (event.type === "turn:complete") {
+        emitTurnEvent(sessionKey, { type: "turn:complete", turnId: event.turnId, sessionKey, finalMessage: event.finalMessage });
+    }
+    else {
+        emitTurnEvent(sessionKey, { type: "turn:error", turnId: event.turnId, sessionKey, error: event.error });
+    }
+    persistTurnEvents(event.turnId, sessionKey);
+    scheduleClearTurnLog(event.turnId);
+}
 const turnContextStorage = new AsyncLocalStorage();
 // ---------------------------------------------------------------------------
 // Module-level state (not per-session)
@@ -765,6 +778,10 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
     // sse-web carries user identity just like web (Fix 3).
     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);
+    if (emitSessionLifecycle) {
+        emitTurnEvent(sessionKey, { type: "turn:started", turnId, sessionKey, prompt, attachments });
+    }
     const manager = registry.getOrCreate(sessionKey);
     void (async () => {
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -793,6 +810,9 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     });
                 });
                 callback(finalContent, true, turnId);
+                if (emitSessionLifecycle) {
+                    finalizeTurnEvent(sessionKey, { type: "turn:complete", turnId, finalMessage: finalContent });
+                }
                 try {
                     logMessage("out", sourceLabel, finalContent);
                 }
@@ -829,6 +849,9 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 }
                 log.error({ msg }, "Error processing message");
                 callback(`Error: ${msg}`, true, turnId);
+                if (emitSessionLifecycle) {
+                    finalizeTurnEvent(sessionKey, { type: "turn:error", turnId, error: msg });
+                }
                 return;
             }
         }
@@ -938,7 +961,7 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
  *
  * 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.
+ *  - Routes through the shared lifecycle emitter in sendToOrchestrator.
  *  - Does NOT write to sseClients — the SSE channel delivers events via subscribeSession().
  *  - Supports interrupt: true which calls interruptCurrentTurn under the hood.
  *
@@ -949,15 +972,9 @@ export function enqueueForSse(opts) {
     const turnId = randomUUID();
     // sse-web carries auth and enables onQueued — unlike "background" (Fixes 2 & 3).
     const source = { type: "sse-web", sessionKey, user: authUser, authorizationHeader: authHeader };
-    // 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 callback = (_text, _done, _tid) => {
+        // Note: sendToOrchestrator now owns turn:started/turn:complete/turn:error emission.
+        // Mid-turn text deltas are still emitted by executeOnSession's delta handler.
     };
     const onQueued = (position, tid) => {
         emitTurnEvent(sessionKey, { type: "turn:queued", turnId: tid, sessionKey, position });

package/dist/copilot/orchestrator.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { clearTurnLog, subscribeSession } from "./turn-event-log.js";
 function createFakeClient(state) {
     class FakeSession {
         sessionId = "session-123";
@@ -25,6 +26,9 @@ function createFakeClient(state) {
                     state.pendingReject = reject;
                 });
             }
+            if (state.sendErrorMessage) {
+                throw new Error(state.sendErrorMessage);
+            }
             return { data: { content: state.sendResult } };
         }
         async setModel(model) {
@@ -245,6 +249,21 @@ async function loadOrchestratorModule(t, overrides = {}) {
     const orchestrator = await import(new URL(`./orchestrator.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
     return { orchestrator, state, client };
 }
+function captureSessionEvents(t, sessionKey) {
+    const events = [];
+    const seenTurnIds = new Set();
+    const unsubscribe = subscribeSession(sessionKey, (event) => {
+        events.push(event);
+        seenTurnIds.add(event.turnId);
+    });
+    t.after(() => {
+        unsubscribe();
+        for (const turnId of seenTurnIds) {
+            clearTurnLog(turnId);
+        }
+    });
+    return events;
+}
 test("initOrchestrator falls back to an available model and eagerly creates a session", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t);
     await orchestrator.initOrchestrator(client);
@@ -340,8 +359,10 @@ test("feedAgentResult injects a background completion turn and proactively notif
             selfEditEnabled: true,
         },
         sendResult: "Agent complete",
+        taskSessionKeys: new Map([["task-9", "chat:bg-lifecycle"]]),
     });
     await orchestrator.initOrchestrator(client);
+    const events = captureSessionEvents(t, "chat:bg-lifecycle");
     const notified = new Promise((resolve) => {
         orchestrator.setProactiveNotify(resolve);
     });
@@ -362,6 +383,57 @@ test("feedAgentResult injects a background completion turn and proactively notif
             source: "background",
         },
     ]);
+    const started = events.filter((event) => event.type === "turn:started");
+    const completed = events.filter((event) => event.type === "turn:complete");
+    assert.equal(started.length, 1, "background turn should emit one turn:started event");
+    assert.equal(completed.length, 1, "background turn should emit one turn:complete event");
+    assert.equal(started[0]?.turnId, completed[0]?.turnId, "background lifecycle events must share the same turnId");
+});
+test("enqueueForSse emits exactly one turn lifecycle pair for sse-web turns", async (t) => {
+    const { orchestrator, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        sendResult: "SSE complete",
+    });
+    await orchestrator.initOrchestrator(client);
+    const sessionKey = `chat:sse-lifecycle-${Date.now()}`;
+    const events = captureSessionEvents(t, sessionKey);
+    const turnId = orchestrator.enqueueForSse({ sessionKey, prompt: "hello from sse" });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    const turnEvents = events.filter((event) => event.turnId === turnId);
+    const started = turnEvents.filter((event) => event.type === "turn:started");
+    const completed = turnEvents.filter((event) => event.type === "turn:complete");
+    assert.equal(started.length, 1, "sse-web turn should emit turn:started exactly once");
+    assert.equal(completed.length, 1, "sse-web turn should emit turn:complete exactly once");
+});
+test("sendToOrchestrator emits turn:error instead of turn:complete on failures", async (t) => {
+    const { orchestrator, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        sendErrorMessage: "session exploded",
+        sendResult: "unreachable",
+    });
+    await orchestrator.initOrchestrator(client);
+    const sessionKey = `chat:error-lifecycle-${Date.now()}`;
+    const events = captureSessionEvents(t, sessionKey);
+    const received = new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("trigger an error", { type: "background", sessionKey }, (text, done, turnId) => {
+            if (done) {
+                resolve({ text, done, turnId });
+            }
+        });
+    });
+    const result = await received;
+    assert.match(result.text, /^Error:/);
+    const turnEvents = events.filter((event) => event.turnId === result.turnId);
+    const errors = turnEvents.filter((event) => event.type === "turn:error");
+    const completed = turnEvents.filter((event) => event.type === "turn:complete");
+    assert.equal(errors.length, 1, "failed turn should emit one turn:error event");
+    assert.equal(completed.length, 0, "failed turn must not emit turn:complete");
 });
 test("cancelCurrentMessage aborts the active request and agent helpers expose running work", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.3.19",
+  "version": "0.3.20",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"