agentfootprint 8.7.0 → 8.9.0

package/dist/types/memory/retrieval/types.d.ts

@@ -0,0 +1,190 @@
+/**
+ * retrieval/types — the record a retrieval leaves behind, and the seam
+ * that decides which candidates reach the prompt.
+ *
+ * Pattern: Strategy (the seam) + Value objects (the record).
+ * Role:    memory/ layer. The law this folder exists to keep is stated
+ *          once, here, because every stage downstream implements a piece
+ *          of it: **a retrieval must be able to say what it considered,
+ *          not only what it used.**
+ * Emits:   N/A (types only). `loadRelevant` emits
+ *          `agentfootprint.memory.retrieved` from the record below;
+ *          `formatDefault` emits `agentfootprint.memory.attached` per
+ *          admitted chunk.
+ *
+ * Before 8.8.0 a retrieval computed a cosine score for every candidate
+ * and then threw all of them away one line later (`results.map(r =>
+ * r.entry)`). The prompt carried the passages; nothing carried the
+ * reason. "Why did the agent read this passage" had no answer in the
+ * recording, and "why did it NOT read that one" had no answer anywhere —
+ * a below-threshold candidate was filtered inside the store and never
+ * came back. {@link RetrievalEvidence} is what that answer is made of.
+ */
+import type { MemoryEntry } from '../entry/index.js';
+/**
+ * Why a candidate did not reach the prompt. Every rejected candidate
+ * names one of these — a rejection without a reason is the silence this
+ * whole record exists to remove.
+ */
+export type RetrievalRejectReason = 
+/** Scored below the retriever's `threshold`. The quality floor refused it. */
+'below-threshold'
+/** Cleared the threshold, but the context-token budget had no room left. */
+ | 'over-budget'
+/** Cleared the threshold and the budget, but the picker's `maxEntries` cap was full. */
+ | 'over-max-entries';
+/**
+ * One candidate the retrieval considered — admitted or not.
+ *
+ * `rank` is the candidate's position by SCORE (1-based, descending),
+ * which is not necessarily the order it appears in the prompt: the
+ * budget picker admits by recency (see {@link RetrievalEvidence.selectionOrder}).
+ * Recording both is the point — a reader can see that the best-scoring
+ * chunk was admitted third, and know that was the picker's doing.
+ */
+export interface RetrievedCandidate {
+    /** The store entry's id. For an indexed corpus this is the chunk id. */
+    readonly id: string;
+    /** Similarity as the store reported it. Cosine ([-1, 1]) for every shipped store. */
+    readonly score: number;
+    /** 1-based position by score, descending, across the whole candidate pool. */
+    readonly rank: number;
+    /** Did this candidate's text reach the prompt? */
+    readonly admitted: boolean;
+    /** Present exactly when `admitted` is false. */
+    readonly reason?: RetrievalRejectReason;
+    /** Source document, when the indexed value carried one in its metadata. */
+    readonly docUri?: string;
+    /** Page number, when the loader knew one (PDFs). */
+    readonly page?: number;
+    /** Section heading, when the splitter knew one. */
+    readonly heading?: string;
+    /**
+     * The exact prompt bytes this chunk contributed, set by the formatter
+     * for admitted candidates. Joining every admitted candidate's fragment
+     * **in {@link promptPosition} order** with `\n\n` reproduces the
+     * injected message exactly — which is what lets one retrieval become
+     * one `InjectionRecord` PER CHUNK without changing a single byte the
+     * model sees.
+     */
+    readonly promptFragment?: string;
+    /**
+     * Where this chunk sat in the injected message, 0-based.
+     *
+     * NOT the same as {@link rank}, and the difference is the honest part:
+     * `rank` is how well the chunk scored, `promptPosition` is where the
+     * budget picker put it. Under the default recency ordering the
+     * best-scoring chunk can land last — which is exactly the kind of thing
+     * a lost-in-the-middle investigation needs to be able to see, and which
+     * a record that only kept one of the two orders could not show.
+     */
+    readonly promptPosition?: number;
+}
+/**
+ * Everything one retrieval knows about itself. Written to the memory
+ * subflow's scope by `loadRelevant`, refined by `pickByBudget` and
+ * `formatDefault`, and lifted to the PARENT scope by the read mount so
+ * it lands in the root commit log where a slice can reach it.
+ */
+export interface RetrievalEvidence {
+    /** The retriever's id (`defineRAG({ id })`). Stamped by the read mount. */
+    readonly memoryId?: string;
+    /**
+     * A stable hash of the query text — NOT the text. The query is already
+     * in the recording once (as `userMessage`); copying it into a second
+     * key would widen the exposure surface for no new information, and any
+     * redaction policy the host configured for the first copy would not
+     * know about the second.
+     */
+    readonly queryHash: string;
+    /** How many chunks the retriever was willing to admit. */
+    readonly k: number;
+    /** The quality floor. Absent when the retriever set none. */
+    readonly threshold?: number;
+    /** The embedder id the query was produced with, when the caller declared one. */
+    readonly embedderId?: string;
+    /** Length of the query vector. Mixing two lengths in one store is a config bug. */
+    readonly dimensions?: number;
+    /** How the budget picker ordered the admitted set. See the note on `rank`. */
+    readonly selectionOrder: 'recency' | 'relevance';
+    /** How many candidates came back from the store. */
+    readonly consideredCount: number;
+    /** How many reached the prompt. */
+    readonly admittedCount: number;
+    /** `consideredCount - admittedCount`. */
+    readonly rejectedCount: number;
+    /**
+     * The candidates themselves, best-scoring first.
+     *
+     * `undefined` means this store could not tell us — see
+     * {@link candidatesOmittedReason}. It never means "there were none";
+     * that case is `[]` with `consideredCount: 0`.
+     */
+    readonly candidates?: readonly RetrievedCandidate[];
+    /**
+     * Whether {@link candidates} is the complete set of candidates that
+     * existed, or only as far as the pool we asked for reached.
+     *
+     * `false` does NOT weaken the admitted set — see the proof in
+     * `loadRelevant`. It only means the REJECTED list is a sample: there
+     * may be further below-threshold entries we never saw.
+     */
+    readonly candidatesComplete: boolean;
+    /** Present exactly when `candidates` is undefined. */
+    readonly candidatesOmittedReason?: string;
+    /**
+     * The store returned nothing at all for this namespace. Distinct from
+     * "everything scored below threshold" (`consideredCount > 0`), and the
+     * distinction is the whole diagnosis: an empty namespace almost always
+     * means the corpus was indexed somewhere else.
+     */
+    readonly corpusEmpty: boolean;
+    /** The namespace that was searched, as a plain string, for the diagnosis above. */
+    readonly namespace?: string;
+}
+/**
+ * The retrieval seam: given the candidates a store returned, decide
+ * which of them the prompt may have — and say why about each one.
+ *
+ * A strategy NEVER talks to the store and never embeds anything. It is
+ * handed a scored, score-descending pool and returns a verdict per
+ * candidate. That narrowness is what makes it composable: a re-ranker or
+ * a diversity selector is the same shape with a different body.
+ *
+ * Shipped: {@link topK}. Deliberately NOT shipped in 8.8.0, and named
+ * here so the destination is on record rather than implied — a
+ * cross-encoder `rerank(...)` and a maximal-marginal-relevance `mmr(...)`
+ * are additional adapters behind this same interface. Neither needs an
+ * engine change, a new stage, or a new event; both were left out because
+ * a re-ranker without a shipped re-ranking model is a config with nothing
+ * to configure.
+ */
+export interface RetrievalStrategy {
+    /** Stable name — appears in the recording and in refusal messages. */
+    readonly name: string;
+    /** How many candidates this strategy is willing to admit. */
+    readonly k: number;
+    /** The quality floor, when the strategy has one. */
+    readonly threshold?: number;
+    /**
+     * How many EXTRA candidates to pull past `k` purely so that rejected
+     * ones can be shown. Never affects which candidates are admitted.
+     */
+    readonly rejectWindow: number;
+    /**
+     * Rule on a score-descending pool. Return one verdict per input, in
+     * the same order. Implementations must not reorder.
+     */
+    select(pool: readonly ScoredCandidate[]): readonly RetrievalVerdict[];
+}
+/** One store result, as a strategy sees it. */
+export interface ScoredCandidate {
+    readonly entry: MemoryEntry<unknown>;
+    readonly score: number;
+}
+/** A strategy's ruling on one candidate. */
+export interface RetrievalVerdict {
+    readonly admitted: boolean;
+    readonly reason?: RetrievalRejectReason;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/memory/retrieval/types.d.ts.map

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

package/dist/types/memory/stages/formatDefault.d.ts

@@ -1,44 +1,64 @@
 /**
  * formatDefault — render picked entries into injection-ready messages.
  *
- * Reads from scope:  `selected`
- * Writes to scope:   `formatted` (messages to inject into the LLM prompt)
+ * Reads from scope:  `selected`, `retrieved`
+ * Writes to scope:   `formatted` (messages to inject into the LLM prompt),
+ *                    `retrieved` (each admitted chunk's prompt fragment)
  *
  * Why a separate stage from the picker?
- *   Retrieval and presentation are orthogonal concerns (MemGPT-reviewer
- *   ask). A picker decides WHICH memories survive the budget; a formatter
- *   decides HOW they appear to the LLM. Consumers can swap either without
- *   touching the other. In research settings, format variations ("JSON
- *   envelope" vs "XML tags" vs "natural paragraphs") are worth ablating.
+ *   Retrieval and presentation are orthogonal concerns. A picker decides
+ *   WHICH memories survive the budget; a formatter decides HOW they appear
+ *   to the LLM. Consumers can swap either without touching the other. In
+ *   research settings, format variations ("JSON envelope" vs "XML tags" vs
+ *   "natural paragraphs") are worth ablating.
  *
- * Default format:
- *   One `system` message containing a citation-tagged block per entry:
+ * ─── Two flavors, because they are two different claims ────────────────
  *
- *     <memory source="turn:5" updated="2026-04-18T06:00:00Z">
- *     User said: I live in San Francisco.
+ *   `'memory'` (default, unchanged since 7.20.0) — recall from THIS
+ *   conversation. Each entry is a turn, so it is rendered with the turn's
+ *   role and number:
+ *
+ *     Relevant context from prior conversations. Use when it helps answer the current turn.
+ *
+ *     <memory role="user" turn="5" updated="2026-04-18T06:00:00Z">
+ *     I live in San Francisco.
  *     </memory>
  *
- *   Citation tags let the LLM reference sources in its response; the
- *   Anthropic-reviewer ask ("recall should carry source").
+ *   `'rag'` (8.8.0) — retrieval from a document corpus. An indexed chunk
+ *   has no role and no turn; it has a document, a position in it, and a
+ *   similarity score. Printing `role="unknown" turn="0"` on a page of a
+ *   PDF, which is what the memory shape did, told the model three things
+ *   that were not true and withheld the one thing it needed to cite:
+ *
+ *     Relevant passages retrieved from the document corpus. Cite the source id when you use one.
  *
- *   Role chosen: `system`. Reasoning: this is NOT the ongoing dialogue,
- *   it's context we're adding. A `user` role would confuse turn-taking;
- *   `assistant` would be a false claim. `system` matches the semantic
- *   of "context injected by the application, not part of the conversation."
+ *     <source id="refunds.md#3" doc="refunds.md" heading="Refund timing" score="0.81">
+ *     Refunds are processed within 3 business days of approval.
+ *     </source>
  *
- *   Wrapping: entries are grouped into ONE system message rather than N
- *   separate messages. One message is easier for LLMs to reason about
- *   and avoids breaking up the conversational flow.
+ *   Role chosen (both flavors): `system`. This is NOT the ongoing dialogue,
+ *   it is context the application is adding. A `user` role would confuse
+ *   turn-taking; `assistant` would be a false claim.
+ *
+ *   Wrapping: entries are grouped into ONE system message rather than N.
+ *   One message is easier for a model to reason about — and the record
+ *   still resolves to one `InjectionRecord` PER chunk, because each chunk's
+ *   exact bytes are kept on the retrieval record (`promptFragment`) and
+ *   joining them with `\n\n` reproduces this message exactly.
  */
 import type { TypedScope } from 'footprintjs';
 import type { MemoryEntry } from '../entry/index.js';
 import type { LLMMessage as Message } from '../../adapters/types.js';
 import type { MemoryState } from './types.js';
+import type { RetrievedCandidate } from '../retrieval/types.js';
+/** Which claim the injected block is making about its entries. */
+export type MemoryFormatFlavor = 'memory' | 'rag';
 export interface FormatDefaultConfig {
     /**
      * Header prepended to the injected message. Explains to the LLM what
      * follows and what it's for. Override if your app has specific phrasing
-     * guidance ("long-term memory" vs "user preferences", etc.).
+     * guidance ("long-term memory" vs "user preferences", etc.). Defaults
+     * per `flavor`.
      */
     readonly header?: string;
     /**
@@ -48,12 +68,18 @@ export interface FormatDefaultConfig {
      */
     readonly footer?: string;
     /**
-     * Custom per-entry renderer. Receives the entry; returns the block
-     * string (without outer tags — the default wrapper adds those). Use
-     * for app-specific formatting: custom source attributions, hiding
-     * tier info, etc.
+     * Which rendering the entries get. Default `'memory'` — conversation
+     * recall, byte-identical to every release before 8.8.0. `defineRAG`
+     * sets `'rag'`.
+     */
+    readonly flavor?: MemoryFormatFlavor;
+    /**
+     * Custom per-entry renderer. Receives the entry (and, for retrieval
+     * pipelines, its candidate record); returns the block string. Use for
+     * app-specific formatting: custom source attributions, hiding tier
+     * info, etc. Overrides `flavor`.
      */
-    readonly renderEntry?: (entry: MemoryEntry<Message>) => string;
+    readonly renderEntry?: (entry: MemoryEntry<Message>, candidate?: RetrievedCandidate) => string;
     /**
      * When `true`, inject even if `selected` is empty (emits only header
      * and footer). Usually NOT desired — an empty memory block is noise.

package/dist/types/memory/stages/formatDefault.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatDefault.d.ts","sourceRoot":"","sources":["../../../../src/memory/stages/formatDefault.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC;IAC/D;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AA8BD,wBAAgB,aAAa,CAAC,MAAM,GAAE,mBAAwB,WAMvC,WAAW,WAAW,CAAC,KAAG,QAAQ,IAAI,CAAC,CA4C7D"}
+{"version":3,"file":"formatDefault.d.ts","sourceRoot":"","sources":["../../../../src/memory/stages/formatDefault.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,kEAAkE;AAClE,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,KAAK,CAAC;AAElD,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,kBAAkB,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,EAAE,kBAAkB,KAAK,MAAM,CAAC;IAC/F;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AA+ED,wBAAgB,aAAa,CAAC,MAAM,GAAE,mBAAwB,WAQvC,WAAW,WAAW,CAAC,KAAG,QAAQ,IAAI,CAAC,CAiG7D"}

package/dist/types/memory/stages/pickByBudget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pickByBudget.d.ts","sourceRoot":"","sources":["../../../../src/memory/stages/pickByBudget.ts"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAA+C,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAE/F;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,IAAI,CAC9C,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACzB,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAEzB,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC;IAEpC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AA2ED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC9D,MAAM,GAAE,kBAAuB,GAC9B,eAAe,CAAC,CAAC,CAAC,CAgCpB"}
+{"version":3,"file":"pickByBudget.d.ts","sourceRoot":"","sources":["../../../../src/memory/stages/pickByBudget.ts"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAA+C,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAE/F;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,IAAI,CAC9C,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,KACzB,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAEzB,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC;IAEpC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAwID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC9D,MAAM,GAAE,kBAAuB,GAC9B,eAAe,CAAC,CAAC,CAAC,CAgCpB"}

package/dist/types/memory/stages/types.d.ts

@@ -57,6 +57,21 @@ export interface MemoryState {
      * messages array (typically as `system` messages before the user turn).
      */
     formatted: Message[];
+    /**
+     * Retrieval record (8.8.0) — what the search considered, what it
+     * admitted, and why about each candidate.
+     *
+     * Written by `loadRelevant`, refined by `pickByBudget` (budget
+     * rejections) and `formatDefault` (the prompt bytes each admitted chunk
+     * contributed), and lifted to the PARENT scope by `mountMemoryRead` so
+     * it reaches the root commit log — a subflow's own scope never does,
+     * which is why a slice could not previously see past the mount.
+     *
+     * Absent for pipelines that do no retrieval (recency load, fact
+     * extraction). Absence means "this pipeline does not rank", never
+     * "this pipeline ranked and found nothing".
+     */
+    retrieved?: import('../retrieval/types.js').RetrievalEvidence;
     /**
      * Write-side input: messages to persist at the end of this turn. The
      * wire layer populates from the agent's final message state;

package/dist/types/memory/stages/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/memory/stages/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAErE,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAElC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;;;;;;OAOG;IACH,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IAExC;;;;OAIG;IACH,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAE/B;;;;;OAKG;IACH,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAEjC;;;;OAIG;IACH,SAAS,EAAE,OAAO,EAAE,CAAC;IAErB;;;;OAIG;IACH,WAAW,EAAE,OAAO,EAAE,CAAC;IAEvB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,+BAA+B,EAAE,WAAW,CAAC;IAElE,+EAA+E;IAC/E,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/memory/stages/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,IAAI,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAErE,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAElC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B;;;;;;;OAOG;IACH,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IAExC;;;;OAIG;IACH,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAE/B;;;;;OAKG;IACH,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;IAEjC;;;;OAIG;IACH,SAAS,EAAE,OAAO,EAAE,CAAC;IAErB;;;;;;;;;;;;;OAaG;IACH,SAAS,CAAC,EAAE,OAAO,uBAAuB,EAAE,iBAAiB,CAAC;IAE9D;;;;OAIG;IACH,WAAW,EAAE,OAAO,EAAE,CAAC;IAEvB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,+BAA+B,EAAE,WAAW,CAAC;IAElE,+EAA+E;IAC/E,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB"}

package/dist/types/memory/wire/mountMemoryPipeline.d.ts

@@ -72,6 +72,31 @@ export interface MountMemoryPipelineConfig<ParentState> {
     readonly readSubflowId?: string;
     /** Subflow id for the write mount. Default `'sf-memory-write'`. */
     readonly writeSubflowId?: string;
+    /**
+     * Read and write under THIS namespace instead of whatever the parent
+     * scope's identity key holds (8.8.0).
+     *
+     * A conversation memory wants the run's identity — that is how each
+     * conversation remembers its own turns. A shared document corpus does
+     * not: it belongs to the application, not to a conversation, and
+     * scoping it per run is what made `defineRAG`'s documented example
+     * retrieve nothing at all. `MemoryDefinition.corpus` feeds this.
+     */
+    readonly identityOverride?: import('../identity/index.js').MemoryIdentity;
+    /**
+     * Scope field the read subflow writes its retrieval record to (8.8.0).
+     *
+     * The record has to be lifted OUT of the subflow to be worth anything:
+     * a subflow's own scope never reaches the root commit log, which is why
+     * a backward slice from the answer used to bottom out at "the memory
+     * mount wrote it" with no way to ask which passage. Lifted here, the
+     * per-chunk ids and scores are ordinary root state, and `sliceForKey`
+     * / `backtrack` / `who_wrote` reach them like any other value.
+     *
+     * Omitted → nothing is lifted, and pipelines that do no retrieval are
+     * unaffected (they never write the record in the first place).
+     */
+    readonly evidenceKey?: keyof ParentState & string;
     /**
      * Evidence source for CAUSAL pipelines (the evidence bridge, backlog #5).
      * Called by the write mount's inputMapper at write time; its result lands on

package/dist/types/memory/wire/mountMemoryPipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mountMemoryPipeline.d.ts","sourceRoot":"","sources":["../../../../src/memory/wire/mountMemoryPipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,yBAAyB,CAAC,WAAW;IACpD,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAElC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAElD,qEAAqE;IACrE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAEpD;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAEvD;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAEnD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAErD,iEAAiE;IACjE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC,mEAAmE;IACnE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAEjC;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,OAAO,+BAA+B,EAAE,WAAW,CAAC;CACrF;AAoBD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,WAAW,EACzC,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,EACtC,MAAM,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAC7C,gBAAgB,CAAC,WAAW,CAAC,CA2B/B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAC1C,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,EACtC,MAAM,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAC7C,gBAAgB,CAAC,WAAW,CAAC,CAuB/B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAC7C,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,EACtC,MAAM,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAC7C,gBAAgB,CAAC,WAAW,CAAC,CAE/B"}
+{"version":3,"file":"mountMemoryPipeline.d.ts","sourceRoot":"","sources":["../../../../src/memory/wire/mountMemoryPipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,yBAAyB,CAAC,WAAW;IACpD,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAElC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAElD,qEAAqE;IACrE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAEpD;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAEvD;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAEnD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAErD,iEAAiE;IACjE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC,mEAAmE;IACnE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAEjC;;;;;;;;;OASG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,sBAAsB,EAAE,cAAc,CAAC;IAE1E;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,WAAW,GAAG,MAAM,CAAC;IAElD;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,OAAO,+BAA+B,EAAE,WAAW,CAAC;CACrF;AAoBD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,WAAW,EACzC,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,EACtC,MAAM,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAC7C,gBAAgB,CAAC,WAAW,CAAC,CAoC/B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAC1C,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,EACtC,MAAM,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAC7C,gBAAgB,CAAC,WAAW,CAAC,CAyB/B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAC7C,OAAO,EAAE,gBAAgB,CAAC,WAAW,CAAC,EACtC,MAAM,EAAE,yBAAyB,CAAC,WAAW,CAAC,GAC7C,gBAAgB,CAAC,WAAW,CAAC,CAE/B"}

package/dist/types/memory-providers.d.ts

@@ -38,5 +38,7 @@
  */
 export { RedisStore, type RedisStoreOptions, type RedisLikeClient, type RedisLikePipeline, } from './adapters/memory/redis.js';
 export { AgentCoreStore, UnreadableMemoryEntryError, type AgentCoreStoreOptions, type AgentCoreLikeClient, type AgentCoreEvent, type AgentCoreMemoryRecord, } from './adapters/memory/agentcore.js';
+export { sqliteVectorStore, UnreadableIndexFileError, EmbedderMismatchError, type SqliteVectorStore, type SqliteVectorStoreOptions, type SqliteVectorDatabaseLike, type SqliteVectorStatementLike, type SqliteVectorModuleLike, } from './adapters/memory/sqliteVector.js';
+export { SqliteUnavailableError } from './lib/sqliteUnavailable.js';
 export { BedrockAgentMemory, type BedrockAgentMemoryOptions, type BedrockAgentMemoryLikeClient, type BedrockAgentSummary, } from './adapters/memory/bedrockAgentMemory.js';
 //# sourceMappingURL=memory-providers.d.ts.map

package/dist/types/memory-providers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-providers.d.ts","sourceRoot":"","sources":["../../src/memory-providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAKH,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,iBAAiB,GACvB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,cAAc,EACd,0BAA0B,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,qBAAqB,GAC3B,MAAM,gCAAgC,CAAC;AAIxC,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,4BAA4B,EACjC,KAAK,mBAAmB,GACzB,MAAM,yCAAyC,CAAC"}
+{"version":3,"file":"memory-providers.d.ts","sourceRoot":"","sources":["../../src/memory-providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAKH,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,iBAAiB,GACvB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,cAAc,EACd,0BAA0B,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,qBAAqB,GAC3B,MAAM,gCAAgC,CAAC;AAMxC,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,GAC5B,MAAM,mCAAmC,CAAC;AAI3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAIpE,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,4BAA4B,EACjC,KAAK,mBAAmB,GACzB,MAAM,yCAAyC,CAAC"}

package/dist/types/observe.d.ts

@@ -22,6 +22,7 @@
  *     • CostRecorder         — token/USD spend
  *     • EvalRecorder         — eval scores from `runner.emit('eval.*', ...)`
  *     • MemoryRecorder       — memory injections + writes
+ *     • EmbeddingRecorder    — embedding cost, index-time vs query-time
  *     • PermissionRecorder   — permission decisions + denials
  *     • SkillRecorder        — skill activations
  *     • LoggingRecorder      — structured log lines per event
@@ -46,6 +47,7 @@ export { toolsRecorder, type ToolsRecorderOptions } from './recorders/core/Tools
 export { contextEvaluatedRecorder, type ContextEvaluatedRecorderOptions, } from './recorders/core/ContextEvaluatedRecorder.js';
 export { evalRecorder, type EvalRecorderOptions } from './recorders/core/EvalRecorder.js';
 export { memoryRecorder, type MemoryRecorderOptions } from './recorders/core/MemoryRecorder.js';
+export { embeddingRecorder, type EmbeddingRecorderOptions, } from './recorders/core/EmbeddingRecorder.js';
 export { permissionRecorder, type PermissionRecorderOptions, } from './recorders/core/PermissionRecorder.js';
 export { skillRecorder, type SkillRecorderOptions } from './recorders/core/SkillRecorder.js';
 export { resilienceRecorder, type ResilienceRecorderOptions, } from './recorders/core/ResilienceRecorder.js';

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/EmbeddingRecorder.d.ts

@@ -0,0 +1,20 @@
+/**
+ * EmbeddingRecorder — forwards `agentfootprint.embedding.*` emits to the dispatcher.
+ *
+ * Pattern: Factory over EmitBridge.
+ * Role:    Bridges the embedding domain — the two-phase cost model. Without a
+ *          bridge an emit never reaches `agent.on(...)` no matter how correctly
+ *          it is fired, which is the shape this domain was in until 8.9.0: it
+ *          had a payload type, a registry entry and a `DomainWildcard` arm, and
+ *          no way for the event to arrive.
+ * Emits:   agentfootprint.embedding.generated
+ *
+ * Always-on and zero-cost: an agent with no memory pipeline embeds nothing and
+ * this bridge sees nothing.
+ */
+import { EmitBridge, type EmitBridgeOptions } from './EmitBridge.js';
+export type EmbeddingRecorderOptions = Omit<EmitBridgeOptions, 'id' | 'prefix'> & {
+    readonly id?: string;
+};
+export declare function embeddingRecorder(options: EmbeddingRecorderOptions): EmitBridge;
+//# sourceMappingURL=EmbeddingRecorder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddingRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/EmbeddingRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,MAAM,wBAAwB,GAAG,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG;IAChF,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,UAAU,CAO/E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "8.7.0",
+  "version": "8.9.0",
   "description": "The explainable agent framework — backtrack a wrong answer to the exact context that caused it (evidence, not guesses). Built on footprintjs.",
   "license": "MIT",
   "type": "commonjs",