@celestea/studio 2.7.1

package/dist/replay/expect-compact.js

@@ -0,0 +1,92 @@
+/**
+ * INDEPENDENT re-derivation of the frozen compaction plan (W259).
+ *
+ * This is deliberately a SECOND implementation: the runtime's planner lives in
+ * `packages/runtime/src/compact/plan.ts` (written as a straight port of
+ * `celestea_studio/src/compact.rs`), while this one is written from the spec text
+ * with a different shape (index scan + slice, no helper reuse). A P5 comparison
+ * between the two is therefore a cross-implementation check of the STRUCTURE
+ * (head turn, kept-tail selection, renumbering, dropping an unterminated tail),
+ * not a tautology.
+ *
+ * The summary string is passed in (the replay reads it back out of the compacted
+ * log), so the summary itself is out of scope for this comparison.
+ */
+export const SPEC_THRESHOLD = 8;
+export const SPEC_KEEP = 4;
+export const SPEC_HEAD_PREFIX = "【上下文压缩】";
+export const SPEC_HEAD_ASSISTANT = "上下文已压缩，以上为历史摘要。";
+/** Index ranges [start, end) of every complete turn (`turn_start` .. `turn_end`). */
+export function completeTurnRanges(events) {
+    const ranges = [];
+    let start = -1;
+    for (let i = 0; i < events.length; i++) {
+        const ev = events[i];
+        if (ev === undefined)
+            continue;
+        if (ev.type === "turn_start") {
+            start = i;
+            continue;
+        }
+        if (ev.type === "turn_end" && start >= 0) {
+            ranges.push([start, i + 1]);
+            start = -1;
+        }
+    }
+    return ranges;
+}
+/** The expected post-compaction log, or null when the history is too short. */
+export function expectedCompactLog(events, summary, keep = SPEC_KEEP) {
+    const ranges = completeTurnRanges(events);
+    if (ranges.length <= SPEC_THRESHOLD)
+        return null;
+    const kept = ranges.slice(Math.max(0, ranges.length - Math.max(1, Math.min(keep, ranges.length))));
+    const out = [
+        { type: "turn_start", id: "turn-1" },
+        // W888: the head summary row carries origin: "compact" (the runtime planner
+        // does too; this second implementation must track the plan shape).
+        { type: "user_message", text: `${SPEC_HEAD_PREFIX}${summary}`, origin: "compact" },
+        { type: "assistant_message", text: SPEC_HEAD_ASSISTANT },
+        { type: "turn_end", id: "turn-1", outcome: "completed" },
+    ];
+    kept.forEach(([from, to], i) => {
+        const id = `turn-${i + 2}`;
+        for (const ev of events.slice(from, to)) {
+            if (ev.type === "turn_start")
+                out.push({ type: "turn_start", id });
+            else if (ev.type === "turn_end")
+                out.push({ type: "turn_end", id, ...(ev.outcome === undefined ? {} : { outcome: ev.outcome }) });
+            else
+                out.push(ev);
+        }
+    });
+    return out;
+}
+/** The inner (non-boundary) rows of a turn: what renumbering must NOT touch. */
+export function turnBody(events) {
+    return events.filter((ev) => ev.type !== "turn_start" && ev.type !== "turn_end");
+}
+/** Split a serialized log into one entry per complete turn (raw text lines). */
+export function rawTurnBodies(text, parse) {
+    const lines = text.split("\n").filter((l) => l.trim() !== "");
+    const events = parse(text).events;
+    const bodies = [];
+    let current = null;
+    events.forEach((ev, i) => {
+        if (ev.type === "turn_start")
+            current = [];
+        else if (ev.type === "turn_end") {
+            if (current !== null)
+                bodies.push(current);
+            current = null;
+        }
+        else if (current !== null)
+            current.push(lines[i] ?? "");
+    });
+    return bodies;
+}
+/** The summary text embedded in a compacted log's head turn (null when absent). */
+export function headSummary(events) {
+    const head = events.find((ev) => ev.type === "user_message" && ev.text.startsWith(SPEC_HEAD_PREFIX));
+    return head === undefined || head.type !== "user_message" ? null : head.text.slice(SPEC_HEAD_PREFIX.length);
+}

