chapterhouse 0.1.1 → 0.1.5

package/dist/api/server.js

@@ -1,7 +1,7 @@
 import cors from "cors";
 import express from "express";
 import helmet from "helmet";
-import { existsSync, statSync } from "fs";
+import { existsSync, statSync, readdirSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
@@ -23,6 +23,7 @@ import { getDb } from "../store/db.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";
 void searchIndex; // re-exported by index-manager; reference here documents the dep
@@ -528,6 +529,31 @@ app.post("/api/restart", (_req, res) => {
 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." });
@@ -535,18 +561,16 @@ app.get("/api/projects", (_req, res) => {
     }
     const db = getDb();
     const rows = db.prepare(`
-    SELECT project_squads.project_root, project_squads.squad_dir,
-           COUNT(squad_agents.slug) as agent_count, project_squads.loaded_at
+    SELECT project_root, squad_dir, loaded_at
     FROM project_squads
-    LEFT JOIN squad_agents ON project_squads.project_root = squad_agents.project_root
-    WHERE project_squads.registered = 1
-    GROUP BY project_squads.project_root
-    ORDER BY project_squads.loaded_at DESC
+    WHERE registered = 1
+    ORDER BY loaded_at DESC
   `).all();
     res.json(rows.map((r) => ({
         projectRoot: r.project_root,
         squadDir: r.squad_dir,
-        agentCount: r.agent_count,
+        // Count from live filesystem — authoritative per Squad SDK rule: repo files win over cache.
+        agentCount: countAgentsOnDisk(r.project_root),
         loadedAt: r.loaded_at,
     })));
 });
@@ -575,6 +599,11 @@ app.post("/api/projects", async (req, res) => {
     }).catch(err => {
         console.warn('[squad] syncDecisionsFileToWiki failed during registration (non-fatal):', err instanceof Error ? err.message : err);
     });
+    // 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 => {
+        console.warn('[squad] resolveProjectSquad failed during registration (non-fatal):', err instanceof Error ? err.message : err);
+    });
     res.status(201).json({ projectRoot, message: "Project registered successfully" });
 });
 app.delete("/api/projects/:projectRoot", (req, res) => {

package/dist/copilot/orchestrator.js

@@ -5,7 +5,7 @@ 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 } from "../store/db.js";
+import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, getTaskSessionKey, getDb } from "../store/db.js";
 import { maybeWriteEpisode } from "./episode-writer.js";
 import { getWikiSummary } from "../wiki/context.js";
 import { SESSIONS_DIR } from "../paths.js";
@@ -403,6 +403,32 @@ async function executeOnSession(sessionKey, prompt, callback, attachments, onAct
             });
         })
         : () => { };
