agentfootprint 6.25.0 → 6.26.0

package/dist/observe.js

@@ -32,8 +32,8 @@
  * directly; Tier 3 dashboards are opt-in.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.coerceCatalog = exports.catalogFromTools = exports.analyzeToolCatalog = exports.traceToolpack = exports.TOOLPACK_HARD_CAPS = exports.callTraceTool = exports.structuralProximity = exports.scoreMargin = exports.scoreInfluence = exports.persistence = exports.pairwiseSimilarity = exports.finalAnswerSimilarity = exports.embeddingCache = exports.EmbeddingCache = exports.DEFAULT_PERSISTENCE_THRESHOLD = exports.DEFAULT_MARGIN_THRESHOLD = exports.DEFAULT_INFLUENCE_WEIGHTS = exports.contentHash = exports.compositeScore = exports.averageRelevancy = exports.adaptWeights = exports.typedEmit = exports.agentThinkingTrace = exports.toolLineageRecorder = exports.attachStatus = exports.LoggingDomains = exports.attachLogging = exports.skillRecorder = exports.permissionRecorder = exports.memoryRecorder = exports.evalRecorder = exports.contextEvaluatedRecorder = exports.toolsRecorder = exports.costRecorder = exports.LiveAgentTurnTracker = exports.LiveToolTracker = exports.LiveLLMTracker = exports.LiveStateRecorder = exports.liveStateRecorder = exports.buildStepGraph = exports.attachFlowchart = exports.runStepRecorder = exports.RunStepRecorder = exports.buildRunSteps = exports.BoundaryRecorder = exports.boundaryRecorder = exports.agentRecorder = exports.compositionRecorder = exports.streamRecorder = exports.ContextRecorder = void 0;
-exports.toolChoiceRecorder = exports.buildChoiceContext = exports.saysWhatNotWhenRule = exports.runToolLintCli = exports.optionalParamRule = exports.MOCK_EMBEDDER_CALIBRATION = exports.formatToolCatalogReport = exports.enumInProseRule = exports.differentiationHint = exports.descriptionRule = exports.defaultStructuralRules = exports.DEFAULT_WHEN_CUES = exports.DEFAULT_WATCH_BAND = exports.DEFAULT_OMISSION_CUES = exports.DEFAULT_CONFUSABILITY_THRESHOLD = exports.confusabilityText = void 0;
+exports.bisectCulprits = exports.applyAblations = exports.ablationForSuspect = exports.traceToolpack = exports.TOOLPACK_HARD_CAPS = exports.callTraceTool = exports.structuralProximity = exports.scoreMargin = exports.scoreInfluence = exports.persistence = exports.pairwiseSimilarity = exports.finalAnswerSimilarity = exports.embeddingCache = exports.EmbeddingCache = exports.DEFAULT_PERSISTENCE_THRESHOLD = exports.DEFAULT_MARGIN_THRESHOLD = exports.DEFAULT_INFLUENCE_WEIGHTS = exports.contentHash = exports.compositeScore = exports.averageRelevancy = exports.adaptWeights = exports.typedEmit = exports.agentThinkingTrace = exports.toolLineageRecorder = exports.attachStatus = exports.LoggingDomains = exports.attachLogging = exports.skillRecorder = exports.permissionRecorder = exports.memoryRecorder = exports.evalRecorder = exports.contextEvaluatedRecorder = exports.toolsRecorder = exports.costRecorder = exports.LiveAgentTurnTracker = exports.LiveToolTracker = exports.LiveLLMTracker = exports.LiveStateRecorder = exports.liveStateRecorder = exports.buildStepGraph = exports.attachFlowchart = exports.runStepRecorder = exports.RunStepRecorder = exports.buildRunSteps = exports.BoundaryRecorder = exports.boundaryRecorder = exports.agentRecorder = exports.compositionRecorder = exports.streamRecorder = exports.ContextRecorder = void 0;
+exports.toolChoiceRecorder = exports.buildChoiceContext = exports.saysWhatNotWhenRule = exports.runToolLintCli = exports.optionalParamRule = exports.MOCK_EMBEDDER_CALIBRATION = exports.formatToolCatalogReport = exports.enumInProseRule = exports.differentiationHint = exports.descriptionRule = exports.defaultStructuralRules = exports.DEFAULT_WHEN_CUES = exports.DEFAULT_WATCH_BAND = exports.DEFAULT_OMISSION_CUES = exports.DEFAULT_CONFUSABILITY_THRESHOLD = exports.confusabilityText = exports.coerceCatalog = exports.catalogFromTools = exports.analyzeToolCatalog = exports.verdictFor = exports.suspectLabel = exports.stepOutputText = exports.runAblationProbe = exports.probeFlipped = exports.localizeContextBug = exports.llmEdgeWeigher = exports.llmCallIdsFromEvents = exports.formatContextBugReport = exports.defaultSuspectClassifier = exports.defaultOutcomeComparator = exports.CONTEXT_BISECT_DEFAULTS = void 0;
 // Tier 1 — context + stream
 var ContextRecorder_js_1 = require("./recorders/core/ContextRecorder.js");
 Object.defineProperty(exports, "ContextRecorder", { enumerable: true, get: function () { return ContextRecorder_js_1.ContextRecorder; } });
