agentfootprint 10.3.0 → 10.3.1

package/dist/types/lib/bug-report/envelope.d.ts

@@ -1,80 +0,0 @@
-/**
- * stampConversation — put the bundle's evidence in the archive contract, or
- * say in one sentence why it could not be.
- *
- * The repo has ONE archive contract (`RecordingEnvelope`) and several
- * presentations over it. This bundle used to be an exception: it packed a bare
- * `recording.json` plus an `environment.json` that repeated the producer facts
- * the envelope already stamps, so the same two versions were written by two
- * different pieces of code with no relationship between them. This is the fold
- * — the envelope is BUILT here, never re-implemented, so every rule it enforces
- * (identity is never invented, `droppedEvents` is proven or refused, an
- * incomplete recording gets no `endedAt`) arrives whole.
- *
- * ## Why a refusal is a return value here, not a throw
- *
- * `persistRecording` throws when a run fact is indeterminate, and it is right
- * to: its caller asked for an ARCHIVE, and an archive stamped with a guess is
- * worse than none. A bug report's caller asked for something else — the
- * evidence, in a zip, so a maintainer can open it. Throwing would leave that
- * person with no bundle at all because the library could not name a start time.
- *
- * So the refusal travels instead of stopping the export: this returns the
- * REASON, the bundle carries the bare recording under its own honest name, and
- * the manifest states which fact was missing and the one line that supplies it.
- * Nothing is stamped that was not known — which is the rule the throw exists to
- * keep — and the report still gets filed.
- *
- * @internal Not a public export; `exportBugReport` is the door.
- */
-import { type RecordingEnvelope, type RecordingSource } from '../../recorders/observability/recordingEnvelope.js';
-import type { BugReportRunFacts } from './types.js';
-/**
- * One recording, plus the one thing only the CALL SITE knows about it: whether
- * the thing we were handed can count its own dropped events.
- */
-export interface EnvelopeSource {
-    /** What `buildRecordingEnvelope` reads: a live handle, or a bare recording. */
-    readonly source: RecordingSource;
-    /**
-     * `true` for a live `recordRun` handle — it counts what the `maxEvents` cap
-     * discarded, so nothing the caller states may override it.
-     */
-    readonly countsDrops: boolean;
-}
-/**
- * The result for ONE conversation: every recording enveloped, or none of them
- * and the reason.
- *
- * All-or-nothing on purpose. A conversation file holding two envelopes and one
- * bare recording would need a reader to check each entry's shape before it
- * could read any of them, and a file whose shape depends on its contents is the
- * kind of archive this program exists to stop producing.
- */
-export interface StampedConversation {
-    /** In the recordings' own order. Absent when {@link refusal} is present. */
-    readonly envelopes?: readonly RecordingEnvelope[];
-    /** One sentence naming the missing fact and how to supply it. */
-    readonly refusal?: string;
-    /**
-     * The envelope field that could not be determined — `'complete'` when the
-     * reporter stated no run facts at all.
-     *
-     * The caller needs it to know whether the fix is even available at this door:
-     * `complete` and `droppedEvents` are stated HERE, while `startedAt` and the
-     * identity fields are read from the recording's own events, so a refusal
-     * naming one of those has to be fixed at recording time.
-     */
-    readonly field?: string;
-}
-/**
- * Envelope every recording of one conversation.
- *
- * @param sources  the conversation's recordings, in order, each with whether it
- *                 can prove its own drop count.
- * @param facts    what the reporter stated. `undefined` — the default, since
- *                 `run` is optional on both entry points — is itself a refusal
- *                 reason, and a named one.
- */
-export declare function stampConversation(sources: readonly EnvelopeSource[], facts: BugReportRunFacts | undefined): StampedConversation;
-//# sourceMappingURL=envelope.d.ts.map

package/dist/types/lib/bug-report/envelope.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../../../src/lib/bug-report/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,oDAAoD,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAClD,iEAAiE;IACjE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,KAAK,EAAE,iBAAiB,GAAG,SAAS,GACnC,mBAAmB,CAoCrB"}