+    // Always persist SDK subagent dispatches to agent_tasks so Workers tab shows them.
+    // These fire when the built-in `task` tool (Squad coordinator) routes work to a
+    // specialist — separate from `delegate_to_agent` which handles CH-registry agents.
+    const db = getDb();
+    const unsubSubStartDb = session.on("subagent.started", (event) => {
+        try {
+            const data = event.data;
+            const agentSlug = (data.agentName || "unknown").toLowerCase().replace(/\s+/g, "-");
+            const 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, currentSourceChannel || null, sessionKey);
+        }
+        catch { /* non-fatal */ }
+    });
+    const unsubSubDoneDb = session.on("subagent.completed", (event) => {
+        try {
+            db.prepare(`UPDATE agent_tasks SET status = 'completed', completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(event.data.toolCallId);
+        }
+        catch { /* non-fatal */ }
+    });
+    const unsubSubFailDb = session.on("subagent.failed", (event) => {
+        try {
+            const data = event.data;
+            db.prepare(`UPDATE agent_tasks SET status = 'error', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(data.error || "Subagent failed", data.toolCallId);
+        }
+        catch { /* non-fatal */ }
+    });
     const unsubDelta = session.on("assistant.message_delta", (event) => {
         // After a tool call completes, ensure a line break separates the text blocks
         // so they don't visually run together in the rendered chat.
@@ -455,6 +481,9 @@ async function executeOnSession(sessionKey, prompt, callback, attachments, onAct
         unsubSubStart();
         unsubSubDone();
         unsubSubFail();
+        unsubSubStartDb();
+        unsubSubDoneDb();
+        unsubSubFailDb();
         currentCallback = undefined;
         currentActivityCallback = undefined;
         currentProcessingSessionKey = undefined;

package/dist/copilot/orchestrator.test.js

@@ -13,6 +13,11 @@ function createFakeClient(state) {
                 this.listeners.set(eventName, next);
             };
         }
+        emit(eventName, data) {
+            for (const handler of this.listeners.get(eventName) || []) {
+                handler({ data });
+            }
+        }
         async sendAndWait(request, _timeoutMs) {
             state.sessionPrompts.push(request);
             if (state.sendResult === "__PENDING__") {
@@ -45,7 +50,11 @@ function createFakeClient(state) {
             if (state.createSessionError) {
                 throw new Error(state.createSessionError);
             }
-            return new FakeSession();
+            const session = new FakeSession();
+            state.lastSession = {
+                emit: (eventName, data) => session.emit(eventName, data),
+            };
+            return session;
         },
         async resumeSession(savedId, options) {
             state.resumeSessionCalls.push({ savedId, options });
@@ -71,6 +80,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
         disconnectCalls: 0,
         conversationLogs: [],
         dbLogs: [],
+        dbWrites: [],
         episodeWrites: 0,
         ensureDefaultAgentsCalls: 0,
         loadAgentsCalls: 0,
@@ -162,6 +172,16 @@ async function loadOrchestratorModule(t, overrides = {}) {
             getCopilotSession: (_sessionKey) => undefined,
             upsertCopilotSession: (_sessionKey, _mode, _copilotSessionId, _projectRoot, _model) => { },
             getTaskSessionKey: (taskId) => state.taskSessionKeys?.get(taskId) ?? "default",
+            getDb: () => ({
+                prepare: (sql) => ({
+                    run: (...args) => {
+                        state.dbWrites.push({ sql, args });
+                        return {};
+                    },
+                    get: () => undefined,
+                    all: () => [],
+                }),
+            }),
         },
     });
     t.mock.module("./episode-writer.js", {
@@ -520,4 +540,89 @@ test("ensureOrchestratorSession cleans up in-flight promise on session creation
     await new Promise((resolve) => setTimeout(resolve, 20));
     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)
+// 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.
+// Fix: unconditional DB subscriptions in executeOnSession write/update rows.
+// ---------------------------------------------------------------------------
+test("S5-01: subagent.started event inserts a squad row into agent_tasks", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    // Start a message so executeOnSession runs and registers event handlers
+    const callbackResults = [];
+    orchestrator.sendToOrchestrator("dispatch something", { type: "background" }, (text, done) => {
+        callbackResults.push({ text, done });
+    });
+    // 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
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-call-001",
+        agentName: "Kaylee",
+        agentDisplayName: "Kaylee — Backend Dev",
+        agentDescription: "Implement S5-01 backend fix",
+    });
+    // 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(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"));
+});
+test("S5-01: subagent.completed event updates agent_tasks status to completed", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch something", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // First, start the subagent
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-call-002",
+        agentName: "Wash",
+        agentDisplayName: "Wash — Frontend Dev",
+        agentDescription: "Fix Workers tab UI",
+    });
+    // Then complete it
+    state.lastSession.emit("subagent.completed", {
+        toolCallId: "subagent-call-002",
+        agentName: "Wash",
+        agentDisplayName: "Wash — Frontend Dev",
+        durationMs: 1234,
+    });
+    const updateWrite = state.dbWrites.find((w) => w.sql.includes("UPDATE") && w.sql.includes("agent_tasks") && w.sql.includes("completed"));
+    assert.ok(updateWrite, "subagent.completed must UPDATE agent_tasks to completed");
+    assert.ok(JSON.stringify(updateWrite.args).includes("subagent-call-002"), "UPDATE must target the correct task_id");
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("S5-01: subagent.failed event updates agent_tasks status to error", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch something", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-call-003",
+        agentName: "Zoe",
+        agentDisplayName: "Zoe — QA",
+        agentDescription: "Run test suite",
+    });
+    state.lastSession.emit("subagent.failed", {
+        toolCallId: "subagent-call-003",
+        agentName: "Zoe",
+        agentDisplayName: "Zoe — QA",
+        error: "Timeout after 600s",
+    });
+    const errorWrite = state.dbWrites.find((w) => w.sql.includes("UPDATE") && w.sql.includes("agent_tasks") && w.sql.includes("error"));
+    assert.ok(errorWrite, "subagent.failed must UPDATE agent_tasks to error status");
+    assert.ok(JSON.stringify(errorWrite.args).includes("subagent-call-003"), "UPDATE must target the correct task_id");
+    state.pendingReject?.(new Error("test teardown"));
+});
 //# sourceMappingURL=orchestrator.test.js.map

package/dist/copilot/tools.js

@@ -156,7 +156,7 @@ export function createTools(deps) {
                 const task = registerTask(delegatedSlug, args.summary, getCurrentSourceChannel());
                 // Persist task to DB
                 const db = getDb();
-                db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key) VALUES (?, ?, ?, 'running', ?, ?)`).run(task.taskId, delegatedSlug, args.summary, task.originChannel || null, getCurrentSessionKey());
+                db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'adhoc')`).run(task.taskId, delegatedSlug, args.summary, task.originChannel || null, getCurrentSessionKey());
                 // Capture the parent's activity callback so the child session can stream
                 // its events back to the originating SSE connection. This survives past
                 // the parent assistant turn — the child runs long after the parent's

