chapterhouse 0.3.12 → 0.3.14

package/dist/copilot/orchestrator.test.js

@@ -68,7 +68,6 @@ async function loadOrchestratorModule(t, overrides = {}) {
         config: {
             copilotModel: "missing-model",
             selfEditEnabled: true,
-            squadEnabled: false,
         },
         routeResults: [],
         routerArgs: [],
@@ -85,8 +84,6 @@ async function loadOrchestratorModule(t, overrides = {}) {
         ensureDefaultAgentsCalls: 0,
         loadAgentsCalls: 0,
         setActiveAgentCalls: [],
-        setChannelProjectCalls: [],
-        channelProjects: new Map(),
         parseMentionArgs: [],
         buildAgentRosterArgs: [],
         clearActiveTasksCalls: 0,
@@ -142,22 +139,6 @@ async function loadOrchestratorModule(t, overrides = {}) {
             resetClient: async () => client,
         },
     });
-    t.mock.module("../squad/context.js", {
-        namedExports: {
-            setChannelProject: (channelKey, projectRoot) => {
-                state.setChannelProjectCalls.push({ channelKey, projectRoot });
-                state.channelProjects.set(channelKey, projectRoot);
-            },
-            getChannelProject: (channelKey) => state.channelProjects.get(channelKey),
-            normalizeProjectPath: (projectPath) => `normalized:${projectPath}`,
-        },
-    });
-    t.mock.module("../squad/charter.js", {
-        namedExports: {
-            buildSquadSystemPrefix: async (_projectRoot) => "# Squad context\n",
-            getSquadCoordinatorSystemMessage: async (_projectRoot) => "# Squad Coordinator\nYou are the Squad coordinator.\n",
-        },
-    });
     t.mock.module("../store/db.js", {
         namedExports: {
             logConversation: (role, content, source) => {
@@ -184,7 +165,6 @@ async function loadOrchestratorModule(t, overrides = {}) {
                 }),
                 transaction: (fn) => fn,
             }),
-            bumpProjectLastUsed: (_projectRoot) => { },
             appendTaskEvent: (taskId, kind, toolName, summary) => {
                 const seq = (state.taskEvents.get(taskId)?.length ?? 0) + 1;
                 const ev = { id: seq, taskId, seq, ts: Date.now(), kind, toolName, summary };
@@ -281,7 +261,6 @@ test("sendToOrchestrator logs both sides, remembers web auth context, and record
         config: {
             copilotModel: "claude-sonnet-4.6",
             selfEditEnabled: true,
-            squadEnabled: false,
         },
         routeResults: [
             {
@@ -337,7 +316,6 @@ test("@mentions route through the orchestrator session without invoking the mode
         config: {
             copilotModel: "claude-sonnet-4.6",
             selfEditEnabled: true,
-            squadEnabled: false,
         },
         parseMentionResult: { agentSlug: "designer", message: "polish the landing page" },
         sendResult: "Delegated",
@@ -355,48 +333,11 @@ test("@mentions route through the orchestrator session without invoking the mode
     assert.deepEqual(state.routerArgs, []);
     assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] polish the landing page" }]);
 });
-test("web projectPath activates squad context, rebuilds the orchestrator roster, and routes mentions per connection", async (t) => {
-    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
-        config: {
-            copilotModel: "claude-sonnet-4.6",
-            selfEditEnabled: true,
-            squadEnabled: true,
-        },
-        parseMentionResult: { agentSlug: "ripley", message: "audit the squad routing" },
-        sendResult: "Squad handled it",
-    });
-    await orchestrator.initOrchestrator(client);
-    const final = await new Promise((resolve) => {
-        orchestrator.sendToOrchestrator("@ripley audit the squad routing", { type: "web", connectionId: "conn-squad", projectPath: "~/workspace/mock-squad" }, (text, done) => {
-            if (done) {
-                resolve(text);
-            }
-        });
-    });
-    assert.equal(final, "Squad handled it");
-    assert.deepEqual(state.setChannelProjectCalls, [{
-            channelKey: "conn-squad",
-            projectRoot: "normalized:~/workspace/mock-squad",
-        }]);
-    assert.deepEqual(state.parseMentionArgs.at(-1), {
-        text: "@ripley audit the squad routing",
-        projectRoot: "normalized:~/workspace/mock-squad",
-    });
-    assert.deepEqual(state.setActiveAgentCalls, [{ channelKey: "conn-squad", agentSlug: "ripley" }]);
-    assert.deepEqual(state.sessionPrompts.at(-1), [{ prompt: "[via web] audit the squad routing" }][0]);
-    // Project sessions use getSquadCoordinatorSystemMessage (not buildAgentRoster) — only the default
-    // session init triggers a buildAgentRoster call.
-    assert.deepEqual(state.buildAgentRosterArgs, [undefined]);
-    assert.equal(state.createSessionCalls.length, 2);
-    assert.equal(typeof orchestrator.getCurrentChannelKey, "function");
-    assert.equal(orchestrator.getCurrentChannelKey(), undefined);
-});
 test("feedAgentResult injects a background completion turn and proactively notifies listeners", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         config: {
             copilotModel: "claude-sonnet-4.6",
             selfEditEnabled: true,
-            squadEnabled: false,
         },
         sendResult: "Agent complete",
     });
@@ -427,7 +368,6 @@ test("cancelCurrentMessage aborts the active request and agent helpers expose ru
         config: {
             copilotModel: "claude-sonnet-4.6",
             selfEditEnabled: true,
-            squadEnabled: false,
         },
         sendResult: "__PENDING__",
     });
