@wardby/cli 0.6.0 → 0.8.0

package/dist/coding/transcript/claude-code.js

@@ -0,0 +1,273 @@
+const KEPT_TYPES = new Set(["user", "assistant", "attachment", "system", "ai-title", "custom-title", "summary"]);
+/** System records kept: a compaction boundary decides which history a resume loads. */
+const KEPT_SYSTEM = new Set(["compact_boundary"]);
+/** Attachments that are part of the conversation the model saw and still applies on a laptop. */
+export const KEPT_ATTACHMENTS = new Set([
+    "agent_listing_delta",
+    "compact_file_reference",
+    "deferred_tools_delta",
+    "deferred_tools_record",
+    "dynamic_skill",
+    "edited_text_file",
+    "file",
+    "hook_additional_context",
+    "hook_success",
+    "instructions",
+    "invoked_skills",
+    "mcp_instructions_delta",
+    "nested_memory",
+    "queued_command",
+    "read_truncation_notice",
+    "skill_listing",
+    // A copy of the run's final StructuredOutput answer, tied to that call (not shown to the model).
+    "structured_output",
+    "task_reminder",
+    "task_status",
+]);
+/**
+ * Attachments dropped on purpose: the run's system prompt, account, organisation, pod and budget
+ * state. Listed so the compatibility test can tell a reviewed kind from a new one.
+ */
+export const DROPPED_ATTACHMENTS = new Set([
+    "auto_mode",
+    "budget_usd",
+    "command_permissions",
+    "credential_org",
+    "date",
+    "environment",
+    "model",
+    "prompt_snapshot",
+    "remote_session_change",
+    "session_context",
+    "session_cron_carry",
+    "silent_turn_reminder",
+    "thinking_drop",
+    "total_tokens_reminder",
+]);
+const THINKING = new Set(["thinking", "redacted_thinking"]);
+/** Fields removed from any kept record: the account's plan and rate-limit state. */
+const DROPPED_FIELDS = ["quotaLimits", "usageLimitNote"];
+/** `fallbackTitle` is used when the session has no title of its own. */
+export function sanitizeClaudeTranscript(jsonl, fallbackTitle) {
+    const kept = [];
+    const titles = [];
+    // A dropped record's uuid -> its parent, so kept children can be relinked past it.
+    const droppedParent = new Map();
+    // Every record's parent as written, for walking a compaction's preserved segment.
+    const rawParent = new Map();
+    let sessionId;
+    for (const line of jsonl.split("\n")) {
+        const record = parseRecord(line);
+        if (!record)
+            continue;
+        if (typeof record.uuid === "string")
+            rawParent.set(record.uuid, parentOf(record));
+        if (record.type === "ai-title" || record.type === "custom-title" || record.type === "summary") {
+            titles.push(record);
+            continue;
+        }
+        const copy = keptRecord(record);
+        if (!copy) {
+            if (typeof record.uuid === "string")
+                droppedParent.set(record.uuid, parentOf(record));
+            continue;
+        }
+        if (typeof record.sessionId === "string" && record.isSidechain !== true)
+            sessionId ??= record.sessionId;
+        kept.push(copy);
+    }
+    for (const record of kept)
+        record.parentUuid = resolveParent(parentOf(record), droppedParent);
+    const end = lastSettled(kept);
+    if (end < 0 || !sessionId)
+        return null;
+    let records = kept.slice(0, end + 1);
+    let present = new Set(records.map((record) => record.uuid));
+    for (const record of records) {
+        if (record.type === "system")
+            repointCompaction(record, present, rawParent, droppedParent);
+    }
+    records = fromLastCompaction(records);
+    present = new Set(records.map((record) => record.uuid));
+    for (const record of records) {
+        // A compaction boundary starts a new chain on purpose (its link back is logicalParentUuid).
+        if (record.parentUuid !== null && !present.has(record.parentUuid))
+            record.parentUuid = null;
+    }
+    for (const title of titles) {
+        if (title.type === "summary" && !present.has(title.leafUuid))
+            continue;
+        records.push(title.type === "summary" ? title : { ...title, sessionId });
+    }
+    if (!titles.some((title) => title.type !== "summary") && fallbackTitle) {
+        records.push({ type: "ai-title", aiTitle: fallbackTitle, sessionId });
+    }
+    return { sessionId, lines: records.map((record) => JSON.stringify(record)) };
+}
+/** The record as stored, or null when it is dropped. Only thinking and account fields are edited out. */
+function keptRecord(record) {
+    const copy = keptRecordWithFields(record);
+    if (copy)
+        for (const field of DROPPED_FIELDS)
+            delete copy[field];
+    return copy;
+}
+function keptRecordWithFields(record) {
+    const type = record.type;
+    if (typeof type !== "string" || !KEPT_TYPES.has(type))
+        return null;
+    if (type === "system")
+        return KEPT_SYSTEM.has(record.subtype) ? { ...record } : null;
+    if (type === "attachment") {
+        const kind = record.attachment?.type;
+        return typeof kind === "string" && KEPT_ATTACHMENTS.has(kind) ? { ...record } : null;
+    }
+    const message = withoutThinking(record.message);
+    return message ? { ...record, message } : null;
+}
+function parseRecord(line) {
+    if (!line.trim())
+        return null;
+    try {
+        const value = JSON.parse(line);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        // A torn last line (the writer was cut off mid-record).
+        return null;
+    }
+}
+function parentOf(record) {
+    return typeof record.parentUuid === "string" ? record.parentUuid : null;
+}
+function resolveParent(parent, dropped) {
+    const seen = new Set();
+    while (parent !== null && dropped.has(parent) && !seen.has(parent)) {
+        seen.add(parent);
+        parent = dropped.get(parent) ?? null;
+    }
+    return parent;
+}
+/**
+ * Only what a resume loads: the last compaction boundary, everything after it, and the messages it
+ * kept word for word. Resume never loads what that compaction summarised (Claude Code continues
+ * "with the last compaction's summary, the messages that compaction left unsummarized, and every
+ * message since"), so the earlier history is not stored. Without a compaction, everything is kept.
+ */
+function fromLastCompaction(records) {
+    let last = -1;
+    records.forEach((record, index) => {
+        if (record.type === "system" && record.subtype === "compact_boundary")
+            last = index;
+    });
+    if (last <= 0)
+        return records;
+    const metadata = (records[last].compactMetadata ?? {});
+    const keep = new Set();
+    const segment = metadata.preservedSegment;
+    if (segment && typeof segment === "object") {
+        const byId = new Map(records.map((record) => [record.uuid, record]));
+        let id = segment.tailUuid;
+        while (typeof id === "string" && byId.has(id) && !keep.has(id)) {
+            keep.add(id);
+            if (id === segment.headUuid)
+                break;
+            id = byId.get(id)?.parentUuid;
+        }
+    }
+    const messages = metadata.preservedMessages;
+    for (const list of [messages?.uuids, messages?.allUuids]) {
+        if (Array.isArray(list))
+            for (const id of list)
+                keep.add(id);
+    }
+    return records.filter((record, index) => index >= last || keep.has(record.uuid));
+}
+/**
+ * A compaction boundary names the messages it kept word for word (`preservedSegment`, from head to
+ * tail, and `preservedMessages`). Resume splices that segment back in after the summary, so ids of
+ * dropped records are moved to the nearest kept record inside the segment, or the segment is removed
+ * when nothing in it is kept.
+ */
+function repointCompaction(boundary, present, rawParent, droppedParent) {
+    if (typeof boundary.logicalParentUuid === "string") {
+        boundary.logicalParentUuid = resolveParent(boundary.logicalParentUuid, droppedParent);
+    }
+    const metadata = boundary.compactMetadata;
+    if (!metadata || typeof metadata !== "object")
+        return;
+    const copy = { ...metadata };
+    boundary.compactMetadata = copy;
+    const segment = copy.preservedSegment;
+    if (segment && typeof segment === "object") {
+        // Walk tail -> head along the links as written; the kept records on that path are the segment.
+        const path = [];
+        let id = typeof segment.tailUuid === "string" ? segment.tailUuid : null;
+        while (id !== null && !path.includes(id)) {
+            path.push(id);
+            if (id === segment.headUuid)
+                break;
+            id = rawParent.get(id) ?? null;
+        }
+        const kept = path.filter((uuid) => present.has(uuid));
+        if (path.at(-1) !== segment.headUuid || kept.length === 0) {
+            delete copy.preservedSegment;
+        }
+        else {
+            copy.preservedSegment = { ...segment, tailUuid: kept[0], headUuid: kept.at(-1) };
+        }
+    }
+    const messages = copy.preservedMessages;
+    if (messages && typeof messages === "object") {
+        const keep = (list) => (Array.isArray(list) ? list.filter((uuid) => present.has(uuid)) : list);
+        copy.preservedMessages = { ...messages, uuids: keep(messages.uuids), allUuids: keep(messages.allUuids) };
+    }
+}
+/** The message without thinking blocks, or null when nothing is left. */
+function withoutThinking(message) {
+    if (!message || typeof message !== "object")
+        return null;
+    const m = message;
+    if (typeof m.content === "string")
+        return m.content ? m : null;
+    if (!Array.isArray(m.content))
+        return null;
+    const content = m.content.filter((block) => !THINKING.has(block?.type));
+    if (content.length === 0)
+        return null;
+    return content.length === m.content.length ? m : { ...m, content };
+}
+/**
+ * The index the history can end at and be continued: the last main-chain record after which no tool
+ * call is waiting for its result. That is a reply that asks for no tool, or a tool result that answers
+ * the last open call (a run's final StructuredOutput call and its result end this way). A call left
+ * without a result (the run was cut off mid-command) is cut, with everything after the last such point.
+ * -1 when the history never settles.
+ */
+function lastSettled(records) {
+    let end = -1;
+    const waiting = new Set();
+    records.forEach((record, index) => {
+        if (record.isSidechain === true || (record.type !== "user" && record.type !== "assistant"))
+            return;
+        const content = record.message.content;
+        const blocks = Array.isArray(content) ? content : [];
+        if (record.type === "assistant") {
+            const calls = blocks.filter((block) => block?.type === "tool_use");
+            // A reply that asks for no tool settles everything before it.
+            if (calls.length === 0) {
+                waiting.clear();
+                end = index;
+            }
+            for (const call of calls)
+                waiting.add(call?.id);
+            return;
+        }
+        const results = blocks.filter((block) => block?.type === "tool_result");
+        for (const result of results)
+            waiting.delete(result?.tool_use_id);
+        if (results.length > 0 && waiting.size === 0)
+            end = index;
+    });
+    return end;
+}