package/dist/replay/fixtures.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Golden-fixture access for the P5 double-run comparison.
+ *
+ * The fixtures are the P0 export of the retired backend
+ * (`fixtures/index.json` + `fixtures/sessions/<slug>/…`): an unmodified session
+ * log, the Studio `messages` projection captured over HTTP, and (for small
+ * sessions) the derived SSE transcript. Nothing here writes into `fixtures/`:
+ * every replay works on a COPY under a temp root.
+ */
+/** One fixture session entry of the manifest. */
+export interface FixtureSession {
+    id: string;
+    slug: string;
+    roles: string[];
+    events: number;
+    turns: number;
+    danglingToolCalls: number;
+    subCalls: number;
+    expectedMessages: number;
+    sseFrames: number;
+}
+export interface FixtureManifest {
+    generatedAt: string;
+    studio: string;
+    sessions: FixtureSession[];
+    counts: Record<string, unknown>;
+}
+/** The four golden artifacts of one session fixture. */
+export interface FixtureFiles {
+    dir: string;
+    log: string;
+    messages: string;
+    derivedMessages: string;
+    sse: string | null;
+}
+export declare function readJson<T>(path: string): T;
+/** Load `fixtures/index.json` (throws with the export hint when missing). */
+export declare function loadManifest(fixturesDir: string): FixtureManifest;
+/** Absolute paths of one session's golden files. */
+export declare function fixtureFiles(fixturesDir: string, slug: string): FixtureFiles;
+/** Split an id into its workspace and session-directory halves. */
+export declare function splitSessionId(id: string): {
+    workspace: string;
+    session: string;
+};
+/** Copy a session fixture into `<root>/<workspace>/<session>/cli-main.jsonl`. */
+export declare function plantFixture(root: string, files: FixtureFiles, id: string): {
+    dir: string;
+    logBytes: string;
+};
+/** Parse one JSONL fixture file (one JSON value per non-empty line). */
+export declare function readJsonl(path: string): unknown[];

package/dist/replay/fixtures.js

@@ -0,0 +1,53 @@
+/**
+ * Golden-fixture access for the P5 double-run comparison.
+ *
+ * The fixtures are the P0 export of the retired backend
+ * (`fixtures/index.json` + `fixtures/sessions/<slug>/…`): an unmodified session
+ * log, the Studio `messages` projection captured over HTTP, and (for small
+ * sessions) the derived SSE transcript. Nothing here writes into `fixtures/`:
+ * every replay works on a COPY under a temp root.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export function readJson(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+/** Load `fixtures/index.json` (throws with the export hint when missing). */
+export function loadManifest(fixturesDir) {
+    const path = join(resolve(fixturesDir), "index.json");
+    if (!existsSync(path))
+        throw new Error(`fixtures manifest not found: ${path} (run \`pnpm golden:export\` first)`);
+    return readJson(path);
+}
+/** Absolute paths of one session's golden files. */
+export function fixtureFiles(fixturesDir, slug) {
+    const dir = join(resolve(fixturesDir), "sessions", slug);
+    const sse = join(dir, "sse-transcript-derived.jsonl");
+    return {
+        dir,
+        log: join(dir, "cli-main.jsonl"),
+        messages: join(dir, "messages-expected.json"),
+        derivedMessages: join(dir, "derive-messages-expected.json"),
+        sse: existsSync(sse) ? sse : null,
+    };
+}
+/** Split an id into its workspace and session-directory halves. */
+export function splitSessionId(id) {
+    const slash = id.indexOf("/");
+    return { workspace: id.slice(0, slash), session: id.slice(slash + 1) };
+}
+/** Copy a session fixture into `<root>/<workspace>/<session>/cli-main.jsonl`. */
+export function plantFixture(root, files, id) {
+    const { workspace, session } = splitSessionId(id);
+    const dir = join(root, workspace, session);
+    mkdirSync(dir, { recursive: true });
+    copyFileSync(files.log, join(dir, "cli-main.jsonl"));
+    return { dir, logBytes: readFileSync(files.log, "utf8") };
+}
+/** Parse one JSONL fixture file (one JSON value per non-empty line). */
+export function readJsonl(path) {
+    return readFileSync(path, "utf8")
+        .split("\n")
+        .filter((line) => line.trim() !== "")
+        .map((line) => JSON.parse(line));
+}

