chapterhouse 0.3.24 → 0.3.26

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");
@@ -266,6 +270,62 @@ test("#86: agent_task_events table exists in schema after getDb()", async () =>
         dbModule.closeDb();
     }
 });
+test("#158: appendTaskOutputDeltaEvent writes output_delta event with text", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-delta-001", "coder", "delta test", "running");
+        const ev = dbModule.appendTaskOutputDeltaEvent("task-delta-001", "Hello world");
+        assert.ok(ev, "appendTaskOutputDeltaEvent must return the event");
+        assert.equal(ev.kind, "output_delta");
+        assert.equal(ev.text, "Hello world");
+        assert.equal(ev.toolName, null);
+        assert.equal(ev.status, null);
+        assert.equal(ev.seq, 1);
+        const events = dbModule.getTaskEvents("task-delta-001");
+        assert.equal(events.length, 1);
+        assert.equal(events[0].text, "Hello world");
+        assert.equal(events[0].kind, "output_delta");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#158: appendTaskStatusEvent writes task_status event with status field", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-status-001", "coder", "status test", "running");
+        const ev = dbModule.appendTaskStatusEvent("task-status-001", "completed", "All done");
+        assert.ok(ev, "appendTaskStatusEvent must return the event");
+        assert.equal(ev.kind, "task_status");
+        assert.equal(ev.status, "completed");
+        assert.equal(ev.summary, "All done");
+        assert.equal(ev.text, null);
+        assert.equal(ev.toolName, null);
+        const events = dbModule.getTaskEvents("task-status-001");
+        assert.equal(events.length, 1);
+        assert.equal(events[0].status, "completed");
+        assert.equal(events[0].kind, "task_status");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#158: updateTaskResult updates agent_tasks status and result", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-result-001", "coder", "result test", "running");
+        dbModule.updateTaskResult("task-result-001", "completed", "output text");
+        const row = db.prepare("SELECT status, result FROM agent_tasks WHERE task_id = ?").get("task-result-001");
+        assert.equal(row.status, "completed");
+        assert.equal(row.result, "output text");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 // ---------------------------------------------------------------------------
 // normalizeSqliteTsToIso — unit tests
 // ---------------------------------------------------------------------------

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.24",
+  "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"