package/dist/coding/transcript/download-protocol.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The run transcript download, as the server (mcp/tools/run-transcript-download.ts)
+ * serves it and `wardby resume` reads it. Import-free, so the CLI side loads
+ * nothing of the server.
+ *
+ * GET <origin>/run-transcripts/download?t=<signed token>
+ *   200: body = the stored gzip object; headers:
+ *     x-wardby-sha256           sha256 (hex) of the body
+ *     x-wardby-session-id       the Claude Code session id
+ *     x-wardby-transcript-meta  base64url JSON TranscriptDownloadMeta
+ *   otherwise: JSON { "error": <DownloadRefusal> }
+ */
+export declare const RUN_TRANSCRIPT_DOWNLOAD_PATH = "/run-transcripts/download";
+/** How long a download link works. */
+export declare const RUN_TRANSCRIPT_LINK_TTL_MS: number;
+export declare const TRANSCRIPT_SHA256_HEADER = "x-wardby-sha256";
+export declare const TRANSCRIPT_SESSION_HEADER = "x-wardby-session-id";
+export declare const TRANSCRIPT_META_HEADER = "x-wardby-transcript-meta";
+/** What the importer needs besides the bytes: where to check the run out. Ids and refs only, never content. */
+export interface TranscriptDownloadMeta {
+    runId: string;
+    sessionId: string;
+    provider: string;
+    repository: string;
+    headRef: string;
+    resultBranch: string | null;
+    baseSha: string | null;
+    sha256: string;
+}
+export type DownloadRefusal = "link_invalid" | "not_found" | "transcript_expired" | "transcript_unavailable" | "transcript_corrupt";