@@ -449,85 +389,99 @@ test("cancelCurrentMessage aborts the active request and agent helpers expose ru
     await orchestrator.shutdownAgents();
     assert.equal(state.clearActiveTasksCalls, 1);
 });
-test("feedAgentResult routes to project session when task session_key is a project key", async (t) => {
+// ---------------------------------------------------------------------------
+// REGRESSION: #35 — per-session isolation
+// This test would have caught the original bug. With a global shared queue,
+// session B's message would queue behind session A's blocking turn and the
+// Promise.race would time out. With per-session queues, session B completes
+// independently.
+// ---------------------------------------------------------------------------
+test("regression #35: session A blocking does not delay session B (concurrent sessions)", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
-        config: {
-            copilotModel: "claude-sonnet-4.6",
-            selfEditEnabled: true,
-            squadEnabled: false,
-        },
-        sendResult: "Routed correctly",
-        taskSessionKeys: new Map([["proj-task-1", "project:/repo/squad"]]),
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false },
+        sendResult: "__PENDING__", // session A will block in sendAndWait
     });
     await orchestrator.initOrchestrator(client);
-    // initOrchestrator creates the default session — record that baseline
-    const sessionsAfterInit = state.createSessionCalls.length;
-    const notified = new Promise((resolve) => {
-        orchestrator.setProactiveNotify(resolve);
+    // Send to session A (explicit sessionKey "chat:a") — parks because sendResult is __PENDING__
+    const sessionACallbacks = [];
+    orchestrator.sendToOrchestrator("slow request to session A", { type: "background", sessionKey: "chat:a" }, (text, done) => sessionACallbacks.push({ text, done }));
+    // Yield to event loop so session A's drain loop runs and parks in sendAndWait
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    // Now session A is blocked inside sendAndWait. Switch sendResult so session B
+    // gets a fast response. Session A's pending reject is still captured in its closure.
+    state.sendResult = "session B complete";
+    // Send to session B (different sessionKey) — must complete without waiting for session A
+    const sessionBDone = new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("quick request to session B", { type: "background", sessionKey: "chat:b" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
     });
-    // Task belongs to the project session; feedAgentResult must open that session
-    orchestrator.feedAgentResult("proj-task-1", "coder", "Squad feature done");
-    assert.equal(await notified, "Routed correctly");
-    // A second createSession call proves the orchestrator opened a fresh project session
-    // rather than reusing the already-open default session.
-    assert.equal(state.createSessionCalls.length, sessionsAfterInit + 1, "feedAgentResult should spin up a project session, not recycle the default one");
-    // The prompt must reference the task and agent
-    const prompt = state.sessionPrompts.at(-1);
-    assert.ok(prompt?.prompt.includes("proj-task-1"), "prompt should reference the task id");
-    assert.ok(prompt?.prompt.includes("coder"), "prompt should reference the agent slug");
-    assert.ok(prompt?.prompt.includes("Squad feature done"), "prompt should include the result text");
+    // Session B must respond before the deadline (session A is still blocked indefinitely)
+    const result = await Promise.race([
+        sessionBDone,
+        new Promise((_, reject) => setTimeout(() => reject(new Error("session B was blocked by session A — global queue bug reproduced")), 300)),
+    ]);
+    assert.equal(result, "session B complete", "session B must resolve independently of blocked session A");
+    assert.equal(sessionACallbacks.length, 0, "session A must still be pending (no response yet)");
+    // Clean up: reject session A's pending promise so the test can finish
+    state.pendingReject?.(new Error("test teardown"));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 });
 // ---------------------------------------------------------------------------
