@celestea/session 2.7.1

package/dist/log/memory.js

@@ -0,0 +1,43 @@
+/**
+ * InMemorySessionLog — port of `crates/session/src/log.rs:16-66`.
+ *
+ * An in-memory, append-only session log: insertion order is the single source
+ * of truth and the model history is always derived from it, never stored
+ * separately. The turn-id counter is owned by the LOG (not the agent loop) and
+ * never resets — not even on `clear` — so ids never repeat across loop
+ * instances (P0-A unique turn identity).
+ */
+import { deriveMessagesFrom, formatTurnId } from "@celestea/core";
+export class InMemorySessionLog {
+    recorded = [];
+    turnCounter = 0;
+    /** Create an empty session log. */
+    static create() {
+        return new InMemorySessionLog();
+    }
+    append(event) {
+        this.recorded.push(event);
+    }
+    /** A copy of the recorded events (`events()` clones the Vec). */
+    events() {
+        return [...this.recorded];
+    }
+    deriveMessages() {
+        return deriveMessagesFrom(this.recorded);
+    }
+    /** Drop every event; the id counter deliberately survives (`clear`). */
+    clear() {
+        this.recorded = [];
+    }
+    nextTurnId() {
+        return formatTurnId(this.turnCounter++);
+    }
+    /** The next number the counter would hand out (diagnostics / recovery). */
+    peekTurnNumber() {
+        return this.turnCounter;
+    }
+    /** Restore the counter after a replay (`PersistentSessionLog` recovery). */
+    restoreTurnCounter(next) {
+        this.turnCounter = next;
+    }
+}

package/dist/log/persistent.d.ts

@@ -0,0 +1,58 @@
+/**
+ * PersistentSessionLog — port of `crates/session/src/persistent.rs:86-280`.
+ *
+ * A drop-in [SessionLog] whose every appended event is mirrored to disk as one
+ * JSON line in a per-session append-only file, while the in-memory semantics of
+ * [InMemorySessionLog] (insertion order + the shared `derive_messages`
+ * projection) are preserved. `open` replays the file, so a restart reconstructs
+ * the same model-visible history and the same turn counter.
+ *
+ * Failure model: the log stays usable if a disk write fails — the event remains
+ * in the in-memory view (derive_messages keeps working), the failure is counted
+ * ([writeErrorCount]) and warned on stderr. Only open/replay/sync surface
+ * errors to the caller.
+ *
+ * Deviation from the legacy implementation (documented, safe direction): it buffers
+ * through a `BufWriter`, so `flushEachAppend=false` batches records and a crash can lose
+ * them. `fs.writeSync` is unbuffered, so every append already reaches the OS;
+ * `flush()` is therefore a no-op and `flushEachAppend=false` cannot lose data.
+ * `sync()` is the real durability point (fsync), matching `sync_each_append`.
+ */
+import type { Message, SessionEvent, SessionLog } from "@celestea/core";
+import { type TornRecord } from "./file.js";
+export interface PersistentOptions {
+    /** Accepted for parity; writes are unbuffered so no record can be lost. */
+    flushEachAppend: boolean;
+    /** fsync after every appended record (survives power loss too). */
+    syncEachAppend: boolean;
+}
+export declare function defaultPersistentOptions(): PersistentOptions;
+export declare class PersistentSessionLog implements SessionLog {
+    readonly path: string;
+    /** The torn tail found on open (null when the file replayed clean). */
+    readonly tornTail: TornRecord | null;
+    private recorded;
+    private turnCounter;
+    private fd;
+    private writeErrors;
+    private readonly opts;
+    private constructor();
+    /** Open (and replay) the append-only log for `sessionId` under `dir`. */
+    static open(dir: string, sessionId: string, opts?: PersistentOptions): PersistentSessionLog;
+    append(event: SessionEvent): void;
+    events(): SessionEvent[];
+    deriveMessages(): Message[];
+    nextTurnId(): string;
+    /** The next number the counter would hand out. */
+    peekTurnNumber(): number;
+    clear(): void;
+    /** No-op: `writeSync` is unbuffered, so records already reached the OS. */
+    flush(): void;
+    /** fsync the file so buffered records survive power loss. */
+    sync(): void;
+    /** How many append-path write failures were recorded (degraded mode). */
+    writeErrorCount(): number;
+    /** Flush + release the descriptor (`Drop`). Idempotent. */
+    close(): void;
+    private closeFd;
+}