package/dist/coding/transcript/download-protocol.js

@@ -0,0 +1,18 @@
+/**
+ * The run transcript download, as the server (mcp/tools/run-transcript-download.ts)
+ * serves it and `wardby resume` reads it. Import-free, so the CLI side loads
+ * nothing of the server.
+ *
+ * GET <origin>/run-transcripts/download?t=<signed token>
+ *   200: body = the stored gzip object; headers:
+ *     x-wardby-sha256           sha256 (hex) of the body
+ *     x-wardby-session-id       the Claude Code session id
+ *     x-wardby-transcript-meta  base64url JSON TranscriptDownloadMeta
+ *   otherwise: JSON { "error": <DownloadRefusal> }
+ */
+export const RUN_TRANSCRIPT_DOWNLOAD_PATH = "/run-transcripts/download";
+/** How long a download link works. */
+export const RUN_TRANSCRIPT_LINK_TTL_MS = 10 * 60_000;
+export const TRANSCRIPT_SHA256_HEADER = "x-wardby-sha256";
+export const TRANSCRIPT_SESSION_HEADER = "x-wardby-session-id";
+export const TRANSCRIPT_META_HEADER = "x-wardby-transcript-meta";

package/dist/coding/transcript/format.d.ts

@@ -0,0 +1,20 @@
+export declare const TRANSCRIPT_FORMAT_VERSION = 1;
+/** The largest sanitised transcript file the worker writes (uncompressed). */
+export declare const MAX_TRANSCRIPT_BYTES: number;
+/** The default cap on a stored transcript before compression (RUN_TRANSCRIPT_MAX_BYTES). */
+export declare const DEFAULT_TRANSCRIPT_MAX_BYTES: number;
+export declare const MAX_RAW_TRANSCRIPT_BYTES: number;
+export type TranscriptProvider = "claude-code";
+export type TranscriptHeaderStatus = "ok" | "too_large" | "no_complete_turn";
+export interface TranscriptHeader {
+    type: "wardby-transcript";
+    version: 1;
+    provider: TranscriptProvider;
+    sessionId: string;
+    status: TranscriptHeaderStatus;
+}
+export declare function formatTranscriptFile(header: TranscriptHeader, lines: readonly string[]): string;
+export declare function parseTranscriptFile(text: string): {
+    header: TranscriptHeader;
+    body: string;
+} | null;

