chapterhouse 0.3.22 → 0.3.24

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

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