agent-nuvira 3.3.1 → 3.3.4

package/dist/parity/observation.d.ts

@@ -0,0 +1,444 @@
+/**
+ * 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.
+ */
+import type { EngineMode } from '../learning/engine-router.js';
+import type { WireFinding } from '../findings/verdicts.js';
+import type { SurfaceId } from './surfaces.js';
+/** How a turn ended, in the taxonomy every surface already reports. */
+export type TurnStatus = 'completed' | 'failed' | 'refused';
+/**
+ * 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 declare function turnStatus(answer: {
+    ok?: boolean;
+    generationFailed?: boolean;
+}): TurnStatus;
+/** Volatile per-invocation values. Recorded for the failure report, never compared. */
+/**
+ * One tool call, as an observer sees it.
+ *
+ * Deliberately not a bare tool name. A call that SUCCEEDED on one surface and
+ * FAILED on another is not agreement, and comparing names alone would report it
+ * as a pass — which is the same class of mistake as the tool descriptions this
+ * repo has spent a workstream fixing (a call reported as done when it was not).
+ * `ok` is optional because a surface may report the call without an outcome yet
+ * (the `started` phase); an absent `ok` never equals `false`.
+ */
+export interface ToolCallObs {
+    tool: string;
+    ok?: boolean;
+}
+export interface ObservationNoise {
+    turnId?: string;
+    sessionId?: string;
+    at?: number;
+    durationMs?: number;
+    cwd?: string;
+    tokens?: number;
+}
+/**
+ * WS2 — the session debug log a surface produced for the turn, reduced to what
+ * the attachable header carries.
+ *
+ * `written` is separate from the backend on purpose: "this surface wrote no log"
+ * and "this surface wrote a log that names no backend" are different failures,
+ * and collapsing them would let a surface that produces NOTHING read as one that
+ * produces an honest `unknown`. The backend triple is what a bug report cannot
+ * be reconstructed without, so it is what is compared — the file's path, size
+ * and timestamps differ per run by construction (the same reason `turnId` and
+ * `at` are noise).
+ */
+export interface DebugLogObs {
+    /** True when the surface actually wrote a log file for this turn. */
+    written: boolean;
+    /** The provider named in the log's header (null = not named). */
+    provider: string | null;
+    /** The model named in the log's header. */
+    model: string | null;
+    /** The transport named in the log's header (`native`/`json`/`none`). */
+    transport: string | null;
+}
+/** The honest "this surface produced no log" value. Fresh each call. */
+export declare function noDebugLog(): DebugLogObs;
+/**
+ * WS3 — the span tree a surface exported, as its OTLP collector received it.
+ *
+ * WHY A COLLECTOR AND NOT A MOCK. The claim is "this surface ships its turn over
+ * OTLP", and only the wire can settle that: a mocked exporter proves the calls
+ * were made, not that a collector could read them. The driver boots a real
+ * loopback HTTP collector and reads the request bodies it received, so
+ * "exported" means spans that left the process and were parsed.
+ *
+ * WHY THE SPANS ARE SORTED. A collector receives spans in COMPLETION order
+ * (measured: a probe turn arrived model-less, tool, then turn), so comparing the
+ * arrival order would fail on a surface that merely closed its spans in a
+ * different sequence. The comparison is over the tree's SHAPE — the set of names
+ * and the parent→child edges — which is the part every surface must agree on.
+ *
+ * `traceId` and `remoteParent` are RECORDED, NOT COMPARED, and that is a stated
+ * decision rather than an oversight: they differ per run by construction, and a
+ * forked child legitimately continues a trace its parent began — where an
+ * in-process surface has no remote parent at all. Comparing them would report
+ * the child's correct behaviour as a divergence and force every other surface to
+ * invent a parent to match. They are kept for the failure report and for the
+ * scenario's own assertions (the child DOES join one trace), which is where a
+ * fact that is true of only one surface belongs.
+ */
+export interface OtelExportObs {
+    /** True when the collector received at least one span from this surface. */
+    exported: boolean;
+    /** Sorted span names received. The tree's vocabulary. */
+    spans: readonly string[];
+    /** Sorted `parent → child` name pairs. The tree's shape. */
+    edges: readonly string[];
+    /** How many `nuvira.turn` spans arrived (exactly one per turn, or the tree is wrong). */
+    turnSpans: number;
+    /** Sorted tool span names (`nuvira.tool.<name>`) — the calls that actually ran. */
+    toolSpans: readonly string[];
+    /** Every span received shares ONE trace id (the tree is one trace, not several). */
+    singleTrace: boolean;
+    /** The `service.name` the resource attributes carried (the SDK's own rendering). */
+    serviceName: string | null;
+    /** The trace id every span shares, or null. RECORDED, never compared. */
+    traceId: string | null;
+    /**
+     * The turn span's parent id when that parent is NOT in this collector — a
+     * genuine remote parent, i.e. this process continued another one's trace.
+     * RECORDED, never compared (see the interface note).
+     */
+    remoteParent: string | null;
+}
+/** The honest "this surface exported nothing" value. Fresh each call. */
+export declare function noOtelExport(): OtelExportObs;
+/**
+ * WS4 (#26) — the operator's tool hooks, as they were seen from OUTSIDE the
+ * surface: the hook the harness declared is a real command, and it recorded every
+ * payload it was handed.
+ *
+ * WHY THE HOOK DOES THE RECORDING. The claim is "every surface runs the
+ * operator's declared hook for a tool call, with the same payload, and honours a
+ * veto", and the only witness to that which is not the surface grading itself is
+ * the operator's own command. So the harness writes one hook script (see
+ * `src/parity/drivers.ts`), points it at a log file, and reads back the
+ * invocations it actually received — the same "read the artifact" rule the debug
+ * log and the OTLP collector follow.
+ *
+ * `vetoReported` and `vetoLeaked` ARE DERIVED FROM TWO INDEPENDENT WITNESSES, and
+ * that is why they are worth comparing: the hook says which tool it denied, and
+ * the SURFACE's own tool lifecycle says what happened to that call. A veto that
+ * reached the hook but not the loop reads as `vetoReported: false`; a verdict that
+ * was returned but ignored, so the tool ran anyway, reads as `vetoLeaked: true`.
+ * Either one alone would be a story told by one side.
+ *
+ * `surfacesSeen` is RECORDED, NEVER COMPARED, for the same reason `traceId` is:
+ * the label is the surface's own identity, so by construction it differs between
+ * the two observations being compared — and it is kept because "the hook was told
+ * WHICH surface called" is exactly the fact a per-turn policy needs, so the
+ * scenario asserts it per surface rather than comparing it across them.
+ */
+export interface ToolHooksObs {
+    /** Every hook invocation as `phase:tool`, sorted and deduplicated. */
+    invocations: readonly string[];
+    /** Tools a `before` hook VETOED, sorted. Empty when nothing was denied. */
+    denied: readonly string[];
+    /** Every denied call is reported by the surface as a FAILED call. */
+    vetoReported: boolean;
+    /** A denied tool ran anyway (its call reported success). Always false; a leak. */
+    vetoLeaked: boolean;
+    /** The surface labels the hook itself saw, sorted. RECORDED, never compared. */
+    surfacesSeen: readonly string[];
+}
+/** The honest "this surface ran no hook" value. Fresh each call. */
+export declare function noToolHooks(): ToolHooksObs;
+/**
+ * WS5 (#27) — the isolation a turn had, and what it changed.
+ *
+ * `asked` is the HARNESS's own declaration (the scenario asked for isolation) and
+ * the rest is the SURFACE's report, and keeping both is what makes the comparison
+ * mean something: a surface that ignored the request reports `isolated: false`
+ * against an `asked: true`, which is a divergence — whereas a field derived from
+ * the request alone could never disagree with itself. Five surfaces agreeing that
+ * no isolation happened when nobody asked would be agreement about nothing, which
+ * is why the scenario that declares `asked` is the only one that proves the row.
+ *
+ * `base` is RECORDED, NEVER COMPARED, for the same reason `traceId` is: it is a
+ * commit sha, so it differs per run by construction. It is kept because "the diff
+ * is against a real commit" is the fact the row is about, and a failure report
+ * that shows two different shas proves both runs were real.
+ */
+export interface IsolationObs {
+    /** True when the turn was asked to run isolated (the scenario declared it). */
+    asked: boolean;
+    /** True when the surface reported a turn that actually ran in a worktree. */
+    isolated: boolean;
+    /** Sorted paths the isolated turn changed, against its base commit. */
+    files: readonly string[];
+    /** True when the surface reported removing the worktree afterwards. */
+    removed: boolean;
+    /** The base commit the diff is against (`''` when there was none). RECORDED. */
+    base: string;
+}
+/** The honest "this turn was not isolated" value. Fresh each call. */
+export declare function noIsolation(): IsolationObs;
+/**
+ * WS5 (#27) — what a RESUMED turn replayed instead of paying for.
+ *
+ * Read from a SECOND turn against a record the FIRST one wrote, because "reuses
+ * unchanged steps instead of re-paying for every model call" is a claim about a
+ * pair of runs and cannot be observed in one. `modelCalls` here is the resumed
+ * turn's own count — the turn that is compared for everything else is the first
+ * one (a fully replayed turn reaches no model at all, and the runner refuses to
+ * compare a turn that never did).
+ *
+ * `asked`/`resuming` are separated so a failure says WHICH half broke: a surface
+ * that never opened a record reads as `resuming: false` while `asked: true`, and a
+ * surface that opened one but replayed nothing reads as `replayed: 0` with a
+ * `modelCalls` equal to the whole turn.
+ */
+export interface ResumeObs {
+    /** True when the harness asked this surface to resume (the scenario declared it). */
+    asked: boolean;
+    /** True when the surface reported a resume at all (it read a record). */
+    resuming: boolean;
+    /** Steps the resumed turn replayed from the record. */
+    replayed: number;
+    /** Model calls the RESUMED turn still made (0 = every step came from the record). */
+    modelCalls: number;
+    /** True when the resumed turn could write the record back for the next run. */
+    saved: boolean;
+}
+/** The honest "this turn was not resumed" value. Fresh each call. */
+export declare function noResume(): ResumeObs;
+/**
+ * WS6 (#28) — a DECLARED fault, and whether its effect is visible in this
+ * surface's own turn.
+ *
+ * WHY `took` IS DERIVED FROM THE OBSERVATION rather than read from a counter. The
+ * fault is declared for the whole run, and the claim is not "the harness fired a
+ * fault" (that is the harness grading itself) but "this surface's turn shows the
+ * consequence". For a provider fault that means the turn did NOT complete; for a
+ * tool fault it means the named call is reported FAILED. A surface that swallowed
+ * the fault reads `took: false` against every other surface's `true`, which is a
+ * divergence — and one that could not be seen any other way, because a swallowed
+ * fault leaves no other trace.
+ *
+ * The counter the injector keeps is real (`FaultInjector.fired`) and used in the
+ * seam's own tests, but it cannot cross the fork: the child is a separate process,
+ * so the parent has no injector to read. Deriving the effect per surface is what
+ * lets ONE field be compared on all five, the forked child included.
+ */
+export interface FaultObs {
+    /** True when the scenario declared a fault for this turn. */
+    asked: boolean;
+    /** The declared site (`provider`/`tool`/`ipc`), or null. */
+    site: string | null;
+    /** The declared kind (`error`/`malformed`/`unavailable`), or null. */
+    kind: string | null;
+    /** True when this surface's own turn shows the declared fault's effect. */
+    took: boolean;
+}
+/** The honest "no fault was declared" value. Fresh each call. */
+export declare function noFault(): FaultObs;
+/**
+ * One surface's view of one turn. Fields the surface does not report stay
+ * `undefined` — and `compare` treats "absent on one surface, present on another"
+ * as a difference, because a surface that cannot say which model served a turn
+ * is exactly the gap WS1-WS5 are closing.
+ */
+export interface TurnObservation {
+    surface: SurfaceId;
+    engine: EngineMode;
+    status: TurnStatus;
+    /**
+     * How many times this turn reached the model.
+     *
+     * EXACTLY ZERO IS NOT "no model needed" — it means the turn was served
+     * without one: a response-cache replay, or a surface that answered from a
+     * shortcut. Such a turn carries no routing, no tool loop and no work, so it
+     * cannot be evidence of parity in either direction. Recorded as a required
+     * field so a driver cannot forget to say, and refused by the runner rather
+     * than compared.
+     */
+    modelCalls: number;
+    /** Provider that served the turn (the child reports this on failure too). */
+    provider?: string;
+    model?: string;
+    transport?: 'native' | 'json' | 'none';
+    /** Tool calls in call order, with the outcome each surface reported. Order is part of the behaviour. */
+    toolCalls: readonly ToolCallObs[];
+    /**
+     * WS2 — the session debug log this surface wrote for the turn.
+     *
+     * REQUIRED, for the reason `modelCalls` and `findings` are: the capability is
+     * "every surface produces an attachable log whose header names the backend",
+     * and an optional field would let a surface that produces nothing go on
+     * reading as at-par. `noDebugLog()` is the honest answer when logging is off
+     * or the surface wrote nothing — the harness turns logging ON for the run, so
+     * a `written: false` there is a failure, not a neutral value.
+     */
+    debugLog: DebugLogObs;
+    /**
+     * WS3 — the span tree this surface exported over OTLP, as a real collector
+     * received it.
+     *
+     * REQUIRED, for the same reason `debugLog` and `modelCalls` are: the row is
+     * "every surface ships the turn's spans", and an optional field would let a
+     * surface that exports nothing go on reading as at-par. The harness turns
+     * export ON for the run and hands every surface a collector, so `exported:
+     * false` there is a failure rather than a neutral value.
+     */
+    otel: OtelExportObs;
+    /**
+     * WS4 — the operator's tool hooks this surface ran for the turn.
+     *
+     * REQUIRED, for the reason `debugLog` and `otel` are: the row is "every surface
+     * runs the operator's declared hooks, and honours a veto", and an optional field
+     * would let a surface that fires nothing go on reading as at-par. The harness
+     * declares the hooks for the scenario and always hands the driver a log to
+     * read, so `invocations: []` on a scenario that declared hooks is a failure
+     * rather than a neutral value.
+     */
+    hooks: ToolHooksObs;
+    /**
+     * WS5 (#27) — the isolation this turn had, and what it changed.
+     *
+     * REQUIRED, for the reason `otel` and `hooks` are: the row is "an investigation
+     * can be isolated and returns a diff against the base", and an optional field
+     * would let a surface that runs in the real tree go on reading as at-par. The
+     * harness asks for isolation on the scenario that declares it, so `isolated:
+     * false` there is a failure rather than a neutral value.
+     */
+    isolation: IsolationObs;
+    /**
+     * WS5 (#27) — what this surface's resumed turn replayed instead of paying for.
+     *
+     * REQUIRED, for the same reason: the row is "a resumed run reuses unchanged
+     * steps", and a surface that quietly paid for every model call must not read as
+     * at-par. The driver wrapper runs the second turn and replaces this field with
+     * what the RESUMED turn did (`src/parity/drivers.ts`), so an ordinary scenario
+     * carries the honest "not asked" value rather than a missing one.
+     */
+    resume: ResumeObs;
+    /**
+     * WS6 (#28) — the fault this turn had declared for it, and whether the turn
+     * shows its effect.
+     *
+     * REQUIRED, for the reason `otel` and `hooks` are: the row is "an injected
+     * failure is reported honestly on every surface", and an optional field would
+     * let a surface that never saw the fault go on reading as at-par. A scenario
+     * that declares nothing carries the honest "not asked" value.
+     */
+    fault: FaultObs;
+    /**
+     * WS1 — the findings the turn recorded, in call order, in the shared wire
+     * form (`findings/verdicts.ts`).
+     *
+     * REQUIRED, for the reason `modelCalls` is: a surface that cannot report its
+     * verdicts is precisely the gap this row closes, and an optional field would
+     * let it go on being silent while still reading as at-par. `[]` is the honest
+     * answer for a turn that recorded none — not the same statement as "this
+     * surface does not say". Compared in ORDER and by VALUE, because the verdict
+     * (CONFIRMED vs PLAUSIBLE) and the evidence behind it are the whole point: two
+     * surfaces agreeing that a finding exists while disagreeing about whether it
+     * was checked have not agreed on anything.
+     */
+    findings: readonly WireFinding[];
+    /** Terminal answer text. Compared exactly: parity runs use one stub provider. */
+    answer?: string;
+    /** Typed refusal code (no provider, unreachable backend, tools on a non-tool provider). */
+    refusalCode?: string;
+    /** Typed error code for a failure that is not a refusal. */
+    errorCode?: string;
+    noise?: ObservationNoise;
+}
+/** The compared projection: no identity, no timing. */
+export interface ComparableObservation {
+    engine: EngineMode;
+    status: TurnStatus;
+    modelCalls: number;
+    provider: string | null;
+    model: string | null;
+    transport: string | null;
+    toolCalls: readonly ToolCallObs[];
+    findings: readonly WireFinding[];
+    debugLog: DebugLogObs;
+    otel: OtelExportObs;
+    hooks: ToolHooksObs;
+    isolation: IsolationObs;
+    resume: ResumeObs;
+    fault: FaultObs;
+    answer: string | null;
+    refusalCode: string | null;
+    errorCode: string | null;
+}
+/** Strip everything that legitimately differs between two runs of the same turn. */
+export declare function comparableOf(observation: TurnObservation): ComparableObservation;
+/** Stable serialisation, so a failure report can show both sides and their digest. */
+export declare function serialize(value: ComparableObservation): string;
+/**
+ * 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 declare function compare(a: TurnObservation, b: TurnObservation): string[];
+/** True when the two observations are interchangeable as far as a user can tell. */
+export declare function isAtPar(a: TurnObservation, b: TurnObservation): boolean;
+/**
+ * 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 declare function reachedModel(observation: TurnObservation): boolean;
+/**
+ * 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 declare function reportParityFailure(observations: readonly TurnObservation[], differences: readonly string[]): string;
+//# sourceMappingURL=observation.d.ts.map

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

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