agentfootprint 6.24.0 → 6.26.0

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

@@ -0,0 +1,356 @@
+/**
+ * context-bisect types — RFC-003 Part B: the contextual-bug localizer
+ * ("git bisect for context").
+ *
+ * Pattern: assembly contract. Part B is pure 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. No new engine features,
+ *          no new typed events.
+ * Role:    `src/lib/context-bisect/` leaf. Exported via
+ *          `agentfootprint/observe`.
+ *
+ * ## The two-tier honest-claims discipline (RFC-003 §B2)
+ *
+ * Every number in these types belongs to exactly ONE of two tiers, and the
+ * docs say which:
+ *
+ *   - **CORRELATIONAL** — edge weights, suspect scores, rankings. These are
+ *     deterministic embedding-geometry PROXIES (influence-core composite:
+ *     semantic alignment between what a source wrote and what the LLM step
+ *     produced). They mean "high semantic alignment", never "the model
+ *     answered BECAUSE of this". A report without reruns stops here and is
+ *     marked `mode: 'correlational'`.
+ *
+ *   - **CAUSAL** — ablation verdicts ONLY. A suspect earns `verdict:
+ *     'confirmed'` exclusively by counterfactual evidence: the consumer's
+ *     `AblationRunner` re-ran the scenario WITHOUT the suspect N seeded
+ *     times and the outcome flipped (with baseline stability checked and
+ *     variance reported — never a single-run verdict).
+ *
+ * Slice completeness is bounded by tracking — and SAYS so: untracked reads
+ * (`$getArgs()` / env / silent reads), missing control-dependence lookups,
+ * missing read tracking, and depth/node truncation all surface as
+ * `honestyFlags` on the report, mirrored from footprintjs's own A2/A4
+ * markers.
+ */
+import type { CommitBundle, RuntimeSnapshot, StageSnapshot } from 'footprintjs/advanced';
+import type { ControlDepLookup } from 'footprintjs/trace';
+import type { Embedder, InfluenceWeights } from '../influence-core/index.js';
+/**
+ * Minimal structural envelope for captured typed events — satisfied by
+ * `AgentfootprintEvent` (collect with `agent.on('*', e => events.push(e))`).
+ * Structural so a consumer can hand in any array shaped like this.
+ */
+export interface CapturedEventLike {
+    readonly type: string;
+    readonly payload: unknown;
+    readonly meta: {
+        readonly runtimeStageId: string;
+    };
+}
+/**
+ * Minimal per-step quality lookup for trigger derivation — satisfied by
+ * footprintjs's `QualityRecorder` (structural, decoupled).
+ */
+export interface QualityTriggerLookup {
+    getLowest(): {
+        runtimeStageId: string;
+        entry: {
+            score: number;
+            stageName: string;
+        };
+    } | undefined;
+}
+/**
+ * The frozen evidence of one completed run — a structural SUPERSET of the
+ * trace-toolpack's `TraceToolpackArtifacts`, so the same bag literal can
+ * serve `traceToolpack(...)` and `localizeContextBug(...)`: every
+ * runtimeStageId in the report drills straight into the toolpack tools.
+ *
+ * - `snapshot` — `executor.getSnapshot()` / `agent.getLastSnapshot()`.
+ * - `controlDeps` — OPTIONAL `controlDepRecorder().asLookup()` from the
+ *   run. With it, the slice includes `[control: <rule label>]` edges to
+ *   the deciders that routed execution. Without it, the report carries the
+ *   `no-control-deps` honesty flag.
+ * - `quality` — OPTIONAL `QualityRecorder` from the run; its
+ *   lowest-scoring step is the default trigger when `atStep` is absent.
+ * - `events` — OPTIONAL captured typed events; used to extract LLM-call
+ *   step ids (`stream.llm_start`) when `llmCallIds` is not given.
+ * - `llmCallIds` — explicit override: the runtimeStageIds of LLM-call
+ *   executions (the steps whose parent edges D7 weighs).
+ */
+export interface ContextBugArtifacts {
+    readonly snapshot: RuntimeSnapshot;
+    readonly controlDeps?: ControlDepLookup;
+    readonly quality?: QualityTriggerLookup;
+    readonly events?: readonly CapturedEventLike[];
+    readonly llmCallIds?: readonly string[];
+}
+/**
+ * What kind of context source a suspect is — picks which ablation adapter
+ * applies. `'stage'` is the honest fallback for slice nodes the classifier
+ * cannot map to an ablatable source (pipeline plumbing, plain stages).
+ */
+export type SuspectKind = 'tool' | 'injection' | 'memory' | 'arg' | 'stage';
+/** Kind-specific identity + the text the semantic refinement embedded. */
+export interface SuspectDetail {
+    /** Tool name (kind 'tool'). */
+    readonly toolName?: string;
+    /** Injection id (kind 'injection' / 'memory') — `Injection.id`. */
+    readonly injectionId?: string;
+    /** Injection flavor (fact / skill / rag / memory / …), when known. */
+    readonly flavor?: string;
+    /**
+     * The suspect's own content text (tool result / injection rawContent),
+     * already redaction-scrubbed by footprintjs at commit time. This is
+     * what the embedder saw for `semanticScore`.
+     */
+    readonly text?: string;
+}
+/**
+ * One hop of a suspect's evidence path — the argmax-weight chain from the
+ * trigger step back to the suspect. Control edges carry `kind: 'control'`
+ * and (when decide() supplied one) the rule label in `key`.
+ */
+export interface EdgePathStep {
+    /** Child (downstream) step. The first hop's `from` is the trigger. */
+    readonly from: string;
+    readonly fromName: string;
+    /** Parent (upstream) step. The last hop's `to` is the suspect. */
+    readonly to: string;
+    readonly toName: string;
+    readonly kind: 'data' | 'control';
+    /** State key (data) or decide() rule label (control), when present. */
+    readonly key?: string;
+    /** Edge weight — 1.0 unless D7 weighed it (child was an LLM call). */
+    readonly weight: number;
+}
+/** Per-run similarity statistics — variance ALWAYS reported (D9). */
+export interface SimilarityStats {
+    readonly mean: number;
+    readonly min: number;
+    readonly max: number;
+    /** Population standard deviation across the N seeded reruns. */
+    readonly stdev: number;
+}
+/** Evidence from N seeded ablation reruns of one probe. */
+export interface AblationRunStats {
+    /** Seeded reruns performed (the consumer's runner was called N times). */
+    readonly samples: number;
+    /** Runs where `outcomeChanged(original, ablated)` was true. */
+    readonly flips: number;
+    /** Embedding similarity of each ablated output to the original. */
+    readonly similarity: SimilarityStats;
+}
+export type AblationVerdictKind = 'confirmed' | 'not-confirmed' | 'inconclusive';
+/**
+ * The ONLY causal claim in the report (§B2). `'confirmed'` = ablating the
+ * suspect flipped the outcome in a MAJORITY of N seeded reruns while the
+ * un-ablated baseline stayed stable. `'inconclusive'` = mixed flips, or an
+ * unstable baseline (the scenario itself doesn't reproduce — no ablation
+ * verdict is trustworthy then). `'not-confirmed'` = no flip observed; the
+ * suspect's score remains a correlational proxy only.
+ */
+export interface AblationVerdict {
+    readonly verdict: AblationVerdictKind;
+    /** Human-readable claim, phrased at the right tier (causal vs proxy). */
+    readonly claim: string;
+}
+/** One ranked suspect. */
+export interface Suspect {
+    /**
+     * runtimeStageId of the slice node this suspect lives at — drillable
+     * with the trace-toolpack tools (`trace_node(source)` etc.).
+     */
+    readonly source: string;
+    readonly stageName: string;
+    readonly kind: SuspectKind;
+    readonly detail?: SuspectDetail;
+    /**
+     * The ranking key — CORRELATIONAL proxy (§B2):
+     * `structuralScore × semanticScore` when a semantic refinement exists,
+     * else `structuralScore`. Means "semantically aligned and causally
+     * UPSTREAM", never "caused".
+     *
+     * Comparison caveat: a suspect WITHOUT content text (kind 'stage'/'arg',
+     * or a path through control edges only) keeps its bare structural score
+     * — an UPPER BOUND with no content evidence behind it. Plumbing can
+     * legitimately rank above ablatable sources; the ablation verdicts (and
+     * `semanticScore`'s presence) are what disambiguate.
+     */
+    readonly score: number;
+    /**
+     * Max-product of edge weights along the best path from the trigger to
+     * this node (1.0 when no D7-weighted LLM edge is on the path).
+     */
+    readonly structuralScore: number;
+    /**
+     * Influence-core composite of the suspect's own content vs the trigger
+     * step's output (clamped to [0, 1]); only for suspects with a known
+     * content text. The same proxy disclaimers as D6 apply.
+     */
+    readonly semanticScore?: number;
+    /**
+     * TRUE when `score` includes a content signal (semanticScore present).
+     * FALSE = path-only structural score — an UPPER BOUND that can reach 1.0
+     * through control-edge paths alone; rank such suspects with care and
+     * prefer ablation verdicts to disambiguate. (Machine-readable twin of
+     * the "path only — no content signal" report marking.)
+     */
+    readonly hasContentEvidence: boolean;
+    /** Evidence path, trigger → … → suspect, control edges labeled. */
+    readonly edgePath: readonly EdgePathStep[];
+    /** The counterfactual to run — absent for kind 'stage'. */
+    readonly ablation?: AblationSpec;
+    /** CAUSAL tier — present only when an `AblationRunner` was supplied. */
+    readonly verdict?: AblationVerdict;
+    /** The rerun evidence behind `verdict`. */
+    readonly runs?: AblationRunStats;
+}
+/**
+ * What to remove for one counterfactual rerun. The library BUILDS specs
+ * (one per suspect kind) and provides `applyAblations` to apply them to
+ * the inputs an agent is constructed from; the consumer's `AblationRunner`
+ * re-runs the scenario with the spec applied.
+ *
+ * THE TOOL SEAM (documented because `AgentOptions` has no `ignoredTools`):
+ * agentfootprint has no runtime tool kill-switch — tools enter an agent at
+ * construction (`.tools([...])` / injection `inject.tools`). Tool ablation
+ * therefore happens where tools are DECLARED: the runner rebuilds the
+ * agent with `applyAblations(specs, { tools }).tools`. The same pattern
+ * covers injections (rebuild without the excluded `Injection.id`s) and
+ * memory (filter `MemoryEntry`s by id before attaching).
+ */
+export type AblationSpec = 
+/** Drop these tools from the catalog the agent is built with. */
+{
+    readonly kind: 'tool';
+    readonly ignoredTools: readonly string[];
+}
+/** Drop these injections (facts / skills / instructions / steering / rag). */
+ | {
+    readonly kind: 'injection';
+    readonly excludeInjectionIds: readonly string[];
+}
+/** Drop these memory entries (matched by `MemoryEntry.id`). */
+ | {
+    readonly kind: 'memory';
+    readonly excludeMemoryIds: readonly string[];
+}
+/**
+ * The suspect is run INPUT (`$getArgs()` / seed args) — there is nothing
+ * the library can filter. The consumer's runner must override the arg
+ * itself (e.g. re-run with a neutralized field). `source` names the step
+ * that consumed the untracked input.
+ */
+ | {
+    readonly kind: 'arg';
+    readonly source: string;
+    readonly note: string;
+};
+/**
+ * Consumer-supplied counterfactual runner: re-run the SAME scenario with
+ * every spec in `specs` applied, and return the run's output text.
+ *
+ * Contract:
+ * - `specs` may be empty — that is the BASELINE probe (re-run unchanged);
+ *   its outputs measure the scenario's natural variance.
+ * - `run.seed` varies 0..N-1 across the N samples of one probe. Thread it
+ *   into any stochastic knob (sampling temperature seed, mock script
+ *   selection) so reruns are deterministic-but-distinct; ignore it for
+ *   fully deterministic scenarios.
+ * - Build a FRESH agent/provider per call — scripted mock providers are
+ *   stateful (replies consume in order).
+ */
+export type AblationRunner = (specs: readonly AblationSpec[], run: {
+    readonly seed: number;
+}) => Promise<string>;
+/**
+ * Did the ablated output mean something DIFFERENT from the original?
+ * Default: embedding similarity below `flipThreshold`. Override with a
+ * domain comparator (e.g. compare extracted decisions) — recommended with
+ * `mockEmbedder`, whose cosine compresses prose into ~0.85–0.97 (the C1
+ * calibration note: absolute thresholds only with real embedders).
+ */
+export type OutcomeComparator = (original: string, ablated: string) => boolean | Promise<boolean>;
+/** The rerun configuration that upgrades the report to the causal tier. */
+export interface AblationRerun {
+    readonly runner: AblationRunner;
+    /** The original (buggy) output the reruns are compared against. */
+    readonly originalOutput: string;
+    /** Seeded reruns per probe. Default 3. Never below 2 (no single-run verdicts — D9). */
+    readonly samples?: number;
+    /** Outcome-flip comparator. Default: similarity < `flipThreshold`. */
+    readonly outcomeChanged?: OutcomeComparator;
+    /** Similarity floor for the DEFAULT comparator. Default 0.8. */
+    readonly flipThreshold?: number;
+    /** Ablate only the top-K ranked suspects that carry a spec. Default 5. */
+    readonly maxSuspects?: number;
+}
+/** Slice-shape numbers — how much evidence the ranking stands on. */
+export interface SliceStats {
+    readonly nodes: number;
+    readonly dataEdges: number;
+    readonly controlEdges: number;
+    /** Edges that received a D7 (LLM-influence) weight. */
+    readonly weightedEdges: number;
+    /** Nodes that ALSO consumed untracked sources (args/env/silent reads). */
+    readonly incompleteNodes: number;
+    readonly maxDepth: number;
+    readonly maxNodes: number;
+    /** Present when a limit actually cut the slice (footprintjs A4). */
+    readonly truncated?: {
+        readonly byDepth: boolean;
+        readonly byNodes: boolean;
+    };
+}
+export type HonestyFlagKind = 'slice-truncated' | 'untracked-sources' | 'no-control-deps' | 'no-read-tracking' | 'no-llm-call-ids' | 'baseline-unstable';
+export interface HonestyFlag {
+    readonly flag: HonestyFlagKind;
+    readonly note: string;
+}
+/** The localizer's full output (D8). */
+export interface ContextBugReport {
+    /** The trigger step the slice was rooted at. */
+    readonly step: string;
+    readonly stepName: string;
+    /** Where the trigger came from. */
+    readonly triggerSource: 'explicit' | 'quality' | 'custom';
+    /** The quality score that selected the trigger (quality source only). */
+    readonly triggerScore?: number;
+    /**
+     * `'correlational'` — no `AblationRunner` supplied: the report STOPS at
+     * the ranking; every score is a proxy and no causal claim is made.
+     * `'causal'` — suspects additionally carry ablation verdicts (§B2: the
+     * verdicts are the only causal claims; the scores stay proxies).
+     */
+    readonly mode: 'correlational' | 'causal';
+    /** Ranked suspects, best (most aligned + upstream) first. */
+    readonly suspects: readonly Suspect[];
+    readonly sliceStats: SliceStats;
+    /** ⚠ everything that bounds what this report can honestly claim. */
+    readonly honestyFlags: readonly HonestyFlag[];
+    /** Baseline probe stats (causal mode only). */
+    readonly baseline?: AblationRunStats;
+}
+export declare const CONTEXT_BISECT_DEFAULTS: {
+    /** Slice depth budget (forwarded to `causalChain`). */
+    readonly maxDepth: 12;
+    /** Slice node budget (forwarded to `causalChain`). */
+    readonly maxNodes: 80;
+    /** Ranked suspects kept on the report. */
+    readonly maxSuspects: 12;
+    /** Chars of written content embedded per step text (D7). */
+    readonly maxTextChars: 2000;
+    /** Seeded reruns per ablation probe (D9 — never single-run verdicts). */
+    readonly samples: 3;
+    /** Default similarity floor for the default outcome comparator. */
+    readonly flipThreshold: 0.8;
+    /** Ablation probes budget for `bisectCulprits`. */
+    readonly maxProbes: 24;
+    /** Independent-culprit search rounds for `bisectCulprits`. */
+    readonly maxCulprits: 4;
+};
+export type { CommitBundle, ControlDepLookup, Embedder, InfluenceWeights, RuntimeSnapshot, StageSnapshot, };
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/types/lib/tool-lint/analyze.d.ts