@@ -121,6 +121,28 @@ var index_js_2 = require("./lib/trace-toolpack/index.js");
 Object.defineProperty(exports, "callTraceTool", { enumerable: true, get: function () { return index_js_2.callTraceTool; } });
 Object.defineProperty(exports, "TOOLPACK_HARD_CAPS", { enumerable: true, get: function () { return index_js_2.TOOLPACK_HARD_CAPS; } });
 Object.defineProperty(exports, "traceToolpack", { enumerable: true, get: function () { return index_js_2.traceToolpack; } });
+// Contextual-bug localizer (RFC-003 Part B, D7–D9) — "git bisect for
+// context". Assembly: footprintjs causal DAG (control edges + honesty
+// markers + EdgeWeigher) × influence-core scoring (D6) × consumer-run
+// counterfactual ablation. §B2 claim tiers: scores/weights are
+// embedding-geometry PROXIES; ablation verdicts are the ONLY causal
+// claims; slice completeness is bounded by tracking — and says so.
+var index_js_3 = require("./lib/context-bisect/index.js");
+Object.defineProperty(exports, "ablationForSuspect", { enumerable: true, get: function () { return index_js_3.ablationForSuspect; } });
+Object.defineProperty(exports, "applyAblations", { enumerable: true, get: function () { return index_js_3.applyAblations; } });
+Object.defineProperty(exports, "bisectCulprits", { enumerable: true, get: function () { return index_js_3.bisectCulprits; } });
+Object.defineProperty(exports, "CONTEXT_BISECT_DEFAULTS", { enumerable: true, get: function () { return index_js_3.CONTEXT_BISECT_DEFAULTS; } });
+Object.defineProperty(exports, "defaultOutcomeComparator", { enumerable: true, get: function () { return index_js_3.defaultOutcomeComparator; } });
+Object.defineProperty(exports, "defaultSuspectClassifier", { enumerable: true, get: function () { return index_js_3.defaultSuspectClassifier; } });
+Object.defineProperty(exports, "formatContextBugReport", { enumerable: true, get: function () { return index_js_3.formatContextBugReport; } });
+Object.defineProperty(exports, "llmCallIdsFromEvents", { enumerable: true, get: function () { return index_js_3.llmCallIdsFromEvents; } });
+Object.defineProperty(exports, "llmEdgeWeigher", { enumerable: true, get: function () { return index_js_3.llmEdgeWeigher; } });
+Object.defineProperty(exports, "localizeContextBug", { enumerable: true, get: function () { return index_js_3.localizeContextBug; } });
+Object.defineProperty(exports, "probeFlipped", { enumerable: true, get: function () { return index_js_3.probeFlipped; } });
+Object.defineProperty(exports, "runAblationProbe", { enumerable: true, get: function () { return index_js_3.runAblationProbe; } });
+Object.defineProperty(exports, "stepOutputText", { enumerable: true, get: function () { return index_js_3.stepOutputText; } });
+Object.defineProperty(exports, "suspectLabel", { enumerable: true, get: function () { return index_js_3.suspectLabel; } });
+Object.defineProperty(exports, "verdictFor", { enumerable: true, get: function () { return index_js_3.verdictFor; } });
 // Tool-catalog confusability lint (RFC-002 tier 1, C1–C3) — build-time,
 // CI-gateable, framework-agnostic: plain { name, description?, inputSchema? }
 // tools in (OpenAI/Anthropic/MCP lists coerce via coerceCatalog; the
