chapterhouse 0.3.23 → 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/server.test.js

@@ -68,6 +68,47 @@ test("formats named SSE status events", async () => {
     assert.equal(sse.formatSseEvent("status", { status: "dreaming", message: "Consolidating memories..." }), 'event: status\ndata: {"status":"dreaming","message":"Consolidating memories..."}\n\n');
 });
 const repoRoot = process.cwd();
+function getProjectDbPath(testRoot) {
+    return join(testRoot, ".chapterhouse", "chapterhouse.db");
+}
+function seedProjectRegistry(testRoot, registry) {
+    mkdirSync(join(testRoot, ".chapterhouse"), { recursive: true });
+    const db = new Database(getProjectDbPath(testRoot));
+    try {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        slug TEXT PRIMARY KEY,
+        cwd TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.prepare("DELETE FROM projects").run();
+        const insert = db.prepare(`
+      INSERT INTO projects (slug, cwd, created_at, updated_at)
+      VALUES (?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+    `);
+        for (const [slug, cwd] of Object.entries(registry).sort(([left], [right]) => left.localeCompare(right))) {
+            insert.run(slug, cwd);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+function readProjectRegistryRows(testRoot) {
+    const dbPath = getProjectDbPath(testRoot);
+    if (!existsSync(dbPath)) {
+        return [];
+    }
+    const db = new Database(dbPath, { readonly: true });
+    try {
+        return db.prepare("SELECT slug, cwd FROM projects ORDER BY slug").all();
+    }
+    finally {
+        db.close();
+    }
+}
 async function getFreePort() {
     const server = createServer();
     await new Promise((resolve) => {
@@ -402,19 +443,10 @@ test("server projects route returns an empty list when the registry is missing",
 });
 test("server projects route sorts by slug and summarizes rule counts", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const projectsIndexPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "index.md");
-        mkdirSync(join(projectsIndexPath, ".."), { recursive: true });
-        writeFileSync(projectsIndexPath, "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "zeta: /srv/zeta\n"
-            + "alpha: /srv/alpha\n"
-            + "```\n", "utf-8");
+        seedProjectRegistry(testRoot, {
+            zeta: "/srv/zeta",
+            alpha: "/srv/alpha",
+        });
         const alphaRulesPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "alpha", "rules.md");
         mkdirSync(join(alphaRulesPath, ".."), { recursive: true });
         writeFileSync(alphaRulesPath, "---\n"
@@ -448,18 +480,9 @@ test("server projects route sorts by slug and summarizes rule counts", async ()
 });
 test("server project detail route returns cwd plus hard and soft rules", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const projectsIndexPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "index.md");
-        mkdirSync(join(projectsIndexPath, ".."), { recursive: true });
-        writeFileSync(projectsIndexPath, "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "alpha: /srv/alpha\n"
-            + "```\n", "utf-8");
+        seedProjectRegistry(testRoot, {
+            alpha: "/srv/alpha",
+        });
         const alphaRulesPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "alpha", "rules.md");
         mkdirSync(join(alphaRulesPath, ".."), { recursive: true });
         writeFileSync(alphaRulesPath, "---\n"
@@ -509,18 +532,9 @@ test("server project detail route returns 404 for an unknown slug", async () =>
 });
 test("server projects create route rejects a duplicate slug", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const projectsIndexPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "index.md");
-        mkdirSync(join(projectsIndexPath, ".."), { recursive: true });
-        writeFileSync(projectsIndexPath, "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "alpha: /srv/original\n"
-            + "```\n", "utf-8");
+        seedProjectRegistry(testRoot, {
+            alpha: "/srv/original",
+        });
         const response = await fetch(`${baseUrl}/api/projects`, {
             method: "POST",
             headers: {
@@ -534,33 +548,17 @@ test("server projects create route rejects a duplicate slug", async () => {
         });
         assert.equal(response.status, 400);
         assert.deepEqual(await response.json(), { error: "Project 'alpha' already exists" });
-        assert.equal(readFileSync(projectsIndexPath, "utf-8"), "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "alpha: /srv/original\n"
-            + "```\n");
+        assert.deepEqual(readProjectRegistryRows(testRoot), [
+            { slug: "alpha", cwd: "/srv/original" },
+        ]);
     }, {}, 60_000);
 });
 test("server projects delete route removes the registry entry and rules page", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const projectsIndexPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "index.md");
-        mkdirSync(join(projectsIndexPath, ".."), { recursive: true });
-        writeFileSync(projectsIndexPath, "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "alpha: /srv/alpha\n"
-            + "beta: /srv/beta\n"
-            + "```\n", "utf-8");
+        seedProjectRegistry(testRoot, {
+            alpha: "/srv/alpha",
+            beta: "/srv/beta",
+        });
         const alphaRulesPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "alpha", "rules.md");
         mkdirSync(join(alphaRulesPath, ".."), { recursive: true });
         writeFileSync(alphaRulesPath, "---\n"
@@ -574,16 +572,9 @@ test("server projects delete route removes the registry entry and rules page", a
         });
         assert.equal(response.status, 200);
         assert.deepEqual(await response.json(), { ok: true, slug: "alpha" });
-        assert.equal(readFileSync(projectsIndexPath, "utf-8"), "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "beta: /srv/beta\n"
-            + "```\n");
+        assert.deepEqual(readProjectRegistryRows(testRoot), [
+            { slug: "beta", cwd: "/srv/beta" },
+        ]);
         assert.equal(existsSync(alphaRulesPath), false);
     }, {}, 60_000);
 });
@@ -599,18 +590,9 @@ test("server projects delete route returns 404 for an unknown slug", async () =>
 });
 test("server project hard-rules update route rewrites only hard-rule frontmatter fields", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const projectsIndexPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "index.md");
-        mkdirSync(join(projectsIndexPath, ".."), { recursive: true });
-        writeFileSync(projectsIndexPath, "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "alpha: /srv/alpha\n"
-            + "```\n", "utf-8");
+        seedProjectRegistry(testRoot, {
+            alpha: "/srv/alpha",
+        });
         const alphaRulesPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "alpha", "rules.md");
         mkdirSync(join(alphaRulesPath, ".."), { recursive: true });
         writeFileSync(alphaRulesPath, "---\n"
@@ -688,18 +670,9 @@ test("server project hard-rules update route rewrites only hard-rule frontmatter
 });
 test("server project soft-rules update route rewrites the body while preserving frontmatter", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
-        const projectsIndexPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "index.md");
-        mkdirSync(join(projectsIndexPath, ".."), { recursive: true });
-        writeFileSync(projectsIndexPath, "---\n"
-            + "title: Projects\n"
-            + "summary: Canonical project registry.\n"
-            + "updated: 2026-05-12\n"
-            + "---\n\n"
-            + "# Projects\n\n"
-            + "## Project Registry\n\n"
-            + "```yaml\n"
-            + "alpha: /srv/alpha\n"
-            + "```\n", "utf-8");
+        seedProjectRegistry(testRoot, {
+            alpha: "/srv/alpha",
+        });
         const alphaRulesPath = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "alpha", "rules.md");
         mkdirSync(join(alphaRulesPath, ".."), { recursive: true });
         writeFileSync(alphaRulesPath, "---\n"

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