package/dist/coding/transcript/format.js

@@ -0,0 +1,32 @@
+export const TRANSCRIPT_FORMAT_VERSION = 1;
+/** The largest sanitised transcript file the worker writes (uncompressed). */
+export const MAX_TRANSCRIPT_BYTES = 64 * 1024 * 1024;
+/** The default cap on a stored transcript before compression (RUN_TRANSCRIPT_MAX_BYTES). */
+export const DEFAULT_TRANSCRIPT_MAX_BYTES = 10 * 1024 * 1024;
+export const MAX_RAW_TRANSCRIPT_BYTES = 64 * 1024 * 1024;
+export function formatTranscriptFile(header, lines) {
+    return [JSON.stringify(header), ...lines].join("\n") + "\n";
+}
+export function parseTranscriptFile(text) {
+    const newline = text.indexOf("\n");
+    const first = newline < 0 ? text : text.slice(0, newline);
+    let header;
+    try {
+        header = JSON.parse(first);
+    }
+    catch {
+        return null;
+    }
+    if (!isHeader(header))
+        return null;
+    return { header, body: newline < 0 ? "" : text.slice(newline + 1) };
+}
+function isHeader(value) {
+    const v = value;
+    return (!!v &&
+        v.type === "wardby-transcript" &&
+        v.version === TRANSCRIPT_FORMAT_VERSION &&
+        v.provider === "claude-code" &&
+        typeof v.sessionId === "string" &&
+        (v.status === "ok" || v.status === "too_large" || v.status === "no_complete_turn"));
+}

package/dist/coding/transcript/recorder.d.ts

