chapterhouse 0.3.24 → 0.3.25

package/dist/api/server.js

@@ -383,14 +383,34 @@ app.get("/api/workers/:taskId/events", (req, res) => {
         ? 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,
-        };
+        let payload;
+        if (event.kind === "output_delta") {
+            payload = {
+                type: "output_delta",
+                taskId: event.taskId,
+                seq: event.seq,
+                text: event.text ?? "",
+            };
+        }
+        else if (event.kind === "task_status") {
+            payload = {
+                type: "task_status",
+                taskId: event.taskId,
+                seq: event.seq,
+                status: event.status ?? "running",
+                summary: event.summary,
+            };
+        }
+        else {
+            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;
@@ -427,24 +447,41 @@ app.get("/api/workers/:taskId/events", (req, res) => {
     const heartbeat = setInterval(() => {
         res.write(`: keep-alive\n\n`);
     }, 15_000);
-    const unsubscribeTaskLog = subscribeTaskLog(taskId, (event) => {
+    let cleaned = false;
+    let unsubscribeTaskLog;
+    let unsubscribeDestroyed;
+    let unsubscribeError;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        clearInterval(heartbeat);
+        unsubscribeTaskLog?.();
+        unsubscribeDestroyed?.();
+        unsubscribeError?.();
+    };
+    unsubscribeTaskLog = subscribeTaskLog(taskId, (event) => {
         sendEvent(event);
+        // Close SSE when a terminal task_status event arrives
+        if (event.kind === "task_status" && event.status && TERMINAL_TASK_STATUSES.has(event.status)) {
+            cleanup();
+            res.end();
+        }
     });
-    const unsubscribeDestroyed = agentEventBus.subscribe("session:destroyed", (event) => {
+    unsubscribeDestroyed = agentEventBus.subscribe("session:destroyed", (event) => {
         if (event.sessionId === taskId && isTerminal()) {
+            cleanup();
             res.end();
         }
     });
-    const unsubscribeError = agentEventBus.subscribe("session:error", (event) => {
+    unsubscribeError = agentEventBus.subscribe("session:error", (event) => {
         if (event.sessionId === taskId && isTerminal()) {
+            cleanup();
             res.end();
         }
     });
     req.on("close", () => {
-        clearInterval(heartbeat);
-        unsubscribeTaskLog();
-        unsubscribeDestroyed();
-        unsubscribeError();
+        cleanup();
     });
 });
 // ---------------------------------------------------------------------------

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

@@ -14,7 +14,7 @@ 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";
+import { appendTaskEvent, appendTaskOutputDeltaEvent, appendTaskStatusEvent, getDb } from "./dist/store/db.js";
 
 const db = getDb();
 initTaskEventLog();
@@ -33,12 +33,58 @@ function emitTaskEvent(taskId, kind, toolName, summary) {
       _seq: event.seq,
       _ts: event.ts,
       _summary: event.summary,
+      _text: event.text,
+      _status: event.status,
       ...(event.toolName ? { toolName: event.toolName } : {}),
     },
   });
   return event;
 }
 
+function emitOutputDelta(taskId, text) {
+  const event = appendTaskOutputDeltaEvent(taskId, text);
+  if (!event) {
+    throw new Error("appendTaskOutputDeltaEvent returned undefined");
+  }
+  agentEventBus.emit({
+    type: "session:tool_call",
+    sessionId: taskId,
+    payload: {
+      toolName: "",
+      toolArgs: {},
+      _kind: event.kind,
+      _seq: event.seq,
+      _ts: event.ts,
+      _summary: null,
+      _text: event.text,
+      _status: null,
+    },
+  });
+  return event;
+}
+
+function emitStatusEvent(taskId, status, summary) {
+  const event = appendTaskStatusEvent(taskId, status, summary ?? null);
+  if (!event) {
+    throw new Error("appendTaskStatusEvent returned undefined");
+  }
+  agentEventBus.emit({
+    type: "session:tool_call",
+    sessionId: taskId,
+    payload: {
+      toolName: "",
+      toolArgs: {},
+      _kind: event.kind,
+      _seq: event.seq,
+      _ts: event.ts,
+      _summary: event.summary,
+      _text: null,
+      _status: event.status,
+    },
+  });
+  return event;
+}
+
 await startApiServer();
 process.stdout.write("${READY_PREFIX}\\n");
 
@@ -61,6 +107,18 @@ for await (const line of rl) {
           event: emitTaskEvent(command.taskId, command.kind, command.toolName ?? null, command.summary ?? null),
         });
         break;
+      case "appendOutputDelta":
+        reply({
+          ok: true,
+          event: emitOutputDelta(command.taskId, command.text),
+        });
+        break;
+      case "appendStatusEvent":
+        reply({
+          ok: true,
+          event: emitStatusEvent(command.taskId, command.status, command.summary ?? null),
+        });
+        break;
       case "finishTask": {
         db.prepare(
           "UPDATE agent_tasks SET status = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?"
@@ -333,4 +391,186 @@ test("worker events SSE replays backlog, streams live events, and closes on comp
         }
     }, 30_000);
 });
+test("worker events SSE streams output_delta events in backlog and live", async () => {
+    await withControlledServer(async ({ baseUrl, authHeader, sendCommand }) => {
+        const taskId = "worker-events-sse-delta-001";
+        await sendCommand({
+            type: "createTask",
+            taskId,
+            description: "Stream output deltas",
+            status: "running",
+        });
+        await sendCommand({
+            type: "appendOutputDelta",
+            taskId,
+            text: "Hello ",
+        });
+        await sendCommand({
+            type: "appendOutputDelta",
+            taskId,
+            text: "world!",
+        });
+        const response = await fetch(`${baseUrl}/api/workers/${taskId}/events`, {
+            headers: {
+                Authorization: authHeader,
+                Accept: "text/event-stream",
+            },
+        });
+        assert.equal(response.status, 200);
+        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 2 backlog output_delta frames");
+            assert.deepEqual(backlogFrames[0]?.data, {
+                type: "output_delta",
+                taskId,
+                seq: 1,
+                text: "Hello ",
+            });
+            assert.deepEqual(backlogFrames[1]?.data, {
+                type: "output_delta",
+                taskId,
+                seq: 2,
+                text: "world!",
+            });
+            assert.equal(backlogFrames[0]?.id, "1");
+            assert.equal(backlogFrames[1]?.id, "2");
+            // Live output_delta
+            await sendCommand({
+                type: "appendOutputDelta",
+                taskId,
+                text: " More text.",
+            });
+            const liveFrames = await reader.readFrames(1, 2_000);
+            assert.equal(liveFrames.length, 1);
+            assert.deepEqual(liveFrames[0]?.data, {
+                type: "output_delta",
+                taskId,
+                seq: 3,
+                text: " More text.",
+            });
+            await sendCommand({
+                type: "finishTask",
+                taskId,
+                status: "completed",
+                reason: "done",
+            });
+            assert.equal(await reader.waitForClose(2_000), true);
+        }
+        finally {
+            await reader.cancel();
+        }
+    }, 30_000);
+});
+test("worker events SSE closes on terminal task_status event", async () => {
+    await withControlledServer(async ({ baseUrl, authHeader, sendCommand }) => {
+        const taskId = "worker-events-sse-status-001";
+        await sendCommand({
+            type: "createTask",
+            taskId,
+            description: "Task status close test",
+            status: "running",
+        });
+        const response = await fetch(`${baseUrl}/api/workers/${taskId}/events`, {
+            headers: {
+                Authorization: authHeader,
+                Accept: "text/event-stream",
+            },
+        });
+        assert.equal(response.status, 200);
+        assert.ok(response.body, "SSE response should have a readable body");
+        const reader = createSseReader(response.body);
+        try {
+            // Emit a task_status completed event (which also marks DB terminal)
+            await sendCommand({
+                type: "appendStatusEvent",
+                taskId,
+                status: "completed",
+                summary: "All done",
+            });
+            // Also mark in DB so isTerminal() returns true
+            await sendCommand({
+                type: "finishTask",
+                taskId,
+                status: "completed",
+                reason: "complete",
+            });
+            const frames = await reader.readFrames(1, 2_000);
+            assert.ok(frames.length >= 1, "Expected at least one task_status frame");
+            const statusFrame = frames.find((f) => f.data.type === "task_status");
+            assert.ok(statusFrame, "Should have received a task_status frame");
+            assert.deepEqual(statusFrame?.data, {
+                type: "task_status",
+                taskId,
+                seq: 1,
+                status: "completed",
+                summary: "All done",
+            });
+            assert.equal(await reader.waitForClose(2_000), true, "SSE should close on terminal task_status");
+        }
+        finally {
+            await reader.cancel();
+        }
+    }, 30_000);
+});
+test("worker events SSE Last-Event-ID skips output_delta events before the ID", async () => {
+    await withControlledServer(async ({ baseUrl, authHeader, sendCommand }) => {
+        const taskId = "worker-events-sse-reconnect-001";
+        await sendCommand({
+            type: "createTask",
+            taskId,
+            description: "Reconnect test",
+            status: "running",
+        });
+        await sendCommand({
+            type: "appendOutputDelta",
+            taskId,
+            text: "chunk-1",
+        });
+        await sendCommand({
+            type: "appendOutputDelta",
+            taskId,
+            text: "chunk-2",
+        });
+        await sendCommand({
+            type: "appendEvent",
+            taskId,
+            kind: "tool_start",
+            toolName: "bash",
+            summary: "echo hi",
+        });
+        // Reconnect after seq 1 — should only get seq 2 and 3
+        const response = await fetch(`${baseUrl}/api/workers/${taskId}/events`, {
+            headers: {
+                Authorization: authHeader,
+                Accept: "text/event-stream",
+                "Last-Event-ID": "1",
+            },
+        });
+        assert.equal(response.status, 200);
+        assert.ok(response.body);
+        const reader = createSseReader(response.body);
+        try {
+            const frames = await reader.readFrames(2, 2_000);
+            assert.equal(frames.length, 2, "Expected 2 frames after Last-Event-ID=1");
+            assert.equal(frames[0]?.id, "2");
+            assert.deepEqual(frames[0]?.data, {
+                type: "output_delta",
+                taskId,
+                seq: 2,
+                text: "chunk-2",
+            });
+            assert.equal(frames[1]?.id, "3");
+            // tool_start events use the old format
+            const toolFrame = frames[1]?.data;
+            assert.equal(toolFrame.kind, "tool_start");
+            assert.equal(toolFrame.toolName, "bash");
+        }
+        finally {
+            await reader.cancel();
+            await sendCommand({ type: "finishTask", taskId, status: "completed", reason: "done" });
+        }
+    }, 30_000);
+});
 //# sourceMappingURL=worker-events-sse.integration.test.js.map