package/dist/replay/host.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The replay host: a throwaway Studio app whose engine is the REAL runtime.
+ *
+ * Every P5 run gets its own temp data root (workspaces.json + one session
+ * directory per fixture copy) and its own engine generation, so a replay can
+ * append turns, compact logs and fail loudly without touching `fixtures/` or the
+ * operator's data files. The engine's tool roots are pinned to the temp root, so
+ * the production path guard stays mounted.
+ */
+import { type StudioApp } from "../app.js";
+import type { Hono } from "hono";
+import { type OfflineLlmOptions } from "../runtime/offline-llm.js";
+import { type RealRuntimeAdapter } from "../runtime/real-runtime-adapter.js";
+export interface ReplayHostOptions {
+    /** Workspace names to register (their directories are created under root). */
+    workspaces: readonly string[];
+    /** Offline LLM options for the composed generations. */
+    llm?: OfflineLlmOptions;
+    /** Static root for the app (defaults to an empty temp build). */
+    staticRoot?: string;
+}
+export interface ReplayHost {
+    app: Hono;
+    studio: StudioApp;
+    runtime: RealRuntimeAdapter;
+    /** Temp data root (workspaces + session copies live here). */
+    root: string;
+    workspacePath(name: string): string;
+    cleanup(): void;
+}
+/** Build a host over a fresh temp root. */
+export declare function createReplayHost(opts: ReplayHostOptions): ReplayHost;

package/dist/replay/host.js

@@ -0,0 +1,62 @@
+/**
+ * The replay host: a throwaway Studio app whose engine is the REAL runtime.
+ *
+ * Every P5 run gets its own temp data root (workspaces.json + one session
+ * directory per fixture copy) and its own engine generation, so a replay can
+ * append turns, compact logs and fail loudly without touching `fixtures/` or the
+ * operator's data files. The engine's tool roots are pinned to the temp root, so
+ * the production path guard stays mounted.
+ */
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { createStudioApp } from "../app.js";
+import { loadStudioConfig } from "../config.js";
+import { createOfflineLlm } from "../runtime/offline-llm.js";
+import { createRealRuntimeAdapter } from "../runtime/real-runtime-adapter.js";
+/** Build a host over a fresh temp root. */
+export function createReplayHost(opts) {
+    const root = mkdtempSync(join(tmpdir(), "replay-host-"));
+    const staticRoot = opts.staticRoot ?? join(root, "dist");
+    mkdirSync(staticRoot, { recursive: true });
+    writeFileSync(join(staticRoot, "index.html"), "<!doctype html><title>replay</title>\n");
+    const workspaces = [...new Set(opts.workspaces)];
+    for (const name of workspaces)
+        mkdirSync(join(root, name), { recursive: true });
+    // The registry is read EAGERLY at compose time, so it must exist up front.
+    writeFileSync(join(root, "workspaces.json"), `${JSON.stringify({ workspaces: workspaces.map((name) => ({ path: join(root, name) })), active_session: null }, null, 2)}\n`);
+    const env = { ...process.env, CELESTEA_TOOL_ROOTS: root };
+    const studio = createStudioApp({
+        config: loadStudioConfig({ cwd: root, env, paths: { staticRoot } }),
+        env,
+        runtime: (stores) => createRealRuntimeAdapter({
+            profile: {
+                model: "offline-replay-model",
+                base_url: "http://127.0.0.1:9/v1",
+                api_key_env: "CELESTEA_API_KEY",
+                reasoning_effort: null,
+                max_steps: 4096,
+                max_parallel_tool_calls: 4,
+                max_output_tokens: null,
+                context_window: 1_000_000,
+                system_prompt: "engine identity prompt",
+            },
+            env,
+            llm: () => createOfflineLlm(opts.llm ?? {}),
+            resultsDir: join(root, "worker-results"),
+            resolveSession: (id) => {
+                const resolved = stores.sessions.require(id);
+                return resolved.ok ? { sessionId: id, dir: resolved.value.dir } : null;
+            },
+        }),
+    });
+    return {
+        app: studio.app,
+        studio,
+        runtime: studio.services.runtime,
+        root,
+        workspacePath: (name) => join(root, name),
+        cleanup: () => rmSync(root, { recursive: true, force: true }),
+    };
+}