package/dist/log/persistent.js

@@ -0,0 +1,118 @@
+/**
+ * PersistentSessionLog — port of `crates/session/src/persistent.rs:86-280`.
+ *
+ * A drop-in [SessionLog] whose every appended event is mirrored to disk as one
+ * JSON line in a per-session append-only file, while the in-memory semantics of
+ * [InMemorySessionLog] (insertion order + the shared `derive_messages`
+ * projection) are preserved. `open` replays the file, so a restart reconstructs
+ * the same model-visible history and the same turn counter.
+ *
+ * Failure model: the log stays usable if a disk write fails — the event remains
+ * in the in-memory view (derive_messages keeps working), the failure is counted
+ * ([writeErrorCount]) and warned on stderr. Only open/replay/sync surface
+ * errors to the caller.
+ *
+ * Deviation from the legacy implementation (documented, safe direction): it buffers
+ * through a `BufWriter`, so `flushEachAppend=false` batches records and a crash can lose
+ * them. `fs.writeSync` is unbuffered, so every append already reaches the OS;
+ * `flush()` is therefore a no-op and `flushEachAppend=false` cannot lose data.
+ * `sync()` is the real durability point (fsync), matching `sync_each_append`.
+ */
+import { appendFileSync, closeSync, fsyncSync, mkdirSync, openSync, truncateSync, writeSync } from "node:fs";
+import { deriveMessagesFrom, formatTurnId, nextTurnNumber, serializeSessionEvent } from "@celestea/core";
+import { fileLacksFinalNewline, filePathFor, replayFile } from "./file.js";
+export function defaultPersistentOptions() {
+    return { flushEachAppend: true, syncEachAppend: false };
+}
+export class PersistentSessionLog {
+    path;
+    /** The torn tail found on open (null when the file replayed clean). */
+    tornTail;
+    recorded = [];
+    turnCounter = 0;
+    fd = null;
+    writeErrors = 0;
+    opts;
+    constructor(path, opts, tornTail) {
+        this.path = path;
+        this.opts = opts;
+        this.tornTail = tornTail;
+    }
+    /** Open (and replay) the append-only log for `sessionId` under `dir`. */
+    static open(dir, sessionId, opts = defaultPersistentOptions()) {
+        mkdirSync(dir, { recursive: true });
+        const path = filePathFor(dir, sessionId);
+        // The longest valid prefix wins; a torn tail is truncated away.
+        const replay = replayFile(path);
+        if (replay.truncated)
+            truncateSync(path, replay.validBytes);
+        if (fileLacksFinalNewline(path))
+            appendFileSync(path, "\n");
+        const log = new PersistentSessionLog(path, opts, replay.torn);
+        log.recorded = replay.events;
+        // P0-A: restore the counter from the replayed file (max id on disk + 1).
+        log.turnCounter = nextTurnNumber(replay.events);
+        log.fd = openSync(path, "a");
+        return log;
+    }
+    append(event) {
+        const line = serializeSessionEvent(event);
+        try {
+            if (this.fd === null)
+                throw new Error("session log is closed");
+            writeSync(this.fd, Buffer.from(`${line}\n`, "utf8"));
+            if (this.opts.syncEachAppend)
+                fsyncSync(this.fd);
+        }
+        catch (e) {
+            this.writeErrors += 1;
+            process.stderr.write(`[celestea-session] append not persisted to ${this.path} (writeErrorCount=${this.writeErrors}); kept in memory only: ${String(e)}\n`);
+        }
+        // The in-memory view is the source of truth for derive_messages: keep the
+        // event even when the disk path failed (graceful degradation).
+        this.recorded.push(event);
+    }
+    events() {
+        return [...this.recorded];
+    }
+    deriveMessages() {
+        return deriveMessagesFrom(this.recorded);
+    }
+    nextTurnId() {
+        return formatTurnId(this.turnCounter++);
+    }
+    /** The next number the counter would hand out. */
+    peekTurnNumber() {
+        return this.turnCounter;
+    }
+    clear() {
+        this.closeFd();
+        this.fd = openSync(this.path, "w"); // truncates
+        this.recorded = [];
+        // The emptied file replays to counter 0; keep the live counter in sync.
+        this.turnCounter = 0;
+    }
+    /** No-op: `writeSync` is unbuffered, so records already reached the OS. */
+    flush() {
+        // Intentionally empty — see the module header.
+    }
+    /** fsync the file so buffered records survive power loss. */
+    sync() {
+        if (this.fd !== null)
+            fsyncSync(this.fd);
+    }
+    /** How many append-path write failures were recorded (degraded mode). */
+    writeErrorCount() {
+        return this.writeErrors;
+    }
+    /** Flush + release the descriptor (`Drop`). Idempotent. */
+    close() {
+        this.closeFd();
+    }
+    closeFd() {
+        if (this.fd !== null) {
+            closeSync(this.fd);
+            this.fd = null;
+        }
+    }
+}

