chapterhouse 0.3.12 → 0.3.14

package/README.md

@@ -54,12 +54,6 @@ ADO_ORG=https://dev.azure.com/your-org
 ADO_PROJECT=your-project
 ADO_PAT=your-ado-pat-here
 
-# Optional — Squad (multi-agent team) integration
-ENABLE_SQUAD=1                            # set to 1 to enable squad agent routing
-
-# Optional — periodic decisions→wiki sync (requires ENABLE_SQUAD=1)
-CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS=300000  # default 5 minutes (300 000 ms)
-
 # Optional — logging
 LOG_LEVEL=info   # trace | debug | info | warn | error | fatal | silent (default: info)
                  # Set to "debug" to see chat message content and routing decisions.
@@ -254,69 +248,8 @@ The deployment assets for the shared instance set Entra auth and `CHAPTERHOUSE_M
 | `chapterhouse update --check-only` | Print current/latest version without updating                    |
 | `chapterhouse update --ref <ver>`  | Install a specific version                                       |
 | `chapterhouse daemon <sub>`    | Manage the persistent background service          |
-| `chapterhouse squad init`      | Initialize a new Squad team for this project (guided dialog)     |
-| `chapterhouse squad worktree <sub>` | Manage per-agent git worktrees for concurrent squad work |
 | `chapterhouse help`            | Show available commands                           |
 
-### Squad Init Command
-
-Bootstrap a Squad team for a project that has no `.squad/` directory yet. The command runs an interactive dialog and writes the full `.squad/` scaffold:
-
-```sh
-chapterhouse squad init
-    # Runs the guided dialog: project name, stack, goal, team size, universe.
-    # Proposes a named roster, then writes .squad/ on confirmation.
-
-chapterhouse squad init --force
-    # Re-scaffolds even if .squad/ already exists (overwrites existing files).
-
-chapterhouse squad init --yes
-    # Skip the confirmation prompt (non-interactive / CI mode).
-
-chapterhouse squad init --universe Firefly
-    # Use a specific naming universe instead of the default (Dune).
-    # Available: Dune (default), Firefly, Star Wars, The Matrix, Breaking Bad
-```
-
-**What gets written:**
-
-| Path | Purpose |
-|------|---------|
-| `.squad/team.md` | Roster with `## Members` table (required by GitHub workflows) |
-| `.squad/routing.md` | Task routing rules by role |
-| `.squad/ceremonies.md` | Sprint rhythm and review gates |
-| `.squad/decisions.md` | Append-only decision log |
-| `.squad/agents/{name}/charter.md` | Per-agent charter with project context |
-| `.squad/agents/{name}/history.md` | Per-agent day-1 seed history |
-| `.squad/casting/policy.json` | Universe allowlist and capacity |
-| `.squad/casting/registry.json` | Persistent name registry (cast names survive re-runs) |
-| `.squad/casting/history.json` | Universe assignment audit trail |
-| `.gitattributes` | Union merge rules for append-only Squad files |
-
-**Naming universes:** By default, Squad uses the **Dune** universe (Leto, Jessica, Stilgar, Chani, Gurney, Duncan, …). This is configurable with `--universe` or via the dialog. Scribe and Ralph are always exempt from casting — they keep their names regardless of universe.
-
-### Squad Worktree Commands
-
-Squad agents that work on GitHub issues each get a dedicated git worktree so they never step on each other. The `chapterhouse squad worktree` subcommands manage these worktrees:
-
-```sh
-chapterhouse squad worktree create <agent> <issue> [--base main] [--slug <slug>]
-    # Creates .worktrees/{agent}-{issue}/ and branch squad/{issue}-{slug}
-    # Prints the worktree path to stdout. Reuses existing worktree if present.
-
-chapterhouse squad worktree list
-    # Shows all active squad worktrees: agent, issue, branch, status, path
-
-chapterhouse squad worktree remove <agent> <issue> [--force] [--delete-branch]
-    # Removes a worktree. Refuses if dirty unless --force is passed.
-
-chapterhouse squad worktree prune [--base main] [--dry-run]
-    # Removes all worktrees whose branch has been merged into main.
-    # Skips dirty worktrees with a warning.
-```
-
-**How it works:** Worktrees live at `.worktrees/{agent}-{issue}/` inside the repo (gitignored). The Squad coordinator creates each worktree *before* spawning an agent and passes the path as `WORKTREE_PATH` in the spawn prompt. Agents do all their work—reads, edits, commits—inside that path. No agent ever runs `git checkout` in a working tree it doesn't own.
-
 ### Flags
 
 | Flag          | Description                                                                      |