package/dist/types/lib/bug-report/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/bug-report/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAChE,YAAY,EACV,SAAS,EACT,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,aAAa,EACb,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/types/lib/bug-report/transcript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../../src/lib/bug-report/transcript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AASH,4CAA4C;AAC5C,MAAM,MAAM,cAAc,GACtB;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB;;;4DAGwD;IACxD,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEN,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;CACtC;AAED,8CAA8C;AAC9C,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;CAC3C;AAgBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,UAAU,GAAG,SAAS,CAsFnF"}

package/dist/types/lib/bug-report/types.d.ts

@@ -1,294 +0,0 @@
-/**
- * bug-report — the types a bug report is made of.
- *
- * Two of them are the point of the whole sub-library:
- *
- *   {@link BugReportUnit}     the SELECTABLE piece. A reporter consents to
- *                             units, not to a blob.
- *   {@link BugReportManifest} the honest statement of what a bundle contains
- *                             AND what it deliberately leaves out.
- */
-import type { Recording, RunRecorder } from '../../recorders/observability/recordRun.js';
-import type { Runner } from '../../core/runner.js';
-/**
- * Anything a bug report can be built from.
- *
- * - a {@link Recording} — the canon `{ snapshot, events, structure }`, live or
- *   parsed back from JSON. **The complete source.**
- * - a {@link RunRecorder} — the handle `recordRun()` returns; frozen for you.
- * - a {@link Runner} — an agent / composition / pattern. Honest but PARTIAL:
- *   a finished runner can hand over its snapshot and its chart, and it cannot
- *   hand over the event stream, because the dispatcher drops events that
- *   nobody subscribed to rather than queuing them. The manifest says so in a
- *   note instead of shipping a silent gap.
- */
-export type BugReportSource = Recording | RunRecorder | Runner;
-/** One source, or several — several runs of one session are one conversation. */
-export type BugReportInput = BugReportSource | readonly BugReportSource[];
-/** What the reporter says happened. The prose half of the report. */
-export interface BugReportFields {
-    /** One line, as it will read in the issue title. */
-    readonly title: string;
-    /** How to get there. Free text; numbered lines read best. */
-    readonly stepsToReproduce: string;
-    /** What should have happened. */
-    readonly expected: string;
-    /** What happened instead. */
-    readonly actual: string;
-    /** The reporting APPLICATION's version, when it has one (not this library's
-     *  — that is read from the package and cannot be mistyped). */
-    readonly appVersion?: string;
-}
-/**
- * A selectable piece of the bundle.
- *
- * Two kinds, and the difference is what a reporter is deciding:
- *
- *   `conversation` — one conversation's evidence (its recordings, its slice of
- *                    the transcript and of the narrative). Keyed by session id
- *                    when the run was session-bound, else by run id.
- *   `file`         — one derived file that is not per-conversation: the
- *                    readable transcript, the narrative, the environment block.
- *
- * `manifest.json` is not a unit: it is the statement of the selection, and a
- * bundle that could omit its own statement is not an honest bundle.
- */
-export interface BugReportUnit {
-    /** Stable within one manifest — `conv-1`, `file-narrative`. Selection is by
-     *  this id, and the oversize trim hints name these ids. */
-    readonly id: string;
-    readonly kind: 'conversation' | 'file';
-    /** One line a human reads in a consent dialog. */
-    readonly label: string;
-    /** Bytes this unit contributes to the bundle, uncompressed. */
-    readonly bytes: number;
-    /** Typed events in this conversation. Conversation units only. */
-    readonly eventCount?: number;
-    /** Agent turns derived from those events. Conversation units only. */
-    readonly turnCount?: number;
-    /** Runs folded into this conversation. Conversation units only. */
-    readonly runCount?: number;
-    /** The hosting session id, when the runs carried one. */
-    readonly sessionId?: string;
-    /**
-     * Conversation units only. `true` when this conversation's evidence rides as
-     * a `RecordingEnvelope` — the archive contract, with the recording under its
-     * `recording` field; `false` when the envelope's run facts were not available
-     * and it rides as the bare recording instead.
-     *
-     * Stated per unit rather than per bundle because a bundle can be mixed: a
-     * live `recordRun` handle proves its own dropped-event count and a bare
-     * `Recording` alongside it cannot, so one conversation can be stamped while
-     * its neighbour is not. The manifest's notes name the missing fact.
-     */
-    readonly enveloped?: boolean;
-    /** Files this unit puts in the bundle (a `file` unit has exactly one). */
-    readonly files: readonly string[];
-}
-/** One file in the bundle, as the manifest reports it. */
-export interface BugReportFileSummary {
-    /** Path inside the zip. */
-    readonly name: string;
-    readonly bytes: number;
-    /** The unit that produced it, when one did. `manifest.json` has none. */
-    readonly unitId?: string;
-    readonly eventCount?: number;
-    readonly turnCount?: number;
-}
-/** What the reporter chose to leave out — stated, never silently absent. */
-export interface BugReportExcluded {
-    readonly conversations: number;
-    readonly files: number;
-    readonly events: number;
-    readonly turns: number;
-    /** The unit ids that were offered and not included. */
-    readonly unitIds: readonly string[];
-}
-/**
- * Versions, and deliberately nothing that identifies a machine or a person.
- *
- * This is the MANIFEST's summary block — the one a consent dialog and the issue
- * body print. The bundled `environment.json` is deliberately NARROWER: since
- * the bundle carries a {@link BugReportManifest.manifestVersion} 2 envelope,
- * the producer versions are stamped there (`envelope.json` → `producer`) and
- * the file keeps only the host half. One archive fact, one stamping place.
- */
-export interface BugReportEnvironment {
-    /** This library's version, read from its own package manifest. */
-    readonly agentfootprint: string;
-    /** The engine underneath it. */
-    readonly footprintjs: string;
-    /** `process.version`, e.g. `v20.11.0`. `'unknown'` off Node. */
-    readonly node: string;
-    /** `process.platform` / `process.arch` — a platform is not an identity. */
-    readonly platform: string;
-    readonly arch: string;
-    /** The reporting application's own version, when it told us. */
-    readonly appVersion?: string;
-}
-/**
- * The run facts an archive envelope needs and a frozen recording cannot supply.
- *
- * The bundle's evidence rides as a `RecordingEnvelope` — the one archive
- * contract this repo has — and that envelope refuses to stamp a fact it had to
- * guess. Two of its fields have no derivation:
- *
- *   `complete`       nothing in a frozen recording says whether it reached the
- *                    run's end; a crash-handler snapshot and a finished run
- *                    look identical. Stated, or the envelope is not built.
- *   `droppedEvents`  only the live `recordRun` handle counts what the
- *                    `maxEvents` cap discarded.
- *
- * Everything else the envelope needs — `runId`, `sessionId`, `principal`,
- * `tenant`, `startedAt`, `endedAt` — is derived per recording from that
- * recording's OWN events, and is deliberately not settable here: a bundle may
- * carry several runs, and one run id stated once cannot be true of all of them.
- */
-export interface BugReportRunFacts {
-    /**
-     * Did each recording in this bundle capture its run through to the end?
-     *
-     * Say `false` for a recording frozen from a crash handler, a timeout or
-     * mid-stream. Leave the whole `run` option off and the bundle still carries
-     * the evidence — as the bare recording, with the manifest stating in a note
-     * which fact was missing and how to supply it.
-     */
-    readonly complete: boolean;
-    /**
-     * Events lost to the recorder's `maxEvents` cap, for sources that cannot
-     * prove their own count.
-     *
-     * A live `recordRun` handle counts them, and that PROVEN count wins over
-     * anything stated here — a number the library can check is never overridden
-     * by a number it cannot. State this when the bundle is built from bare
-     * `Recording` objects, whose shape carries no count.
-     */
-    readonly droppedEvents?: number;
-}
-/** The oversize verdict, with hints that name real, droppable unit ids. */
-export interface BugReportOversize {
-    readonly totalBytes: number;
-    readonly limitBytes: number;
-    /** Sentences naming unit ids and what dropping each one saves. */
-    readonly trimHints: readonly string[];
-}
-/**
- * The honest summary of a bundle — what a human reads BEFORE consenting, and
- * what rides inside the zip as `manifest.json` afterwards.
- *
- * `describeBugReport` returns one with every unit selected and no reporter
- * prose. `exportBugReport` returns one that reflects the SELECTION, carries
- * the reporter's fields, and states the exclusions.
- */
-export interface BugReportManifest {
-    /**
-     * The BUNDLE LAYOUT version — bumped when the file set or this manifest's own
-     * shape changes, so a reader can tell which archive it is holding instead of
-     * inferring it from which names happen to be present.
-     *
-     *   1 — the evidence rode as a bare `recording.json`, and `environment.json`
-     *       repeated the producer versions the archive contract stamps.
-     *   2 — the evidence rides as `envelope.json`, a full `RecordingEnvelope`;
-     *       `environment.json` keeps only the host facts the envelope does not
-     *       hold. A conversation whose run facts could not be stamped falls back
-     *       to `recording.json` and the manifest says which fact was missing.
-     */
-    readonly manifestVersion: 2;
-    /** ISO 8601, UTC. Also the timestamp stamped on every zip entry. */
-    readonly createdAt: string;
-    /** Present on an export manifest; absent on a description. */
-    readonly report?: BugReportFields;
-    /** Everything on offer, selected or not. */
-    readonly units: readonly BugReportUnit[];
-    /** The unit ids actually in this bundle. */
-    readonly selected: readonly string[];
-    readonly excluded: BugReportExcluded;
-    readonly files: readonly BugReportFileSummary[];
-    readonly counts: {
-        readonly conversations: number;
-        readonly runs: number;
-        readonly events: number;
-        readonly turns: number;
-        readonly files: number;
-    };
-    /** Sum of every file in the bundle, uncompressed (the zip is stored). */
-    readonly totalBytes: number;
-    /**
-     * The keys whose values arrived already scrubbed, BY NAME ONLY — state keys,
-     * and the field names of served events.
-     *
-     * Redaction happens upstream (an agent's `Agent.create({ redact })`:
-     * footprintjs scrubs state at commit time, and every event is served under
-     * the same rule before it is recorded), so a bundle never carries the
-     * values. This list is derived from the evidence itself — the placeholders
-     * that are actually in it — so a human can see WHICH secrets were protected
-     * and consent knowing it.
-     */
-    readonly redactedKeys: readonly string[];
-    /** Loud, human-readable problems: oversize, a missing timeline, an empty run. */
-    readonly warnings: readonly string[];
-    /** Quiet, true facts about how the bundle was assembled. */
-    readonly notes: readonly string[];
-    /** Present when the bundle is over the size ceiling. */
-    readonly oversize?: BugReportOversize;
-    readonly environment: BugReportEnvironment;
-}
-/** One file, as bytes, ready to write or to zip. */
-export interface BugReportFile {
-    /** Path inside the bundle, `/`-separated and relative. */
-    readonly name: string;
-    /** The bytes. UTF-8 for every file this library produces. */
-    readonly bytes: Uint8Array;
-    /** The same content as text, for a consumer that would only decode it again. */
-    readonly text: string;
-}
-/** The finished bundle. */
-export interface BugReport {
-    /** The manifest, reflecting the selection. Also `manifest.json` inside the zip. */
-    readonly manifest: BugReportManifest;
-    /** The pieces, named. `files[0]` is always `manifest.json`. */
-    readonly files: readonly BugReportFile[];
-    /** A real, stored (uncompressed) zip of exactly those files. */
-    readonly zip: Uint8Array;
-    /** `<yyyy-mm-dd>-<slug>.zip` — a reporter may override it. */
-    readonly filename: string;
-}
-export interface ExportBugReportOptions extends BugReportFields {
-    /**
-     * Unit ids to bundle. Default: all of them.
-     *
-     * This is the consent seam: show `describeBugReport(input).units` to the
-     * reporter, take back the ids they ticked, pass them here. Anything left out
-     * is COUNTED in `manifest.excluded` — the maintainer learns that a subset
-     * was sent rather than wondering why turn 4 refers to a turn 3 that is not
-     * there.
-     */
-    readonly include?: readonly string[];
-    /**
-     * Byte ceiling that flips `oversize` and the loud warning. Default 20 MB —
-     * comfortably under what an issue tracker will take, and the point at which
-     * a bundle stops being reviewable by a person.
-     */
-    readonly warnOverBytes?: number;
-    /** Override the timestamp — the only thing that makes the zip deterministic. */
-    readonly now?: Date;
-    /**
-     * The two run facts the archive envelope cannot derive. Supply them and the
-     * bundle's evidence rides as `envelope.json`; leave them off and it rides as
-     * the bare `recording.json`, with the manifest naming the missing fact.
-     */
-    readonly run?: BugReportRunFacts;
-}
-/** `describeBugReport` takes nothing but the input, and the same dials. */
-export interface DescribeBugReportOptions {
-    readonly warnOverBytes?: number;
-    readonly now?: Date;
-    /**
-     * The same run facts {@link ExportBugReportOptions.run} takes — pass the same
-     * value to both calls. The offer measures the files the export will write, so
-     * stating the facts to one call and not the other would size the bundle from
-     * a different set of files than the one that leaves.
-     */
-    readonly run?: BugReportRunFacts;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/bug-report/types.d.ts.map

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

package/dist/types/lib/bug-report/zip.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../../src/lib/bug-report/zip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,yEAAyE;AACzE,MAAM,WAAW,QAAQ;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;CAC1B;AAeD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,EAAE,OAAO,GAAE,eAAoB,GAAG,UAAU,CAqFhG;AA+CD,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAc/C"}

package/dist/types/lib/context-bisect/ablation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ablation.d.ts","sourceRoot":"","sources":["../../../../src/lib/context-bisect/ablation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,eAAe,EAEf,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,OAAO,EACR,MAAM,YAAY,CAAC;AAKpB;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,GAAG,SAAS,CAyB7E;AAID,0EAA0E;AAC1E,UAAU,UAAU;IAClB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,gEAAgE;AAChE,UAAU,SAAS;IACjB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5C;AAED,MAAM,WAAW,eAAe,CAC9B,KAAK,SAAS,SAAS,GAAG,SAAS,EACnC,UAAU,SAAS,UAAU,GAAG,UAAU,EAC1C,YAAY,SAAS,UAAU,GAAG,UAAU;IAE5C,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IAC5C,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,KAAK,SAAS,SAAS,EACvB,UAAU,SAAS,UAAU,EAC7B,YAAY,SAAS,UAAU,EAE/B,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,OAAO,EAAE,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,CAAC,GACxD;IACD,KAAK,EAAE,SAAS,KAAK,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,UAAU,EAAE,CAAC;IAClC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;CACxC,CAiBA;AAID;kFACkF;AAClF,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAGlE;AAED,4EAA4E;AAC5E,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAKxD;AAMD;gFACgF;AAChF,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,SAAS,MAAM,EAAE,GACxB,SAAS,GAAG,SAAS,CAOvB;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe,CAU1E;AAED,wEAAwE;AACxE,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,GACpB,iBAAiB,CAQnB;AAED,wDAAwD;AACxD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,SAAS,YAAY,EAAE,GAC7B,OAAO,CAAC,gBAAgB,CAAC,CA8B3B;AAED,8DAA8D;AAC9D,wBAAgB,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,gBAAgB,EACvB,cAAc,EAAE,OAAO;AACvB;;iEAEiE;AACjE,MAAM,GAAE,UAAU,GAAG,WAAwB,GAC5C,eAAe,CAkCjB"}

package/dist/types/lib/context-bisect/arms/apply.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../../../src/lib/context-bisect/arms/apply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAkB,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,6EAA6E;AAC7E,UAAU,UAAU;IAClB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED,gEAAgE;AAChE,UAAU,SAAS;IACjB,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CACtB,KAAK,SAAS,SAAS,EACvB,UAAU,SAAS,UAAU,EAC7B,YAAY,SAAS,UAAU,EAE/B,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,CAAC,GACxD;IACD,KAAK,EAAE,SAAS,KAAK,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,UAAU,EAAE,CAAC;IAClC,aAAa,EAAE,SAAS,YAAY,EAAE,CAAC;CACxC,CAEA"}

package/dist/types/lib/context-bisect/arms/compare.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../../../src/lib/context-bisect/arms/compare.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAYH,OAAO,KAAK,EAEV,0BAA0B,EAE1B,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAIpB,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,kBAAkB,CAAC,CA4E7B"}

package/dist/types/lib/context-bisect/arms/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Strategy arms — SUBSTITUTION counterfactuals, kept distinct from ablation's
- * removals and sharing its statistics. See README.md in this folder for the
- * design argument, and `types.ts` for why this is not a fifth `AblationSpec`
- * arm.
- *
- * @beta Beta feature (RFC-003 Part B). The API works and is tested, but may
- * change before GA.
- */
-export { applyArm } from './apply.js';
-export { compareStrategyArms } from './compare.js';
-export { armFacetsFromManifest, armLabel, checkArmApplied, manifestFromEvents, matchArm, RUN_CONFIGURED_EVENT, } from './manifest.js';
-export { checkArmApplication, collectArmRuns, nullBandFrom, scoreArmRuns, type ArmRuns, } from './probe.js';
-export { armConfigKey, declaredFacetCount, validateStrategyArms } from './validate.js';
-export { verdictForArm, type ArmVerdictContext } from './verdict.js';
-export type { ArmApplication, ArmFacetMismatch, ArmFacets, ArmMemoryFacet, ArmOutcome, ArmRunResult, ArmRunner, CompareStrategyArmsOptions, ManifestMemoryLike, NullBand, RunManifestLike, StrategyArm, StrategyComparison, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/context-bisect/arms/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/context-bisect/arms/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EACL,qBAAqB,EACrB,QAAQ,EACR,eAAe,EACf,kBAAkB,EAClB,QAAQ,EACR,oBAAoB,GACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,KAAK,OAAO,GACb,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACvF,OAAO,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACrE,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,cAAc,EACd,UAAU,EACV,YAAY,EACZ,SAAS,EACT,0BAA0B,EAC1B,kBAAkB,EAClB,QAAQ,EACR,eAAe,EACf,WAAW,EACX,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/types/lib/context-bisect/arms/manifest.d.ts

@@ -1,80 +0,0 @@
-/**
- * The manifest bridge — which arm did this run belong to, according to the RUN
- * rather than according to the experimenter.
- *
- * Before 9.41.0 an arm label was bookkeeping: the consumer set a variable to
- * `'rerank'`, built an agent it believed re-ranked, and nothing in the library
- * could contradict it. `agentfootprint.agent.run_configured` names the adapters
- * and strategies a run is about to use, so the belief became checkable — and
- * {@link ArmFacets} is deliberately spelled in that event's own vocabulary so
- * the check is a field-by-field comparison and not a translation layer.
- *
- * Two directions, both here:
- *  - **verify** — `checkArmApplied(arm, manifest)`: the arm said `retrieval:
- *    'rerank'`; did the run agree? A contradiction costs the arm its verdict
- *    (`compare.ts`), because a difference measured between two arms that were
- *    secretly one configuration is not evidence about either.
- *  - **classify** — `matchArm(arms, manifest)`: hand it a recorded run's
- *    manifest and it says which declared arm that run belongs to. This is the
- *    door for grouping runs a study already made, offline, out of saved
- *    recordings.
- *
- * ## Absence is a contradiction, not a wildcard
- *
- * The manifest's own rule is that an absent field means "not configured", never
- * a guessed default. So an arm declaring `window: 'tokenBudget'` against a
- * manifest with no `window` is a MISMATCH, reported with `observed` absent. The
- * alternative — treating absence as "could be anything" — would let a run with
- * no window stage pass as the token-budget arm, which is exactly the mis-wiring
- * this file exists to catch.
- */
-import type { CapturedEventLike } from '../types.js';
-import type { ArmFacetMismatch, ArmFacets, RunManifestLike, StrategyArm } from './types.js';
-/** The event type the run manifest rides on (9.41.0). */
-export declare const RUN_CONFIGURED_EVENT = "agentfootprint.agent.run_configured";
-/**
- * Pull the run manifest out of a run's captured typed events — the same
- * `CapturedEventLike[]` bag `localizeContextBug` already accepts, so a consumer
- * who collected events with `agent.on('*', …)` needs no second capture.
- *
- * One manifest per run by design; the FIRST is returned. A bag holding events
- * from several runs is the caller's own mixing — filter by `meta.runId` first.
- */
-export declare function manifestFromEvents(events: readonly CapturedEventLike[] | undefined): RunManifestLike | undefined;
-/**
- * Project a manifest onto the arm-facet vocabulary — the inverse of what an arm
- * declares. Memory rows collapse to the FIRST one; a study varying retrieval
- * across several mounted memories should declare `memory.id` and read the rows
- * itself rather than trust a projection to pick.
- */
-export declare function armFacetsFromManifest(manifest: RunManifestLike): ArmFacets;
-/**
- * A stable label for a set of facets — sorted `key=value`, so two runs of one
- * configuration produce the same string whatever order the fields were written
- * in. Useful as a grouping key for N recorded runs.
- */
-export declare function armLabel(facets: ArmFacets): string;
-/**
- * Compare one arm's DECLARED facets against a run's manifest. Empty result =
- * the run agreed with everything the arm claimed.
- *
- * Only declared facets are compared. An arm is a claim about the facets it
- * names and says nothing about the rest — checking undeclared fields would fail
- * every arm for differing from the manifest in ways it never claimed.
- */
-export declare function checkArmApplied(arm: StrategyArm, manifest: RunManifestLike): readonly ArmFacetMismatch[];
-/**
- * Which declared arm does this run belong to? The offline door: group N
- * recorded runs into arms by what each run's own manifest says.
- *
- * Rules, all conservative:
- * - only arms that DECLARE facets are candidates (an arm naming nothing matches
- *   every run and would swallow the whole study);
- * - a candidate matches when the manifest contradicts none of its facets;
- * - the MOST SPECIFIC match wins (most declared facets), and a tie returns
- *   `undefined` — two arms fitting one run equally well is an ambiguity, and
- *   guessing which the experimenter meant is exactly the bookkeeping this
- *   function replaces.
- */
-export declare function matchArm(arms: readonly StrategyArm[], manifest: RunManifestLike): StrategyArm | undefined;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/types/lib/context-bisect/arms/manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../../../src/lib/context-bisect/arms/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,KAAK,EACV,gBAAgB,EAChB,SAAS,EAET,eAAe,EACf,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB,yDAAyD;AACzD,eAAO,MAAM,oBAAoB,wCAAwC,CAAC;AAE1E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,iBAAiB,EAAE,GAAG,SAAS,GAC/C,eAAe,GAAG,SAAS,CAO7B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,CAoB1E;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAalD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,eAAe,GACxB,SAAS,gBAAgB,EAAE,CA8C7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,QAAQ,EAAE,eAAe,GACxB,WAAW,GAAG,SAAS,CASzB"}

package/dist/types/lib/context-bisect/arms/probe.d.ts

@@ -1,55 +0,0 @@
-/**
- * The arm probe — seeded runs in, shared statistics out.
- *
- * Split in two on purpose. `collectArmRuns` only RUNS (it cannot know the
- * reference yet: when no prior answer was supplied, the reference IS the
- * baseline arm's first answer). `scoreArmRuns` only SCORES. Keeping them apart
- * is what lets the reference be chosen between the two halves without a second
- * pass over the model — the same "one ablation, two readouts" thrift
- * `runAblationProbe` applies to cost.
- *
- * Everything statistical is borrowed, not re-derived: `similarityStats`,
- * `costStatsFrom` and `resolveSamples` come from `ablation.ts` unchanged, so an
- * arm's `AblationRunStats` is the same number computed the same way as an
- * ablation's — which is the point of sharing the statistics while keeping the
- * spec types apart.
- */
-import type { AblationRunStats, Embedder, OutcomeComparator } from '../types.js';
-import type { ArmApplication, ArmRunner, NullBand, RunManifestLike, StrategyArm } from './types.js';
-/** The raw harvest of one arm's seeded runs — no scoring yet. */
-export interface ArmRuns {
-    readonly answers: readonly string[];
-    readonly loops: readonly number[];
-    readonly tokens: readonly number[];
-    readonly manifests: readonly RunManifestLike[];
-}
-/**
- * Call the consumer's runner once per seed (0..samples-1) for ONE arm and
- * normalize the two return shapes (`string` | `{output, cost?, manifest?}`) —
- * the same normalization `runAblationProbe` performs, so a bare-string runner
- * costs the caller nothing in ceremony.
- */
-export declare function collectArmRuns(arm: StrategyArm, runner: ArmRunner, samples: number): Promise<ArmRuns>;
-/**
- * Score one arm's harvested answers against the reference: similarity per seed
- * (mean/min/max/stdev) plus the outcome-flip count. Shape-identical to what an
- * ablation probe reports.
- */
-export declare function scoreArmRuns(runs: ArmRuns, reference: string, embedder: Embedder, outcomeChanged: OutcomeComparator): Promise<AblationRunStats>;
-/**
- * Build the inert-intervention control from the baseline arm's OWN seeded runs.
- * See {@link NullBand} for why leave-one-out does not transfer and this does.
- */
-export declare function nullBandFrom(baselineArmId: string, baselineStats: AblationRunStats, gates: boolean): NullBand;
-/**
- * Did this arm actually take effect? Compares every manifest the runner
- * reported against the arm's declared facets.
- *
- * `checked: false` — and therefore no refusal — in exactly two cases, both of
- * which are absence of evidence rather than evidence of absence: the runner
- * reported no manifest, or the arm declares only ablations (no manifest names a
- * tool catalog). Refusing a verdict in either case would punish a consumer for
- * a capture they were never required to make.
- */
-export declare function checkArmApplication(arm: StrategyArm, manifests: readonly RunManifestLike[]): ArmApplication;
-//# sourceMappingURL=probe.d.ts.map

package/dist/types/lib/context-bisect/arms/probe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../../../../src/lib/context-bisect/arms/probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,KAAK,EACV,cAAc,EAEd,SAAS,EACT,QAAQ,EACR,eAAe,EACf,WAAW,EACZ,MAAM,YAAY,CAAC;AAIpB,iEAAiE;AACjE,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,SAAS,eAAe,EAAE,CAAC;CAChD;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,WAAW,EAChB,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,CAiBlB;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,iBAAiB,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAgB3B;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,gBAAgB,EAC/B,KAAK,EAAE,OAAO,GACb,QAAQ,CAgBV;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,SAAS,eAAe,EAAE,GACpC,cAAc,CAuBhB"}