-// Sprint 3, Item 5 — orchestrator lifecycle: project-session cancel/shutdown
+// Orchestrator lifecycle: shutdown clears all sessions
 // ---------------------------------------------------------------------------
-test("cancelCurrentMessage targets the active project session, not the default session", async (t) => {
-    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
-        config: {
-            copilotModel: "claude-sonnet-4.6",
-            selfEditEnabled: false,
-            // squadEnabled true so sendToOrchestrator derives a "project:…" session key
-            squadEnabled: true,
-        },
-        sendResult: "__PENDING__",
-    });
-    await orchestrator.initOrchestrator(client);
-    // Default session was created during init
-    const sessionsAfterInit = state.createSessionCalls.length;
-    // Send to a project path — this should open a separate project session
-    orchestrator.sendToOrchestrator("scaffold the new API", { type: "web", connectionId: "conn-project", projectPath: "/repo/squad-proj" }, () => { });
-    // Yield to the event loop so the project session is created and the
-    // sendAndWait promise is parked in PENDING state.
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    assert.equal(state.createSessionCalls.length, sessionsAfterInit + 1, "a distinct project session must be created, separate from the default session");
-    // Cancel should abort the active project session, not the default one
-    const cancelled = await orchestrator.cancelCurrentMessage();
-    assert.equal(cancelled, true, "cancelCurrentMessage should return true when an active request was aborted");
-    assert.equal(state.abortCalls, 1, "exactly one abort — on the in-flight project session");
-});
 test("shutdownAgents disconnects all sessions, clears maps, and clears active tasks", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
-        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false, squadEnabled: true },
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false },
         sendResult: "ok",
     });
     // Init default session
     await orchestrator.initOrchestrator(client);
     const sessionsAfterInit = state.createSessionCalls.length;
-    // Trigger a project session by sending a message with a projectPath
-    orchestrator.sendToOrchestrator("hello from project", { type: "web", connectionId: "conn-1", projectPath: "/fake/project" }, (_text, _done) => { });
+    // Trigger a second session by sending a background message with a distinct sessionKey
+    orchestrator.sendToOrchestrator("hello from session chat:1", { type: "background", sessionKey: "chat:1" }, (_text, _done) => { });
     // Yield so the async session-creation IIFE runs
     await new Promise((resolve) => setTimeout(resolve, 10));
-    assert.ok(state.createSessionCalls.length > sessionsAfterInit, "a project session should have been created");
+    assert.ok(state.createSessionCalls.length > sessionsAfterInit, "a second session should have been created");
     // Shutdown — both sessions should be disconnected
     await orchestrator.shutdownAgents();
-    assert.equal(state.disconnectCalls, 2, "disconnect must be called once per session (default + project)");
+    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");
     // 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)");
 });
