@zanii/blackbox 0.0.0-stage → 0.2.0

package/dist/ratings/index.js

@@ -0,0 +1,48 @@
+// Type ratings (spec/type-ratings.md): airworthiness per label and model, and flying unrated.
+// Pure; mirrors sdks/python/src/zanii_blackbox/ratings.py; pinned by spec/vectors/type-ratings.json.
+import { sessionCost } from "../cost/index.js";
+import { airworthiness, DEFAULT_AIRWORTHINESS, } from "../fleet/index.js";
+/** spec/type-ratings.md §1. `items` newest first. */
+export function typeRatings(items, criteria = DEFAULT_AIRWORTHINESS) {
+    const pairs = new Map();
+    for (const i of items)
+        if (i.summary.closed)
+            for (const model of new Set(i.models)) {
+                const label = i.summary.label ?? "(no label)";
+                pairs.set(JSON.stringify([label, model]), { label, model });
+            }
+    const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+    return [...pairs.values()]
+        .sort((a, b) => cmp(a.label, b.label) || cmp(a.model, b.model))
+        .map(({ label, model }) => ({
+        ...airworthiness(label, items.filter((i) => i.models.includes(model)).map((i) => i.summary), criteria),
+        model,
+    }));
+}
+/** spec/type-ratings.md §2. `severity` is "warning" when the server requires type ratings. */
+export function typeUnrated(lines, prices, ratings, severity = "advisory") {
+    const open = lines[0]
+        ? JSON.parse(lines[0])
+        : null;
+    if (open?.kind !== "session.open")
+        return [];
+    const label = typeof open.meta.label === "string" ? open.meta.label : "(no label)";
+    const mine = ratings.filter((r) => r.label === label);
+    if (!mine.some((r) => r.verdict === "airworthy"))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const c of sessionCost(lines, prices).calls) {
+        if (!c.model || seen.has(c.model))
+            continue;
+        seen.add(c.model);
+        if (!mine.some((r) => r.model === c.model && r.verdict === "airworthy"))
+            out.push({
+                code: "TYPE_UNRATED",
+                source: "type_rating",
+                severity,
+                ref: { seq: c.seq, model: c.model },
+            });
+    }
+    return out;
+}

package/dist/reconcile/claude-code.d.ts

@@ -0,0 +1,19 @@
+import type { Call, Receipt } from "./record.ts";
+import { type Finding, type LocalLog } from "./shared.ts";
+export declare const CLAUDE_CODE_TYPES: ReadonlySet<string>;
+export interface Outcome {
+    findings: Finding[];
+    expected: Call[];
+    matched: {
+        calls: number;
+        tool_results: number;
+    };
+    notes: string[];
+    agentSessions: string[];
+    /** When receipts are required (§7). */
+    workspace?: {
+        receipts: number;
+        changed_by: string[];
+    };
+}
+export declare function reconcileClaudeCode(calls: Call[], log: LocalLog, agentSessions: string[], allReceipts?: Receipt[], requireReceipts?: boolean): Outcome;

package/dist/reconcile/claude-code.js