package/dist/replay/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * P5 double-run comparison harness (`pnpm replay:e2e`).
+ *
+ * Replays the golden fixtures from the retired backend through the
+ * TS host (real runtime + offline LLM) and reports, per artifact, whether the
+ * output is byte-identical, frozen-golden, independently re-derived or merely
+ * self-consistent — plus what still has to be captured before P6.
+ */
+export * from "./compare.js";
+export * from "./expect-compact.js";
+export * from "./fixtures.js";
+export * from "./host.js";
+export * from "./probes.js";
+export * from "./session-e2e.js";
+export * from "./e2e-replay.js";
+export * from "./report.js";

package/dist/replay/index.js

@@ -0,0 +1,16 @@
+/**
+ * P5 double-run comparison harness (`pnpm replay:e2e`).
+ *
+ * Replays the golden fixtures from the retired backend through the
+ * TS host (real runtime + offline LLM) and reports, per artifact, whether the
+ * output is byte-identical, frozen-golden, independently re-derived or merely
+ * self-consistent — plus what still has to be captured before P6.
+ */
+export * from "./compare.js";
+export * from "./expect-compact.js";
+export * from "./fixtures.js";
+export * from "./host.js";
+export * from "./probes.js";
+export * from "./session-e2e.js";
+export * from "./e2e-replay.js";
+export * from "./report.js";

package/dist/replay/probes.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The end-to-end probes of one replayed session: a REAL turn through the host,
+ * the SSE transport check and the compaction probe.
+ *
+ * Every probe reads back the artifact it produced (the JSONL file, the SSE wire,
+ * the `.precompact` backup) so the report can state byte-level facts instead of
+ * "the call returned 200".
+ */
+import { type Finding } from "./compare.js";
+import type { ReplayHost } from "./host.js";
+/** The frozen "nothing to compact" note. */
+export declare const SKIP_NOTE = "\u5386\u53F2\u4E0D\u8DB3\uFF0C\u65E0\u9700\u538B\u7F29";
+/** The frozen compacted note for K = 4. */
+export declare const COMPACT_NOTE = "\u5DF2\u538B\u7F29\uFF1A\u6458\u8981\u8F6E + \u6700\u8FD14\u8F6E";
+export interface WireFrame {
+    event: string;
+    turn: number;
+    payload: Record<string, unknown>;
+}
+/** Activate a session over the HTTP contract (the engine binds it per turn). */
+export declare function activate(host: ReplayHost, id: string): Promise<number>;
+/** Wait until the host reports the engine idle again. */
+export declare function waitIdle(host: ReplayHost, timeoutMs?: number): Promise<void>;
+/** Drive one real turn over `POST /api/turn`, collecting its SSE frames. */
+export declare function runTurn(host: ReplayHost, input: string): Promise<{
+    status: number;
+    frames: WireFrame[];
+}>;
+/** Byte-level checks of the turn a probe appended to a session log. */
+export declare function turnFindings(id: string, before: string, after: string, input: string, frames: readonly WireFrame[]): Finding[];
+/** Parse the SSE wire text produced by `GET /api/events` into frames. */
+export declare function parseWire(text: string): WireFrame[];
+/**
+ * Push frames through the REAL `GET /api/events` endpoint and read them back.
+ * Frames are emitted in bursts smaller than the bus capacity (512): a larger
+ * backlog would be DROPPED on purpose (the frozen `lagged` degradation), which
+ * is a property of the bus, not of the replay.
+ */
+export interface SseCapture {
+    frames: WireFrame[];
+    /** Raw SSE blocks (`event: …\ndata: …`) exactly as the endpoint wrote them. */
+    blocks: string[];
+}
+export declare function captureSseWire(host: ReplayHost, frames: readonly WireFrame[], session?: string | null, timeoutMs?: number): Promise<SseCapture>;
+/**
+ * Byte-level wire check: every frame the endpoint wrote must equal the block
+ * re-serialized from its own envelope — which pins the field ORDER
+ * (`{v,session,turn,seq,payload}` since W513), the SSE framing and
+ * one-block-per-frame, not merely the parsed values.
+ */
+export declare function compareSseWire(scope: string, expected: readonly WireFrame[], capture: SseCapture, note: string, session?: string | null): Finding;
+/** SSE comparison of a session's derived transcript + the wire-level transport check. */
+export declare function sseFindings(id: string, derived: unknown[], golden: unknown[] | null, capture: SseCapture): Finding[];
+/** The compaction probe: run it over HTTP and verify every produced artifact. */
+export declare function compactFindings(host: ReplayHost, id: string, dir: string): Promise<Finding[]>;

package/dist/replay/probes.js

