chapterhouse 0.3.22 → 0.3.23

package/dist/api/server.js

@@ -361,48 +361,90 @@ app.get("/api/workers/:taskId", (req, res) => {
         completedAt: row.completed_at,
     });
 });
-// Historical event log for a task (catch-up on page load / SSE reconnect).
-// Ring buffer (fast, in-memory) is checked first; falls back to SQLite for
-// completed tasks whose buffer has been cleared.
+const TERMINAL_TASK_STATUSES = new Set(["completed", "failed", "cancelled", "error"]);
+// SSE stream for per-task tool-call activity.
+// Replays buffered/persisted backlog on connect, then streams live events until
+// the task reaches a terminal state.
 app.get("/api/workers/:taskId/events", (req, res) => {
     const taskId = req.params.taskId;
-    const afterSeqRaw = req.query.afterSeq;
-    const afterSeq = typeof afterSeqRaw === "string" && !isNaN(Number(afterSeqRaw)) ? Number(afterSeqRaw) : 0;
     const taskRow = getDb()
         .prepare(`SELECT task_id FROM agent_tasks WHERE task_id = ?`)
         .get(taskId);
     if (!taskRow) {
         throw new NotFoundError("Task not found");
     }
-    const ringEvents = getTaskLogEvents(taskId, afterSeq);
-    const events = ringEvents.length > 0 ? ringEvents : getTaskEvents(taskId, afterSeq);
-    res.json({ taskId, events });
-});
-// SSE stream for per-task live tool-call activity.
-// Uses the ring-buffer subscriber (subscribeTaskLog) so events fire immediately
-// from in-memory state rather than needing an extra SQLite read.
-app.get("/api/workers/:taskId/events/stream", (req, res) => {
-    const taskId = req.params.taskId;
-    const taskRow = getDb()
-        .prepare(`SELECT task_id FROM agent_tasks WHERE task_id = ?`)
-        .get(taskId);
-    if (!taskRow) {
-        throw new NotFoundError("Task not found");
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    const rawLastId = req.headers["last-event-id"];
+    const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
+        ? parseInt(rawLastId.trim(), 10)
+        : undefined;
+    const sendEvent = (event) => {
+        const payload = {
+            taskId: event.taskId,
+            seq: event.seq,
+            ts: event.ts,
+            kind: event.kind,
+            toolName: event.toolName,
+            summary: event.summary,
+        };
+        res.write(`id: ${event.seq}\ndata: ${JSON.stringify(payload)}\n\n`);
+    };
+    let replayHighSeq = lastSeq;
+    if (lastSeq !== undefined) {
+        const bufferedEvents = getTaskLogEvents(taskId);
+        const oldestBufferedSeq = bufferedEvents[0]?.seq;
+        const bufferMissesRange = oldestBufferedSeq === undefined || oldestBufferedSeq > lastSeq + 1;
+        if (bufferMissesRange) {
+            const dbEvents = getTaskEvents(taskId, lastSeq);
+            for (const event of dbEvents) {
+                sendEvent(event);
+                if (replayHighSeq === undefined || event.seq > replayHighSeq) {
+                    replayHighSeq = event.seq;
+                }
+            }
+        }
     }
-    res.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        Connection: "keep-alive",
+    const replayEvents = getTaskLogEvents(taskId, replayHighSeq ?? 0);
+    const backlog = replayEvents.length > 0 ? replayEvents : getTaskEvents(taskId, replayHighSeq ?? 0);
+    for (const event of backlog) {
+        sendEvent(event);
+    }
+    const isTerminal = () => {
+        const row = getDb()
+            .prepare(`SELECT status FROM agent_tasks WHERE task_id = ?`)
+            .get(taskId);
+        return row ? TERMINAL_TASK_STATUSES.has(row.status) : true;
+    };
+    res.write(`: connected task=${taskId}\n\n`);
+    if (isTerminal()) {
+        res.end();
+        return;
+    }
+    const heartbeat = setInterval(() => {
+        res.write(`: keep-alive\n\n`);
+    }, 15_000);
+    const unsubscribeTaskLog = subscribeTaskLog(taskId, (event) => {
+        sendEvent(event);
     });
-    res.write(formatSseData({ type: "connected", taskId }));
-    const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
-    // subscribeTaskLog delivers ring-buffer-sourced events as they arrive.
-    const unsub = subscribeTaskLog(taskId, (event) => {
-        res.write(formatSseData({ type: "task_event", ...event }));
+    const unsubscribeDestroyed = agentEventBus.subscribe("session:destroyed", (event) => {
+        if (event.sessionId === taskId && isTerminal()) {
+            res.end();
+        }
+    });
+    const unsubscribeError = agentEventBus.subscribe("session:error", (event) => {
+        if (event.sessionId === taskId && isTerminal()) {
+            res.end();
+        }
     });
     req.on("close", () => {
         clearInterval(heartbeat);
-        unsub();
+        unsubscribeTaskLog();
+        unsubscribeDestroyed();
+        unsubscribeError();
     });
 });
 // ---------------------------------------------------------------------------

package/dist/api/worker-events-sse.integration.test.js

@@ -0,0 +1,336 @@
+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";
+const repoRoot = process.cwd();
+const testWorkRoot = join(repoRoot, ".test-work", `worker-events-sse-${process.pid}`);
+let instanceCounter = 0;
+const CONTROL_PREFIX = "__CH__";
+const READY_PREFIX = "__CH_READY__";
+const controlledServerScript = `
+import readline from "node:readline";
+import { startApiServer } from "./dist/api/server.js";
+import { agentEventBus } from "./dist/copilot/agent-event-bus.js";
+import { initTaskEventLog } from "./dist/copilot/task-event-log.js";
+import { appendTaskEvent, getDb } from "./dist/store/db.js";
+
+const db = getDb();
+initTaskEventLog();
+const reply = (payload) => process.stdout.write("${CONTROL_PREFIX}" + JSON.stringify(payload) + "\\n");
+
+function emitTaskEvent(taskId, kind, toolName, summary) {
+  const event = appendTaskEvent(taskId, kind, toolName ?? null, summary ?? null);
+  if (!event) {
+    throw new Error("appendTaskEvent returned undefined");
+  }
+  agentEventBus.emit({
+    type: "session:tool_call",
+    sessionId: taskId,
+    payload: {
+      _kind: event.kind,
+      _seq: event.seq,
+      _ts: event.ts,
+      _summary: event.summary,
+      ...(event.toolName ? { toolName: event.toolName } : {}),
+    },
+  });
+  return event;
+}
+
+await startApiServer();
+process.stdout.write("${READY_PREFIX}\\n");
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+for await (const line of rl) {
+  if (!line.trim()) continue;
+
+  const command = JSON.parse(line);
+  try {
+    switch (command.type) {
+      case "createTask":
+        db.prepare(
+          "INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)"
+        ).run(command.taskId, command.agentSlug ?? "coder", command.description ?? "Test worker task", command.status ?? "running");
+        reply({ ok: true });
+        break;
+      case "appendEvent":
+        reply({
+          ok: true,
+          event: emitTaskEvent(command.taskId, command.kind, command.toolName ?? null, command.summary ?? null),
+        });
+        break;
+      case "finishTask": {
+        db.prepare(
+          "UPDATE agent_tasks SET status = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?"
+        ).run(command.status, command.taskId);
+        agentEventBus.emit({
+          type: command.status === "failed" ? "session:error" : "session:destroyed",
+          sessionId: command.taskId,
+          payload: command.status === "failed"
+            ? { agentName: command.agentName ?? "coder", error: command.reason ?? "Task failed" }
+            : { agentName: command.agentName ?? "coder", reason: command.reason ?? "complete" },
+        });
+        reply({ ok: true });
+        break;
+      }
+      default:
+        throw new Error(\`Unknown command: \${command.type}\`);
+    }
+  } catch (error) {
+    reply({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+}
+`;
+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");
+    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 withControlledServer(run, timeoutMs = 30_000) {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    const instanceRoot = `${testWorkRoot}-${Date.now()}-${++instanceCounter}`;
+    rmSync(instanceRoot, { recursive: true, force: true });
+    mkdirSync(instanceRoot, { recursive: true });
+    const port = await getFreePort();
+    const logs = [];
+    let stdoutBuffer = "";
+    let readyResolve;
+    let readyReject;
+    const ready = new Promise((resolve, reject) => {
+        readyResolve = resolve;
+        readyReject = reject;
+    });
+    const pendingReplies = [];
+    const child = spawn(process.execPath, ["--input-type=module", "-e", controlledServerScript], {
+        cwd: repoRoot,
+        env: {
+            ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("COPILOT_") && !key.startsWith("NODE_TEST_"))),
+            CHAPTERHOUSE_DISABLE_DOTENV: "1",
+            CHAPTERHOUSE_HOME: instanceRoot,
+            API_HOST: "127.0.0.1",
+            API_PORT: String(port),
+            API_TOKEN: "test-token",
+        },
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    child.stdout?.on("data", (chunk) => {
+        stdoutBuffer += String(chunk);
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line === READY_PREFIX) {
+                readyResolve?.();
+            }
+            else if (line.startsWith(CONTROL_PREFIX)) {
+                const pending = pendingReplies.shift();
+                if (!pending)
+                    continue;
+                clearTimeout(pending.timer);
+                pending.resolve(JSON.parse(line.slice(CONTROL_PREFIX.length)));
+            }
+            else if (line.length > 0) {
+                logs.push(`${line}\n`);
+            }
+        }
+    });
+    child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
+    const sendCommand = async (command) => {
+        assert.ok(child.stdin, "Controlled server stdin should be writable");
+        const reply = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Timed out waiting for control reply for ${command.type}`));
+            }, 2_000);
+            pendingReplies.push({ resolve, reject, timer });
+        });
+        child.stdin.write(`${JSON.stringify(command)}\n`);
+        const payload = await reply;
+        if (!payload.ok) {
+            throw new Error(payload.error ?? `Control command ${command.type} failed`);
+        }
+        return payload;
+    };
+    const baseUrl = `http://127.0.0.1:${port}`;
+    try {
+        const timeout = setTimeout(() => {
+            readyReject?.(new Error(`Server did not start in ${timeoutMs}ms:\n${logs.join("")}`));
+        }, timeoutMs);
+        try {
+            await ready;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (child.exitCode !== null) {
+            throw new Error(`Server exited early:\n${logs.join("")}`);
+        }
+        await run({ baseUrl, authHeader: "Bearer test-token", sendCommand });
+    }
+    finally {
+        child.stdin?.end();
+        await stopChild(child);
+        rmSync(instanceRoot, { recursive: true, force: true });
+    }
+}
+function createSseReader(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let leftover = "";
+    function drainFrames() {
+        const frames = [];
+        const parts = leftover.split("\n\n");
+        leftover = parts.pop() ?? "";
+        for (const part of parts) {
+            if (!part.trim())
+                continue;
+            const frame = { data: null };
+            for (const line of part.split("\n")) {
+                if (line.startsWith(":"))
+                    continue;
+                if (line.startsWith("id: "))
+                    frame.id = line.slice(4);
+                else if (line.startsWith("event: "))
+                    frame.event = line.slice(7);
+                else if (line.startsWith("data: ")) {
+                    try {
+                        frame.data = JSON.parse(line.slice(6));
+                    }
+                    catch {
+                        frame.data = line.slice(6);
+                    }
+                }
+            }
+            if (frame.data !== null)
+                frames.push(frame);
+        }
+        return frames;
+    }
+    async function readFrames(count, timeoutMs = 3_000) {
+        const frames = [];
+        const deadline = Date.now() + timeoutMs;
+        while (frames.length < count && Date.now() < deadline) {
+            const { value, done } = await Promise.race([
+                reader.read(),
+                new Promise((resolve) => setTimeout(() => resolve({ value: undefined, done: false }), 200)),
+            ]);
+            if (done)
+                break;
+            if (value !== undefined) {
+                leftover += decoder.decode(value, { stream: true });
+                frames.push(...drainFrames());
+            }
+        }
+        return frames;
+    }
+    async function waitForClose(timeoutMs = 3_000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const { value, done } = await Promise.race([
+                reader.read(),
+                new Promise((resolve) => setTimeout(() => resolve({ value: undefined, done: false }), 200)),
+            ]);
+            if (done)
+                return true;
+            if (value !== undefined) {
+                leftover += decoder.decode(value, { stream: true });
+                void drainFrames();
+            }
+        }
+        return false;
+    }
+    async function cancel() {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Ignore already-closed streams.
+        }
+    }
+    return { readFrames, waitForClose, cancel };
+}
+test("worker events SSE replays backlog, streams live events, and closes on completion", async () => {
+    await withControlledServer(async ({ baseUrl, authHeader, sendCommand }) => {
+        const taskId = "worker-events-sse-001";
+        await sendCommand({
+            type: "createTask",
+            taskId,
+            description: "Stream worker task events",
+            status: "running",
+        });
+        await sendCommand({
+            type: "appendEvent",
+            taskId,
+            kind: "tool_start",
+            toolName: "bash",
+            summary: "npm run build",
+        });
+        await sendCommand({
+            type: "appendEvent",
+            taskId,
+            kind: "tool_complete",
+            summary: "build complete",
+        });
+        const response = await fetch(`${baseUrl}/api/workers/${taskId}/events`, {
+            headers: {
+                Authorization: authHeader,
+                Accept: "text/event-stream",
+            },
+        });
+        assert.equal(response.status, 200);
+        assert.ok(response.headers.get("content-type")?.includes("text/event-stream"), `Content-Type should include text/event-stream, got ${response.headers.get("content-type")}`);
+        assert.ok(response.body, "SSE response should have a readable body");
+        const reader = createSseReader(response.body);
+        try {
+            const backlogFrames = await reader.readFrames(2, 2_000);
+            assert.equal(backlogFrames.length, 2, "Expected backlog replay frames");
+            assert.deepEqual(backlogFrames.map((frame) => frame.id), ["1", "2"], "Backlog frames should preserve task event sequence ids");
+            const backlogKinds = backlogFrames.map((frame) => frame.data.kind);
+            assert.deepEqual(backlogKinds, ["tool_start", "tool_complete"]);
+            await sendCommand({
+                type: "appendEvent",
+                taskId,
+                kind: "tool_start",
+                toolName: "view",
+                summary: "README.md",
+            });
+            const liveFrames = await reader.readFrames(1, 2_000);
+            assert.equal(liveFrames.length, 1, "Expected one live frame");
+            assert.equal(liveFrames[0]?.id, "3");
+            assert.deepEqual(liveFrames[0]?.data, {
+                taskId,
+                seq: 3,
+                ts: (liveFrames[0]?.data).ts,
+                kind: "tool_start",
+                toolName: "view",
+                summary: "README.md",
+            });
+            await sendCommand({
+                type: "finishTask",
+                taskId,
+                status: "completed",
+                reason: "complete",
+            });
+            assert.equal(await reader.waitForClose(2_000), true, "SSE stream should close when the task completes");
+        }
+        finally {
+            await reader.cancel();
+        }
+    }, 30_000);
+});
+//# sourceMappingURL=worker-events-sse.integration.test.js.map

package/dist/copilot/orchestrator.js

@@ -574,10 +574,16 @@ async function executeOnSession(manager, item) {
         });
         const unsubSubDoneDb = session.on("subagent.completed", (event) => {
             try {
-                spawnArgsMap.delete(event.data.toolCallId);
-                activeSubagentTaskIds.delete(event.data.toolCallId);
-                db.prepare(`UPDATE agent_tasks SET status = 'completed', completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(event.data.toolCallId);
-                const taskId = event.data.toolCallId;
+                const doneData = event.data;
+                const taskId = String(doneData.toolCallId ?? "");
+                const finalResult = typeof doneData.result?.detailedContent === "string"
+                    ? doneData.result.detailedContent
+                    : typeof doneData.result?.content === "string"
+                        ? doneData.result.content
+                        : null;
+                spawnArgsMap.delete(taskId);
+                activeSubagentTaskIds.delete(taskId);
+                db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(finalResult?.slice(0, 10000) ?? null, taskId);
                 const taskRow = db.prepare(`SELECT agent_slug FROM agent_tasks WHERE task_id = ?`).get(taskId);
                 void agentEventBus.emit({
                     type: "session:destroyed",
@@ -587,7 +593,6 @@ async function executeOnSession(manager, item) {
                     timestamp: new Date(),
                 });
                 // Emit turn:delta with subagent completed part (coexistence — #130)
-                const doneData = event.data;
                 const donePart = {
                     type: "subagent",
                     toolCallId: String(doneData.toolCallId ?? ""),

package/dist/copilot/orchestrator.test.js

@@ -914,7 +914,7 @@ test("S5-01: subagent.started event inserts an adhoc row into agent_tasks", asyn
     // 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) => {
+test("S5-01: subagent.completed event persists final result text to agent_tasks", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         sendResult: "__PENDING__",
     });
@@ -934,10 +934,15 @@ test("S5-01: subagent.completed event updates agent_tasks status to completed",
         agentName: "Wash",
         agentDisplayName: "Wash — Frontend Dev",
         durationMs: 1234,
+        result: {
+            detailedContent: "Workers tab refreshes with persisted final output",
+        },
     });
     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(updateWrite.sql.includes("result = ?"), "completed subagent updates must persist the final result text");
     assert.ok(JSON.stringify(updateWrite.args).includes("subagent-call-002"), "UPDATE must target the correct task_id");
+    assert.ok(JSON.stringify(updateWrite.args).includes("Workers tab refreshes with persisted final output"), "UPDATE must store the final result text in agent_tasks.result");
     state.pendingReject?.(new Error("test teardown"));
 });
 test("S5-01: subagent.failed event updates agent_tasks status to error", async (t) => {

package/dist/copilot/task-event-log.js

@@ -7,11 +7,12 @@
  * in sync without the caller needing to wire anything extra.
  *
  * Consumers:
- *  1. `GET /api/workers/:taskId/events` — REST hydration on page-load / SSE reconnect.
- *     The ring buffer is checked first (fast path, in-memory); SQLite is the fallback
- *     for completed tasks whose ring buffer has been cleared.
- *  2. Per-task SSE subscribers — `subscribeTaskLog` delivers events as they arrive
- *     so the SSE frame fires immediately (no SQLite round-trip).
+ *  1. `GET /api/workers/:taskId/events` — SSE backlog replay on connect and
+ *     reconnect. The ring buffer is checked first (fast path, in-memory);
+ *     SQLite is the fallback for completed tasks whose ring buffer has been
+ *     cleared.
+ *  2. Per-task SSE subscribers — `subscribeTaskLog` delivers live events as
+ *     they arrive so the SSE frame fires immediately (no SQLite round-trip).
  *
  * Lifecycle:
  *  - `initTaskEventLog()` must be called once from `initOrchestrator()`.

package/package.json

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