@@ -128,24 +150,24 @@ Object.defineProperty(exports, "traceToolpack", { enumerable: true, get: functio
 // out. Pluggable structural rule pack; thresholds + embedder consumer-
 // injected with our defaults. Bin: `agentfootprint-lint-tools`.
 // Front door: docs/guides/tool-catalog-lint.md.
-var index_js_3 = require("./lib/tool-lint/index.js");
-Object.defineProperty(exports, "analyzeToolCatalog", { enumerable: true, get: function () { return index_js_3.analyzeToolCatalog; } });
-Object.defineProperty(exports, "catalogFromTools", { enumerable: true, get: function () { return index_js_3.catalogFromTools; } });
-Object.defineProperty(exports, "coerceCatalog", { enumerable: true, get: function () { return index_js_3.coerceCatalog; } });
-Object.defineProperty(exports, "confusabilityText", { enumerable: true, get: function () { return index_js_3.confusabilityText; } });
-Object.defineProperty(exports, "DEFAULT_CONFUSABILITY_THRESHOLD", { enumerable: true, get: function () { return index_js_3.DEFAULT_CONFUSABILITY_THRESHOLD; } });
-Object.defineProperty(exports, "DEFAULT_OMISSION_CUES", { enumerable: true, get: function () { return index_js_3.DEFAULT_OMISSION_CUES; } });
-Object.defineProperty(exports, "DEFAULT_WATCH_BAND", { enumerable: true, get: function () { return index_js_3.DEFAULT_WATCH_BAND; } });
-Object.defineProperty(exports, "DEFAULT_WHEN_CUES", { enumerable: true, get: function () { return index_js_3.DEFAULT_WHEN_CUES; } });
-Object.defineProperty(exports, "defaultStructuralRules", { enumerable: true, get: function () { return index_js_3.defaultStructuralRules; } });
-Object.defineProperty(exports, "descriptionRule", { enumerable: true, get: function () { return index_js_3.descriptionRule; } });
-Object.defineProperty(exports, "differentiationHint", { enumerable: true, get: function () { return index_js_3.differentiationHint; } });
-Object.defineProperty(exports, "enumInProseRule", { enumerable: true, get: function () { return index_js_3.enumInProseRule; } });
-Object.defineProperty(exports, "formatToolCatalogReport", { enumerable: true, get: function () { return index_js_3.formatToolCatalogReport; } });
-Object.defineProperty(exports, "MOCK_EMBEDDER_CALIBRATION", { enumerable: true, get: function () { return index_js_3.MOCK_EMBEDDER_CALIBRATION; } });
-Object.defineProperty(exports, "optionalParamRule", { enumerable: true, get: function () { return index_js_3.optionalParamRule; } });
-Object.defineProperty(exports, "runToolLintCli", { enumerable: true, get: function () { return index_js_3.runToolLintCli; } });
-Object.defineProperty(exports, "saysWhatNotWhenRule", { enumerable: true, get: function () { return index_js_3.saysWhatNotWhenRule; } });
+var index_js_4 = require("./lib/tool-lint/index.js");
+Object.defineProperty(exports, "analyzeToolCatalog", { enumerable: true, get: function () { return index_js_4.analyzeToolCatalog; } });
+Object.defineProperty(exports, "catalogFromTools", { enumerable: true, get: function () { return index_js_4.catalogFromTools; } });
+Object.defineProperty(exports, "coerceCatalog", { enumerable: true, get: function () { return index_js_4.coerceCatalog; } });
+Object.defineProperty(exports, "confusabilityText", { enumerable: true, get: function () { return index_js_4.confusabilityText; } });
+Object.defineProperty(exports, "DEFAULT_CONFUSABILITY_THRESHOLD", { enumerable: true, get: function () { return index_js_4.DEFAULT_CONFUSABILITY_THRESHOLD; } });
+Object.defineProperty(exports, "DEFAULT_OMISSION_CUES", { enumerable: true, get: function () { return index_js_4.DEFAULT_OMISSION_CUES; } });
+Object.defineProperty(exports, "DEFAULT_WATCH_BAND", { enumerable: true, get: function () { return index_js_4.DEFAULT_WATCH_BAND; } });
+Object.defineProperty(exports, "DEFAULT_WHEN_CUES", { enumerable: true, get: function () { return index_js_4.DEFAULT_WHEN_CUES; } });
+Object.defineProperty(exports, "defaultStructuralRules", { enumerable: true, get: function () { return index_js_4.defaultStructuralRules; } });
+Object.defineProperty(exports, "descriptionRule", { enumerable: true, get: function () { return index_js_4.descriptionRule; } });
+Object.defineProperty(exports, "differentiationHint", { enumerable: true, get: function () { return index_js_4.differentiationHint; } });
+Object.defineProperty(exports, "enumInProseRule", { enumerable: true, get: function () { return index_js_4.enumInProseRule; } });
+Object.defineProperty(exports, "formatToolCatalogReport", { enumerable: true, get: function () { return index_js_4.formatToolCatalogReport; } });
+Object.defineProperty(exports, "MOCK_EMBEDDER_CALIBRATION", { enumerable: true, get: function () { return index_js_4.MOCK_EMBEDDER_CALIBRATION; } });
+Object.defineProperty(exports, "optionalParamRule", { enumerable: true, get: function () { return index_js_4.optionalParamRule; } });
+Object.defineProperty(exports, "runToolLintCli", { enumerable: true, get: function () { return index_js_4.runToolLintCli; } });
+Object.defineProperty(exports, "saysWhatNotWhenRule", { enumerable: true, get: function () { return index_js_4.saysWhatNotWhenRule; } });
 // Tool-choice margin recorder (RFC-002 tier 2, C4–C6) — per LLM call,
 // ranks the OFFERED catalog against the choice context (user message +
 // latest assistant reasoning) via influence-core scoreMargin; embeds

package/dist/observe.js.map

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

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

@@ -0,0 +1,97 @@
+/**
+ * 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, OutcomeComparator, 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[];
+};
+/** 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): AblationVerdict;
+export {};
+//# sourceMappingURL=ablation.d.ts.map

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

@@ -0,0 +1 @@
+{"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,EACf,iBAAiB,EAEjB,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;AAgBD,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,CAgB3B;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,GACtB,eAAe,CAgCjB"}

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

@@ -0,0 +1,76 @@
+/**
+ * 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>;
+//# sourceMappingURL=bisect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bisect.d.ts","sourceRoot":"","sources":["../../../../src/lib/context-bisect/bisect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAMrF,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,kBAAkB,GAAG,cAAc,CAAC;IACpE;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,SAAS,OAAO,EAAE,CAAC,EAAE,CAAC;IACnD,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC;;gDAE4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,uEAAuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,6DAA6D;IAC7D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAUD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC,CA+F7F"}

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

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+export { llmEdgeWeigher, stepOutputText, type LlmEdgeWeigherHandle, type LlmEdgeWeigherOptions, type RankedParentEdge, } from './llmEdgeWeigher.js';
+export { defaultSuspectClassifier, formatContextBugReport, llmCallIdsFromEvents, localizeContextBug, suspectLabel, type ClassifyContext, type LocalizeContextBugOptions, type SuspectClassifier, type SuspectSeed, } from './localize.js';
+export { ablationForSuspect, applyAblations, defaultOutcomeComparator, probeFlipped, runAblationProbe, verdictFor, type AblationTargets, type ProbeConfig, } from './ablation.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 EdgePathStep, type HonestyFlag, type HonestyFlagKind, type OutcomeComparator, type QualityTriggerLookup, type SimilarityStats, type SliceStats, type Suspect, type SuspectDetail, type SuspectKind, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/context-bisect/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,cAAc,EACd,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,GACtB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,EACZ,KAAK,eAAe,EACpB,KAAK,yBAAyB,EAC9B,KAAK,iBAAiB,EACtB,KAAK,WAAW,GACjB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,uBAAuB,EACvB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,WAAW,GACjB,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,125 @@
+/**
+ * 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;
+//# sourceMappingURL=llmEdgeWeigher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"llmEdgeWeigher.d.ts","sourceRoot":"","sources":["../../../../src/lib/context-bisect/llmEdgeWeigher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGjE,OAAO,EAEL,KAAK,QAAQ,EAEb,KAAK,gBAAgB,EACtB,MAAM,4BAA4B,CAAC;AAMpC,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IACtC,6DAA6D;IAC7D,QAAQ,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAAC;IAC5C,gDAAgD;IAChD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACtE;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACrF;AAED,iEAAiE;AACjE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,gBAAgB,EAAE,CAAC;IAC9D,wEAAwE;IACxE,aAAa,IAAI,SAAS,MAAM,EAAE,CAAC;CACpC;AAeD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,YAAY,EAAE,EAClC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAepB;AAmBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,oBAAoB,CA+FnF"}

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

@@ -0,0 +1,119 @@
+/**
+ * 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 } from '../influence-core/index.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;
+    /** 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;
+}
+/**
+ * Localize a contextual bug: trigger → causal slice → influence-weighted
+ * ranking → (optional) counterfactual ablation. See module docs for the
+ * pipeline and the §B2 claim tiers.
+ *
+ * @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;
+//# sourceMappingURL=localize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"localize.d.ts","sourceRoot":"","sources":["../../../../src/lib/context-bisect/localize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EAAkB,KAAK,QAAQ,EAAsB,MAAM,4BAA4B,CAAC;AAG/F,OAAO,KAAK,EACV,aAAa,EACb,mBAAmB,EACnB,gBAAgB,EAIhB,OAAO,EACP,aAAa,EACb,WAAW,EACZ,MAAM,YAAY,CAAC;AAKpB;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,EAAE,GAC/F,MAAM,EAAE,CAWV;AAID,kEAAkE;AAClE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;CACjC;AAED,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,gCAAgC;IAChC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C;AAED;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,eAAe,KAAK,SAAS,WAAW,EAAE,GAAG,SAAS,CAAC;AAuB7F;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,eAAe,GAAG,SAAS,WAAW,EAAE,CAsDrF;AAmGD,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,SAAS,EAAE,mBAAmB,CAAC;IACxC,8DAA8D;IAC9D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,mBAAmB,KAAK,MAAM,GAAG,SAAS,CAAC;IAC1E;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;IAC/B,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,qCAAqC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CACvC;AAID;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA+N3B;AAsGD,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAGrD;AAID;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAiFvE"}