comisai 1.0.45 → 1.0.46

package/node_modules/@comis/memory/dist/sqlite-memory-adapter.js

@@ -19,10 +19,10 @@ import { openSqliteDatabase } from "./sqlite-adapter-base.js";
 import { systemNowMs, normalizeForSearch, validateMemoryWrite } from "@comis/core";
 // Row mappers
 const memoryRowMapper = createRowMapper(MemoryRowSchema);
-// DIST-05 (WR-02) id-projection mapper — the sanctioned typed-read path for the
+// Id-projection mapper — the sanctioned typed-read path for the
 // session-scoped id capture (no `as Foo[]` cast — untyped-sqlite gate).
 const idProjectionRowMapper = createRowMapper(IdProjectionRowSchema);
-// FORGET-04: the canonical `memories.history` JSON shape — an ordered array of
+// The canonical `memories.history` JSON shape — an ordered array of
 // prior contents (MemoryEntrySchema.history + the growObservation precedent). Built
 // once at module scope; parses the nullable TEXT column on read-back inside
 // supersede(). A strictObject mirrors the row-mapper's HistorySchema (the read path),
@@ -65,7 +65,7 @@ export class SqliteMemoryAdapter {
             dbPath: config.dbPath,
             walMode: config.walMode,
             initSchema: (db) => {
-                // Initialize schema and capture per-instance vec state (Phase 226: recall keys nest under .recall)
+                // Initialize schema and capture per-instance vec state (recall keys nest under .recall)
                 const schemaResult = initSchema(db, config.recall.embeddingDimensions);
                 vecAvailable = schemaResult.vecAvailable;
             },
@@ -120,7 +120,7 @@ export class SqliteMemoryAdapter {
                 const now = systemNowMs();
                 const results = [];
                 for (const vr of vecResults) {
-                    // FORGET-01 (CR-01): the ALWAYS-ON `evicted_at IS NULL` recall exclusion —
+                    // The ALWAYS-ON `evicted_at IS NULL` recall exclusion —
                     // a soft-evicted row (evicted_at set by the lifecycle sweep) is omitted from
                     // THIS live vector-only recall path too, not only hybridSearch. The
                     // inspect/asOf raw reads stay UNFILTERED (eviction is soft + asOf-resolvable).
@@ -189,7 +189,7 @@ export class SqliteMemoryAdapter {
             const now = systemNowMs();
             const results = [];
             for (const hr of hybridResults) {
-                // FORGET-01 (CR-01): hybridSearch already applies `evicted_at IS NULL` in its
+                // hybridSearch already applies `evicted_at IS NULL` in its
                 // post-fusion WHERE, so an evicted id never reaches here — but the per-id hydrate
                 // is itself a recall read, so it carries the same always-on exclusion explicitly
                 // (defense in depth; the two halves of the soft-eviction guarantee stay coupled).
@@ -282,7 +282,7 @@ export class SqliteMemoryAdapter {
         const out = [];
         let rank = 0;
         for (const id of ids) {
-            // FORGET-01 (CR-01): the ALWAYS-ON `evicted_at IS NULL` recall exclusion —
+            // The ALWAYS-ON `evicted_at IS NULL` recall exclusion —
             // hydrateLane backs searchLanes, the PRIMARY live recall path (createMemoryRecall
             // prefers searchLanes, memory-recall.ts:183), so a soft-evicted row MUST be omitted
             // here exactly as hybridSearch's post-fusion WHERE does it (hybrid-search.ts:440).
@@ -394,13 +394,13 @@ export class SqliteMemoryAdapter {
             return err(e instanceof Error ? e : new Error(String(e)));
         }
     }
-    // ── supersede (FORGET-04 — non-destructive contradiction → revise) ─
+    // ── supersede (non-destructive contradiction → revise) ─
     /**
-     * Phase 224 (FORGET-04): resolve a user CORRECTION of an existing fact by
+     * Resolve a user CORRECTION of an existing fact by
      * SUPERSESSION, NOT deletion. UPDATEs the scoped incumbent's `content` to
      * `newContent` and APPENDs the prior state (`{ previousContent, changedAt }`) to
      * the `memories.history` JSON array. The row is UPDATEd, never DELETEd — deletion
-     * stays reserved for the FORGET-02 corroborated-poison security path. The existing
+     * stays reserved for the corroborated-poison security path. The existing
      * row IS the latest, so recall (search/searchLanes) naturally returns the new
      * content; there is NO `mentioned_at` column and NO recall-side asOf filter (the
      * superseded content simply stops being the row's `content`, preserved in history).
@@ -413,7 +413,7 @@ export class SqliteMemoryAdapter {
      * `WHERE id = ? AND tenant_id = ? AND agent_id = ?` (+ `user_id` when supplied),
      * bound params only (V4 isolation). The incumbent is parsed via the row mapper (no
      * `as Row`). The NEW content passes the same `validateMemoryWrite` redaction
-     * firewall a write goes through (INV-5) BEFORE the txn — a CRITICAL correction is
+     * firewall a write goes through BEFORE the txn — a CRITICAL correction is
      * rejected, never persisted. The `memories_au AFTER UPDATE OF content` trigger
      * re-syncs `memory_fts`; the normalized `memory_fts_tri` trigram twin is
      * re-inserted on the content change (the `growObservation` precedent), and the
@@ -432,7 +432,7 @@ export class SqliteMemoryAdapter {
     async supersede(id, newContent, scope, now) {
         const startMs = systemNowMs();
         const { tenantId, agentId, userId } = scope;
-        // INV-5 redaction firewall on the untrusted correction, BEFORE the txn — a
+        // The redaction firewall on the untrusted correction, BEFORE the txn — a
         // CRITICAL classification (dangerous command / secret egress) is REJECTED and
         // never persisted (mirrors revise()'s rejectUnwritableEntry → err). A `warn`
         // is permitted (the existing trust_level on the row is unchanged — a correction
@@ -560,15 +560,15 @@ export class SqliteMemoryAdapter {
             return err(error);
         }
     }
-    // ── listMemoryIdsBySessionKey (DIST-05, WR-02) ─────────────────────
+    // ── listMemoryIdsBySessionKey ─────────────────────
     /**
-     * Phase 172 (DIST-05, WR-02): Read the memory ids for a (sessionKey, tenant,
+     * Read the memory ids for a (sessionKey, tenant,
      * agent) scope WITHOUT deleting. Used by the session-reset handler to capture
      * THIS session's ids BEFORE `deleteBySessionKey`, so `--purge-derived` can be
      * session-scoped (source_ids ∩ thisSessionIds) instead of the coarse
      * "any dangling source id" sweep.
      *
-     * R4 isolation: filters on `source_session_key` AND `tenant_id` AND `agent_id`
+     * Tenant/agent isolation: filters on `source_session_key` AND `tenant_id` AND `agent_id`
      * — the SAME scope as `deleteBySessionKey`. Typed read via the row mapper (no
      * `as Foo[]` cast — untyped-sqlite gate). Returns the ids (possibly empty).
      */
@@ -585,13 +585,13 @@ export class SqliteMemoryAdapter {
             return err(e instanceof Error ? e : new Error(String(e)));
         }
     }
-    // ── deleteBySessionKey (DIST-05) ───────────────────────────────────
+    // ── deleteBySessionKey ───────────────────────────────────
     /**
-     * Phase 172 (DIST-05): Delete ALL memory rows for a (sessionKey, tenant, agent)
+     * Delete ALL memory rows for a (sessionKey, tenant, agent)
      * scope. ONE query covers BOTH paired-conversation memories AND lcd-distilled
      * episodic memories — both store `source_session_key` on the `memories` row.
      *
-     * R4 isolation: the WHERE filters on `source_session_key` AND `tenant_id` AND
+     * Tenant/agent isolation: the WHERE filters on `source_session_key` AND `tenant_id` AND
      * `agent_id`, so a cross-tenant or cross-agent row is never deleted (the same
      * fail-closed scoping the consolidation paths use). The `ON DELETE CASCADE` on
      * `lcd_memory_provenance.memory_id` drops the provenance rows automatically;
@@ -606,7 +606,7 @@ export class SqliteMemoryAdapter {
         try {
             const tx = this.db.transaction(() => {
                 // vec_memories has no cascade — delete the matching vec rows by id first.
-                // Subquery is fully tenant+agent+session scoped (R4) so it can only ever
+                // Subquery is fully tenant+agent+session scoped so it can only ever
                 // reference this scope's memory ids.
                 if (this.vecAvailable) {
                     this.db
@@ -676,9 +676,9 @@ export class SqliteMemoryAdapter {
     // ── listPinned ───────────────────────────────────────────────────
     async listPinned(scope, limit) {
         return fromPromise((async () => {
-            // CR-02 fix: exclude expired entries (mirrors the other read paths in
+            // Exclude expired entries (mirrors the other read paths in
             // hydrateLane and search — `expires_at IS NULL OR expires_at > nowMs`).
-            // FORGET-01 (CR-01): the `AND evicted_at IS NULL` is defensive coupling — a
+            // The `AND evicted_at IS NULL` is defensive coupling — a
             // pinned row is store-side eviction-EXEMPT (the lifecycle sweep never evicts
             // pinned/system/high-proof rows), so a `pinned = 1` row can never carry
             // evicted_at; the guard makes the always-on-exclusion invariant explicit on this

package/node_modules/@comis/memory/dist/sqlite-memory-causal-store.js

@@ -75,7 +75,7 @@ export function createSqliteMemoryCausalStore(deps) {
     // Hydrate a linked memory, re-asserting the FULL (tenant, agent) scope so the
     // hydrate is self-sufficient (no fail-open if the lane query is ever
     // refactored). Bound params only.
-    // FORGET-01 (CR-01): the ALWAYS-ON `evicted_at IS NULL` recall exclusion. This is the
+    // The ALWAYS-ON `evicted_at IS NULL` recall exclusion. This is the
     // RECALL-side hydration (causalLane → MemorySearchResult[] → createMemoryRecall → the
     // prompt), so a soft-evicted causal counterpart MUST be omitted here. NB: the WRITE-path
     // `memoryInScope` scope-check above is deliberately NOT filtered — a causal edge may
@@ -140,7 +140,7 @@ export function createSqliteMemoryCausalStore(deps) {
                     logger?.debug({ step: "causal-lane", seedCount: 0, resultCount: 0, durationMs: 0 }, "Causal lane skipped (no seeds)");
                     return ok([]);
                 }
-                // The scoped one-hop UNION (RESEARCH Pattern 3 — verified). The
+                // The scoped one-hop UNION. The
                 // `tenant_id = ? AND agent_id = ?` on BOTH arms is the load-bearing
                 // ISOLATION boundary — a cross-scope edge sharing a memory id is
                 // excluded. The first arm walks source→effect (PK prefix); the second walks
@@ -171,7 +171,7 @@ export function createSqliteMemoryCausalStore(deps) {
                         bestConfidence.set(linked, confidence);
                 }
                 // Hydrate each linked memory (scoped) into a MemorySearchResult; score =
-                // edge confidence (RESEARCH Pattern 3 intra-lane order).
+                // edge confidence (intra-lane order).
                 const scored = [];
                 for (const [linkedId, score] of bestConfidence) {
                     const memParsed = memoryRowMapper.parseOptionalRow(hydrateMemory.get(linkedId, tenantId, agentId));

package/node_modules/@comis/memory/dist/sqlite-memory-consolidation-store.d.ts

@@ -2,19 +2,19 @@
  * SqliteMemoryConsolidationStore: the SOLE adapter for the segregated
  * `MemoryConsolidationStore` port (@comis/core).
  *
- * Phase 226 (SIMPLIFY-02): TRIMMED to the LIVE read + deletion-reconciliation
- * surface after the consolidation CRON (the writer) was retired in phase 225.
- * It owns ONLY the SQL behind the three live, non-cron methods:
+ * This adapter exposes the live read + deletion-reconciliation surface only;
+ * there is no consolidation writer. It owns the SQL behind the three live,
+ * non-cron methods:
  *   - `listObservations`             — the scoped observation listing
  *                                      (`proof_count IS NOT NULL`) behind the
  *                                      `comis memory` observation view.
- *   - `unlinkDeletedSources`         — DIST-05 deletion reconciliation: re-scan
+ *   - `unlinkDeletedSources`         — deletion reconciliation: re-scan
  *                                      in-scope observations' `source_ids`,
  *                                      delete orphans / shrink multi-source rows.
- *   - `purgeConsolidatedDerivedFrom` — DIST-05 nuclear purge of observations
+ *   - `purgeConsolidatedDerivedFrom` — nuclear purge of observations
  *                                      derived from a reset session's ids.
- * The dead writer SQL (candidate selection / apply / fold / surprisal k-NN /
- * deductive-drain) is gone.
+ * No writer SQL (candidate selection / apply / fold / surprisal k-NN /
+ * deductive-drain) lives here.
  *
  * It shares the `better-sqlite3` handle of the `SqliteMemoryAdapter` (passed in
  * via `getDb()`), so it runs against the same schema — the `memories` table

package/node_modules/@comis/memory/dist/sqlite-memory-consolidation-store.js

@@ -3,19 +3,19 @@
  * SqliteMemoryConsolidationStore: the SOLE adapter for the segregated
  * `MemoryConsolidationStore` port (@comis/core).
  *
- * Phase 226 (SIMPLIFY-02): TRIMMED to the LIVE read + deletion-reconciliation
- * surface after the consolidation CRON (the writer) was retired in phase 225.
- * It owns ONLY the SQL behind the three live, non-cron methods:
+ * This adapter exposes the live read + deletion-reconciliation surface only;
+ * there is no consolidation writer. It owns the SQL behind the three live,
+ * non-cron methods:
  *   - `listObservations`             — the scoped observation listing
  *                                      (`proof_count IS NOT NULL`) behind the
  *                                      `comis memory` observation view.
- *   - `unlinkDeletedSources`         — DIST-05 deletion reconciliation: re-scan
+ *   - `unlinkDeletedSources`         — deletion reconciliation: re-scan
  *                                      in-scope observations' `source_ids`,
  *                                      delete orphans / shrink multi-source rows.
- *   - `purgeConsolidatedDerivedFrom` — DIST-05 nuclear purge of observations
+ *   - `purgeConsolidatedDerivedFrom` — nuclear purge of observations
  *                                      derived from a reset session's ids.
- * The dead writer SQL (candidate selection / apply / fold / surprisal k-NN /
- * deductive-drain) is gone.
+ * No writer SQL (candidate selection / apply / fold / surprisal k-NN /
+ * deductive-drain) lives here.
  *
  * It shares the `better-sqlite3` handle of the `SqliteMemoryAdapter` (passed in
  * via `getDb()`), so it runs against the same schema — the `memories` table
@@ -46,7 +46,7 @@ import { MemoryRowSchema, IdProjectionRowSchema } from "./row-schemas.js";
 // peels the joined `embedding` column off each raw row BEFORE this strict parse,
 // so the extra column never trips MemoryRowSchema's `strictObject`.
 const memoryRowMapper = createRowMapper(MemoryRowSchema);
-// DIST-05 id-projection mapper (sanctioned typed-read path; no `as Foo[]` cast).
+// Id-projection mapper (sanctioned typed-read path; no `as Foo[]` cast).
 const idProjectionMapper = createRowMapper(IdProjectionRowSchema);
 /**
  * Create the SQLite-backed {@link MemoryConsolidationStore} adapter over a
@@ -57,7 +57,7 @@ export function createSqliteMemoryConsolidationStore(deps) {
     const { db, logger } = deps;
     // --- Prepared statements (parameterized; built once, reused across calls) ---
     // Observation listing (the `comis memory` observation view). proof_count IS
-    // NOT NULL is the column-flag for "this row is an observation" (§4.1). Scoped
+    // NOT NULL is the column-flag for "this row is an observation". Scoped
     // on (tenant_id, agent_id) — a cross-scope observation is never returned.
     const selectObservations = db.prepare("SELECT * FROM memories WHERE tenant_id = ? AND agent_id = ? AND proof_count IS NOT NULL " +
         "ORDER BY created_at DESC LIMIT ?");
@@ -89,7 +89,7 @@ export function createSqliteMemoryConsolidationStore(deps) {
             }
         },
         async unlinkDeletedSources(_sessionKey, tenantId, agentId) {
-            // DIST-05: called AFTER the raw memories were deleted by
+            // Called AFTER the raw memories were deleted by
             // deleteBySessionKey, so the source rows are already gone. We re-scan each
             // in-scope observation's source_ids and treat any id no longer present in
             // `memories` (for this tenant+agent) as a deleted source. Orphan (every
@@ -101,12 +101,12 @@ export function createSqliteMemoryConsolidationStore(deps) {
             // --purge path + a future provenance-joined variant; the
             // delete-already-happened semantics mean the load-bearing predicate is
             // "source id absent from memories" — sessionKey-agnostic but
-            // (tenant, agent)-SCOPED (WR-05: matches deleteBySessionKey's scope exactly,
+            // (tenant, agent)-SCOPED (matches deleteBySessionKey's scope exactly,
             // fail-closed isolation), so the param is intentionally unused here.
             const startMs = systemNowMs();
             try {
                 // The set of live memory ids for this tenant+agent — the membership oracle
-                // for "still exists". Scoped on tenant_id AND agent_id (WR-05, fail-closed:
+                // for "still exists". Scoped on tenant_id AND agent_id (fail-closed:
                 // a cross-scope id is never in this set, so it can never be treated as
                 // "surviving"). Typed read via the sanctioned mapper (untyped-sqlite).
                 const liveIdsParsed = idProjectionMapper.parseRows(db.prepare("SELECT id FROM memories WHERE tenant_id = ? AND agent_id = ?").all(tenantId, agentId));
@@ -116,7 +116,7 @@ export function createSqliteMemoryConsolidationStore(deps) {
                 // All observations (proof_count IS NOT NULL) in this tenant+agent carry the
                 // source_ids array. Read the full rows through the existing memoryRowMapper
                 // (SELECT *) so source_ids is parsed for us by rowToEntry (no new schema,
-                // no manual JSON.parse). Scoped on tenant_id AND agent_id (WR-05) — mirrors
+                // no manual JSON.parse). Scoped on tenant_id AND agent_id — mirrors
                 // the agent-scoped selectObservations/selectCandidates in this file.
                 const observationsParsed = memoryRowMapper.parseRows(db
                     .prepare("SELECT * FROM memories WHERE proof_count IS NOT NULL AND tenant_id = ? AND agent_id = ?")
@@ -164,20 +164,20 @@ export function createSqliteMemoryConsolidationStore(deps) {
             }
         },
         async purgeConsolidatedDerivedFrom(sessionKey, tenantId, agentId, thisSessionIds) {
-            // DIST-05 nuclear escalation: delete EVERY observation derived from THIS
+            // Nuclear escalation: delete EVERY observation derived from THIS
             // session's deleted memory ids. Called via the opt-in --purge-derived flag
             // ONLY. Runs AFTER the raw memories were deleted, but the purge oracle is
             // the explicit `thisSessionIds` set (captured BEFORE the delete via
             // MemoryPort.listMemoryIdsBySessionKey), NOT "any source id now absent".
             //
-            // WR-02 (session-scoped, not coarse): an observation is purged ONLY if its
+            // Session-scoped (not coarse): an observation is purged ONLY if its
             // source_ids INTERSECT thisSessionIds. A prior unrelated dangling source id
             // in an UNRELATED observation (from an earlier admin delete / TTL / another
             // session's purge) is left alone — the bug the "any absent id" oracle had.
             // It still nukes a multi-source observation when one of its sources WAS a
             // this-session id (nuclear regardless of surviving corroboration).
             //
-            // WR-05: scoped on tenant_id AND agent_id (matches deleteBySessionKey).
+            // Scoped on tenant_id AND agent_id (matches deleteBySessionKey).
             // `sessionKey` is retained for the audit log. An empty thisSessionIds set
             // purges nothing (fast-path).
             const startMs = systemNowMs();
@@ -202,7 +202,7 @@ export function createSqliteMemoryConsolidationStore(deps) {
                             continue;
                         // Purge ONLY when a source id was one of THIS session's deleted ids
                         // (source_ids ∩ thisSessionIds ≠ ∅) — nuclear regardless of surviving
-                        // corroboration, but session-scoped (WR-02): unrelated observations
+                        // corroboration, but session-scoped: unrelated observations
                         // with a prior dangling id are untouched.
                         const derivedFromThisSession = ids.some((id) => sessionIdSet.has(id));
                         if (derivedFromThisSession) {

package/node_modules/@comis/memory/dist/sqlite-memory-entity-store.js

@@ -38,7 +38,7 @@ import { normalizeEntityKey, nameSimilarity } from "./entity-resolver.js";
 import { createRowMapper, rowToEntry } from "./row-mapper.js";
 import { MemoryEntityRowSchema, MemoryRowSchema, EntityLaneRowSchema, EntityListRowSchema, } from "./row-schemas.js";
 /** Dice-bigram similarity at/above which a near-duplicate name reuses an
- *  existing entity rather than minting a new one (design §6.2). */
+ *  existing entity rather than minting a new one. */
 const FUZZY_REUSE_THRESHOLD = 0.6;
 // Row mappers — the sanctioned read path (no `as Foo[]`).
 const entityRowMapper = createRowMapper(MemoryEntityRowSchema);
@@ -67,7 +67,7 @@ export function createSqliteMemoryEntityStore(deps) {
     // isolation boundary then depends on two statements agreeing, with the agent
     // dimension enforced in only one. Re-asserting the full scope here makes the
     // hydrate self-sufficient (no fail-open if the lane query is ever refactored).
-    // FORGET-01 (CR-01): the ALWAYS-ON `evicted_at IS NULL` recall exclusion. This is a
+    // The ALWAYS-ON `evicted_at IS NULL` recall exclusion. This is a
     // RECALL-side hydration (associativeLane → MemorySearchResult[] → createMemoryRecall →
     // the prompt), so a soft-evicted shared-entity memory MUST be omitted here exactly as on
     // the adapter's recall paths. The inspect/asOf raw reads stay UNFILTERED (eviction soft +
@@ -211,8 +211,8 @@ export function createSqliteMemoryEntityStore(deps) {
                 if (!parsed.ok)
                     return err(new Error(parsed.error.message));
                 // Hydrate each shared-entity memory row (scoped) into a
-                // MemorySearchResult; score = tanh(shared * 0.5) (design §5.2 intra-lane
-                // order). Rows already arrive most-shared-first.
+                // MemorySearchResult; score = tanh(shared * 0.5) sets the intra-lane
+                // order. Rows already arrive most-shared-first.
                 const results = [];
                 for (const { memory_id, shared } of parsed.value) {
                     const memParsed = memoryRowMapper.parseOptionalRow(hydrateMemory.get(memory_id, tenantId, agentId));

package/node_modules/@comis/memory/dist/sqlite-memory-lifecycle-store.d.ts

@@ -20,12 +20,11 @@
  *                                     (liveEviction && failureCount >= failureEvictionFloor))
  *
  * where `exempt` = pinned ∨ `trust_level === 'system'` ∨ `proof_count >=
- * highProofFloor` — the FORGET-03 anti-induced-eviction floors. (The FadeMem
- * strength-decay disjunct was DELETED in Phase 224: its strength formula floored at
- * `0.5·exp(…) ≥ ~0.25`, ABOVE the 0.2 strength floor, so the strength term could
- * never fire for a failure-implicated row — the EVI-STRENGTH-FLOOR dead branch. The
- * corroborated-`failure_count` floor is the reachable wrongness-eviction path that
- * replaces it.) A soft-evicted row has
+ * highProofFloor` — the anti-induced-eviction floors. (There is no strength-decay
+ * disjunct: a strength formula that floors at `0.5·exp(…) ≥ ~0.25`, ABOVE the 0.2
+ * strength floor, could never fire for a failure-implicated row, so the
+ * corroborated-`failure_count` floor is the reachable wrongness-eviction path.) A
+ * soft-evicted row has
  * `evicted_at` set NON-DESTRUCTIVELY (a marker, never a hard DELETE — the
  * `consolidated_at` precedent), preserving the raw row + provenance for audit/`asOf`.
  * The eviction is REVERSIBLE via {@link MemoryLifecyclePort.unevict} (clear
@@ -34,12 +33,12 @@
  * `evicted`/`demoted` = 0, no UPDATE, no DELETE) — the byte-identity guarantee. Tier
  * demote/promote moves remain a deferred step (`promoted`/`demoted` are still 0 in
  * this build). The recall-side exclusion of evicted rows is enforced on EVERY live
- * recall path (CR-01), not here: `hybrid-search.ts` (the post-fusion `evicted_at IS
+ * recall path, not here: `hybrid-search.ts` (the post-fusion `evicted_at IS
  * NULL`) AND `sqlite-memory-adapter.ts` (`hydrateLane`/`searchLanes` + the
  * vector-only `search()` per-id reads). The inspect/asOf raw reads stay UNFILTERED so
  * an evicted row is still audit/asOf-resolvable.
  *
- * ## Isolation is the load-bearing security boundary (the §5.2 invariant)
+ * ## Isolation is the load-bearing security boundary
  *
  * Comis runs many agents and many tenants in ONE DB. The candidate SELECT filters
  * `WHERE tenant_id = ? AND agent_id = ?` (bound params), so a sweep run under one
@@ -71,16 +70,16 @@ interface MemoryLogger {
 }
 /**
  * The lifecycle policy: the dormancy window PLUS the optional LIVE soft-eviction
- * behavior gate + the two FORGET-03/02 floors. The daemon passes the
+ * behavior gate + the two anti-induced-eviction floors. The daemon passes the
  * operator-configured `learningForgetting` values via `deps`/`scope.policy` when it
  * wires the cron; until then the unit adapter uses {@link DEFAULT_POLICY}.
  */
 export interface MemoryLifecyclePolicy {
     /**
      * Dormancy window (T_max, days): a memory UNUSED (not recalled-useful) for longer
-     * than T_max is an eviction candidate. WR-02: "dormant" is measured from
+     * than T_max is an eviction candidate. "dormant" is measured from
      * `last_useful_at` (last recall), NOT `occurred_at` (event time) — a recently-
-     * recalled memory about an OLD event is NOT dormant (FORGET-04). A never-recalled
+     * recalled memory about an OLD event is NOT dormant. A never-recalled
      * memory falls back to event age, so genuinely-stale rows still reap.
      */
     maxDormantDays: number;
@@ -93,19 +92,19 @@ export interface MemoryLifecyclePolicy {
      */
     evictionEnabled?: boolean;
     /**
-     * The high-`proof_count` eviction-exemption floor (FORGET-03 anti-induced-
+     * The high-`proof_count` eviction-exemption floor (anti-induced-
      * eviction): a memory with `proof_count >= highProofFloor` is NEVER soft-evicted,
      * no matter how many failures — a poisoner inducing failures cannot evict a
      * well-corroborated memory. Defaults to {@link DEFAULT_HIGH_PROOF_FLOOR}.
      */
     highProofFloor?: number;
     /**
-     * The corroborated-`failure_count` eviction floor (FORGET-02, the EVI-STRENGTH-FLOOR
-     * fix): the at/above-which a NON-EXEMPT memory is soft-evicted. This is the reachable
-     * wrongness-eviction path (the deleted strength disjunct floored above its threshold
-     * and never fired). Each `failure_count` increment is itself corroboration-gated (≥2
-     * independent sessions OR a deterministic source, setup-learning-corroboration.ts).
-     * SECURITY: gated by the SAME FORGET-03 exemptions (pinned / system / `proof_count >=
+     * The corroborated-`failure_count` eviction floor: the at/above-which a NON-EXEMPT
+     * memory is soft-evicted. This is the reachable wrongness-eviction path (a
+     * strength-decay disjunct would floor above its threshold and never fire). Each
+     * `failure_count` increment is itself corroboration-gated (≥2 independent sessions
+     * OR a deterministic source, setup-learning-corroboration.ts).
+     * SECURITY: gated by the SAME anti-induced-eviction exemptions (pinned / system / `proof_count >=
      * highProofFloor`), so an induced-failure attacker still cannot evict a
      * well-corroborated/pinned/system memory — the floor only reaches LOW-proof,
      * non-pinned, non-system rows. Default {@link DEFAULT_FAILURE_EVICTION_FLOOR}; a

package/node_modules/@comis/memory/dist/sqlite-memory-lifecycle-store.js

@@ -21,12 +21,11 @@
  *                                     (liveEviction && failureCount >= failureEvictionFloor))
  *
  * where `exempt` = pinned ∨ `trust_level === 'system'` ∨ `proof_count >=
- * highProofFloor` — the FORGET-03 anti-induced-eviction floors. (The FadeMem
- * strength-decay disjunct was DELETED in Phase 224: its strength formula floored at
- * `0.5·exp(…) ≥ ~0.25`, ABOVE the 0.2 strength floor, so the strength term could
- * never fire for a failure-implicated row — the EVI-STRENGTH-FLOOR dead branch. The
- * corroborated-`failure_count` floor is the reachable wrongness-eviction path that
- * replaces it.) A soft-evicted row has
+ * highProofFloor` — the anti-induced-eviction floors. (There is no strength-decay
+ * disjunct: a strength formula that floors at `0.5·exp(…) ≥ ~0.25`, ABOVE the 0.2
+ * strength floor, could never fire for a failure-implicated row, so the
+ * corroborated-`failure_count` floor is the reachable wrongness-eviction path.) A
+ * soft-evicted row has
  * `evicted_at` set NON-DESTRUCTIVELY (a marker, never a hard DELETE — the
  * `consolidated_at` precedent), preserving the raw row + provenance for audit/`asOf`.
  * The eviction is REVERSIBLE via {@link MemoryLifecyclePort.unevict} (clear
@@ -35,12 +34,12 @@
  * `evicted`/`demoted` = 0, no UPDATE, no DELETE) — the byte-identity guarantee. Tier
  * demote/promote moves remain a deferred step (`promoted`/`demoted` are still 0 in
  * this build). The recall-side exclusion of evicted rows is enforced on EVERY live
- * recall path (CR-01), not here: `hybrid-search.ts` (the post-fusion `evicted_at IS
+ * recall path, not here: `hybrid-search.ts` (the post-fusion `evicted_at IS
  * NULL`) AND `sqlite-memory-adapter.ts` (`hydrateLane`/`searchLanes` + the
  * vector-only `search()` per-id reads). The inspect/asOf raw reads stay UNFILTERED so
  * an evicted row is still audit/asOf-resolvable.
  *
- * ## Isolation is the load-bearing security boundary (the §5.2 invariant)
+ * ## Isolation is the load-bearing security boundary
  *
  * Comis runs many agents and many tenants in ONE DB. The candidate SELECT filters
  * `WHERE tenant_id = ? AND agent_id = ?` (bound params), so a sweep run under one
@@ -71,18 +70,18 @@ const DEFAULT_POLICY = {
     maxDormantDays: 90,
 };
 /**
- * The default high-`proof_count` eviction-exemption floor (FORGET-03). A memory
+ * The default high-`proof_count` eviction-exemption floor. A memory
  * corroborated by >= 5 independent observations is treated as durably-trusted and
  * is never soft-evicted — the anti-cache-poisoning guarantee at the store. Mirrors
  * the design's high-proof exemption; the daemon can override via the policy.
  */
 const DEFAULT_HIGH_PROOF_FLOOR = 5;
 /**
- * RC-3: the default corroborated-`failure_count` eviction floor. Each `failure_count`
+ * The default corroborated-`failure_count` eviction floor. Each `failure_count`
  * increment is corroboration-gated (≥2 independent sessions OR a deterministic source),
  * so 3 means a memory implicated in failures across multiple independent corroborated
  * events — sustained wrongness, not a stray transient. Deliberately conservative; only
- * reaches LOW-proof, non-pinned, non-system rows (the FORGET-03 exemptions still hold).
+ * reaches LOW-proof, non-pinned, non-system rows (the exemptions still hold).
  */
 const DEFAULT_FAILURE_EVICTION_FLOOR = 3;
 /**
@@ -108,16 +107,16 @@ export function createSqliteMemoryLifecycleStore(deps) {
     // scope can NEVER read another tenant/agent's rows. The LIMIT (a bound `?`)
     // bounds the per-sweep working set. Bound params only — never concatenated.
     //
-    // The LEFT JOIN folds in the FORGET-02 wrongness signal: the per-(tenant, agent,
+    // The LEFT JOIN folds in the failure-count wrongness signal: the per-(tenant, agent,
     // memory) `failure_count` SUMmed across intents (a memory may accrue failures in
-    // several intent buckets). WR-02: it ALSO folds in the last-recall recency
+    // several intent buckets). It ALSO folds in the last-recall recency
     // `MAX(last_useful_at)` across intents — the DISUSE signal the dormant-age branch
     // keys off (NOT occurred_at, the event time), so a recently-recalled old-event
     // memory is not "dormant". The subquery is scoped to the SAME (tenant, agent) as
     // the outer scan (it cannot leak another scope's failures/recency), and the LEFT
     // JOIN keeps memories with no usefulness row (NULL → coalesced below; an absent
     // last_useful_at falls back to event age so a never-recalled old memory still
-    // reaps). `pinned` and `trust_level` feed the FORGET-03 exemptions.
+    // reaps). `pinned` and `trust_level` feed the anti-induced-eviction exemptions.
     const scanCandidates = db.prepare("SELECT m.id, m.memory_type, m.occurred_at, m.created_at, m.proof_count, " +
         "m.lifecycle_demoted_at, m.evicted_at, m.strength, m.pinned, m.trust_level, " +
         "u.failure_count AS failure_count, u.last_useful_at AS last_useful_at " +
@@ -130,13 +129,13 @@ export function createSqliteMemoryLifecycleStore(deps) {
         ") u ON u.memory_id = m.id " +
         "WHERE m.tenant_id = ? AND m.agent_id = ? " +
         "LIMIT ?");
-    // The NON-DESTRUCTIVE soft-eviction UPDATE (FORGET-01): set the `evicted_at`
+    // The NON-DESTRUCTIVE soft-eviction UPDATE: set the `evicted_at`
     // marker, NEVER DELETE. Scoped to (tenant, agent) so a sweep can only mark its
     // own rows. The `evicted_at IS NULL` guard makes a re-eviction a no-op (idempotent;
     // never re-stamps an already-evicted row's timestamp).
     const softEvict = db.prepare("UPDATE memories SET evicted_at = ? " +
         "WHERE id = ? AND tenant_id = ? AND agent_id = ? AND evicted_at IS NULL");
-    // The REVERSAL (FORGET-04): clear the marker on renewed usefulness. Scoped to
+    // The REVERSAL: clear the marker on renewed usefulness. Scoped to
     // (tenant, agent) — the isolation boundary holds on the un-evict too.
     const clearEvict = db.prepare("UPDATE memories SET evicted_at = NULL WHERE id = ? AND tenant_id = ? AND agent_id = ?");
     return {
@@ -152,7 +151,7 @@ export function createSqliteMemoryLifecycleStore(deps) {
                     return err(new Error(parsed.error.message));
                 const rows = parsed.value;
                 // The EFFECTIVE policy = the per-call `scope.policy` override (the daemon's per-agent
-                // `learningForgetting`, FORGET-06) layered over the constructor policy. The store is
+                // `learningForgetting`) layered over the constructor policy. The store is
                 // shared across agents but the eviction behavior is PER-AGENT, so the gate rides the
                 // call: an absent override → the constructor policy (DORMANT by default — byte-identity).
                 const ov = scope.policy;
@@ -163,10 +162,10 @@ export function createSqliteMemoryLifecycleStore(deps) {
                 const liveEviction = effEvictionEnabled === true;
                 const highProofFloor = policy.highProofFloor ?? DEFAULT_HIGH_PROOF_FLOOR;
                 // The corroborated-failure eviction floor (the reachable wrongness path). Only
-                // consulted under the LIVE policy; the FORGET-03 exemptions still gate it.
+                // consulted under the LIVE policy; the exemptions still gate it.
                 const failureEvictionFloor = ov?.failureEvictionFloor ?? policy.failureEvictionFloor ?? DEFAULT_FAILURE_EVICTION_FLOOR;
                 // Per-row eviction candidacy: the two reachable disjuncts (dormancy OR
-                // corroborated-failure), minus the FORGET-03 exemptions. Under the LIVE policy
+                // corroborated-failure), minus the exemptions. Under the LIVE policy
                 // the eligible candidates are collected for the soft UPDATE below; under DORMANT
                 // nothing is applied (the byte-identity guarantee).
                 let evictionCandidates = 0;
@@ -175,18 +174,18 @@ export function createSqliteMemoryLifecycleStore(deps) {
                     // Event-time in epoch ms (occurred_at ?? created_at) — the fallback for a
                     // never-recalled row's disuse age below. Uses the INJECTED scope.now, never Date.now.
                     const eventMs = row.occurred_at ?? row.created_at;
-                    // WR-02: the DISUSE age — days since the memory was last RECALLED-useful
+                    // The DISUSE age — days since the memory was last RECALLED-useful
                     // (last_useful_at), falling back to the event age when it was never recalled
                     // (NULL). This — NOT the event age — gates the dormant-age candidacy disjunct,
-                    // so a recently-recalled memory about an OLD event is NOT "dormant" (FORGET-04:
-                    // wrong fades faster than merely old; a still-useful old fact is not reaped on
+                    // so a recently-recalled memory about an OLD event is NOT "dormant" (wrong
+                    // fades faster than merely old; a still-useful old fact is not reaped on
                     // event-age alone). A never-recalled old memory falls back to event age, so the
                     // age reaper still prunes genuinely dormant rows.
                     const lastUsefulMs = row.last_useful_at ?? eventMs;
                     const disuseDays = Math.max(0, (now - lastUsefulMs) / DAY_MS);
                     const proof = row.proof_count ?? 0;
                     const failureCount = row.failure_count ?? 0;
-                    // FORGET-03 anti-induced-eviction EXEMPTIONS (the store-side half of the
+                    // Anti-induced-eviction EXEMPTIONS (the store-side half of the
                     // corroboration control): pinned / system-trust / high-proof memories are
                     // NEVER evicted, no matter how many failures. A poisoner inducing failures
                     // cannot evict a well-corroborated, pinned, or system memory.
@@ -194,14 +193,14 @@ export function createSqliteMemoryLifecycleStore(deps) {
                         row.trust_level === "system" ||
                         proof >= highProofFloor;
                     // The eviction candidacy: DORMANT (UNUSED) beyond T_max OR corroborated-wrong
-                    // (`failure_count >= failureEvictionFloor`) — minus the exemptions. WR-02: the
+                    // (`failure_count >= failureEvictionFloor`) — minus the exemptions. The
                     // age disjunct uses `disuseDays` (days since last recall), so a recently-recalled
-                    // old-event memory survives the age branch (FORGET-04); a never-recalled old
+                    // old-event memory survives the age branch; a never-recalled old
                     // memory still trips it (disuseDays falls back to event age). The failure disjunct
-                    // is the reachable wrongness path — the deleted FadeMem strength disjunct floored
-                    // above its threshold and never fired (EVI-STRENGTH-FLOOR). The failure disjunct
+                    // is the reachable wrongness path — a strength-decay disjunct would floor
+                    // above its threshold and never fire. The failure disjunct
                     // is gated on `liveEviction` so the DORMANT-mode candidacy count stays
-                    // byte-identical; `!exempt` keeps the FORGET-03 guarantee (high-proof / pinned /
+                    // byte-identical; `!exempt` keeps the anti-induced-eviction guarantee (high-proof / pinned /
                     // system are never reached, no matter how many failures).
                     const isEvictionCandidate = !exempt &&
                         (disuseDays > policy.maxDormantDays ||

package/node_modules/@comis/memory/dist/sqlite-memory-temporal-store.js

@@ -58,7 +58,7 @@ export function createSqliteMemoryTemporalStore(deps) {
     // min-distance is computed, so a tighter `LIMIT` here would risk dropping a nearer row
     // that sorts after a farther one by raw occurred_at — fetch generously, cap in TS).
     // Placeholders only — no string-built SQL.
-    // FORGET-01 (CR-01): the ALWAYS-ON `evicted_at IS NULL` recall exclusion. This windowed
+    // The ALWAYS-ON `evicted_at IS NULL` recall exclusion. This windowed
     // read is a RECALL-side hydration (spreadLane → MemorySearchResult[] → createMemoryRecall
     // → the prompt), so a soft-evicted in-window memory MUST be omitted here exactly as on the
     // adapter's recall paths. The inspect/asOf raw reads stay UNFILTERED (eviction soft +

package/node_modules/@comis/memory/dist/sqlite-memory-usefulness-store.js

@@ -73,7 +73,7 @@ export function createSqliteMemoryUsefulnessStore(deps) {
     const upsertIgnored = db.prepare("INSERT INTO memory_usefulness (tenant_id, agent_id, memory_id, intent, used_count, ignored_count, last_useful_at) " +
         "VALUES (?, ?, ?, ?, 0, 1, NULL) " +
         "ON CONFLICT(tenant_id, agent_id, memory_id, intent) DO UPDATE SET ignored_count = ignored_count + 1");
-    // Failure per-intent upsert (FORGET-02): first touch INSERTs failure_count=1
+    // Failure per-intent upsert: first touch INSERTs failure_count=1
     // (used/ignored=0, last_useful_at NULL — a failure is NEITHER a use NOR an
     // ignore), later touches bump failure_count within the SAME (…, intent) bucket.
     // failure_count is a DISTINCT signal from ignored_count (outcome-attributed task
@@ -178,7 +178,7 @@ export function createSqliteMemoryUsefulnessStore(deps) {
                 // (?, '')` fetches BOTH the requested per-intent bucket AND the global
                 // fallback row per id; the per-id preference is resolved below.
                 const ph = memoryIds.map(() => "?").join(", ");
-                // WR-03: `failure_count` is now PROJECTED (the bandit feed's negative-reward
+                // `failure_count` is PROJECTED (the bandit feed's negative-reward
                 // signal). It is surfaced onto the signal ONLY when > 0 below, so a clean
                 // memory's signal shape is byte-identical and the recall hot-path usefulnessNorm
                 // (used/ignored only) is unaffected.
@@ -209,7 +209,7 @@ export function createSqliteMemoryUsefulnessStore(deps) {
                         usedCount: row.used_count,
                         ignoredCount: row.ignored_count,
                         ...(row.last_useful_at !== null ? { lastUsefulAt: row.last_useful_at } : {}),
-                        // WR-03: surface failure_count ONLY when > 0 (spread-conditional, like
+                        // Surface failure_count ONLY when > 0 (spread-conditional, like
                         // lastUsefulAt) so a clean memory's signal is byte-identical — the recall
                         // hot path ignores it; the bandit feed reads it as the negative-reward term.
                         ...(row.failure_count !== undefined && row.failure_count > 0