@@ -0,0 +1,220 @@
+// Claude Code transcripts vs the record (spec/reconcile.md §3). Mirrors reconcile/claude_code.py.
+import { canonical, isObj, normText } from "./shared.js";
+const KNOWN = new Set([
+    "user",
+    "assistant",
+    "system",
+    "attachment",
+    "summary",
+    "queue-operation",
+    "last-prompt",
+    "mode",
+    "permission-mode",
+    "ai-title",
+    "custom-title",
+    "atis-latch",
+    "cost-state",
+    "file-history-snapshot",
+    "file-history-delta",
+]);
+export const CLAUDE_CODE_TYPES = KNOWN;
+export function reconcileClaudeCode(calls, log, agentSessions, allReceipts = [], requireReceipts = false) {
+    const sessions = agentSessions.length > 0 ? agentSessions : localSessions(log);
+    const findings = [];
+    const notes = [];
+    const matched = { calls: 0, tool_results: 0 };
+    // The local side: assistant blocks by message id, tool results by tool_use_id.
+    const messages = new Map();
+    const toolResults = new Map();
+    for (const r of log.records) {
+        const message = isObj(r.json.message) ? r.json.message : null;
+        const content = message && Array.isArray(message.content) ? message.content.filter(isObj) : [];
+        if (r.json.type === "assistant" && message && typeof message.id === "string") {
+            if (message.model === "<synthetic>")
+                continue;
+            let m = messages.get(message.id);
+            if (!m) {
+                m = { blocks: new Map(), file: r.file, line: r.line };
+                messages.set(message.id, m);
+            }
+            let index = typeof r.json.apiBlockIndex === "number" ? r.json.apiBlockIndex : m.blocks.size;
+            for (const block of content)
+                m.blocks.set(index++, block);
+        }
+        else if (r.json.type === "user") {
+            for (const block of content)
+                if (block.type === "tool_result" &&
+                    typeof block.tool_use_id === "string" &&
+                    !toolResults.has(block.tool_use_id))
+                    toolResults.set(block.tool_use_id, block);
+        }
+    }
+    const expected = calls.filter((c) => {
+        if (!c.complete || c.status !== 200 || !c.request)
+            return false;
+        const tools = c.request.tools;
+        if (!Array.isArray(tools) || tools.length === 0)
+            return false;
+        return sessions.length === 0 || sessions.includes(c.headers["x-claude-code-session-id"] ?? "");
+    });
+    let redacted = 0;
+    // Steps 1–2: every expected response is in the transcript, block for block.
+    for (const call of [...expected].sort((a, b) => a.endSeq - b.endSeq)) {
+        if (call.redacted)
+            redacted++;
+        const id = call.messageId;
+        if (!id) {
+            notes.push(`call at seq ${call.requestSeq} has no message id`);
+            continue;
+        }
+        const local = messages.get(id);
+        if (!local) {
+            findings.push({ code: "MISSING_LOCAL", ref: { message_id: id }, gateway_seq: call.endSeq });
+            continue;
+        }
+        let clean = true;
+        for (const [i, block] of [...call.blocks].sort(([a], [b]) => a - b)) {
+            if (block.type !== "text" && block.type !== "thinking" && block.type !== "tool_use")
+                continue;
+            const mine = local.blocks.get(i);
+            if (!mine) {
+                if (block.type !== "thinking") {
+                    findings.push({
+                        code: "MISSING_LOCAL",
+                        ref: { message_id: id, block: i },
+                        gateway_seq: call.endSeq,
+                    });
+                    clean = false;
+                }
+                continue;
+            }
+            if (mine.type !== block.type || (!call.redacted && !sameBlock(block, mine))) {
+                findings.push({
+                    code: "ALTERED",
+                    ref: { message_id: id, block: i },
+                    gateway_seq: call.endSeq,
+                });
+                clean = false;
+            }
+        }
+        if (clean)
+            matched.calls++;
+    }
+    // Steps 3–4: every tool result the model was given, from the first request that carried it.
+    const given = new Map();
+    for (const call of [...expected].sort((a, b) => a.requestSeq - b.requestSeq)) {
+        const msgs = Array.isArray(call.request?.messages) ? call.request.messages.filter(isObj) : [];
+        for (const m of msgs) {
+            if (!Array.isArray(m.content))
+                continue;
+            for (const block of m.content.filter(isObj))
+                if (block.type === "tool_result" &&
+                    typeof block.tool_use_id === "string" &&
+                    !given.has(block.tool_use_id))
+                    given.set(block.tool_use_id, { block, call });
+        }
+    }
+    for (const [toolUseId, { block, call }] of given) {
+        const mine = toolResults.get(toolUseId);
+        if (!mine) {
+            findings.push({
+                code: "MISSING_LOCAL",
+                ref: { tool_use_id: toolUseId },
+                gateway_seq: call.requestSeq,
+            });
+            continue;
+        }
+        if (call.requestRedacted) {
+            matched.tool_results++;
+            continue;
+        }
+        const recorded = normText(block.content);
+        const same = (recorded === normText(mine.content) || log.offloaded.has(recorded)) &&
+            Boolean(block.is_error) === Boolean(mine.is_error);
+        if (same)
+            matched.tool_results++;
+        else
+            findings.push({
+                code: "ALTERED",
+                ref: { tool_use_id: toolUseId },
+                gateway_seq: call.requestSeq,
+            });
+    }
+    // Step 5: model output the record never saw.
+    const seen = new Set(calls.map((c) => c.messageId).filter((m) => m !== null));
+    for (const [id, m] of messages)
+        if (!seen.has(id))
+            findings.push({
+                code: "EXTRA_LOCAL",
+                ref: { message_id: id },
+                local: { file: m.file, line: m.line },
+            });
+    if (redacted > 0)
+        notes.push(`redacted: ${redacted} call(s) not compared for content`);
+    // Steps 6–7: workspace receipts (§7).
+    const receipts = allReceipts.filter((r) => sessions.length === 0 || (r.agentSession !== null && sessions.includes(r.agentSession)));
+    if (!requireReceipts && receipts.length === 0)
+        return { findings, expected, matched, notes, agentSessions: sessions };
+    const has = (id, phase) => receipts.some((r) => r.toolUseId === id && r.phase === phase);
+    for (const call of [...expected].sort((a, b) => a.endSeq - b.endSeq))
+        for (const [, block] of [...call.blocks].sort(([a], [b]) => a - b)) {
+            if (block.type !== "tool_use" || typeof block.id !== "string")
+                continue;
+            if (!has(block.id, "pre"))
+                findings.push({
+                    code: "RECEIPT_MISSING",
+                    ref: { tool_use_id: block.id, phase: "pre" },
+                    gateway_seq: call.endSeq,
+                });
+            const result = given.get(block.id);
+            if (result && !result.block.is_error && !has(block.id, "post"))
+                findings.push({
+                    code: "RECEIPT_MISSING",
+                    ref: { tool_use_id: block.id, phase: "post" },
+                    gateway_seq: call.endSeq,
+                });
+        }
+    const withTree = receipts.filter((r) => r.tree !== null);
+    withTree.forEach((b, i) => {
+        const a = withTree[i - 1];
+        if (a && a.phase === "post" && b.phase === "pre" && a.tree !== b.tree)
+            findings.push({
+                code: "UNATTRIBUTED_CHANGE",
+                ref: { after: a.toolUseId, before: b.toolUseId },
+                gateway_seq: b.seq,
+            });
+    });
+    const changedBy = [];
+    for (const post of withTree.filter((r) => r.phase === "post")) {
+        const pre = withTree.find((r) => r.phase === "pre" && r.toolUseId === post.toolUseId);
+        if (pre && pre.tree !== post.tree && !changedBy.includes(post.toolUseId))
+            changedBy.push(post.toolUseId);
+    }
+    return {
+        findings,
+        expected,
+        matched,
+        notes,
+        agentSessions: sessions,
+        workspace: { receipts: receipts.length, changed_by: changedBy },
+    };
+}
+function sameBlock(recorded, local) {
+    if (recorded.type === "text")
+        return (recorded.text ?? "") === local.text;
+    if (recorded.type === "thinking") {
+        const a = recorded.thinking ?? "";
+        const b = typeof local.thinking === "string" ? local.thinking : "";
+        return a === "" || b === "" || a === b;
+    }
+    return (recorded.id === local.id &&
+        recorded.name === local.name &&
+        canonical(recorded.input ?? {}) === canonical(local.input ?? {}));
+}
+function localSessions(log) {
+    const ids = new Set();
+    for (const r of log.records)
+        if (typeof r.json.sessionId === "string")
+            ids.add(r.json.sessionId);
+    return [...ids].sort();
+}

