agentfootprint 6.43.0 → 6.45.0

package/dist/esm/index.js.map

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

package/dist/esm/injection-engine.d.ts

@@ -0,0 +1,4 @@
+/**
+ * agentfootprint/injection-engine — public re-export for the InjectionEngine subsystem.
+ */
+export * from './lib/injection-engine/index.js';

package/dist/esm/lib/canonicalJson.d.ts

@@ -0,0 +1,56 @@
+/**
+ * canonicalJson — deterministic JSON serialization (`afp-cjson/1`).
+ *
+ * Pattern: Canonicalization function (RFC 8785 JCS-inspired, JS-native).
+ * Role:    The byte contract under the tamper-evident audit chain
+ *          (backlog #20). `AuditRecord.hash` = SHA-256 over the
+ *          canonical serialization of the record — two parties that
+ *          serialize the same VALUE must produce the same BYTES, or
+ *          verification breaks. These rules ARE the contract; bump the
+ *          identifier (`afp-cjson/2`) for ANY behavioral change.
+ *
+ * ## Canonicalization rules (`afp-cjson/1`)
+ *
+ *  1. **Objects** — own enumerable string-keyed properties only, keys
+ *     sorted lexicographically by UTF-16 code unit (JavaScript's
+ *     default `Array.prototype.sort()` comparison), serialized
+ *     `{"k":v,...}` with no whitespace. Symbol keys are ignored.
+ *  2. **Arrays** — element order preserved, `[v,...]` no whitespace.
+ *  3. **Strings** — `JSON.stringify` escaping (deterministic per the
+ *     ECMAScript spec: minimal escapes, lowercase `\uXXXX` hex).
+ *  4. **Numbers** — finite numbers via `JSON.stringify` (ECMAScript
+ *     shortest round-trip formatting). `NaN` / `±Infinity` → `null`
+ *     (JSON.stringify parity). `-0` serializes as `0`.
+ *  5. **`null`** → `null`. **`undefined`** — omitted as an object
+ *     property, `null` as an array element or top-level value
+ *     (JSON.stringify parity).
+ *  6. **Functions / symbols** — omitted as object properties, `null`
+ *     in arrays (JSON.stringify parity).
+ *  7. **`toJSON`** — honored before serialization (so `Date` →
+ *     ISO-8601 string, exactly like `JSON.stringify`).
+ *  8. **`bigint`** → `TypeError` (JSON.stringify parity). Sanitize
+ *     upstream (the audit bounding layer converts bigint to string).
+ *  9. **Cycles** → `TypeError`. Canonicalization is defined over
+ *     JSON-safe trees; the audit bounding layer breaks cycles first.
+ *
+ * The domain is "anything `JSON.parse` can produce" (the audit bundle
+ * is JSON); for other inputs the behavior mirrors `JSON.stringify`
+ * except that object keys are SORTED. Verification re-canonicalizes
+ * records that came through `JSON.parse(JSON.stringify(bundle))`, so
+ * round-tripping a bundle never changes its hashes.
+ *
+ * Browser-safe: no Node imports — pure computation.
+ */
+/** Identifier of the canonicalization rules implemented by
+ *  {@link canonicalJson}. Carried on `AuditBundleHeader.canonicalization`
+ *  so offline verifiers can reject bundles produced under different
+ *  rules instead of mis-verifying them. */
+export declare const CANONICAL_JSON_VERSION = "afp-cjson/1";
+/**
+ * Serialize `value` to canonical JSON (see module docs for the exact
+ * `afp-cjson/1` rules). Deterministic: equal values (after key
+ * reordering) always produce identical strings.
+ *
+ * @throws TypeError on circular references or bigint values.
+ */
+export declare function canonicalJson(value: unknown): string;