@@ -0,0 +1,84 @@
+/**
+ * analyzeToolCatalog — the tool-catalog confusability lint
+ * (RFC-002 block C1, the adoption front door).
+ *
+ * Pattern: policy layer over `pairwiseSimilarity` (influence-core) — the
+ *          geometry is computed there; thresholds, verdicts, hints and
+ *          the structural rule pack live here. Everything is consumer-
+ *          injectable with our defaults (the plug-and-play meta-pattern).
+ * Role:    `src/lib/tool-lint/`. ZERO stack buy-in — plain
+ *          `{ name, description?, inputSchema? }[]` in, report out.
+ *          `catalogFromTools` adapts the library's own `Tool[]`;
+ *          `coerceCatalog` (cli.ts) normalizes OpenAI/Anthropic/MCP
+ *          shapes.
+ *
+ * ## What is embedded (and why)
+ *
+ * `confusabilityText(tool)` = tokenized name + ': ' + description. The
+ * model differentiates tools by name AND description together, so two
+ * tools with near-identical names and overlapping descriptions ARE the
+ * confusability case (`get_fcns_database` vs `influx_get_fcns_database`)
+ * — embedding only the prose would miss the name signal.
+ *
+ * ## Calibration (RFC-002 §3 — read this before trusting verdicts)
+ *
+ * Absolute cosine ranges are PER-EMBEDDER. The default threshold (0.85)
+ * is a starting point for real sentence embedders. The test/demo
+ * `mockEmbedder` (character-frequency) compresses unrelated prose into
+ * ~0.85–0.97 — with it, use `MOCK_EMBEDDER_CALIBRATION` and trust only
+ * the RELATIVE ordering in `report.similarity.ranked` (the acceptance
+ * fixtures assert ordering, never absolute scores).
+ */
+import type { Tool } from '../../core/tools.js';
+import type { AnalyzeToolCatalogOptions, CatalogTool, ToolCatalogReport } from './types.js';
+/** Default `confusabilityThreshold` — a starting point for REAL sentence
+ *  embedders (unrelated tool descriptions typically land 0.3–0.7).
+ *  Calibrate per embedder; meaningless for the mock (see below). */
+export declare const DEFAULT_CONFUSABILITY_THRESHOLD = 0.85;
+/** Default `watchBand` below the threshold. */
+export declare const DEFAULT_WATCH_BAND = 0.05;
+/**
+ * Threshold/band calibrated for the char-frequency `mockEmbedder` on
+ * realistic tool prose (seed corpus: the Neo SAN catalog). The mock
+ * compresses unrelated descriptions into ~0.85–0.97 cosine, so expect
+ * false positives even at 0.94 — with the mock, the RELATIVE ordering
+ * of `report.similarity.ranked` is the trustworthy signal; absolute
+ * verdicts are only honest with a real embedder + per-embedder
+ * calibration.
+ */
+export declare const MOCK_EMBEDDER_CALIBRATION: Readonly<{
+    confusabilityThreshold: 0.94;
+    watchBand: 0.02;
+}>;
+/**
+ * Adapt the library's `Tool[]` (from `defineTool` / `Agent.tool`) to the
+ * lint's plain catalog shape. Trivial on purpose: `Tool.schema` already
+ * IS `{ name, description, inputSchema }`.
+ */
+export declare function catalogFromTools(tools: readonly Tool[]): readonly CatalogTool[];
+/**
+ * The text the confusability analysis embeds for one tool: the name with
+ * `_`/`-`/camelCase boundaries opened into words, then the description.
+ * Exported so consumers can reproduce or replace the construction.
+ */
+export declare function confusabilityText(tool: CatalogTool): string;
+/**
+ * Lint a tool catalog: pairwise confusability over what the model reads
+ * (when an embedder is supplied) + the structural rule pack. Returns a
+ * report whose `ok` is the CI gate.
+ *
+ * Duplicate tool names are themselves reported as structural errors
+ * (rule `duplicate-name`, built-in precondition — a catalog where two
+ * tools share a name is broken before any similarity question); the
+ * duplicates are dropped from the similarity analysis (first one wins).
+ */
+export declare function analyzeToolCatalog(tools: readonly CatalogTool[], options?: AnalyzeToolCatalogOptions): Promise<ToolCatalogReport>;
+/**
+ * Suggest the DIFFERENTIATING AXIS for a flagged pair. Heuristic: when
+ * the names are near-twins (≤2 distinct tokens), the qualifier IS the
+ * axis — the descriptions must say when to choose each variant. When the
+ * names differ, surface the few description terms each tool does NOT
+ * share, as the place to anchor an explicit choice condition.
+ */
+export declare function differentiationHint(a: CatalogTool, b: CatalogTool): string;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/types/lib/tool-lint/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../../src/lib/tool-lint/analyze.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAGhD,OAAO,KAAK,EACV,yBAAyB,EACzB,WAAW,EAGX,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB;;oEAEoE;AACpE,eAAO,MAAM,+BAA+B,OAAO,CAAC;AAEpD,+CAA+C;AAC/C,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB;;;EAGpC,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,SAAS,WAAW,EAAE,CAM/E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAO3D;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,iBAAiB,CAAC,CAyF5B;AA4CD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CA6B1E"}