package/dist/messages.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The two projections of the session log.
+ *
+ * 1. Studio projection (GET /api/sessions/{id}/messages) — src/api.rs:94-135.
+ *    Per-event, independent, NO pairing/dropping; thinking rows are included;
+ *    orphan tool_result rows are emitted; tool rows carry tool_parent_id.
+ * 2. Engine `derive_messages` — the model-visible history (see ./log/derive.ts):
+ *    turn markers and thinking are skipped, run_code sub-call rows
+ *    (parent_id present) are skipped, consecutive tool calls merge into ONE
+ *    assistant message, and unanswered calls are balanced with a synthetic
+ *    cancelled result.
+ *
+ * Keeping both explicit is the whole point: they differ, and the difference is
+ * contract.
+ */
+import type { Message, SessionEvent, SessionEventOrigin, StudioMessage } from "@celestea/core";
+/** The label of a non-user origin ('user' never reaches here). */
+export declare function originLabel(origin: SessionEventOrigin): string;
+/** Studio projection of a single event; null for structural markers. */
+export declare function sessionEventToMessage(ev: SessionEvent): StudioMessage | null;
+/** The Studio message list for a whole log (golden-compared against HTTP). */
+export declare function projectMessages(events: readonly SessionEvent[]): StudioMessage[];
+/**
+ * Engine model-visible projection (`derive_messages`). Returns the engine's
+ * `Message` shape (`role` / `content[]` / `tool_call_id`), not the Studio shape.
+ */
+export declare function deriveMessages(events: readonly SessionEvent[]): Message[];

package/dist/messages.js