package/dist/squad/discovery.test.js

@@ -90,4 +90,65 @@ test("invalidateProjectSquad marks agents stale — next loadProjectSquad re-res
     // Both should have agents (content integrity survives invalidation + re-resolve)
     assert.ok(after && typeof after === "object" && "agents" in after, "re-resolved context should include agents");
 });
+// ---------------------------------------------------------------------------
+// S5-02: agent count from filesystem is always authoritative
+// These tests guard the fix: GET /api/projects must count agents from disk,
+// not from the SQLite squad_agents cache (which is never populated on a fresh
+// registration, causing the badge to show 0).
+// ---------------------------------------------------------------------------
+test("S5-02: resolveProjectSquad counts 0 agents for an empty agents dir", async () => {
+    const m = await loadDiscovery();
+    const dir = join(repoRoot, ".test-work", `s502-empty-${process.pid}`);
+    mkdirSync(join(dir, ".squad", "agents"), { recursive: true });
+    try {
+        const result = await m.resolveProjectSquad(dir);
+        assert.ok(result !== null, "should return context even with no agents");
+        assert.equal(result.agents.length, 0, "empty agents dir → 0 agents");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("S5-02: resolveProjectSquad counts N agents matching charter-bearing subdirs", async () => {
+    const m = await loadDiscovery();
+    const dir = join(repoRoot, ".test-work", `s502-n-agents-${process.pid}`);
+    // Create 3 agents (with charter.md) and 1 directory without charter.md
+    for (const slug of ["alpha", "beta", "gamma"]) {
+        mkdirSync(join(dir, ".squad", "agents", slug), { recursive: true });
+        const { writeFileSync } = await import("node:fs");
+        writeFileSync(join(dir, ".squad", "agents", slug, "charter.md"), `# ${slug}\n\n**Role:** Specialist\n`);
+    }
+    mkdirSync(join(dir, ".squad", "agents", "no-charter"), { recursive: true }); // no charter.md
+    try {
+        const result = await m.resolveProjectSquad(dir);
+        assert.ok(result !== null, "should return context");
+        assert.equal(result.agents.length, 3, "only dirs with charter.md count as agents");
+        const slugs = result.agents.map((a) => a.slug).sort();
+        assert.deepEqual(slugs, ["alpha", "beta", "gamma"]);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+test("S5-02: resolveProjectSquad re-reads filesystem after agent added (no stale count)", async () => {
+    const m = await loadDiscovery();
+    const dir = join(repoRoot, ".test-work", `s502-refresh-${process.pid}`);
+    const { writeFileSync } = await import("node:fs");
+    // Start with 1 agent
+    mkdirSync(join(dir, ".squad", "agents", "first"), { recursive: true });
+    writeFileSync(join(dir, ".squad", "agents", "first", "charter.md"), "# first\n\n**Role:** Scout\n");
+    try {
+        const before = await m.resolveProjectSquad(dir);
+        assert.equal(before.agents.length, 1, "before: 1 agent on disk");
+        // Add a second agent to disk
+        mkdirSync(join(dir, ".squad", "agents", "second"), { recursive: true });
+        writeFileSync(join(dir, ".squad", "agents", "second", "charter.md"), "# second\n\n**Role:** Recon\n");
+        // resolveProjectSquad always reads from disk (no TTL — direct filesystem read)
+        const after = await m.resolveProjectSquad(dir);
+        assert.equal(after.agents.length, 2, "after adding agent to disk: 2 agents");
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
 //# sourceMappingURL=discovery.test.js.map

package/dist/store/db.js

@@ -146,6 +146,10 @@ export function getDb() {
         if (!taskCols.some((c) => c.name === 'session_key')) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
         }
+        // Migrate: add source column to agent_tasks ('adhoc' | 'squad') if not present
+        if (!taskCols.some((c) => c.name === 'source')) {
+            db.exec(`ALTER TABLE agent_tasks ADD COLUMN source TEXT NOT NULL DEFAULT 'adhoc'`);
+        }
         // Prune conversation log at startup — keep more history for better recovery
         db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)`).run();
         // Set up FTS5 for memory search (graceful fallback if not available)

package/package.json

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

package/web/dist/chapterhouse-icon.svg

@@ -4,7 +4,7 @@
  width="512px" height="512px" viewBox="0 0 1024.000000 1024.000000"
  preserveAspectRatio="xMidYMid meet">
 <g transform="translate(0.000000,1024.000000) scale(0.100000,-0.100000)"
-fill="#000000" stroke="none">
+fill="#CD7F32" stroke="none">
 <path d="M4960 9676 c-415 -143 -684 -258 -935 -401 -530 -300 -969 -739
 -1277 -1275 -48 -83 -186 -364 -231 -471 -214 -503 -382 -1155 -491 -1909 -25
 -172 -73 -606 -101 -909 -18 -192 -32 -297 -43 -325 -26 -62 -23 -283 6 -397