package/dist/reconcile/codex.d.ts

@@ -0,0 +1,5 @@
+import type { Outcome } from "./claude-code.ts";
+import type { Call } from "./record.ts";
+import { type LocalLog } from "./shared.ts";
+export declare const CODEX_TYPES: ReadonlySet<string>;
+export declare function reconcileCodex(calls: Call[], log: LocalLog, agentSessions: string[]): Outcome;

package/dist/reconcile/codex.js

@@ -0,0 +1,191 @@
+// Codex rollouts vs the record (spec/reconcile.md §3). Mirrors reconcile/codex.py.
+import { canonical, isObj } from "./shared.js";
+export const CODEX_TYPES = new Set([
+    "session_meta",
+    "turn_context",
+    "response_item",
+    "event_msg",
+    "token_usage_record",
+    "world_state",
+    "compacted",
+]);
+const OUTPUT_TYPES = new Set(["message", "function_call", "custom_tool_call"]);
+const TOOL_OUTPUT_TYPES = new Set(["function_call_output", "custom_tool_call_output"]);
+export function reconcileCodex(calls, log, agentSessions) {
+    const findings = [];
+    const notes = [];
+    const matched = { calls: 0, tool_results: 0 };
+    const payload = (r) => (isObj(r.json.payload) ? r.json.payload : {});
+    // Step 1: ordinals count 0, 1, 2 … in each file.
+    const last = new Map();
+    for (const r of log.records) {
+        if (typeof r.json.ordinal !== "number")
+            continue;
+        const prev = last.get(r.file) ?? -1;
+        if (r.json.ordinal !== prev + 1)
+            findings.push({
+                code: "LOCAL_GAP",
+                ref: { after: prev, next: r.json.ordinal },
+                local: { file: r.file, line: r.line },
+            });
+        last.set(r.file, r.json.ordinal);
+    }
+    const sessions = agentSessions.length > 0
+        ? agentSessions
+        : [
+            ...new Set(log.records
+                .filter((r) => r.json.type === "session_meta")
+                .map((r) => String(payload(r).id ?? ""))),
+        ]
+            .filter(Boolean)
+            .sort();
+    const responses = new Set();
+    const items = new Map();
+    const byCallId = new Map();
+    const outputs = new Map();
+    for (const r of log.records) {
+        const p = payload(r);
+        if (r.json.type === "token_usage_record" && typeof p.response_id === "string")
+            responses.add(p.response_id);
+        if (r.json.type !== "response_item")
+            continue;
+        const type = String(p.type ?? "");
+        if (typeof p.id === "string" && !items.has(p.id))
+            items.set(p.id, p);
+        if (OUTPUT_TYPES.has(type) && typeof p.call_id === "string" && !byCallId.has(p.call_id))
+            byCallId.set(p.call_id, p);
+        if (TOOL_OUTPUT_TYPES.has(type) &&
+            typeof p.call_id === "string" &&
+            !outputs.has(`${type}:${p.call_id}`))
+            outputs.set(`${type}:${p.call_id}`, p);
+    }
+    const expected = calls.filter((c) => {
+        if (!c.complete ||
+            c.status !== 200 ||
+            !c.request ||
+            !c.path.split("?")[0]?.endsWith("/responses"))
+            return false;
+        const metadata = isObj(c.request.client_metadata) ? c.request.client_metadata : {};
+        if (metadata.request_kind !== undefined && metadata.request_kind !== "turn")
+            return false;
+        const session = c.request.prompt_cache_key ?? metadata.session_id;
+        return sessions.length === 0 || sessions.includes(String(session ?? ""));
+    });
+    let redacted = 0;
+    // Steps 2–3: every expected response and its output items are in the rollout.
+    for (const call of [...expected].sort((a, b) => a.endSeq - b.endSeq)) {
+        if (call.redacted)
+            redacted++;
+        let clean = true;
+        const id = call.responseId;
+        if (!id)
+            notes.push(`call at seq ${call.requestSeq} has no response id`);
+        else if (!responses.has(id)) {
+            findings.push({ code: "MISSING_LOCAL", ref: { response_id: id }, gateway_seq: call.endSeq });
+            clean = false;
+        }
+        for (const item of call.items) {
+            const type = String(item.type ?? "");
+            if (!OUTPUT_TYPES.has(type) || typeof item.id !== "string")
+                continue;
+            const mine = items.get(item.id) ??
+                (typeof item.call_id === "string" ? byCallId.get(item.call_id) : undefined);
+            if (!mine) {
+                findings.push({
+                    code: "MISSING_LOCAL",
+                    ref: { item_id: item.id },
+                    gateway_seq: call.endSeq,
+                });
+                clean = false;
+            }
+            else if (!call.redacted && itemContent(item) !== itemContent(mine)) {
+                findings.push({ code: "ALTERED", ref: { item_id: item.id }, gateway_seq: call.endSeq });
+                clean = false;
+            }
+        }
+        if (clean)
+            matched.calls++;
+    }
+    // Step 4: every tool output the model was given, from the first request that carried it.
+    const given = new Map();
+    for (const call of [...expected].sort((a, b) => a.requestSeq - b.requestSeq)) {
+        const input = Array.isArray(call.request?.input) ? call.request.input.filter(isObj) : [];
+        for (const item of input) {
+            const type = String(item.type ?? "");
+            if (TOOL_OUTPUT_TYPES.has(type) &&
+                typeof item.call_id === "string" &&
+                !given.has(`${type}:${item.call_id}`))
+                given.set(`${type}:${item.call_id}`, { item, call });
+        }
+    }
+    for (const [key, { item, call }] of given) {
+        const callId = String(item.call_id);
+        const mine = outputs.get(key);
+        if (!mine)
+            findings.push({
+                code: "MISSING_LOCAL",
+                ref: { call_id: callId },
+                gateway_seq: call.requestSeq,
+            });
+        else if (!call.requestRedacted && outputText(item.output) !== outputText(mine.output))
+            findings.push({ code: "ALTERED", ref: { call_id: callId }, gateway_seq: call.requestSeq });
+        else
+            matched.tool_results++;
+    }
+    // Step 5: model output the record never saw.
+    const seenResponses = new Set(calls.map((c) => c.responseId).filter((r) => r !== null));
+    const seenItems = new Set();
+    const seenCallIds = new Set();
+    for (const c of calls)
+        for (const item of c.items) {
+            if (typeof item.id === "string")
+                seenItems.add(item.id);
+            if (typeof item.call_id === "string")
+                seenCallIds.add(item.call_id);
+        }
+    const reported = new Set();
+    for (const r of log.records) {
+        const p = payload(r);
+        const local = { file: r.file, line: r.line };
+        if (r.json.type === "token_usage_record" && typeof p.response_id === "string") {
+            if (!seenResponses.has(p.response_id) && !reported.has(`r:${p.response_id}`)) {
+                reported.add(`r:${p.response_id}`);
+                findings.push({ code: "EXTRA_LOCAL", ref: { response_id: p.response_id }, local });
+            }
+            continue;
+        }
+        if (r.json.type !== "response_item")
+            continue;
+        const type = String(p.type ?? "");
+        const modelOutput = (type === "message" && p.role === "assistant") ||
+            type === "function_call" ||
+            type === "custom_tool_call";
+        if (!modelOutput)
+            continue;
+        const known = (typeof p.id === "string" && seenItems.has(p.id)) ||
+            (typeof p.call_id === "string" && seenCallIds.has(p.call_id));
+        const key = String(p.id ?? p.call_id ?? "");
+        if (!known && key && !reported.has(`i:${key}`)) {
+            reported.add(`i:${key}`);
+            findings.push({ code: "EXTRA_LOCAL", ref: { item_id: key }, local });
+        }
+    }
+    if (redacted > 0)
+        notes.push(`redacted: ${redacted} call(s) not compared for content`);
+    return { findings, expected, matched, notes, agentSessions: sessions };
+}
+function itemContent(item) {
+    if (item.type === "message") {
+        const content = Array.isArray(item.content) ? item.content.filter(isObj) : [];
+        return content
+            .filter((c) => c.type === "output_text")
+            .map((c) => (typeof c.text === "string" ? c.text : ""))
+            .join("");
+    }
+    if (item.type === "function_call")
+        return `${String(item.name)}\u0000${outputText(item.arguments)}`;
+    return `${String(item.name)}\u0000${outputText(item.input)}`;
+}
+function outputText(value) {
+    return typeof value === "string" ? value : canonical(value ?? null);
+}

