chapterhouse 0.3.25 → 0.3.26

package/dist/api/server-runtime.js

@@ -20,7 +20,7 @@ export function createHealthPayload(now = new Date()) {
     };
 }
 export function createPublicConfigPayload(config) {
-    const chatSseEnabled = config.chatSseEnabled ?? false;
+    const chatSseEnabled = config.chatSseEnabled ?? true;
     if (!config.entraAuthEnabled) {
         return {
             appName: "Chapterhouse",

package/dist/api/server.js

@@ -668,7 +668,7 @@ app.post("/api/sessions/:sessionKey/interrupt", (req, res) => {
     res.json({ status: "interrupting" });
 });
 // ---------------------------------------------------------------------------
-// Chat POST→SSE endpoints — gated by CHAPTERHOUSE_CHAT_SSE=1 (#130)
+// Chat POST→SSE endpoints — enabled by default, overridable via CHAPTERHOUSE_CHAT_SSE (#130)
 // ---------------------------------------------------------------------------
 const turnRequestSchema = z.object({
     prompt: z.string().trim().min(1, "Missing prompt"),

package/dist/api/server.test.js

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
 import Database from "better-sqlite3";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 test("supports API_TOKEN env var and personal health route helpers", async () => {
     const runtime = await import("./server-runtime.js");
     assert.equal(typeof runtime.resolveApiToken, "function", "resolveApiToken should be exported");
@@ -29,25 +29,25 @@ test("supports API_TOKEN env var and personal health route helpers", async () =>
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: true,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     });
     assert.deepEqual(runtime.createPublicConfigPayload({
         entraAuthEnabled: false,
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: false,
         standalone: false,
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     });
     assert.doesNotThrow(() => runtime.assertAuthenticationConfigured({
         entraAuthEnabled: false,
@@ -62,6 +62,21 @@ test("supports API_TOKEN env var and personal health route helpers", async () =>
         apiToken: null,
     }));
 });
+test("createPublicConfigPayload defaults chat SSE on when not explicitly provided", async () => {
+    const runtime = await import("./server-runtime.js");
+    assert.equal(typeof runtime.createPublicConfigPayload, "function", "createPublicConfigPayload should be exported");
+    assert.deepEqual(runtime.createPublicConfigPayload({
+        entraAuthEnabled: false,
+        standaloneMode: true,
+        entraClientId: "client-id",
+        entraTenantId: "tenant-id",
+    }), {
+        appName: "Chapterhouse",
+        entraAuthEnabled: false,
+        standalone: true,
+        chatSseEnabled: true,
+    });
+});
 test("formats named SSE status events", async () => {
     const sse = await import("./sse.js");
     assert.equal(typeof sse.formatSseEvent, "function", "formatSseEvent should be exported");
@@ -109,42 +124,18 @@ function readProjectRegistryRows(testRoot) {
         db.close();
     }
 }
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => {
-        server.listen(0, "127.0.0.1", () => resolve());
-    });
-    const address = server.address();
-    assert.ok(address && typeof address === "object", "server should expose a bound address");
-    await new Promise((resolve, reject) => {
-        server.close((err) => (err ? reject(err) : resolve()));
-    });
-    return address.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null) {
-        return;
-    }
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => {
-            if (child.exitCode === null) {
-                child.kill("SIGKILL");
-            }
-        }, 2_000);
-    });
-}
 // Standalone mode triggers a full daemon init via the server→daemon circular import
 // (server.ts imports restartDaemon from daemon.ts, which has module-level main()).
 // 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.
+// so the HTTP server cannot respond until SDK init completes (~10-30 s depending on
+// session state and runner load). Other modes usually complete much faster, but cold
+// CI starts can still exceed a 10 s budget.
 // 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.
+// guard env var in daemon.ts). Interim fix: use a more generous startup timeout for
+// integration tests while keeping the same /status readiness probe.
 // 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.
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     const testRoot = join(repoRoot, ".test-work", `server-routes-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     rmSync(testRoot, { recursive: true, force: true });
@@ -174,24 +165,8 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null) {
-                throw new Error(`API server exited early:\n${logs.join("")}`);
-            }
-            try {
-                const response = await fetch(`${baseUrl}/status`);
-                if (response.ok) {
-                    await run({ baseUrl, authHeader: "Bearer route-token", testRoot });
-                    return;
-                }
-            }
-            catch {
-                // Server still starting.
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        throw new Error(`Timed out waiting for API server to start:\n${logs.join("")}`);
+        await waitForApiServerReady({ child, baseUrl, logs, timeoutMs });
+        await run({ baseUrl, authHeader: "Bearer route-token", testRoot });
     }
     finally {
         await stopChild(child);
@@ -209,7 +184,7 @@ test("server routes expose bootstrap and public config without auth", async () =
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: false,
-            chatSseEnabled: false,
+            chatSseEnabled: true,
         });
     });
 });
@@ -224,14 +199,14 @@ test("server runs in standalone mode without auth", async () => {
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: true,
-            chatSseEnabled: false,
+            chatSseEnabled: true,
         });
         const model = await fetch(`${baseUrl}/api/model`);
         assert.equal(model.status, 200);
         assert.deepEqual(await model.json(), { model: "claude-sonnet-4.6" });
     }, {
         API_TOKEN: "",
-    }, 30_000);
+    }, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS);
 });
 test("server bootstrap rejects non-loopback origins", async () => {
     await withStartedServer(async ({ baseUrl }) => {

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

@@ -1,42 +1,16 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { mkdirSync, rmSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 // ---------------------------------------------------------------------------
 // Server harness (copied from server.test.ts; distinct root path suffix to
 // avoid collision when both test files run in parallel in the same process).
 // ---------------------------------------------------------------------------
 const repoRoot = process.cwd();
 const sseTestRoot = join(repoRoot, ".test-work", `sse-integration-${process.pid}`);
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => {
-        server.listen(0, "127.0.0.1", () => resolve());
-    });
-    const address = server.address();
-    assert.ok(address && typeof address === "object", "server should expose a bound address");
-    await new Promise((resolve, reject) => {
-        server.close((err) => (err ? reject(err) : resolve()));
-    });
-    return address.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null) {
-        return;
-    }
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => {
-            if (child.exitCode === null) {
-                child.kill("SIGKILL");
-            }
-        }, 2_000);
-    });
-}
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     rmSync(sseTestRoot, { recursive: true, force: true });
     mkdirSync(sseTestRoot, { recursive: true });
@@ -65,24 +39,8 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null) {
-                throw new Error(`API server exited early:\n${logs.join("")}`);
-            }
-            try {
-                const response = await fetch(`${baseUrl}/status`);
-                if (response.ok) {
-                    await run({ baseUrl, authHeader: "Bearer route-token" });
-                    return;
-                }
-            }
-            catch {
-                // Server still starting.
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        throw new Error(`Timed out waiting for API server to start:\n${logs.join("")}`);
+        await waitForApiServerReady({ child, baseUrl, logs, timeoutMs });
+        await run({ baseUrl, authHeader: "Bearer route-token" });
     }
     finally {
         await stopChild(child);

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

@@ -2,8 +2,8 @@
  * Integration tests for the POST→SSE chat endpoints (#130).
  *
  * Tests:
- *  1. POST /api/sessions/:key/turn returns 404 when flag is off
- *  2. GET /api/sessions/:key/stream returns 404 when flag is off
+ *  1. POST /api/sessions/:key/turn returns 404 when flag is explicitly off
+ *  2. GET /api/sessions/:key/stream returns 404 when flag is explicitly off
  *  3. POST /api/sessions/:key/turn returns { turnId } when flag is on
  *  4. GET /api/sessions/:key/stream delivers turn events (SSE)
  *  5. SSE reconnect with Last-Event-ID replays missed events
@@ -11,8 +11,8 @@
  *  7. Legacy POST /api/message path unaffected when flag is off
  *
  * The tests that require the feature flag spawn a separate server process with
- * CHAPTERHOUSE_CHAT_SSE=1.  Tests that verify flag-off behavior use a server
- * without the flag.
+ * CHAPTERHOUSE_CHAT_SSE defaults on. Tests that verify flag-off behavior use a
+ * server with CHAPTERHOUSE_CHAT_SSE=0.
  *
  * Because the Copilot SDK is not available in test env (no valid token), tests
  * that would trigger a real turn instead verify the API shape and event
@@ -23,34 +23,16 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { mkdirSync, rmSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 // ---------------------------------------------------------------------------
 // Helpers — copied/adapted from sse.integration.test.ts
 // ---------------------------------------------------------------------------
 const repoRoot = process.cwd();
 const testWorkRoot = join(repoRoot, ".test-work", `turn-sse-${process.pid}`);
 let _instanceCounter = 0;
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
-    const addr = server.address();
-    assert.ok(addr && typeof addr === "object");
-    await new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
-    return addr.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null)
-        return;
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => { if (child.exitCode === null)
-            child.kill("SIGKILL"); }, 2_000);
-    });
-}
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     const instanceRoot = `${testWorkRoot}-${Date.now()}-${++_instanceCounter}`;
     rmSync(instanceRoot, { recursive: true, force: true });
@@ -78,24 +60,15 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (c) => logs.push(String(c)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null)
-                throw new Error(`Server exited early:\n${logs.join("")}`);
-            let serverReady = false;
-            try {
-                const r = await fetch(`${baseUrl}/status`);
-                serverReady = r.ok;
-            }
-            catch { /* not ready yet */ }
-            if (serverReady) {
-                // Run outside the fetch try/catch so assertion errors propagate correctly.
-                await run({ baseUrl, authHeader: "Bearer test-token" });
-                return;
-            }
-            await new Promise((r) => setTimeout(r, 100));
-        }
-        throw new Error(`Server did not start in ${timeoutMs}ms:\n${logs.join("")}`);
+        await waitForApiServerReady({
+            child,
+            baseUrl,
+            logs,
+            timeoutMs,
+            timeoutMessage: `Server did not start in ${timeoutMs}ms`,
+            exitMessage: "Server exited early",
+        });
+        await run({ baseUrl, authHeader: "Bearer test-token" });
     }
     finally {
         await stopChild(child);
@@ -162,18 +135,18 @@ test("turn-sse: POST /api/sessions/:key/turn returns 404 when flag is off", asyn
             headers: { Authorization: authHeader, "Content-Type": "application/json" },
             body: JSON.stringify({ prompt: "hello" }),
         });
-        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE=0");
         const body = await res.json();
         assert.ok(typeof body.error === "string" && body.error.includes("Chat SSE"), `Expected error about Chat SSE, got: ${body.error}`);
-    });
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 test("turn-sse: GET /api/sessions/:key/stream returns 404 when flag is off", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
         const res = await fetch(`${baseUrl}/api/sessions/default/stream`, {
             headers: { Authorization: authHeader },
         });
-        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
-    });
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE=0");
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 test("turn-sse: legacy POST /api/message is unaffected when flag is off", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
@@ -186,7 +159,7 @@ test("turn-sse: legacy POST /api/message is unaffected when flag is off", async
         });
         // 400 = route exists and validated the request (connectionId not found in sseClients)
         assert.ok(res.status === 400 || res.status === 401 || res.status === 422, `Expected 4xx from /api/message, got ${res.status}`);
-    });
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 // ---------------------------------------------------------------------------
 // Tests: feature flag ON

package/dist/config.js

@@ -60,6 +60,16 @@ export const DEFAULT_API_RATE_LIMIT_WINDOW_MS = 60_000;
 export const DEFAULT_API_RATE_LIMIT_GENERAL_MAX = 100;
 export const DEFAULT_API_RATE_LIMIT_AUTH_MAX = 10;
 export const DEFAULT_API_RATE_LIMIT_SSE_MAX_CONNECTIONS = 5;
+function parseZeroOneEnv(name, rawValue, defaultValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return defaultValue;
+    }
+    if (normalized !== "0" && normalized !== "1") {
+        throw new Error(`${name} must be '0' or '1', got: "${rawValue}"`);
+    }
+    return normalized === "1";
+}
 function parseBooleanEnv(name, rawValue, defaultValue) {
     const normalized = rawValue?.trim();
     if (!normalized) {
@@ -230,7 +240,7 @@ export function parseRuntimeConfig(env, options = {}) {
         apiRateLimitAuthMax,
         apiRateLimitSseMaxConnections,
         workiqAutoInstall: parseBooleanEnv("CHAPTERHOUSE_WORKIQ_AUTO_INSTALL", raw.CHAPTERHOUSE_WORKIQ_AUTO_INSTALL, true),
-        chatSseEnabled: raw.CHAPTERHOUSE_CHAT_SSE === "1",
+        chatSseEnabled: parseZeroOneEnv("CHAPTERHOUSE_CHAT_SSE", raw.CHAPTERHOUSE_CHAT_SSE, true),
     };
 }
 const runtimeConfig = parseRuntimeConfig(process.env);

package/dist/config.test.js

@@ -95,6 +95,20 @@ test("defaults TEAM_WIKI_PATHS to include the shared namespace", async () => {
     const parsed = configModule.parseRuntimeConfig({});
     assert.deepEqual(parsed.teamWikiPaths, ["pages/team", "pages/okrs", "pages/kpis", "pages/shared"]);
 });
+test("defaults chat SSE on and still honors explicit CHAPTERHOUSE_CHAT_SSE overrides", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsedDefault = configModule.parseRuntimeConfig({});
+    const parsedDisabled = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_CHAT_SSE: "0",
+    });
+    const parsedEnabled = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_CHAT_SSE: "1",
+    });
+    assert.equal(parsedDefault.chatSseEnabled, true);
+    assert.equal(parsedDisabled.chatSseEnabled, false);
+    assert.equal(parsedEnabled.chatSseEnabled, true);
+});
 test("prefers COPILOT_TOKEN over GITHUB_TOKEN for Copilot SDK auth", async () => {
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");

package/dist/copilot/orchestrator.js

@@ -843,7 +843,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
     const taggedPrompt = source.type === "background"
         ? routedPrompt
         : `[via ${sourceLabel}] ${routedPrompt}`;
-    const logRole = source.type === "background" ? "system" : "user";
+    const logRole = source.type === "background" ? "agent_completion" : "user";
     const sourceChannel = source.type === "web" ? "web" : undefined;
     // Capture auth context at enqueue time — prevents cross-session contamination
     // when concurrent sessions are processing simultaneously.

package/dist/copilot/orchestrator.test.js

@@ -675,7 +675,7 @@ test("feedAgentResult injects a background completion turn and proactively notif
         }]);
     assert.deepEqual(state.dbLogs, [
         {
-            role: "system",
+            role: "agent_completion",
             content: "[Agent task completed] @coder finished task task-9:\n\nFixed the flaky test",
             source: "background",
         },

package/dist/store/db.js

@@ -62,7 +62,7 @@ export function getDb() {
         db.exec(`
       CREATE TABLE IF NOT EXISTS conversation_log (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system', 'agent_completion')),
         content TEXT NOT NULL,
         source TEXT NOT NULL DEFAULT 'unknown',
         ts DATETIME DEFAULT CURRENT_TIMESTAMP
@@ -80,16 +80,16 @@ export function getDb() {
     `);
         // Migrate: if the table already existed with a stricter CHECK, recreate it
         try {
-            db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('system', '__migration_test__', 'test')`).run();
+            db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('agent_completion', '__migration_test__', 'test')`).run();
             db.prepare(`DELETE FROM conversation_log WHERE content = '__migration_test__'`).run();
         }
         catch {
-            // CHECK constraint doesn't allow 'system' — recreate table preserving data
+            // CHECK constraint doesn't allow current synthetic roles — recreate table preserving data
             db.exec(`ALTER TABLE conversation_log RENAME TO conversation_log_old`);
             db.exec(`
         CREATE TABLE conversation_log (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
-          role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+          role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system', 'agent_completion')),
           content TEXT NOT NULL,
           source TEXT NOT NULL DEFAULT 'unknown',
           ts DATETIME DEFAULT CURRENT_TIMESTAMP
@@ -309,7 +309,8 @@ export function getRecentConversation(limit, sessionKey) {
     return rows.map((r) => {
         const tag = r.role === "user" ? `[${r.source}] User`
             : r.role === "system" ? `[${r.source}] System`
-                : "Chapterhouse";
+                : r.role === "agent_completion" ? `[${r.source}] Agent completion`
+                    : "Chapterhouse";
         // Truncate long messages to keep context manageable
         const content = r.content.length > 1500 ? r.content.slice(0, 1500) + "…" : r.content;
         return `${tag}: ${content}`;
@@ -344,21 +345,22 @@ export function normalizeSqliteTsToIso(ts) {
  * suitable for seeding the frontend Zustand store on mount.
  *
  * Unlike `getRecentConversation()`, this returns structured objects (not a
- * formatted string) and omits system messages (role = 'system') because the
- * UI only renders user/assistant turns.
+ * formatted string) and omits internal system messages. Synthetic background
+ * completion notices are included and mapped to assistant-style turns so reload
+ * matches the live chat rendering path.
  */
 export function getSessionMessages(sessionKey, limit) {
     const db = getDb();
     const effectiveLimit = Math.min(limit ?? DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT);
     const rows = db
         .prepare(`SELECT role, content, ts FROM conversation_log
-       WHERE session_key = ? AND role IN ('user', 'assistant')
+       WHERE session_key = ? AND role IN ('user', 'assistant', 'agent_completion')
        ORDER BY id DESC LIMIT ?`)
         .all(sessionKey, effectiveLimit);
     // Reverse so oldest is first (chronological order for the UI)
     rows.reverse();
     return rows.map((r) => ({
-        role: r.role,
+        role: r.role === "agent_completion" ? "assistant" : r.role,
         content: r.content,
         ts: normalizeSqliteTsToIso(r.ts),
     }));

package/dist/store/db.test.js

@@ -165,28 +165,32 @@ test("getSessionMessages returns empty array for unknown session", async () => {
         dbModule.closeDb();
     }
 });
-test("getSessionMessages returns structured messages in chronological order, excludes system rows, respects limit", async () => {
+test("getSessionMessages returns structured messages in chronological order, includes agent completions, excludes system rows, respects limit", async () => {
     const dbModule = await loadDbModule();
     try {
-        dbModule.getDb();
+        const db = dbModule.getDb();
         dbModule.logConversation("user", "hello", "web", "test-session");
         dbModule.logConversation("assistant", "hi there", "web", "test-session");
         dbModule.logConversation("system", "system noise", "worker", "test-session");
+        db.prepare(`INSERT INTO conversation_log (role, content, source, session_key)
+       VALUES ('agent_completion', ?, 'background', 'test-session')`).run("[Agent task completed] @coder finished task task-1:\n\nDone");
         dbModule.logConversation("user", "second message", "web", "test-session");
         dbModule.logConversation("user", "from other session", "web", "other-session");
         const all = dbModule.getSessionMessages("test-session");
-        assert.equal(all.length, 3, "3 user/assistant rows, system excluded");
+        assert.equal(all.length, 4, "user/assistant rows plus agent completion, system excluded");
         assert.equal(all[0].role, "user");
         assert.equal(all[0].content, "hello");
         assert.equal(all[1].role, "assistant");
         assert.equal(all[1].content, "hi there");
-        assert.equal(all[2].role, "user");
-        assert.equal(all[2].content, "second message");
+        assert.equal(all[2].role, "assistant");
+        assert.equal(all[2].content, "[Agent task completed] @coder finished task task-1:\n\nDone");
+        assert.equal(all[3].role, "user");
+        assert.equal(all[3].content, "second message");
         // Limit clamping
         const limited = dbModule.getSessionMessages("test-session", 2);
         assert.equal(limited.length, 2, "limit=2 returns 2 most recent rows");
-        // After reversal, these should be the 2 most-recent (assistant + second user)
-        assert.equal(limited[0].content, "hi there");
+        // After reversal, these should be the 2 most-recent renderable rows.
+        assert.equal(limited[0].content, "[Agent task completed] @coder finished task task-1:\n\nDone");
         assert.equal(limited[1].content, "second message");
         // Other session not leaked
         const other = dbModule.getSessionMessages("other-session");

package/dist/test/api-server.js

@@ -0,0 +1,50 @@
+import { createServer } from "node:http";
+import { setTimeout as delay } from "node:timers/promises";
+import assert from "node:assert/strict";
+export const DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS = 60_000;
+export const STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS = 60_000;
+export const API_SERVER_STARTUP_POLL_INTERVAL_MS = 100;
+export async function getFreePort() {
+    const server = createServer();
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    const address = server.address();
+    assert.ok(address && typeof address === "object", "server should expose a bound address");
+    await new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+    });
+    return address.port;
+}
+export async function stopChild(child) {
+    if (child.exitCode !== null) {
+        return;
+    }
+    child.kill("SIGTERM");
+    await new Promise((resolve) => {
+        child.once("exit", () => resolve());
+        setTimeout(() => {
+            if (child.exitCode === null) {
+                child.kill("SIGKILL");
+            }
+        }, 2_000);
+    });
+}
+export async function waitForApiServerReady({ child, baseUrl, logs, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, pollIntervalMs = API_SERVER_STARTUP_POLL_INTERVAL_MS, timeoutMessage = "Timed out waiting for API server to start", exitMessage = "API server exited early", }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null) {
+            throw new Error(`${exitMessage}:\n${logs.join("")}`);
+        }
+        try {
+            const response = await fetch(`${baseUrl}/status`);
+            if (response.ok) {
+                return;
+            }
+        }
+        catch {
+            // Server is still starting.
+        }
+        await delay(pollIntervalMs);
+    }
+    throw new Error(`${timeoutMessage}:\n${logs.join("")}`);
+}
+//# sourceMappingURL=api-server.js.map

package/dist/test/api-server.test.js

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import test from "node:test";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS, waitForApiServerReady, } from "./api-server.js";
+async function listen(server) {
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    const address = server.address();
+    assert.ok(address && typeof address === "object");
+    return address.port;
+}
+async function close(server) {
+    if (!server.listening) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+    });
+}
+test("waitForApiServerReady waits until /status responds with ok", async () => {
+    let ready = false;
+    const server = createServer((req, res) => {
+        if (req.url !== "/status") {
+            res.writeHead(404).end();
+            return;
+        }
+        if (!ready) {
+            res.writeHead(503).end("starting");
+            return;
+        }
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+    });
+    const port = await listen(server);
+    const child = { exitCode: null };
+    setTimeout(() => {
+        ready = true;
+    }, 200);
+    const startedAt = Date.now();
+    try {
+        await waitForApiServerReady({
+            child,
+            baseUrl: `http://127.0.0.1:${port}`,
+            logs: [],
+            timeoutMs: 1_000,
+            pollIntervalMs: 25,
+        });
+    }
+    finally {
+        await close(server);
+    }
+    assert.ok(Date.now() - startedAt >= 150);
+});
+test("API server startup timeouts leave headroom for slow CI runners", () => {
+    assert.equal(DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, 60_000);
+    assert.equal(STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS, 60_000);
+});
+//# sourceMappingURL=api-server.test.js.map

package/dist/test/setup-env.js

@@ -1,3 +1,12 @@
+const RUNTIME_OVERRIDE_ENV_VARS = [
+    "CHAPTERHOUSE_MODE",
+    "CHAPTERHOUSE_SELF_EDIT",
+    "CHAPTERHOUSE_WORKIQ_AUTO_INSTALL",
+    "CHAPTERHOUSE_CHAT_SSE",
+];
+for (const name of RUNTIME_OVERRIDE_ENV_VARS) {
+    delete process.env[name];
+}
 process.env.CHAPTERHOUSE_DISABLE_DOTENV = "1";
 export {};
 //# sourceMappingURL=setup-env.js.map

package/dist/test/setup-env.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+const RUNTIME_OVERRIDE_ENV_VARS = [
+    "CHAPTERHOUSE_MODE",
+    "CHAPTERHOUSE_SELF_EDIT",
+    "CHAPTERHOUSE_WORKIQ_AUTO_INSTALL",
+    "CHAPTERHOUSE_CHAT_SSE",
+];
+test("setup-env clears ambient Chapterhouse runtime overrides", async () => {
+    const originalValues = new Map(["CHAPTERHOUSE_DISABLE_DOTENV", ...RUNTIME_OVERRIDE_ENV_VARS].map((name) => [name, process.env[name]]));
+    try {
+        process.env.CHAPTERHOUSE_DISABLE_DOTENV = "0";
+        process.env.CHAPTERHOUSE_MODE = "team";
+        process.env.CHAPTERHOUSE_SELF_EDIT = "1";
+        process.env.CHAPTERHOUSE_WORKIQ_AUTO_INSTALL = "false";
+        process.env.CHAPTERHOUSE_CHAT_SSE = "0";
+        await import(`./setup-env.js?cache-bust=${Date.now()}`);
+        assert.equal(process.env.CHAPTERHOUSE_DISABLE_DOTENV, "1");
+        for (const name of RUNTIME_OVERRIDE_ENV_VARS) {
+            assert.equal(process.env[name], undefined, `${name} should be cleared by setup-env`);
+        }
+    }
+    finally {
+        for (const [name, value] of originalValues) {
+            if (value === undefined) {
+                delete process.env[name];
+            }
+            else {
+                process.env[name] = value;
+            }
+        }
+    }
+});
+//# sourceMappingURL=setup-env.test.js.map

package/package.json

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