chapterhouse 0.3.24 → 0.3.26

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/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

@@ -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),
     });
@@ -841,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/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

@@ -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
@@ -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')) {
@@ -283,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}`;
@@ -318,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),
     }));
@@ -342,7 +370,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 +380,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 +413,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() {