@@ -0,0 +1,128 @@
+/**
+ * The two projections of the session log.
+ *
+ * 1. Studio projection (GET /api/sessions/{id}/messages) — src/api.rs:94-135.
+ *    Per-event, independent, NO pairing/dropping; thinking rows are included;
+ *    orphan tool_result rows are emitted; tool rows carry tool_parent_id.
+ * 2. Engine `derive_messages` — the model-visible history (see ./log/derive.ts):
+ *    turn markers and thinking are skipped, run_code sub-call rows
+ *    (parent_id present) are skipped, consecutive tool calls merge into ONE
+ *    assistant message, and unanswered calls are balanced with a synthetic
+ *    cancelled result.
+ *
+ * Keeping both explicit is the whole point: they differ, and the difference is
+ * contract.
+ */
+import { deriveMessagesFrom, toolSurfaceValue } from "@celestea/core";
+/** W888: the human-readable label each non-user origin shows in the block. */
+const ORIGIN_LABEL = {
+    skill: "技能目录",
+    memory: "记忆 · 每轮注入",
+    receipt: "回执",
+    steering: "插话",
+    compact: "压缩摘要",
+};
+/** The label of a non-user origin ('user' never reaches here). */
+export function originLabel(origin) {
+    return origin === "user" ? "用户" : ORIGIN_LABEL[origin];
+}
+/** Studio projection of a single event; null for structural markers. */
+export function sessionEventToMessage(ev) {
+    switch (ev.type) {
+        case "turn_start":
+        case "turn_end":
+            return null;
+        case "user_message": {
+            // W888: a non-user ORIGIN projects to an inbox row (the UI's existing
+            // renderInboxMessage branch). Absent/'user' keeps the exact pre-W888 bytes.
+            const origin = ev.origin;
+            if (origin !== undefined && origin !== "user") {
+                const inbox = { role: "inbox", kind: origin, content: ev.text, source: originLabel(origin) };
+                if (ev.attachments !== undefined && ev.attachments.length > 0)
+                    inbox.attachments = ev.attachments;
+                return inbox;
+            }
+            // W804 §4.2D: the Studio projection carries the attachment references (the
+            // bytes stay on disk); no attachments => the pre-W804 object byte for byte.
+            const out = { role: "user", content: ev.text };
+            if (ev.attachments !== undefined && ev.attachments.length > 0)
+                out.attachments = ev.attachments;
+            return out;
+        }
+        case "assistant_message":
+            return { role: "assistant", content: ev.text };
+        case "thinking_delta":
+            return { role: "thinking", content: ev.text };
+        case "tool_call": {
+            const out = {
+                role: "tool",
+                kind: "call",
+                tool_call_id: ev.id,
+                tool_name: ev.name,
+                tool_args: ev.args,
+            };
+            if (ev.parent_id !== undefined)
+                out.tool_parent_id = ev.parent_id;
+            return out;
+        }
+        case "tool_result": {
+            // W855 (B6): the log stores the ORIGINAL value; the transcript shows the
+            // bounded/annotated FACE (the original can be arbitrarily large) plus the
+            // descriptor so a card can badge "N bytes omitted -> locator".
+            const out = {
+                role: "tool",
+                kind: "result",
+                tool_call_id: ev.id,
+                tool_value: toolSurfaceValue(ev.value, ev.surface),
+                tool_error: ev.error,
+            };
+            if (ev.parent_id !== undefined)
+                out.tool_parent_id = ev.parent_id;
+            if (ev.surface !== undefined)
+                out.tool_surface = ev.surface;
+            return out;
+        }
+        // W783 §7: the two host-side question rows. The Studio projection is the
+        // per-event transcript surface the UI replays, so a parked question and its
+        // answer stay visible there (an unanswered row is how a restart looks).
+        case "user_question": {
+            const out = {
+                role: "question",
+                kind: "question",
+                question_id: ev.id,
+                content: ev.questions,
+            };
+            if (ev.expires_at !== undefined)
+                out.question_expires_at = ev.expires_at;
+            return out;
+        }
+        case "user_answer": {
+            const out = {
+                role: "question",
+                kind: "answer",
+                question_id: ev.id,
+                content: ev.answers,
+            };
+            if (ev.timed_out !== undefined)
+                out.question_timed_out = ev.timed_out;
+            return out;
+        }
+    }
+}
+/** The Studio message list for a whole log (golden-compared against HTTP). */
+export function projectMessages(events) {
+    const out = [];
+    for (const ev of events) {
+        const m = sessionEventToMessage(ev);
+        if (m !== null)
+            out.push(m);
+    }
+    return out;
+}
+/**
+ * Engine model-visible projection (`derive_messages`). Returns the engine's
+ * `Message` shape (`role` / `content[]` / `tool_call_id`), not the Studio shape.
+ */
+export function deriveMessages(events) {
+    return deriveMessagesFrom(events);
+}

