agentfootprint 6.22.0 → 6.24.0

package/dist/types/lib/influence-core/margin.d.ts

@@ -0,0 +1,34 @@
+import type { Embedder, MarginCandidate, MarginResult } from './types.js';
+export interface ScoreMarginArgs {
+    /** The offered candidates (e.g. the tool catalog on `llm_start`). */
+    readonly candidates: readonly MarginCandidate[];
+    /** The choice context — the text the chooser ranked against. */
+    readonly contextText: string;
+    /** Names of the chosen candidate(s). Must exist in `candidates`. */
+    readonly chosen: readonly string[];
+    /**
+     * Injected embedder. Wrap in an `EmbeddingCache` so descriptions
+     * embed once across calls (RFC-002 §3 — the same cache the catalog
+     * lint already filled).
+     */
+    readonly embedder: Embedder;
+    /** Margins below this flag `narrow`. Default 0.05 (RFC-002 §4). */
+    readonly marginThreshold?: number;
+    /** Abort signal threaded to the embedder (network backends). */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Rank candidates by cosine similarity to the choice context and
+ * measure how decisively the chosen one(s) won.
+ *
+ * Returns ranked `scores` (descending; ties keep candidate input
+ * order), the `topScored` name, the `margin` (undefined when every
+ * candidate was chosen — no competition to measure; `narrow` is false
+ * in that case), and the two flags.
+ *
+ * Fail-loud validation: empty candidates/chosen, duplicate candidate
+ * names, or a chosen name missing from the candidates throw — those
+ * are wiring bugs in the caller, not runtime conditions.
+ */
+export declare function scoreMargin(args: ScoreMarginArgs): Promise<MarginResult>;
+//# sourceMappingURL=margin.d.ts.map

package/dist/types/lib/influence-core/margin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"margin.d.ts","sourceRoot":"","sources":["../../../../src/lib/influence-core/margin.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAkB,QAAQ,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1F,MAAM,WAAW,eAAe;IAC9B,qEAAqE;IACrE,QAAQ,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;IAChD,gEAAgE;IAChE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,gEAAgE;IAChE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,YAAY,CAAC,CA6C9E"}

package/dist/types/lib/influence-core/signals.d.ts

@@ -0,0 +1,104 @@
+import type { Embedder, EvidenceInput, InfluenceScore, InfluenceWeights, SignalScores } from './types.js';
+/**
+ * FA — Final Answer Similarity (paper Eq. 1).
+ *
+ * `FA(d) = sim(e_d, e_f)` — cosine between the evidence embedding and
+ * the final-answer embedding. The strongest prior: verbatim or
+ * paraphrased reuse of a tool result scores high. Proxy: semantic
+ * overlap, not provenance.
+ */
+export declare function finalAnswerSimilarity(evidenceVec: readonly number[], finalAnswerVec: readonly number[]): number;
+/**
+ * AVG — Average Relevancy (paper Eq. 2).
+ *
+ * Mean cosine between the evidence and each LLM reasoning ancestor;
+ * 0 when there are no ancestors (structurally zero — see
+ * `adaptWeights`). Proxy: consistent semantic closeness across the
+ * chain, not actual consultation.
+ */
+export declare function averageRelevancy(evidenceVec: readonly number[], ancestorVecs: ReadonlyArray<readonly number[]>): number;
+/**
+ * PERSIST — Persistence (paper Eq. 3).
+ *
+ * Fraction of ancestors whose similarity to the evidence EXCEEDS the
+ * threshold T (strict `>`, default 0.30); 0 when there are no
+ * ancestors. Unlike AVG it measures BREADTH: referenced in 4 of 5
+ * steps (0.8) beats referenced intensely in 1. Proxy: similarity
+ * above a tunable bar, not counted citations.
+ */
+export declare function persistence(evidenceVec: readonly number[], ancestorVecs: ReadonlyArray<readonly number[]>, threshold?: number): number;
+/**
+ * DEPTH — Structural Proximity (paper Eq. 4).
+ *
+ * `DEPTH(d) = 1 / (1 + n)` where n counts LLM reasoning ancestors
+ * ONLY (not pipeline plumbing — callers decide what counts as an
+ * ancestor when building `EvidenceInput.ancestorTexts`). Direct
+ * evidence with no intermediaries gets exactly 1.0. The only
+ * content-blind signal: pure trace structure.
+ */
+export declare function structuralProximity(ancestorCount: number): number;
+/**
+ * Adaptive weight redistribution (paper Eq. 6, §5.3).
+ *
+ * When an item has NO LLM ancestors, AVG and PERSIST are structurally
+ * zero — not because the evidence was uninfluential, but because there
+ * is nothing to measure against. Without adaptation its score is
+ * capped at α+δ (≈0.50 under defaults). Eq. 6 moves the β+γ mass onto
+ * FA and DEPTH preserving their ratio:
+ *
+ *   α′ = α + (β+γ)·α/(α+δ),  δ′ = δ + (β+γ)·δ/(α+δ),  β′ = γ′ = 0
+ *
+ * Defaults → α′=0.80, δ′=0.20 (the 4:1 FA:DEPTH ratio kept).
+ * Per-evidence-item: in a multi-tool pipeline some items adapt while
+ * others keep standard weights; `adapted` says which (surface it — the
+ * paper's UI marks adapted items).
+ *
+ * Degenerate guard: if α+δ = 0 there is no defined ratio to preserve —
+ * weights return unchanged with `adapted: false`, and the composite is
+ * honestly 0 for a no-ancestor item.
+ */
+export declare function adaptWeights(weights: InfluenceWeights, ancestorCount: number): {
+    weights: InfluenceWeights;
+    adapted: boolean;
+};
+/**
+ * Composite score S(d) (paper Eq. 5).
+ *
+ * `S = α·FA + β·AVG + γ·PERSIST + δ·DEPTH` under the given weights —
+ * pass the EFFECTIVE weights from `adaptWeights` for no-ancestor
+ * items. With weights summing to 1, S ∈ [−(α+β), 1] (FA/AVG are
+ * cosines and may go negative; PERSIST/DEPTH are non-negative).
+ */
+export declare function compositeScore(signals: SignalScores, weights: InfluenceWeights): number;
+export interface ScoreInfluenceArgs {
+    /** Evidence items (tool results / context sources) with ancestors. */
+    readonly evidence: readonly EvidenceInput[];
+    /** The final answer text the evidence is scored against. */
+    readonly finalAnswerText: string;
+    /**
+     * Injected embedder. Wrap in an `EmbeddingCache` to share embeddings
+     * with the catalog lint / margin scorer (RFC-002 §3 — one cache
+     * serves all three consumers).
+     */
+    readonly embedder: Embedder;
+    /** Composite weights. Default: paper priors 0.40/0.30/0.20/0.10. */
+    readonly weights?: InfluenceWeights;
+    /** PERSIST threshold T. Default 0.30. */
+    readonly persistenceThreshold?: number;
+    /** Abort signal threaded to the embedder (network backends). */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Score every evidence item on the four FDL signals and rank by
+ * composite, descending (paper pipeline stages 4–6 in one call:
+ * embed → score → rank). Ties keep input order (stable sort).
+ *
+ * Deterministic for a deterministic embedder: same inputs → same
+ * scores. All texts are embedded in ONE deduplicated batch — with an
+ * `EmbeddingCache` injected, repeat calls embed nothing.
+ *
+ * Honest claim: ranked semantic-alignment proxies. NOT causal
+ * attribution — see module docs.
+ */
+export declare function scoreInfluence(args: ScoreInfluenceArgs): Promise<InfluenceScore[]>;
+//# sourceMappingURL=signals.d.ts.map

package/dist/types/lib/influence-core/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../../../src/lib/influence-core/signals.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,YAAY,EACb,MAAM,YAAY,CAAC;AAGpB;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,MAAM,CAER;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,YAAY,EAAE,aAAa,CAAC,SAAS,MAAM,EAAE,CAAC,GAC7C,MAAM,CAQR;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,YAAY,EAAE,aAAa,CAAC,SAAS,MAAM,EAAE,CAAC,EAC9C,SAAS,GAAE,MAAsC,GAChD,MAAM,CAQR;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAOjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,MAAM,GACpB;IAAE,OAAO,EAAE,gBAAgB,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAcjD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAOvF;AAED,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;IAC5C,4DAA4D;IAC5D,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,gEAAgE;IAChE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAuCxF"}

package/dist/types/lib/influence-core/similarity.d.ts

@@ -0,0 +1,26 @@
+import type { Embedder, PairwiseSimilarityResult, SimilarityItem } from './types.js';
+export interface PairwiseSimilarityArgs {
+    /** The texts to compare — e.g. `{ id: toolName, text: description }`. */
+    readonly items: readonly SimilarityItem[];
+    /**
+     * Injected embedder. Wrap in an `EmbeddingCache` so catalog
+     * descriptions embed once across lint runs (RFC-002 §3).
+     */
+    readonly embedder: Embedder;
+    /** Abort signal threaded to the embedder (network backends). */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Embed every item once (deduplicated batch) and compute the full
+ * cosine matrix plus ranked upper-triangle pairs (descending; ties
+ * keep input pair order).
+ *
+ * Invariants (pinned by property tests):
+ *  - `matrix[i][j] === matrix[j][i]` — computed once, mirrored.
+ *  - `matrix[i][i] === 1` EXACTLY — set by definition, so
+ *    self-similarity is an invariant rather than a float artifact
+ *    (and duplicate texts at different ids still compare via cosine).
+ *  - N items → N·(N−1)/2 pairs.
+ */
+export declare function pairwiseSimilarity(args: PairwiseSimilarityArgs): Promise<PairwiseSimilarityResult>;
+//# sourceMappingURL=similarity.d.ts.map

package/dist/types/lib/influence-core/similarity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarity.d.ts","sourceRoot":"","sources":["../../../../src/lib/influence-core/similarity.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,QAAQ,EACR,wBAAwB,EACxB,cAAc,EAEf,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,sBAAsB;IACrC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,wBAAwB,CAAC,CAoCnC"}

package/dist/types/lib/influence-core/types.d.ts

@@ -0,0 +1,158 @@
+/**
+ * influence-core types — the ONE embedding-based scoring contract.
+ *
+ * Pattern: Strategy seam (plug-and-play meta-pattern) — the frame and
+ *          rule engine are the library's; the `Embedder` is consumer-
+ *          injected, exactly like NarrativeFormatter / reliability /
+ *          permission / commentary strategies.
+ * Role:    `src/lib/` leaf module. Shared by the FDL paper pipeline
+ *          (Visible Reasoning, Eq. 1–6), RFC-002's tool-catalog lint +
+ *          margin recorder (C1/C4/C5), and RFC-003 Part B's LLM-edge
+ *          weigher (D7). Extracted as RFC-003 block D6 so all three
+ *          consumers share one scoring engine and one embedding cache.
+ *
+ * ## Honest claim (RFC-002 §2, the FDL discipline)
+ *
+ * Every score produced under these types is a PROXY computed from
+ * embedding geometry — cosine similarity over consumer-injected
+ * embeddings. None of it reads model internals. Scores mean "high
+ * semantic alignment", never "the model chose/answered BECAUSE".
+ * Scores are not additive across items and are not causal attribution
+ * — counterfactual ablation (RFC-003 stage 4) is where causal claims
+ * live.
+ */
+export type { Embedder, EmbedArgs, EmbedBatchArgs } from '../../memory/embedding/types.js';
+/**
+ * Weights for the four-signal composite (paper Eq. 5).
+ *
+ * Configurable PRIORS, not learned parameters (paper §8). Defaults
+ * encode: direct semantic similarity (fa) strongest, then consistency
+ * across reasoning (avg), breadth of reference (persist), structural
+ * proximity (depth).
+ */
+export interface InfluenceWeights {
+    /** α — Final Answer Similarity weight. */
+    readonly fa: number;
+    /** β — Average Relevancy weight. */
+    readonly avg: number;
+    /** γ — Persistence weight. */
+    readonly persist: number;
+    /** δ — Structural Proximity weight. */
+    readonly depth: number;
+}
+/** Paper defaults: α=0.40, β=0.30, γ=0.20, δ=0.10 (sum to 1.0). */
+export declare const DEFAULT_INFLUENCE_WEIGHTS: InfluenceWeights;
+/** Paper default for the PERSIST threshold T (Eq. 3). */
+export declare const DEFAULT_PERSISTENCE_THRESHOLD = 0.3;
+/** RFC-002 §4 default: margins below this flag the choice as `narrow`. */
+export declare const DEFAULT_MARGIN_THRESHOLD = 0.05;
+/** The four signal values for one evidence item (paper Eq. 1–4). */
+export interface SignalScores {
+    /** FA — cosine(evidence, finalAnswer). Range [-1, 1]. */
+    readonly fa: number;
+    /** AVG — mean cosine(evidence, ancestor_i); 0 when no ancestors. */
+    readonly avg: number;
+    /** PERSIST — fraction of ancestors with similarity > T; 0 when none. */
+    readonly persist: number;
+    /** DEPTH — 1 / (1 + ancestorCount). Range (0, 1]. */
+    readonly depth: number;
+}
+/** One evidence item to score: a tool result (or any context source)
+ *  plus the texts of the LLM reasoning steps that referenced it. */
+export interface EvidenceInput {
+    /** Stable identifier — e.g. a runtimeStageId or tool-call id. */
+    readonly id: string;
+    /** The evidence text (tool result content). */
+    readonly text: string;
+    /**
+     * Texts of the item's LLM reasoning ANCESTORS — only stages with
+     * model text output, not pipeline plumbing (paper §5.1, DEPTH).
+     * Empty array = direct evidence with no intermediaries.
+     */
+    readonly ancestorTexts: readonly string[];
+}
+/** Scored evidence item — the per-item output of `scoreInfluence`. */
+export interface InfluenceScore {
+    readonly id: string;
+    /** The four raw signals (proxies — see module honest claim). */
+    readonly signals: SignalScores;
+    /**
+     * The EFFECTIVE weights used for this item — equals the configured
+     * weights normally; the Eq. 6 redistribution when `adapted` is true.
+     */
+    readonly weights: InfluenceWeights;
+    /**
+     * True when adaptive weight redistribution (paper Eq. 6) applied —
+     * the item had no LLM ancestors, so AVG/PERSIST were structurally
+     * zero and their weight mass moved onto FA/DEPTH. Per-item: a
+     * multi-tool pipeline may mix adapted and standard items.
+     */
+    readonly adapted: boolean;
+    /** Composite S(d) (Eq. 5) under the effective weights. */
+    readonly score: number;
+}
+/** A text item for pairwise comparison (e.g. a tool description). */
+export interface SimilarityItem {
+    /** Stable identifier — e.g. the tool name. Must be unique. */
+    readonly id: string;
+    readonly text: string;
+}
+/** One ranked pair from `pairwiseSimilarity`. */
+export interface SimilarityPair {
+    /** id of the first item (lower input index). */
+    readonly a: string;
+    /** id of the second item (higher input index). */
+    readonly b: string;
+    /** cosine(embed(a.text), embed(b.text)). */
+    readonly similarity: number;
+}
+export interface PairwiseSimilarityResult {
+    /** Item ids in input order — the matrix axes. */
+    readonly ids: readonly string[];
+    /**
+     * Full similarity matrix, `matrix[i][j] = cosine(item_i, item_j)`.
+     * Symmetric by construction; the diagonal is EXACTLY 1 by definition
+     * (self-similarity is an invariant, not a float approximation).
+     */
+    readonly matrix: ReadonlyArray<readonly number[]>;
+    /** Upper-triangle pairs ranked by similarity, descending. */
+    readonly pairs: readonly SimilarityPair[];
+}
+/** A candidate in a choice competition (e.g. an offered tool). */
+export interface MarginCandidate {
+    /** Unique name — the identifier the chooser used. */
+    readonly name: string;
+    /** The text the chooser saw (the tool description). */
+    readonly text: string;
+}
+/** One candidate's proximity to the choice context, ranked. */
+export interface CandidateScore {
+    readonly name: string;
+    /** cosine(embed(contextText), embed(candidate.text)). */
+    readonly score: number;
+}
+export interface MarginResult {
+    /** All candidates ranked by score, descending. */
+    readonly scores: readonly CandidateScore[];
+    /** The chosen candidate names, echoed from the input. */
+    readonly chosen: readonly string[];
+    /** Name of the highest-scoring candidate (by the proxy). */
+    readonly topScored: string;
+    /**
+     * score(best chosen) − score(best non-chosen). Small margin =
+     * fragile choice. `undefined` when every candidate was chosen
+     * (no competition to measure).
+     */
+    readonly margin: number | undefined;
+    readonly flags: {
+        /** margin < marginThreshold — the choice was a close call. */
+        readonly narrow: boolean;
+        /**
+         * The top-scored candidate was NOT among the chosen. Either a
+         * proxy miss or a genuinely surprising choice — both are exactly
+         * what a debugger wants surfaced (RFC-002 §4).
+         */
+        readonly proxyDisagreement: boolean;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/influence-core/types.d.ts.map

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

package/dist/types/lib/trace-toolpack/bounded.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Bounded serialization helpers for the trace toolpack.
+ *
+ * Pattern: pure functions — no state, no events.
+ * Role:    The token-economics layer. EVERY value the toolpack serves goes
+ *          through these: previews are capped, truncation is EXPLICIT
+ *          (never silent), and nested-path keys round-trip between the
+ *          engine's DELIM encoding and LLM-friendly dot notation.
+ */
+/**
+ * footprintjs's canonical nested-path delimiter (ASCII unit separator,
+ * `src/lib/memory/utils.ts`). Internal to the engine — the toolpack
+ * translates it to/from dot notation so the LLM never sees a control char.
+ */
+export declare const FP_PATH_DELIM = "\u001F";
+/** Engine path → LLM-friendly dotted display form. */
+export declare function displayKey(path: string): string;
+/**
+ * LLM-supplied key → engine path. Exact keys pass through; a dotted key
+ * that doesn't exist verbatim but matches a known DELIM-joined path is
+ * translated back. `knownPaths` is the set of every path seen in the
+ * commit log's trace entries.
+ */
+export declare function normalizeKey(key: string, knownPaths: ReadonlySet<string>): string;
+/** Replace every DELIM in an already-formatted text block with '.' for display. */
+export declare function displayText(text: string): string;
+/**
+ * Serialize a value to compact JSON, total-function style: cycles, BigInt
+ * and other non-JSON values degrade to a tagged placeholder instead of
+ * throwing — a debugger tool must never crash on the evidence it serves.
+ */
+export declare function safeStringify(value: unknown): string;
+/** A bounded preview of a value: capped text + the TRUE total size, never silent. */
+export interface BoundedPreview {
+    /** The (possibly truncated) serialized text. */
+    readonly text: string;
+    /** Full serialized length in chars — so the consumer knows what it's NOT seeing. */
+    readonly totalChars: number;
+    /** True when `text` is shorter than the full serialization. */
+    readonly truncated: boolean;
+}
+/** Serialize + cap at `maxChars`. Truncation is reported, never silent. */
+export declare function boundedPreview(value: unknown, maxChars: number): BoundedPreview;
+/** Render a preview with its honesty suffix when truncated. */
+export declare function renderPreview(preview: BoundedPreview, fetchHint?: string): string;
+/** Clamp an LLM-supplied numeric param into [min, hardCap], with a default. */
+export declare function clampParam(requested: number | undefined, fallback: number, min: number, hardCap: number): number;
+//# sourceMappingURL=bounded.d.ts.map

package/dist/types/lib/trace-toolpack/bounded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/bounded.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;GAIG;AACH,eAAO,MAAM,aAAa,WAAW,CAAC;AAEtC,sDAAsD;AACtD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAOjF;AAED,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQpD;AAED,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC7B,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAM/E;AAED,+DAA+D;AAC/D,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAIjF;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACd,MAAM,CAGR"}

package/dist/types/lib/trace-toolpack/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * trace-toolpack — RFC-003 Part C: the introspection toolpack.
+ *
+ * footprintjs trace evidence exposed as TOOLS an LLM calls: a debugging
+ * model navigates a COMPLETED run's evidence by runtimeStageIds instead of
+ * reading dumps. Bounded, honest (⚠ markers), redaction-respecting.
+ */
+export { callTraceTool, traceToolpack } from './traceToolpack.js';
+export { TOOLPACK_HARD_CAPS, type TraceToolpackArtifacts, type TraceToolpackOptions, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/lib/trace-toolpack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EACL,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,GAC1B,MAAM,YAAY,CAAC"}

package/dist/types/lib/trace-toolpack/traceToolpack.d.ts

@@ -0,0 +1,70 @@
+/**
+ * traceToolpack — footprintjs trace evidence exposed as TOOLS an LLM calls
+ * (RFC-003 Part C: the introspection toolpack).
+ *
+ * "The framework's internal tool for itself": after a run completes, a
+ * debugging LLM (a cheap model in a SEPARATE session) navigates the run's
+ * evidence by ids instead of reading dumps — the same just-in-time,
+ * token-efficient loading pattern as `read_skill`. Feed the slice, not the
+ * trace; the LLM ranks by navigating, so no embedder is needed.
+ *
+ * Pattern: Factory over frozen artifacts. `traceToolpack(artifacts)` returns
+ *          plain `Tool[]` — mount them on any Agent, or drive them scripted
+ *          via `callTraceTool` (the offline auditor pattern, like
+ *          examples/features/20). Nothing re-runs; every tool is a bounded
+ *          read-only VIEW over a COMPLETED run's snapshot + commit log.
+ *
+ * The toolpack's three contracts (B13 posture):
+ *
+ *   1. BOUNDED BY DEFAULT — every output is capped (previews, slice
+ *      depth/nodes, value chars, narrative lines). Per-call params raise
+ *      the budget only up to hard caps the LLM cannot exceed.
+ *   2. HONEST — truncation and incompleteness are ALWAYS marked (⚠), never
+ *      silent: truncated slices, untracked sources (args/env/silent reads),
+ *      missing read tracking, missing control-dependence lookup, values the
+ *      commit log cannot see (pre-run state, closures).
+ *   3. REDACTION-RESPECTING — the commit log already carries redacted
+ *      payloads (footprintjs scrubs at commit time); the toolpack passes
+ *      placeholders through verbatim and flags redacted keys. It never
+ *      reconstructs around a redaction.
+ *
+ * Why ids: every view names steps by `runtimeStageId`
+ * (`stageId#executionIndex`) — the universal key linking the commit log,
+ * the execution tree, and recorder events. The LLM drills like a debugger:
+ * overview → slice → node → value, paying only for what it opens.
+ */
+import { type Tool } from '../../core/tools.js';
+import { type TraceToolpackArtifacts, type TraceToolpackOptions } from './types.js';
+/**
+ * Build the introspection toolpack over a COMPLETED run's artifacts.
+ *
+ * Returns plain `Tool[]`:
+ *
+ * | Tool             | Question it answers                                       |
+ * |------------------|-----------------------------------------------------------|
+ * | `run_overview`   | What happened, broadly? (the entry point)                 |
+ * | `trace_node`     | What did step X read/write, and where did its inputs come from? |
+ * | `trace_slice`    | Which chain of steps produced the data at X? (causal slice) |
+ * | `who_wrote`      | Which step last wrote key K?                              |
+ * | `get_value`      | The full value of K as of step X (capped, truncation-marked) |
+ * | `read_narrative` | The human-readable story, paginated (only when narrative provided) |
+ *
+ * Mount on an Agent (`Agent.create({...}).tool(...tools)`) or drive scripted
+ * via {@link callTraceTool}. The tools NEVER throw on bad ids/keys — they
+ * return corrective, model-visible messages (the #9 philosophy), and their
+ * strict input schemas give Agent-dispatched calls free arg validation.
+ *
+ * Security note (B13 posture): trace content can carry adversarial text from
+ * the original run (tool results, user input). Serve these tools to a
+ * SEPARATE debugging session over completed runs — not to the production
+ * agent mid-run — and treat tool outputs as data, not instructions.
+ */
+export declare function traceToolpack(artifacts: TraceToolpackArtifacts, options?: TraceToolpackOptions): Tool[];
+/**
+ * Invoke a toolpack tool OUTSIDE an Agent (scripted debug sessions, tests,
+ * offline auditors). Mirrors the Agent's #9 boundary: args are validated
+ * against the tool's inputSchema first, and an invalid call returns the same
+ * model-visible correction string instead of executing.
+ */
+export declare function callTraceTool(tools: readonly Tool[], name: string, args?: Record<string, unknown>): Promise<string>;
+//# sourceMappingURL=traceToolpack.d.ts.map

package/dist/types/lib/trace-toolpack/traceToolpack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceToolpack.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/traceToolpack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAMH,OAAO,EAAc,KAAK,IAAI,EAA6B,MAAM,qBAAqB,CAAC;AAWvF,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAiNpB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,sBAAsB,EACjC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,EAAE,CAeR;AA8jBD;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/dist/types/lib/trace-toolpack/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Trace toolpack types — RFC-003 Part C (the introspection toolpack).
+ *
+ * Pattern: artifact bag — everything a debugging LLM needs to navigate a
+ *          COMPLETED run, captured once and handed to `traceToolpack()`.
+ * Role:    Input contract. The toolpack never re-runs anything; it serves
+ *          bounded, id-addressed views over these frozen artifacts.
+ */
+import type { RuntimeSnapshot } from 'footprintjs';
+import type { ControlDepLookup } from 'footprintjs/trace';
+/**
+ * The frozen evidence of one completed run.
+ *
+ * - `snapshot` — `executor.getSnapshot()`. Carries the commit log (what every
+ *   step wrote, with verbs + redaction + `untrackedSources` honesty markers),
+ *   the execution tree (per-step name/description/reads/errors), the final
+ *   shared state, and the `commitValues` mode discriminant.
+ * - `controlDeps` — OPTIONAL `controlDepRecorder().asLookup()` from the run.
+ *   With it, causal slices include `[control: <rule label>]` edges to the
+ *   decider that routed execution. Without it, slices say so explicitly.
+ * - `narrative` — OPTIONAL narrative lines (e.g. rendered from
+ *   `executor.getNarrativeEntries()`). When present, a `read_narrative` tool
+ *   is added for bounded, paginated access to the human-readable story.
+ */
+export interface TraceToolpackArtifacts {
+    readonly snapshot: RuntimeSnapshot;
+    readonly controlDeps?: ControlDepLookup;
+    readonly narrative?: readonly string[];
+}
+/**
+ * Bounding dials. Every output is bounded BY DEFAULT — these set the
+ * defaults; per-call params (`maxDepth`, `maxNodes`, `maxChars`, `maxLines`)
+ * let the LLM ask for more up to hard caps the consumer cannot exceed.
+ */
+export interface TraceToolpackOptions {
+    /** Value-preview length in chars (trace_node / who_wrote). Default 160. */
+    readonly previewChars?: number;
+    /** Default causal-slice depth for trace_slice. Default 6 (hard cap 20). */
+    readonly sliceMaxDepth?: number;
+    /** Default causal-slice node budget for trace_slice. Default 25 (hard cap 100). */
+    readonly sliceMaxNodes?: number;
+    /** Default char budget for get_value. Default 2000 (hard cap 8000). */
+    readonly valueMaxChars?: number;
+}
+/** Resolved options with defaults applied (internal). */
+export interface ResolvedToolpackOptions {
+    readonly previewChars: number;
+    readonly sliceMaxDepth: number;
+    readonly sliceMaxNodes: number;
+    readonly valueMaxChars: number;
+}
+/** Hard caps — per-call params clamp to these regardless of what the LLM asks for. */
+export declare const TOOLPACK_HARD_CAPS: {
+    readonly sliceMaxDepth: 20;
+    readonly sliceMaxNodes: 100;
+    readonly valueMaxChars: 8000;
+    readonly narrativeMaxLines: 200;
+};
+export declare function resolveToolpackOptions(options?: TraceToolpackOptions): ResolvedToolpackOptions;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/lib/trace-toolpack/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/lib/trace-toolpack/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,2EAA2E;IAC3E,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,mFAAmF;IACnF,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,uEAAuE;IACvE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,yDAAyD;AACzD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,sFAAsF;AACtF,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AAEX,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,uBAAuB,CAO9F"}

package/dist/types/observe.d.ts

@@ -50,4 +50,6 @@ export { attachStatus, type StatusEvent, type StatusOptions, } from './recorders
 export { toolLineageRecorder, type ToolLineageRecorderHandle, type ToolLineageOptions, type ToolLineageGraph, type ToolLineageEdge, type ToolCallRef, } from './recorders/observability/ToolLineageRecorder.js';
 export { agentThinkingTrace, type AgentThinkingTraceHandle, type AgentThinkingTraceOptions, type AttTrace, type AttStep, type AttCost, type AttAnswer, type AttToolSeen, } from './recorders/observability/AgentThinkingTraceRecorder.js';
 export { typedEmit } from './recorders/core/typedEmit.js';
+export { adaptWeights, averageRelevancy, compositeScore, contentHash, DEFAULT_INFLUENCE_WEIGHTS, DEFAULT_MARGIN_THRESHOLD, DEFAULT_PERSISTENCE_THRESHOLD, EmbeddingCache, embeddingCache, finalAnswerSimilarity, pairwiseSimilarity, persistence, scoreInfluence, scoreMargin, structuralProximity, type CandidateScore, type Embedder, type EmbeddingCacheOptions, type EmbeddingCacheStats, type EvidenceInput, type InfluenceScore, type InfluenceWeights, type MarginCandidate, type MarginResult, type PairwiseSimilarityArgs, type PairwiseSimilarityResult, type ScoreInfluenceArgs, type ScoreMarginArgs, type SignalScores, type SimilarityItem, type SimilarityPair, } from './lib/influence-core/index.js';
+export { callTraceTool, TOOLPACK_HARD_CAPS, traceToolpack, type TraceToolpackArtifacts, type TraceToolpackOptions, } from './lib/trace-toolpack/index.js';
 //# sourceMappingURL=observe.d.ts.map

package/dist/types/observe.d.ts.map

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

package/dist/types/recorders/core/typedEmit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typedEmit.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/typedEmit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEhG;;;;GAIG;AACH,UAAU,aAAa;IACrB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,uBAAuB,EACzD,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAC5C,IAAI,CAEN"}
+{"version":3,"file":"typedEmit.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/typedEmit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEhG;;;;GAIG;AACH,UAAU,aAAa;IACrB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9C;AA4BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,uBAAuB,EACzD,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAC5C,IAAI,CAGN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "6.22.0",
+  "version": "6.24.0",
   "description": "The explainable agent framework — build AI agents you can explain, audit, and trust. Built on footprintjs.",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",
@@ -184,7 +184,7 @@
     "@aws-sdk/client-xray": "*",
     "@modelcontextprotocol/sdk": "*",
     "@opentelemetry/api": "*",
-    "footprintjs": "^9.1.0",
+    "footprintjs": "^9.8.0",
     "ioredis": "*",
     "openai": "*",
     "zod": "*"
@@ -229,7 +229,7 @@
     "esbuild": "^0.28.0",
     "eslint": "^8.44.0",
     "eslint-config-prettier": "^6.15.0",
-    "footprintjs": "^9.1.0",
+    "footprintjs": "^9.8.0",
     "prettier": "^2.8.1",
     "typedoc": "^0.28.19",
     "typedoc-plugin-markdown": "^4.11.0",