@tangle-network/traces 0.11.4 → 0.11.6

package/dist/index.d.ts

@@ -420,6 +420,25 @@ interface SessionIntegrity {
     status: 'degraded_not_lossless';
     corruptions: SessionCorruptionReceipt[];
 }
+/**
+ * Execution-environment identity for a session — what replay verification
+ * needs to reconstruct where the session's commands actually ran. Populated
+ * by adapters/importers where known: sandbox sessions know their image
+ * (`runtime.ready` carries it); host-harness sessions usually do not.
+ * Absent fields mean "not recorded", never "none".
+ */
+interface SessionEnvironment {
+    /** Container image reference (repo:tag or repo@digest) the session executed in. */
+    image?: string;
+    /** Immutable image digest (`sha256:…`) — the replay-grade pin when known. */
+    imageDigest?: string;
+    /** Sandbox/container instance id that executed the session. */
+    sandboxId?: string;
+    /** Working directory commands executed from; null when unrecorded. */
+    cwd: string | null;
+    /** Commit hash the workspace was at when the session ran, when recorded. */
+    gitCommit?: string;
+}
 /** A single discovered session, before parsing. */
 interface SessionRef {
     /** Harness id (matches the nix profile / backend name). */
@@ -434,6 +453,8 @@ interface SessionRef {
     mtimeMs: number;
     /** Present when parsing recovered valid records around corrupt source records. */
     integrity?: SessionIntegrity;
+    /** Execution-environment identity, when the source records it (sandbox sessions). */
+    environment?: SessionEnvironment;
 }
 interface LocateOptions {
     /** Limit discovery to sessions whose cwd matches (exact or prefix). */
@@ -819,9 +840,44 @@ declare const ATTR: {
     readonly CORRUPTION_BYTE_LENGTH: "traces.session.corruption.byte_length";
     readonly CORRUPTION_SHA256: "traces.session.corruption.sha256";
     readonly RAW_SOURCE_RETENTION: "traces.session.raw_source_retention";
+    /** Container image reference the session executed in (OTel semconv key). */
+    readonly CONTAINER_IMAGE: "container.image.name";
+    /** Immutable image digest (`sha256:…`) — the replay-grade environment pin. */
+    readonly CONTAINER_IMAGE_DIGEST: "container.image.digest";
+    /** Sandbox/container instance id that executed the session. */
+    readonly SANDBOX_ID: "tangle.sandbox.id";
+    /** Recorded execution cwd, verbatim. Unlike `tangle.cwd` it is never
+     *  repaired against the host filesystem — replay verification needs the
+     *  in-container path even when no such path exists on this host. */
+    readonly ENVIRONMENT_CWD: "tangle.environment.cwd";
 };
 /** `tangle.ingest_source` value for CLI-uploaded traces. Wire contract. */
 declare const INGEST_SOURCE_CLI = "cli";
+/**
+ * Project a `SessionEnvironment` onto span-attribute keys. Only recorded
+ * fields are emitted — an absent image stays absent, so "environment not
+ * captured" and "environment captured without an image" remain different
+ * artifacts downstream.
+ */
+declare function environmentAttributes(environment: SessionEnvironment | undefined): Record<string, string>;
+/**
+ * Stamp environment identity onto every span so it survives into the OTLP
+ * resource block (see `toOpenInferenceSpan`). Additive — a value an adapter
+ * already set deliberately is never clobbered.
+ */
+declare function stampEnvironmentAttrs(spans: readonly {
+    attributes: Record<string, unknown>;
+}[], environment: SessionEnvironment | undefined): void;
+/**
+ * Recover a `SessionEnvironment` from stamped span attributes — the read
+ * counterpart of `stampEnvironmentAttrs`, for consumers that hold only the
+ * OTLP artifact (replay-environment resolution reads the exported spans, not
+ * the source session). Returns null when no environment identity was
+ * recorded — "not captured" stays distinguishable from any captured value.
+ */
+declare function environmentFromSpanAttributes(spans: readonly {
+    attributes: Readonly<Record<string, unknown>>;
+}[]): SessionEnvironment | null;
 /** Harness used when none is specified on a single-harness command. */
 declare const DEFAULT_HARNESS = "claude-code";
 declare function sessionIdFromAttributes(attributes: Readonly<Record<string, unknown>>): string | undefined;
@@ -1722,6 +1778,13 @@ interface TraceExecutionOptions {
 declare function summarizeOtlpExecution(otlpJsonl: string, opts?: TraceExecutionOptions): ExecutionReport;
 declare function summarizeSpanExecution(spans: readonly OtlpSpan[], opts?: TraceExecutionOptions): ExecutionReport;
 
+/**
+ * The one sentence of prose every policy-evidence record carries. It is the
+ * same for every session, so a content check that compares an evidence file
+ * against a transcript must subtract it: a session that reads or writes this
+ * package's source would otherwise look like it leaked its own text.
+ */
+declare const POLICY_EVIDENCE_NOTE = "This is normalized coding-agent session evidence for downstream policy mining; it is not an eval campaign cell.";
 interface PolicyEvidenceToolSummary {
     readonly name: string;
     readonly calls: number;
@@ -1890,6 +1953,14 @@ interface CollectSessionIndexOptions extends ScanOptions, BuildSessionIndexOptio
 declare function buildSessionIndex(records: readonly PolicyEvidenceRecord[], opts?: BuildSessionIndexOptions & {
     context?: TraceContextIndex;
 }): TraceSessionIndex;
+/**
+ * Walk up from a session cwd to the root the session's local context lives
+ * under: the first ancestor carrying `.git`, `.evolve`, `AGENTS.md`, or
+ * `CLAUDE.md`. The context index and the session bundler both anchor their
+ * `.evolve` reads here so "which ledger belongs to this session" has exactly
+ * one answer.
+ */
+declare function findContextRoot(cwd: string | null | undefined): Promise<string | null>;
 declare function buildSessionIndexFromRows(rows: readonly {
     ref: SessionRef;
     spans: readonly OtlpSpan[];
@@ -1898,6 +1969,306 @@ declare function collectSessionIndex(opts?: CollectSessionIndexOptions): Promise
 declare function serializeSessionIndex(index: TraceSessionIndex): string;
 declare function writeSessionIndexFile(index: TraceSessionIndex, outPath?: string): Promise<string>;
 
+/**
+ * `traces bundle` — assemble one session's durable evidence directory.
+ *
+ * A bundle is the input contract for downstream consumers (distillers,
+ * report writers, auditors) that must cite a session long after the live
+ * stores have rotated: the raw transcript + subagent transcripts, every
+ * derived artifact this CLI already knows how to produce (session index,
+ * deterministic analyze report, policy evidence, OTLP spans), the repo's
+ * `.evolve` ledger sliced to the session window, the git log for that
+ * window, and a manifest with a SHA-256 per file so any later claim can be
+ * checked against the exact bytes it cites.
+ *
+ * The transcript is REQUIRED — no transcript, no bundle, loudly. Everything
+ * else is an optional input whose absence is a recorded fact in the
+ * manifest (`absent`, with the reason), never a silent gap and never an
+ * error: a session without subagents or without an `.evolve` ledger is a
+ * complete bundle of a smaller session.
+ *
+ * This module assembles the FULL view. `bundle-view.ts` projects that full
+ * bundle down to the evidence-only view for a consumer that must not read the
+ * session's own words; `manifest.view` names which of the two a directory is.
+ */
+
+interface SessionBundleFile {
+    /** Bundle-relative path, `/`-separated. */
+    readonly path: string;
+    readonly bytes: number;
+    readonly sha256: string;
+}
+interface SessionBundleAbsence {
+    /** Bundle-relative path the artifact would have occupied. */
+    readonly path: string;
+    readonly reason: string;
+}
+type SessionBundleSliceRule = 
+/** JSONL rows kept verbatim when their `ts` falls inside the padded session window. */
+'session-window-rows' | 'copied-whole'
+/** The lexically last `handoff-*.md` — names are date-prefixed, so name order is time order. */
+ | 'latest-by-name'
+/** Files whose name carries a `YYYY-MM-DD` date inside the session window's dates. */
+ | 'session-window-dated-files';
+interface SessionBundleLedgerSlice {
+    readonly path: string;
+    /** Absolute source path the slice was read from. */
+    readonly source: string;
+    readonly rule: SessionBundleSliceRule;
+    readonly totalRows?: number;
+    readonly keptRows?: number;
+    /** Rows excluded because no `ts` could be parsed — counted, never silently dropped. */
+    readonly unparseableTsRows?: number;
+}
+/**
+ * Which projection of a session a bundle directory holds.
+ *
+ * `full` is the auditor's copy: every source byte, so a claim can be checked
+ * against the exact text it cites. `evidence-only` is the writer's copy: the
+ * counted artifacts, with the session's own words removed, so a writer that
+ * must reach its own conclusion cannot read an earlier one instead.
+ */
+type SessionBundleView = 'full' | 'evidence-only';
+type SessionBundleExclusionRule = 
+/** The session's raw text: transcript and subagent transcripts. */
+'session-source'
+/** A derived artifact that replays session text (prompt lines, excerpts, span content). */
+ | 'session-text-derived'
+/** A file whose body is prose someone authored: ledger notes, handoffs, commit subjects. */
+ | 'authored-prose'
+/** An allow-listed file dropped because its own text repeats an excluded source. */
+ | 'content-signature'
+/** Default deny: the evidence-only view carries an allow-list, and this path is not on it. */
+ | 'not-allow-listed';
+interface SessionBundleExclusion {
+    /** Bundle-relative path in the FULL bundle this view was projected from. */
+    readonly path: string;
+    readonly bytes: number;
+    /** SHA-256 of the excluded bytes, so an auditor can prove which file was dropped. */
+    readonly sha256: string;
+    readonly rule: SessionBundleExclusionRule;
+    readonly reason: string;
+    /**
+     * Present when `rule` is `content-signature`: how much text the file shared
+     * with which excluded sources. Counts and paths only — quoting the matched
+     * text here would carry into the view the very text the exclusion removes.
+     */
+    readonly contentMatch?: {
+        readonly signatures: number;
+        readonly sources: readonly string[];
+    };
+}
+interface SessionBundleCarriedSignatures {
+    readonly path: string;
+    /** What the artifact is made of, which is the reason it is safe to carry. */
+    readonly carries: string;
+    /** Distinct content signatures the carried file holds at all. 0 = no prose run of that length. */
+    readonly signatures: number;
+}
+/**
+ * The projection's own proof that no excluded file's text survived into the
+ * view. `matches` is typed `0` because a match aborts the projection: a view
+ * directory carrying a leak is never written, so the artifact cannot record one.
+ */
+interface SessionBundleLeakCheck {
+    /** Consecutive words per content signature. */
+    readonly signatureWords: number;
+    /** Excluded files whose text supplied the signatures compared against. */
+    readonly comparedSources: readonly string[];
+    readonly sourceSignatures: number;
+    readonly carried: readonly SessionBundleCarriedSignatures[];
+    readonly matches: 0;
+}
+interface SessionBundleProjection {
+    /** Absolute directory of the full bundle this view was projected from. */
+    readonly sourceDirectory: string;
+    /** SHA-256 of that bundle's `manifest.json` bytes. */
+    readonly sourceManifestSha256: string;
+    readonly leakCheck: SessionBundleLeakCheck;
+}
+interface SessionBundleManifest {
+    readonly schemaVersion: 2;
+    readonly kind: 'traces.session_bundle';
+    /** Which projection this directory is. A reader must branch on this, never on the file list. */
+    readonly view: SessionBundleView;
+    readonly createdAt: string;
+    readonly provenance: {
+        readonly sessionId: string;
+        readonly harness: string;
+        readonly cwd: string | null;
+        /** Absolute path of the source transcript at assembly time. */
+        readonly transcriptPath: string;
+        readonly transcriptSha256: string;
+        /** Root the `.evolve` ledger and git log were read under, when found. */
+        readonly contextRoot: string | null;
+        readonly tracesVersion: string;
+        readonly sessionWindow: {
+            readonly firstSpanAt: string | null;
+            readonly lastSpanAt: string | null;
+            /** Pad applied to each side of the window when slicing ledger rows. */
+            readonly padMs: number;
+        };
+    };
+    readonly files: readonly SessionBundleFile[];
+    readonly absent: readonly SessionBundleAbsence[];
+    /** Files the view deliberately dropped. Empty in the `full` view: it drops nothing. */
+    readonly excluded: readonly SessionBundleExclusion[];
+    readonly ledgerSlices: readonly SessionBundleLedgerSlice[];
+    readonly knownLimits: readonly string[];
+    /** Present only in a projected view: where it came from, and the leak check that passed. */
+    readonly projection?: SessionBundleProjection;
+}
+interface SessionBundleResult {
+    readonly directory: string;
+    readonly manifestPath: string;
+    readonly manifest: SessionBundleManifest;
+}
+interface AssembleSessionBundleOptions {
+    readonly adapter: HarnessTraceAdapter;
+    readonly ref: SessionRef;
+    /** Bundle directory to create. Must be new or empty: one bundle, one session. */
+    readonly outDir: string;
+    readonly generatedAt?: string;
+    readonly minLoopOccurrences?: number;
+    readonly signal?: AbortSignal;
+    readonly log?: (msg: string, fields?: Record<string, unknown>) => void;
+}
+/**
+ * Every file under a bundle directory, as sorted bundle-relative
+ * `/`-separated paths. Both the manifest writer and the view projector walk a
+ * bundle through here, so neither can see a file the other does not.
+ */
+declare function listSessionBundleFiles(root: string): Promise<string[]>;
+/**
+ * Assemble one session's bundle directory. Throws when the transcript is
+ * missing or unparseable — a bundle without its primary source is not a
+ * degraded bundle, it is not a bundle. Optional inputs (subagents directory,
+ * `.evolve` ledger, git history) that are absent are recorded in
+ * `manifest.absent` with the probed path and reason.
+ */
+declare function assembleSessionBundle(opts: AssembleSessionBundleOptions): Promise<SessionBundleResult>;
+/** SHA-256 + byte count for every file under a bundle directory, manifest included when present. */
+declare function hashSessionBundleFiles(root: string): Promise<SessionBundleFile[]>;
+declare function writeSessionBundleManifest(outDir: string, manifest: SessionBundleManifest): Promise<string>;
+/**
+ * Read a bundle's manifest and prove it is one. A directory that merely looks
+ * like a bundle must not be projected: the view guarantee is only as good as
+ * the classification, and the classification only holds over paths this
+ * package wrote.
+ */
+declare function readSessionBundleManifest(bundleDir: string): Promise<SessionBundleManifest>;
+
+/**
+ * `traces bundle-view` — project a full session bundle down to one view.
+ *
+ * A bundle has two consumers with opposite needs. An AUDITOR cites the
+ * session and needs every source byte. A WRITER must reach its own conclusion
+ * about the session and therefore must not be able to read the conclusion the
+ * session already reached — which the transcript holds verbatim, including the
+ * shell call that authored an earlier report.
+ *
+ * Serving both from one directory cannot work, and policing it by grep cannot
+ * work either: a check that looks for the earlier report FILE passes while its
+ * CONTENT sits in the transcript. So the two consumers get two directories.
+ * The evidence-only view is a projection of the full bundle: an explicit
+ * allow-list of counted artifacts, every other path excluded by name with its
+ * reason and its hash, and a content check that proves no excluded file's text
+ * survived into the view.
+ *
+ * The allow-list is the structure. The content check is the proof that the
+ * structure is right: before anything is written, every candidate is compared
+ * against every excluded file, and a candidate that repeats one is dropped
+ * from the view and named in the manifest. So the written view never carries
+ * text from a file the view says it removed.
+ */
+
+/**
+ * Distinct signatures in one text: every run of `SIGNATURE_WORDS` consecutive
+ * words, lowercased, taken WITHIN one line's prose. Signatures never span a
+ * newline, so memory stays bounded by the longest line rather than the file,
+ * and a structure whose every line is a key and a number produces no
+ * signatures at all — which is the true statement about it: it holds no prose.
+ */
+declare function sessionTextSignatures(text: string): Set<string>;
+interface SessionTextLeak {
+    /** Bundle-relative path of the carried file that repeats excluded text. */
+    readonly viewPath: string;
+    /** Bundle-relative paths of the excluded files the repeated text came from. */
+    readonly sources: readonly string[];
+    /** Distinct signatures this file shares with those sources. */
+    readonly signatures: number;
+    /**
+     * One matched signature, for a diagnostic message only. It is a fragment of
+     * the excluded text, so it must never be written into a view artifact.
+     */
+    readonly example: string;
+}
+interface FindSessionTextLeaksOptions {
+    /** Directory holding the carried files. */
+    readonly viewDir: string;
+    /** Directory holding the excluded files. */
+    readonly sourceDir: string;
+    /** Bundle-relative paths under `viewDir` to check. */
+    readonly carriedPaths: readonly string[];
+    /** Bundle-relative paths under `sourceDir` whose text must not appear in the view. */
+    readonly excludedPaths: readonly string[];
+}
+interface SessionTextLeakReport {
+    /** One entry per carried file that repeats excluded text. Empty is the pass. */
+    readonly leaks: readonly SessionTextLeak[];
+    readonly carried: readonly {
+        readonly path: string;
+        readonly signatures: number;
+    }[];
+    readonly comparedSources: readonly string[];
+    readonly sourceSignatures: number;
+}
+/**
+ * Compare a set of carried files against the files a view excluded.
+ *
+ * The signature index is built from the CARRIED files, which are small, and
+ * the excluded files are then read one at a time and tested against it — the
+ * cheap direction, since a transcript can be orders of magnitude larger than
+ * everything a view keeps. Every excluded file is scanned to the end, so the
+ * per-file counts are totals rather than "however many we saw before stopping".
+ */
+declare function findSessionTextLeaks(opts: FindSessionTextLeaksOptions): Promise<SessionTextLeakReport>;
+type EvidenceOnlyVerdict = {
+    readonly carried: true;
+    readonly owned: boolean;
+    readonly carries: string;
+} | {
+    readonly carried: false;
+    readonly rule: SessionBundleExclusionRule;
+    readonly reason: string;
+};
+/** Classify one bundle-relative path against the evidence-only view. */
+declare function classifyEvidenceOnlyPath(path: string): EvidenceOnlyVerdict;
+interface ProjectSessionBundleOptions {
+    /** Directory holding the FULL bundle to project. */
+    readonly bundleDir: string;
+    /** View directory to create. Must be new or empty: one directory, one view. */
+    readonly outDir: string;
+    readonly view: SessionBundleView;
+    readonly generatedAt?: string;
+}
+interface ProjectSessionBundleResult {
+    readonly directory: string;
+    readonly manifestPath: string;
+    readonly manifest: SessionBundleManifest;
+    readonly leakCheck: SessionBundleLeakCheck;
+}
+/**
+ * Project a full bundle into a narrower view.
+ *
+ * Every file is verified against the source manifest's hash first: a bundle
+ * whose bytes have drifted from its own manifest cannot be projected, because
+ * the classification is only meaningful over the files this package wrote.
+ * The content check then runs before anything is written, so a candidate that
+ * repeats an excluded source is dropped instead of copied.
+ */
+declare function projectSessionBundle(opts: ProjectSessionBundleOptions): Promise<ProjectSessionBundleResult>;
+
 type TraceInspectionSeverity = 'high' | 'medium' | 'low';
 type TraceInspectionArea = 'index' | 'session' | 'repo' | 'context';
 interface TraceInspectionFinding {
@@ -2516,6 +2887,85 @@ declare function writeHodoscopeInput(otlpPath: string, options?: {
 /** Run Hodoscope as a behavior-discovery engine. Its output requires review. */
 declare function hodoscopeAnalyzer(options?: HodoscopeAnalyzerOptions): ExternalAnalyzer;
 
+/**
+ * Prime analyst engine — a bundled {@link ExternalAnalyzer} that runs a
+ * one-shot RLM over the OTLP-JSONL artifact through an OpenAI-compatible
+ * bridge (cli-bridge's prime backend, or any `/v1/chat/completions` endpoint).
+ *
+ * Protocol, in one pass with no tools:
+ *   1. The FULL span projection is inlined into the prompt as JSON — prime has
+ *      no REPL and no trace tools, so unlike the dspy-rlm analysts (which
+ *      drill via viewSpans/searchTrace) every fact must travel in the prompt.
+ *   2. The reply contract is one fenced ```json block of SHORT strings
+ *      (long strings get corrupted in transport), citing span ids verbatim.
+ *   3. A structurally malformed reply gets ONE bounded stateless repair turn
+ *      carrying the malformed reply plus the contract — never the trajectory —
+ *      mirroring the typed-adapter repair the dspy arm gets, so both arms face
+ *      the same structured-output affordance.
+ *   4. Cited span ids are resolved against the artifact; rows citing unknown
+ *      or ambiguous ids are rejected with a recorded reason, never guessed.
+ *      Zero findings from a well-formed reply is an honest null, not an error.
+ *
+ * Oversized traces: when the rendered projection exceeds the inline budget it
+ * is re-rendered with a per-attribute character cap (the prompt-side analog of
+ * the trace store's per-attribute byte cap); if still oversized the run fails
+ * loud — inline delivery is the only delivery, so silently dropping spans
+ * would understate the trajectory. The delivery decision is recorded in the
+ * result output.
+ *
+ * Usage (bridge-reported token counts and call count) is recorded in the
+ * result output; cost stays uncaptured because the bridge reports no priced
+ * cost and this adapter carries no pricing table.
+ */
+
+interface PrimeTransportRequest {
+    url: string;
+    body: {
+        model: string;
+        messages: Array<{
+            role: 'user';
+            content: string;
+        }>;
+    };
+    /** Aborts on the analyzer's deadline AND the caller's signal. */
+    signal: AbortSignal;
+}
+interface PrimeTransportResponse {
+    status: number;
+    text: string;
+}
+/** POSTs one JSON chat completion; injectable so tests run on a fake bridge. */
+type PrimeTransport = (req: PrimeTransportRequest) => Promise<PrimeTransportResponse>;
+interface PrimeAnalyzerOptions {
+    /** Bridge ROOT url; the adapter calls `<root>/v1/chat/completions`.
+     *  Default: TRACES_PRIME_BRIDGE_URL, then http://localhost:4181. */
+    bridgeUrl?: string;
+    /** Model id the bridge routes on. Default: TRACES_PRIME_MODEL, then prime/zai/glm-5.2. */
+    model?: string;
+    /** Per-call deadline. Default: TRACES_PRIME_TIMEOUT_MS, then 1200000 (20 min —
+     *  prime runs legitimately exceed 5 minutes). */
+    timeoutMs?: number;
+    /** Question asked when the caller passes no prompt. */
+    defaultPrompt?: string;
+    /** Rendered-projection budget before the per-attribute cap kicks in. */
+    maxInlineChars?: number;
+    /** Character cap applied to each attribute on the oversized re-render. */
+    perAttributeCharCap?: number;
+    /** Disable the bounded repair turn (one extra call on a malformed reply). */
+    repair?: boolean;
+    transport?: PrimeTransport;
+}
+/** Default transport: plain node:http/https, NOT fetch — undici's fixed 300s
+ *  headers timeout kills prime calls that legitimately run longer; the
+ *  analyzer's AbortSignal is the only deadline. */
+declare const httpJsonTransport: PrimeTransport;
+/** One-shot prime-RLM analysis over the emitted OTLP artifact, as a peer of
+ *  `haloAnalyzer` / `hodoscopeAnalyzer` on the `--analyzer` registry. Requires
+ *  a running OpenAI-compatible bridge with the prime backend; deterministic
+ *  analysis and every other engine are unaffected when it is down (`ok:false`
+ *  result, never a thrown run). */
+declare function primeAnalyzer(opts?: PrimeAnalyzerOptions): ExternalAnalyzer;
+
 /**
  * Live trace observer — compatibility wrapper behind `traces watch`.
  *
@@ -3466,10 +3916,33 @@ interface FixPromptInput {
     /** Steps of context on each side of k (default 3). */
     readonly contextRadius?: number;
 }
+/** Head+tail excerpt with an elision marker; identity below the limit. */
+declare function clipText(text: string, limit: number): string;
 declare function buildFixPrompt(input: FixPromptInput): {
     system: string;
     user: string;
 };
+/** One prior attempt of the fix loop, rendered into the retry prompt. */
+interface FailedFixAttempt {
+    readonly attempt: number;
+    /** Null when the model call itself failed before producing a command. */
+    readonly command: string | null;
+    readonly exitCode: number | null;
+    readonly stdoutTail: string | null;
+    readonly stderrTail: string | null;
+    readonly llmError: string | null;
+}
+/**
+ * Retry prompt for fix-loop attempts ≥2: the original context plus every prior
+ * attempt with its REAL executed output, and permission to answer with a short
+ * script (the block still executes as one /bin/sh unit).
+ */
+declare function buildRetryFixPrompt(input: FixPromptInput, priorAttempts: readonly FailedFixAttempt[], maxScriptCommands?: number): {
+    system: string;
+    user: string;
+};
+/** Non-empty, non-comment lines of a fix script — the loop's script-size cap. */
+declare function countScriptCommands(script: string): number;
 /** Last fenced code block, else the whole trimmed content; null when empty. */
 declare function extractFixCommand(content: string): string | null;
 type FixGenerationOutcome = {
@@ -3484,6 +3957,75 @@ type FixGenerationOutcome = {
 };
 declare function generateFixCommand(caller: ChatCompletionCaller, input: FixPromptInput): Promise<FixGenerationOutcome>;
 
+/**
+ * Iterative counterfactual fix loop.
+ *
+ * Attempt 1 is exactly the one-shot generator (same prompt, same caller), so
+ * flip@1 stays comparable to `--fix generate`. When an attempt does not flip
+ * the failure — nonzero exit, signature still present, or the model call
+ * itself failed — the next attempt's prompt carries every prior command and
+ * its REAL executed stdout/stderr, up to a fixed attempt budget.
+ *
+ * Isolation invariant: every attempt executes through the injected executor,
+ * which must provide a FRESH sandbox with the same replayed prefix. A used
+ * sandbox is never mutated mid-arm; a flip therefore always proves the
+ * corrected step against the recorded prefix state, not against debris from
+ * an earlier attempt.
+ */
+
+/** Result of executing one corrected command as a full arm. */
+interface FixArmExecution {
+    readonly exitCode: number;
+    readonly prefixExecuted: number;
+    readonly prefixDivergences: number;
+    readonly failureVanished: boolean;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Runs one corrected command as a full arm: fresh sandbox + prefix replay. */
+type FixArmExecutor = (command: string, attempt: number) => Promise<FixArmExecution>;
+interface FixLoopOptions {
+    /** Total LLM attempts per case (≥1); 1 degenerates to the one-shot path. */
+    readonly maxAttempts: number;
+    /** Command-line cap on retry scripts (default 5). */
+    readonly maxScriptCommands?: number;
+    /** Chars kept per stdout/stderr tail in records and retry prompts. */
+    readonly outputTailChars?: number;
+    readonly onProgress?: (message: string) => void;
+}
+interface FixLoopAttemptRecord {
+    readonly attempt: number;
+    readonly command: string | null;
+    readonly llmError: string | null;
+    readonly usage: {
+        readonly promptTokens: number;
+        readonly completionTokens: number;
+    } | null;
+    readonly executed: boolean;
+    readonly exitCode: number | null;
+    readonly prefixExecuted: number | null;
+    readonly prefixDivergences: number | null;
+    readonly failureVanished: boolean | null;
+    readonly stdoutTail: string | null;
+    readonly stderrTail: string | null;
+    readonly armBError: string | null;
+    readonly wallMs: number;
+}
+interface FixLoopResult {
+    readonly flipped: boolean;
+    readonly flippedAtAttempt: number | null;
+    readonly attempts: readonly FixLoopAttemptRecord[];
+    /** True when a sandbox error ended the loop before the attempt budget. */
+    readonly aborted: boolean;
+    readonly llmCalls: number;
+    /** Calls that produced no runnable fix: transport errors, empty replies,
+     *  and retry scripts over the command cap. */
+    readonly llmFailures: number;
+    readonly promptTokens: number;
+    readonly completionTokens: number;
+}
+declare function runFixLoop(caller: ChatCompletionCaller, input: FixPromptInput, executor: FixArmExecutor, options: FixLoopOptions): Promise<FixLoopResult>;
+
 /**
  * Batch replay-verification across gold-labeled CodeTraceBench corpora.
  *
@@ -3538,8 +4080,12 @@ interface ReplayBatchOptions {
     readonly out: string;
     readonly baseUrl?: string;
     readonly apiKey?: string;
-    /** 'generate' runs one LLM call per arm-A-reproduced case, then arm B. */
-    readonly fix: 'none' | 'generate';
+    /** 'generate' = one LLM call per arm-A-reproduced case, then arm B.
+     *  'loop' = iterative: failed arms feed their real output into up to
+     *  --fix-attempts prompts, each executed in its own fresh sandbox. */
+    readonly fix: 'none' | 'generate' | 'loop';
+    /** Attempt budget per case in loop mode (default 3). */
+    readonly fixAttempts?: number;
     readonly fixCaller?: ChatCompletionCaller;
     readonly fixModelLabel?: string;
     /** Cap on LLM fix calls; eligible cases beyond it are seeded-sampled out. */
@@ -3564,12 +4110,19 @@ interface ReplayBatchFixResult {
     readonly sampledOut: boolean;
     readonly command: string | null;
     readonly llmError: string | null;
+    /** Loop mode: token totals summed across every attempt (null when the
+     *  provider reported no usage). */
     readonly usage: ChatUsage | null;
     readonly armBExit: number | null;
     readonly armBPrefixExecuted: number | null;
     readonly armBPrefixDivergences: number | null;
     readonly failureVanished: boolean | null;
     readonly armBError: string | null;
+    /** Loop mode only: the full per-attempt trail. Null in generate mode. */
+    readonly attempts: readonly FixLoopAttemptRecord[] | null;
+    /** 1-based attempt that flipped the failure; null when none did.
+     *  Generate mode: 1 when the single attempt flipped. */
+    readonly flippedAtAttempt: number | null;
 }
 interface ReplayBatchCaseRow {
     readonly corpus: string;
@@ -3642,6 +4195,15 @@ interface ReplayBatchReport {
             denominator: number;
             value: number | null;
         } | null;
+        /** Loop mode only: flips at attempt 1 over cases whose attempt 1 executed —
+         *  the number directly comparable to the one-shot fixFlipRate. */
+        readonly fixFlipAttempt1: {
+            numerator: number;
+            denominator: number;
+            value: number | null;
+        } | null;
+        /** Loop mode only: flip count keyed by the attempt number that flipped. */
+        readonly flipsByAttempt: Record<string, number> | null;
     };
     readonly llm: {
         readonly model: string;
@@ -3670,7 +4232,8 @@ declare function renderBatchReport(report: ReplayBatchReport): string;
 interface ReplayBatchCliArgs {
     readonly corpora: CorpusSpec[];
     readonly out: string;
-    readonly fix: 'none' | 'generate';
+    readonly fix: 'none' | 'generate' | 'loop';
+    readonly fixAttempts: number;
     readonly fixModel: string;
     readonly fixBaseUrl: string;
     readonly fixApiKeyEnv: string;
@@ -3753,6 +4316,177 @@ interface ReplayFindingResult {
  */
 declare function replayVerifyFinding(finding: AnalystReplayFinding, options: ReplayFindingOptions): Promise<ReplayFindingResult>;
 
+/**
+ * Proof-carrying findings: execute analyst findings as sandbox replays.
+ *
+ * An analyst finding is a cited claim ("step 12 is where the run went
+ * wrong"). This module turns each finding into an executed verdict by
+ * replaying the trajectory prefix in a real sandbox and running the accused
+ * step (arm A), optionally followed by a corrected step (arm B):
+ *
+ *   `reproduced`     arm A re-produced the recorded failure signature
+ *                    (returncode + stable output substring).
+ *   `fix-flipped`    arm A reproduced AND arm B's corrected command made the
+ *                    failure vanish — the strongest per-finding proof.
+ *   `divergent`      arm A executed but the recorded failure did NOT
+ *                    reproduce; evidence against the finding (or against
+ *                    replay fidelity — the receipt carries prefix
+ *                    divergences so the reader can tell which).
+ *   `not-replayable` the finding could not be executed at all; the receipt
+ *                    carries the precise reason (no step subject, unknown
+ *                    trajectory, no docker image, submit step, …).
+ *
+ * Verification is execution, not generation: no LLM is involved unless the
+ * caller supplies a corrected command for arm B. Sandbox infrastructure being
+ * absent while a finding needs execution is an error, never a silent skip.
+ *
+ * Findings are matched by the shape the analyst product emits
+ * (agent-eval `AnalystFinding`): `subject` (`incorrect-step-<n>` or the wire's
+ * `incorrect-steps-<f>-<l>-<escaped|unescaped>-consequence-<c>`),
+ * `metadata.block_first_step`, and `trace://<traj>/…` evidence refs.
+ */
+
+interface VerifiableFinding {
+    readonly finding_id?: string;
+    readonly analyst_id?: string;
+    readonly subject?: string;
+    readonly area?: string;
+    readonly claim?: string;
+    readonly evidence_refs?: readonly {
+        readonly kind?: string;
+        readonly uri?: string;
+        readonly excerpt?: string;
+    }[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/**
+ * 1-based step the finding accuses, or null when the finding names none.
+ * `metadata.block_first_step` wins over the subject: the analyst records the
+ * block's first incorrect step there even when the subject names a later
+ * step of the same block.
+ */
+declare function findingReplayStep(finding: VerifiableFinding): number | null;
+/** Trajectory id from the finding's `trace://<traj>/…` evidence refs, or null. */
+declare function findingTrajectoryId(finding: VerifiableFinding): string | null;
+/**
+ * Where the executable trajectory lives.
+ * `direct` — one trajectory's steps.json plus a replay-ready image (the
+ *   caller owns image preparation, exactly like `traces replay-verify`).
+ * `corpus` — CodeTraceBench corpora; each finding's trajectory is resolved
+ *   by its `trace://` evidence and the image is derived through the batch
+ *   preparer (uid-1000 chown) unless a test backend is injected.
+ */
+type FindingReplaySource = {
+    readonly kind: 'direct';
+    readonly stepsPath: string;
+    readonly image: string;
+    readonly cwd: string;
+    readonly caseId?: string;
+} | {
+    readonly kind: 'corpus';
+    readonly corpora: readonly CorpusSpec[];
+    readonly preparer?: ImagePreparer;
+};
+interface ResolvedFindingReplay {
+    readonly caseId: string;
+    readonly stepsPath: string;
+    /** Raw image; corpus-mode execution derives the uid-1000 replay image from it. */
+    readonly image: string;
+    readonly cwd: string;
+    /** 1-based step_id arm A executes. */
+    readonly at: number;
+    readonly recordedReturncode: number;
+    readonly recordedStepTimeoutMs: number | null;
+}
+type FindingReplayability = {
+    readonly replayable: true;
+    readonly resolved: ResolvedFindingReplay;
+} | {
+    readonly replayable: false;
+    readonly reason: string;
+};
+/**
+ * Decides whether one finding can be executed against the source, and with
+ * what invocation. Never throws for a finding-shaped problem — every dead end
+ * becomes a `not-replayable` reason the receipt can carry verbatim.
+ */
+declare function resolveFindingReplayability(finding: VerifiableFinding, source: FindingReplaySource): FindingReplayability;
+type FindingVerificationStatus = 'reproduced' | 'fix-flipped' | 'not-replayable' | 'divergent';
+interface FindingVerification {
+    readonly finding_id: string | null;
+    readonly subject: string | null;
+    readonly trajectory_id: string | null;
+    /** 1-based step the proof executed at; null when not replayable. */
+    readonly step: number | null;
+    readonly verified: FindingVerificationStatus;
+    /** Present exactly when `verified` is `not-replayable`. */
+    readonly reason: string | null;
+    /** Receipt directory: receipt.json plus, when executed, replay-verdict.json + report.md. */
+    readonly receipt: string;
+    readonly verdict_path: string | null;
+    /** Receipt dir of the executed proof this finding shares (same case, step, and fix). */
+    readonly deduplicated_with: string | null;
+}
+interface VerifyFindingsRun {
+    readonly out: string;
+    readonly verifications: readonly FindingVerification[];
+    readonly counts: Readonly<Record<FindingVerificationStatus, number>>;
+    /** Sandbox executions actually performed (deduplicated proofs count once). */
+    readonly executions: number;
+}
+interface VerifyFindingsOptions {
+    readonly source: FindingReplaySource;
+    /** Receipt root; one subdirectory per finding plus verifications.json. */
+    readonly out: string;
+    /** Corrected command for arm B on every executed finding; omit for arm A only. */
+    readonly fixCommand?: string;
+    readonly stepTimeoutMs?: number;
+    readonly prefixLimit?: number;
+    /** Injectable for tests; when set, no sandbox reachability check and no image preparation run. */
+    readonly backend?: ReplayExecBackend;
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly maxLifetimeSeconds?: number;
+    readonly onProgress?: (message: string) => void;
+}
+/** Arm A reproduced → the fix flipping it beats plain reproduction; anything else diverged. */
+declare function classifyVerdict(verdict: ReplayVerdict): FindingVerificationStatus;
+declare const DEFAULT_SANDBOX_BASE_URL = "http://127.0.0.1:4097";
+/**
+ * Fails loud when the sandbox SDK adapter is not answering. Executed findings
+ * require real infrastructure; verification is never silently skipped.
+ */
+declare function assertSandboxReachable(baseUrl: string): Promise<void>;
+/**
+ * Verifies every finding against the source: resolves replayability, executes
+ * one sandbox proof per distinct (case, step, fix) — findings accusing the
+ * same step share the executed proof — and writes a receipt directory per
+ * finding plus a run-level verifications.json.
+ */
+declare function verifyFindings(findings: readonly VerifiableFinding[], options: VerifyFindingsOptions): Promise<VerifyFindingsRun>;
+/** Markdown section the analyze report appends when --verify-findings ran. */
+declare function renderVerifiedFindingsSection(run: VerifyFindingsRun): string;
+/**
+ * Accepts the two shapes findings travel in: a bare JSON array of analyst
+ * findings, or an object with a `findings` array (e.g. an extracted
+ * `observations[n]` from an agent-eval result.json).
+ */
+declare function readFindingsFile(path: string): VerifiableFinding[];
+interface VerifyFindingsCliArgs {
+    findingsPath: string;
+    source: FindingReplaySource;
+    out: string;
+    fixCommand?: string;
+    stepTimeoutMs?: number;
+    prefixLimit?: number;
+    baseUrl: string;
+    apiKeyEnv: string;
+    maxLifetimeSeconds?: number;
+}
+declare function verifyFindingsUsage(): string;
+declare function parseVerifyFindingsArgs(argv: readonly string[]): VerifyFindingsCliArgs | 'help';
+declare function cmdVerifyFindings(argv: readonly string[]): Promise<void>;
+
 /**
  * Local upload-dedup state.
  *
@@ -3855,4 +4589,4 @@ interface ExecuteOptions {
 /** Send the final, new outbound items (or write their dry-run OTLP). */
 declare function executeUpload(plan: UploadPlan, opts?: ExecuteOptions): Promise<UploadResult>;
 
-export { ACTOR_ATTR, ATTR, type Actor, type AdoptionOptions, type AdoptionReport, AmpAdapter, type AnalystReplayFinding, type AnalyzeOptions, type AnalyzeResult, type ArmExecutionResult, BLOBS_DIR, type BuildPolicyEvidenceOptions, type BuildSessionIndexOptions, type BuildTraceFindingPacketOptions, CODING_REDACTION_RULES, CONTENT_CAP, COORDINATION_LOG_FILE, CORRECTIVE_REACTIONS, type CaseResources, type ChatCompletionCaller, type ChatOutcome, type ChatTrajectory, type ChatTrajectoryMessage, type ChatTrajectoryOptions, type ChatUsage, ClaudeAdapter, type CodeTraceBenchFileRef, type CodeTraceBenchImportOptions, type CodeTraceBenchImportReceipt, type CodeTraceBenchImportResult, type CodeTraceBenchImportedTrace, type CodeTraceBenchStep, CodexAdapter, CodexExecAdapter, CodexExecStreamError, CodexTaskScopeError, type CollectOptions, type CollectPolicyEvidenceOptions, type CollectSessionIndexOptions, type CollectSessionSelectionOptions, type CollectSessionWorkflowOptions, type ConformanceRenderOptions, type CoordinationLog, type CoordinationQuestion, type CoordinationSteer, CopilotAdapter, type CorpusSpec, type CorruptionMode, type CwdSource, DEFAULT_HARNESS, type DockerImagePreparerOptions, EMPTY_SPAN_RUN_SNAPSHOT, EXPORT_RULE, EmptySessionError, type EnumerationResult, type ExcludedCase, type ExecuteOptions, type ExportRule, type ExternalAnalysisKind, type ExternalAnalysisPayload, type ExternalAnalysisResult, type ExternalAnalyzer, type ExternalAnalyzerOptions, type ExternalDiscoveryCandidate, FactoryAdapter, type FileRunContextReaderOptions, type FixGenerationOutcome, type FixPromptInput, ForgeAdapter, GeminiAdapter, type HaloAnalyzerOptions, type HaloReasoningEffort, type HarnessTraceAdapter, type HodoscopeAnalyzerOptions, type HodoscopeInput, type HodoscopeMessage, type HodoscopeSourceMapEntry, type HodoscopeTrajectory, INGEST_SOURCE_CLI, type ImagePreparation, type ImagePreparer, type IncorrectStepsSubject, type IngestedTrajectory, type InspectSessionIndexOptions, JsonSourceError, type JsonlCorruptionReceipt, JsonlParseError, type JsonlReadOptions, type LiveBatchOptions, type LocateOptions, type LoopConvergence, type LoopConvergenceReport, type LoopIteration, type LoopTrend, type LoopTrendBasis, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpIngestIssue, type OtlpIngestIssueKind, type OtlpInput, type OtlpInputFile, type OtlpRowConversion, type OtlpSpan, type OtlpSpanKind, type OtlpSpanLink, type OtlpStatusCode, type ParentTaskResolution, type ParseOptions, PartialUploadError, PiAdapter, type PiAdapterOptions, type PipelineOptions, type PipelineReport, type PlanOptions, type PolicyEvidenceLoopSummary, type PolicyEvidenceRecord, type PolicyEvidenceToolSummary, type PrefixDivergence, type PrefixReplayResult, QwenAdapter, REACTIONS, RESULT_FILE, RULE, type Reaction, type ReactionReport, type ReactionSessionReport, type Redactor, type ReplayArmVerdict, type ReplayBatchCaseRow, type ReplayBatchCliArgs, type ReplayBatchFixResult, type ReplayBatchOptions, type ReplayBatchReport, type ReplayExclusionReason, type ReplayExecBackend, type ReplayExecResult, type ReplayExecSession, type ReplayFindingOptions, type ReplayFindingResult, type ReplayVerdict, type ReplayVerifyCliArgs, type ReplayVerifyOptions, type ReplayableCase, type RepoAttrs, type RepoResolution, type RepoResolutionSource, type ResolvedOtlpInput, type ResolvedReplayInvocation, type ResourceResolution, type RunContextJournal, type RunContextNode, type RunContextResult, type RunContextSnapshot, type RunResult, type RunWatchSnapshot, type RunWatchTarget, type RuntimeTrace, SPAWN_JOURNAL_FILE, STATUS_MARK, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, type SandboxCounterfactualRunnerOptions, type SandboxReplayBackendOptions, type ScanOptions, type ScannedSession, type SessionBatch, type SessionCorruptionReceipt, type SessionIdentityConflict, type SessionIdentityIndex, type SessionIntegrity, type SessionRef, type SessionRelationship, type SessionRole, type SessionSeedGroup, type SessionSelection, type SessionSelectionRow, type SessionSourceFile, type SessionWorkflow, SessionWorkflowError, type SessionWorkflowErrorCode, type SessionWorkflowIssue, type SessionWorkflowSession, type SessionWorkflowSummary, type SkippedAnalysis, type SkippedInputFile, type SpanInput, type SpanNodeStatus, type SpanRedaction, type SpanRunNode, type SpanRunSnapshot, type SpanStructure, type SpendRoll, type SteeringChainReport, type SteeringEdge, TRACES_REDACTION_RULES, type TraceAgenticRoute, type TraceAgenticRouteReason, type TraceAgenticRouteReasonCode, type TraceContextIndex, type TraceContextRoot, type TraceEvidenceExportOptions, type TraceEvidenceExportResult, type TraceEvidenceFormatOption, type TraceEvidenceInputFormat, type TraceEvidenceRow, type TraceExecutionOptions, type TraceFindingPacket, type TraceImprovementArtifacts, type TraceImprovementOptions, type TraceImprovementResult, type TraceIndexedFile, type TraceInspectionArea, type TraceInspectionFinding, type TraceInspectionReport, type TraceInspectionSeverity, type TraceInvestigationOptions, type TraceInvestigationResult, type TraceLiveAction, type TraceLiveActionKind, type TraceLiveAnalysisContext, type TraceLiveAnalyst, type TraceLiveBatch, type TraceLiveEvidence, type TraceLiveFinding, type TraceLiveLoop, type TraceLiveSeverity, type TraceSessionIndex, type TraceSessionIndexRow, type TraceStoreInvestigationOptions, type TraceStoreInvestigationResult, type TraceStreamEvent, type TraceStreamOptions, type TraceStreamReplayOptions, type TraceStreamSession, type TracesConfig, type TriggerPair, type UnavailableCapabilities, type UploadBackend, type UploadIdentity, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, type UserPromptInput, type WatchRunTargetOptions, ZERO_ROLL, type ZaiChatCallerOptions, addSpend, alreadyUploaded, analyzeAdoption, analyzeLiveBatch, analyzeLoopConvergence, analyzeReactions, analyzeSpans, analyzeSteeringChain, applyRedactor, buildFixPrompt, buildPolicyEvidenceRecord, buildSessionIndex, buildSessionIndexFromRows, buildSpanRunTree, buildTraceFindingPacket, capText, chatTrajectoryToSpans, classifyLiveActions, classifyReaction, claudeActor, cmdReplayVerify, cmdReplayVerifyBatch, codexActor, collectPolicyEvidence, collectSessionIndex, collectSessionSelection, collectSessionWorkflow, collectSessions, commandAnalyzer, commandRedactor, conformanceOfSpans, connectors, countSkillRunsJsonl, cwdMatchesSelection, defaultTraceLiveAnalysts, deriveFailureSignature, derivedImageTag, describeSessionRelationship, dockerImagePreparer, enumerateReplayableCases, equivalentGitCwds, executeUpload, exportTraceEvidenceFile, exportTraceEvidenceRows, exportTraceEvidenceText, extractFixCommand, fileRunContextSupervisorRunReader, findSpanSourceFiles, forEachTreeNode, generateFixCommand, goldIncorrectSteps, haloAnalyzer, hodoscopeAnalyzer, importCodeTraceBench, incompleteInputsNote, indexSessionIdsByTrace, inferRole, inferSpanKind, ingestCodeTraceBenchSteps, inspectSessionIndex, int, isChatTrajectory, isChatTrajectoryMessage, isFileRunContextDir, isSubmitAction, knownHarnesses, listAdapters, loadState, loadTracesConfig, locateSessions, looksLikeAgentPrompt, mergeRolls, mergeTracesConfig, ms, normalizeRemote, otlpRowToSpan, outboundHash, parseCorpusFlag, parseIncorrectStepsSubject, parseIsoToEpochMs, parseObservationOutput, parseRecordedReturncode, parseReplayBatchArgs, parseReplayVerifyArgs, parseSession, parseSince, planTraceAgenticRoute, planUpload, readCoordinationLog, readFileRunContext, readJsonFile, readJsonl, readLabelEntries, readOtlpInput, readRunContextJournal, readRunContextSnapshot, readRunWatchSnapshot, readSessionIndexFile, readSpanRunSnapshot, recordSessionCorruption, redactSpans, renderBatchReport, renderConformance, renderInspectionReport, renderRunContextSnapshot, renderRunWatchSnapshot, renderSpanRunSnapshot, renderValidation, replayBatchUsage, replayVerify, replayVerifyFinding, replayVerifyUsage, resolveAdapter, resolveCaseResources, resolveFindingInvocation, resolveOtlpInputFiles, resolveRepoAttrs, resolveRunContextDir, resolveRunWatchTarget, resolveSessionRepoAttrs, runCommand, runExternalAnalyzers, runPipelines, runReplayBatch, runTotals, runTraceImprovement, runTraceInvestigation, runTraceStoreInvestigation, sandboxReplayBackend, saveReport, saveState, scanSessions, seededSample, selectAdapters, serializeInspectionReport, serializePolicyEvidence, serializeSessionIndex, serializeSpans, serializeTraceStreamEvent, sessionHash, sessionIdFromAttributes, sessionIntegrityAttributes, skippedAnalyses, span, spanRunTotals, stampRepoAttrs, stampSessionIdentity, stampSessionIntegrity, stampSpanWorkdirRepoAttrs, streamSessions, summarizeOtlpExecution, summarizeSpanExecution, summarizeSpanStructure, takeJsonl, textIsSynthetic, toOpenInferenceSpan, toRuntimeStore, toTraceSpanEvents, tokens, totalAgenticFailureMessage, traceAgenticKinds, traceStreamEventsFromSpans, unavailableCapabilities, uploadKey, usd, userPromptSpan, validateOtlpSpans, validationExitCode, watchRunTarget, watchSessions, wrap, wrapActionForExec, writeHodoscopeInput, writeInspectionReportFile, writeOtlpFile, writePolicyEvidenceFile, writeSessionIndexFile, writeTraceEvidenceExportFile, writeTraceImprovementArtifacts, zaiChatCaller, zeroPricedCost };
+export { ACTOR_ATTR, ATTR, type Actor, type AdoptionOptions, type AdoptionReport, AmpAdapter, type AnalystReplayFinding, type AnalyzeOptions, type AnalyzeResult, type ArmExecutionResult, type AssembleSessionBundleOptions, BLOBS_DIR, type BuildPolicyEvidenceOptions, type BuildSessionIndexOptions, type BuildTraceFindingPacketOptions, CODING_REDACTION_RULES, CONTENT_CAP, COORDINATION_LOG_FILE, CORRECTIVE_REACTIONS, type CaseResources, type ChatCompletionCaller, type ChatOutcome, type ChatTrajectory, type ChatTrajectoryMessage, type ChatTrajectoryOptions, type ChatUsage, ClaudeAdapter, type CodeTraceBenchFileRef, type CodeTraceBenchImportOptions, type CodeTraceBenchImportReceipt, type CodeTraceBenchImportResult, type CodeTraceBenchImportedTrace, type CodeTraceBenchStep, CodexAdapter, CodexExecAdapter, CodexExecStreamError, CodexTaskScopeError, type CollectOptions, type CollectPolicyEvidenceOptions, type CollectSessionIndexOptions, type CollectSessionSelectionOptions, type CollectSessionWorkflowOptions, type ConformanceRenderOptions, type CoordinationLog, type CoordinationQuestion, type CoordinationSteer, CopilotAdapter, type CorpusSpec, type CorruptionMode, type CwdSource, DEFAULT_HARNESS, DEFAULT_SANDBOX_BASE_URL, type DockerImagePreparerOptions, EMPTY_SPAN_RUN_SNAPSHOT, EXPORT_RULE, EmptySessionError, type EnumerationResult, type EvidenceOnlyVerdict, type ExcludedCase, type ExecuteOptions, type ExportRule, type ExternalAnalysisKind, type ExternalAnalysisPayload, type ExternalAnalysisResult, type ExternalAnalyzer, type ExternalAnalyzerOptions, type ExternalDiscoveryCandidate, FactoryAdapter, type FailedFixAttempt, type FileRunContextReaderOptions, type FindSessionTextLeaksOptions, type FindingReplaySource, type FindingReplayability, type FindingVerification, type FindingVerificationStatus, type FixArmExecution, type FixArmExecutor, type FixGenerationOutcome, type FixLoopAttemptRecord, type FixLoopOptions, type FixLoopResult, type FixPromptInput, ForgeAdapter, GeminiAdapter, type HaloAnalyzerOptions, type HaloReasoningEffort, type HarnessTraceAdapter, type HodoscopeAnalyzerOptions, type HodoscopeInput, type HodoscopeMessage, type HodoscopeSourceMapEntry, type HodoscopeTrajectory, INGEST_SOURCE_CLI, type ImagePreparation, type ImagePreparer, type IncorrectStepsSubject, type IngestedTrajectory, type InspectSessionIndexOptions, JsonSourceError, type JsonlCorruptionReceipt, JsonlParseError, type JsonlReadOptions, type LiveBatchOptions, type LocateOptions, type LoopConvergence, type LoopConvergenceReport, type LoopIteration, type LoopTrend, type LoopTrendBasis, type ObservedLoop, type ObserverOptions, OpencodeAdapter, type OtlpIngestIssue, type OtlpIngestIssueKind, type OtlpInput, type OtlpInputFile, type OtlpRowConversion, type OtlpSpan, type OtlpSpanKind, type OtlpSpanLink, type OtlpStatusCode, POLICY_EVIDENCE_NOTE, type ParentTaskResolution, type ParseOptions, PartialUploadError, PiAdapter, type PiAdapterOptions, type PipelineOptions, type PipelineReport, type PlanOptions, type PolicyEvidenceLoopSummary, type PolicyEvidenceRecord, type PolicyEvidenceToolSummary, type PrefixDivergence, type PrefixReplayResult, type PrimeAnalyzerOptions, type PrimeTransport, type PrimeTransportRequest, type PrimeTransportResponse, type ProjectSessionBundleOptions, type ProjectSessionBundleResult, QwenAdapter, REACTIONS, RESULT_FILE, RULE, type Reaction, type ReactionReport, type ReactionSessionReport, type Redactor, type ReplayArmVerdict, type ReplayBatchCaseRow, type ReplayBatchCliArgs, type ReplayBatchFixResult, type ReplayBatchOptions, type ReplayBatchReport, type ReplayExclusionReason, type ReplayExecBackend, type ReplayExecResult, type ReplayExecSession, type ReplayFindingOptions, type ReplayFindingResult, type ReplayVerdict, type ReplayVerifyCliArgs, type ReplayVerifyOptions, type ReplayableCase, type RepoAttrs, type RepoResolution, type RepoResolutionSource, type ResolvedFindingReplay, type ResolvedOtlpInput, type ResolvedReplayInvocation, type ResourceResolution, type RunContextJournal, type RunContextNode, type RunContextResult, type RunContextSnapshot, type RunResult, type RunWatchSnapshot, type RunWatchTarget, type RuntimeTrace, SPAWN_JOURNAL_FILE, STATUS_MARK, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, type SandboxCounterfactualRunnerOptions, type SandboxReplayBackendOptions, type ScanOptions, type ScannedSession, type SessionBatch, type SessionBundleAbsence, type SessionBundleCarriedSignatures, type SessionBundleExclusion, type SessionBundleExclusionRule, type SessionBundleFile, type SessionBundleLeakCheck, type SessionBundleLedgerSlice, type SessionBundleManifest, type SessionBundleProjection, type SessionBundleResult, type SessionBundleSliceRule, type SessionBundleView, type SessionCorruptionReceipt, type SessionEnvironment, type SessionIdentityConflict, type SessionIdentityIndex, type SessionIntegrity, type SessionRef, type SessionRelationship, type SessionRole, type SessionSeedGroup, type SessionSelection, type SessionSelectionRow, type SessionSourceFile, type SessionTextLeak, type SessionTextLeakReport, type SessionWorkflow, SessionWorkflowError, type SessionWorkflowErrorCode, type SessionWorkflowIssue, type SessionWorkflowSession, type SessionWorkflowSummary, type SkippedAnalysis, type SkippedInputFile, type SpanInput, type SpanNodeStatus, type SpanRedaction, type SpanRunNode, type SpanRunSnapshot, type SpanStructure, type SpendRoll, type SteeringChainReport, type SteeringEdge, TRACES_REDACTION_RULES, type TraceAgenticRoute, type TraceAgenticRouteReason, type TraceAgenticRouteReasonCode, type TraceContextIndex, type TraceContextRoot, type TraceEvidenceExportOptions, type TraceEvidenceExportResult, type TraceEvidenceFormatOption, type TraceEvidenceInputFormat, type TraceEvidenceRow, type TraceExecutionOptions, type TraceFindingPacket, type TraceImprovementArtifacts, type TraceImprovementOptions, type TraceImprovementResult, type TraceIndexedFile, type TraceInspectionArea, type TraceInspectionFinding, type TraceInspectionReport, type TraceInspectionSeverity, type TraceInvestigationOptions, type TraceInvestigationResult, type TraceLiveAction, type TraceLiveActionKind, type TraceLiveAnalysisContext, type TraceLiveAnalyst, type TraceLiveBatch, type TraceLiveEvidence, type TraceLiveFinding, type TraceLiveLoop, type TraceLiveSeverity, type TraceSessionIndex, type TraceSessionIndexRow, type TraceStoreInvestigationOptions, type TraceStoreInvestigationResult, type TraceStreamEvent, type TraceStreamOptions, type TraceStreamReplayOptions, type TraceStreamSession, type TracesConfig, type TriggerPair, type UnavailableCapabilities, type UploadBackend, type UploadIdentity, type UploadItem, type UploadPlan, type UploadRecord, type UploadResult, type UploadState, type UserPromptInput, type VerifiableFinding, type VerifyFindingsCliArgs, type VerifyFindingsOptions, type VerifyFindingsRun, type WatchRunTargetOptions, ZERO_ROLL, type ZaiChatCallerOptions, addSpend, alreadyUploaded, analyzeAdoption, analyzeLiveBatch, analyzeLoopConvergence, analyzeReactions, analyzeSpans, analyzeSteeringChain, applyRedactor, assembleSessionBundle, assertSandboxReachable, buildFixPrompt, buildPolicyEvidenceRecord, buildRetryFixPrompt, buildSessionIndex, buildSessionIndexFromRows, buildSpanRunTree, buildTraceFindingPacket, capText, chatTrajectoryToSpans, classifyEvidenceOnlyPath, classifyLiveActions, classifyReaction, classifyVerdict, claudeActor, clipText, cmdReplayVerify, cmdReplayVerifyBatch, cmdVerifyFindings, codexActor, collectPolicyEvidence, collectSessionIndex, collectSessionSelection, collectSessionWorkflow, collectSessions, commandAnalyzer, commandRedactor, conformanceOfSpans, connectors, countScriptCommands, countSkillRunsJsonl, cwdMatchesSelection, defaultTraceLiveAnalysts, deriveFailureSignature, derivedImageTag, describeSessionRelationship, dockerImagePreparer, enumerateReplayableCases, environmentAttributes, environmentFromSpanAttributes, equivalentGitCwds, executeUpload, exportTraceEvidenceFile, exportTraceEvidenceRows, exportTraceEvidenceText, extractFixCommand, fileRunContextSupervisorRunReader, findContextRoot, findSessionTextLeaks, findSpanSourceFiles, findingReplayStep, findingTrajectoryId, forEachTreeNode, generateFixCommand, goldIncorrectSteps, haloAnalyzer, hashSessionBundleFiles, hodoscopeAnalyzer, httpJsonTransport, importCodeTraceBench, incompleteInputsNote, indexSessionIdsByTrace, inferRole, inferSpanKind, ingestCodeTraceBenchSteps, inspectSessionIndex, int, isChatTrajectory, isChatTrajectoryMessage, isFileRunContextDir, isSubmitAction, knownHarnesses, listAdapters, listSessionBundleFiles, loadState, loadTracesConfig, locateSessions, looksLikeAgentPrompt, mergeRolls, mergeTracesConfig, ms, normalizeRemote, otlpRowToSpan, outboundHash, parseCorpusFlag, parseIncorrectStepsSubject, parseIsoToEpochMs, parseObservationOutput, parseRecordedReturncode, parseReplayBatchArgs, parseReplayVerifyArgs, parseSession, parseSince, parseVerifyFindingsArgs, planTraceAgenticRoute, planUpload, primeAnalyzer, projectSessionBundle, readCoordinationLog, readFileRunContext, readFindingsFile, readJsonFile, readJsonl, readLabelEntries, readOtlpInput, readRunContextJournal, readRunContextSnapshot, readRunWatchSnapshot, readSessionBundleManifest, readSessionIndexFile, readSpanRunSnapshot, recordSessionCorruption, redactSpans, renderBatchReport, renderConformance, renderInspectionReport, renderRunContextSnapshot, renderRunWatchSnapshot, renderSpanRunSnapshot, renderValidation, renderVerifiedFindingsSection, replayBatchUsage, replayVerify, replayVerifyFinding, replayVerifyUsage, resolveAdapter, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, resolveOtlpInputFiles, resolveRepoAttrs, resolveRunContextDir, resolveRunWatchTarget, resolveSessionRepoAttrs, runCommand, runExternalAnalyzers, runFixLoop, runPipelines, runReplayBatch, runTotals, runTraceImprovement, runTraceInvestigation, runTraceStoreInvestigation, sandboxReplayBackend, saveReport, saveState, scanSessions, seededSample, selectAdapters, serializeInspectionReport, serializePolicyEvidence, serializeSessionIndex, serializeSpans, serializeTraceStreamEvent, sessionHash, sessionIdFromAttributes, sessionIntegrityAttributes, sessionTextSignatures, skippedAnalyses, span, spanRunTotals, stampEnvironmentAttrs, stampRepoAttrs, stampSessionIdentity, stampSessionIntegrity, stampSpanWorkdirRepoAttrs, streamSessions, summarizeOtlpExecution, summarizeSpanExecution, summarizeSpanStructure, takeJsonl, textIsSynthetic, toOpenInferenceSpan, toRuntimeStore, toTraceSpanEvents, tokens, totalAgenticFailureMessage, traceAgenticKinds, traceStreamEventsFromSpans, unavailableCapabilities, uploadKey, usd, userPromptSpan, validateOtlpSpans, validationExitCode, verifyFindings, verifyFindingsUsage, watchRunTarget, watchSessions, wrap, wrapActionForExec, writeHodoscopeInput, writeInspectionReportFile, writeOtlpFile, writePolicyEvidenceFile, writeSessionBundleManifest, writeSessionIndexFile, writeTraceEvidenceExportFile, writeTraceImprovementArtifacts, zaiChatCaller, zeroPricedCost };