package/dist/types/lib/tool-lint/cli.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Tool-lint CLI core (RFC-002 block C3 — the CI gate).
+ *
+ * Pattern: humble shell — `bin/agentfootprint-lint-tools.mjs` is a
+ *          3-line wrapper; ALL behavior (arg parsing, catalog coercion,
+ *          report, exit code) lives here so it is unit-testable without
+ *          spawning a process.
+ * Role:    `src/lib/tool-lint/`. Reads ONE JSON file of tools, prints a
+ *          report, returns the process exit code:
+ *            0 — report.ok
+ *            1 — findings failed the gate (!ok)
+ *            2 — usage / input error (bad flags, unreadable file,
+ *                unrecognized JSON shape)
+ *
+ * ## Embedder & gating honesty
+ *
+ * The CLI has no way to receive a consumer embedder, so it uses the
+ * built-in deterministic mock (char-frequency, offline, dependency-free)
+ * for the similarity RANKING — and, by default, does NOT gate on it:
+ * without `--threshold`, similarity is report-only (relative ordering +
+ * watch hints) and the exit code reflects structural findings alone.
+ * Pass `--threshold` to make confusable pairs fail the gate — you own
+ * the calibration at that point (start from
+ * `MOCK_EMBEDDER_CALIBRATION.confusabilityThreshold` = 0.94). For real
+ * embedder gating, use `analyzeToolCatalog` from
+ * `agentfootprint/observe` in a small script instead.
+ */
+import type { CatalogTool } from './types.js';
+export interface ToolLintCliIO {
+    readonly stdout: (line: string) => void;
+    readonly stderr: (line: string) => void;
+}
+/**
+ * Normalize any of the recognized tool-list JSON shapes to the lint's
+ * plain catalog. Throws (with a shape description) on unrecognized
+ * input — the CLI maps that to exit code 2.
+ */
+export declare function coerceCatalog(json: unknown): readonly CatalogTool[];
+/**
+ * Run the lint CLI. Returns the exit code (never calls `process.exit` —
+ * the bin wrapper assigns it to `process.exitCode`).
+ */
+export declare function runToolLintCli(argv: readonly string[], io?: ToolLintCliIO): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/types/lib/tool-lint/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../../src/lib/tool-lint/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAqBD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,WAAW,EAAE,CAuCnE;AAmDD;;;GAGG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,GAAE,aAKH,GACA,OAAO,CAAC,MAAM,CAAC,CAkDjB"}