package/dist/reconcile/index.d.ts

@@ -0,0 +1,19 @@
+import { type Bundle } from "../verify/index.ts";
+import { type Bodies } from "./record.ts";
+import { type Harness, type LocalLog, type Report } from "./shared.ts";
+export type { Finding, FindingCode, Harness, LocalLog, Report } from "./shared.ts";
+export { loadLocal } from "./shared.ts";
+export declare class RecordNotVerified extends Error {
+}
+export interface ReconcileOptions {
+    harness: Harness;
+    bundle: Bundle;
+    bodies: Bodies;
+    /** The local log: a path (read with loadLocal), or one already loaded. */
+    local: string | LocalLog;
+    agentSessions?: string[];
+    /** Every tool call must have its workspace receipts (§7), even if the record holds none. */
+    requireReceipts?: boolean;
+}
+/** Throws RecordNotVerified if the bundle doesn't verify: there'd be nothing to trust. */
+export declare function reconcile(options: ReconcileOptions): Promise<Report>;

package/dist/reconcile/index.js

@@ -0,0 +1,50 @@
+// Reconciliation (spec/reconcile.md): the agent's own log vs the verified record.
+// Mirrors sdks/python/src/zanii_blackbox/reconcile/.
+import { verifyBundle } from "../verify/index.js";
+import { CLAUDE_CODE_TYPES, reconcileClaudeCode } from "./claude-code.js";
+import { CODEX_TYPES, reconcileCodex } from "./codex.js";
+import { callsOf, receiptsOf } from "./record.js";
+import { loadLocal, unknownTypes } from "./shared.js";
+export { loadLocal } from "./shared.js";
+export class RecordNotVerified extends Error {
+}
+/** Throws RecordNotVerified if the bundle doesn't verify: there'd be nothing to trust. */
+export async function reconcile(options) {
+    // Audit K3: the bodies it reads are checked against the chain first.
+    const verified = await verifyBundle(options.bundle, {
+        body: (h) => options.bodies(h) ?? undefined,
+    });
+    if (!verified.ok) {
+        const why = verified.chain.ok ? (verified.identity.message ?? "identity") : verified.chain.code;
+        throw new RecordNotVerified(`the record does not verify (${why})`);
+    }
+    const log = typeof options.local === "string" ? loadLocal(options.local, options.harness) : options.local;
+    const calls = callsOf(options.bundle.lines, options.bodies);
+    const sessions = options.agentSessions ?? [];
+    const outcome = options.harness === "claude-code"
+        ? reconcileClaudeCode(calls, log, sessions, receiptsOf(options.bundle.lines), options.requireReceipts ?? false)
+        : reconcileCodex(calls, log, sessions);
+    const known = options.harness === "claude-code" ? CLAUDE_CODE_TYPES : CODEX_TYPES;
+    return {
+        v: 1,
+        harness: options.harness,
+        ok: outcome.findings.length === 0,
+        record: {
+            session_id: options.bundle.session.session_id,
+            events: options.bundle.lines.length,
+            calls: calls.length,
+            calls_expected: outcome.expected.length,
+            calls_not_expected: calls.length - outcome.expected.length,
+        },
+        local: {
+            files: log.files.length,
+            records: log.records.length,
+            agent_sessions: outcome.agentSessions,
+        },
+        matched: outcome.matched,
+        findings: outcome.findings,
+        ...(outcome.workspace ? { workspace: outcome.workspace } : {}),
+        notes: log.files.length === 0 ? ["no local log", ...outcome.notes] : outcome.notes,
+        warnings: [...log.warnings, ...unknownTypes(log.records, known)],
+    };
+}

