chapterhouse 0.3.8 → 0.3.10

package/dist/api/server-runtime.js

@@ -20,11 +20,13 @@ export function createHealthPayload(now = new Date()) {
     };
 }
 export function createPublicConfigPayload(config) {
+    const chatSseEnabled = config.chatSseEnabled ?? false;
     if (!config.entraAuthEnabled) {
         return {
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: config.standaloneMode,
+            chatSseEnabled,
         };
     }
     return {
@@ -32,6 +34,7 @@ export function createPublicConfigPayload(config) {
         entraAuthEnabled: true,
         entraClientId: config.entraClientId,
         entraTenantId: config.entraTenantId,
+        chatSseEnabled,
     };
 }
 export function shouldServeSpaPath(pathname) {

package/dist/api/server.js

@@ -5,7 +5,7 @@ import { existsSync, statSync, readdirSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
-import { sendToOrchestrator, getAgentInfo, cancelCurrentMessage, getLastRouteResult, getCurrentSessionKey, subscribeTaskEvents } from "../copilot/orchestrator.js";
+import { sendToOrchestrator, interruptCurrentTurn, enqueueForSse, getAgentInfo, cancelCurrentMessage, getLastRouteResult, getCurrentSessionKey } from "../copilot/orchestrator.js";
 import { squadEventBus } from "../copilot/squad-event-bus.js";
 import { getAgentRegistry } from "../copilot/agents.js";
 import { config, persistModel } from "../config.js";
@@ -21,6 +21,8 @@ import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { API_TOKEN_PATH, resolveWikiRelativePath } from "../paths.js";
 import { getDb, getSessionMessages, getTaskEvents, normalizeSqliteTsToIso } from "../store/db.js";
+import { getTaskLogEvents, subscribeTaskLog } from "../copilot/task-event-log.js";
+import { subscribeSession, getSessionEventsFromDb, oldestSessionSeq, } from "../copilot/turn-event-log.js";
 import { getStatus, onStatusChange } from "../status.js";
 import { formatSseData, formatSseEvent } from "./sse.js";
 import { syncDecisionsFileToWiki } from "../squad/mirror.js";
@@ -45,6 +47,15 @@ const messageRequestSchema = z.object({
      * so the frontend can match the event to the user message bubble it should update. */
     msgId: z.string().optional(),
 });
+const interruptRequestSchema = z.object({
+    prompt: requiredString("Missing 'prompt' in request body"),
+    connectionId: requiredString("Missing or invalid 'connectionId'. Connect to /stream first."),
+    attachments: z.array(z.object({
+        type: z.literal("file"),
+        path: z.string(),
+        displayName: z.string().optional(),
+    })).optional(),
+});
 const modelRequestSchema = z.object({
     model: requiredString("Missing 'model' in request body"),
 }).strict();
@@ -222,6 +233,7 @@ app.get("/api/config/public", (_req, res) => {
         standaloneMode: config.standaloneMode,
         entraClientId: config.entraClientId,
         entraTenantId: config.entraTenantId,
+        chatSseEnabled: config.chatSseEnabled,
     }));
 });
 // Health check — intentionally unauthenticated, returns no sensitive data
@@ -284,7 +296,9 @@ app.get("/api/workers/:taskId", (req, res) => {
         completedAt: row.completed_at,
     });
 });
