chapterhouse 0.3.13 → 0.3.14

package/dist/copilot/orchestrator.js

@@ -1,7 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { approveAll } from "@github/copilot-sdk";
-import { initHookPipeline, createSessionHooks } from "./hooks.js";
 import { createTools } from "./tools.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
 import { CHAPTERHOUSE_VERSION } from "../version.js";
@@ -9,16 +8,14 @@ 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, getDb, bumpProjectLastUsed, appendTaskEvent } from "../store/db.js";
+import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, getTaskSessionKey, getDb, appendTaskEvent } 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";
 import { childLogger } from "../util/logger.js";
-import { squadEventBus } from "./squad-event-bus.js";
+import { agentEventBus } from "./agent-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";
@@ -56,7 +53,7 @@ export function getLastRouteResult() {
     return lastRouteResult;
 }
 export function subscribeTaskEvents(taskId, listener) {
-    return squadEventBus.subscribe("session:tool_call", (event) => {
+    return agentEventBus.subscribe("session:tool_call", (event) => {
         if (event.sessionId !== taskId)
             return;
         const p = event.payload;
@@ -70,7 +67,7 @@ export function subscribeTaskEvents(taskId, listener) {
     });
 }
 function emitTaskEvent(taskId, event) {
-    void squadEventBus.emit({
+    void agentEventBus.emit({
         type: "session:tool_call",
         sessionId: taskId,
         payload: {
@@ -140,11 +137,11 @@ function getSessionConfig() {
     const skillDirectories = getSkillDirectories();
     return { tools, mcpServers, skillDirectories };
 }
-function getSystemMessageOptions(memorySummary, projectRoot) {
+function getSystemMessageOptions(memorySummary) {
     return {
         selfEditEnabled: config.selfEditEnabled,
         memorySummary: memorySummary || undefined,
-        agentRoster: buildAgentRoster(projectRoot),
+        agentRoster: buildAgentRoster(),
         userContext: currentUserContext,
     };
 }
@@ -234,17 +231,11 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         backgroundCompactionThreshold: 0.80,
         bufferExhaustionThreshold: 0.95,
     };
-    let systemMessageContent;
-    if (isProjectSession && projectRoot) {
-        systemMessageContent = await getSquadCoordinatorSystemMessage(projectRoot);
-    }
-    else {
-        const memorySummary = getWikiSummary();
-        systemMessageContent = getOrchestratorSystemMessage({
-            ...getSystemMessageOptions(memorySummary, isProjectSession ? projectRoot : undefined),
-            version: CHAPTERHOUSE_VERSION,
-        });
-    }
+    const memorySummary = getWikiSummary();
+    const systemMessageContent = getOrchestratorSystemMessage({
+        ...getSystemMessageOptions(memorySummary),
+        version: CHAPTERHOUSE_VERSION,
+    });
     const stored = getCopilotSession(sessionKey);
     const savedSessionId = stored?.copilotSessionId ?? (sessionKey === "default" ? getState(ORCHESTRATOR_SESSION_KEY) : undefined);
     if (savedSessionId) {
@@ -259,7 +250,6 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 mcpServers,
                 skillDirectories,
                 onPermissionRequest: approveAll,
-                hooks: createSessionHooks("orchestrator"),
                 infiniteSessions,
             });
             log.info({ sessionKey }, "Session resumed successfully");
@@ -285,7 +275,6 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         mcpServers,
         skillDirectories,
         onPermissionRequest: approveAll,
-        hooks: createSessionHooks("orchestrator"),
         infiniteSessions,
     });
     log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
@@ -299,9 +288,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
 }
 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.
+    // Initialize per-task ring buffer — subscribes to agentEventBus for session:tool_call events.
     initTaskEventLog();
     // (Re-)create the registry — supports multiple initOrchestrator calls in tests
     if (registry) {
@@ -450,7 +437,7 @@ async function executeOnSession(manager, item) {
                     .replace(/\s+/g, "-");
                 const resolvedDescription = (typeof spawnArgs?.description === "string"
                     ? spawnArgs.description
-                    : data.agentDescription || data.agentDisplayName || `Squad dispatch: ${agentSlug}`).slice(0, 500);
+                    : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
                 item.onActivity({
                     kind: "subagent_started",
                     toolCallId: data.toolCallId,
@@ -521,10 +508,10 @@ async function executeOnSession(manager, item) {
                     .replace(/\s+/g, "-");
                 const description = (typeof spawnArgs?.description === "string"
                     ? spawnArgs.description
-                    : data.agentDescription || data.agentDisplayName || `Squad dispatch: ${agentSlug}`).slice(0, 500);
-                db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'squad')`).run(data.toolCallId, agentSlug, description, item.sourceChannel || null, sessionKey);
+                    : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
+                db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'adhoc')`).run(data.toolCallId, agentSlug, description, item.sourceChannel || null, sessionKey);
                 activeSubagentTaskIds.add(data.toolCallId);
-                void squadEventBus.emit({
+                void agentEventBus.emit({
                     type: "session:created",
                     sessionId: data.toolCallId,
                     agentName: agentSlug,
@@ -552,7 +539,7 @@ async function executeOnSession(manager, item) {
                 db.prepare(`UPDATE agent_tasks SET status = 'completed', completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(event.data.toolCallId);
                 const taskId = event.data.toolCallId;
                 const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(taskId);
-                void squadEventBus.emit({
+                void agentEventBus.emit({
                     type: "session:destroyed",
                     sessionId: taskId,
                     agentName: taskRow?.agent_slug,
@@ -580,7 +567,7 @@ async function executeOnSession(manager, item) {
                 activeSubagentTaskIds.delete(data.toolCallId);
                 db.prepare(`UPDATE agent_tasks SET status = 'error', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(data.error || "Subagent failed", data.toolCallId);
                 const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(data.toolCallId);
-                void squadEventBus.emit({
+                void agentEventBus.emit({
                     type: "session:error",
                     sessionId: data.toolCallId,
                     agentName: taskRow?.agent_slug,
@@ -758,20 +745,14 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
     const sourceLabel = source.type === "background" ? "background" : "web";
     logMessage("in", sourceLabel, prompt);
     let sessionKey;
-    if (source.type === "web" && source.projectPath && config.squadEnabled) {
-        sessionKey = "project:" + normalizeProjectPath(source.projectPath);
-        setChannelProject(source.connectionId, normalizeProjectPath(source.projectPath));
-        bumpProjectLastUsed(normalizeProjectPath(source.projectPath));
-    }
-    else if ((source.type === "background" || source.type === "sse-web") && source.sessionKey) {
+    if ((source.type === "background" || source.type === "sse-web") && source.sessionKey) {
         sessionKey = source.sessionKey;
     }
     else {
         sessionKey = "default";
     }
     const channelKey = source.type === "web" ? source.connectionId : "default";
-    const projectRoot = sessionKey.startsWith("project:") ? sessionKey.slice("project:".length) : undefined;
-    const mention = parseAtMention(prompt, projectRoot);
+    const mention = parseAtMention(prompt);
     const targetAgent = mention?.agentSlug;
     const routedPrompt = mention ? mention.message : prompt;
     const taggedPrompt = source.type === "background"

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);
     });