package/dist/copilot/orchestrator.js

@@ -97,6 +97,8 @@ function emitTaskEvent(taskId, event) {
             _seq: event.seq,
             _ts: event.ts,
             _summary: event.summary,
+            _text: event.text ?? null,
+            _status: event.status ?? null,
         },
         timestamp: new Date(event.ts),
     });

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

@@ -69,14 +69,19 @@ export function initTaskEventLog() {
         if (!taskId)
             return;
         const p = event.payload;
+        const kind = p._kind === "tool_complete" || p._kind === "output_delta" || p._kind === "task_status"
+            ? p._kind
+            : "tool_start";
         const taskEvent = {
             id: 0, // not a DB row — id is meaningless for ring-buffer entries
             taskId,
             seq: p._seq ?? 0,
             ts: p._ts ?? Date.now(),
-            kind: p._kind === "tool_complete" ? "tool_complete" : "tool_start",
+            kind,
             toolName: p.toolName ?? null,
             summary: p._summary ?? null,
+            text: p._text ?? null,
+            status: p._status ?? null,
         };
         const buf = getOrCreateBuffer(taskId);
         buf.push(taskEvent);

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

@@ -197,5 +197,50 @@ describe("task event log — bus-wired", () => {
         assert.equal(getTaskLogEvents("task-Y").length, 0);
         clearTaskLog("task-X");
     });
+    it("preserves output_delta payloads from the bus for live subscribers", () => {
+        agentEventBus.emit({
+            type: "session:tool_call",
+            sessionId: "task-output-live",
+            payload: {
+                toolName: "",
+                toolArgs: {},
+                _kind: "output_delta",
+                _seq: 4,
+                _ts: Date.now(),
+                _summary: null,
+                _text: "chunk-1",
+                _status: null,
+            },
+            timestamp: new Date(),
+        });
+        const events = getTaskLogEvents("task-output-live");
+        assert.equal(events.length, 1);
+        assert.equal(events[0].kind, "output_delta");
+        assert.equal(events[0].text, "chunk-1");
+        clearTaskLog("task-output-live");
+    });
+    it("preserves task_status payloads from the bus", () => {
+        agentEventBus.emit({
+            type: "session:tool_call",
+            sessionId: "task-status-live",
+            payload: {
+                toolName: "",
+                toolArgs: {},
+                _kind: "task_status",
+                _seq: 5,
+                _ts: Date.now(),
+                _summary: "All done",
+                _text: null,
+                _status: "completed",
+            },
+            timestamp: new Date(),
+        });
+        const events = getTaskLogEvents("task-status-live");
+        assert.equal(events.length, 1);
+        assert.equal(events[0].kind, "task_status");
+        assert.equal(events[0].status, "completed");
+        assert.equal(events[0].summary, "All done");
+        clearTaskLog("task-status-live");
+    });
 });
 //# sourceMappingURL=task-event-log.test.js.map