-// Historical event log for a task (catch-up on page load)
+// 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.
 app.get("/api/workers/:taskId/events", (req, res) => {
     const taskId = req.params.taskId;
     const afterSeqRaw = req.query.afterSeq;
@@ -295,10 +309,13 @@ app.get("/api/workers/:taskId/events", (req, res) => {
     if (!taskRow) {
         throw new NotFoundError("Task not found");
     }
-    const events = getTaskEvents(taskId, afterSeq);
+    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
+// 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()
@@ -314,8 +331,9 @@ app.get("/api/workers/:taskId/events/stream", (req, res) => {
     });
     res.write(formatSseData({ type: "connected", taskId }));
     const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
-    const unsub = subscribeTaskEvents(taskId, (event) => {
-        res.write(formatSseData({ type: "task_event", taskId, ...event }));
+    // subscribeTaskLog delivers ring-buffer-sourced events as they arrive.
+    const unsub = subscribeTaskLog(taskId, (event) => {
+        res.write(formatSseData({ type: "task_event", ...event }));
     });
     req.on("close", () => {
         clearInterval(heartbeat);
@@ -495,6 +513,173 @@ app.post("/api/cancel", async (_req, res) => {
     }
     res.json({ status: "ok", cancelled });
 });
+// Interrupt the active turn on a specific session and start a replacement turn.
+// POST /api/sessions/:sessionKey/interrupt
+// Body: { prompt, connectionId, attachments? }
+app.post("/api/sessions/:sessionKey/interrupt", (req, res) => {
+    const sessionKey = Array.isArray(req.params.sessionKey)
+        ? req.params.sessionKey[0]
+        : req.params.sessionKey;
+    if (!sessionKey)
+        throw new BadRequestError("Missing sessionKey");
+    const { prompt, connectionId, attachments } = parseRequest(interruptRequestSchema, req.body);
+    if (!sseClients.has(connectionId)) {
+        throw new BadRequestError("Missing or invalid 'connectionId'. Connect to /stream first.");
+    }
+    const source = {
+        type: "web",
+        connectionId,
+        user: req.user,
+        authorizationHeader: typeof req.headers.authorization === "string" ? req.headers.authorization : undefined,
+    };
+    interruptCurrentTurn(sessionKey, prompt, source, (text, done, turnId) => {
+        const sseRes = sseClients.get(connectionId);
+        if (sseRes) {
+            const event = {
+                type: done ? "message" : "delta",
+                content: text,
+                sessionKey,
+                turnId,
+            };
+            if (done) {
+                const routeResult = getLastRouteResult();
+                if (routeResult) {
+                    event.route = {
+                        model: routeResult.model,
+                        routerMode: routeResult.routerMode,
+                        tier: routeResult.tier,
+                        ...(routeResult.overrideName ? { overrideName: routeResult.overrideName } : {}),
+                    };
+                }
+            }
+            sseRes.write(formatSseData(event));
+        }
+    }, attachments, (activity, turnId) => {
+        const sseRes = sseClients.get(connectionId);
+        if (sseRes) {
+            sseRes.write(formatSseData({ type: "activity", ...activity, sessionKey, ...(turnId ? { turnId } : {}) }));
+        }
+    }, (abortedTurnId) => {
+        const sseRes = sseClients.get(connectionId);
+        if (sseRes) {
+            sseRes.write(formatSseData({ type: "turn-interrupted", abortedTurnId, sessionKey }));
+        }
+    });
+    res.json({ status: "interrupting" });
+});
+// ---------------------------------------------------------------------------
+// Chat POST→SSE endpoints — gated by CHAPTERHOUSE_CHAT_SSE=1 (#130)
+// ---------------------------------------------------------------------------
+const turnRequestSchema = z.object({
+    prompt: z.string().trim().min(1, "Missing prompt"),
+    source: z.string().optional(),
+    attachments: z
+        .array(z.object({
+        type: z.literal("file"),
+        path: z.string(),
+        displayName: z.string().optional(),
+    }))
+        .optional(),
+    interrupt: z.boolean().optional(),
+});
+if (config.chatSseEnabled) {
+    /**
+     * POST /api/sessions/:key/turn
+     *
+     * Submit a new turn to the given session.  Returns `{ turnId }` immediately;
+     * the turn runs asynchronously and emits events on the per-session SSE stream.
+     *
+     * Body: `{ prompt, source?, attachments?, interrupt? }`
+     * Response: `{ turnId: string }`
+     */
+    app.post("/api/sessions/:key/turn", (req, res) => {
+        const sessionKey = Array.isArray(req.params.key) ? req.params.key[0] : req.params.key;
+        if (!sessionKey)
+            throw new BadRequestError("Missing session key");
+        const { prompt, attachments, interrupt } = parseRequest(turnRequestSchema, req.body);
+        const authUser = req.user;
+        const authHeader = req.headers.authorization ?? undefined;
+        const turnId = enqueueForSse({
+            sessionKey,
+            prompt,
+            attachments,
+            authUser,
+            authHeader,
+            interrupt: interrupt ?? false,
+        });
+        res.json({ turnId });
+    });
+    /**
+     * GET /api/sessions/:key/stream
+     *
+     * Per-session SSE channel.  Delivers turn events:
+     *   `turn:started`, `turn:delta`, `turn:queued`, `turn:interrupted`,
+     *   `turn:complete`, `turn:error`
+     *
+     * Supports `Last-Event-ID` for reconnect replay:
+     *  - If the session ring buffer covers the requested range, replays from memory.
+     *  - Otherwise falls back to SQLite (covers completed-turn replay).
+     *
+     * Keep-alive comments are sent every 15 s.
+     * Multiple simultaneous subscribers (tabs) are supported.
+     */
+    app.get("/api/sessions/:key/stream", (req, res) => {
+        const sessionKey = Array.isArray(req.params.key) ? req.params.key[0] : req.params.key;
+        if (!sessionKey)
+            throw new BadRequestError("Missing session key");
+        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();
+        // Parse Last-Event-ID for reconnect replay
+        const rawLastId = req.headers["last-event-id"];
+        const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
+            ? parseInt(rawLastId.trim(), 10)
+            : undefined;
+        // Helper: send a named SSE event with an id: field
+        const sendEvent = (event, seq) => {
+            const payload = JSON.stringify(event);
+            res.write(`id: ${seq}\ndata: ${payload}\n\n`);
+        };
+        // If Last-Event-ID is present and the session ring buffer doesn't cover it,
+        // fall back to SQLite for replay of completed turns.
+        if (lastSeq !== undefined) {
+            const oldestBuf = oldestSessionSeq(sessionKey);
+            const bufferMissesRange = oldestBuf === undefined || oldestBuf > lastSeq + 1;
+            if (bufferMissesRange) {
+                // Replay from SQLite (completed turns)
+                const dbEvents = getSessionEventsFromDb(sessionKey, lastSeq);
+                for (const e of dbEvents) {
+                    sendEvent(e, e._seq);
+                }
+            }
+        }
+        // Subscribe to session events (replays ring buffer for afterSeq, then live)
+        const unsub = subscribeSession(sessionKey, (e) => {
+            sendEvent(e, e._seq);
+        }, lastSeq);
+        // Send connected event
+        res.write(`: connected session=${sessionKey}\n\n`);
+        // Keep-alive every 15 s
+        const keepAlive = setInterval(() => {
+            res.write(`: keep-alive\n\n`);
+        }, 15_000);
+        req.on("close", () => {
+            clearInterval(keepAlive);
+            unsub();
+        });
+    });
+}
+else {
+    // Feature flag off — return 404 for both endpoints
+    app.post("/api/sessions/:key/turn", (_req, res) => {
+        res.status(404).json({ error: "Chat SSE not enabled. Set CHAPTERHOUSE_CHAT_SSE=1." });
+    });
+    app.get("/api/sessions/:key/stream", (_req, res) => {
+        res.status(404).json({ error: "Chat SSE not enabled. Set CHAPTERHOUSE_CHAT_SSE=1." });
+    });
+}
 // ---------------------------------------------------------------------------
 // Model & router
 // ---------------------------------------------------------------------------

package/dist/api/server.test.js

@@ -28,21 +28,25 @@ test("supports API_TOKEN env var and personal health route helpers", async () =>
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
+        chatSseEnabled: false,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: true,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
+        chatSseEnabled: false,
     });
     assert.deepEqual(runtime.createPublicConfigPayload({
         entraAuthEnabled: false,
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
+        chatSseEnabled: false,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: false,
         standalone: false,
+        chatSseEnabled: false,
     });
     assert.doesNotThrow(() => runtime.assertAuthenticationConfigured({
         entraAuthEnabled: false,
@@ -188,6 +192,7 @@ test("server routes expose bootstrap and public config without auth", async () =
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: false,
+            chatSseEnabled: false,
         });
     });
 });
@@ -202,6 +207,7 @@ test("server runs in standalone mode without auth", async () => {
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: true,
+            chatSseEnabled: false,
         });
         const model = await fetch(`${baseUrl}/api/model`);
         assert.equal(model.status, 200);

package/dist/api/turn-sse.integration.test.js

@@ -0,0 +1,352 @@
+/**
+ * Integration tests for the POST→SSE chat endpoints (#130).
+ *
+ * Tests:
+ *  1. POST /api/sessions/:key/turn returns 404 when flag is off
+ *  2. GET /api/sessions/:key/stream returns 404 when flag is off
+ *  3. POST /api/sessions/:key/turn returns { turnId } when flag is on
+ *  4. GET /api/sessions/:key/stream delivers turn events (SSE)
+ *  5. SSE reconnect with Last-Event-ID replays missed events
+ *  6. Multi-subscriber: two tabs both receive events
+ *  7. Legacy POST /api/message path unaffected when flag is off
+ *
+ * The tests that require the feature flag spawn a separate server process with
+ * CHAPTERHOUSE_CHAT_SSE=1.  Tests that verify flag-off behavior use a server
+ * without the flag.
+ *
+ * Because the Copilot SDK is not available in test env (no valid token), tests
+ * that would trigger a real turn instead verify the API shape and event
+ * delivery plumbing via the turn event log directly.  Integration of the full
+ * orchestrator path (POST→turn→events→SSE) is documented as manual verification
+ * because it requires a live Copilot token.
+ */
+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";
+// ---------------------------------------------------------------------------
+// Helpers — copied/adapted from sse.integration.test.ts
+// ---------------------------------------------------------------------------
+const repoRoot = process.cwd();
+const testWorkRoot = join(repoRoot, ".test-work", `turn-sse-${process.pid}`);
+let _instanceCounter = 0;
+async function getFreePort() {
+    const server = createServer();
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    const addr = server.address();
+    assert.ok(addr && typeof addr === "object");
+    await new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
+    return addr.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 withStartedServer(run, extraEnv = {}, timeoutMs = 10_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 = [];
+    const child = spawn(process.execPath, [
+        "--input-type=module",
+        "-e",
+        "import { startApiServer } from './dist/api/server.js'; await startApiServer();",
+    ], {
+        cwd: repoRoot,
+        env: {
+            ...Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith("COPILOT_") && !k.startsWith("NODE_TEST_"))),
+            CHAPTERHOUSE_DISABLE_DOTENV: "1",
+            CHAPTERHOUSE_HOME: instanceRoot,
+            API_HOST: "127.0.0.1",
+            API_PORT: String(port),
+            API_TOKEN: "test-token",
+            ...extraEnv,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    child.stdout?.on("data", (c) => logs.push(String(c)));
+    child.stderr?.on("data", (c) => logs.push(String(c)));
+    const baseUrl = `http://127.0.0.1:${port}`;
+    try {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (child.exitCode !== null)
+                throw new Error(`Server exited early:\n${logs.join("")}`);
+            let serverReady = false;
+            try {
+                const r = await fetch(`${baseUrl}/status`);
+                serverReady = r.ok;
+            }
+            catch { /* not ready yet */ }
+            if (serverReady) {
+                // Run outside the fetch try/catch so assertion errors propagate correctly.
+                await run({ baseUrl, authHeader: "Bearer test-token" });
+                return;
+            }
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        throw new Error(`Server did not start in ${timeoutMs}ms:\n${logs.join("")}`);
+    }
+    finally {
+        await stopChild(child);
+        rmSync(instanceRoot, { recursive: true, force: true });
+    }
+}
+function createSseReader(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let leftover = "";
+    async function readFrames(n, timeoutMs = 3_000) {
+        const frames = [];
+        const deadline = Date.now() + timeoutMs;
+        while (frames.length < n && Date.now() < deadline) {
+            const { value, done } = await Promise.race([
+                reader.read(),
+                new Promise((r) => setTimeout(() => r({ value: undefined, done: true }), 200)),
+            ]);
+            if (done || value === undefined)
+                continue;
+            leftover += decoder.decode(value, { stream: true });
+            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("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);
+                        }
+                    }
+                    // skip comment lines (": ...")
+                }
+                if (frame.data !== null)
+                    frames.push(frame);
+            }
+        }
+        return frames;
+    }
+    async function cancel() {
+        try {
+            await reader.cancel();
+        }
+        catch { /* ignore */ }
+    }
+    return { readFrames, cancel };
+}
+// ---------------------------------------------------------------------------
+// Tests: feature flag OFF
+// ---------------------------------------------------------------------------
+test("turn-sse: POST /api/sessions/:key/turn returns 404 when flag is off", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const res = await fetch(`${baseUrl}/api/sessions/default/turn`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "hello" }),
+        });
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
+        const body = await res.json();
+        assert.ok(typeof body.error === "string" && body.error.includes("Chat SSE"), `Expected error about Chat SSE, got: ${body.error}`);
+    });
+});
+test("turn-sse: GET /api/sessions/:key/stream returns 404 when flag is off", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const res = await fetch(`${baseUrl}/api/sessions/default/stream`, {
+            headers: { Authorization: authHeader },
+        });
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
+    });
+});
+test("turn-sse: legacy POST /api/message is unaffected when flag is off", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        // The legacy endpoint doesn't need a live SSE connection in our test —
+        // we just verify it returns 400 for a bad connectionId (the route exists).
+        const res = await fetch(`${baseUrl}/api/message`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "test", connectionId: "nonexistent-conn-id" }),
+        });
+        // 400 = route exists and validated the request (connectionId not found in sseClients)
+        assert.ok(res.status === 400 || res.status === 401 || res.status === 422, `Expected 4xx from /api/message, got ${res.status}`);
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests: feature flag ON
+// ---------------------------------------------------------------------------
+test("turn-sse: POST /api/sessions/:key/turn returns { turnId } when flag is on", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const res = await fetch(`${baseUrl}/api/sessions/default/turn`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "hello world" }),
+        });
+        // The turn will queue but fail quickly without a real Copilot token.
+        // We only care that the route accepted the request and returned a turnId.
+        // Read body once to avoid "body used already" if the status assertion were to fail.
+        const bodyText = await res.text();
+        assert.ok(res.status === 200 || res.status === 202, `Expected 2xx from /api/sessions/:key/turn, got ${res.status}: ${bodyText}`);
+        const body = JSON.parse(bodyText);
+        assert.ok(typeof body.turnId === "string" && body.turnId.length > 0, `Expected turnId string, got ${JSON.stringify(body)}`);
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
+test("turn-sse: GET /api/sessions/:key/stream opens SSE connection", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const res = await fetch(`${baseUrl}/api/sessions/default/stream`, {
+            headers: { Authorization: authHeader, Accept: "text/event-stream" },
+        });
+        assert.equal(res.status, 200, "SSE stream should return 200");
+        assert.ok(res.headers.get("content-type")?.includes("text/event-stream"), "Content-Type should be text/event-stream");
+        assert.ok(res.body, "Response should have a readable body");
+        await res.body.cancel();
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
+test("turn-sse: POST turn then GET stream receives turn:started event", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const sessionKey = "test-session-post-stream";
+        // Open SSE connection first
+        const sseRes = await fetch(`${baseUrl}/api/sessions/${sessionKey}/stream`, {
+            headers: { Authorization: authHeader, Accept: "text/event-stream" },
+        });
+        assert.ok(sseRes.body, "SSE body should be readable");
+        const reader = createSseReader(sseRes.body);
+        // POST a turn
+        const turnRes = await fetch(`${baseUrl}/api/sessions/${sessionKey}/turn`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "test prompt for SSE" }),
+        });
+        assert.equal(turnRes.status, 200);
+        const { turnId } = await turnRes.json();
+        assert.ok(typeof turnId === "string", "turnId must be a string");
+        // Read events — expect turn:started
+        const frames = await reader.readFrames(1, 2_000);
+        await reader.cancel();
+        // The frame should be a turn:started or another turn event
+        assert.ok(frames.length >= 1, `Expected at least 1 SSE frame, got ${frames.length}`);
+        const firstData = frames[0]?.data;
+        assert.ok(typeof firstData?.type === "string" && firstData.type.startsWith("turn:"), `First event should be a turn:* event, got: ${JSON.stringify(firstData?.type)}`);
+        assert.equal(firstData?.turnId, turnId, "Event turnId must match posted turnId");
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
+test("turn-sse: SSE events have id: field for Last-Event-ID reconnect", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const sessionKey = "test-session-lastid";
+        const sseRes = await fetch(`${baseUrl}/api/sessions/${sessionKey}/stream`, {
+            headers: { Authorization: authHeader, Accept: "text/event-stream" },
+        });
+        assert.ok(sseRes.body);
+        const reader = createSseReader(sseRes.body);
+        // POST a turn to generate events
+        await fetch(`${baseUrl}/api/sessions/${sessionKey}/turn`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "generate events" }),
+        });
+        const frames = await reader.readFrames(1, 2_000);
+        await reader.cancel();
+        if (frames.length > 0) {
+            assert.ok(typeof frames[0].id === "string" && /^\d+$/.test(frames[0].id), `Each SSE frame must have a numeric id:, got: ${JSON.stringify(frames[0].id)}`);
+        }
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
+test("turn-sse: multi-subscriber — two clients both receive events", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const sessionKey = "test-session-multi-sub";
+        // Open two SSE connections
+        const [res1, res2] = await Promise.all([
+            fetch(`${baseUrl}/api/sessions/${sessionKey}/stream`, {
+                headers: { Authorization: authHeader, Accept: "text/event-stream" },
+            }),
+            fetch(`${baseUrl}/api/sessions/${sessionKey}/stream`, {
+                headers: { Authorization: authHeader, Accept: "text/event-stream" },
+            }),
+        ]);
+        assert.ok(res1.body && res2.body, "Both SSE connections should have bodies");
+        const reader1 = createSseReader(res1.body);
+        const reader2 = createSseReader(res2.body);
+        // POST a turn
+        const turnRes = await fetch(`${baseUrl}/api/sessions/${sessionKey}/turn`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "broadcast test" }),
+        });
+        assert.equal(turnRes.status, 200);
+        const { turnId } = await turnRes.json();
+        // Both should receive the turn:started event
+        const [frames1, frames2] = await Promise.all([
+            reader1.readFrames(1, 2_000),
+            reader2.readFrames(1, 2_000),
+        ]);
+        await Promise.all([reader1.cancel(), reader2.cancel()]);
+        assert.ok(frames1.length >= 1, "Client 1 should receive events");
+        assert.ok(frames2.length >= 1, "Client 2 should receive events");
+        const data1 = frames1[0]?.data;
+        const data2 = frames2[0]?.data;
+        assert.equal(data1?.turnId, turnId, "Client 1 event should have correct turnId");
+        assert.equal(data2?.turnId, turnId, "Client 2 event should have correct turnId");
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
+test("turn-sse: reconnect with Last-Event-ID replays buffered events", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const sessionKey = "test-session-reconnect";
+        // Connect, receive a turn:started event, then disconnect
+        const res1 = await fetch(`${baseUrl}/api/sessions/${sessionKey}/stream`, {
+            headers: { Authorization: authHeader, Accept: "text/event-stream" },
+        });
+        assert.ok(res1.body);
+        const reader1 = createSseReader(res1.body);
+        await fetch(`${baseUrl}/api/sessions/${sessionKey}/turn`, {
+            method: "POST",
+            headers: { Authorization: authHeader, "Content-Type": "application/json" },
+            body: JSON.stringify({ prompt: "reconnect test" }),
+        });
+        const initialFrames = await reader1.readFrames(1, 2_000);
+        await reader1.cancel();
+        if (initialFrames.length === 0) {
+            // No events generated (no real Copilot token) — skip replay assertion
+            return;
+        }
+        // The last id: field we saw
+        const lastId = initialFrames[initialFrames.length - 1].id;
+        assert.ok(lastId, "Events must have id: for reconnect");
+        // Reconnect with Last-Event-ID header BEFORE the first event's id
+        const prevId = String(parseInt(lastId, 10) - 1);
+        const res2 = await fetch(`${baseUrl}/api/sessions/${sessionKey}/stream`, {
+            headers: {
+                Authorization: authHeader,
+                Accept: "text/event-stream",
+                "Last-Event-ID": prevId,
+            },
+        });
+        assert.ok(res2.body);
+        const reader2 = createSseReader(res2.body);
+        // Should get replayed events from the ring buffer
+        const replayedFrames = await reader2.readFrames(1, 2_000);
+        await reader2.cancel();
+        // The replayed events should all have _seq > prevId
+        for (const frame of replayedFrames) {
+            if (frame.id) {
+                assert.ok(parseInt(frame.id, 10) > parseInt(prevId, 10), `Replayed event id (${frame.id}) should be > Last-Event-ID (${prevId})`);
+            }
+        }
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
+//# sourceMappingURL=turn-sse.integration.test.js.map