package/dist/esm/lib/context-bisect/ablation.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Ablation — the counterfactual seam (RFC-003 Part B, D8 stage 4 + the
+ * D9 stats engine).
+ *
+ * Three pieces:
+ *
+ *   1. **Adapters** — `ablationForSuspect` maps a classified suspect to
+ *      the spec that removes it (tool → drop from catalog; injection /
+ *      fact / skill → exclude the `Injection.id`; memory → filter the
+ *      `MemoryEntry.id`; arg → consumer-override note).
+ *
+ *   2. **The seam** — `applyAblations` filters the inputs an agent is
+ *      BUILT from. Documented here because the seam did not previously
+ *      exist: `AgentOptions` has no `ignoredTools` runtime kill-switch, so
+ *      tool ablation happens at construction (the consumer's
+ *      `AblationRunner` rebuilds the agent from filtered inputs). Same for
+ *      injections and memory entries.
+ *
+ *   3. **The probe engine** — `runAblationProbe` calls the consumer's
+ *      runner N seeded times, measures embedding similarity to the
+ *      original output, counts outcome flips, and returns variance —
+ *      never a single-run verdict (D9 discipline).
+ *
+ * §B2: only `runAblationProbe`-derived verdicts are causal claims; every
+ * score elsewhere is a correlational proxy.
+ */
+import type { Embedder } from '../influence-core/index.js';
+import type { AblationRerun, AblationRunStats, AblationSpec, AblationVerdict, CostStats, OutcomeComparator, SimilarityStats, Suspect } from './types.js';
+/**
+ * The spec that removes one suspect — or `undefined` for kind `'stage'`
+ * (plain pipeline stages have no removable input; re-rank or refactor).
+ */
+export declare function ablationForSuspect(suspect: Suspect): AblationSpec | undefined;
+/** Anything with a stable id — `Injection` and `MemoryEntry` both fit. */
+interface Identified {
+    readonly id: string;
+}
+/** Anything with a named schema — the library's `Tool` fits. */
+interface NamedTool {
+    readonly schema: {
+        readonly name: string;
+    };
+}
+export interface AblationTargets<TTool extends NamedTool = NamedTool, TInjection extends Identified = Identified, TMemoryEntry extends Identified = Identified> {
+    readonly tools?: readonly TTool[];
+    readonly injections?: readonly TInjection[];
+    readonly memoryEntries?: readonly TMemoryEntry[];
+}
+/**
+ * Apply ablation specs to the inputs an agent is constructed from —
+ * THE documented seam (see module docs). Generic over the concrete tool /
+ * injection / memory-entry types so it filters without importing them.
+ *
+ * `'arg'` specs are deliberately NOT handled here: run input belongs to
+ * the consumer's runner (`spec.note` says so).
+ *
+ * @example inside an AblationRunner
+ * ```ts
+ * const { tools, injections } = applyAblations(specs, {
+ *   tools: ALL_TOOLS, injections: ALL_FACTS,
+ * });
+ * const agent = Agent.create({ provider: freshProvider(), model })
+ *   .tools([...tools]);
+ * for (const inj of injections) agent.fact(inj);
+ * ```
+ */
+export declare function applyAblations<TTool extends NamedTool, TInjection extends Identified, TMemoryEntry extends Identified>(specs: readonly AblationSpec[], targets: AblationTargets<TTool, TInjection, TMemoryEntry>): {
+    tools: readonly TTool[];
+    injections: readonly TInjection[];
+    memoryEntries: readonly TMemoryEntry[];
+};
+/** Resolve the seeded-rerun count: default on non-finite, floor, clamp to >= 2
+ *  (no single-run verdicts — D9). Shared by the ablation + restoration probes. */
+export declare function resolveSamples(samples: number | undefined): number;
+/** Median of a numeric sample (mean of the two middles for even length). */
+export declare function median(values: readonly number[]): number;
+/** Build a probe's CostStats from per-seed loop/token samples — undefined when
+ *  the runner reported no cost (keeps quality-only behavior byte-identical). */
+export declare function costStatsFrom(samples: number, loops: readonly number[], tokens: readonly number[]): CostStats | undefined;
+export declare function similarityStats(values: readonly number[]): SimilarityStats;
+/** The default comparator: embedding similarity below the threshold. */
+export declare function defaultOutcomeComparator(embedder: Embedder, flipThreshold: number): OutcomeComparator;
+/** Resolved probe configuration shared by D8 and D9. */
+export interface ProbeConfig {
+    readonly rerun: AblationRerun;
+    readonly embedder: Embedder;
+}
+/**
+ * Run ONE probe: call the consumer's runner with `specs` once per seed
+ * (0..samples-1), measure each output's embedding similarity to the
+ * original, and count outcome flips. Variance is always reported.
+ *
+ * `samples` is clamped to ≥ 2 — D9: never single-run verdicts.
+ */
+export declare function runAblationProbe(config: ProbeConfig, specs: readonly AblationSpec[]): Promise<AblationRunStats>;
+/** Majority-flip rule shared by D8 verdicts and D9 probes. */
+export declare function probeFlipped(stats: AblationRunStats): boolean;
+/**
+ * Translate probe evidence into the verdict — the ONLY causal claim tier
+ * (§B2). `baselineStable=false` (the un-ablated scenario itself flipped)
+ * forces `'inconclusive'`: no ablation verdict is trustworthy on an
+ * unstable baseline.
+ */
+export declare function verdictFor(label: string, stats: AblationRunStats, baselineStable: boolean, 
+/** The counterfactual intervention. `'ablating'` (default) for present
+ *  suspects; `'restoring'` for missing-context candidates (interface #3).
+ *  Default keeps every claim string byte-identical to before. */
+action?: 'ablating' | 'restoring'): AblationVerdict;
+export {};

