@loomwork/memory 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

package/NOTICE

@@ -0,0 +1,8 @@
+Loom
+Copyright 2026 Sushil Chhetri
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this project except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0

package/README.md

@@ -1,3 +1,80 @@
-# Temporary Holding Version
+# @loomwork/memory — agent memory
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Scoped memory for agents and flows: ordered lists of entries kept outside the event log, addressed by a
+memory id plus a scope (an execution, a conversation, a user). `MemoryRuntime` applies each memory's TTL
+and size limits, `TieredMemory` adds named tiers with their own policy plus promotion between them, and
+the `MemoryStore` interface is what a backend (SQLite, Postgres, a vector store) implements. Use it
+directly when you want recency or relevance recall inside a flow; `defineConfig` already builds one
+`MemoryRuntime` for `app.memory` over its `memoryStore` option.
+
+```ts
+import {
+  DEFAULT_TIERS,
+  EmbeddingMemoryStore,
+  HashingEmbeddingProvider,
+  InMemoryMemoryStore,
+  TieredMemory,
+} from "@loomwork/memory";
+import type { ExecutionContext } from "@loomwork/workflow-runtime";
+
+// Any MemoryStore works; wrapping one in EmbeddingMemoryStore makes `search` semantic.
+// HashingEmbeddingProvider is the offline reference (lexical overlap only): swap in a real model.
+const store = new EmbeddingMemoryStore({
+  store: new InMemoryMemoryStore(),
+  provider: new HashingEmbeddingProvider(),
+  minScore: 0.2, // required: cosine is defined against every entry, so "matches" needs a floor
+});
+const memory = new TieredMemory({ tiers: DEFAULT_TIERS, store });
+
+await memory.remember("episodic", "user-42", { role: "user", content: "prefers metric units" });
+const recent = await memory.recall("episodic", "user-42", { limit: 5 }); // newest N
+
+// Inside a flow, pass ctx.decide: the retrieved set is recorded, so a replay is served the same entries.
+export async function relevantFacts(ctx: ExecutionContext, question: string) {
+  return memory.recallRelevant("semantic", "user-42", question, { decide: ctx.decide });
+}
+```
+
+## Surface
+
+- **Runtime.** `MemoryRuntime` (`register`, `append`, `read`, `clear`, `remove`, `search`) keyed by
+  `(memoryId, scope)`; definitions come from `memory$({ id, name, ttlMs, maxEntries })` in `@loomwork/core`.
+- **Tiers.** `TieredMemory` (`remember`, `recall`, `recallRelevant`, `promote`, `summarize`, `forget`,
+  `clear`) and `DEFAULT_TIERS`: `working` (`summarizeAfter: 20`), `episodic` (`maxEntries: 200`),
+  `semantic` and `procedural` (no eviction). A tier policy is `ttlMs`, `maxEntries` or `summarizeAfter`.
+- **Stores.** `InMemoryMemoryStore` (default; lost on restart). Durable ones are `SqliteMemoryStore`
+  (`@loomwork/plugin-sqlite`) and `PostgresMemoryStore` (`@loomwork/plugin-postgres`).
+- **Backend contract.** `MemoryStore` needs `append`, `read`, `clear`; `replace`, `search`, `remove` and
+  `close` are optional. Also `MEMORY_STORE_SPI_VERSION` (2.1.0), `searchableText`, `tokenize`,
+  `queryTerms` / `MAX_QUERY_TERMS`, `clampSearchLimit` with `DEFAULT_SEARCH_LIMIT` and `MAX_SEARCH_LIMIT`.
+  `runMemoryStoreConformance` in `@loomwork/conformance` proves a backend.
+- **Embeddings (ADR 0124).** `EmbeddingMemoryStore`, the `EmbeddingProvider` and `VectorIndex` interfaces,
+  `InMemoryVectorIndex`, `HashingEmbeddingProvider`, `cosine`, `EmbeddingError`,
+  `EmbeddingModelMismatchError`, `MemoryIndexTooLargeError`.
+
+## Behaviour that surprises people
+
+- **Relevance recall needs `search`.** `MemoryRuntime.search` throws if the store has none, and
+  `recallRelevant` takes a required `decide` so what reached the prompt is a recorded fact. To search
+  without recording (an ops lookup, a test), call the store's `search` directly.
+- **TTL is applied after the store's `limit`**, so a search over an expiring memory can return fewer than
+  `limit` hits. `read` persists the pruned list; `search` does not.
+- **Reads are in append order**, not timestamp order, and an absent key reads as `[]`.
+- **`forget` and `clear` are not recorded.** Only recall goes through `decide`.
+- **Entry `id` is not indexed.** It is caller metadata that every backend must round-trip; `content` is
+  what `searchableText` projects.
+- **A tier that evicts cannot hold a corpus.** `@loomwork/knowledge` refuses `ttlMs` / `maxEntries` tiers for
+  that reason.
+- **An embedding failure on `append` to an already-indexed key means the append is not made**, so the
+  store and its index do not silently disagree.
+
+## Install
+
+Unpublished for now: inside this repo use `workspace:*`; from a sibling checkout use a `link:` override (see [AGENTS.md](../../AGENTS.md)).
+
+## See also
+
+- API reference: section "`@loomwork/memory` — agent memory" in [docs/api-reference.org](../../docs/api-reference.org).
+- Guides: [user guide, section 16: tiered memory](../../docs/user-guide.md#16-tiered-memory), [reasoning and memory](../../docs/loom-2.0/02-reasoning-and-memory.md).
+- ADRs: [0033 SPI conformance](../../docs/adr/0033-spi-conformance-contracts.md), [0090 knowledge is retrieval over memory](../../docs/adr/0090-knowledge-is-retrieval-over-memory.md), [0124 learning lifecycle](../../docs/adr/0124-learning-lifecycle.md) (embeddings).
+- Source: `packages/memory/src`. Retrieval over documents: [`@loomwork/knowledge`](../knowledge/README.md).

package/dist/InMemoryMemoryStore.d.ts

@@ -0,0 +1,26 @@
+import type { MemoryEntry, MemorySearchOptions, MemoryStore } from "./types";
+export declare class InMemoryMemoryStore implements MemoryStore {
+    private readonly entries;
+    append(key: string, entry: MemoryEntry): Promise<void>;
+    read(key: string): Promise<MemoryEntry[]>;
+    clear(key: string): Promise<void>;
+    /**
+     * Remove by id in one pass with a Set membership test — O(entries + ids), not
+     * O(entries x ids), because a corpus removal names every chunk of a document at once.
+     *
+     * Rebuilds the list rather than splicing: `read` hands out the stored array itself,
+     * so mutating it in place would edit a list a caller may still be holding.
+     */
+    remove(key: string, ids: readonly string[]): Promise<void>;
+    /**
+     * Reference relevance search: sum of the IDF of the query terms an entry contains,
+     * ties broken by recency. Deliberately simple and deliberately NOT a hidden search
+     * engine — it exists so `recallRelevant` works on the default store and so the kit
+     * runs against three independent rankers rather than one implementation twice. IDF
+     * (rather than a raw match count) is what stops a term present in every entry from
+     * deciding the order; a real corpus belongs in SqliteMemoryStore/PostgresMemoryStore,
+     * whose indexes do this properly and without scanning.
+     */
+    search(key: string, query: string, opts?: MemorySearchOptions): Promise<MemoryEntry[]>;
+}
+//# sourceMappingURL=InMemoryMemoryStore.d.ts.map

package/dist/InMemoryMemoryStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryMemoryStore.d.ts","sourceRoot":"","sources":["../src/InMemoryMemoryStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE7E,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAEtD,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAIzC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC;;;;;;OAMG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWhE;;;;;;;;OAQG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CA8BjG"}

package/dist/InMemoryMemoryStore.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryMemoryStore = void 0;
+const searchText_1 = require("./searchText");
+const types_1 = require("./types");
+class InMemoryMemoryStore {
+    entries = new Map();
+    async append(key, entry) {
+        const list = this.entries.get(key) ?? [];
+        list.push(entry);
+        this.entries.set(key, list);
+    }
+    async read(key) {
+        return this.entries.get(key) ?? [];
+    }
+    async clear(key) {
+        this.entries.delete(key);
+    }
+    /**
+     * Remove by id in one pass with a Set membership test — O(entries + ids), not
+     * O(entries x ids), because a corpus removal names every chunk of a document at once.
+     *
+     * Rebuilds the list rather than splicing: `read` hands out the stored array itself,
+     * so mutating it in place would edit a list a caller may still be holding.
+     */
+    async remove(key, ids) {
+        if (ids.length === 0)
+            return;
+        const list = this.entries.get(key);
+        if (list === undefined)
+            return;
+        const doomed = new Set(ids);
+        const kept = list.filter((entry) => entry.id === undefined || !doomed.has(entry.id));
+        if (kept.length === list.length)
+            return;
+        if (kept.length === 0)
+            this.entries.delete(key);
+        else
+            this.entries.set(key, kept);
+    }
+    /**
+     * Reference relevance search: sum of the IDF of the query terms an entry contains,
+     * ties broken by recency. Deliberately simple and deliberately NOT a hidden search
+     * engine — it exists so `recallRelevant` works on the default store and so the kit
+     * runs against three independent rankers rather than one implementation twice. IDF
+     * (rather than a raw match count) is what stops a term present in every entry from
+     * deciding the order; a real corpus belongs in SqliteMemoryStore/PostgresMemoryStore,
+     * whose indexes do this properly and without scanning.
+     */
+    async search(key, query, opts = {}) {
+        const terms = new Set((0, searchText_1.queryTerms)(query));
+        const entries = this.entries.get(key) ?? [];
+        if (terms.size === 0 || entries.length === 0)
+            return [];
+        // One pass to the document-frequency table, one to score: O(entries × terms).
+        const documents = entries.map((entry) => new Set((0, searchText_1.tokenize)((0, searchText_1.searchableText)(entry))));
+        const documentFrequency = new Map();
+        for (const document of documents) {
+            for (const term of terms) {
+                if (document.has(term))
+                    documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
+            }
+        }
+        const scored = [];
+        for (const [index, document] of documents.entries()) {
+            let score = 0;
+            for (const term of terms) {
+                const frequency = documentFrequency.get(term);
+                if (frequency !== undefined && document.has(term)) {
+                    score += Math.log(1 + entries.length / frequency);
+                }
+            }
+            if (score > 0)
+                scored.push({ entry: entries[index], index, score });
+        }
+        // Descending score; a tie goes to the more recently appended entry.
+        scored.sort((a, b) => b.score - a.score || b.index - a.index);
+        return scored.slice(0, (0, types_1.clampSearchLimit)(opts.limit)).map((s) => s.entry);
+    }
+}
+exports.InMemoryMemoryStore = InMemoryMemoryStore;
+//# sourceMappingURL=InMemoryMemoryStore.js.map

package/dist/InMemoryMemoryStore.js.map

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

package/dist/MemoryRuntime.d.ts

@@ -0,0 +1,49 @@
+import type { MemoryDefinition } from "@loomwork/core";
+import type { MemoryEntry, MemorySearchOptions, MemoryStore } from "./types";
+export declare class MemoryRuntime {
+    private readonly store;
+    private readonly definitions;
+    constructor(store?: MemoryStore);
+    register(definition: MemoryDefinition): this;
+    /**
+     * The registered definition for a memory id, or `undefined`.
+     *
+     * Exposed for the same reason as `TieredMemory.tierPolicy`: a caller that is about to
+     * write data whose correctness depends on the WHOLE set being present needs to know
+     * whether something else has registered an eviction policy over the same key space.
+     * Two runtimes can share one store, and only the one that reads applies its own policy.
+     */
+    definitionFor(memoryId: string): MemoryDefinition | undefined;
+    private key;
+    append(memoryId: string, scope: string, entry: Omit<MemoryEntry, "timestamp"> & {
+        timestamp?: number;
+    }): Promise<void>;
+    read(memoryId: string, scope: string): Promise<MemoryEntry[]>;
+    clear(memoryId: string, scope: string): Promise<void>;
+    /**
+     * Remove specific entries by {@link MemoryEntry.id}, keeping the rest of the scope.
+     *
+     * Unlike `search`, an absent backend verb here does NOT fail: the fallback —
+     * read, filter, rewrite — is CORRECT, just linear in the scope, so refusing would
+     * deny a working capability rather than prevent a silent wrong answer. (That is the
+     * whole distinction: there is no read-based way to fake relevance retrieval, and
+     * there is an obvious read-based way to delete.)
+     *
+     * The rewrite goes through `persist`, so it inherits atomic `replace` where the
+     * backend has one — the same durability argument as eviction: a crash between
+     * `clear` and the re-appends would lose the scope this call was asked to prune.
+     */
+    remove(memoryId: string, scope: string, ids: readonly string[]): Promise<void>;
+    /**
+     * Retrieve by relevance instead of by recency. Requires a store that implements the
+     * optional `search`; a store without one FAILS LOUDLY rather than falling back to
+     * `read`, because a silent fallback would hand back the tail of the scope while the
+     * caller believed it had retrieved — the kind of degradation nothing downstream can
+     * detect, and which shows up only as worse answers.
+     */
+    search(memoryId: string, scope: string, query: string, opts?: MemorySearchOptions): Promise<MemoryEntry[]>;
+    private pruneList;
+    private persist;
+    private evict;
+}
+//# sourceMappingURL=MemoryRuntime.d.ts.map

package/dist/MemoryRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryRuntime.d.ts","sourceRoot":"","sources":["../src/MemoryRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAO7E,qBAAa,aAAa;IAGZ,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuC;gBAEtC,KAAK,GAAE,WAAuC;IAE3E,QAAQ,CAAC,UAAU,EAAE,gBAAgB,GAAG,IAAI;IAK5C;;;;;;;OAOG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAI7D,OAAO,CAAC,GAAG;IAIL,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAC7D,OAAO,CAAC,IAAI,CAAC;IAMV,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAW7D,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3D;;;;;;;;;;;;OAYG;IACG,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAapF;;;;;;OAMG;IACG,MAAM,CACV,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,mBAAwB,GAC7B,OAAO,CAAC,WAAW,EAAE,CAAC;IAoBzB,OAAO,CAAC,SAAS;YAmBH,OAAO;YAUP,KAAK;CAOpB"}

package/dist/MemoryRuntime.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRuntime = void 0;
+const InMemoryMemoryStore_1 = require("./InMemoryMemoryStore");
+// The Agent Runtime's "memory access" from the proposal. A MemoryRuntime holds
+// named memories (registered from memory$() definitions) and enforces each
+// memory's ttlMs / maxEntries policy on read and write. Memory is addressed by
+// (memoryId, scope) — scope is typically an executionId, conversationId, or
+// userId, letting one memory definition serve many concurrent sessions.
+class MemoryRuntime {
+    store;
+    definitions = new Map();
+    constructor(store = new InMemoryMemoryStore_1.InMemoryMemoryStore()) {
+        this.store = store;
+    }
+    register(definition) {
+        this.definitions.set(definition.id, definition);
+        return this;
+    }
+    /**
+     * The registered definition for a memory id, or `undefined`.
+     *
+     * Exposed for the same reason as `TieredMemory.tierPolicy`: a caller that is about to
+     * write data whose correctness depends on the WHOLE set being present needs to know
+     * whether something else has registered an eviction policy over the same key space.
+     * Two runtimes can share one store, and only the one that reads applies its own policy.
+     */
+    definitionFor(memoryId) {
+        return this.definitions.get(memoryId);
+    }
+    key(memoryId, scope) {
+        return `${memoryId}::${scope}`;
+    }
+    async append(memoryId, scope, entry) {
+        const key = this.key(memoryId, scope);
+        await this.store.append(key, { ...entry, timestamp: entry.timestamp ?? Date.now() });
+        await this.evict(memoryId, key);
+    }
+    async read(memoryId, scope) {
+        const key = this.key(memoryId, scope);
+        const stored = await this.store.read(key);
+        const pruned = this.pruneList(memoryId, stored);
+        // Lazy expiry: if the view dropped entries, persist it so a cold scope (read but never
+        // re-appended) doesn't retain stale entries — and a scope pruned to empty drops its key
+        // entirely (clear + no re-append), bounding the store's distinct-scope growth.
+        if (pruned.length !== stored.length)
+            await this.persist(key, pruned);
+        return pruned;
+    }
+    async clear(memoryId, scope) {
+        await this.store.clear(this.key(memoryId, scope));
+    }
+    /**
+     * Remove specific entries by {@link MemoryEntry.id}, keeping the rest of the scope.
+     *
+     * Unlike `search`, an absent backend verb here does NOT fail: the fallback —
+     * read, filter, rewrite — is CORRECT, just linear in the scope, so refusing would
+     * deny a working capability rather than prevent a silent wrong answer. (That is the
+     * whole distinction: there is no read-based way to fake relevance retrieval, and
+     * there is an obvious read-based way to delete.)
+     *
+     * The rewrite goes through `persist`, so it inherits atomic `replace` where the
+     * backend has one — the same durability argument as eviction: a crash between
+     * `clear` and the re-appends would lose the scope this call was asked to prune.
+     */
+    async remove(memoryId, scope, ids) {
+        if (ids.length === 0)
+            return;
+        const key = this.key(memoryId, scope);
+        if (this.store.remove !== undefined) {
+            await this.store.remove(key, ids);
+            return;
+        }
+        const stored = await this.store.read(key);
+        const doomed = new Set(ids);
+        const kept = stored.filter((entry) => entry.id === undefined || !doomed.has(entry.id));
+        if (kept.length !== stored.length)
+            await this.persist(key, kept);
+    }
+    /**
+     * Retrieve by relevance instead of by recency. Requires a store that implements the
+     * optional `search`; a store without one FAILS LOUDLY rather than falling back to
+     * `read`, because a silent fallback would hand back the tail of the scope while the
+     * caller believed it had retrieved — the kind of degradation nothing downstream can
+     * detect, and which shows up only as worse answers.
+     */
+    async search(memoryId, scope, query, opts = {}) {
+        if (this.store.search === undefined) {
+            throw new Error(`memory "${memoryId}": the configured MemoryStore does not implement search(). Use a backend that does (SqliteMemoryStore, PostgresMemoryStore, InMemoryMemoryStore), or recall by recency with read().`);
+        }
+        const hits = await this.store.search(this.key(memoryId, scope), query, opts);
+        // TTL applies to a hit as much as to a read — an expired entry reaching a prompt is
+        // the bug TTL exists to prevent. Filtered AFTER the store's `limit`, so an expiring
+        // tier can return fewer than `limit` rows; the alternative is reading the whole scope
+        // to prune it, which is exactly what an index is for. NOT persisted: unlike `read`,
+        // these entries are an arbitrary subset, and rewriting the list from a subset would
+        // delete everything that did not match.
+        const def = this.definitions.get(memoryId);
+        if (def?.ttlMs === undefined)
+            return hits;
+        const cutoff = Date.now() - def.ttlMs;
+        return hits.filter((e) => e.timestamp >= cutoff);
+    }
+    // Drop entries older than ttlMs, then keep only the newest maxEntries. Pure.
+    pruneList(memoryId, entries) {
+        const def = this.definitions.get(memoryId);
+        let out = entries;
+        if (def?.ttlMs !== undefined) {
+            const cutoff = Date.now() - def.ttlMs;
+            out = out.filter((e) => e.timestamp >= cutoff);
+        }
+        if (def?.maxEntries !== undefined && out.length > def.maxEntries) {
+            out = out.slice(out.length - def.maxEntries);
+        }
+        return out;
+    }
+    // Rewrite the stored list to `entries` (empty ⇒ the key is dropped).
+    //
+    // Prefers the store's atomic `replace` when it has one: on a durable backend the
+    // clear-then-re-append fallback is a window in which eviction — the routine path —
+    // can lose the whole scope to a crash. The fallback is still the contract for
+    // backends without it (including the in-memory default, which has no crash to lose).
+    async persist(key, entries) {
+        if (this.store.replace !== undefined) {
+            await this.store.replace(key, entries);
+            return;
+        }
+        await this.store.clear(key);
+        for (const entry of entries)
+            await this.store.append(key, entry);
+    }
+    // Rewrite the stored list to the pruned view so eviction is durable (only when it changed).
+    async evict(memoryId, key) {
+        const def = this.definitions.get(memoryId);
+        if (def?.ttlMs === undefined && def?.maxEntries === undefined)
+            return;
+        const stored = await this.store.read(key);
+        const pruned = this.pruneList(memoryId, stored);
+        if (pruned.length !== stored.length)
+            await this.persist(key, pruned);
+    }
+}
+exports.MemoryRuntime = MemoryRuntime;
+//# sourceMappingURL=MemoryRuntime.js.map

package/dist/MemoryRuntime.js.map

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