@@ -374,7 +307,7 @@ Chapterhouse enforces a **3-layer timing contract** so in-flight LLM streams can
 
 #### Session lifecycle
 
-Each conversation window (browser tab, terminal session, squad worktree) maps to a separate `SessionManager` with its own queue and SDK session. Two env vars control how long sessions live:
+Each conversation window (browser tab, terminal session) maps to a separate `SessionManager` with its own queue and SDK session. Two env vars control how long sessions live:
 
 | Config | What it controls | Default |
 |--------|-----------------|---------|
@@ -546,7 +479,7 @@ git push origin main --follow-tags
 
 `npm version` handles the commit and tag automatically. `prepublishOnly` runs `npm run build` before publish so the tarball always contains a fresh build. If you don't have CI set up, publish manually with `npm publish` after the tag push.
 
-> **Pre-release gate:** `preversion` runs `npm run release:check` automatically before any `npm version` call. The script aborts with a clear error if the git working tree is dirty. Stash or commit all changes (including `.squad/` metadata edits) before bumping the version.
+> **Pre-release gate:** `preversion` runs `npm run release:check` automatically before any `npm version` call. The script aborts with a clear error if the git working tree is dirty. Stash or commit all changes before bumping the version.
 
 ### Commit message convention
 

package/dist/api/server.js

@@ -1,12 +1,12 @@
 import cors from "cors";
 import express from "express";
 import helmet from "helmet";
