@vibe-commit/capture 0.10.0 → 0.11.0

package/dist/firing.d.ts

@@ -0,0 +1,169 @@
+/**
+ * THE FIRING LOG AND THE HOOK'S LIVENESS STAMP — U3 of the detached uploader.
+ *
+ * A *firing* is one hook that ended a turn: today's hook body, deferred. The hook appends one line saying "this turn ended here, at this
+ * size, in this folder, with these repos" and returns; the upload worker (U5) replays the lines in order, each ALONE, with the values
+ * recorded at the moment the hook fired (plan §3.2-§3.4, D15). This module is the storage half and nothing in the hook calls it yet:
+ * it is inert until the hook is flipped (U6).
+ *
+ * ## What it owns
+ *  - `<sid>.firings.jsonl` — append-only, one `O_APPEND` write per line, no lock (hooks never wait).
+ *  - `<sid>.firings.cursor` — the worker's progress: a byte offset, and how many times the firing at that offset made the worker THROW.
+ *    Written atomically, and only by a holder of the session's writer lock.
+ *  - `<repo digest>/<sid>.live` — the hook-only liveness stamp, and the ONE function that reads liveness (`liveAtOf`).
+ *
+ * ## What a firing holds: paths and numbers only
+ * No credential, no transcript content. The worker re-confines `transcript` and `announced` with `admitsTranscript` before every read.
+ *
+ * ## ⛔ A LEAF MODULE. It imports `paths` and `atomic_write` and nothing else of this package's, because `spool.ts` and `state.ts` both
+ * read liveness through it and neither may import the other.
+ */
+import { type SessionKey } from "./paths.js";
+/** The line format this build writes and reads. A reader sees a NEWER `v` as a stop sign, never as garbage (§3.14). */
+export declare const FIRING_VERSION = 1;
+/** A line longer than this is not written: a firing is ~300 bytes, and one `O_APPEND` write of a small buffer is what keeps hooks lock-free. */
+export declare const MAX_FIRING_BYTES: number;
+/** After this many uncaught throws on one firing, the worker skips it. A firing only sets an EOF, so the next one still covers its bytes. */
+export declare const MAX_FIRING_THROWS = 3;
+/**
+ * Per repo key: the liveness the hook read BEFORE it stamped (plan §3.4, P2 point 4). Stamping first would flip `stale-own` to `first-turn`.
+ *  - a number: the stamp (`SessionState.liveAt`, or the `.live` file, whichever is later).
+ *  - `null`: a state file exists with NO `liveAt` (what `finalize` and `backfill` leave). Reads as `stale-own`.
+ *  - key ABSENT: no state file at all. Reads as `first-turn`.
+ * A plain number-or-omitted map would read a resumed session as `first-turn` and keep a lingering-id line.
+ */
+export type PriorLiveness = Readonly<Record<string, number | null>>;
+export interface Firing {
+    readonly v: number;
+    /** The hook's own clock, epoch ms: "the moment its hook runs". Promotion, pending mode and the commit pin are all judged as of it. */
+    readonly at: number;
+    /**
+     * The session id as the agent named it. The log's FILE NAME is `sanitise(sid)` (capped at 128 characters), which loses characters the
+     * wire id keeps, so the worker takes the id to send from here and never from a file name.
+     */
+    readonly sid: string;
+    /** `Stop`, `PreCompact`, `SessionEnd`, ... as the dialect named it. */
+    readonly event: string;
+    /** The main transcript's size when the hook ran. `SessionEnd` is settled by the worker, not here. */
+    readonly eof: number;
+    readonly transcript: string;
+    /** The turn-end folder (stdin's `cwd`). */
+    readonly cwd: string;
+    /** The turn-end repo's keys as step 3 resolved them. Re-deriving from `cwd` fails once a work tree is gone (§3.2). Absent: not in a repo. */
+    readonly keys?: {
+        readonly worktree: string;
+        readonly consent: string;
+    };
+    /** Present only when step 3's consent check got a REAL slug, never the `local:` fallback. */
+    readonly slug?: string;
+    readonly agent: string;
+    /** The identity digest (§3.13): a worker serves only firings of its own. */
+    readonly id: string;
+    readonly prior: PriorLiveness;
+    /** A sub-agent transcript the dialect announced for this firing. */
+    readonly announced?: string;
+    /**
+     * U6b (F5, C33): each sub-agent file's size when the hook ran, by file key. A replay sends no sub-agent byte past these (a file absent here
+     * sends nothing in this step), so a late replay cannot read sub-agent bytes that did not exist at the firing and a delayed worker produces what
+     * a prompt one does. ABSENT: an older firing, or one whose map would not fit the line; its sub-agents are sent to their real size, as before.
+     */
+    readonly sub?: Readonly<Record<string, number>>;
+}
+/** More sub-agent files than this in one firing: the map is left out (uncapped) rather than growing the line past `MAX_FIRING_BYTES`. */
+export declare const MAX_FIRING_SUB_FILES = 200;
+/** One firing as read back: where it starts and ends in the log, so a cursor can step over exactly it. */
+export interface ReadFiring {
+    readonly firing: Firing;
+    readonly start: number;
+    readonly end: number;
+}
+export interface FiringRead {
+    /** Valid firings at or after the cursor, oldest first, up to the first line of a NEWER version. */
+    readonly firings: readonly ReadFiring[];
+    /**
+     * The offset after the last COMPLETE line this read judged (a malformed one included, a partial trailing one not, a newer-version one
+     * not). Advancing the cursor here steps over torn lines that no valid firing follows.
+     */
+    readonly through: number;
+    /** True when a line of a newer `v` stopped the read. The worker leaves it unconsumed and exits (a newer build owns it). */
+    readonly blockedByNewer: boolean;
+}
+/**
+ * Append one firing. Returns false on any failure — a hook must never throw, and a missed firing self-heals: the NEXT firing's `eof`
+ * covers the same bytes.
+ *
+ * ⛔ ONE `O_APPEND` WRITE. Two hooks (Cursor double-fires) interleave whole lines, never halves, so no lock is needed. A line over
+ * `MAX_FIRING_BYTES` is refused rather than split.
+ */
+export declare function appendFiring(home: string, sessionId: string, firing: Firing): boolean;
+/**
+ * What the hook calls: `appendFiring`, and if the line is refused while it carries a `sub` map, once more WITHOUT it (uncapped, the behaviour before
+ * the cap existed). The map is the one part of a line that grows with the session; the cap must never cost a firing. Never throws.
+ */
+export declare function recordFiring(home: string, sessionId: string, firing: Firing): boolean;
+/**
+ * The firings from `from` (a cursor offset) on. Never throws: an unreadable log reads as empty.
+ *
+ * A malformed COMPLETE line is skipped and counted in `through`. A trailing line with no newline is a hook mid-append and is left alone.
+ * A line of a newer `v` stops the read and is not consumed (`blockedByNewer`).
+ */
+export declare function readFirings(home: string, sessionId: string, from?: number): FiringRead;
+/**
+ * Every session that has a firing log: the file stems, oldest-modified first (so a session that has waited longest is served first). A
+ * stem is `sanitise(sid)`; it names the log and cursor files and nothing else, because the id to SEND is `Firing.sid`. Never throws.
+ */
+export declare function firingSessions(home: string): string[];
+/** Forget a session's firing log and cursor (with its target record, on the existing 30-day schedule). Never throws. */
+export declare function forgetFirings(home: string, sessionId: string): void;
+export interface FiringCursor {
+    /** Byte offset of the first unconsumed firing. */
+    readonly offset: number;
+    /** Uncaught throws on the firing at `offset`. Reset whenever the cursor moves. */
+    readonly throws: number;
+}
+export declare const START_OF_LOG: FiringCursor;
+/**
+ * The cursor, or the start of the log when it is missing or unreadable. Starting over is SAFE: replaying a consumed firing is a no-op
+ * (`firing.eof <= sentOffset`, trap 1), just slower.
+ */
+export declare function readCursor(home: string, sessionId: string): FiringCursor;
+/**
+ * Persist the cursor atomically. ⛔ ONLY A HOLDER OF THE SESSION'S WRITER LOCK may call this, and only after a heartbeat that said the
+ * lock is still its own (§3.3: "every cursor write beats first"); a worker that lost its lock writes nothing. Returns false on failure.
+ */
+export declare function writeCursor(home: string, sessionId: string, cursor: FiringCursor): boolean;
+/** Move the cursor to `offset`; the throw count belongs to the firing it left, so it resets. */
+export declare const advanced: (cursor: FiringCursor, offset: number) => FiringCursor;
+/** The firing at the cursor made the worker throw once more. */
+export declare const threw: (cursor: FiringCursor) => FiringCursor;
+/** Skip the firing at the cursor: it has thrown `MAX_FIRING_THROWS` times. */
+export declare const shouldSkip: (cursor: FiringCursor) => boolean;
+/**
+ * Stamp "this session's hook ran at `atMs`" for one repo key. HOOK-ONLY: the worker runs `deliver` with `byHook: false` and never calls
+ * this. A JSON object (`{at}`) rather than a bare number so P2's T7 can add `transcript` without a format change; the reader ignores
+ * unknown fields. Atomic replace. Never throws; false on failure (the commit then falls to the cold rung or goes unrecorded, as today
+ * before a first hook).
+ */
+export declare function stampLive(home: string, key: SessionKey, atMs: number): boolean;
+/** The `.live` stamp at `path`, or null when absent, unreadable or not a positive number. Unknown fields are ignored. */
+export declare function readLiveFile(path: string): number | null;
+/**
+ * ⛔ THE ONE LIVENESS READER (§3.5). A session is live as of the LATER of its state file's `liveAt` (stamped by `deliver()` for a hook
+ * delivery) and its `.live` file (stamped by the hook itself, before the worker has delivered anything). All three readers go through
+ * this: `liveSessions` and `pendingModeFor` (`spool.ts`) and the two `status` classifiers (`state.ts`). Read straight from the files,
+ * never from the mtime: a `finalize` that rewrites a dead session's state must not make it live (VG review 2, D2).
+ */
+export declare function liveAtOf(stateLiveAt: number | null, livePath: string | null): number | null;
+/**
+ * Which repo keys a hook stamps `.live` for (§3.5).
+ *  - the turn-end repo, when allowed;
+ *  - for a dialect that ISOLATES its content records (Claude Code, Codex): also every ledger key in the session's target record;
+ *  - for one that does not (Cursor): the turn-end repo ONLY. Sticky targets stay in Cursor's record but are not delivered, and only
+ *    delivered targets stamp today. Stamping them would keep a repo Cursor has left live for 30 minutes past every turn, a human's commit
+ *    there would become `sole_live_session`, and the row is permanent.
+ */
+export declare function liveStampKeys(input: {
+    readonly isolates: boolean;
+    readonly turnEnd: string | null;
+    readonly recordLedgerKeys: readonly string[];
+}): string[];