package/dist/esm/lib/context-bisect/bisect.d.ts

@@ -0,0 +1,75 @@
+/**
+ * bisectCulprits — multi-culprit bisection over the ranked suspect set
+ * (RFC-003 Part B, block D9). The "git bisect" of the localizer.
+ *
+ * When single-suspect ablations don't flip the outcome — redundant causes
+ * (two facts that EACH justify the wrong answer), or interacting ones —
+ * the culprit is a SET. This harness finds a minimal culprit set by
+ * recursive halving over the ranked suspects (delta-debugging style,
+ * Zeller's ddmin specialized to two-way splits), then keeps searching the
+ * remainder for INDEPENDENT culprits until the remainder stops flipping.
+ *
+ * Probe semantics (the D9 discipline):
+ *  - every probe = N seeded reruns of the consumer's `AblationRunner`
+ *    with the probe's combined specs; "flipped" = MAJORITY of runs
+ *    changed outcome; similarity mean ± spread is always reported —
+ *    never single-run verdicts;
+ *  - probe 0 is the BASELINE (no ablation): if it flips, the scenario
+ *    itself is unstable and the result is honestly `'inconclusive'`;
+ *  - probes are cached by spec-set, and budgeted (`maxProbes`) — running
+ *    out of budget yields `'inconclusive'`, never a partial claim
+ *    dressed up as a finding.
+ *
+ * §B2: the returned `verdict`/`culprits` are CAUSAL claims — they rest
+ * exclusively on counterfactual reruns. The input ranking only chooses
+ * the SEARCH ORDER (better ranking = fewer probes), it never decides the
+ * outcome.
+ */
+import type { AblationRerun, AblationRunStats, Embedder, Suspect } from './types.js';
+/** One executed probe — full variance evidence, kept for the report. */
+export interface BisectionProbe {
+    /** Labels of the suspects ablated together ([] = the baseline probe). */
+    readonly ablated: readonly string[];
+    readonly stats: AblationRunStats;
+    /** Majority-of-N outcome flip. */
+    readonly flipped: boolean;
+}
+export interface BisectionResult {
+    /**
+     * `'confirmed'` — a minimal culprit set was found and verified by
+     * counterfactual reruns. `'not-reproducible'` — ablating EVERY ranked
+     * suspect together does not flip the outcome: the bug's cause is not
+     * in the ranked set (look at the report's honesty flags — the slice
+     * may be incomplete). `'inconclusive'` — unstable baseline or probe
+     * budget exhausted.
+     */
+    readonly verdict: 'confirmed' | 'not-reproducible' | 'inconclusive';
+    /**
+     * Minimal culprit set(s): each inner array is one minimal set whose
+     * JOINT ablation flips the outcome. Independent culprits appear as
+     * separate sets; redundant/interacting causes appear together in one.
+     */
+    readonly culprits: readonly (readonly Suspect[])[];
+    /** Every probe executed, in order (baseline first). */
+    readonly probes: readonly BisectionProbe[];
+    /** Total consumer-runner invocations (probes × samples). */
+    readonly runsUsed: number;
+}
+export interface BisectCulpritsOptions {
+    /** Ranked suspects — only those carrying an applicable ablation spec
+     *  participate ('arg' and 'stage' suspects are skipped: nothing the
+     *  harness can remove for the consumer). */
+    readonly suspects: readonly Suspect[];
+    readonly rerun: AblationRerun;
+    /** Embedder for similarity stats (and the default flip comparator). */
+    readonly embedder: Embedder;
+    /** Probe budget. Default 24. Exhaustion → 'inconclusive'. */
+    readonly maxProbes?: number;
+    /** Max independent culprit sets to search for. Default 4. */
+    readonly maxCulprits?: number;
+}
+/**
+ * Find minimal culprit set(s) by seeded counterfactual bisection. See
+ * module docs for semantics and the §B2 claim tier.
+ */
+export declare function bisectCulprits(options: BisectCulpritsOptions): Promise<BisectionResult>;

package/dist/esm/lib/context-bisect/cost.d.ts