@@ -0,0 +1,52 @@
+import type { PrismaClient } from "#prisma";
+import { type BlobStore } from "../../providers/storage/types.js";
+export type TranscriptStatus = "stored" | "too_large" | "not_captured" | "failed";
+/** What `record` reports to its caller: the row's status, or that the row itself was lost. */
+export type RecordResult = TranscriptStatus | "row_write_failed";
+/** The stored object: the transcript file, gzip-compressed. */
+export declare function transcriptBlobKey(runId: string): string;
+/** RUN_TRANSCRIPT_MAX_BYTES: the largest transcript stored, measured before compression. */
+export declare function loadTranscriptMaxBytes(env?: NodeJS.ProcessEnv): number;
+export declare function loadTranscriptRetentionDays(env?: NodeJS.ProcessEnv): number;
+export interface RunTranscriptRecorderDeps {
+    db: {
+        runTranscript: Pick<PrismaClient["runTranscript"], "upsert" | "findMany" | "deleteMany">;
+    };
+    blobs: BlobStore | undefined;
+    /**
+     * The agent's attached secret values; rejects when any can't be loaded. The run capability (rrp_), the
+     * registry token derived from it (rrg_) and the run's MCP token (rmt_) are not listed: they have fixed
+     * token shapes that redactSecrets (redact.ts) removes whatever their value, and the vault no longer holds
+     * the capability or the MCP token by now.
+     */
+    secretValues: (agentId: string) => Promise<string[]>;
+    retentionDays: number;
+    /** The largest transcript stored, before compression (loadTranscriptMaxBytes). */
+    maxBytes: number;
+    now?: () => Date;
+}
+export interface RecordTranscriptInput {
+    runId: string;
+    agentId: string;
+    provider: string;
+    read: (maxBytes: number) => Promise<string | undefined>;
+}
+/**
+ * Stores a coding run's session transcript for local resume. The worker's file is not trusted: it is
+ * sanitised again here, then every string in each record (values and object keys) is redacted by exact
+ * value against the agent's attached secret values (and their JSON-escaped forms); the run capability
+ * (rrp_), the registry token (rrg_) and the MCP token (rmt_) are removed by their fixed token shape. Only that copy is stored.
+ * Rows carry fixed codes, never content. Never throws.
+ */
+export declare class RunTranscriptRecorder {
+    private readonly deps;
+    constructor(deps: RunTranscriptRecorderDeps);
+    /**
+     * Returns the stored status, or `row_write_failed` when the row could not be written (the caller logs
+     * that code with the run id; the error itself is never surfaced, as it may quote content).
+     */
+    record(input: RecordTranscriptInput): Promise<RecordResult>;
+    private capture;
+    private writeRow;
+    pruneExpired(limit?: number): Promise<number>;
+}

package/dist/coding/transcript/recorder.js