package/dist/firing.js

@@ -0,0 +1,334 @@
+/**
+ * THE FIRING LOG AND THE HOOK'S LIVENESS STAMP — U3 of the detached uploader.
+ *
+ * A *firing* is one hook that ended a turn: today's hook body, deferred. The hook appends one line saying "this turn ended here, at this
+ * size, in this folder, with these repos" and returns; the upload worker (U5) replays the lines in order, each ALONE, with the values
+ * recorded at the moment the hook fired (plan §3.2-§3.4, D15). This module is the storage half and nothing in the hook calls it yet:
+ * it is inert until the hook is flipped (U6).
+ *
+ * ## What it owns
+ *  - `<sid>.firings.jsonl` — append-only, one `O_APPEND` write per line, no lock (hooks never wait).
+ *  - `<sid>.firings.cursor` — the worker's progress: a byte offset, and how many times the firing at that offset made the worker THROW.
+ *    Written atomically, and only by a holder of the session's writer lock.
+ *  - `<repo digest>/<sid>.live` — the hook-only liveness stamp, and the ONE function that reads liveness (`liveAtOf`).
+ *
+ * ## What a firing holds: paths and numbers only
+ * No credential, no transcript content. The worker re-confines `transcript` and `announced` with `admitsTranscript` before every read.
+ *
+ * ## ⛔ A LEAF MODULE. It imports `paths` and `atomic_write` and nothing else of this package's, because `spool.ts` and `state.ts` both
+ * read liveness through it and neither may import the other.
+ */
+import { appendFileSync, chmodSync, closeSync, fstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, rmSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import { writeFileAtomic } from "./atomic_write.js";
+import { sessionFileStem, sessionFiringsCursorPath, sessionFiringsPath, sessionLivePath, targetsDir } from "./paths.js";
+/** The line format this build writes and reads. A reader sees a NEWER `v` as a stop sign, never as garbage (§3.14). */
+export const FIRING_VERSION = 1;
+/** A line longer than this is not written: a firing is ~300 bytes, and one `O_APPEND` write of a small buffer is what keeps hooks lock-free. */
+export const MAX_FIRING_BYTES = 32 * 1024;
+/** After this many uncaught throws on one firing, the worker skips it. A firing only sets an EOF, so the next one still covers its bytes. */
+export const MAX_FIRING_THROWS = 3;
+/** More sub-agent files than this in one firing: the map is left out (uncapped) rather than growing the line past `MAX_FIRING_BYTES`. */
+export const MAX_FIRING_SUB_FILES = 200;
+// --- the log -------------------------------------------------------------------------------------------------------------------
+/**
+ * Append one firing. Returns false on any failure — a hook must never throw, and a missed firing self-heals: the NEXT firing's `eof`
+ * covers the same bytes.
+ *
+ * ⛔ ONE `O_APPEND` WRITE. Two hooks (Cursor double-fires) interleave whole lines, never halves, so no lock is needed. A line over
+ * `MAX_FIRING_BYTES` is refused rather than split.
+ */
+export function appendFiring(home, sessionId, firing) {
+    try {
+        const line = `${JSON.stringify(firing)}\n`;
+        if (Buffer.byteLength(line) > MAX_FIRING_BYTES)
+            return false;
+        const path = sessionFiringsPath(home, sessionId);
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        appendFileSync(path, line, { mode: 0o600 });
+        chmodSync(path, 0o600);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * What the hook calls: `appendFiring`, and if the line is refused while it carries a `sub` map, once more WITHOUT it (uncapped, the behaviour before
+ * the cap existed). The map is the one part of a line that grows with the session; the cap must never cost a firing. Never throws.
+ */
+export function recordFiring(home, sessionId, firing) {
+    if (appendFiring(home, sessionId, firing))
+        return true;
+    if (firing.sub === undefined)
+        return false;
+    const { sub: _dropped, ...withoutSub } = firing;
+    return appendFiring(home, sessionId, withoutSub);
+}
+/**
+ * The firings from `from` (a cursor offset) on. Never throws: an unreadable log reads as empty.
+ *
+ * A malformed COMPLETE line is skipped and counted in `through`. A trailing line with no newline is a hook mid-append and is left alone.
+ * A line of a newer `v` stops the read and is not consumed (`blockedByNewer`).
+ */
+export function readFirings(home, sessionId, from = 0) {
+    const empty = { firings: [], through: from, blockedByNewer: false };
+    let fd = null;
+    try {
+        fd = openSync(sessionFiringsPath(home, sessionId), "r");
+        const size = fstatSync(fd).size;
+        if (!Number.isSafeInteger(from) || from < 0 || from >= size)
+            return { ...empty, through: Math.min(Math.max(from, 0), size) };
+        const buf = Buffer.alloc(size - from);
+        let got = 0;
+        while (got < buf.length) {
+            const n = readSync(fd, buf, got, buf.length - got, from + got);
+            if (n <= 0)
+                break;
+            got += n;
+        }
+        const firings = [];
+        let through = from;
+        let start = 0;
+        for (let nl = buf.indexOf(0x0a, 0); nl !== -1 && nl < got; nl = buf.indexOf(0x0a, start)) {
+            const parsed = parseFiring(buf.subarray(start, nl).toString("utf8"), sessionFileStem(sessionId));
+            const lineStart = from + start;
+            const lineEnd = from + nl + 1;
+            if (parsed === "newer")
+                return { firings, through, blockedByNewer: true };
+            if (parsed !== null)
+                firings.push({ firing: parsed, start: lineStart, end: lineEnd });
+            through = lineEnd;
+            start = nl + 1;
+        }
+        return { firings, through, blockedByNewer: false };
+    }
+    catch {
+        return empty;
+    }
+    finally {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                /* nothing to do */
+            }
+        }
+    }
+}
+/** A valid firing, `"newer"` for a line of a version this build does not know, or null for anything else. */
+function parseFiring(text, stem) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const o = raw;
+    if (typeof o.v !== "number" || !Number.isInteger(o.v) || o.v < 1)
+        return null;
+    if (o.v > FIRING_VERSION)
+        return "newer";
+    const str = (x) => typeof x === "string" && x !== "";
+    if (typeof o.at !== "number" || !Number.isFinite(o.at) || o.at <= 0)
+        return null;
+    if (typeof o.eof !== "number" || !Number.isSafeInteger(o.eof) || o.eof < 0)
+        return null;
+    // `sid` must be THIS log's session: a line whose id sanitises to another file name could otherwise be replayed under another session's cursor,
+    // lock and ledger. It is deliberately NOT required to be header-safe HERE: `sid` goes on the wire as `x-session-id` and delivery refuses an id the
+    // wire cannot carry (`sessionIdSafe`, post.ts) as a LOUD write-off (`never`, a gap `status` counts). Dropping such a line at the parse would be a
+    // new, differently-silent no-op (the 182 ruling); the id never reaches a header, a file name or a lock path except through `sanitise`.
+    if (!str(o.sid) || o.sid.length > 512 || sessionFileStem(o.sid) !== stem)
+        return null;
+    if (!str(o.event) || !str(o.transcript) || !str(o.agent) || !str(o.id) || typeof o.cwd !== "string")
+        return null;
+    const prior = {};
+    if (o.prior !== undefined) {
+        if (o.prior === null || typeof o.prior !== "object" || Array.isArray(o.prior))
+            return null;
+        for (const [key, value] of Object.entries(o.prior)) {
+            if (value === null)
+                prior[key] = null;
+            else if (typeof value === "number" && Number.isFinite(value) && value > 0)
+                prior[key] = value;
+            else
+                return null;
+        }
+    }
+    let keys;
+    if (o.keys !== undefined) {
+        const k = o.keys;
+        if (k === null || typeof k !== "object" || !str(k.worktree) || !str(k.consent))
+            return null;
+        keys = { worktree: k.worktree, consent: k.consent };
+    }
+    if (o.slug !== undefined && !str(o.slug))
+        return null;
+    if (o.announced !== undefined && !str(o.announced))
+        return null;
+    // A `sub` map that is not exactly {key: non-negative integer} is IGNORED (the firing is uncapped, today's behaviour), never a reason to drop the firing.
+    let sub;
+    if (o.sub !== null && typeof o.sub === "object" && !Array.isArray(o.sub)) {
+        const entries = Object.entries(o.sub);
+        if (entries.length <= MAX_FIRING_SUB_FILES && entries.every(([, size]) => typeof size === "number" && Number.isSafeInteger(size) && size >= 0)) {
+            sub = Object.fromEntries(entries);
+        }
+    }
+    return {
+        v: o.v,
+        at: o.at,
+        sid: o.sid,
+        event: o.event,
+        eof: o.eof,
+        transcript: o.transcript,
+        cwd: o.cwd,
+        ...(keys === undefined ? {} : { keys }),
+        ...(o.slug === undefined ? {} : { slug: o.slug }),
+        agent: o.agent,
+        id: o.id,
+        prior,
+        ...(o.announced === undefined ? {} : { announced: o.announced }),
+        ...(sub === undefined ? {} : { sub }),
+    };
+}
+const LOG_SUFFIX = ".firings.jsonl";
+/**
+ * Every session that has a firing log: the file stems, oldest-modified first (so a session that has waited longest is served first). A
+ * stem is `sanitise(sid)`; it names the log and cursor files and nothing else, because the id to SEND is `Firing.sid`. Never throws.
+ */
+export function firingSessions(home) {
+    try {
+        const dir = targetsDir(home);
+        return readdirSync(dir)
+            .filter((name) => name.endsWith(LOG_SUFFIX) && name.length > LOG_SUFFIX.length)
+            .map((name) => ({ stem: name.slice(0, -LOG_SUFFIX.length), at: modifiedAt(`${dir}/${name}`) }))
+            .sort((a, b) => a.at - b.at || (a.stem < b.stem ? -1 : 1))
+            .map((entry) => entry.stem);
+    }
+    catch {
+        return [];
+    }
+}
+function modifiedAt(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Forget a session's firing log and cursor (with its target record, on the existing 30-day schedule). Never throws. */
+export function forgetFirings(home, sessionId) {
+    for (const path of [sessionFiringsPath(home, sessionId), sessionFiringsCursorPath(home, sessionId)]) {
+        try {
+            rmSync(path, { force: true });
+        }
+        catch {
+            /* an undeletable file is retried next schedule */
+        }
+    }
+}
+export const START_OF_LOG = { offset: 0, throws: 0 };
+/**
+ * The cursor, or the start of the log when it is missing or unreadable. Starting over is SAFE: replaying a consumed firing is a no-op
+ * (`firing.eof <= sentOffset`, trap 1), just slower.
+ */
+export function readCursor(home, sessionId) {
+    try {
+        const raw = JSON.parse(readFileSync(sessionFiringsCursorPath(home, sessionId), "utf8"));
+        const offset = raw.offset;
+        const throws = raw.throws;
+        if (typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 0)
+            return START_OF_LOG;
+        return { offset, throws: typeof throws === "number" && Number.isSafeInteger(throws) && throws > 0 ? throws : 0 };
+    }
+    catch {
+        return START_OF_LOG;
+    }
+}
+/**
+ * Persist the cursor atomically. ⛔ ONLY A HOLDER OF THE SESSION'S WRITER LOCK may call this, and only after a heartbeat that said the
+ * lock is still its own (§3.3: "every cursor write beats first"); a worker that lost its lock writes nothing. Returns false on failure.
+ */
+export function writeCursor(home, sessionId, cursor) {
+    try {
+        const path = sessionFiringsCursorPath(home, sessionId);
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        writeFileAtomic(path, `${JSON.stringify({ v: 1, offset: cursor.offset, throws: cursor.throws })}\n`, 0o600);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Move the cursor to `offset`; the throw count belongs to the firing it left, so it resets. */
+export const advanced = (cursor, offset) => ({ offset: Math.max(cursor.offset, offset), throws: 0 });
+/** The firing at the cursor made the worker throw once more. */
+export const threw = (cursor) => ({ offset: cursor.offset, throws: cursor.throws + 1 });
+/** Skip the firing at the cursor: it has thrown `MAX_FIRING_THROWS` times. */
+export const shouldSkip = (cursor) => cursor.throws >= MAX_FIRING_THROWS;
+// --- liveness ------------------------------------------------------------------------------------------------------------------
+/**
+ * Stamp "this session's hook ran at `atMs`" for one repo key. HOOK-ONLY: the worker runs `deliver` with `byHook: false` and never calls
+ * this. A JSON object (`{at}`) rather than a bare number so P2's T7 can add `transcript` without a format change; the reader ignores
+ * unknown fields. Atomic replace. Never throws; false on failure (the commit then falls to the cold rung or goes unrecorded, as today
+ * before a first hook).
+ */
+export function stampLive(home, key, atMs) {
+    const path = sessionLivePath(home, key);
+    if (path === null || !Number.isFinite(atMs) || atMs <= 0)
+        return false;
+    try {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        writeFileAtomic(path, `${JSON.stringify({ at: atMs })}\n`, 0o600);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The `.live` stamp at `path`, or null when absent, unreadable or not a positive number. Unknown fields are ignored. */
+export function readLiveFile(path) {
+    try {
+        const at = JSON.parse(readFileSync(path, "utf8")).at;
+        return typeof at === "number" && Number.isFinite(at) && at > 0 ? at : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * ⛔ THE ONE LIVENESS READER (§3.5). A session is live as of the LATER of its state file's `liveAt` (stamped by `deliver()` for a hook
+ * delivery) and its `.live` file (stamped by the hook itself, before the worker has delivered anything). All three readers go through
+ * this: `liveSessions` and `pendingModeFor` (`spool.ts`) and the two `status` classifiers (`state.ts`). Read straight from the files,
+ * never from the mtime: a `finalize` that rewrites a dead session's state must not make it live (VG review 2, D2).
+ */
+export function liveAtOf(stateLiveAt, livePath) {
+    const stamped = livePath === null ? null : readLiveFile(livePath);
+    if (stamped === null)
+        return stateLiveAt;
+    return stateLiveAt === null ? stamped : Math.max(stateLiveAt, stamped);
+}
+/**
+ * Which repo keys a hook stamps `.live` for (§3.5).
+ *  - the turn-end repo, when allowed;
+ *  - for a dialect that ISOLATES its content records (Claude Code, Codex): also every ledger key in the session's target record;
+ *  - for one that does not (Cursor): the turn-end repo ONLY. Sticky targets stay in Cursor's record but are not delivered, and only
+ *    delivered targets stamp today. Stamping them would keep a repo Cursor has left live for 30 minutes past every turn, a human's commit
+ *    there would become `sole_live_session`, and the row is permanent.
+ */
+export function liveStampKeys(input) {
+    const keys = new Set();
+    if (input.turnEnd !== null && input.turnEnd !== "")
+        keys.add(input.turnEnd);
+    if (input.isolates)
+        for (const key of input.recordLedgerKeys)
+            if (key !== "")
+                keys.add(key);
+    return [...keys];
+}
+//# sourceMappingURL=firing.js.map

package/dist/firing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firing.js","sourceRoot":"","sources":["../src/firing.ts"],"names":[],"mappings":"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"}