+// ---------------------------------------------------------------------------
+// feedAgentResult routes to the correct non-default session
+// ---------------------------------------------------------------------------
+test("feedAgentResult routes to a non-default session when the task's session_key is non-default", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false },
+        sendResult: "Routed correctly",
+        taskSessionKeys: new Map([["chat-task-1", "chat:abc"]]),
+    });
+    await orchestrator.initOrchestrator(client);
+    // initOrchestrator creates the default session — record that baseline
+    const sessionsAfterInit = state.createSessionCalls.length;
+    const notified = new Promise((resolve) => {
+        orchestrator.setProactiveNotify(resolve);
+    });
+    // Task belongs to "chat:abc" session; feedAgentResult must open that session
+    orchestrator.feedAgentResult("chat-task-1", "coder", "Feature done");
+    assert.equal(await notified, "Routed correctly");
+    // A second createSession call proves the orchestrator opened a fresh non-default session
+    // rather than reusing the already-open default session.
+    assert.equal(state.createSessionCalls.length, sessionsAfterInit + 1, "feedAgentResult should spin up a non-default session, not recycle the default one");
+    // The prompt must reference the task and agent
+    const prompt = state.sessionPrompts.at(-1);
+    assert.ok(prompt?.prompt.includes("chat-task-1"), "prompt should reference the task id");
+    assert.ok(prompt?.prompt.includes("coder"), "prompt should reference the agent slug");
+    assert.ok(prompt?.prompt.includes("Feature done"), "prompt should include the result text");
+});
 test("ensureOrchestratorSession cleans up in-flight promise on session creation failure", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
-        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false, squadEnabled: false },
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false },
         // Non-recoverable error so the retry loop exits immediately
         createSessionError: "fatal: SDK host permanently unavailable",
         sendResult: "unreachable",
@@ -552,13 +506,13 @@ test("ensureOrchestratorSession cleans up in-flight promise on session creation
     assert.ok(state.createSessionCalls.length > countAfterFirst, "a second message must trigger a new createSession attempt, proving sessionCreatePromises was cleaned up");
 });
 // ---------------------------------------------------------------------------
-// S5-01: SDK subagent events persist to agent_tasks (squad dispatch tracking)
+// S5-01: SDK subagent events persist to agent_tasks (agent dispatch tracking)
 // Root cause: executeOnSession subscribed to subagent.* events for the UI
 // activity feed but never wrote rows to agent_tasks. Workers tab only reads
-// agent_tasks, so squad coordinator dispatches were invisible.
+// agent_tasks, so agent dispatches were invisible.
 // Fix: unconditional DB subscriptions in executeOnSession write/update rows.
 // ---------------------------------------------------------------------------