@@ -0,0 +1,225 @@
+import { createHash } from "node:crypto";
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+import { BlobStoreError } from "../../providers/storage/types.js";
+import { withEscapedForms } from "../../core/secret-spans.js";
+import { REDACTED, redactSecrets } from "../redact.js";
+import { sanitizeClaudeTranscript } from "./claude-code.js";
+import { DEFAULT_TRANSCRIPT_MAX_BYTES, formatTranscriptFile, MAX_TRANSCRIPT_BYTES, parseTranscriptFile, } from "./format.js";
+const gzipAsync = promisify(gzip);
+const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** The stored object: the transcript file, gzip-compressed. */
+export function transcriptBlobKey(runId) {
+    return `run-transcripts/${runId}.jsonl.gz`;
+}
+const MIN_TRANSCRIPT_MAX_BYTES = 1024 * 1024;
+/** RUN_TRANSCRIPT_MAX_BYTES: the largest transcript stored, measured before compression. */
+export function loadTranscriptMaxBytes(env = process.env) {
+    const raw = env.RUN_TRANSCRIPT_MAX_BYTES?.trim();
+    if (!raw)
+        return DEFAULT_TRANSCRIPT_MAX_BYTES;
+    const bytes = Number(raw);
+    if (!Number.isInteger(bytes) || bytes < MIN_TRANSCRIPT_MAX_BYTES || bytes > MAX_TRANSCRIPT_BYTES) {
+        throw new Error(`RUN_TRANSCRIPT_MAX_BYTES must be a whole number of bytes from ${MIN_TRANSCRIPT_MAX_BYTES} to ${MAX_TRANSCRIPT_BYTES}.`);
+    }
+    return bytes;
+}
+export function loadTranscriptRetentionDays(env = process.env) {
+    const raw = env.RUN_TRANSCRIPT_RETENTION_DAYS?.trim();
+    if (!raw)
+        return 30;
+    const days = Number(raw);
+    if (!Number.isInteger(days) || days < 1 || days > 3650) {
+        throw new Error("RUN_TRANSCRIPT_RETENTION_DAYS must be a whole number of days from 1 to 3650.");
+    }
+    return days;
+}
+/**
+ * Stores a coding run's session transcript for local resume. The worker's file is not trusted: it is
+ * sanitised again here, then every string in each record (values and object keys) is redacted by exact
+ * value against the agent's attached secret values (and their JSON-escaped forms); the run capability
+ * (rrp_), the registry token (rrg_) and the MCP token (rmt_) are removed by their fixed token shape. Only that copy is stored.
+ * Rows carry fixed codes, never content. Never throws.
+ */
+export class RunTranscriptRecorder {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Returns the stored status, or `row_write_failed` when the row could not be written (the caller logs
+     * that code with the run id; the error itself is never surfaced, as it may quote content).
+     */
+    async record(input) {
+        const outcome = await this.capture(input).catch(() => ({ status: "failed", reason: "unexpected" }));
+        const rowWritten = await this.writeRow(input, outcome).then(() => true, () => false);
+        if (outcome.status === "stored")
+            await this.pruneExpired().catch(() => 0);
+        return rowWritten ? outcome.status : "row_write_failed";
+    }
+    async capture(input) {
+        const { blobs } = this.deps;
+        if (!blobs)
+            return { status: "not_captured", reason: "no_blob_store" };
+        if (input.provider !== "claude-code")
+            return { status: "not_captured", reason: "provider_unsupported" };
+        let text;
+        try {
+            text = await input.read(this.deps.maxBytes);
+        }
+        catch (error) {
+            const tooLarge = error instanceof Error && error.message === "transcript_too_large";
+            return tooLarge ? { status: "too_large" } : { status: "not_captured", reason: "unreadable" };
+        }
+        if (text === undefined)
+            return { status: "not_captured", reason: "missing" };
+        const file = parseTranscriptFile(text);
+        if (!file)
+            return { status: "failed", reason: "invalid_file" };
+        if (!SESSION_ID.test(file.header.sessionId))
+            return { status: "failed", reason: "invalid_file" };
+        if (file.header.status === "too_large")
+            return { status: "too_large", sessionId: file.header.sessionId };
+        if (file.header.status === "no_complete_turn") {
+            return { status: "not_captured", reason: "no_complete_turn", sessionId: file.header.sessionId };
+        }
+        const sanitized = sanitizeClaudeTranscript(file.body);
+        if (!sanitized)
+            return { status: "not_captured", reason: "no_complete_turn", sessionId: file.header.sessionId };
+        if (!SESSION_ID.test(sanitized.sessionId))
+            return { status: "failed", reason: "invalid_file" };
+        let secrets;
+        try {
+            secrets = await this.deps.secretValues(input.agentId);
+        }
+        catch {
+            return { status: "failed", reason: "secrets_unavailable" };
+        }
+        const escaped = withEscapedForms(secrets);
+        let lines;
+        try {
+            lines = sanitized.lines.map((line) => redactJsonLine(line, escaped));
+        }
+        catch {
+            return { status: "failed", reason: "redaction_broke_record" };
+        }
+        // Guard: every stored line must still be one JSON record.
+        for (const line of lines) {
+            try {
+                JSON.parse(line);
+            }
+            catch {
+                return { status: "failed", reason: "redaction_broke_record" };
+            }
+        }
+        const body = Buffer.from(formatTranscriptFile({
+            type: "wardby-transcript",
+            version: 1,
+            provider: "claude-code",
+            sessionId: sanitized.sessionId,
+            status: "ok",
+        }, lines));
+        if (body.byteLength > this.deps.maxBytes)
+            return { status: "too_large", sessionId: sanitized.sessionId };
+        // Async, so compressing a large transcript does not block the server's event loop.
+        const stored = await gzipAsync(body);
+        const blobKey = transcriptBlobKey(input.runId);
+        try {
+            await blobs.put(blobKey, stored, { contentType: "application/gzip" });
+        }
+        catch {
+            return { status: "failed", reason: "store_failed", sessionId: sanitized.sessionId };
+        }
+        // Size and hash are of the stored (compressed) bytes, for the importer to verify its download.
+        return {
+            status: "stored",
+            sessionId: sanitized.sessionId,
+            blobKey,
+            sizeBytes: stored.byteLength,
+            sha256: createHash("sha256").update(stored).digest("hex"),
+        };
+    }
+    async writeRow(input, outcome) {
+        const now = (this.deps.now ?? (() => new Date()))();
+        const data = {
+            provider: input.provider,
+            status: outcome.status,
+            reason: outcome.reason ?? null,
+            sessionId: outcome.sessionId ?? null,
+            blobKey: outcome.blobKey ?? null,
+            sizeBytes: outcome.sizeBytes ?? null,
+            sha256: outcome.sha256 ?? null,
+            expiresAt: new Date(now.getTime() + this.deps.retentionDays * DAY_MS),
+        };
+        await this.deps.db.runTranscript.upsert({
+            where: { runId: input.runId },
+            create: { runId: input.runId, ...data },
+            update: data,
+        });
+    }
+    async pruneExpired(limit = 20) {
+        const now = (this.deps.now ?? (() => new Date()))();
+        const expired = await this.deps.db.runTranscript.findMany({
+            where: { expiresAt: { lt: now } },
+            select: { runId: true, blobKey: true },
+            orderBy: { expiresAt: "asc" },
+            take: limit,
+        });
+        const deletable = [];
+        for (const row of expired) {
+            try {
+                if (row.blobKey && this.deps.blobs)
+                    await this.deps.blobs.delete(row.blobKey);
+                deletable.push(row.runId);
+            }
+            catch (error) {
+                if (error instanceof BlobStoreError && error.code === "not_found")
+                    deletable.push(row.runId);
+            }
+        }
+        if (deletable.length === 0)
+            return 0;
+        const { count } = await this.deps.db.runTranscript.deleteMany({ where: { runId: { in: deletable } } });
+        return count;
+    }
+}
+/**
+ * Redacts every string leaf of one JSON record, then re-serialises it. Redacting the serialised line
+ * instead lets token patterns consume JSON escapes (the Bearer pattern eats the backslash of `\"`).
+ */
+function redactJsonLine(line, secrets) {
+    return JSON.stringify(redactJsonValue(parseNumbersAsSource(line, secrets), secrets));
+}
+const NUMERIC = /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/;
+/**
+ * Parses one record, replacing any number that holds a secret (a digits-only value written as a
+ * JSON number) with the marker. Checks the source text and the numeric value: the sanitiser has
+ * already re-serialised the record, so a number too long for a double arrives rounded.
+ */
+function parseNumbersAsSource(line, secrets) {
+    const numericSecrets = secrets.filter((secret) => NUMERIC.test(secret)).map(Number);
+    const reviver = (_key, value, context) => {
+        if (typeof value !== "number")
+            return value;
+        const source = context.source ?? String(value);
+        if (redactSecrets(source, secrets) !== source || numericSecrets.includes(value))
+            return REDACTED;
+        return value;
+    };
+    return JSON.parse(line, reviver);
+}
+function redactJsonValue(value, secrets) {
+    if (typeof value === "string")
+        return redactSecrets(value, secrets);
+    if (Array.isArray(value))
+        return value.map((item) => redactJsonValue(item, secrets));
+    if (value !== null && typeof value === "object") {
+        // A null-prototype object keeps a "__proto__" key as data.
+        const out = Object.create(null);
+        for (const [key, item] of Object.entries(value))
+            out[redactSecrets(key, secrets)] = redactJsonValue(item, secrets);
+        return out;
+    }
+    return value;
+}