package/dist/types/lib/tool-lint/format.d.ts

@@ -0,0 +1,19 @@
+/**
+ * formatToolCatalogReport — human-readable rendering of a lint report.
+ *
+ * Pattern: pure presenter. One report → one string; used verbatim by the
+ *          CLI (`agentfootprint-lint-tools`) and the examples so output
+ *          stays byte-identical across surfaces.
+ * Role:    `src/lib/tool-lint/` leaf. No I/O.
+ */
+import type { ToolCatalogReport } from './types.js';
+export interface FormatReportOptions {
+    /** How many ranked pairs to show in the relative-ordering section.
+     *  Default 10. 0 hides the section. */
+    readonly topPairs?: number;
+    /** How many WATCH pairs to print before eliding the rest (the report
+     *  object always carries all of them). Default 10. */
+    readonly maxWatch?: number;
+}
+export declare function formatToolCatalogReport(report: ToolCatalogReport, options?: FormatReportOptions): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/types/lib/tool-lint/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/lib/tool-lint/format.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,mBAAmB;IAClC;2CACuC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B;0DACsD;IACtD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,mBAAwB,GAChC,MAAM,CA6DR"}

package/dist/types/lib/tool-lint/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * tool-lint — the tool-catalog confusability lint (RFC-002 tier 1,
+ * blocks C1–C3).
+ *
+ * Build-time, CI-gateable, framework-agnostic: a plain
+ * `{ name, description?, inputSchema? }[]` in (any OpenAI / Anthropic /
+ * LangChain / MCP tool list coerces to it), a report with a CI-gateable
+ * `ok` out. The embedding geometry comes from influence-core
+ * (`pairwiseSimilarity`); this module is the policy layer — thresholds,
+ * verdicts, hints, and the pluggable structural rule pack.
+ *
+ * Surfaces:
+ *   - `analyzeToolCatalog(tools, opts)` — the API (C1)
+ *   - `defaultStructuralRules` + rule factories — the rule pack (C2)
+ *   - `runToolLintCli` / bin `agentfootprint-lint-tools` — the gate (C3)
+ *
+ * Front-door guide: docs/guides/tool-catalog-lint.md
+ */
+export type { AnalyzeToolCatalogOptions, CatalogTool, ConfusablePairFinding, LintRule, LintSeverity, PairVerdict, SimilarityReport, StructuralFinding, ToolCatalogReport, } from './types.js';
+export { analyzeToolCatalog, catalogFromTools, confusabilityText, differentiationHint, DEFAULT_CONFUSABILITY_THRESHOLD, DEFAULT_WATCH_BAND, MOCK_EMBEDDER_CALIBRATION, } from './analyze.js';
+export { defaultStructuralRules, descriptionRule, enumInProseRule, optionalParamRule, saysWhatNotWhenRule, DEFAULT_OMISSION_CUES, DEFAULT_WHEN_CUES, type DescriptionRuleOptions, type OptionalParamRuleOptions, type SaysWhatNotWhenRuleOptions, } from './rules.js';
+export { formatToolCatalogReport, type FormatReportOptions } from './format.js';
+export { coerceCatalog, runToolLintCli, type ToolLintCliIO } from './cli.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/tool-lint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/tool-lint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,YAAY,EACV,yBAAyB,EACzB,WAAW,EACX,qBAAqB,EACrB,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,+BAA+B,EAC/B,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,0BAA0B,GAChC,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEhF,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/types/lib/tool-lint/rules.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Structural lint rules (RFC-002 block C2) — the PLUGGABLE RULE PACK.
+ *
+ * Pattern: Strategy list — each rule is a plain `{ id, check }` object;
+ *          `defaultStructuralRules` is OUR pack, and consumers add /
+ *          remove / replace freely via `AnalyzeToolCatalogOptions.rules`.
+ *          Parameterizable rules ship as FACTORIES (`descriptionRule`,
+ *          `saysWhatNotWhenRule`, …) returning a configured `LintRule`.
+ * Role:    `src/lib/tool-lint/` leaf. Pure functions over `CatalogTool`;
+ *          no embedder, no I/O.
+ *
+ * Every rule encodes a FIELD FINDING from real catalogs (the Neo SAN
+ * triage agent's 29-tool catalog was the seed corpus):
+ *
+ *   1. description-missing-or-short — the model can only guess from a name.
+ *   2. says-what-not-when — describes WHAT the tool returns but gives the
+ *      model no cue for WHEN to pick it over a sibling (the #1 cause of
+ *      twin-tool confusion: 'get_fcns_database' vs 'influx_get_fcns_database').
+ *   3. enum-in-prose — string params whose legal values are listed in prose
+ *      ("avg_iops | peak_iops | mbps") instead of a JSON-Schema `enum` the
+ *      model (and validators, see #9 tool-args validation) can act on.
+ *   4. optional-param-undocumented — optional params whose omission has
+ *      meaning (fabric-wide sweep vs one switch) but whose schema never
+ *      says so; the model can't reason about leaving them out.
+ *
+ * Honest claim: these are token/regex HEURISTICS. They flag review
+ * prompts, not certainties — expect (rare) false positives and tune via
+ * the factory options instead of deleting the rule.
+ */
+import type { LintRule } from './types.js';
+export interface DescriptionRuleOptions {
+    /** Descriptions shorter than this (in chars) get a `warn`. Default 40. */
+    readonly minChars?: number;
+}
+/**
+ * Missing description → `error` (the model can only guess from the
+ * name). Present but shorter than `minChars` → `warn` (too short to
+ * differentiate from siblings).
+ */
+export declare function descriptionRule(options?: DescriptionRuleOptions): LintRule;
+/** RFC-002 C2 heuristic cue list — temporal/conditional words whose
+ *  presence suggests the description says WHEN to use the tool. */
+export declare const DEFAULT_WHEN_CUES: readonly string[];
+export interface SaysWhatNotWhenRuleOptions {
+    /** Cue tokens (whole-word, case-insensitive). Default `DEFAULT_WHEN_CUES`. */
+    readonly cueTokens?: readonly string[];
+}
+/**
+ * A description with NO temporal/conditional cue token usually describes
+ * WHAT the tool returns but never WHEN to pick it — the #1 cause of
+ * twin-tool confusion. Heuristic by design: tune `cueTokens` rather than
+ * dropping the rule. Skips tools with no description (rule 1's finding).
+ */
+export declare function saysWhatNotWhenRule(options?: SaysWhatNotWhenRuleOptions): LintRule;
+/**
+ * A string param whose description enumerates its legal values in prose
+ * (pipe-separated literals, or comma lists behind "one of"/"allowed
+ * values") should declare a JSON-Schema `enum` instead — the model picks
+ * reliably from enums, and arg validators (#9) can enforce them. The
+ * field case: Neo's `influx_get_port_ranking.metric` =
+ * `"avg_iops | peak_iops | mbps"`.
+ */
+export declare function enumInProseRule(): LintRule;
+/** Words that signal the description DOES say what omission means. */
+export declare const DEFAULT_OMISSION_CUES: readonly string[];
+export interface OptionalParamRuleOptions {
+    /** Cue tokens that satisfy the rule. Default `DEFAULT_OMISSION_CUES`. */
+    readonly omissionCues?: readonly string[];
+}
+/**
+ * An optional param's omission usually MEANS something (Neo:
+ * `influx_get_interface_counters` without `switch_name` = fabric-wide
+ * sweep) — but the model can only reason about leaving a param out if
+ * the description says so. No description at all, or one with no
+ * omission cue, gets a `warn`.
+ */
+export declare function optionalParamRule(options?: OptionalParamRuleOptions): LintRule;
+/**
+ * OUR rule pack, built with default options. Compose your own:
+ *
+ *   rules: [...defaultStructuralRules, myRule]                 // add
+ *   rules: defaultStructuralRules.filter(r => r.id !== '…')    // remove
+ *   rules: [descriptionRule({ minChars: 80 }), …]              // re-tune
+ */
+export declare const defaultStructuralRules: readonly LintRule[];
+//# sourceMappingURL=rules.d.ts.map

package/dist/types/lib/tool-lint/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../../src/lib/tool-lint/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAe,QAAQ,EAAqB,MAAM,YAAY,CAAC;AA2C3E,MAAM,WAAW,sBAAsB;IACrC,0EAA0E;IAC1E,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,QAAQ,CA6B9E;AAID;mEACmE;AACnE,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAO9C,CAAC;AAEF,MAAM,WAAW,0BAA0B;IACzC,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B,GAAG,QAAQ,CAqBtF;AAcD;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,QAAQ,CA4B1C;AAgBD,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAalD,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,yEAAyE;IACzE,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,wBAA6B,GAAG,QAAQ,CA+BlF;AAID;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,QAAQ,EAKrD,CAAC"}