package/dist/copilot/tools.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
 import { approveAll, defineTool } from "@github/copilot-sdk";
-import { getDb } from "../store/db.js";
+import { getDb, appendTaskOutputDeltaEvent, appendTaskStatusEvent, updateTaskResult } from "../store/db.js";
 import { readdirSync, readFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
+import { agentEventBus } from "./agent-event-bus.js";
 import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
@@ -137,6 +138,34 @@ export function createTools(deps) {
                 // `executeOnSession` finishes.
                 const parentActivity = getCurrentActivityCallback();
                 const childUnsubs = [];
+                const emitTaskLogEvent = (taskEvent) => {
+                    void agentEventBus.emit({
+                        type: "session:tool_call",
+                        sessionId: task.taskId,
+                        payload: {
+                            toolName: "",
+                            toolArgs: {},
+                            _kind: taskEvent.kind,
+                            _seq: taskEvent.seq,
+                            _ts: taskEvent.ts,
+                            _summary: taskEvent.summary,
+                            _text: taskEvent.text,
+                            _status: taskEvent.status,
+                        },
+                        timestamp: new Date(taskEvent.ts),
+                    });
+                };
+                let workerOutput = "";
+                childUnsubs.push(session.on("assistant.message_delta", (event) => {
+                    const delta = typeof event.data.deltaContent === "string" ? event.data.deltaContent : "";
+                    if (!delta)
+                        return;
+                    workerOutput += delta;
+                    const taskEvent = appendTaskOutputDeltaEvent(task.taskId, delta);
+                    if (!taskEvent)
+                        return;
+                    emitTaskLogEvent(taskEvent);
+                }));
                 if (parentActivity) {
                     childUnsubs.push(session.on("assistant.reasoning_delta", (event) => {
                         parentActivity({
@@ -179,15 +208,21 @@ export function createTools(deps) {
                 (async () => {
                     try {
                         const result = await session.sendAndWait({ prompt: taskPrompt }, timeoutMs);
-                        const output = result?.data?.content || "No response";
+                        const output = workerOutput || result?.data?.content || "No response";
                         completeTask(task.taskId, output);
-                        db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(output.slice(0, 10000), task.taskId);
+                        updateTaskResult(task.taskId, "completed", output);
+                        const statusEvent = appendTaskStatusEvent(task.taskId, "completed");
+                        if (statusEvent)
+                            emitTaskLogEvent(statusEvent);
                         deps.onAgentTaskComplete(task.taskId, delegatedSlug, output);
                     }
                     catch (err) {
                         const msg = err instanceof Error ? err.message : String(err);
                         failTask(task.taskId, msg);
-                        db.prepare(`UPDATE agent_tasks SET status = 'error', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(msg, task.taskId);
+                        updateTaskResult(task.taskId, "error", msg);
+                        const statusEvent = appendTaskStatusEvent(task.taskId, "error", msg);
+                        if (statusEvent)
+                            emitTaskLogEvent(statusEvent);
                         deps.onAgentTaskComplete(task.taskId, delegatedSlug, `Error: ${msg}`);
                     }
                     finally {

package/dist/store/db.js

@@ -126,19 +126,45 @@ export function getDb() {
         if (!taskCols.some((c) => c.name === "prompt")) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN prompt TEXT`);
         }
-        // agent_task_events: append-only per-task tool-call activity log for /workers streaming
+        // agent_task_events: append-only per-task activity log for /workers streaming
         db.exec(`
       CREATE TABLE IF NOT EXISTS agent_task_events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         task_id TEXT NOT NULL REFERENCES agent_tasks(task_id) ON DELETE CASCADE,
         seq INTEGER NOT NULL,
         ts INTEGER NOT NULL,
-        kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete')),
+        kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete', 'output_delta', 'task_status')),
         tool_name TEXT,
-        summary TEXT
+        summary TEXT,
+        text TEXT,
+        status TEXT
       )
     `);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
+        // Migrate existing agent_task_events tables that lack text/status columns
+        const taskEventCols = db.prepare(`PRAGMA table_info(agent_task_events)`).all();
+        if (!taskEventCols.some((c) => c.name === "text") || !taskEventCols.some((c) => c.name === "status")) {
+            db.exec(`ALTER TABLE agent_task_events RENAME TO agent_task_events_old`);
+            db.exec(`
+        CREATE TABLE agent_task_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task_id TEXT NOT NULL REFERENCES agent_tasks(task_id) ON DELETE CASCADE,
+          seq INTEGER NOT NULL,
+          ts INTEGER NOT NULL,
+          kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete', 'output_delta', 'task_status')),
+          tool_name TEXT,
+          summary TEXT,
+          text TEXT,
+          status TEXT
+        )
+      `);
+            db.exec(`
+        INSERT INTO agent_task_events (id, task_id, seq, ts, kind, tool_name, summary)
+        SELECT id, task_id, seq, ts, kind, tool_name, summary FROM agent_task_events_old
+      `);
+            db.exec(`DROP TABLE agent_task_events_old`);
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
+        }
         // Migrate: add event_seq column to agent_tasks for monotonic event numbering
         const taskColsNow = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
         if (!taskColsNow.some((c) => c.name === 'event_seq')) {
@@ -342,7 +368,7 @@ export function getSessionMessages(sessionKey, limit) {
  * Uses a transaction so seq is monotonically incremented.
  * Non-fatal: silently ignores DB errors (task may not exist yet due to race).
  */
-export function appendTaskEvent(taskId, kind, toolName, summary) {
+export function appendTaskEvent(taskId, kind, toolName, summary, text = null, status = null) {
     const db = getDb();
     try {
         return db.transaction(() => {
@@ -352,20 +378,30 @@ export function appendTaskEvent(taskId, kind, toolName, summary) {
                 return undefined;
             const seq = row.event_seq;
             const ts = Date.now();
-            const info = db.prepare(`INSERT INTO agent_task_events (task_id, seq, ts, kind, tool_name, summary) VALUES (?, ?, ?, ?, ?, ?)`).run(taskId, seq, ts, kind, toolName, summary);
-            return { id: Number(info.lastInsertRowid), taskId, seq, ts, kind, toolName, summary };
+            const info = db.prepare(`INSERT INTO agent_task_events (task_id, seq, ts, kind, tool_name, summary, text, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(taskId, seq, ts, kind, toolName, summary, text, status);
+            return { id: Number(info.lastInsertRowid), taskId, seq, ts, kind, toolName, summary, text, status };
         })();
     }
     catch {
         return undefined;
     }
 }
+export function appendTaskOutputDeltaEvent(taskId, text) {
+    return appendTaskEvent(taskId, "output_delta", null, null, text, null);
+}
+export function appendTaskStatusEvent(taskId, status, summary = null) {
+    return appendTaskEvent(taskId, "task_status", null, summary, null, status);
+}
+export function updateTaskResult(taskId, status, result) {
+    const db = getDb();
+    db.prepare(`UPDATE agent_tasks SET status = ?, result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(status, result ? result.slice(0, 10000) : null, taskId);
+}
 /**
  * Return all events for a task ordered by seq ascending.
  */
 export function getTaskEvents(taskId, afterSeq = 0) {
     const db = getDb();
-    const rows = db.prepare(`SELECT id, task_id, seq, ts, kind, tool_name, summary
+    const rows = db.prepare(`SELECT id, task_id, seq, ts, kind, tool_name, summary, text, status
      FROM agent_task_events WHERE task_id = ? AND seq > ? ORDER BY seq ASC`).all(taskId, afterSeq);
     return rows.map((r) => ({
         id: r.id,
@@ -375,6 +411,8 @@ export function getTaskEvents(taskId, afterSeq = 0) {
         kind: r.kind,
         toolName: r.tool_name,
         summary: r.summary,
+        text: r.text,
+        status: r.status,
     }));
 }
 export function closeDb() {