chapterhouse 0.9.1 → 0.10.0

package/dist/copilot/orchestrator.test.js

@@ -10,6 +10,10 @@ function createFakeClient(state) {
             this.options = options;
         }
         on(eventName, handler) {
+            state.sessionOnCalls++;
+            if (state.sessionOnThrowAt === state.sessionOnCalls) {
+                throw new Error(`session.on failed for ${eventName}`);
+            }
             const handlers = this.listeners.get(eventName) || [];
             handlers.push(handler);
             this.listeners.set(eventName, handlers);
@@ -67,6 +71,7 @@ function createFakeClient(state) {
             const session = new FakeSession(options);
             state.lastSession = {
                 emit: (eventName, data) => session.emit(eventName, data),
+                listenerCount: (eventName) => session.listeners.get(eventName)?.length ?? 0,
             };
             return session;
         },
@@ -116,6 +121,9 @@ async function loadOrchestratorModule(t, overrides = {}) {
         ],
         sendResult: "Finished successfully",
         promptMemoryContexts: [],
+        loggerWarnings: [],
+        loggerErrors: [],
+        sessionOnCalls: 0,
         taskEvents: new Map(),
         projectRegistry: {},
         resolveProjectArgs: [],
@@ -130,6 +138,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
         housekeepingRuns: [],
         housekeepingInFlight: false,
         activeScope: makeScope(1, "chapterhouse", "Chapterhouse", "Core Chapterhouse work."),
+        stopClassifierCalls: 0,
         wikiPages: [{ title: "Chapterhouse", summary: "wiki summary", last_updated: "2026-05-13" }],
         ...overrides,
     };