@@ -0,0 +1,37 @@
+/**
+ * cost — the SECOND score of two-score localization (proposal 004).
+ *
+ * A context bug costs you twice: a wrong ANSWER (the flip `verdict`, the strong
+ * causal tier) OR extra COST — loops/tokens — even when a capable model recovers
+ * and answers correctly. This module reads the cost score from the SAME ablation
+ * reruns (`AblationRunStats.cost`, captured in `runAblationProbe`) and attaches a
+ * `CostVerdict` to each suspect, then classifies each on the 2×2.
+ *
+ * HONEST TIER (the two-lens review): the cost score is a WEAKER, gated tier than
+ * the flip. Removing a piece reducing cost shows **necessity for the cost, NOT
+ * that the work was "wasted"** (the piece could be load-bearing scaffolding). So:
+ *   - PLACEBO control — a cost cause must beat the loops-saved of pieces whose
+ *     removal did NOT flip the answer (benign path variance), leave-one-out;
+ *     (v1 limitation: the placebo population is the non-flipping suspects, which
+ *     may themselves include real cost causes — so the band's MAX is CONSERVATIVE
+ *     and UNDER-detects when several pieces reduce cost by similar amounts. Safe
+ *     direction for a causal-ish claim. A dedicated neutral-filler placebo is v2.)
+ *   - STABILITY — every ablated rerun used no MORE loops than baseline
+ *     (consistent reduction; an integer ±1 delta is brittle — determinism ≠
+ *     robustness), AND a placebo band existed to clear.
+ */
+import type { AblationRunStats, Suspect, SuspectClass } from './types.js';
+/** Minimum loops saved (over the placebo band) to call a piece a cost cause. */
+export declare const MIN_LOOPS_SAVED = 1;
+/**
+ * Attach a `CostVerdict` to each suspect from the ablation reruns + a
+ * leave-one-out placebo control. Suspects without cost data are returned
+ * unchanged (quality-only). See the module honesty note.
+ */
+export declare function assignCostVerdicts(suspects: readonly Suspect[], baseline: AblationRunStats): Suspect[];
+/**
+ * Derive the 2×2 class from the flip verdict (quality) and the cost verdict.
+ * The no-bug cell is `'no-detected-effect'` — never "innocent" (a piece can
+ * matter in ways neither axis sees: overdetermination, same-loops-different-path).
+ */
+export declare function classifySuspect(suspect: Suspect): SuspectClass;

package/dist/esm/lib/context-bisect/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * context-bisect — RFC-003 Part B: the contextual-bug LOCALIZER,
+ * "git bisect for context".
+ *
+ * Assembly over shipped pieces: footprintjs 9.8.0's complete causal DAG
+ * (control edges, honesty markers, `EdgeWeigher` hook) × influence-core
+ * scoring (D6) × consumer-run counterfactual ablation.
+ *
+ *   D7 — `llmEdgeWeigher`     influence-weighted LLM-call slice edges
+ *   D8 — `localizeContextBug` trigger → slice → ranked suspects → ablation
+ *   D9 — `bisectCulprits`     seeded multi-culprit bisection + variance
+ *
+ * §B2 claim tiers (spelled out on every type): weights/scores are
+ * embedding-geometry PROXIES; ablation verdicts are the ONLY causal
+ * claims; slice completeness is bounded by tracking — and says so.
+ *
+ * @beta Beta feature (RFC-003 Part B). The API works and is tested, but
+ * may change before GA.
+ */
+export { llmEdgeWeigher, stepOutputText, type LlmEdgeWeigherHandle, type LlmEdgeWeigherOptions, type RankedParentEdge, } from './llmEdgeWeigher.js';
+export { findDroppedContext, type ContextUnit, type DroppedUnit, type MissingContextResult, } from './missingContext.js';
+export { runRestorationProbe, type RestorationProbeConfig, type RestorationRerun, type RestorationRunner, } from './restoration.js';
+export { defaultSuspectClassifier, formatContextBugReport, llmCallIdsFromEvents, localizeContextBug, suspectLabel, type ClassifyContext, type LocalizeContextBugOptions, type SuspectClassifier, type SuspectSeed, } from './localize.js';
+export { toBacktrackTrace, type BacktrackCustodyHop, type BacktrackHop, type BacktrackSuspectCard, type BacktrackTrace, type BacktrackTrail, type ToBacktrackTraceOptions, } from './toBacktrackTrace.js';
+export { ablationForSuspect, applyAblations, costStatsFrom, defaultOutcomeComparator, median, probeFlipped, runAblationProbe, verdictFor, type AblationTargets, type ProbeConfig, } from './ablation.js';
+export { assignCostVerdicts, classifySuspect, MIN_LOOPS_SAVED } from './cost.js';
+export { shortlistEarlyCulprits, DEFAULT_RECENCY_DECAY, type LoopCandidate, type LoopRecallShortlist, type ShortlistEarlyCulpritsOptions, } from './loop-recall.js';
+export { walkToRoot, walkTrajectory, buildWriterFrameIndex, type RootCauseHop, type RootCauseNote, type RootCausePath, type WalkToRootOptions, } from './walk-to-root.js';
+export { assembleTrajectory, bucketByAnchors, findLoopHeads, type AnchorBucket, type AssembleTrajectoryOptions, type ContextSource, type LoopFrame, type SyntheticQuestionNode, type Trajectory, } from './trajectory.js';
+export { bisectCulprits, type BisectCulpritsOptions, type BisectionProbe, type BisectionResult, } from './bisect.js';
+export { CONTEXT_BISECT_DEFAULTS, type AblationRerun, type AblationRunner, type AblationRunStats, type AblationSpec, type AblationVerdict, type AblationVerdictKind, type CapturedEventLike, type ContextBugArtifacts, type ContextBugReport, type CostRange, type CostStats, type CostVerdict, type EdgePathStep, type HonestyFlag, type HonestyFlagKind, type OutcomeComparator, type QualityTriggerLookup, type RestoredCandidate, type RunCost, type SimilarityStats, type SliceStats, type Suspect, type SuspectClass, type SuspectDetail, type SuspectKind, } from './types.js';