package/dist/plugin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The session package as a PLUGIN (rule 3: everything is a plugin).
+ *
+ * `packages/session` never gets imported by `core`: it only provides a
+ * [SessionLog] implementation into a [Context] under the well-known
+ * `SESSION_LOG_SERVICE` token, exactly like `celestea-session` is plugged into
+ * the harness at compose time. A later mount of the same token wins, so a
+ * test can swap in an in-memory log over a persistent one.
+ */
+import { type Plugin, type SessionLog } from "@celestea/core";
+import { PersistentSessionLog, type PersistentOptions } from "./log/persistent.js";
+/** Provide an (optionally pre-populated) in-memory log. */
+export declare function inMemorySessionLogPlugin(name?: string, log?: SessionLog): Plugin;
+export interface PersistentSessionLogOptions {
+    dir: string;
+    sessionId: string;
+    options?: PersistentOptions;
+}
+/** Open a JSONL-backed log and provide it (the log is returned via `onOpen`). */
+export declare function persistentSessionLogPlugin(cfg: PersistentSessionLogOptions, onOpen?: (log: PersistentSessionLog) => void, name?: string): Plugin;

package/dist/plugin.js

@@ -0,0 +1,24 @@
+/**
+ * The session package as a PLUGIN (rule 3: everything is a plugin).
+ *
+ * `packages/session` never gets imported by `core`: it only provides a
+ * [SessionLog] implementation into a [Context] under the well-known
+ * `SESSION_LOG_SERVICE` token, exactly like `celestea-session` is plugged into
+ * the harness at compose time. A later mount of the same token wins, so a
+ * test can swap in an in-memory log over a persistent one.
+ */
+import { definePlugin, SESSION_LOG_SERVICE } from "@celestea/core";
+import { InMemorySessionLog } from "./log/memory.js";
+import { PersistentSessionLog } from "./log/persistent.js";
+/** Provide an (optionally pre-populated) in-memory log. */
+export function inMemorySessionLogPlugin(name = "celestea.session.InMemorySessionLog", log = new InMemorySessionLog()) {
+    return definePlugin(name, (ctx) => ctx.provide(SESSION_LOG_SERVICE, log));
+}
+/** Open a JSONL-backed log and provide it (the log is returned via `onOpen`). */
+export function persistentSessionLogPlugin(cfg, onOpen, name = "celestea.session.PersistentSessionLog") {
+    return definePlugin(name, (ctx) => {
+        const log = PersistentSessionLog.open(cfg.dir, cfg.sessionId, cfg.options);
+        onOpen?.(log);
+        ctx.provide(SESSION_LOG_SERVICE, log);
+    });
+}

package/dist/replay.d.ts