package/dist/reconcile/record.d.ts

@@ -0,0 +1,49 @@
+export type Obj = Record<string, unknown>;
+export interface Block {
+    type: string;
+    text?: string;
+    thinking?: string;
+    id?: string;
+    name?: string;
+    input?: unknown;
+}
+export interface Call {
+    requestSeq: number;
+    /** seq of the llm.response / llm.incomplete; the request's when there is none. */
+    endSeq: number;
+    path: string;
+    headers: Record<string, string>;
+    request: Obj | null;
+    complete: boolean;
+    status: number | null;
+    redacted: boolean;
+    requestRedacted: boolean;
+    messageId: string | null;
+    responseId: string | null;
+    model: string | null;
+    /** The response's flattened usage (spec/api.md §3), when recorded. */
+    usage: Record<string, unknown> | null;
+    /** The configured provider id the request went to (spec/cost.md §1: provider-scoped prices). */
+    provider: string | null;
+    /** The provider's service tier, when the response names one (spec/cost.md §1). */
+    serviceTier: string | null;
+    /** A cost the provider itself reported (OpenRouter's `usage.cost`), in micro-USD. */
+    reportedMicroUsd: number | null;
+    /** Content blocks, by index: Anthropic's, or a Chat Completions message mapped onto them. */
+    blocks: Map<number, Block>;
+    /** OpenAI Responses output items, in order. */
+    items: Obj[];
+}
+export type Bodies = (hash: string) => Uint8Array | undefined;
+export declare function parseJson(text: string): unknown;
+/** The calls in a verified record, in request order. */
+export declare function callsOf(lines: readonly string[], bodies: Bodies): Call[];
+export interface Receipt {
+    seq: number;
+    phase: "pre" | "post";
+    toolUseId: string;
+    agentSession: string | null;
+    tree: string | null;
+}
+/** The workspace receipts in a record (spec/reconcile.md §7), in seq order. */
+export declare function receiptsOf(lines: readonly string[]): Receipt[];