package/dist/esm/lib/context-bisect/index.js

@@ -13,6 +13,9 @@
  * §B2 claim tiers (spelled out on every type): weights/scores are
  * embedding-geometry PROXIES; ablation verdicts are the ONLY causal
  * claims; slice completeness is bounded by tracking — and says so.
+ *
+ * @beta Beta feature (RFC-003 Part B). The API works and is tested, but
+ * may change before GA.
  */
 export { llmEdgeWeigher, stepOutputText, } from './llmEdgeWeigher.js';
 // Interface #3 — missing-context finder (available − sent; confirm by restoration).

package/dist/esm/lib/context-bisect/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/context-bisect/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,cAAc,EACd,cAAc,GAIf,MAAM,qBAAqB,CAAC;AAE7B,oFAAoF;AACpF,OAAO,EACL,kBAAkB,GAInB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,mBAAmB,GAIpB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,GAKb,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,gBAAgB,GAOjB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,wBAAwB,EACxB,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,UAAU,GAGX,MAAM,eAAe,CAAC;AAEvB,8EAA8E;AAC9E,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjF,gGAAgG;AAChG,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GAItB,MAAM,kBAAkB,CAAC;AAE1B,qGAAqG;AACrG,OAAO,EACL,UAAU,EACV,cAAc,EACd,qBAAqB,GAKtB,MAAM,mBAAmB,CAAC;AAE3B,4EAA4E;AAC5E,6CAA6C;AAC7C,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,aAAa,GAOd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,cAAc,GAIf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,uBAAuB,GA0BxB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/context-bisect/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACL,cAAc,EACd,cAAc,GAIf,MAAM,qBAAqB,CAAC;AAE7B,oFAAoF;AACpF,OAAO,EACL,kBAAkB,GAInB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,mBAAmB,GAIpB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,GAKb,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,gBAAgB,GAOjB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,wBAAwB,EACxB,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,UAAU,GAGX,MAAM,eAAe,CAAC;AAEvB,8EAA8E;AAC9E,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjF,gGAAgG;AAChG,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GAItB,MAAM,kBAAkB,CAAC;AAE1B,qGAAqG;AACrG,OAAO,EACL,UAAU,EACV,cAAc,EACd,qBAAqB,GAKtB,MAAM,mBAAmB,CAAC;AAE3B,4EAA4E;AAC5E,6CAA6C;AAC7C,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,aAAa,GAOd,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,cAAc,GAIf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,uBAAuB,GA0BxB,MAAM,YAAY,CAAC"}

package/dist/esm/lib/context-bisect/llmEdgeWeigher.d.ts