@@ -0,0 +1,59 @@
+/** Structural analysis of a replayed session log (P0 replay comparison). */
+import { type ParseJsonlResult } from "./jsonl.js";
+import { type TurnIdAudit } from "./turn-id.js";
+import { type SessionEvent } from "@celestea/core";
+export interface ReplayStats {
+    physicalLines: number;
+    parsedEvents: number;
+    blankLines: number;
+    tornTail: ParseJsonlResult["tornTail"];
+    turnStarts: number;
+    turnEnds: number;
+    /** turn_start rows with no matching turn_end (a killed/crashed turn). */
+    danglingTurns: number;
+    toolCalls: number;
+    toolResults: number;
+    /** tool_call rows with no matching tool_result id. */
+    danglingToolCalls: Array<{
+        id: string;
+        name: string;
+    }>;
+    /** tool_result rows with no matching tool_call id. */
+    orphanToolResults: string[];
+    /** W255 run_code sub-calls (parent_id present). */
+    subCalls: number;
+    subCallParents: string[];
+    thinkingEvents: number;
+    userMessages: number;
+    assistantMessages: number;
+    outcomes: Record<string, number>;
+    turnIds: TurnIdAudit;
+}
+export declare function analyzeReplay(parsed: ParseJsonlResult): ReplayStats;
+/**
+ * Derive the SSE transcript a client would have observed for this log.
+ * `seq` is synthetic (the real counter is process-global and not recoverable
+ * from the log); `turn` is the engine turn number.
+ *
+ * W834 F08 — what is reconstructable (and what is not):
+ *   turn_start        -> status{phase:"start"}
+ *   thinking_delta    -> thinking
+ *   assistant_message -> text
+ *   tool_call         -> tool
+ *   tool_result       -> tool_result
+ *   turn_end          -> turn_end + status
+ *   user_question     -> question (payload mirrors runtime `questionFrame`)
+ * Deliberately NOT reconstructable: `user_message` (never an SSE frame),
+ * `user_answer` (the product emits no frame — the answer resolves the parked
+ * promise in-process, `apps/studio/src/runtime/question-view.ts`), and the
+ * `done`/`compact` frames (they have no session-log row).
+ */
+export interface DerivedSseFrame {
+    event: string;
+    data: {
+        turn: number;
+        seq: number;
+        payload: Record<string, unknown>;
+    };
+}
+export declare function deriveSseTranscript(events: readonly SessionEvent[], startTurn?: number): DerivedSseFrame[];

package/dist/replay.js

