comisai 1.0.44 → 1.0.46

package/node_modules/@comis/memory/dist/lcd-store-fts-populate.d.ts

@@ -1,8 +1,8 @@
 /**
- * LCD FTS populate helpers — the index-write half of FTS-01 (Phase 180).
+ * LCD FTS populate helpers — the index-write half of the FTS search path.
  * Extracted from `lcd-store.ts` so the adapter stays under the 800-line
  * file-size cap (mirrors the prior `lcd-store-writes.ts` / `lcd-fts.ts`
- * extractions; RESEARCH Pitfall 4). This file holds the populate logic + its
+ * extractions). This file holds the populate logic + its
  * prepared statements; `createLcdStore` calls `createFtsPopulator(db)` ONCE at
  * factory top and invokes the returned methods inside its write transactions
  * (so the "prepare once" discipline is preserved — the statements are prepared
@@ -11,11 +11,11 @@
  * The WORD-lane populate (`populateMessageFts`) was relocated BYTE-IDENTICALLY
  * (same SQL strings, same `messageRowidRowMapper` guard, same `isFtsAvailable`
  * gate, same narrow catch). The normalized TRIGRAM-TWIN inserts
- * (`populateMessageTri` / `insertSummaryTri`) are the index half of the FTS-01
- * symmetry: they fold RAW content through `normalizeForSearch` HERE — the I7
+ * (`populateMessageTri` / `insertSummaryTri`) are the index half of the trigram
+ * symmetry: they fold RAW content through `normalizeForSearch` HERE — the
  * single call site — so the call sites in `lcd-store.ts` / `lcd-store-writes.ts`
  * CANNOT forget the fold. The stored twin text is the SAME symbol the query side
- * (plan 180-05) imports, which is the entire FTS-01 contract: query מלך finds
+ * imports, which is the entire contract: query מלך finds
  * stored מלכים because both fold identically.
  *
  * Each twin's statements are prepared inside its OWN try/catch — `prepare()`
@@ -23,19 +23,19 @@
  * so a failed prep sets THAT twin's handles null and its methods become a clean
  * no-op. This mirrors the `isFtsAvailable` defensive posture without a second
  * probe: if a twin's statements compiled, that twin's table exists. The preps are
- * INDEPENDENT (WR-01) so a partial-schema host with one twin present and the other
+ * INDEPENDENT so a partial-schema host with one twin present and the other
  * absent keeps the present twin live — matching ensureTrigramTwins's per-block DDL.
  *
  * `@comis/memory` is infra-free (AGENTS.md §2.4 — no logger): a degraded
- * populate skips the index row silently by design (WR-03); a twin failure leaves
+ * populate skips the index row silently by design; a twin failure leaves
  * the row DE-INDEXED (the fail-safe direction), never a rolled-back base write.
  *
  * @module
  */
 import type Database from "better-sqlite3";
 import type { LcdMessagePart } from "@comis/core";