@@ -153,6 +162,19 @@ async function loadOrchestratorModule(t, overrides = {}) {
             },
         },
     });
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (...args) => {
+                    state.loggerWarnings.push(args);
+                },
+                error: (...args) => {
+                    state.loggerErrors.push(args);
+                },
+            }),
+        },
+    });
     t.mock.module("../config.js", {
         namedExports: {
             config: state.config,
@@ -417,8 +439,13 @@ async function loadOrchestratorModule(t, overrides = {}) {
             deleteState: (key) => {
                 state.store.delete(key);
             },
-            getCopilotSession: (_sessionKey) => undefined,
-            upsertCopilotSession: (_sessionKey, _mode, _copilotSessionId, _projectRoot, _model) => { },
+            getCopilotSession: (sessionKey) => state.copilotSessions?.get(sessionKey),
+            upsertCopilotSession: (sessionKey, _mode, copilotSessionId, _projectRoot, model) => {
+                state.copilotSessions?.set(sessionKey, { copilotSessionId, model });
+            },
+            deleteCopilotSession: (sessionKey) => {
+                state.copilotSessions?.delete(sessionKey);
+            },
             getTaskSessionKey: (taskId) => state.taskSessionKeys?.get(taskId) ?? "default",
             getDb: () => ({
                 prepare: (sql) => ({
@@ -485,6 +512,13 @@ async function loadOrchestratorModule(t, overrides = {}) {
             },
         },
     });
+    t.mock.module("./classifier.js", {
+        namedExports: {
+            stopClassifier: () => {
+                state.stopClassifierCalls++;
+            },
+        },
+    });
     t.mock.module("./agents.js", {
         namedExports: {
             loadAgents: () => {
@@ -904,8 +938,8 @@ test("sendToOrchestrator logs both sides, remembers web auth context, and record
     assert.equal(final, "All green");
     assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] Summarize the deployment" }]);
     assert.deepEqual(state.routerArgs, [["[via web] Summarize the deployment", "claude-sonnet-4.6", []]]);
-    assert.deepEqual(orchestrator.getCurrentAuthenticatedUser(), user);
-    assert.equal(orchestrator.getCurrentAuthorizationHeader(), "Bearer token-123");
+    assert.equal(orchestrator.getCurrentAuthenticatedUser(), undefined);
+    assert.equal(orchestrator.getCurrentAuthorizationHeader(), undefined);
     assert.deepEqual(orchestrator.getLastAuthenticatedUser(), user);
     assert.deepEqual(orchestrator.getLastRouteResult(), {
         model: "claude-sonnet-4.6",
@@ -1438,6 +1472,47 @@ test("feedAgentResult emits a delta even when the agent result is empty", async
     assert.equal(deltas.length, 1);
     assert.deepEqual(deltas[0]?.part, { type: "text", text: "" });
 });
+test("feedAgentResult logs fire-and-forget acknowledgement failures instead of leaking rejections", async (t) => {
+    const { orchestrator, state } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: true },
+    });
+    const unhandled = [];
+    const onUnhandledRejection = (reason) => {
+        unhandled.push(reason);
+    };
+    process.on("unhandledRejection", onUnhandledRejection);
+    t.after(() => {
+        process.off("unhandledRejection", onUnhandledRejection);
+    });
+    t.mock.method(global, "setImmediate", (() => {
+        throw new Error("setImmediate exploded");
+    }));
+    orchestrator.feedAgentResult("task-uninitialized", "coder", "done");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.deepEqual(unhandled, []);
+    assert.ok(state.loggerErrors.some((entry) => entry[1] === "unhandled rejection in feedAgentResult"), "feedAgentResult should log fire-and-forget failures");
+});
+test("sendToOrchestrator logs top-level async callback failures on error delivery", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false },
+        createSessionError: "fatal: SDK host permanently unavailable",
+    });
+    const unhandled = [];
+    const onUnhandledRejection = (reason) => {
+        unhandled.push(reason);
+    };
+    process.on("unhandledRejection", onUnhandledRejection);
+    t.after(() => {
+        process.off("unhandledRejection", onUnhandledRejection);
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("hello", { type: "background" }, () => {
+        throw new Error("callback exploded");
+    });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.deepEqual(unhandled, []);
+    assert.ok(state.loggerErrors.some((entry) => entry[1] === "unhandled rejection in sendToOrchestrator"), "sendToOrchestrator should log top-level async failures");
+});
 test("enqueueForSse emits exactly one turn lifecycle pair for sse-web turns", async (t) => {
     const { orchestrator, client } = await loadOrchestratorModule(t, {
         config: {
@@ -1698,10 +1773,54 @@ test("shutdownAgents disconnects all sessions, clears maps, and clears active ta
     await orchestrator.shutdownAgents();
     assert.equal(state.disconnectCalls, 2, "disconnect must be called once per session (default + chat:1)");
     assert.equal(state.clearActiveTasksCalls, 1, "clearActiveTasks must be called exactly once");
+    assert.equal(state.stopClassifierCalls, 1, "classifier session must be stopped during shutdown");
     // Re-init after shutdown must create a fresh session (proves sessionMap was cleared)
     await orchestrator.initOrchestrator(client);
     assert.ok(state.createSessionCalls.length > sessionsAfterInit + 1, "re-init after shutdown must create a new session (not reuse stale sessionMap entry)");
 });
+test("failed persistent session resume clears the stored session id even when replacement creation fails", async (t) => {
+    const copilotSessions = new Map([
+        ["chat:stale", { copilotSessionId: "stale-session", model: "claude-sonnet-4.6" }],
+    ]);
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false },
+        copilotSessions,
+        createSessionError: "replacement create failed",
+    });
+    await orchestrator.initOrchestrator(client);
+    let final = "";
+    orchestrator.sendToOrchestrator("hello", { type: "background", sessionKey: "chat:stale" }, (text, done) => {
+        if (done)
+            final = text;
+    });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.deepEqual(state.resumeSessionCalls.map((call) => call.savedId), ["stale-session"]);
+    assert.match(final, /replacement create failed/);
+    assert.equal(copilotSessions.has("chat:stale"), false, "failed resume must remove the stale persisted session id");
+});
+test("subagent completion logs a warning when the persisted result is truncated", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false },
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("run a subagent", { type: "background", sessionKey: "chat:long-result" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const longContent = "x".repeat(10_001);
+    state.lastSession?.emit("subagent.started", {
+        toolCallId: "task-long",
+        agentName: "coder",
+        agentDisplayName: "Coder",
+        agentDescription: "Writes code",
+    });
+    state.lastSession?.emit("subagent.completed", {
+        toolCallId: "task-long",
+        result: { content: longContent },
+    });
+    assert.ok(state.loggerWarnings.some((args) => JSON.stringify(args).includes("truncated")), "long subagent result truncation should be logged");
+    state.pendingReject?.(new Error("test teardown"));
+    await new Promise((resolve) => setTimeout(resolve, 10));
+});
 // ---------------------------------------------------------------------------
 // feedAgentResult routes to the correct non-default session
 // ---------------------------------------------------------------------------
@@ -1762,6 +1881,21 @@ test("ensureOrchestratorSession cleans up in-flight promise on session creation
 // agent_tasks, so agent dispatches were invisible.
 // Fix: unconditional DB subscriptions in executeOnSession write/update rows.
 // ---------------------------------------------------------------------------
+test("executeOnSession unsubscribes partially registered listeners when setup throws", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+        sessionOnThrowAt: 2,
+    });
+    await orchestrator.initOrchestrator(client);
+    const received = [];
+    orchestrator.sendToOrchestrator("dispatch something", { type: "background" }, (text, done) => {
+        received.push({ text, done });
+    });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.ok(state.lastSession, "FakeSession should have been created");
+    assert.equal(state.lastSession.listenerCount("tool.execution_start"), 0, "setup failures must clean up listeners that were already registered");
+    assert.ok(received.some((entry) => entry.done && entry.text.startsWith("Error:")), "setup failure should still surface as a turn error");
+});
 test("S5-01: subagent.started event inserts an adhoc row into agent_tasks", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         sendResult: "__PENDING__",
@@ -2070,6 +2204,7 @@ test("#98: interruptCurrentTurn aborts active turn and starts 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");
+    assert.ok(interruptedTurnId, "interrupt callback should report the aborted turn id");
     // Resolve the pending session so the replacement turn can complete
     state.pendingReject?.(new Error("aborted"));
     await new Promise((resolve) => setTimeout(resolve, 50));

package/dist/copilot/prompt-date.js

@@ -1,5 +1,6 @@
+import { config } from "../config.js";
 export function getCurrentDateSystemLine() {
-    if (process.env.CHAPTERHOUSE_INJECT_DATE === "0") {
+    if (!config.injectDate) {
         return undefined;
     }
     const now = new Date();

package/dist/copilot/session-manager.js

@@ -15,30 +15,26 @@
 //   CHAPTERHOUSE_SESSION_MAX_ACTIVE   (default: 20)
 // ---------------------------------------------------------------------------
 import { childLogger } from "../util/logger.js";
+import { config } from "../config.js";
 const log = childLogger("session-manager");
 // ---------------------------------------------------------------------------
 // Env-configurable eviction parameters
 // ---------------------------------------------------------------------------
-const DEFAULT_SESSION_IDLE_TTL_MS = 1_800_000; // 30 min
-export const SESSION_IDLE_TTL_MS = (() => {
-    const env = process.env.CHAPTERHOUSE_SESSION_IDLE_TTL_MS;
-    if (env) {
-        const parsed = parseInt(env, 10);
-        if (!isNaN(parsed) && parsed > 0)
-            return parsed;
-    }
-    return DEFAULT_SESSION_IDLE_TTL_MS;
-})();
-const DEFAULT_SESSION_MAX_ACTIVE = 20;
-export const SESSION_MAX_ACTIVE = (() => {
-    const env = process.env.CHAPTERHOUSE_SESSION_MAX_ACTIVE;
-    if (env) {
-        const parsed = parseInt(env, 10);
-        if (!isNaN(parsed) && parsed > 0)
-            return parsed;
-    }
-    return DEFAULT_SESSION_MAX_ACTIVE;
-})();
+export const SESSION_IDLE_TTL_MS = config.sessionIdleTtlMs;
+export const SESSION_MAX_ACTIVE = config.sessionMaxActive;
+export class SessionCapacityError extends Error {
+    statusCode = 503;
+    expose = true;
+    activeSessions;
+    maxActive;
+    constructor(sessionKey, activeSessions, maxActive) {
+        super(`Cannot create session '${sessionKey}': maximum active sessions (${maxActive}) reached and no idle session is available to evict.`);
+        this.name = "SessionCapacityError";
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.activeSessions = activeSessions;
+        this.maxActive = maxActive;
+    }
+}
 // ---------------------------------------------------------------------------
 // SessionManager — owns one session key
 // ---------------------------------------------------------------------------
@@ -310,8 +306,10 @@ export class SessionRegistry {
         const existing = this.managers.get(sessionKey);
         if (existing)
             return existing;
-        if (this.nonPersistentSize() >= this.options.maxActive) {
-            this.evictLRU();
+        if (!this.isPersistentSessionKey(sessionKey) && this.nonPersistentSize() >= this.options.maxActive) {
+            if (!this.evictLRU()) {
+                throw new SessionCapacityError(sessionKey, this.nonPersistentSize(), this.options.maxActive);
+            }
         }
         const manager = this.createManager(sessionKey);
         this.managers.set(sessionKey, manager);
@@ -384,16 +382,20 @@ export class SessionRegistry {
             .sort(([, a], [, b]) => a.lastActivityAt - b.lastActivityAt);
         if (evictable.length === 0) {
             log.warn({ size: this.managers.size, max: this.options.maxActive }, "At max active sessions and no idle sessions available for LRU eviction");
-            return;
+            return false;
         }
         const [sessionKey, manager] = evictable[0];
         this.managers.delete(sessionKey);
         void manager.evict("lru-bumped");
         log.info({ sessionKey, reason: "lru-bumped" }, "session.evicted");
+        return true;
     }
     nonPersistentSize() {
         return [...this.managers.values()].filter((manager) => !manager.isPersistent).length;
     }
+    isPersistentSessionKey(sessionKey) {
+        return sessionKey.startsWith("agent:");
+    }
     /** Shut down all sessions. Stops the eviction timer and disconnects every session. */
     async shutdown() {
         this.stopEvictionTimer();

package/dist/copilot/session-manager.test.js

@@ -197,6 +197,41 @@ test("SessionRegistry: LRU eviction fires when at maxActive capacity", async ()
     assert.ok(disconnectLog.includes("s1"), "s1 (oldest) should be LRU-evicted");
     assert.ok(!registry.get("s1"), "s1 should be removed from registry");
 });
+test("SessionRegistry: getOrCreate rejects new non-persistent sessions when cap is full and all sessions are busy", async () => {
+    let unblock1;
+    let unblock2;
+    let callCount = 0;
+    const { registry } = (() => {
+        const r = new SessionRegistry({ idleTtlMs: 60_000, maxActive: 2 }, (sk) => {
+            const t = makeFakeSession();
+            const worker = () => {
+                callCount++;
+                return new Promise((res) => {
+                    if (callCount === 1)
+                        unblock1 = () => res("one");
+                    else
+                        unblock2 = () => res("two");
+                });
+            };
+            return new SessionManager(sk, worker, factory(t.session));
+        });
+        return { registry: r };
+    })();
+    const first = registry.getOrCreate("s1");
+    const second = registry.getOrCreate("s2");
+    first.enqueue(makeDeferred().item);
+    second.enqueue(makeDeferred().item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.throws(() => registry.getOrCreate("s3"), (error) => error instanceof Error
+        && error.name === "SessionCapacityError"
+        && error.statusCode === 503
+        && /maximum active sessions/i.test(error.message));
+    assert.equal(registry.size(), 2, "registry must not exceed maxActive");
+    assert.equal(registry.get("s3"), undefined);
+    unblock1();
+    unblock2();
+    await new Promise((r) => setTimeout(r, 0));
+});
 test("SessionRegistry: explicit close evicts an idle session", async () => {
     const { registry, disconnectLog } = makeRegistry();
     const m = registry.getOrCreate("my-session");
@@ -208,7 +243,6 @@ test("SessionRegistry: explicit close evicts an idle session", async () => {
     assert.ok(disconnectLog.includes("my-session"), "session should be disconnected");
 });
 test("SessionRegistry: close is deferred when session is processing", async () => {
-    const { registry, disconnectLog } = makeRegistry();
     let unblock;
     // Replace the factory with a blocking one
     const { registry: reg2, disconnectLog: dl2 } = (() => {

package/dist/copilot/standup.js

@@ -1,5 +1,5 @@
 import { config } from "../config.js";
-import { sendToOrchestrator, getCurrentAuthorizationHeader, getCurrentAuthenticatedUser, getLastAuthenticatedUser, } from "./orchestrator.js";
+import { sendToOrchestrator, getCurrentAuthorizationHeader, getCurrentAuthenticatedUser, } from "./orchestrator.js";
 import { TeamPushClient } from "../integrations/team-push.js";
 import { getMyOkrsSummary } from "./tools.js";
 import { readPage, writePage } from "../wiki/fs.js";
@@ -106,7 +106,7 @@ function formatDate(now) {
     return `${year}-${month}-${day}`;
 }
 async function defaultGetMyOkrs(period) {
-    const getCurrentUser = () => getCurrentAuthenticatedUser() ?? getLastAuthenticatedUser();
+    const getCurrentUser = () => getCurrentAuthenticatedUser();
     return await getMyOkrsSummary({
         createTeamPushClient: () => new TeamPushClient({
             getAuthorizationHeader: getCurrentAuthorizationHeader,

package/dist/copilot/task-event-log.js

@@ -34,6 +34,7 @@ export const RING_BUFFER_CAPACITY = 500;
 // ---------------------------------------------------------------------------
 const taskBuffers = new Map();
 const taskListeners = new Map();
+let eventBusCleanup;
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -64,6 +65,9 @@ function notifyListeners(taskId, event) {
  * Call once from initOrchestrator(). Returns an unsub / cleanup function.
  */
 export function initTaskEventLog() {
+    if (eventBusCleanup) {
+        return eventBusCleanup;
+    }
     const unsubToolCall = agentEventBus.subscribe("session:tool_call", (event) => {
         const taskId = event.sessionId;
         if (!taskId)
@@ -91,10 +95,12 @@ export function initTaskEventLog() {
         if (event.sessionId)
             clearTaskLog(event.sessionId);
     });
-    return () => {
+    eventBusCleanup = () => {
         unsubToolCall();
         unsubDestroyed();
+        eventBusCleanup = undefined;
     };
+    return eventBusCleanup;
 }
 /**
  * Return all ring-buffered events for a task, optionally filtered to seq > afterSeq.

package/dist/copilot/task-event-log.test.js

@@ -128,6 +128,19 @@ describe("task event log — bus-wired", () => {
         assert.equal(events[0].seq, 1);
         clearTaskLog("task-001");
     });
+    it("does not double-subscribe when initialized twice", () => {
+        const secondShutdown = initTaskEventLog();
+        try {
+            agentEventBus.emit(makeToolCallEvent({ sessionId: "task-idempotent", kind: "tool_start", seq: 1, toolName: "view" }));
+            const events = getTaskLogEvents("task-idempotent");
+            assert.equal(events.length, 1);
+            assert.equal(events[0].toolName, "view");
+        }
+        finally {
+            secondShutdown();
+            clearTaskLog("task-idempotent");
+        }
+    });
     it("accumulates multiple events in order", () => {
         agentEventBus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_start", seq: 1, toolName: "bash" }));
         agentEventBus.emit(makeToolCallEvent({ sessionId: "task-002", kind: "tool_complete", seq: 2, summary: "ok" }));