-import { existsSync, statSync, readdirSync } from "fs";
+import { existsSync, statSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
 import { sendToOrchestrator, interruptCurrentTurn, enqueueForSse, getAgentInfo, cancelCurrentMessage, getLastRouteResult, getCurrentSessionKey } from "../copilot/orchestrator.js";
-import { squadEventBus } from "../copilot/squad-event-bus.js";
+import { agentEventBus } from "../copilot/agent-event-bus.js";
 import { getAgentRegistry } from "../copilot/agents.js";
 import { config, persistModel } from "../config.js";
 import { getRouterConfig, updateRouterConfig } from "../copilot/router.js";
@@ -20,17 +20,14 @@ import { withWikiWrite } from "../wiki/lock.js";
 import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { API_TOKEN_PATH, resolveWikiRelativePath } from "../paths.js";
-import { getDb, getSessionMessages, getTaskEvents, normalizeSqliteTsToIso } from "../store/db.js";
+import { getDb, getSessionMessages, getTaskEvents } from "../store/db.js";
 import { getTaskLogEvents, subscribeTaskLog } from "../copilot/task-event-log.js";
 import { subscribeSession, getSessionEventsFromDb, oldestSessionSeq, } from "../copilot/turn-event-log.js";
 import { getStatus, onStatusChange } from "../status.js";
 import { formatSseData, formatSseEvent } from "./sse.js";
-import { syncDecisionsFileToWiki } from "../squad/mirror.js";
-import { resolveProjectSquad } from "../squad/discovery.js";
 import { assertAuthenticationConfigured, createHealthPayload, createPublicConfigPayload, buildHistoryEntries, getDisplayHost, resolveApiToken, shouldServeSpaPath, } from "./server-runtime.js";
 import { BadRequestError, ForbiddenError, InternalServerError, NotFoundError, apiNotFoundHandler, asBadRequest, createApiErrorHandler, parseRequest, } from "./errors.js";
 import { childLogger } from "../util/logger.js";
-import { getRalphStatus, startRalph, stopRalph, getRalphQueue } from "./ralph.js";
 const log = childLogger("server");
 void searchIndex; // re-exported by index-manager; reference here documents the dep
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -249,7 +246,7 @@ app.get("/api/agents", (_req, res) => {
     res.json(getAgentInfo());
 });
 // List all workers: reads from SQLite agent_tasks (last 24 hours) so completed
-// squad-dispatched tasks remain visible after they finish, not just in-flight ones.
+// dispatched subagents remain visible after they finish, not just in-flight ones.
 app.get("/api/workers", (_req, res) => {
     const rows = getDb()
         .prepare(`SELECT task_id, agent_slug, description, status, started_at, completed_at
@@ -341,13 +338,13 @@ app.get("/api/workers/:taskId/events/stream", (req, res) => {
     });
 });
 // ---------------------------------------------------------------------------
-// Global squad EventBus SSE stream — thin pass-through of SDK SquadEvents.
+// Global agent EventBus SSE stream — thin pass-through of AgentEvents.
 // Replaces the 4-second poll in the Workers frontend: clients subscribe once
 // and receive push notifications on session:created / session:destroyed /
 // session:error so the worker list updates in real time.
 // Chat-specific events (delta, message, queued) are NOT emitted here.
 // ---------------------------------------------------------------------------
-app.get("/api/squad/stream", (req, res) => {
+app.get("/api/agents/stream", (req, res) => {
     res.writeHead(200, {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
@@ -355,58 +352,14 @@ app.get("/api/squad/stream", (req, res) => {
     });
     res.write(formatSseData({ type: "connected" }));
     const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
-    const unsub = squadEventBus.subscribeAll((event) => {
-        res.write(formatSseData({ type: "squad_event", squadEvent: event }));
+    const unsub = agentEventBus.subscribeAll((event) => {
+        res.write(formatSseData({ type: "agent_event", agentEvent: event }));
     });
     req.on("close", () => {
         clearInterval(heartbeat);
         unsub();
     });
 });
-// ---------------------------------------------------------------------------
-// Ralph watch panel endpoints — /api/squad/ralph/*
-// ---------------------------------------------------------------------------
-const ralphStartSchema = z.object({
-    projectRoot: z.string().min(1, "projectRoot is required"),
-    interval: z.number().int().min(1).max(120).default(10),
-}).strict();
-app.get("/api/squad/ralph/status", (_req, res) => {
-    res.json(getRalphStatus());
-});
-app.post("/api/squad/ralph/start", (req, res) => {
-    const { projectRoot, interval } = parseRequest(ralphStartSchema, req.body);
-    const result = startRalph(projectRoot, interval);
-    if (!result.started) {
-        res.status(409).json({ error: result.error });
-        return;
-    }
-    res.status(201).json({ pid: result.pid, projectRoot, interval });
-});
-app.post("/api/squad/ralph/stop", (_req, res) => {
-    const result = stopRalph();
-    if (!result.stopped) {
-        res.status(409).json({ error: result.error });
-        return;
-    }
-    res.json({ stopped: true });
-});
-app.get("/api/squad/ralph/queue", async (req, res) => {
-    const projectRoot = Array.isArray(req.query.projectRoot)
-        ? req.query.projectRoot[0]
-        : req.query.projectRoot;
-    if (!projectRoot || typeof projectRoot !== "string") {
-        res.status(400).json({ error: "Missing required query param: projectRoot" });
-        return;
-    }
-    try {
-        const issues = await getRalphQueue(projectRoot);
-        res.json({ projectRoot, issues });
-    }
-    catch (err) {
-        log.warn({ err: err instanceof Error ? err.message : err }, "getRalphQueue failed");
-        res.status(502).json({ error: err instanceof Error ? err.message : "gh issue list failed" });
-    }
-});
 app.get("/stream", (req, res) => {
     const connectionId = `web-${++connectionCounter}`;
     res.writeHead(200, {
@@ -644,6 +597,7 @@ if (config.chatSseEnabled) {
         };
         // If Last-Event-ID is present and the session ring buffer doesn't cover it,
         // fall back to SQLite for replay of completed turns.
+        let replayHighSeq = lastSeq;
         if (lastSeq !== undefined) {
             const oldestBuf = oldestSessionSeq(sessionKey);
             const bufferMissesRange = oldestBuf === undefined || oldestBuf > lastSeq + 1;
@@ -652,13 +606,17 @@ if (config.chatSseEnabled) {
                 const dbEvents = getSessionEventsFromDb(sessionKey, lastSeq);
                 for (const e of dbEvents) {
                     sendEvent(e, e._seq);
+                    if (replayHighSeq === undefined || e._seq > replayHighSeq)
+                        replayHighSeq = e._seq;
                 }
             }
         }
-        // Subscribe to session events (replays ring buffer for afterSeq, then live)
+        // Subscribe to session events (replays ring buffer for afterSeq, then live).
+        // Use replayHighSeq (not lastSeq) so ring-buffer replay starts after any DB
+        // events we already sent — avoids double-replay overlap (Fix 5).
         const unsub = subscribeSession(sessionKey, (e) => {
             sendEvent(e, e._seq);
-        }, lastSeq);
+        }, replayHighSeq);
         // Send connected event
         res.write(`: connected session=${sessionKey}\n\n`);
         // Keep-alive every 15 s
@@ -842,106 +800,6 @@ app.post("/api/restart", (_req, res) => {
     }, 500);
 });
 // ---------------------------------------------------------------------------
-// Projects (Squad integration)
-// ---------------------------------------------------------------------------
-const projectRegisterSchema = z.object({
-    projectRoot: requiredString("projectRoot must be a non-empty string"),
-}).strict();
-/**
- * Count squad agents on disk for a project.
- * Authoritative source: each subdirectory of <projectRoot>/.squad/agents/ that
- * contains a charter.md is one agent.  Never relies on the SQLite cache so the
- * badge is always accurate even before the cache is warm.
- */
-function countAgentsOnDisk(projectRoot) {
-    const agentsDir = join(projectRoot, ".squad", "agents");
-    if (!existsSync(agentsDir))
-        return 0;
-    try {
-        return readdirSync(agentsDir).filter((entry) => {
-            try {
-                return statSync(join(agentsDir, entry)).isDirectory() &&
-                    existsSync(join(agentsDir, entry, "charter.md"));
-            }
-            catch {
-                return false;
-            }
-        }).length;
-    }
-    catch {
-        return 0;
-    }
-}
-app.get("/api/projects", (_req, res) => {
-    if (!config.squadEnabled) {
-        res.status(503).json({ error: "Squad integration is disabled. Set ENABLE_SQUAD=1 to enable." });
-        return;
-    }
-    const db = getDb();
-    const rows = db.prepare(`
-    SELECT project_root, squad_dir, loaded_at, last_used_at
-    FROM project_squads
-    WHERE registered = 1
-    ORDER BY COALESCE(last_used_at, 0) DESC
-  `).all();
-    res.json(rows.map((r) => ({
-        projectRoot: r.project_root,
-        squadDir: r.squad_dir,
-        // Count from live filesystem — authoritative per Squad SDK rule: repo files win over cache.
-        agentCount: countAgentsOnDisk(r.project_root),
-        loadedAt: normalizeSqliteTsToIso(r.loaded_at),
-        lastUsedAt: r.last_used_at != null ? new Date(r.last_used_at).toISOString() : undefined,
-    })));
-});
-app.post("/api/projects", async (req, res) => {
-    if (!config.squadEnabled) {
-        res.status(503).json({ error: "Squad integration is disabled. Set ENABLE_SQUAD=1 to enable." });
-        return;
-    }
-    const { projectRoot } = parseRequest(projectRegisterSchema, req.body);
-    if (!existsSync(projectRoot)) {
-        throw new BadRequestError(`Directory not found: ${projectRoot}`);
-    }
-    const squadDir = join(projectRoot, ".squad");
-    if (!existsSync(squadDir)) {
-        res.status(400).json({ error: "No .squad directory found at this path" });
-        return;
-    }
-    const db = getDb();
-    db.prepare(`INSERT OR REPLACE INTO project_squads (project_root, squad_dir, team_dir, mode, registered) VALUES (?, ?, ?, 'local', 1)`)
-        .run(projectRoot, squadDir, squadDir);
-    // Fire-and-forget: sync decisions.md to the wiki. Non-fatal if it fails.
-    syncDecisionsFileToWiki(projectRoot).then(result => {
-        if (result) {
-            log.info({ entriesSynced: result.entriesSynced, projectRoot }, "Synced squad decisions to wiki");
-        }
-    }).catch(err => {
-        log.warn({ err: err instanceof Error ? err.message : err }, "syncDecisionsFileToWiki failed during registration (non-fatal)");
-    });
-    // Fire-and-forget: populate squad_agents cache from disk so future queries have
-    // something to work with (non-fatal — GET /api/projects counts live from disk anyway).
-    resolveProjectSquad(projectRoot).catch(err => {
-        log.warn({ err: err instanceof Error ? err.message : err }, "resolveProjectSquad failed during registration (non-fatal)");
-    });
-    res.status(201).json({ projectRoot, message: "Project registered successfully" });
-});
-app.delete("/api/projects/:projectRoot", (req, res) => {
-    if (!config.squadEnabled) {
-        res.status(503).json({ error: "Squad integration is disabled. Set ENABLE_SQUAD=1 to enable." });
-        return;
-    }
-    const raw = Array.isArray(req.params.projectRoot) ? req.params.projectRoot[0] : req.params.projectRoot;
-    const projectRoot = decodeURIComponent(raw);
-    const db = getDb();
-    const existing = db.prepare(`SELECT project_root FROM project_squads WHERE project_root = ?`).get(projectRoot);
-    if (!existing) {
-        throw new NotFoundError("Project not found");
-    }
-    db.prepare(`DELETE FROM project_squads WHERE project_root = ?`).run(projectRoot);
-    db.prepare(`DELETE FROM squad_agents WHERE project_root = ?`).run(projectRoot);
-    res.json({ message: "Project removed" });
-});
-// ---------------------------------------------------------------------------
 // Session messages — frontend rehydration on reload
 // ---------------------------------------------------------------------------
 app.get("/api/session/:sessionKey/messages", (req, res) => {

package/dist/api/server.test.js

@@ -124,7 +124,7 @@ async function stopChild(child) {
 // The Copilot SDK's client.start() then blocks the event loop while authenticating,
 // so the HTTP server cannot respond until SDK init completes (~10-20 s depending on
 // session state).  Other modes complete in ~330 ms because the SDK yields quickly.
-// Root cause tracked in .squad/decisions/ for Kaylee (backend fix: lazy-import or
+// Root cause tracked in decisions notes (backend fix: lazy-import or
 // guard env var in daemon.ts).  Interim fix: 30 s timeout for standalone, 10 s elsewhere.
 // Additionally, strip COPILOT_* env vars from the child so it doesn't accidentally
 // piggy-back on the running agent session, which worsens the blocking behaviour.

package/dist/api/turn-sse.integration.test.js

@@ -349,4 +349,40 @@ test("turn-sse: reconnect with Last-Event-ID replays buffered events", async ()
         }
     }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
 });
+// ---------------------------------------------------------------------------
+// Regression test: turn ID contract (Fix 1 — root cause of blank SSE bubbles)
+// ---------------------------------------------------------------------------
+test("turn-sse: turnId returned by POST matches turnId in all SSE events for that turn", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const sessionKey = "test-session-turnid-contract";
+        // Open SSE stream first
+        const sseRes = await fetch(`${baseUrl}/api/sessions/${sessionKey}/stream`, {
+            headers: { Authorization: authHeader, Accept: "text/event-stream" },
+        });
+        assert.ok(sseRes.body, "SSE body must be readable");
+        const reader = createSseReader(sseRes.body);
+        // POST the turn — this is the canonical turnId the frontend tags user messages with
+        const turnRes = await fetch(`${baseUrl}/api/sessions/${sessionKey}/turn`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "turn-id-contract test" }),
+        });
+        assert.equal(turnRes.status, 200, `POST /turn returned ${turnRes.status}`);
+        const bodyText = await turnRes.text();
+        const { turnId: postedTurnId } = JSON.parse(bodyText);
+        assert.ok(typeof postedTurnId === "string" && postedTurnId.length > 0, "POST must return a non-empty turnId");
+        // Read all events for up to 3 s (no real Copilot token — only turn:started and
+        // possibly turn:error will arrive; that is sufficient to verify ID plumbing).
+        const frames = await reader.readFrames(3, 3_000);
+        await reader.cancel();
+        assert.ok(frames.length >= 1, `Expected at least 1 SSE frame, got ${frames.length}`);
+        // THE CONTRACT: every turn:* event must carry the same turnId the POST returned.
+        for (const frame of frames) {
+            const data = frame.data;
+            if (typeof data?.type === "string" && data.type.startsWith("turn:")) {
+                assert.equal(data.turnId, postedTurnId, `Event type=${data.type} has turnId=${String(data.turnId)} but POST returned turnId=${postedTurnId}`);
+            }
+        }
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
 //# sourceMappingURL=turn-sse.integration.test.js.map

package/dist/cli.js

@@ -25,7 +25,6 @@ Commands:
   setup            Pick a default model and write ~/.chapterhouse/.env
   update           Check for updates and install the latest version
   daemon <sub>     Manage the persistent background service (install/uninstall/start/stop/restart/status/logs)
-  squad <sub>      Squad agent tools (init, worktree management)
   help             Show this help message
 
 Flags (start):
@@ -179,35 +178,6 @@ switch (command) {
         }
         break;
     }
-    case "squad": {
-        const squadSub = args[1];
-        if (squadSub === 'worktree') {
-            const { runWorktreeCli } = await import("./squad/worktree.js");
-            await runWorktreeCli(args.slice(2));
-        }
-        else if (squadSub === 'init') {
-            const { runInitCli } = await import("./squad/init-cli.js");
-            await runInitCli(args.slice(2));
-        }
-        else {
-            if (squadSub) {
-                console.error(`Unknown squad subcommand: ${squadSub}\n`);
-            }
-            console.log(`
-chapterhouse squad — Squad agent tools
-
-Subcommands:
-  init       Initialize a new Squad team for this project (guided dialog)
-  worktree   Manage per-agent git worktrees (create / list / remove / prune)
-
-Run \`chapterhouse squad init\` to scaffold a .squad/ directory with a named team.
-Run \`chapterhouse squad worktree\` for worktree subcommand help.
-`.trim());
-            if (squadSub)
-                process.exit(1);
-        }
-        break;
-    }
     case "help":
     case "--help":
     case "-h":

package/dist/config.js

@@ -45,7 +45,6 @@ const configSchema = z.object({
     API_RATE_LIMIT_GENERAL_MAX: z.string().optional(),
     API_RATE_LIMIT_AUTH_MAX: z.string().optional(),
     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(),
 });
@@ -220,7 +219,6 @@ export function parseRuntimeConfig(env, options = {}) {
         apiRateLimitGeneralMax,
         apiRateLimitAuthMax,
         apiRateLimitSseMaxConnections,
-        squadEnabled: raw.ENABLE_SQUAD === "1",
         workiqAutoInstall: parseBooleanEnv("CHAPTERHOUSE_WORKIQ_AUTO_INSTALL", raw.CHAPTERHOUSE_WORKIQ_AUTO_INSTALL, true),
         chatSseEnabled: raw.CHAPTERHOUSE_CHAT_SSE === "1",
     };
@@ -261,7 +259,6 @@ export const config = {
     apiRateLimitGeneralMax: runtimeConfig.apiRateLimitGeneralMax,
     apiRateLimitAuthMax: runtimeConfig.apiRateLimitAuthMax,
     apiRateLimitSseMaxConnections: runtimeConfig.apiRateLimitSseMaxConnections,
-    squadEnabled: runtimeConfig.squadEnabled,
     workiqAutoInstall: runtimeConfig.workiqAutoInstall,
     chatSseEnabled: runtimeConfig.chatSseEnabled,
     copilotAuthToken: runtimeConfig.copilotAuthToken,

package/dist/copilot/agent-event-bus.js

@@ -0,0 +1,41 @@
+/**
+ * Process-scoped singleton event bus for agent (subagent) lifecycle events.
+ *
+ * Backed by Node's EventEmitter. The entire daemon process shares one bus.
+ * Keeps the same surface used by
+ * task-event-log.ts (subscribe by type), orchestrator.ts (emit), and the
+ * /api/agents/stream SSE endpoint (subscribeAll).
+ *
+ * Event types:
+ *   session:created    — subagent spawned       payload: { agentName, priority }
+ *   session:tool_call  — tool invoked           payload: { toolName, toolArgs, resultType?, _kind?, _seq?, _ts?, _summary? }
+ *   session:destroyed  — subagent finished      payload: { agentName, reason: "complete" | "error" | "abort" }
+ *   session:error      — subagent failed        payload: { agentName, error }
+ *
+ * @module copilot/agent-event-bus
+ */
+import { EventEmitter } from "node:events";
+const ALL = "*";
+class AgentEventBus {
+    emitter = new EventEmitter();
+    constructor() {
+        // Subagent fan-out can exceed the default 10 listeners; lift the cap.
+        this.emitter.setMaxListeners(0);
+    }
+    emit(event) {
+        const e = { timestamp: new Date(), ...event };
+        this.emitter.emit(e.type, e);
+        this.emitter.emit(ALL, e);
+    }
+    subscribe(type, handler) {
+        this.emitter.on(type, handler);
+        return () => this.emitter.off(type, handler);
+    }
+    subscribeAll(handler) {
+        this.emitter.on(ALL, handler);
+        return () => this.emitter.off(ALL, handler);
+    }
+}
+/** Process-level singleton. Import this everywhere instead of newing a bus. */
+export const agentEventBus = new AgentEventBus();
+//# sourceMappingURL=agent-event-bus.js.map

package/dist/copilot/agent-event-bus.test.js

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { agentEventBus } from "./agent-event-bus.js";
+test("subscribe receives only matching event type", () => {
+    const got = [];
+    const unsub = agentEventBus.subscribe("session:created", (e) => got.push(e));
+    agentEventBus.emit({ type: "session:created", sessionId: "a", payload: { agentName: "x", priority: "normal" } });
+    agentEventBus.emit({ type: "session:destroyed", sessionId: "a", payload: { agentName: "x", reason: "complete" } });
+    unsub();
+    assert.equal(got.length, 1);
+    assert.equal(got[0].sessionId, "a");
+    assert.ok(got[0].timestamp instanceof Date);
+});
+test("subscribeAll receives every event; unsub stops delivery", () => {
+    const got = [];
+    const unsub = agentEventBus.subscribeAll((e) => got.push(e));
+    agentEventBus.emit({ type: "session:created", sessionId: "b", payload: {} });
+    agentEventBus.emit({ type: "session:tool_call", sessionId: "b", payload: { toolName: "Read" } });
+    unsub();
+    agentEventBus.emit({ type: "session:error", sessionId: "b", payload: { agentName: "x", error: "boom" } });
+    assert.equal(got.length, 2);
+});
+//# sourceMappingURL=agent-event-bus.test.js.map

package/dist/copilot/agents.js

@@ -8,8 +8,6 @@ import { AGENTS_DIR, SESSIONS_DIR } from "../paths.js";
 import { getState, setState } from "../store/db.js";
 import { loadMcpConfig } from "./mcp-config.js";
 import { getSkillDirectories } from "./skills.js";
-import { createSessionHooks } from "./hooks.js";
-import { findSquadAgent, renderProjectAgentRoster } from "../squad/registry.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("agents");
 // Frontmatter schema
@@ -246,7 +244,7 @@ export function composeAgentSystemMessage(agent, rosterInfo) {
     return `${agentPrompt}\n\n${base}`;
 }
 /** Build a roster description of all agents for @chapterhouse's system prompt. */
-export function buildAgentRoster(projectRoot) {
+export function buildAgentRoster() {
     const agents = getAgentRegistry();
     const chLines = agents
         .filter((a) => a.slug !== "chapterhouse")
@@ -255,22 +253,9 @@ export function buildAgentRoster(projectRoot) {
         const skills = a.skills?.length ? ` | skills: ${a.skills.join(", ")}` : "";
         return `- **@${a.slug}** — ${a.description} (model: ${model}${skills})`;
     });
-    let squadLines = [];
-    if (projectRoot) {
-        try {
-            const squadRoster = renderProjectAgentRoster(projectRoot);
-            if (squadRoster) {
-                squadLines = squadRoster.split("\n").filter(Boolean);
-            }
-        }
-        catch {
-            // squad roster unavailable — skip
-        }
-    }
-    const allLines = [...chLines, ...squadLines];
-    if (allLines.length === 0)
+    if (chLines.length === 0)
         return "No agents registered.";
-    return allLines.join("\n");
+    return chLines.join("\n");
 }
 // The wiki tools that every agent gets regardless of tool config
 const WIKI_TOOL_NAMES = new Set([
@@ -325,7 +310,6 @@ export async function createEphemeralAgentSession(slug, client, allTools, modelO
         mcpServers,
         skillDirectories,
         onPermissionRequest: approveAll,
-        hooks: createSessionHooks(slug, agent.allowedPaths),
         infiniteSessions: {
             enabled: true,
             backgroundCompactionThreshold: 0.80,
@@ -335,34 +319,6 @@ export async function createEphemeralAgentSession(slug, client, allTools, modelO
     log.info({ agentSlug: agent.slug, model }, "Created ephemeral agent session");
     return session;
 }
-/** Create an ephemeral session for a squad virtual agent (not in CH registry). */
-export async function createSquadAgentSession(slug, client, allTools, systemMessagePrefix, modelOverride) {
-    const model = (modelOverride && modelOverride.length > 0)
-        ? modelOverride
-        : "claude-sonnet-4.6";
-    const squadTools = allTools.filter((t) => !MANAGEMENT_TOOL_NAMES.has(t.name));
-    const mcpServers = loadMcpConfig();
-    const skillDirectories = getSkillDirectories();
-    const session = await client.createSession({
-        model,
-        configDir: SESSIONS_DIR,
-        workingDirectory: process.cwd(),
-        streaming: true,
-        systemMessage: { content: systemMessagePrefix },
-        tools: squadTools,
-        mcpServers,
-        skillDirectories,
-        onPermissionRequest: approveAll,
-        hooks: createSessionHooks(slug),
-        infiniteSessions: {
-            enabled: true,
-            backgroundCompactionThreshold: 0.80,
-            bufferExhaustionThreshold: 0.95,
-        },
-    });
-    log.info({ agentSlug: slug, model }, "Created squad virtual agent session");
-    return session;
-}
 /** Clean up active task tracking (for shutdown/restart). */
 export async function clearActiveTasks() {
     activeTasks.clear();
@@ -428,7 +384,7 @@ export function setActiveAgent(channel, slug) {
     activeAgentByChannel.set(channel, slug);
 }
 /** Parse @mention from message text. Returns agent slug and remaining message, or null. */
-export function parseAtMention(text, projectRoot) {
+export function parseAtMention(text) {
     const match = text.match(/^@([a-zA-Z0-9-]+)\s*([\s\S]*)$/);
     if (!match)
         return null;
@@ -438,17 +394,6 @@ export function parseAtMention(text, projectRoot) {
     if (agent) {
         return { agentSlug: agent.slug, message: message || "" };
     }
-    if (projectRoot) {
-        try {
-            const squadAgent = findSquadAgent(projectRoot, mentionedName);
-            if (squadAgent) {
-                return { agentSlug: mentionedName, message: message || "" };
-            }
-        }
-        catch {
-            // squad lookup failed — fall through
-        }
-    }
     return null;
 }
 //# sourceMappingURL=agents.js.map