agentfootprint 9.4.0 → 9.5.1

package/dist/esm/memory/strategies.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Named memory strategies — what each one does, which TYPES accept it, and
+ * what the host must supply before it can run.
+ *
+ * `MEMORY_STRATEGIES` is a const of seven bare strings. A string is enough to
+ * WRITE `strategy: { kind: … }` and not nearly enough to OFFER the choice: a
+ * host rendering a strategy picker off that const offers seven options, and
+ * learns which of them this deployment can actually run by calling
+ * `defineMemory` and reading the exception. That is a selector that discovers
+ * its own capabilities by failing.
+ *
+ * So each strategy declares itself, and `listMemoryStrategies()` enumerates
+ * the declarations. The shape mirrors the influence exemplar in this same
+ * package (`listInfluenceStrategies()` → `{ name, description, requirements,
+ * scorer }`), with two deliberate differences:
+ *
+ *   • the id is `kind`, not `name` — it is the value the caller writes into
+ *     `strategy.kind`, so a picker's option value IS the id;
+ *   • there is no `scorer`, because a memory strategy is not a function the
+ *     host calls; what it needs instead is `types` — the memory TYPES that
+ *     accept it, which is the other half of "can I offer this?" (`decay` on a
+ *     SEMANTIC store is refused however good the host's credentials are).
+ *
+ * `requirements` is what a host must SUPPLY (an embedder, an LLM, a store
+ * that can search). Empty means the strategy runs anywhere, at $0.
+ *
+ * Pattern: declared capability descriptors + the two guards that enforce
+ *          them — SHAPE first (`assertStrategyShape`: is this even a
+ *          strategy?), REQUIREMENTS after (`assertStrategyRequirements`: can
+ *          this deployment run it?).
+ * Role:    memory/ layer-1, beside the const it describes.
+ * Emits:   N/A — build-time only.
+ *
+ * @see ./define.types.ts  for `MEMORY_STRATEGIES` and the strategy union
+ * @see ../lib/influence-core/strategies.ts  for the exemplar this follows
+ */
+import { type DefineMemoryOptions, type MemoryStrategyKind, type MemoryType } from './define.types.js';
+/**
+ * What a strategy needs the host to supply before it can run. A picker greys
+ * out (or refuses to offer) strategies whose requirements it cannot meet.
+ *
+ * Three well-known values ship; the type stays open so a consumer's own
+ * strategy descriptor can name something else:
+ *
+ *   - `'embedder'`     — an `Embedder` that turns text into a vector.
+ *   - `'vector-store'` — a store that implements `search()`. Not the same
+ *                        requirement as an embedder: the embedder makes the
+ *                        query vector, the store is what ranks against it,
+ *                        and a deployment can easily have one without the
+ *                        other (`RedisStore` is a full memory store with no
+ *                        `search()` at all).
+ *   - `'llm'`          — a chat provider the strategy calls on the host's
+ *                        behalf.
+ */
+export type MemoryStrategyRequirement = 'embedder' | 'vector-store' | 'llm' | (string & Record<never, never>);
+/**
+ * A memory strategy, described: enough for a host to render it in a picker
+ * and know, before it offers the option, whether this deployment can run it.
+ */
+export interface MemoryStrategyInfo {
+    /** The value written as `strategy.kind` — a member of `MEMORY_STRATEGIES`. */
+    readonly kind: MemoryStrategyKind;
+    /** One-or-two-sentence plain description, current-truth caveats included. */
+    readonly description: string;
+    /** What the host must supply. Empty = runs anywhere, no dependency, $0. */
+    readonly requirements: readonly MemoryStrategyRequirement[];
+    /** The memory TYPES that accept this strategy. Any other pair is refused. */
+    readonly types: readonly MemoryType[];
+}
+/**
+ * Every memory strategy, described — cheapest first, in the order the docs
+ * teach them. Frozen: a host renders its picker straight off this.
+ *
+ * @example Offer only what this deployment can actually run
+ * ```ts
+ * import { listMemoryStrategies } from 'agentfootprint/memory';
+ *
+ * const available = new Set(embedder ? ['embedder', 'vector-store'] : []);
+ * const offerable = listMemoryStrategies().filter(
+ *   (s) => s.types.includes('episodic') && s.requirements.every((r) => available.has(r)),
+ * );
+ * // → window, budget, decay, hybrid — the four that cost nothing to run.
+ * ```
+ */
+export declare function listMemoryStrategies(): readonly MemoryStrategyInfo[];
+/**
+ * One strategy's description by `kind`, or `undefined` for a string that is
+ * not a strategy at all.
+ */
+export declare function memoryStrategyInfo(kind: string): MemoryStrategyInfo | undefined;
+/**
+ * Refuse a strategy whose SHAPE is wrong, before anything reads into it.
+ *
+ * WHY it runs FIRST, ahead of both the pipeline dispatch and the
+ * requirements walk: those two read FIELDS off the strategy
+ * (`strategies[0]`, `s.embedder`, `for (const sub of strategy.strategies)`),
+ * and a field read off a shape that never had it is a `TypeError` with the
+ * library's internals in the text — `Cannot read properties of undefined
+ * (reading '0')` for `{ kind: 'hybrid', size: 5 }`, which names neither the
+ * option the caller got wrong nor the one they meant. A caller cannot act on
+ * that. This guard turns every such read into a refusal that names the
+ * field, shows the line that would have worked, and points at the catalogue.
+ *
+ * It checks SHAPE only — is this an object, does it carry a `kind`, does a
+ * `hybrid` carry the array that makes it a hybrid. It deliberately does NOT
+ * judge whether the kind is real or legal for the type: the dispatch refuses
+ * those and names the alternative for that type, which is the better message.
+ *
+ * @param strategy the strategy exactly as the caller wrote it — `unknown`,
+ *                 because the whole point is that it may not be a `Strategy`.
+ * @param site     the call to name in the message, e.g. `defineMemory[chat]`.
+ */
+export declare function assertStrategyShape(strategy: unknown, site: string): void;
+/**
+ * Refuse a config whose strategy declares a requirement the caller did not
+ * supply — by name, at BUILD, with the fix in the message.
+ *
+ * WHY it runs LAST, after the pipeline dispatch rather than before it: the
+ * dispatch's own refusals know more than this one does. `defineMemory`'s
+ * TOP_K arm knows about the `ranksBy: 'server-text'` exemption AND about the
+ * write half it takes away; the CAUSAL arm knows that exemption does not
+ * apply to it; the EXTRACT arm knows the `llm` matters only for
+ * `extractor: 'llm'`. Speaking first would replace those messages with a
+ * blunter one. This is the BACKSTOP: it says something only when nothing
+ * better already did, and its job is that no declared requirement can go
+ * unchecked — the failure it exists to prevent is a missing dependency
+ * surfacing as a `TypeError` from five frames inside a stage, halfway
+ * through a paid run.
+ *
+ * @param options the config as written by the caller.
+ * @param site    the call to name in the message, e.g. `defineMemory[chat]`.
+ */
+export declare function assertStrategyRequirements(options: DefineMemoryOptions, site: string): void;

package/dist/esm/memory/strategies.js

@@ -0,0 +1,336 @@
+/**
+ * Named memory strategies — what each one does, which TYPES accept it, and
+ * what the host must supply before it can run.
+ *
+ * `MEMORY_STRATEGIES` is a const of seven bare strings. A string is enough to
+ * WRITE `strategy: { kind: … }` and not nearly enough to OFFER the choice: a
+ * host rendering a strategy picker off that const offers seven options, and
+ * learns which of them this deployment can actually run by calling
+ * `defineMemory` and reading the exception. That is a selector that discovers
+ * its own capabilities by failing.
+ *
+ * So each strategy declares itself, and `listMemoryStrategies()` enumerates
+ * the declarations. The shape mirrors the influence exemplar in this same
+ * package (`listInfluenceStrategies()` → `{ name, description, requirements,
+ * scorer }`), with two deliberate differences:
+ *
+ *   • the id is `kind`, not `name` — it is the value the caller writes into
+ *     `strategy.kind`, so a picker's option value IS the id;
+ *   • there is no `scorer`, because a memory strategy is not a function the
+ *     host calls; what it needs instead is `types` — the memory TYPES that
+ *     accept it, which is the other half of "can I offer this?" (`decay` on a
+ *     SEMANTIC store is refused however good the host's credentials are).
+ *
+ * `requirements` is what a host must SUPPLY (an embedder, an LLM, a store
+ * that can search). Empty means the strategy runs anywhere, at $0.
+ *
+ * Pattern: declared capability descriptors + the two guards that enforce
+ *          them — SHAPE first (`assertStrategyShape`: is this even a
+ *          strategy?), REQUIREMENTS after (`assertStrategyRequirements`: can
+ *          this deployment run it?).
+ * Role:    memory/ layer-1, beside the const it describes.
+ * Emits:   N/A — build-time only.
+ *
+ * @see ./define.types.ts  for `MEMORY_STRATEGIES` and the strategy union
+ * @see ../lib/influence-core/strategies.ts  for the exemplar this follows
+ */
+import { MEMORY_STRATEGIES, MEMORY_TYPES, } from './define.types.js';
+import { resolveRankingMode } from './store/capability.js';
+const WINDOW = Object.freeze({
+    kind: MEMORY_STRATEGIES.WINDOW,
+    description: 'Keeps the last `size` entries — messages on an Episodic store, facts or beats on the ' +
+        'others. A pure rule: no LLM, no embeddings, nothing to configure but the number. The ' +
+        'right default for short-to-medium chats.',
+    requirements: Object.freeze([]),
+    types: Object.freeze([MEMORY_TYPES.EPISODIC, MEMORY_TYPES.SEMANTIC, MEMORY_TYPES.NARRATIVE]),
+});
+const BUDGET = Object.freeze({
+    kind: MEMORY_STRATEGIES.BUDGET,
+    description: 'Injects as many recent entries as fit a token budget, and injects none at all when the ' +
+        'budget is below the floor. Free — the count is estimated, not modelled by a tokenizer ' +
+        'call. The decision (pick / skip-empty / skip-no-budget) is recorded as branch evidence.',
+    requirements: Object.freeze([]),
+    types: Object.freeze([MEMORY_TYPES.EPISODIC]),
+});
+const SUMMARIZE = Object.freeze({
+    kind: MEMORY_STRATEGIES.SUMMARIZE,
+    description: 'Names a cheap LLM to compress older turns while the most recent `recent` turns stay ' +
+        'raw. HONEST CAVEAT (9.5.0): the compression stage exists but is not composed into the ' +
+        'pipeline `defineMemory` builds, so what runs today is the last `recent` entries, ' +
+        'verbatim — the `llm` is required and not yet called. Until it is wired, ' +
+        '`.compaction({ summarizer, model })` on the Agent is the summarizer that does run.',
+    requirements: Object.freeze(['llm']),
+    types: Object.freeze([MEMORY_TYPES.EPISODIC]),
+});
+const TOP_K = Object.freeze({
+    kind: MEMORY_STRATEGIES.TOP_K,
+    description: 'Embeds the query and returns the closest stored entries above a threshold — strictly: ' +
+        'when nothing clears the threshold, nothing is injected. The embedder is exempt for a ' +
+        "store that declares `ranksBy: 'server-text'`, which takes the question as words and " +
+        'ranks it on its own side.',
+    requirements: Object.freeze(['embedder', 'vector-store']),
+    types: Object.freeze([MEMORY_TYPES.SEMANTIC, MEMORY_TYPES.CAUSAL]),
+});
+const EXTRACT = Object.freeze({
+    kind: MEMORY_STRATEGIES.EXTRACT,
+    description: 'Distills each turn into structured facts or narrative beats on the WRITE side. ' +
+        "`extractor: 'pattern'` is regex heuristics — free, no dependency, which is why this " +
+        "strategy requires nothing. `extractor: 'llm'` additionally needs an `llm`, and is " +
+        'refused without one.',
+    requirements: Object.freeze([]),
+    types: Object.freeze([MEMORY_TYPES.SEMANTIC, MEMORY_TYPES.NARRATIVE]),
+});
+const DECAY = Object.freeze({
+    kind: MEMORY_STRATEGIES.DECAY,
+    description: 'Lets old memory fade: each loaded entry is scored by age against a half-life and ' +
+        'dropped below `minScore`, so a long-running agent stops rehearsing last month. Free — ' +
+        'arithmetic on a timestamp, no LLM and no embeddings.',
+    requirements: Object.freeze([]),
+    types: Object.freeze([MEMORY_TYPES.EPISODIC]),
+});
+const HYBRID = Object.freeze({
+    kind: MEMORY_STRATEGIES.HYBRID,
+    description: 'Composes several strategies on one store. It requires nothing of its own — each ' +
+        'sub-strategy carries its own requirements, and every one of them is checked at build ' +
+        'so a hybrid cannot smuggle in a strategy this deployment cannot run.',
+    requirements: Object.freeze([]),
+    types: Object.freeze([MEMORY_TYPES.EPISODIC, MEMORY_TYPES.SEMANTIC, MEMORY_TYPES.NARRATIVE]),
+});
+const BUILT_IN = Object.freeze([
+    WINDOW,
+    BUDGET,
+    SUMMARIZE,
+    TOP_K,
+    EXTRACT,
+    DECAY,
+    HYBRID,
+]);
+/**
+ * Every memory strategy, described — cheapest first, in the order the docs
+ * teach them. Frozen: a host renders its picker straight off this.
+ *
+ * @example Offer only what this deployment can actually run
+ * ```ts
+ * import { listMemoryStrategies } from 'agentfootprint/memory';
+ *
+ * const available = new Set(embedder ? ['embedder', 'vector-store'] : []);
+ * const offerable = listMemoryStrategies().filter(
+ *   (s) => s.types.includes('episodic') && s.requirements.every((r) => available.has(r)),
+ * );
+ * // → window, budget, decay, hybrid — the four that cost nothing to run.
+ * ```
+ */
+export function listMemoryStrategies() {
+    return BUILT_IN;
+}
+/**
+ * One strategy's description by `kind`, or `undefined` for a string that is
+ * not a strategy at all.
+ */
+export function memoryStrategyInfo(kind) {
+    return BUILT_IN.find((s) => s.kind === kind);
+}
+// ─── The guard that makes the SHAPE true ────────────────────────────
+/**
+ * One correct line per kind — what a caller writes to get that strategy.
+ * These are quoted verbatim into refusals, so a reader can copy the fix out
+ * of the message instead of going to look for a doc.
+ */
+const EXAMPLE = Object.freeze({
+    [MEMORY_STRATEGIES.WINDOW]: `{ kind: 'window', size: 20 }`,
+    [MEMORY_STRATEGIES.BUDGET]: `{ kind: 'budget', maxEntries: 20 }`,
+    [MEMORY_STRATEGIES.SUMMARIZE]: `{ kind: 'summarize', recent: 5, llm }`,
+    [MEMORY_STRATEGIES.TOP_K]: `{ kind: 'topK', topK: 3, embedder }`,
+    [MEMORY_STRATEGIES.EXTRACT]: `{ kind: 'extract', extractor: 'pattern' }`,
+    [MEMORY_STRATEGIES.DECAY]: `{ kind: 'decay', halfLifeMs: 86_400_000 }`,
+    [MEMORY_STRATEGIES.HYBRID]: `{ kind: 'hybrid', strategies: [{ kind: 'window', size: 20 }] }`,
+});
+const LISTING_HINT = `  \`listMemoryStrategies()\` describes all seven kinds — what each one does, which memory ` +
+    `TYPES accept it, and what it needs supplied.`;
+/**
+ * Refuse a strategy whose SHAPE is wrong, before anything reads into it.
+ *
+ * WHY it runs FIRST, ahead of both the pipeline dispatch and the
+ * requirements walk: those two read FIELDS off the strategy
+ * (`strategies[0]`, `s.embedder`, `for (const sub of strategy.strategies)`),
+ * and a field read off a shape that never had it is a `TypeError` with the
+ * library's internals in the text — `Cannot read properties of undefined
+ * (reading '0')` for `{ kind: 'hybrid', size: 5 }`, which names neither the
+ * option the caller got wrong nor the one they meant. A caller cannot act on
+ * that. This guard turns every such read into a refusal that names the
+ * field, shows the line that would have worked, and points at the catalogue.
+ *
+ * It checks SHAPE only — is this an object, does it carry a `kind`, does a
+ * `hybrid` carry the array that makes it a hybrid. It deliberately does NOT
+ * judge whether the kind is real or legal for the type: the dispatch refuses
+ * those and names the alternative for that type, which is the better message.
+ *
+ * @param strategy the strategy exactly as the caller wrote it — `unknown`,
+ *                 because the whole point is that it may not be a `Strategy`.
+ * @param site     the call to name in the message, e.g. `defineMemory[chat]`.
+ */
+export function assertStrategyShape(strategy, site) {
+    checkShape(strategy, site, 'strategy');
+}
+function checkShape(value, site, path) {
+    if (typeof value !== 'object' || value === null) {
+        throw new Error(notAStrategyObject(value, site, path));
+    }
+    const kind = value.kind;
+    if (typeof kind !== 'string' || kind === '') {
+        throw new Error(missingKind(site, path));
+    }
+    if (kind !== MEMORY_STRATEGIES.HYBRID)
+        return;
+    // A hybrid IS its list. Every other kind can survive a missing field on a
+    // default; this one has nothing left to be.
+    const subs = value.strategies;
+    if (!Array.isArray(subs) || subs.length === 0) {
+        throw new Error(hybridWithoutStrategies(subs, site, path));
+    }
+    subs.forEach((sub, index) => checkShape(sub, site, `${path}.strategies[${index}]`));
+}
+/** `'window'`, `42`, `null` — anything that is not an object at all. */
+function notAStrategyObject(value, site, path) {
+    const written = typeof value === 'string'
+        ? `the string \`'${value}'\``
+        : value === undefined
+            ? 'nothing at all'
+            : `\`${String(value)}\``;
+    // A bare string is almost always a caller reaching for the right kind with
+    // the wrong syntax — so answer with THAT kind's line, not a generic one.
+    const example = typeof value === 'string' && memoryStrategyInfo(value) !== undefined
+        ? EXAMPLE[value]
+        : EXAMPLE[MEMORY_STRATEGIES.WINDOW];
+    return (`${site}: \`${path}\` must be an OBJECT with a \`kind\` — got ${written}.\n` +
+        `  A bare kind name is not a strategy: the kind names the rule, and the object's other ` +
+        `fields configure it.\n` +
+        `  Fix:  ${path}: ${example}\n` +
+        LISTING_HINT);
+}
+/** `{}`, or an object whose `kind` is not a string. */
+function missingKind(site, path) {
+    return (`${site}: \`${path}\` has no \`kind\` — that field is what says which strategy this is, ` +
+        `so there is nothing here to build.\n` +
+        `  Fix:  ${path}: ${EXAMPLE[MEMORY_STRATEGIES.WINDOW]}\n` +
+        LISTING_HINT);
+}
+/** `{ kind: 'hybrid' }` — the field-report shape, and its neighbours. */
+function hybridWithoutStrategies(subs, site, path) {
+    const written = !Array.isArray(subs)
+        ? subs === undefined
+            ? 'none was passed'
+            : `\`strategies\` is not an array (got \`${typeof subs}\`)`
+        : 'the array is empty';
+    return (`${site}: the \`hybrid\` strategy needs a non-empty \`strategies\` array and ${written} — a ` +
+        `hybrid is defined by the strategies it composes, so an empty one has nothing to compose ` +
+        `and no behaviour of its own.\n` +
+        `  Fix:  ${path}: { kind: 'hybrid', strategies: [{ kind: 'window', size: 20 }, ` +
+        `{ kind: 'topK', topK: 3, embedder }] }\n` +
+        `  Or:   drop \`hybrid\` and name the one rule you meant, e.g. ` +
+        `${EXAMPLE[MEMORY_STRATEGIES.WINDOW]}.\n` +
+        LISTING_HINT);
+}
+// ─── The guard that makes the declaration true ──────────────────────
+/**
+ * Refuse a config whose strategy declares a requirement the caller did not
+ * supply — by name, at BUILD, with the fix in the message.
+ *
+ * WHY it runs LAST, after the pipeline dispatch rather than before it: the
+ * dispatch's own refusals know more than this one does. `defineMemory`'s
+ * TOP_K arm knows about the `ranksBy: 'server-text'` exemption AND about the
+ * write half it takes away; the CAUSAL arm knows that exemption does not
+ * apply to it; the EXTRACT arm knows the `llm` matters only for
+ * `extractor: 'llm'`. Speaking first would replace those messages with a
+ * blunter one. This is the BACKSTOP: it says something only when nothing
+ * better already did, and its job is that no declared requirement can go
+ * unchecked — the failure it exists to prevent is a missing dependency
+ * surfacing as a `TypeError` from five frames inside a stage, halfway
+ * through a paid run.
+ *
+ * @param options the config as written by the caller.
+ * @param site    the call to name in the message, e.g. `defineMemory[chat]`.
+ */
+export function assertStrategyRequirements(options, site) {
+    checkStrategy(options.strategy, options.type, options.store, site, undefined);
+}
+function checkStrategy(strategy, type, store, site, insideHybrid) {
+    const info = memoryStrategyInfo(strategy.kind);
+    // An unknown kind, or a kind this TYPE does not accept, is not this guard's
+    // business — the dispatch refuses both, and names the alternative.
+    if (!info || !info.types.includes(type))
+        return;
+    for (const requirement of info.requirements) {
+        if (isSatisfied(requirement, strategy, type, store, site))
+            continue;
+        throw new Error(missingRequirement(requirement, info, site, insideHybrid === true));
+    }
+    if (strategy.kind === MEMORY_STRATEGIES.HYBRID) {
+        // A hybrid is only as runnable as its parts, and the pipelines it builds
+        // do not all read every part — so the parts are checked HERE, where the
+        // caller's words still exist, rather than trusted to whatever the
+        // composed pipeline happens to consume.
+        for (const sub of strategy.strategies)
+            checkStrategy(sub, type, store, site, true);
+    }
+}
+function isSatisfied(requirement, strategy, type, store, site) {
+    // Read through a structural shape: the union's arms declare each other's
+    // fields as `never`, so the union itself cannot be asked these questions.
+    const s = strategy;
+    switch (requirement) {
+        case 'embedder':
+            // The one exemption, and it is a fact about the STORE: a backend that
+            // ranks TEXT on its own side has nothing here to embed. It does not
+            // extend to CAUSAL, which matches a stored query VECTOR — there is
+            // always a vector to produce there.
+            if (type !== MEMORY_TYPES.CAUSAL && resolveRankingMode(store, site) === 'server-text') {
+                return true;
+            }
+            return s.embedder !== undefined;
+        case 'vector-store':
+            return typeof store.search === 'function';
+        case 'llm':
+            return s.llm !== undefined;
+        default:
+            // A requirement this library does not know how to check is not a
+            // requirement it may fail the caller over.
+            return true;
+    }
+}
+function missingRequirement(requirement, info, site, insideHybrid) {
+    const where = insideHybrid
+        ? `the \`${info.kind}\` strategy inside \`hybrid\``
+        : `the \`${info.kind}\` strategy`;
+    const declared = `  Every strategy declares what it needs — \`listMemoryStrategies()\` reports ` +
+        `\`requirements: [${info.requirements.map((r) => `'${r}'`).join(', ')}]\` for this one, so a ` +
+        `host can check before it offers the choice.\n`;
+    switch (requirement) {
+        case 'embedder':
+            return (`${site}: ${where} needs an \`embedder\` and none was passed — somebody has to turn ` +
+                `the query into a vector before a store can rank it.\n` +
+                declared +
+                `  Fix:  pass \`embedder\` on the strategy (\`mockEmbedder()\` for dev/tests), or omit ` +
+                `it only for a store that declares \`ranksBy: 'server-text'\` and embeds on its own side.`);
+        case 'vector-store':
+            return (`${site}: ${where} needs a store that can \`search()\`, and the store you passed does ` +
+                `not implement one — nothing would ever rank the entries written to it.\n` +
+                declared +
+                `  Fix:  pass a vector-capable store — \`InMemoryStore\` (dev/tests), ` +
+                `\`sqliteVectorStore\` (durable, one file), \`pgVectorStore\`, \`s3VectorsStore\`, or any ` +
+                `adapter that ranks the vectors you give it.\n` +
+                `  Or:   keep this store and pick a strategy that ranks nothing — \`window\` (last N) ` +
+                `or \`budget\` (fit-to-tokens).`);
+        case 'llm':
+            return (`${site}: ${where} names an \`llm\` and none was passed.\n` +
+                declared +
+                `  Fix:  pass \`llm\` on the strategy — a cheap model is the point of it.\n` +
+                `  Or:   use \`{ kind: 'window', size: <recent> }\`, which needs nothing, and which is ` +
+                `what this strategy's read path does today (its compression stage is not yet wired).`);
+        default:
+            return (`${site}: ${where} declares \`${requirement}\` and it was not supplied.\n` +
+                declared +
+                `  Fix:  supply it, or pick a strategy whose \`requirements\` are empty.`);
+    }
+}
+//# sourceMappingURL=strategies.js.map

package/dist/esm/memory/strategies.js.map

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

package/dist/memory/define.js

@@ -31,6 +31,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unwrapMemoryFlowChart = exports.defineMemory = void 0;
 const asRoleRefusal_js_1 = require("./asRoleRefusal.js");
+const strategies_js_1 = require("./strategies.js");
 const capability_js_1 = require("./store/capability.js");
 const default_js_1 = require("./pipeline/default.js");
 const ephemeral_js_1 = require("./pipeline/ephemeral.js");
@@ -54,7 +55,8 @@ const define_types_js_1 = require("./define.types.js");
  * | --------- | ------------- | ------------------------ |
  * | EPISODIC  | WINDOW        | defaultPipeline          |
  * | EPISODIC  | BUDGET        | defaultPipeline          |
- * | EPISODIC  | SUMMARIZE     | defaultPipeline + summarize stage |
+ * | EPISODIC  | SUMMARIZE     | defaultPipeline (the compression stage is NOT composed in yet — see `listMemoryStrategies()`) |
+ * | EPISODIC  | DECAY         | defaultPipeline + filterByDecay stage |
  * | SEMANTIC  | TOP_K         | semanticPipeline         |
  * | SEMANTIC  | EXTRACT       | factPipeline             |
  * | SEMANTIC  | WINDOW        | factPipeline (recency-load) |
@@ -69,6 +71,14 @@ const define_types_js_1 = require("./define.types.js");
 function defineMemory(options) {
     validate(options);
     const pipeline = buildPipeline(options);
+    // The declared-requirements backstop (9.5.0), deliberately AFTER the
+    // dispatch: the arms above know things this check does not (the
+    // server-text exemption, that it does not apply to CAUSAL, that EXTRACT's
+    // `llm` matters only for `extractor: 'llm'`), so they speak first and this
+    // says something only when nothing better did. What it guarantees is that
+    // no requirement `listMemoryStrategies()` DECLARES can go unchecked —
+    // including the ones a composed pipeline would have quietly ignored.
+    (0, strategies_js_1.assertStrategyRequirements)(options, `defineMemory[${options.id}]`);
     // `readOnly` drops the write half entirely (8.8.0). Not "writes are
     // skipped at runtime" — the subflow is never compiled and never mounted,
     // so a read-only memory has no write stage in its chart, no write commit
@@ -105,6 +115,14 @@ function validate(options) {
         throw new Error(`defineMemory[id=${options.id}]: \`store\` is required. ` +
             'Pass `new InMemoryStore()` for dev/tests, or a backed store for production.');
     }
+    // SHAPE before anything reads a field (9.5.1). Both the dispatch below and
+    // the requirements walk read fields off the strategy — `h.strategies[0]`,
+    // `for (const sub of strategy.strategies)` — and a field read off a shape
+    // that never had it is a `TypeError` from inside this library, naming
+    // neither the option the caller got wrong nor the one they meant.
+    // Field-reported: `{ kind: 'hybrid', size: 5 }` produced `Cannot read
+    // properties of undefined (reading '0')`.
+    (0, strategies_js_1.assertStrategyShape)(options.strategy, `defineMemory[${options.id}]`);
     // The shorthand and the spelled-out rule EXCLUDE. Accepting both would
     // mean one of two numbers silently loses, and the recording would name
     // a `k` the run did not use.
@@ -164,10 +182,18 @@ function buildEpisodicPipeline(options) {
             return (0, default_js_1.defaultPipeline)(config);
         }
         case define_types_js_1.MEMORY_STRATEGIES.SUMMARIZE: {
-            // Load recent N raw turns; older content is summarized by an LLM
-            // before injection. defaultPipeline handles load+pick; the
-            // summarize stage is composed in by the wire helpers when the
-            // strategy carries an `llm` provider.
+            // WHAT THIS ACTUALLY DOES, as of 9.5.0: loads the last `recent` turns
+            // and stops. The `summarize` stage exists (stages/summarize.ts) and is
+            // composed into NOTHING — the comment that used to sit here said the
+            // wire helpers add it "when the strategy carries an `llm`", and they
+            // never have. Verified by counting calls: eight turns through this
+            // pipeline with a counting provider, zero `complete()` calls.
+            //   It is left as-is rather than half-wired because the compressor
+            // needs things this strategy does not carry (a model name, cost
+            // accounting, the separate-instance law `.compaction()` enforces), and
+            // the Agent already has that door. `listMemoryStrategies()` says so in
+            // the strategy's own description so a reader learns it from the
+            // library rather than from a token bill.
             const sum = s;
             const config = { store: options.store, loadCount: sum.recent };
             return (0, default_js_1.defaultPipeline)(config);
@@ -180,6 +206,10 @@ function buildEpisodicPipeline(options) {
             const h = s;
             const inner = h.strategies[0];
             if (!inner) {
+                // Unreachable since 9.5.1 — `assertStrategyShape` refuses a missing,
+                // non-array or empty `strategies` in `validate()`, with the field
+                // named and a working line in the message. Kept as the index-access
+                // backstop the type system asks for, not as the message a caller sees.
                 throw new Error(`defineMemory[${options.id}]: HYBRID strategy requires at least one sub-strategy.`);
             }
             return buildEpisodicPipeline({ ...options, strategy: inner });
@@ -190,9 +220,28 @@ function buildEpisodicPipeline(options) {
         case define_types_js_1.MEMORY_STRATEGIES.TOP_K:
             throw new Error(`defineMemory[${options.id}]: TOP_K strategy on EPISODIC type requires a vector store. ` +
                 'Use type=SEMANTIC for vector retrieval, or type=EPISODIC with strategy=WINDOW for recency.');
-        case define_types_js_1.MEMORY_STRATEGIES.DECAY:
-            throw new Error(`defineMemory[${options.id}]: DECAY strategy is not yet wired. ` +
-                'Workaround: set TTL on MemoryEntry, or compose manually via mountMemoryRead.');
+        case define_types_js_1.MEMORY_STRATEGIES.DECAY: {
+            // Wired in 9.5.0. Until then this arm threw "not yet wired" while
+            // `MEMORY_STRATEGIES` went on offering the choice — a const that
+            // advertised seven strategies and built six.
+            const d = s;
+            if (!Number.isFinite(d.halfLifeMs) || d.halfLifeMs < 0) {
+                throw new Error(`defineMemory[${options.id}]: DECAY needs a \`halfLifeMs\` that is a non-negative ` +
+                    `number of milliseconds — how long before an untouched entry is worth half as ` +
+                    `much. Got \`${String(d.halfLifeMs)}\`.\n` +
+                    `  A negative half-life inverts the curve (older scores HIGHER), which no config ` +
+                    `means to say, so it is refused rather than obeyed.\n` +
+                    `  Fix:  a day is \`86_400_000\`; an hour is \`3_600_000\`.`);
+            }
+            const config = {
+                store: options.store,
+                decay: {
+                    halfLifeMs: d.halfLifeMs,
+                    ...(d.minScore !== undefined && { minScore: d.minScore }),
+                },
+            };
+            return (0, default_js_1.defaultPipeline)(config);
+        }
         default: {
             const _exhaustive = s;
             void _exhaustive;