@@ -0,0 +1,124 @@
+/**
+ * llmEdgeWeigher — influence-scored `EdgeWeigher` for LLM-call slice edges
+ * (RFC-003 Part B, block D7).
+ *
+ * The gap this fills: footprintjs's causal slice treats every parent of an
+ * LLM call equally — a 12-parent hairball (system prompt, history, tool
+ * results, cache markers, counters …) gives a debugger 12 equally-plausible
+ * leads. D7 turns the hairball into a RANKED shortlist by weighing each
+ * parent edge with influence-core's composite (D6): the parent's WRITTEN
+ * content vs the LLM call's OUTPUT.
+ *
+ * Pattern: two-pass adapter over footprintjs's synchronous `EdgeWeigher`
+ *          hook (A3). Embedding is async, the hook is sync — so the handle
+ *          PRIMES first (walk an unweighted slice, embed every needed text
+ *          in deduplicated batches, memoize composites), and `weigh` then
+ *          answers synchronously from the primed map. `localizeContextBug`
+ *          drives the two passes; standalone consumers call
+ *          `prime(dag)` themselves and re-run `causalChain({ weigh })`.
+ * Role:    `src/lib/context-bisect/` leaf. The engine stays zero-dep — the
+ *          weigher is consumer-injected exactly as A3 intended.
+ *
+ * ## Honest claim (§B2)
+ *
+ * Weights are CORRELATIONAL proxies: deterministic embedding geometry
+ * between texts the run already committed — never model internals, never
+ * causal attribution (ablation is the causal tier). A weight of 0.93 means
+ * "this parent's content is semantically close to what the LLM produced",
+ * not "the LLM used it".
+ *
+ * ## Determinism
+ *
+ * Same artifacts + same (deterministic) embedder → same weights and same
+ * ranking, run after run: texts are built from the commit log in commit
+ * order, embedded via influence-core's deduplicated batch, and ties in
+ * `rankedParents` keep first-seen (slice BFS) order. Wrap the embedder in
+ * `embeddingCache(...)` to also make repeat localizations embed nothing.
+ *
+ * ## What is weighed
+ *
+ * DATA edges whose CHILD is an LLM call (`llmCallIds`). Everything else —
+ * non-LLM children, control edges (a routing decision's influence is not a
+ * semantic-content question) — returns `undefined`, which footprintjs
+ * stamps as the default 1.0.
+ *
+ * ## Redaction posture
+ *
+ * Texts come exclusively from the COMMIT LOG, which footprintjs scrubs at
+ * commit time — a redacted key's committed value IS the placeholder, so
+ * the embedder never sees the raw secret.
+ */
+import type { CommitBundle } from 'footprintjs/advanced';
+import type { CausalNode, EdgeWeigher } from 'footprintjs/trace';
+import { type Embedder, type InfluenceWeights } from '../influence-core/index.js';
+export interface LlmEdgeWeigherOptions {
+    /**
+     * Injected embedder (D6 contract). Wrap in `embeddingCache(...)` so the
+     * weigher, the suspect refinement, and any margin/lint consumer share
+     * one embedding spend.
+     */
+    readonly embedder: Embedder;
+    /**
+     * runtimeStageIds of LLM-call executions — the children whose parent
+     * edges get weighed. Provide explicitly, or extract from captured
+     * events with `llmCallIdsFromEvents` (the `stream.llm_start` ids).
+     */
+    readonly llmCallIds: Iterable<string>;
+    /** The run's commit log — where edge texts are read from. */
+    readonly commitLog: readonly CommitBundle[];
+    /** Char cap per embedded text. Default 2000. */
+    readonly maxTextChars?: number;
+    /** Composite weights forwarded to influence-core. Default: paper priors. */
+    readonly weights?: InfluenceWeights;
+    /**
+     * Override the CHILD text (the LLM call's output). Default: the values
+     * the child committed, serialized `key=value` in trace order, capped.
+     */
+    readonly childTextOf?: (runtimeStageId: string) => string | undefined;
+    /**
+     * Override the PARENT text for one edge. Default: the value the parent
+     * committed for the edge's key, serialized + capped.
+     */
+    readonly parentTextOf?: (runtimeStageId: string, key: string) => string | undefined;
+}
+/** One ranked parent edge of an LLM call (descending weight). */
+export interface RankedParentEdge {
+    readonly parentId: string;
+    readonly stageName: string;
+    readonly key: string;
+    /** Influence composite clamped to [0, 1] — a correlational proxy (§B2). */
+    readonly weight: number;
+}
+export interface LlmEdgeWeigherHandle {
+    /**
+     * Pass 1 — walk an (unweighted) causal DAG, embed every LLM-edge text in
+     * one deduplicated batch, and memoize composite weights. Idempotent;
+     * call again with a different DAG to extend the map.
+     */
+    prime(root: CausalNode): Promise<void>;
+    /**
+     * Pass 2 — the synchronous footprintjs `EdgeWeigher`. Returns the primed
+     * weight for (LLM child, parent, data key); `undefined` (→ engine
+     * default 1.0) for control edges, non-LLM children, and unprimed pairs.
+     */
+    readonly weigh: EdgeWeigher;
+    /**
+     * The D7 acceptance view: an LLM call's parents ranked by weight,
+     * descending; ties keep first-seen (slice BFS) order. Empty until
+     * `prime` ran over a DAG containing the call.
+     */
+    rankedParents(llmCallId: string): readonly RankedParentEdge[];
+    /** Texts the embedder was given — exposed for security audits/tests. */
+    embeddedTexts(): readonly string[];
+}
+/**
+ * Default child text: everything the step committed, `key=value` in trace
+ * order. For an agent's LLM call this carries the assistant content +
+ * tool-call intents — the step's observable OUTPUT.
+ */
+export declare function stepOutputText(commitLog: readonly CommitBundle[], lastIdxOf: Map<string, number>, runtimeStageId: string, maxChars: number): string | undefined;
+/**
+ * Build the D7 weigher. See module docs for the two-pass contract, the
+ * determinism guarantee, and the §B2 honest claim (weights = proxies).
+ */
+export declare function llmEdgeWeigher(options: LlmEdgeWeigherOptions): LlmEdgeWeigherHandle;