-/** The two-column scope the FTS UNINDEXED columns carry (R4). The FTS tables hold
- *  NO tenant_id — `conversation_id` encodes the tenant boundary (lcd-fts.ts:24). */
+/** The two-column scope the FTS UNINDEXED columns carry. The FTS tables hold
+ *  NO tenant_id — `conversation_id` encodes the tenant boundary. */
 export interface FtsPopulateScope {
     conversationId: string;
     agentId: string;
@@ -47,12 +47,12 @@ export interface FtsPopulator {
      *  `isFtsAvailable`; the narrow catch swallows a post-boot INSERT failure. */
     populateMessageFts(messageId: string, parts: LcdMessagePart[], scope: FtsPopulateScope): void;
     /** Trigram-twin populate: `normalizeForSearch(renderMessageFtsText(parts))`
-     *  into `lcd_messages_fts_tri` at the base rowid. Normalizes internally (I7).
+     *  into `lcd_messages_fts_tri` at the base rowid. Normalizes internally.
      *  No-op when the twins are absent (trigram-less host). */
     populateMessageTri(messageId: string, parts: LcdMessagePart[], scope: FtsPopulateScope): void;
     /** Trigram-twin populate for a summary: `normalizeForSearch(rawContent)` into
      *  `lcd_summaries_fts_tri` at the summary's base rowid (resolved by summary_id).
-     *  Normalizes internally (I7). No-op when the twins are absent. */
+     *  Normalizes internally. No-op when the twins are absent. */
     insertSummaryTri(summaryId: string, rawContent: string, scope: FtsPopulateScope): void;
 }
 /**

package/node_modules/@comis/memory/dist/lcd-store-fts-populate.js

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * LCD FTS populate helpers — the index-write half of FTS-01 (Phase 180).
+ * LCD FTS populate helpers — the index-write half of the FTS search path.
  * Extracted from `lcd-store.ts` so the adapter stays under the 800-line
  * file-size cap (mirrors the prior `lcd-store-writes.ts` / `lcd-fts.ts`
- * extractions; RESEARCH Pitfall 4). This file holds the populate logic + its
+ * extractions). This file holds the populate logic + its
  * prepared statements; `createLcdStore` calls `createFtsPopulator(db)` ONCE at
  * factory top and invokes the returned methods inside its write transactions
  * (so the "prepare once" discipline is preserved — the statements are prepared
@@ -12,11 +12,11 @@
  * The WORD-lane populate (`populateMessageFts`) was relocated BYTE-IDENTICALLY
  * (same SQL strings, same `messageRowidRowMapper` guard, same `isFtsAvailable`
  * gate, same narrow catch). The normalized TRIGRAM-TWIN inserts
- * (`populateMessageTri` / `insertSummaryTri`) are the index half of the FTS-01
- * symmetry: they fold RAW content through `normalizeForSearch` HERE — the I7
+ * (`populateMessageTri` / `insertSummaryTri`) are the index half of the trigram
+ * symmetry: they fold RAW content through `normalizeForSearch` HERE — the
  * single call site — so the call sites in `lcd-store.ts` / `lcd-store-writes.ts`
  * CANNOT forget the fold. The stored twin text is the SAME symbol the query side
- * (plan 180-05) imports, which is the entire FTS-01 contract: query מלך finds
+ * imports, which is the entire contract: query מלך finds
  * stored מלכים because both fold identically.
  *
  * Each twin's statements are prepared inside its OWN try/catch — `prepare()`
@@ -24,11 +24,11 @@
  * so a failed prep sets THAT twin's handles null and its methods become a clean
  * no-op. This mirrors the `isFtsAvailable` defensive posture without a second
  * probe: if a twin's statements compiled, that twin's table exists. The preps are
- * INDEPENDENT (WR-01) so a partial-schema host with one twin present and the other
+ * INDEPENDENT so a partial-schema host with one twin present and the other
  * absent keeps the present twin live — matching ensureTrigramTwins's per-block DDL.
  *
  * `@comis/memory` is infra-free (AGENTS.md §2.4 — no logger): a degraded
- * populate skips the index row silently by design (WR-03); a twin failure leaves
+ * populate skips the index row silently by design; a twin failure leaves
  * the row DE-INDEXED (the fail-safe direction), never a rolled-back base write.
  *
  * @module
@@ -50,13 +50,13 @@ export function createFtsPopulator(db) {
     // lcd_messages.rowid. Bound by the message id.
     const selectMessageRowid = db.prepare("SELECT rowid FROM lcd_messages WHERE id = ?");
     function populateMessageFts(messageId, parts, scope) {
-        // E1 (gap #1): populate the CONTENTLESS lcd_messages_fts with the rendered
+        // Populate the CONTENTLESS lcd_messages_fts with the rendered
         // part-text so ctx_search finds this message. lcd_messages has no content
         // column (text is JSON in the parts), so the adapter — not a trigger — is the
         // only place that can render + index it; keep the FTS rowid in step with the
         // lcd_messages rowid (joinable).
         //
-        // WR-03: GATE the populate on isFtsAvailable(db) (memoized per db). On an
+        // GATE the populate on isFtsAvailable(db) (memoized per db). On an
         // FTS5-uncompiled host the lcd_*_fts tables are absent, so this is a CLEAN
         // CONDITIONAL SKIP — the EXPECTED degraded-host case no longer rides the
         // exception path (the old bare `catch {}` swallowed it indistinguishably from
@@ -65,17 +65,17 @@ export function createFtsPopulator(db) {
         // genuinely-exceptional populate failure (e.g. on-disk FTS corruption after a
         // healthy boot). The swallow is RETAINED — and must be — because appendTxn is
         // a db.transaction: re-throwing would roll back the message+parts write the
-        // contentless index is merely best-effort for (LOSSLESS-CLAW §4: the lossless
+        // contentless index is merely best-effort for (the lossless
         // base tables are authoritative; search is a recoverable derived index that
         // the LIKE fallback also covers). @comis/memory is intentionally logger-free
         // (AGENTS.md §2.4 — no getLogger import), so this content-free swallow is the
         // floor; the agent-side boundary-observability line for FTS-populate health
-        // rides the injected-logger write path (Plan 128), not this layer.
+        // rides the injected-logger write path, not this layer.
         if (isFtsAvailable(db)) {
             try {
                 const parsedRowid = messageRowidRowMapper.parseOptionalRow(selectMessageRowid.get(messageId));
                 if (parsedRowid.ok && parsedRowid.value) {
-                    insertMessageFts.run(parsedRowid.value.rowid, renderMessageFtsText(parts), scope.conversationId, scope.agentId, // R4: agent_id UNINDEXED so the FTS MATCH filters by agent (WR-02)
+                    insertMessageFts.run(parsedRowid.value.rowid, renderMessageFtsText(parts), scope.conversationId, scope.agentId, // agent_id UNINDEXED so the FTS MATCH filters by agent
                     messageId);
                 }
             }
@@ -90,13 +90,13 @@ export function createFtsPopulator(db) {
     // ── Trigram twins (probe-gated via guarded prep) ────────────────────────────
     // `prepare()` THROWS on a trigram-less host (the twin tables do not exist →
     // "no such table"). A failed prep leaves the handles null and every twin method
-    // is a clean no-op — search degrades to the scan floors (plan 180-05), the
+    // is a clean no-op — search degrades to the scan floors, the
     // append path is unaffected. If the statements compiled, the twin tables exist
     // (so no second runtime probe is needed). The twin's rowid = the base rowid
-    // (the same linkage insertMessageFts uses) so the 180-02 AFTER DELETE triggers
+    // (the same linkage insertMessageFts uses) so the AFTER DELETE triggers
     // mirror twin deletes by `old.rowid`.
     //
-    // WR-01: prepare EACH twin in its OWN try/catch — mirror ensureTrigramTwins's
+    // Prepare EACH twin in its OWN try/catch — mirror ensureTrigramTwins's
     // per-block DDL independence. On a partial-schema host where the message twin
     // exists but the summaries twin does NOT (e.g. the summaries CREATE failed while
     // the messages one succeeded, or a hand-edited dev DB — each DDL twin lives in
@@ -124,7 +124,7 @@ export function createFtsPopulator(db) {
     catch {
         // Summary twin absent (trigram tokenizer missing, or this twin's DDL block
         // failed) → both handles stay null and insertSummaryTri is a clean no-op. A
-        // present message twin (above) is UNAFFECTED (WR-01).
+        // present message twin (above) is UNAFFECTED.
         insertSummaryTriStmt = null;
         selectSummaryRowid = null;
     }
@@ -136,10 +136,10 @@ export function createFtsPopulator(db) {
             const parsedRowid = messageRowidRowMapper.parseOptionalRow(selectMessageRowid.get(messageId));
             if (parsedRowid.ok && parsedRowid.value) {
                 insertMessageTri.run(parsedRowid.value.rowid, 
-                // I7: normalize RAW content HERE (the single call site) so the index
-                // side folds identically to the query side (plan 180-05 imports the
+                // Normalize RAW content HERE (the single call site) so the index
+                // side folds identically to the query side (which imports the
                 // same symbol). The folded text is what a script-routed MATCH reads.
-                normalizeForSearch(renderMessageFtsText(parts)), scope.conversationId, scope.agentId, // R4: agent_id UNINDEXED so the twin MATCH filters by agent (WR-02)
+                normalizeForSearch(renderMessageFtsText(parts)), scope.conversationId, scope.agentId, // agent_id UNINDEXED so the twin MATCH filters by agent
                 messageId);
             }
         }
@@ -157,8 +157,8 @@ export function createFtsPopulator(db) {
             const parsedRowid = messageRowidRowMapper.parseOptionalRow(selectSummaryRowid.get(summaryId));
             if (parsedRowid.ok && parsedRowid.value) {
                 insertSummaryTriStmt.run(parsedRowid.value.rowid, 
-                // I7: normalize RAW summary content HERE (the single call site).
-                normalizeForSearch(rawContent), scope.conversationId, scope.agentId, // R4: agent_id UNINDEXED so the twin MATCH filters by agent (WR-02)
+                // Normalize RAW summary content HERE (the single call site).
+                normalizeForSearch(rawContent), scope.conversationId, scope.agentId, // agent_id UNINDEXED so the twin MATCH filters by agent
                 summaryId);
             }
         }

package/node_modules/@comis/memory/dist/lcd-store-mappers.d.ts

@@ -11,10 +11,10 @@
 import { type LcdMessage, type LcdPartMetadata } from "@comis/core";
 import type { Message } from "@earendil-works/pi-ai";
 /**
- * The named pi-ai reconstruction entry point for the LCD store (F2/F3).
+ * The named pi-ai reconstruction entry point for the LCD store.
  *
  * `getMessages` returns the faithful `LcdMessage` DTO rows; turning one back
- * into a canonical pi-ai `Message` is the consumer's step — Phase-128 assembly
+ * into a canonical pi-ai `Message` is the consumer's step — the assembly layer
  * calls this. It delegates to the core `partsToMessage` codec (the single
  * pi-ai-typed seam) rather than duplicating the per-block reconstruction in the
  * store; it is exposed here so consumers reconstruct via one named function
@@ -96,8 +96,8 @@ export declare const cursorRowMapper: import("./row-mapper.js").RowMapper<{
     ingested_live_len: number;
 }>;
 /**
- * Parse the JSON `metadata` column with graceful degradation (T-127-10 /
- * ASVS V5): a corrupt/poisoned persisted block degrades `raw` to undefined and
+ * Parse the JSON `metadata` column with graceful degradation (ASVS V5):
+ * a corrupt/poisoned persisted block degrades `raw` to undefined and
  * NEVER throws — a malformed row can not crash reconstruction.
  */
 export declare function parseMetadata(raw: string): LcdPartMetadata;

package/node_modules/@comis/memory/dist/lcd-store-mappers.js

@@ -14,10 +14,10 @@ import { z } from "zod";
 import { createRowMapper } from "./row-mapper.js";
 import { LcdContextItemRowSchema, LcdMessageRowSchema, LcdMessagePartRowSchema, LcdSummaryRowSchema, } from "./row-schemas.js";
 /**
- * The named pi-ai reconstruction entry point for the LCD store (F2/F3).
+ * The named pi-ai reconstruction entry point for the LCD store.
  *
  * `getMessages` returns the faithful `LcdMessage` DTO rows; turning one back
- * into a canonical pi-ai `Message` is the consumer's step — Phase-128 assembly
+ * into a canonical pi-ai `Message` is the consumer's step — the assembly layer
  * calls this. It delegates to the core `partsToMessage` codec (the single
  * pi-ai-typed seam) rather than duplicating the per-block reconstruction in the
  * store; it is exposed here so consumers reconstruct via one named function
@@ -46,31 +46,31 @@ export const ctxOrdinalRowMapper = createRowMapper(CtxOrdinalRowSchema);
 const CtxCountRowSchema = z.strictObject({ c: z.number() });
 export const ctxCountRowMapper = createRowMapper(CtxCountRowSchema);
 /**
- * `MAX(ordinal)` projection for the per-append dense-view maintenance (CRIT-2).
+ * `MAX(ordinal)` projection for the per-append dense-view maintenance.
  * `MAX` over zero rows returns SQL NULL → `maxOrdinal` is nullable; the next
  * ordinal is `(maxOrdinal ?? -1) + 1` (0 for the first row). No `as` cast.
  */
 const CtxMaxOrdinalRowSchema = z.strictObject({ maxOrdinal: z.number().nullable() });
 export const ctxMaxOrdinalRowMapper = createRowMapper(CtxMaxOrdinalRowSchema);
-/** Single-column message-id projection for the E1 leaf→message walk (no `as` cast). */
+/** Single-column message-id projection for the leaf→message walk (no `as` cast). */
 const SummaryMessageIdRowSchema = z.strictObject({ message_id: z.string() });
 export const summaryMessageIdRowMapper = createRowMapper(SummaryMessageIdRowSchema);
 /**
- * Single-column rowid projection for the contentless-FTS populate (WR-03 — the
+ * Single-column rowid projection for the contentless-FTS populate (the
  * sanctioned `createRowMapper(z.strictObject)` read replacing the raw
  * `as { rowid: number } | undefined` cast the §6.8 untyped-sqlite rule forbids).
  */
 const MessageRowidRowSchema = z.strictObject({ rowid: z.number() });
 export const messageRowidRowMapper = createRowMapper(MessageRowidRowSchema);
 /**
- * Phase 164 (RR1): cursor row schema — two projected columns only
+ * Cursor row schema — two projected columns only
  * (`epoch_anchor` + `ingested_live_len`). Uses `z.strictObject` (drift
  * detection) and `createRowMapper` (degrade-to-undefined, never throws) —
  * the same pattern as every other row mapper in this module.
  */
 const CursorRowSchema = z.strictObject({ epoch_anchor: z.string(), ingested_live_len: z.number() });
 export const cursorRowMapper = createRowMapper(CursorRowSchema);
-/** The verbatim canonical block is opaque at the row layer (F1). */
+/** The verbatim canonical block is opaque at the row layer. */
 const LcdPartMetadataSchema = z.looseObject({
     raw: z.unknown(),
     rawType: z.string().optional(),
@@ -79,8 +79,8 @@ const LcdPartMetadataSchema = z.looseObject({
     envelopeCarrier: z.boolean().optional(),
 });
 /**
- * Parse the JSON `metadata` column with graceful degradation (T-127-10 /
- * ASVS V5): a corrupt/poisoned persisted block degrades `raw` to undefined and
+ * Parse the JSON `metadata` column with graceful degradation (ASVS V5):
+ * a corrupt/poisoned persisted block degrades `raw` to undefined and
  * NEVER throws — a malformed row can not crash reconstruction.
  */
 export function parseMetadata(raw) {

package/node_modules/@comis/memory/dist/lcd-store-provenance-read.d.ts

@@ -1,6 +1,5 @@
 /**
- * LCD→LTM distillation provenance READ surface (Phase 173, DIST-03 read side —
- * the C1→C2 carry-in activation). The read-mirror of the write-side
+ * LCD→LTM distillation provenance READ surface. The read-mirror of the write-side
  * `lcd-store-provenance.ts` (buildProvenanceWrites).
  *
  * `buildProvenanceReadStore(db)` is the concrete {@link LcdProvenanceReadStore}
@@ -8,16 +7,16 @@
  * provenance down-weighting pass (packages/agent/src/rag/recall-provenance.ts)
  * can resolve the EXACT provenance-linked memoryIds a distilled summary subsumes.
  * Built as its OWN factory (NOT a method on ContextStorePort / createLcdStore) so
- * the recall pipeline's import surface stays narrow — per the port doc at
- * context-store.ts:254-258. It is threaded as a separate `provenanceStore`.
+ * the recall pipeline's import surface stays narrow — per the port doc in
+ * context-store.ts. It is threaded as a separate `provenanceStore`.
  *
- * R4 (WR-01) is the load-bearing security property: the SELECT carries
+ * Tenant + agent isolation is the load-bearing security property: the SELECT carries
  * `WHERE summary_id = ? AND tenant_id = ? AND agent_id = ?` (mirror the write
  * side's INSERT/UPDATE scope columns). A summary_id collision under a different
  * (tenant, agent) scope is a fail-closed no-op — a cross-scope read returns ZERO
  * rows, so another scope's provenance can never leak into the recall pass.
  *
- * Static SQL, bound params, no interpolated identifiers (T-127-09). Reads go
+ * Static SQL, bound params, no interpolated identifiers. Reads go
  * through `createRowMapper` (no `as Foo[]` cast — untyped-sqlite.test.ts). The
  * store NEVER logs summary/memory content (@comis/memory is infra-free per
  * AGENTS.md §2.4 — no logger import).
@@ -27,7 +26,7 @@
 import type Database from "better-sqlite3";
 import type { LcdProvenanceReadStore } from "@comis/core";
 /**
- * Prepare the R4-scoped `lcd_memory_provenance` read statement once and return
+ * Prepare the scoped `lcd_memory_provenance` read statement once and return
  * the concrete {@link LcdProvenanceReadStore}. Called once at the composition
  * root (setup-memory.ts) on the SAME db handle as createLcdStore, so the
  * prepare-once discipline holds.

package/node_modules/@comis/memory/dist/lcd-store-provenance-read.js

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * LCD→LTM distillation provenance READ surface (Phase 173, DIST-03 read side —
- * the C1→C2 carry-in activation). The read-mirror of the write-side
+ * LCD→LTM distillation provenance READ surface. The read-mirror of the write-side
  * `lcd-store-provenance.ts` (buildProvenanceWrites).
  *
  * `buildProvenanceReadStore(db)` is the concrete {@link LcdProvenanceReadStore}
@@ -9,16 +8,16 @@
  * provenance down-weighting pass (packages/agent/src/rag/recall-provenance.ts)
  * can resolve the EXACT provenance-linked memoryIds a distilled summary subsumes.
  * Built as its OWN factory (NOT a method on ContextStorePort / createLcdStore) so
- * the recall pipeline's import surface stays narrow — per the port doc at
- * context-store.ts:254-258. It is threaded as a separate `provenanceStore`.
+ * the recall pipeline's import surface stays narrow — per the port doc in
+ * context-store.ts. It is threaded as a separate `provenanceStore`.
  *
- * R4 (WR-01) is the load-bearing security property: the SELECT carries
+ * Tenant + agent isolation is the load-bearing security property: the SELECT carries
  * `WHERE summary_id = ? AND tenant_id = ? AND agent_id = ?` (mirror the write
  * side's INSERT/UPDATE scope columns). A summary_id collision under a different
  * (tenant, agent) scope is a fail-closed no-op — a cross-scope read returns ZERO
  * rows, so another scope's provenance can never leak into the recall pass.
  *
- * Static SQL, bound params, no interpolated identifiers (T-127-09). Reads go
+ * Static SQL, bound params, no interpolated identifiers. Reads go
  * through `createRowMapper` (no `as Foo[]` cast — untyped-sqlite.test.ts). The
  * store NEVER logs summary/memory content (@comis/memory is infra-free per
  * AGENTS.md §2.4 — no logger import).
@@ -44,13 +43,13 @@ const LcdProvenanceReadRowSchema = z.strictObject({
 // Row mapper — the sanctioned read path (no `as Foo[]`).
 const provenanceReadRowMapper = createRowMapper(LcdProvenanceReadRowSchema);
 /**
- * Prepare the R4-scoped `lcd_memory_provenance` read statement once and return
+ * Prepare the scoped `lcd_memory_provenance` read statement once and return
  * the concrete {@link LcdProvenanceReadStore}. Called once at the composition
  * root (setup-memory.ts) on the SAME db handle as createLcdStore, so the
  * prepare-once discipline holds.
  */
 export function buildProvenanceReadStore(db) {
-    // R4 (WR-01): tenant_id + agent_id are load-bearing — a summary_id collision
+    // tenant_id + agent_id are load-bearing — a summary_id collision
     // under a different scope is a fail-closed no-op (mirrors the write-side
     // INSERT/UPDATE scope columns + every other LCD SQL).
     const selectBySummary = db.prepare("SELECT provenance_id, memory_id, source_session_key, superseded_by" +

package/node_modules/@comis/memory/dist/lcd-store-provenance.d.ts

@@ -1,5 +1,5 @@
 /**
- * LCD→LTM distillation provenance write surface (Phase 172, DIST-01/DIST-03).
+ * LCD→LTM distillation provenance write surface.
  * Extracted from `lcd-store.ts` so the adapter stays under the 800-line
  * file-size cap (mirrors the `lcd-store-writes.ts` / `lcd-store-reads.ts`
  * extractions).
@@ -8,21 +8,21 @@
  * statements ONCE (preserving the "prepare once at createLcdStore" discipline —
  * they are prepared at store construction and returned as bound closures) and
  * returns the two synchronous ContextStorePort methods the distillation runner
- * (172-02) calls via optional chaining:
+ * calls via optional chaining:
  *
  *   - `appendProvenance(input)` — INSERT one row linking a distilled episodic
  *     memory (memoryId) to the LCD condensed summary (summaryId) it came from.
- *     R4 scope columns come straight from the DTO; the store never reads the
+ *     The scope columns come straight from the DTO; the store never reads the
  *     clock (createdAt is caller-supplied). The row FKs into `memories(id)`
  *     ON DELETE CASCADE — deleting the memory drops the provenance row.
  *   - `markProvenanceSuperseded(summaryId, supersededByMemoryId, tenantId,
  *     agentId)` — the pyramid rule: set `superseded_by` on a descendant
  *     summary's row, ONLY when not already set (`superseded_by IS NULL`), so the
- *     FIRST subsumer wins and a re-run is a harmless no-op. R4-scoped on
- *     tenant_id + agent_id (WR-01): a cross-scope summary_id collision is a
+ *     FIRST subsumer wins and a re-run is a harmless no-op. Scoped on
+ *     tenant_id + agent_id: a cross-scope summary_id collision is a
  *     fail-closed no-op.
  *
- * Static SQL, bound params, no interpolated identifiers (T-127-09). The store
+ * Static SQL, bound params, no interpolated identifiers. The store
  * NEVER logs summary/memory content (lossless store; @comis/memory is infra-free
  * per AGENTS.md §2.4).
  *

package/node_modules/@comis/memory/dist/lcd-store-provenance.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * LCD→LTM distillation provenance write surface (Phase 172, DIST-01/DIST-03).
+ * LCD→LTM distillation provenance write surface.
  * Extracted from `lcd-store.ts` so the adapter stays under the 800-line
  * file-size cap (mirrors the `lcd-store-writes.ts` / `lcd-store-reads.ts`
  * extractions).
@@ -9,21 +9,21 @@
  * statements ONCE (preserving the "prepare once at createLcdStore" discipline —
  * they are prepared at store construction and returned as bound closures) and
  * returns the two synchronous ContextStorePort methods the distillation runner
- * (172-02) calls via optional chaining:
+ * calls via optional chaining:
  *
  *   - `appendProvenance(input)` — INSERT one row linking a distilled episodic
  *     memory (memoryId) to the LCD condensed summary (summaryId) it came from.
- *     R4 scope columns come straight from the DTO; the store never reads the
+ *     The scope columns come straight from the DTO; the store never reads the
  *     clock (createdAt is caller-supplied). The row FKs into `memories(id)`
  *     ON DELETE CASCADE — deleting the memory drops the provenance row.
  *   - `markProvenanceSuperseded(summaryId, supersededByMemoryId, tenantId,
  *     agentId)` — the pyramid rule: set `superseded_by` on a descendant
  *     summary's row, ONLY when not already set (`superseded_by IS NULL`), so the
- *     FIRST subsumer wins and a re-run is a harmless no-op. R4-scoped on
- *     tenant_id + agent_id (WR-01): a cross-scope summary_id collision is a
+ *     FIRST subsumer wins and a re-run is a harmless no-op. Scoped on
+ *     tenant_id + agent_id: a cross-scope summary_id collision is a
  *     fail-closed no-op.
  *
- * Static SQL, bound params, no interpolated identifiers (T-127-09). The store
+ * Static SQL, bound params, no interpolated identifiers. The store
  * NEVER logs summary/memory content (lossless store; @comis/memory is infra-free
  * per AGENTS.md §2.4).
  *
@@ -44,7 +44,7 @@ export function buildProvenanceWrites(db) {
         " VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
     // First-subsumer-wins: only set the pointer when not already set, so re-runs
     // are no-ops and a later (different) subsumer never overwrites the first.
-    // R4 (WR-01): tenant_id + agent_id are load-bearing — the UPDATE runs on a
+    // tenant_id + agent_id are load-bearing — the UPDATE runs on a
     // multi-tenant table, so a summary_id collision under a different scope is a
     // fail-closed no-op (mirrors the INSERT's scope columns + every other LCD SQL).
     const updateProvenanceSuperseded = db.prepare("UPDATE lcd_memory_provenance SET superseded_by = ?" +

package/node_modules/@comis/memory/dist/lcd-store-reads.d.ts

@@ -1,17 +1,17 @@
 /**
- * EFF-01 bounded read helpers extracted from `lcd-store.ts` to keep the store
+ * Bounded read helpers extracted from `lcd-store.ts` to keep the store
  * factory under the 800-line architecture line cap (mirrors the prior
- * `lcd-store-writes.ts` + `lcd-fts.ts` extractions; Pitfall 6).
+ * `lcd-store-writes.ts` + `lcd-fts.ts` extractions).
  *
  * Three responsibilities, BYTE-IDENTICAL relocations of the methods that used
  * to live inside the `createLcdStore` return object (no SQL/column/ordering/
  * error-handling change):
  *   1. `getMessagesByIds(scope, ids)` — bounded message fetch via variable-length
- *      IN(), scoped by (conversation_id, agent_id, tenant_id) (R4/WR-02).
+ *      IN(), scoped by (conversation_id, agent_id, tenant_id).
  *   2. `getSummariesByIds(scope, ids)` — bounded summary fetch via variable-length
  *      IN(), same scope discipline.
  *   3. `countMessages(scope)` — single-integer COUNT(*) over lcd_messages with no
- *      row materialization, preserving the O(referenced-ids) read budget (EFF-01).
+ *      row materialization, preserving the O(referenced-ids) read budget.
  *
  * The factory `createBoundedReads(db, selectParts)` takes:
  *   - `db`           — the live database handle (for on-demand IN() prepares +
@@ -21,14 +21,14 @@
  *                      at `createLcdStore` top (preserves the prepare-once rule).
  *
  * `@comis/memory` is infra-free (AGENTS.md §2.4 — no logger): a degraded row
- * is skipped silently (WR-02), exactly as the originals did.
+ * is skipped silently, exactly as the originals did.
  *
  * @module
  */
 import type Database from "better-sqlite3";
 import type { ContextStoreScope, LcdMessage, LcdSummary } from "@comis/core";
 /**
- * The three EFF-01 bounded-read methods returned by the factory.
+ * The three bounded-read methods returned by the factory.
  * Signatures are byte-identical to the `ContextStorePort` declarations.
  */
 export interface BoundedReads {
@@ -37,7 +37,7 @@ export interface BoundedReads {
     countMessages(scope: ContextStoreScope): number;
 }
 /**
- * Build the three EFF-01 bounded-read helpers. Call once at `createLcdStore`
+ * Build the three bounded-read helpers. Call once at `createLcdStore`
  * top and spread the returned object into the port literal.
  *
  * @param db          — the live better-sqlite3 Database handle.

package/node_modules/@comis/memory/dist/lcd-store-reads.js

@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * EFF-01 bounded read helpers extracted from `lcd-store.ts` to keep the store
+ * Bounded read helpers extracted from `lcd-store.ts` to keep the store
  * factory under the 800-line architecture line cap (mirrors the prior
- * `lcd-store-writes.ts` + `lcd-fts.ts` extractions; Pitfall 6).
+ * `lcd-store-writes.ts` + `lcd-fts.ts` extractions).
  *
  * Three responsibilities, BYTE-IDENTICAL relocations of the methods that used
  * to live inside the `createLcdStore` return object (no SQL/column/ordering/
  * error-handling change):
  *   1. `getMessagesByIds(scope, ids)` — bounded message fetch via variable-length
- *      IN(), scoped by (conversation_id, agent_id, tenant_id) (R4/WR-02).
+ *      IN(), scoped by (conversation_id, agent_id, tenant_id).
  *   2. `getSummariesByIds(scope, ids)` — bounded summary fetch via variable-length
  *      IN(), same scope discipline.
  *   3. `countMessages(scope)` — single-integer COUNT(*) over lcd_messages with no
- *      row materialization, preserving the O(referenced-ids) read budget (EFF-01).
+ *      row materialization, preserving the O(referenced-ids) read budget.
  *
  * The factory `createBoundedReads(db, selectParts)` takes:
  *   - `db`           — the live database handle (for on-demand IN() prepares +
@@ -22,13 +22,13 @@
  *                      at `createLcdStore` top (preserves the prepare-once rule).
  *
  * `@comis/memory` is infra-free (AGENTS.md §2.4 — no logger): a degraded row
- * is skipped silently (WR-02), exactly as the originals did.
+ * is skipped silently, exactly as the originals did.
  *
  * @module
  */
 import { messageRowMapper, partRowMapper, summaryRowMapper, ctxCountRowMapper, parseJsonColumn, parseMetadata, intToBool, parseFileIds, } from "./lcd-store-mappers.js";
 /**
- * Build the three EFF-01 bounded-read helpers. Call once at `createLcdStore`
+ * Build the three bounded-read helpers. Call once at `createLcdStore`
  * top and spread the returned object into the port literal.
  *
  * @param db          — the live better-sqlite3 Database handle.
@@ -37,15 +37,15 @@ import { messageRowMapper, partRowMapper, summaryRowMapper, ctxCountRowMapper, p
  *                      prepare-once discipline).
  */
 export function createBoundedReads(db, selectParts) {
-    // EFF-01: bounded total-message COUNT for the assembler's `persistedMsgCount` —
+    // Bounded total-message COUNT for the assembler's `persistedMsgCount` —
     // a single integer, NO row materialization, so it keeps the O(referenced-ids)
-    // read budget (never an O(total-history) row fetch). R4: scoped by agent_id +
-    // tenant_id (WR-02). The count read goes through ctxCountRowMapper, not a raw
+    // read budget (never an O(total-history) row fetch). Scoped by agent_id +
+    // tenant_id. The count read goes through ctxCountRowMapper, not a raw
     // count cast (§6.8 untyped-sqlite) — same { c } shape as countCtxItems.
     const countMsgs = db.prepare("SELECT COUNT(*) AS c FROM lcd_messages WHERE conversation_id = ? AND agent_id = ? AND tenant_id = ?");
     return {
         getMessagesByIds(scope, ids) {
-            // EFF-01: bounded fetch — short-circuit immediately on empty set so zero
+            // Bounded fetch — short-circuit immediately on empty set so zero
             // DB queries are issued (the IN() SQL with zero placeholders is also an
             // error in most SQLite builds, making the guard doubly necessary).
             if (ids.length === 0)
@@ -54,11 +54,11 @@ export function createBoundedReads(db, selectParts) {
             // Documented deviation from the prepare-once rule: the working set is
             // bounded by context_items cardinality (max ~100 items per turn), so the
             // extra statement-prepare cost is negligible and avoids a placeholder-count
-            // mismatch at the boundary. T-170-01-01: ids are always bound as '?'
+            // mismatch at the boundary. Ids are always bound as '?'
             // parameters — never string-interpolated — so SQL injection is structurally
-            // impossible. T-170-01-02: the three-column R4 scope triple
+            // impossible. The three-column scope triple
             // (conversation_id, agent_id, tenant_id) is always present so a cross-agent
-            // id lookup returns [] (EFF-01-S-4).
+            // id lookup returns [].
             const placeholders = ids.map(() => "?").join(",");
             const stmt = db.prepare(`SELECT * FROM lcd_messages
          WHERE conversation_id = ? AND agent_id = ? AND tenant_id = ?
@@ -99,7 +99,7 @@ export function createBoundedReads(db, selectParts) {
             return out;
         },
         countMessages(scope) {
-            // EFF-01: single-integer COUNT — no row materialization, so it preserves the
+            // Single-integer COUNT — no row materialization, so it preserves the
             // O(referenced-ids) read budget (the assembler's persistedMsgCount no longer
             // forces an O(total-history) getMessages fetch). Routed through
             // ctxCountRowMapper, not a raw count cast (§6.8 untyped-sqlite). A scope with
@@ -109,7 +109,7 @@ export function createBoundedReads(db, selectParts) {
             return countRow.ok && countRow.value ? countRow.value.c : 0;
         },
         getSummariesByIds(scope, ids) {
-            // EFF-01: bounded fetch — short-circuit on empty set (zero DB queries).
+            // Bounded fetch — short-circuit on empty set (zero DB queries).
             if (ids.length === 0)
                 return [];
             const placeholders = ids.map(() => "?").join(",");