@@ -0,0 +1,145 @@
+/** Structural analysis of a replayed session log (P0 replay comparison). */
+import { outcomePhase } from "./jsonl.js";
+import { auditTurnIds } from "./turn-id.js";
+import { toolSurfaceValue } from "@celestea/core";
+export function analyzeReplay(parsed) {
+    const events = parsed.events;
+    const calls = new Map();
+    const results = new Set();
+    const subCallParents = new Set();
+    const outcomes = {};
+    let turnStarts = 0;
+    let turnEnds = 0;
+    let thinkingEvents = 0;
+    let userMessages = 0;
+    let assistantMessages = 0;
+    let subCalls = 0;
+    for (const ev of events) {
+        switch (ev.type) {
+            case "turn_start":
+                turnStarts += 1;
+                break;
+            case "turn_end":
+                turnEnds += 1;
+                outcomes[outcomePhase(ev.outcome)] = (outcomes[outcomePhase(ev.outcome)] ?? 0) + 1;
+                break;
+            case "thinking_delta":
+                thinkingEvents += 1;
+                break;
+            case "user_message":
+                userMessages += 1;
+                break;
+            case "assistant_message":
+                assistantMessages += 1;
+                break;
+            case "tool_call":
+                calls.set(ev.id, ev.name);
+                if (ev.parent_id !== undefined) {
+                    subCalls += 1;
+                    subCallParents.add(ev.parent_id);
+                }
+                break;
+            case "tool_result":
+                results.add(ev.id);
+                break;
+        }
+    }
+    const danglingToolCalls = [];
+    for (const [id, name] of calls)
+        if (!results.has(id))
+            danglingToolCalls.push({ id, name });
+    const orphanToolResults = [];
+    for (const id of results)
+        if (!calls.has(id))
+            orphanToolResults.push(id);
+    return {
+        physicalLines: parsed.physicalLines,
+        parsedEvents: parsed.events.length,
+        blankLines: parsed.blankLines,
+        tornTail: parsed.tornTail,
+        turnStarts,
+        turnEnds,
+        danglingTurns: Math.max(0, turnStarts - turnEnds),
+        toolCalls: calls.size,
+        toolResults: results.size,
+        danglingToolCalls,
+        orphanToolResults,
+        subCalls,
+        subCallParents: [...subCallParents].sort(),
+        thinkingEvents,
+        userMessages,
+        assistantMessages,
+        outcomes,
+        turnIds: auditTurnIds(events),
+    };
+}
+export function deriveSseTranscript(events, startTurn = 0) {
+    const frames = [];
+    let seq = 0;
+    let turn = startTurn;
+    let sawTurnStart = false;
+    const push = (event, payload) => {
+        frames.push({ event, data: { turn, seq: seq++, payload } });
+    };
+    for (const ev of events) {
+        switch (ev.type) {
+            case "turn_start":
+                turn += 1;
+                sawTurnStart = true;
+                push("status", { phase: "start" });
+                break;
+            case "user_message":
+                break; // not an SSE event
+            case "user_question":
+                // W834 F08: the only frame a client can have seen for a question,
+                // rebuilt from the row's own fields. `session` is null because the
+                // derived envelope carries no session identity (the log does not
+                // either); the other four keys mirror `questionFrame` exactly.
+                push("question", {
+                    session: null,
+                    id: ev.id,
+                    questions: [...ev.questions],
+                    expires_at: ev.expires_at,
+                    timeout_ms: ev.timeout_ms,
+                });
+                break;
+            case "user_answer":
+                // The product emits NO frame when a question is answered: POST
+                // /api/questions/{id}/answer resolves the parked promise directly
+                // (question-view.ts). The row is the durable record; there is no
+                // client-visible frame to rebuild, so it is explicitly skipped.
+                break;
+            case "thinking_delta":
+                push("thinking", { delta: ev.text });
+                break;
+            case "assistant_message":
+                push("text", { delta: ev.text });
+                break;
+            case "tool_call":
+                push("tool", { id: ev.id, name: ev.name, args: ev.args });
+                break;
+            case "tool_result":
+                // W855 (B6): the log stores the original; the frame a client saw carried
+                // the FACE, so replay applies the same surface the live loop emitted.
+                push("tool_result", {
+                    id: ev.id,
+                    ok: ev.error === null,
+                    value: toolSurfaceValue(ev.value, ev.surface),
+                    render: null,
+                    error: ev.error,
+                    decision: null,
+                });
+                break;
+            case "turn_end": {
+                const phase = outcomePhase(ev.outcome);
+                const error = ev.outcome !== undefined && typeof ev.outcome === "object" ? `${ev.outcome.error.kind}: ${ev.outcome.error.message}` : null;
+                push("turn_end", { outcome: phase, error });
+                push("status", { phase, error });
+                break;
+            }
+        }
+    }
+    if (!sawTurnStart && frames.length > 0)
+        turn = startTurn;
+    return frames;
+}

package/dist/turn-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Turn id math — A2 (W746): moved to `@celestea/core` (`core/src/turn-id.ts`)
+ * because `SessionLog.nextTurnId()` is a seam method: the log owns the counter
+ * and every implementation must mint the same `turn-<n>` ids from the same
+ * arithmetic. This module stays as the stable import path inside the package.
+ */
+export { auditTurnIds, formatTurnId, maxTurnNumber, nextTurnId, nextTurnNumber, parseTurnNumber, } from "@celestea/core";
+export type { TurnIdAudit } from "@celestea/core";

package/dist/turn-id.js

@@ -0,0 +1,7 @@
+/**
+ * Turn id math — A2 (W746): moved to `@celestea/core` (`core/src/turn-id.ts`)
+ * because `SessionLog.nextTurnId()` is a seam method: the log owns the counter
+ * and every implementation must mint the same `turn-<n>` ids from the same
+ * arithmetic. This module stays as the stable import path inside the package.
+ */
+export { auditTurnIds, formatTurnId, maxTurnNumber, nextTurnId, nextTurnNumber, parseTurnNumber, } from "@celestea/core";

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@celestea/session",
+  "version": "2.7.1",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@celestea/core": "2.7.1"
+  },
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json"
+  }
+}