package/dist/esm/lib/context-bisect/localize.d.ts

@@ -0,0 +1,152 @@
+/**
+ * localizeContextBug — the contextual-bug LOCALIZER, "git bisect for
+ * context" (RFC-003 Part B, block D8).
+ *
+ * The five-stage pipeline (each stage is a shipped piece — this file only
+ * ASSEMBLES):
+ *
+ *   1. TRIGGER     — an explicit `atStep`, a custom trigger strategy, or
+ *                    the QualityRecorder's lowest-scoring step.
+ *   2. SLICE       — footprintjs `causalChain` over the commit log, WITH
+ *                    control-dependence edges (D3) and honesty markers
+ *                    (A2/A4) when the artifacts carry them.
+ *   3. WEIGH       — D7's `llmEdgeWeigher` stamps influence weights on
+ *                    every LLM-call parent edge (two-pass: prime, re-slice).
+ *   4. RANK        — suspects = slice nodes classified into ablatable
+ *                    context sources (tool / injection / memory / arg),
+ *                    scored by max-product path weight × per-item semantic
+ *                    refinement. CORRELATIONAL tier — and marked so.
+ *   5. ABLATE      — optional: the consumer's `AblationRunner` re-runs the
+ *                    scenario without each top suspect, N seeded times.
+ *                    Verdicts (the ONLY causal claims, §B2) + variance.
+ *
+ * Without a runner the report stops at stage 4 with
+ * `mode: 'correlational'` — explicitly a ranking of proxies, no causal
+ * claim anywhere.
+ *
+ * Every `source` / `step` id in the report is a plain runtimeStageId —
+ * drill any of them with the trace-toolpack tools (`trace_node`,
+ * `trace_slice`, `get_value`) over the same artifacts bag.
+ */
+import type { CausalNode } from 'footprintjs/trace';
+import { type Embedder, type InfluenceScorer } from '../influence-core/index.js';
+import type { LoopRecallShortlist } from './loop-recall.js';
+import { type ContextUnit } from './missingContext.js';
+import { type RestorationRerun } from './restoration.js';
+import type { AblationRerun, ContextBugArtifacts, ContextBugReport, Suspect, SuspectDetail, SuspectKind } from './types.js';
+/**
+ * Extract LLM-call step ids from captured typed events: the
+ * `meta.runtimeStageId` of every `agentfootprint.stream.llm_start`
+ * envelope, deduplicated in event order. Collect events with
+ * `agent.on('*', (e) => events.push(e))`.
+ */
+export declare function llmCallIdsFromEvents(events: readonly {
+    readonly type: string;
+    readonly meta: {
+        readonly runtimeStageId: string;
+    };
+}[]): string[];
+/** A classified-but-unscored suspect produced by a classifier. */
+export interface SuspectSeed {
+    readonly kind: SuspectKind;
+    readonly detail?: SuspectDetail;
+}
+/** What a classifier sees for one slice node. */
+export interface ClassifyContext {
+    readonly node: CausalNode;
+    /** Keys this node committed. */
+    readonly keysWritten: readonly string[];
+    /** Verb-aware value of a key as of this node's last commit. */
+    readonly valueOf: (key: string) => unknown;
+}
+/**
+ * Pluggable classifier: map one slice node to its ablatable context
+ * sources. Return `undefined` to fall through to the default (which
+ * understands the agent chart's committed shapes); return `[]` to
+ * suppress the node entirely.
+ */
+export type SuspectClassifier = (ctx: ClassifyContext) => readonly SuspectSeed[] | undefined;
+/**
+ * The default classifier — reads the node's COMMITTED values (already
+ * redaction-scrubbed) and recognizes the agent chart's shapes:
+ *
+ * - `systemPromptInjections` / `messagesInjections` / `toolsInjections`
+ *   records with an engineered source → one suspect per `Injection.id`
+ *   (kind `'memory'` for source `'memory'`, else `'injection'`).
+ * - `lastToolResult` → a `'tool'` suspect for the tool that ran.
+ * - footprintjs A2 honesty marker `args` → an `'arg'` suspect (the
+ *   consumer's runner must override the input — nothing to filter).
+ * - anything else → the honest `'stage'` fallback (no ablation spec).
+ */
+export declare function defaultSuspectClassifier(ctx: ClassifyContext): readonly SuspectSeed[];
+export interface LocalizeContextBugOptions {
+    readonly artifacts: ContextBugArtifacts;
+    /** Injected embedder (D6) — wrap in `embeddingCache(...)`. */
+    readonly embedder: Embedder;
+    /** Explicit trigger step (runtimeStageId). Wins over everything. */
+    readonly atStep?: string;
+    /** Custom trigger strategy — consulted when `atStep` is absent. */
+    readonly trigger?: (artifacts: ContextBugArtifacts) => string | undefined;
+    /**
+     * The counterfactual tier: supply a runner (+ the original output) and
+     * top suspects get ablation verdicts. Absent → the report stops at the
+     * ranking, marked `mode: 'correlational'`.
+     */
+    readonly rerun?: AblationRerun;
+    /**
+     * Interface #3 — the MISSING-context tier. Supply what was `available` for
+     * the turn and what was `sent` to the model; the report's `dropped` lists the
+     * units that never reached the model (`available − sent`). Add a `rerun` and
+     * each dropped candidate gets a RESTORATION verdict (the mirror of ablation:
+     * restoring it flips the outcome → causal). Absent → no `dropped` section.
+     */
+    readonly missingContext?: {
+        readonly available: readonly ContextUnit[];
+        readonly sent: readonly ContextUnit[];
+        readonly rerun?: RestorationRerun;
+    };
+    /** Slice depth budget. Default 12. */
+    readonly maxDepth?: number;
+    /** Slice node budget. Default 80. */
+    readonly maxNodes?: number;
+    /** Ranked suspects kept on the report. Default 12. */
+    readonly maxSuspects?: number;
+    /** Override / extend the suspect classifier. */
+    readonly classify?: SuspectClassifier;
+    /**
+     * The RANK stage's pluggable influence scorer (the suspect-ordering
+     * extension point). Default `scoreInfluence` — the FDL four-signal
+     * composite. Bring your own `InfluenceScorer` — e.g.
+     * `scoreContrastiveInfluence` wrapped with a `referenceText`, or a
+     * scorer of your own — to change the ranking ORDER, never causality:
+     * a scorer only changes how FAST §B2 ablation confirms a culprit;
+     * ablation alone makes the causal claim.
+     */
+    readonly scorer?: InfluenceScorer;
+    /**
+     * L3 narrowing (proposal 006): a per-loop recall shortlist from `shortlistEarlyCulprits`.
+     * When supplied, suspects are REORDERED (never filtered) so high-recall candidates float to the
+     * top and survive the `maxSuspects` slice → ablation targets them first. Joined on the suspect
+     * identity (`detail.injectionId`/`detail.toolName`). Default off (back-compat).
+     */
+    readonly shortlist?: LoopRecallShortlist;
+}
+/**
+ * Localize a contextual bug: trigger → causal slice → influence-weighted
+ * ranking → (optional) counterfactual ablation. See module docs for the
+ * pipeline and the §B2 claim tiers.
+ *
+ * @beta Beta feature — the API may change before GA.
+ *
+ * @throws when no trigger can be resolved (no `atStep`, no custom
+ *         strategy hit, no `artifacts.quality`), or when the trigger step
+ *         is not in the commit log.
+ */
+export declare function localizeContextBug(options: LocalizeContextBugOptions): Promise<ContextBugReport>;
+export declare function suspectLabel(suspect: Suspect): string;
+/**
+ * Human-readable report. The claim tiers are spelled out in the output
+ * itself (§B2): scores are proxies; verdict lines are the only causal
+ * claims; every ⚠ honesty flag prints.
+ */
+export declare function formatContextBugReport(report: ContextBugReport): string;

package/dist/esm/lib/context-bisect/localize.js

@@ -231,6 +231,8 @@ function reorderByShortlist(suspects, shortlist) {
  * ranking → (optional) counterfactual ablation. See module docs for the
  * pipeline and the §B2 claim tiers.
  *
+ * @beta Beta feature — the API may change before GA.
+ *
  * @throws when no trigger can be resolved (no `atStep`, no custom
  *         strategy hit, no `artifacts.quality`), or when the trigger step
  *         is not in the commit log.