-test("S5-01: subagent.started event inserts a squad row into agent_tasks", async (t) => {
+test("S5-01: subagent.started event inserts an adhoc row into agent_tasks", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         sendResult: "__PENDING__",
     });
@@ -571,7 +525,7 @@ test("S5-01: subagent.started event inserts a squad row into agent_tasks", async
     // Yield so the async IIFE reaches sendAndWait (which is pending)
     await new Promise((resolve) => setTimeout(resolve, 10));
     assert.ok(state.lastSession, "FakeSession should have been created");
-    // Fire a subagent.started event — simulates the SDK's task tool starting a squad dispatch
+    // Fire a subagent.started event — simulates the SDK's task tool starting an agent dispatch
     state.lastSession.emit("subagent.started", {
         toolCallId: "subagent-call-001",
         agentName: "Kaylee",
@@ -581,7 +535,7 @@ test("S5-01: subagent.started event inserts a squad row into agent_tasks", async
     // The handler is synchronous — DB write should be in state.dbWrites immediately
     const insertWrite = state.dbWrites.find((w) => w.sql.includes("INSERT") && w.sql.includes("agent_tasks"));
     assert.ok(insertWrite, "subagent.started must INSERT a row into agent_tasks");
-    assert.ok((insertWrite.sql + JSON.stringify(insertWrite.args)).includes("squad"), "inserted row must carry source='squad'");
+    assert.ok((insertWrite.sql + JSON.stringify(insertWrite.args)).includes("adhoc"), "inserted row must carry source='adhoc'");
     assert.ok(JSON.stringify(insertWrite.args).includes("subagent-call-001"), "task_id must equal the toolCallId from the event");
     // Resolve the pending sendAndWait so the test can clean up
     state.pendingReject?.(new Error("test teardown"));
@@ -637,45 +591,6 @@ test("S5-01: subagent.failed event updates agent_tasks status to error", async (
     state.pendingReject?.(new Error("test teardown"));
 });
 // ---------------------------------------------------------------------------
-// REGRESSION: #35 — per-session isolation
-// This test would have caught the original bug. With a global shared queue,
-// session B's message would queue behind session A's blocking turn and the
-// Promise.race would time out. With per-session queues, session B completes
-// independently.
-// ---------------------------------------------------------------------------
-test("regression #35: session A blocking does not delay session B (concurrent sessions)", async (t) => {
-    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
-        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false, squadEnabled: true },
-        sendResult: "__PENDING__", // session A will block in sendAndWait
-    });
-    await orchestrator.initOrchestrator(client);
-    // Send to session A (project /project/a) — parks because sendResult is __PENDING__
-    const sessionACallbacks = [];
-    orchestrator.sendToOrchestrator("slow request to project A", { type: "web", connectionId: "conn-a", projectPath: "/project/a" }, (text, done) => sessionACallbacks.push({ text, done }));
-    // Yield to event loop so session A's drain loop runs and parks in sendAndWait
-    await new Promise((resolve) => setTimeout(resolve, 20));
-    // Now session A is blocked inside sendAndWait. Switch sendResult so session B
-    // gets a fast response. session A's pending reject is still captured in its closure.
-    state.sendResult = "session B complete";
-    // Send to session B (different project) — must complete without waiting for session A
-    const sessionBDone = new Promise((resolve) => {
-        orchestrator.sendToOrchestrator("quick request to project B", { type: "web", connectionId: "conn-b", projectPath: "/project/b" }, (text, done) => {
-            if (done)
-                resolve(text);
-        });
-    });
-    // Session B must respond before the deadline (session A is still blocked indefinitely)
-    const result = await Promise.race([
-        sessionBDone,
-        new Promise((_, reject) => setTimeout(() => reject(new Error("session B was blocked by session A — global queue bug reproduced")), 300)),
-    ]);
-    assert.equal(result, "session B complete", "session B must resolve independently of blocked session A");
-    assert.equal(sessionACallbacks.length, 0, "session A must still be pending (no response yet)");
-    // Clean up: reject session A's pending promise so the test can finish
-    state.pendingReject?.(new Error("test teardown"));
-    await new Promise((resolve) => setTimeout(resolve, 10));
-});
-// ---------------------------------------------------------------------------
 // #81 — task spawn args (name/description) must win over SDK agent_type fields
 // Root cause: subagent.started only carries agent_type boilerplate. The actual
 // spawn params (name, description) arrive earlier via tool.execution_start for

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

@@ -3,7 +3,7 @@
  *
  * Maintains a `Map<taskId, RingBuffer<TaskEvent>>` in the daemon process,
  * capped at 500 events per task. Subscribes to the process-wide
- * `squadEventBus` for `session:tool_call` events so the ring buffer stays
+ * `agentEventBus` for `session:tool_call` events so the ring buffer stays
  * in sync without the caller needing to wire anything extra.
  *
  * Consumers:
@@ -21,7 +21,7 @@
  *
  * @module copilot/task-event-log
  */
-import { squadEventBus } from "./squad-event-bus.js";
+import { agentEventBus } from "./agent-event-bus.js";
 import { RingBuffer } from "./ring-buffer.js";
 // ---------------------------------------------------------------------------
 // Ring buffer — re-export so existing imports stay compatible
@@ -59,11 +59,11 @@ function notifyListeners(taskId, event) {
 // Public API
 // ---------------------------------------------------------------------------
 /**
- * Subscribe to the squadEventBus and maintain the ring buffer.
+ * Subscribe to the agent event bus and maintain the ring buffer.
  * Call once from initOrchestrator(). Returns an unsub / cleanup function.
  */
 export function initTaskEventLog() {
-    const unsubToolCall = squadEventBus.subscribe("session:tool_call", (event) => {
+    const unsubToolCall = agentEventBus.subscribe("session:tool_call", (event) => {
         const taskId = event.sessionId;
         if (!taskId)
             return;
@@ -81,7 +81,7 @@ export function initTaskEventLog() {
         buf.push(taskEvent);
         notifyListeners(taskId, taskEvent);
     });
-    const unsubDestroyed = squadEventBus.subscribe("session:destroyed", (event) => {
+    const unsubDestroyed = agentEventBus.subscribe("session:destroyed", (event) => {
         if (event.sessionId)
             clearTaskLog(event.sessionId);
     });