@@ -0,0 +1,225 @@
+/**
+ * The end-to-end probes of one replayed session: a REAL turn through the host,
+ * the SSE transport check and the compaction probe.
+ *
+ * Every probe reads back the artifact it produced (the JSONL file, the SSE wire,
+ * the `.precompact` backup) so the report can state byte-level facts instead of
+ * "the call returned 200".
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseSessionJsonl } from "@celestea/session";
+import { serializeEventLog } from "@celestea/runtime";
+import { SESSION_LOG_NAME } from "../runtime/engine-session.js";
+import { compareBytes, compareJson, note } from "./compare.js";
+import { expectedCompactLog, headSummary, rawTurnBodies } from "./expect-compact.js";
+/** Terminal status phases of a turn. */
+const TERMINAL = ["completed", "cancelled", "error", "step_limit", "interrupted"];
+/** The frozen "nothing to compact" note. */
+export const SKIP_NOTE = "历史不足，无需压缩";
+/** The frozen compacted note for K = 4. */
+export const COMPACT_NOTE = "已压缩：摘要轮 + 最近4轮";
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(() => resolve(null), ms));
+}
+/** Activate a session over the HTTP contract (the engine binds it per turn). */
+export async function activate(host, id) {
+    const res = await host.app.request(`/api/sessions/${encodeURIComponent(id)}/activate`, { method: "POST" });
+    return res.status;
+}
+/** Wait until the host reports the engine idle again. */
+export async function waitIdle(host, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (host.runtime.isBusy()) {
+        if (Date.now() > deadline)
+            throw new Error("engine did not settle");
+        await delay(5);
+    }
+}
+/** Drive one real turn over `POST /api/turn`, collecting its SSE frames. */
+export async function runTurn(host, input) {
+    const sub = host.studio.services.bus.subscribe();
+    const frames = [];
+    const res = await host.app.request("/api/turn", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ input }) });
+    if (res.status === 202) {
+        const deadline = Date.now() + 10_000;
+        for (;;) {
+            const left = deadline - Date.now();
+            if (left <= 0)
+                break;
+            const frame = await Promise.race([sub.next(), delay(left)]);
+            if (frame === null)
+                break;
+            const payload = (frame.envelope.payload ?? {});
+            frames.push({ event: frame.event, turn: frame.envelope.turn, payload });
+            if (frame.event === "status" && TERMINAL.includes(String(payload["phase"])))
+                break;
+        }
+    }
+    sub.close();
+    await waitIdle(host);
+    return { status: res.status, frames };
+}
+/** Byte-level checks of the turn a probe appended to a session log. */
+export function turnFindings(id, before, after, input, frames) {
+    const findings = [];
+    const newEvents = parseSessionJsonl(after).events.slice(parseSessionJsonl(before).events.length);
+    findings.push(compareBytes(`${id} :: turn-append-bytes`, before + serializeEventLog(newEvents), after, "appended turn is exactly its serialized events"));
+    findings.push(compareJson(`${id} :: turn-append-shape`, "byte-exact", ["turn_start", "user_message", "assistant_message", "turn_end"], newEvents.map((e) => e.type), "appended turn shape"));
+    const text = newEvents.find((e) => e.type === "assistant_message");
+    findings.push(compareJson(`${id} :: turn-answer`, "byte-exact", `echo: ${input}`, text?.type === "assistant_message" ? text.text : null, "offline answer"));
+    const end = newEvents.find((e) => e.type === "turn_end");
+    findings.push(compareJson(`${id} :: turn-outcome`, "byte-exact", "completed", end?.type === "turn_end" ? end.outcome : null, "terminal outcome"));
+    const names = frames.map((f) => f.event);
+    const ok = names[0] === "status" && names.includes("turn_end") && names[names.length - 1] === "status";
+    findings.push(ok
+        ? note(`${id} :: turn-sse`, "byte-exact", `turn frames ${names.join(">")}`, "match")
+        : note(`${id} :: turn-sse`, "golden", `turn frames ${names.join(">")}`, "diff"));
+    return findings;
+}
+/** Parse the SSE wire text produced by `GET /api/events` into frames. */
+export function parseWire(text) {
+    const out = [];
+    for (const block of text.split("\n\n")) {
+        if (block.trim() === "")
+            continue;
+        const eventLine = block.split("\n").find((l) => l.startsWith("event: "));
+        const dataLine = block.split("\n").find((l) => l.startsWith("data: "));
+        if (eventLine === undefined || dataLine === undefined)
+            continue;
+        const envelope = JSON.parse(dataLine.slice("data: ".length));
+        out.push({ event: eventLine.slice("event: ".length), turn: envelope.turn, payload: (envelope.payload ?? {}) });
+    }
+    return out;
+}
+export async function captureSseWire(host, frames, session = null, timeoutMs = 20_000) {
+    const res = await host.app.request("/api/events");
+    const reader = res.body?.getReader();
+    if (reader === undefined)
+        throw new Error("/api/events returned no body");
+    await delay(20); // let the streamSSE handler subscribe before the first emit
+    const decoder = new TextDecoder();
+    let wire = "";
+    const burst = 128;
+    for (let i = 0; i < frames.length; i += burst) {
+        const target = Math.min(i + burst, frames.length);
+        for (const frame of frames.slice(i, target))
+            host.studio.services.bus.emit(frame.event, frame.turn, frame.payload, session);
+        const deadline = Date.now() + timeoutMs;
+        while (parseWire(wire).length < target && Date.now() < deadline) {
+            const chunk = await Promise.race([reader.read(), delay(300).then(() => null)]);
+            if (chunk === null || chunk.done === true)
+                break;
+            wire += decoder.decode(chunk.value);
+        }
+    }
+    await reader.cancel();
+    return { frames: parseWire(wire), blocks: wire.split("\n\n").filter((b) => b.trim() !== "") };
+}
+/**
+ * Byte-level wire check: every frame the endpoint wrote must equal the block
+ * re-serialized from its own envelope — which pins the field ORDER
+ * (`{v,session,turn,seq,payload}` since W513), the SSE framing and
+ * one-block-per-frame, not merely the parsed values.
+ */
+export function compareSseWire(scope, expected, capture, note, session = null) {
+    if (capture.frames.length !== expected.length) {
+        return wireDiff(scope, `${note}: ${capture.frames.length} frame(s) on the wire, expected ${expected.length}`, []);
+    }
+    const diffs = [];
+    for (let i = 0; i < expected.length; i++) {
+        const frame = expected[i];
+        const block = capture.blocks[i] ?? "";
+        // `seq` is a process-global counter the replay cannot predict: take it off
+        // the wire, then demand the REST of the block be byte-identical.
+        const seq = seqOf(block);
+        const rebuilt = `event: ${frame.event}\ndata: ${JSON.stringify({ v: 2, session, turn: frame.turn, seq, payload: frame.payload })}`;
+        if (block !== rebuilt && diffs.length < 3)
+            diffs.push(`$[${i}] wire block differs: ${block.slice(0, 80)} != ${rebuilt.slice(0, 80)}`);
+    }
+    if (diffs.length > 0)
+        return wireDiff(scope, `${note}: ${diffs.length} wire divergence(s)`, diffs);
+    return { scope, kind: "byte-exact", verdict: "match", detail: `${note}: ${capture.frames.length} wire block(s) byte-identical (envelope order v,session,turn,seq,payload)` };
+}
+/** One wire-level divergence finding (only byte-level evidence is reported here). */
+function wireDiff(scope, detail, diffs) {
+    return { scope, kind: "byte-exact", verdict: "diff", detail, diffs };
+}
+/** `seq` of a written block (a process-global counter the replay cannot predict). */
+function seqOf(block) {
+    const data = block.split("\n").find((l) => l.startsWith("data: "));
+    if (data === undefined)
+        return null;
+    try {
+        return JSON.parse(data.slice("data: ".length)).seq ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** SSE comparison of a session's derived transcript + the wire-level transport check. */
+export function sseFindings(id, derived, golden, capture) {
+    const findings = [];
+    if (golden === null) {
+        findings.push(note(`${id} :: sse-transcript`, "self-check", `golden transcript not stored for this session; ${derived.length} frame(s) regenerated in-memory`));
+    }
+    else {
+        findings.push(compareJson(`${id} :: sse-transcript`, "self-check", golden, derived, "TS-derived transcript (legacy capture is a P6 gap)"));
+    }
+    const expected = derived.map((f) => ({
+        event: f.event,
+        turn: f.data.turn,
+        payload: f.data.payload,
+    }));
+    const source = golden === null ? "TS-derived frames" : "stored golden transcript frames";
+    findings.push(compareSseWire(`${id} :: sse-transport`, expected, capture, `GET /api/events replayed ${source}`, id));
+    return findings;
+}
+/** The compaction probe: run it over HTTP and verify every produced artifact. */
+export async function compactFindings(host, id, dir) {
+    const logPath = join(dir, SESSION_LOG_NAME);
+    const before = readFileSync(logPath, "utf8");
+    const beforeEvents = parseSessionJsonl(before).events;
+    const sub = host.studio.services.bus.subscribe();
+    const res = await host.app.request(`/api/sessions/${encodeURIComponent(id)}/compact`, { method: "POST" });
+    const body = (await res.json());
+    const frame = await Promise.race([sub.next(), delay(2_000)]);
+    sub.close();
+    const after = readFileSync(logPath, "utf8");
+    return expectedCompactLog(beforeEvents, "", 4) === null
+        ? shortHistoryFindings(id, before, after, body, frame)
+        : compactedFindings({ id, dir, before, after, body, frame });
+}
+/** History at/below the threshold: nothing may change. */
+function shortHistoryFindings(id, before, after, body, frame) {
+    const findings = [compareBytes(`${id} :: compact-log`, before, after, "log untouched (history below threshold)")];
+    findings.push(compareJson(`${id} :: compact-response`, "golden", { compacted: false, note: SKIP_NOTE }, { compacted: body["compacted"], note: body["note"] }, "skip branch"));
+    findings.push(skipFrameFinding(id, frame));
+    return findings;
+}
+function skipFrameFinding(id, frame) {
+    const payload = frame === null ? null : frame.envelope.payload;
+    return compareJson(`${id} :: compact-sse`, "golden", { compacted: false, note: SKIP_NOTE }, { compacted: false, note: payload?.["note"] }, "compact frame");
+}
+/** History above the threshold: structure, backup and kept-turn bytes. */
+function compactedFindings(input) {
+    const { id, dir, before, after, body, frame } = input;
+    const findings = [];
+    const events = parseSessionJsonl(after).events;
+    const summary = headSummary(events);
+    const expected = summary === null ? null : expectedCompactLog(parseSessionJsonl(before).events, summary, 4);
+    if (expected === null) {
+        findings.push(note(`${id} :: compact-log`, "spec-derived", "compacted log has no 【上下文压缩】 head turn", "diff"));
+    }
+    else {
+        findings.push(compareBytes(`${id} :: compact-log`, serializeEventLog(expected), after, "independent re-derivation of the W259 plan"));
+    }
+    findings.push(compareBytes(`${id} :: compact-backup`, before, readFileSync(join(dir, "cli-main.jsonl.precompact"), "utf8"), ".precompact backup of the pre-compaction log"));
+    const keptBefore = rawTurnBodies(before, parseSessionJsonl).slice(-4);
+    const keptAfter = rawTurnBodies(after, parseSessionJsonl).slice(-4);
+    findings.push(compareJson(`${id} :: compact-kept-turn-bodies`, "byte-exact", keptBefore, keptAfter, "kept turns are byte-identical apart from renumbering"));
+    findings.push(compareJson(`${id} :: compact-response`, "golden", { compacted: true, kept_turns: 4, note: COMPACT_NOTE }, { compacted: body["compacted"], kept_turns: body["kept_turns"], note: body["note"] }, "compacted branch"));
+    const payload = frame === null ? null : frame.envelope.payload;
+    findings.push(compareJson(`${id} :: compact-sse`, "golden", { session: id, kept_turns: 4, note: COMPACT_NOTE, rebound: true }, payload, "compact frame"));
+    return findings;
+}

package/dist/replay/report.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Markdown / console rendering of the P5 double-run report.
+ *
+ * The markdown is the deliverable of the replay: it states, per finding, WHICH
+ * evidence class backs the claim (byte-exact / frozen golden / spec-derived /
+ * self-check) so a reader can tell a proven byte-level match from a
+ * self-consistency check, and it lists the P6 gaps next to the verdict.
+ */
+import type { ReplayE2EReport } from "./e2e-replay.js";
+/** The full markdown report. */
+export declare function renderReplayMarkdown(report: ReplayE2EReport): string;
+/** One-line console summary (the CLI prints this plus the session rows). */
+export declare function renderReplayConsole(report: ReplayE2EReport): string;