agent-nuvira 3.3.3 → 3.3.4

package/dist/parity/observation.js

@@ -0,0 +1,333 @@
+/**
+ * WS0 (#22) — what "the same experience on every surface" means, in code.
+ *
+ * A parity test is only worth having if its comparison can FAIL for the right
+ * reason and PASS for the right reason. Two traps:
+ *
+ *   1. Comparing everything. Turn ids, timestamps, durations, the working
+ *      directory and token counts differ on every invocation by construction, so
+ *      a byte comparison would fail for surfaces that behave identically and
+ *      teach everyone to ignore it.
+ *   2. Comparing nothing that matters. If the projection drops the tool calls
+ *      and the error taxonomy, every surface "passes" while one of them silently
+ *      answers without touching a file.
+ *
+ * So the projection here is deliberate: WHAT THE TURN DID (status, the ordered
+ * tool calls, the terminal answer, the typed refusal/error code) and WHICH
+ * BACKEND DID IT (provider, model, transport) are compared; identity and timing
+ * are not. `compare` names each difference and which surface it came from,
+ * because a parity failure that does not say "gateway" is not actionable.
+ *
+ * A THIRD TRAP, found by measurement rather than reasoning: comparing turns that
+ * never reached a model. The response cache is shared and on-disk
+ * (`src/context/cache.ts`, enabled for `answerOnce` at `src/cli/chat.ts:690`),
+ * so an identical message on the second surface of a run is served from the
+ * first one's cache entry — same answer, no model call, no tool lifecycle. Two
+ * such replays agree perfectly and mean nothing. `modelCalls` records whether
+ * the turn was real, and both `compare` and the runner refuse to read a zero as
+ * agreement.
+ */
+/**
+ * The turn's status, read the same way for every surface. WS6 (#28).
+ *
+ * `generationFailed` OUTRANKS `ok` whenever both are present, and a declared
+ * provider fault is why this exists. The dashboard console and the command report
+ * `ok` for "the request was served" while carrying `generationFailed: true` for
+ * "the model produced no answer" — two different facts, and the first version of
+ * this projection read `ok` first, so a backend that failed every call was called
+ * a COMPLETION on two of the five surfaces while the CLI and the gateway called it
+ * a failure.
+ *
+ * That divergence was invisible until a fault row existed, because no earlier
+ * scenario ever produced a failed generation: every other row either succeeds or
+ * fails at the TOOL level, and a failed tool still leaves a completed turn. What
+ * the surfaces must agree on is the TURN's outcome, so that is what is read — and
+ * a surface that reports neither flag is read as completed, which is the honest
+ * default for a surface that produced an answer.
+ */
+export function turnStatus(answer) {
+    if (typeof answer.generationFailed === 'boolean')
+        return answer.generationFailed ? 'failed' : 'completed';
+    return answer.ok === false ? 'failed' : 'completed';
+}
+/** The honest "this surface produced no log" value. Fresh each call. */
+export function noDebugLog() {
+    return { written: false, provider: null, model: null, transport: null };
+}
+/** The honest "this surface exported nothing" value. Fresh each call. */
+export function noOtelExport() {
+    return {
+        exported: false,
+        spans: [],
+        edges: [],
+        turnSpans: 0,
+        toolSpans: [],
+        singleTrace: false,
+        serviceName: null,
+        traceId: null,
+        remoteParent: null,
+    };
+}
+/** The honest "this surface ran no hook" value. Fresh each call. */
+export function noToolHooks() {
+    return { invocations: [], denied: [], vetoReported: false, vetoLeaked: false, surfacesSeen: [] };
+}
+/** The honest "this turn was not isolated" value. Fresh each call. */
+export function noIsolation() {
+    return { asked: false, isolated: false, files: [], removed: false, base: '' };
+}
+/** The honest "this turn was not resumed" value. Fresh each call. */
+export function noResume() {
+    return { asked: false, resuming: false, replayed: 0, modelCalls: 0, saved: false };
+}
+/** The honest "no fault was declared" value. Fresh each call. */
+export function noFault() {
+    return { asked: false, site: null, kind: null, took: false };
+}
+/** Strip everything that legitimately differs between two runs of the same turn. */
+export function comparableOf(observation) {
+    return {
+        engine: observation.engine,
+        status: observation.status,
+        modelCalls: observation.modelCalls,
+        provider: observation.provider ?? null,
+        model: observation.model ?? null,
+        transport: observation.transport ?? null,
+        toolCalls: observation.toolCalls.map((call) => ({ tool: call.tool, ...(call.ok === undefined ? {} : { ok: call.ok }) })),
+        // Absent at runtime is normalised to `[]` rather than compared as a
+        // difference: the field is required by the type, and a driver that forgot it
+        // should fail the typecheck, not silently diverge at runtime.
+        findings: observation.findings ?? [],
+        debugLog: observation.debugLog ?? noDebugLog(),
+        otel: observation.otel ?? noOtelExport(),
+        hooks: observation.hooks ?? noToolHooks(),
+        isolation: observation.isolation ?? noIsolation(),
+        resume: observation.resume ?? noResume(),
+        fault: observation.fault ?? noFault(),
+        answer: observation.answer ?? null,
+        refusalCode: observation.refusalCode ?? null,
+        errorCode: observation.errorCode ?? null,
+    };
+}
+/** Stable serialisation, so a failure report can show both sides and their digest. */
+export function serialize(value) {
+    return JSON.stringify(value);
+}
+function show(value) {
+    return value === null ? '(none)' : JSON.stringify(value);
+}
+/** How one call reads in a failure report. */
+function showCall(call) {
+    if (call.ok === undefined)
+        return call.tool;
+    return call.ok ? `${call.tool}(ok)` : `${call.tool}(FAILED)`;
+}
+/** Same tool, same outcome. An absent outcome equals only an absent outcome. */
+function sameCall(a, b) {
+    return a.tool === b.tool && a.ok === b.ok;
+}
+/**
+ * Every difference between two observations, each named with the field and both
+ * surfaces. Empty array means parity for this pair.
+ *
+ * Deliberately granular on `toolCalls`: "both called 3 tools" is not the
+ * question; "which call came first and did the other one make it at all" is.
+ */
+export function compare(a, b) {
+    const left = comparableOf(a);
+    const right = comparableOf(b);
+    const differences = [];
+    const who = `${a.surface} vs ${b.surface}`;
+    const scalars = [
+        'engine',
+        'status',
+        'modelCalls',
+        'provider',
+        'model',
+        'transport',
+        'answer',
+        'refusalCode',
+        'errorCode',
+    ];
+    for (const field of scalars) {
+        const l = left[field];
+        const r = right[field];
+        if (l !== r) {
+            differences.push(`${who}: ${field} differs — ${show(l === null ? null : String(l))} vs ${show(r === null ? null : String(r))}`);
+        }
+    }
+    const max = Math.max(left.toolCalls.length, right.toolCalls.length);
+    for (let i = 0; i < max; i += 1) {
+        const l = left.toolCalls[i];
+        const r = right.toolCalls[i];
+        if (l && r && sameCall(l, r))
+            continue;
+        differences.push(l === undefined
+            ? `${who}: ${b.surface} made an extra call at #${i + 1} — ${showCall(r)}`
+            : r === undefined
+                ? `${who}: ${a.surface} made a call the other surface did not, at #${i + 1} — ${showCall(l)}`
+                : `${who}: tool call #${i + 1} differs — ${showCall(l)} vs ${showCall(r)}`);
+    }
+    // WS1 — findings, in order, by value. The VERDICT is part of the value: two
+    // surfaces that both recorded the claim while one called it CONFIRMED and the
+    // other PLAUSIBLE have not agreed, and the evidence decides which is honest.
+    const maxFindings = Math.max(left.findings.length, right.findings.length);
+    for (let i = 0; i < maxFindings; i += 1) {
+        const l = left.findings[i];
+        const r = right.findings[i];
+        if (l && r && JSON.stringify(l) === JSON.stringify(r))
+            continue;
+        const say = (f) => f === undefined ? '(none)' : `${show(f.claim)} [${f.verdict}]`;
+        differences.push(l === undefined
+            ? `${who}: ${b.surface} recorded a finding the other surface did not, at #${i + 1} — ${say(r)}`
+            : r === undefined
+                ? `${who}: ${a.surface} recorded a finding the other surface did not, at #${i + 1} — ${say(l)}`
+                : `${who}: finding #${i + 1} differs — ${say(l)} vs ${say(r)}`);
+    }
+    // WS2 — the session debug log's header. Compared field by field (rather than
+    // by object identity) so a failure names WHICH part of the header diverged:
+    // "one surface wrote no log" and "one named a different model" are very
+    // different bugs, and a bare `debugLog differs` would hide that.
+    const debugFields = ['written', 'provider', 'model', 'transport'];
+    for (const field of debugFields) {
+        const l = left.debugLog[field];
+        const r = right.debugLog[field];
+        if (l !== r) {
+            differences.push(`${who}: debugLog.${field} differs — ${show(l === null ? null : String(l))} vs ${show(r === null ? null : String(r))}`);
+        }
+    }
+    // WS3 — the exported span tree. The scalars (`turnSpans`, `singleTrace`,
+    // `exported`, `serviceName`) are called out individually so a failure says
+    // WHICH claim broke ("no spans arrived" vs "two turn spans, not one" vs "the
+    // spans are not one trace"), and the two list-shaped fields are compared as
+    // sorted lists so a failure shows both sides rather than "they differ".
+    const otelScalars = [
+        'exported',
+        'turnSpans',
+        'singleTrace',
+        'serviceName',
+    ];
+    for (const field of otelScalars) {
+        const l = left.otel[field];
+        const r = right.otel[field];
+        if (l !== r) {
+            differences.push(`${who}: otel.${field} differs — ${show(l === null ? null : String(l))} vs ${show(r === null ? null : String(r))}`);
+        }
+    }
+    const otelLists = ['spans', 'edges', 'toolSpans'];
+    for (const field of otelLists) {
+        const l = left.otel[field].join(', ');
+        const r = right.otel[field].join(', ');
+        if (l !== r) {
+            differences.push(`${who}: otel.${field} differs — [${l}] vs [${r}]`);
+        }
+    }
+    // WS4 — the operator's hooks. The scalars are separate so a failure says WHICH
+    // claim broke ("a surface never ran the hook" vs "a veto was ignored, so the
+    // tool ran anyway"), and the list-shaped fields are compared as sorted lists so
+    // a failure shows both sides. `surfacesSeen` is deliberately absent: it holds
+    // each surface's own label, which differs between the two observations by
+    // construction (see `ToolHooksObs`).
+    const hookScalars = ['vetoReported', 'vetoLeaked'];
+    for (const field of hookScalars) {
+        const l = left.hooks[field];
+        const r = right.hooks[field];
+        if (l !== r) {
+            differences.push(`${who}: hooks.${field} differs — ${String(l)} vs ${String(r)}`);
+        }
+    }
+    const hookLists = ['invocations', 'denied'];
+    for (const field of hookLists) {
+        const l = left.hooks[field].join(', ');
+        const r = right.hooks[field].join(', ');
+        if (l !== r) {
+            differences.push(`${who}: hooks.${field} differs — [${l}] vs [${r}]`);
+        }
+    }
+    // WS5 (#27) — isolation. `asked` is compared like any other field on purpose:
+    // the scenario declares it, so both sides carrying the SAME declaration is the
+    // proof that the value compared is the request that was made, and `isolated`
+    // against it is what catches a surface that ignored it. `base` is deliberately
+    // absent (a per-run commit sha — see `IsolationObs`).
+    const isolationScalars = [
+        'asked',
+        'isolated',
+        'removed',
+    ];
+    for (const field of isolationScalars) {
+        const l = left.isolation[field];
+        const r = right.isolation[field];
+        if (l !== r) {
+            differences.push(`${who}: isolation.${field} differs — ${String(l)} vs ${String(r)}`);
+        }
+    }
+    const isolationFiles = left.isolation.files.join(', ');
+    if (isolationFiles !== right.isolation.files.join(', ')) {
+        differences.push(`${who}: isolation.files differs — [${isolationFiles}] vs [${right.isolation.files.join(', ')}]`);
+    }
+    // WS5 (#27) — resume. Field by field, so a failure says WHICH half broke: a
+    // surface that never opened a record (`resuming`) is a different bug from one
+    // that opened it and replayed nothing (`replayed`, `modelCalls`), and reporting
+    // both as "resume differs" would hide that.
+    const resumeFields = [
+        'asked',
+        'resuming',
+        'replayed',
+        'modelCalls',
+        'saved',
+    ];
+    for (const field of resumeFields) {
+        const l = left.resume[field];
+        const r = right.resume[field];
+        if (l !== r) {
+            differences.push(`${who}: resume.${field} differs — ${show(String(l))} vs ${show(String(r))}`);
+        }
+    }
+    // WS6 (#28) — the declared fault. `asked`/`site`/`kind` are the declaration
+    // (both sides must have been told the same thing for the comparison to mean
+    // anything), and `took` is what catches the failure mode the row exists for: a
+    // surface whose turn shows no sign of a fault it was definitely given.
+    const faultFields = ['asked', 'site', 'kind', 'took'];
+    for (const field of faultFields) {
+        const l = left.fault[field];
+        const r = right.fault[field];
+        if (l !== r) {
+            differences.push(`${who}: fault.${field} differs — ${show(l === null ? null : String(l))} vs ${show(r === null ? null : String(r))}`);
+        }
+    }
+    return differences;
+}
+/** True when the two observations are interchangeable as far as a user can tell. */
+export function isAtPar(a, b) {
+    return compare(a, b).length === 0;
+}
+/**
+ * True when the turn actually reached a model.
+ *
+ * Separate from `status === 'completed'` on purpose: a cache replay completes.
+ * A caller that wants a parity verdict must require this on every surface (the
+ * runner does), and a caller that wants to prove a surface *did* the work must
+ * assert it rather than infer it from an answer it likes the look of.
+ */
+export function reachedModel(observation) {
+    return observation.modelCalls > 0;
+}
+/**
+ * A one-block report for a failing parity case: both projections plus the named
+ * differences. Kept here rather than in the test so the wording is consistent
+ * across every workstream that adds a case.
+ */
+export function reportParityFailure(observations, differences) {
+    const lines = ['cross-surface parity FAILED', ''];
+    for (const observation of observations) {
+        lines.push(`  ${observation.surface} [${observation.engine}] ${serialize(comparableOf(observation))}`);
+        if (observation.noise && Object.keys(observation.noise).length > 0) {
+            lines.push(`    noise: ${JSON.stringify(observation.noise)}`);
+        }
+    }
+    lines.push('', 'differences:');
+    for (const difference of differences)
+        lines.push(`  - ${difference}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=observation.js.map

package/dist/parity/observation.js.map

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

package/dist/parity/scenarios.d.ts

@@ -0,0 +1,229 @@
+/**
+ * WS0 (#22) — one scenario, every surface, one verdict.
+ *
+ * The registry (`surfaces.ts`) answers "which surfaces exist and what do they
+ * run through". This module answers the harder question: did they behave the
+ * same, and is the verdict trustworthy.
+ *
+ * THREE RULES, each closing a way a parity test lies:
+ *
+ *   1. STUB DEPTH MUST BE COMPARABLE. Every driver records where its stub sits.
+ *      `provider` (a stub provider object) and `transport` (a real provider
+ *      object talking to a stub SERVER — the forked subagent child) both run the
+ *      real turn code end to end, so they are ONE comparable class; folding them
+ *      together is what makes the child readable against the in-process
+ *      surfaces. `engine` replaces the very behaviour under test, so it never
+ *      compares with anything, itself included. A run that would have to compare
+ *      incomparable depths is refused rather than answered.
+ *
+ *   2. SKIPPED SURFACES ARE NAMED. A surface that cannot be driven appears in
+ *      `skipped` with the reason it is missing. Silence is how a harness ends up
+ *      "passing" for months while covering one surface.
+ *
+ *   3. TWO SURFACES IS THE MINIMUM. One available driver is not a parity run; it
+ *      is a smoke test wearing a parity label. That case reports
+ *      `insufficient`, never `at-par`.
+ *
+ *   4. THE TURN MUST HAVE REACHED A MODEL. The response cache is shared and
+ *      enabled on the `answerOnce` path, so the second surface of a run can be
+ *      served from the first one's entry — same answer, no model call, no tool
+ *      lifecycle, and a flawless "agreement" between two replays that proves
+ *      nothing. Measured, not hypothetical: before this rule existed, the second
+ *      surface of every two-driver run was a cache hit (the drivers now isolate
+ *      the cache per turn as well — belt and braces, because either guard alone
+ *      would be one edit away from being removed).
+ *      A zero is refused as `unreached-model` rather than compared.
+ *
+ * Pure by construction: no `fs`, no `vi`, no process env — which is what lets
+ * both the test suite and `nuvira parity run` import it. The drivers that
+ * actually drive a turn live in `./drivers.ts` (transport depth, a loopback stub
+ * server), so the CLI and CI run the SAME mechanism instead of two copies that
+ * could disagree.
+ */
+import { type TurnObservation } from './observation.js';
+import type { SurfaceId } from './surfaces.js';
+import type { FaultPlan } from '../runtime/fault-injection.js';
+/** What one parity case asks every surface to do. */
+export interface ParityScenario {
+    id: string;
+    /** The user message every surface receives, verbatim. */
+    message: string;
+    /**
+     * The tool the stub provider asks for on its FIRST model call. Absent means
+     * the scenario is a plain completion with no tool use.
+     */
+    toolCall?: {
+        tool: string;
+        args: Record<string, unknown>;
+    };
+    /** The terminal answer the stub provider returns once the tool work is done. */
+    answer: string;
+    /** Files the scenario expects to exist, as `path` → contents, for a deterministic tool result. */
+    fixtures?: Record<string, string>;
+    /**
+     * WS4 (#26) — the operator's tool hooks this scenario asks the harness to
+     * DECLARE for its turn.
+     *
+     * A scenario field rather than a harness-wide setting, because a hook changes
+     * what the turn does: declaring one for every scenario would make the earlier
+     * cases measure a different system than the one they were written against, and
+     * the harness cannot tell a deliberate declaration from a leftover. Absent means
+     * no hook is declared, which is the default the surfaces must also be correct
+     * under.
+     *
+     * This is DATA, not a command: the harness writes the hook script itself (see
+     * `src/parity/drivers.ts`) and the surface runs it the way an operator's own
+     * hook would be run — a real process, a real pipe, the payload as JSON on stdin.
+     */
+    hooks?: {
+        /** The phases to declare a hook for. The harness declares one command per phase. */
+        phases: readonly ('before' | 'after' | 'failed')[];
+        /** Tool names a `before` hook VETOES. Absent or empty = the hook observes only. */
+        deny?: readonly string[];
+    };
+    /**
+     * WS5 (#27) — ask this turn to run in its own git worktree and report the diff
+     * against its base commit.
+     *
+     * A scenario field rather than a harness-wide setting, for the same reason the
+     * hooks are: isolation CHANGES where the turn writes, so declaring it for every
+     * scenario would make the earlier cases measure a different system than the one
+     * they were written against. Absent means no isolation is asked for — the
+     * default every surface must also be correct under.
+     *
+     * The harness declares it through `NUVIRA_ISOLATE`, which is how a surface with
+     * no command line (the dashboard server, the gateway, the forked child) is
+     * asked, so ONE declaration covers all five rather than five different flags.
+     */
+    isolation?: boolean;
+    /**
+     * WS5 (#27) — ask this turn to RESUME: replay the steps of a previous run of the
+     * same ask whose input is unchanged, instead of paying for them again.
+     *
+     * The driver runs the scenario TWICE — once to write the record and once to
+     * replay it — and reports what the second turn avoided, because the claim is
+     * about a pair of runs and one turn cannot show it (see `ResumeObs`).
+     */
+    resume?: boolean;
+    /**
+     * WS6 (#28) — the fault this turn is run under.
+     *
+     * TWO PATHS, and which one is taken depends on the SITE, because each proves a
+     * different half of the claim:
+     *
+     *   - `provider` — the harness's own loopback stub answers 500 / malformed JSON
+     *     / 503. No production seam is involved, the REAL adapter's error mapping
+     *     runs, and the model call still happens (so the runner's "the turn must have
+     *     reached a model" rule holds and the refusal cannot hide a surface that was
+     *     never driven). This is where a provider fault is proven, because a real
+     *     outage reaches a surface through the adapter, not through this repo.
+     *   - `tool` / `ipc` — the DECLARED seam (`NUVIRA_INJECT_FAULT`, see
+     *     `src/runtime/fault-injection.ts`) is armed for the turn, so the fault is
+     *     injected by the running agent itself. That is the path that proves the seam
+     *     is honoured on EVERY surface, the forked child included — the child reads
+     *     the same declaration out of the environment it inherited.
+     *
+     * A scenario field rather than a harness-wide setting, for the same reason the
+     * hooks and isolation are: a fault changes what the turn does, so declaring one
+     * for every scenario would make the earlier cases measure a different system than
+     * the one they were written against. Absent means no fault is declared — the
+     * default every surface must also be correct under.
+     */
+    fault?: FaultPlan;
+}
+/**
+ * Where a driver's stub sits. Only equal depths may be compared.
+ *
+ *  - `provider`  — the real turn code runs end to end and only the model I/O is
+ *                  replaced. The strongest and the default for parity work.
+ *  - `transport` — a real provider object talks to a stub server (subagent IPC).
+ *                  Comparable with `provider`: both run the real turn code end
+ *                  to end, only the model I/O is replaced. Kept distinct so the
+ *                  distinction stays a stated decision rather than an accident.
+ *  - `engine`    — the engine itself is replaced (a fake `answerOnce`). Only good
+ *                  for exercising a surface's own plumbing; never for behaviour
+ *                  parity, and refused even against another `engine` stub.
+ */
+export type StubDepth = 'provider' | 'transport' | 'engine';
+/** A way to drive one surface through one scenario. */
+export interface ParityDriver {
+    surface: SurfaceId;
+    depth: StubDepth;
+    /** False when this surface cannot be driven yet; `blockedBy` must then say why. */
+    available: boolean;
+    /** Required when `available` is false: what is missing, concretely. */
+    blockedBy?: string;
+    /** Drives the turn and returns what an observer could see. */
+    run(scenario: ParityScenario): Promise<TurnObservation>;
+}
+/** A surface that was not driven, and why. Never dropped silently. */
+export interface SkippedSurface {
+    surface: SurfaceId;
+    reason: string;
+}
+export interface DepthMismatch {
+    kind: 'depth-mismatch';
+    depths: Array<{
+        surface: SurfaceId;
+        depth: StubDepth;
+    }>;
+    message: string;
+}
+export interface InsufficientCoverage {
+    kind: 'insufficient-coverage';
+    available: SurfaceId[];
+    message: string;
+}
+/**
+ * At least one surface's turn never reached a model, so nothing was compared.
+ *
+ * Distinct from a divergence: a replay and a real turn say nothing about each
+ * other, and reporting either as a difference would be as wrong as reporting
+ * them as agreement.
+ */
+export interface UnreachedModel {
+    kind: 'unreached-model';
+    /** Surfaces whose turn completed without a single model call. */
+    surfaces: SurfaceId[];
+    message: string;
+}
+export interface ParityRun {
+    scenario: string;
+    /** The depth compared, when a comparison happened. */
+    depth: StubDepth | null;
+    /** Observations in driver order, for the failure report. */
+    observations: TurnObservation[];
+    /** Named differences against the first observation. Empty means every surface agreed. */
+    differences: string[];
+    skipped: SkippedSurface[];
+    /** `at-par` · `divergent` · `not-run` (with `refusal` explaining why). */
+    verdict: 'at-par' | 'divergent' | 'not-run';
+    refusal?: DepthMismatch | InsufficientCoverage | UnreachedModel;
+}
+/**
+ * Drive one scenario through every available driver and compare the results.
+ *
+ * Order matters only for the report: the first available driver is the baseline.
+ * Driver order is the caller's, so a scenario can pin a baseline deliberately.
+ */
+export declare function runParityScenario(scenario: ParityScenario, drivers: readonly ParityDriver[]): Promise<ParityRun>;
+/**
+ * WS6 (#28) — the fields a FAULT row is compared on: what the turn was given, and
+ * whether it reported the consequence.
+ *
+ * `status` and the fault's own `asked`/`site`/`kind` say both surfaces were told
+ * the same thing and ended the same way; `took` is the load-bearing one, because a
+ * surface that SWALLOWED the fault — completed a turn the backend never served, or
+ * reported an injected tool failure as a success — reads `took: false` against
+ * every other surface's `true`. A swallowed fault leaves no other trace, which is
+ * why it is a compared field and not something a test reads off one surface.
+ *
+ * Deliberately absent: `answer`, `errorCode`, `provider`/`transport`/`model`,
+ * `debugLog`, `otel`, `modelCalls` and `toolCalls`. Each of those legitimately
+ * differs under a fatal fault (a messaging surface has no bubble to fill; a child
+ * announces its transport before it fails; the last attempt a debug header names
+ * is the fallback, not the provider that errored). They are still recorded on the
+ * observation for the failure report — only the comparison excludes them.
+ */
+export declare function compareFaultHonesty(a: TurnObservation, b: TurnObservation): string[];
+//# sourceMappingURL=scenarios.d.ts.map

package/dist/parity/scenarios.d.ts.map

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