comisai 1.0.45 → 1.0.46

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

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
  * SqliteOutcomeStore: the SOLE adapter for the segregated `OutcomeSignalPort`
- * (@comis/core, v2.26 Verified Learning WS1). It owns ALL the `outcome_events`
+ * (@comis/core). It owns ALL the `outcome_events`
  * SQL — the idempotent `observe()` write (one raw observation per signal source),
  * the scoped `resolve()` read+fusion (precedence-first then confidence,
  * fail-closed `unknown`), and the age-based `prune()`.
  *
- * ## Idempotency (OUTCOME-01 / T-198-09)
+ * ## Idempotency
  *
  * `observe()` derives the row `id` as a deterministic sha256 hash of the UNIQUE
  * tuple `(tenant_id, agent_id, trajectory_id, source, observed_at)` in CODE
@@ -15,7 +15,7 @@
  * upsert the same primary key even if the row was deleted, and the `UNIQUE`
  * backstop catches it regardless.
  *
- * ## Isolation is the load-bearing security boundary (SEC-01 / T-198-05)
+ * ## Isolation is the load-bearing security boundary
  *
  * Comis runs many agents in one DB. EVERY statement (both `observe` and
  * `resolve`) filters on `(tenant_id, agent_id)` — parameterized — and the table
@@ -23,7 +23,7 @@
  * visible to a read under another even when `trajectory_id` is byte-identical. An
  * UNRESOLVED `(tenant, agent)` scope (empty id) on `resolve()` fails-closed with
  * `err(...)` — it NEVER widens to a shared/global pool (the hindsight
- * `get_current_schema()` leak vector, design §9).
+ * `get_current_schema()` leak vector).
  *
  * ## Untrusted input
  *
@@ -43,9 +43,11 @@ import { createRowMapper } from "./row-mapper.js";
 import { OutcomeEventRowSchema } from "./outcome-event-row-schema.js";
 // Row mapper — the sanctioned read path (no `as Foo[]`).
 const outcomeRowMapper = createRowMapper(OutcomeEventRowSchema);
-// Row mapper for listTrajectoryIds — the two projected columns only (sanctioned
-// typed read; no `as Foo[]` cast, per untyped-sqlite.test.ts).
-const trajectoryIdRowMapper = createRowMapper(z.object({ t: z.string(), s: z.string() }));
+// Row mapper for listTrajectoryIds — the projected columns (sanctioned typed read;
+// no `as Foo[]` cast, per untyped-sqlite.test.ts). `d` is the per-turn
+// procedure_descriptor read back (the content-free JSON tool-NAME array; NULL when no
+// procedure ran — SQLite NULL ≠ undefined → `.nullable()`).
+const trajectoryIdRowMapper = createRowMapper(z.object({ t: z.string(), s: z.string(), d: z.string().nullable() }));
 // Lenient JSON-string[] parser for the recalled_ids/used_skill_ids columns:
 // corrupt/non-array JSON degrades to [] (never a throw that breaks resolve()).
 const StringArraySchema = z.array(z.string());
@@ -62,7 +64,7 @@ function parseIdList(raw) {
     }
 }
 /**
- * Source-tier precedence for `resolve()` fusion (OUTCOME-05): LOWER rank = HIGHER
+ * Source-tier precedence for `resolve()` fusion: LOWER rank = HIGHER
  * precedence. The deterministic `tool`/`pipeline` signals outrank everything —
  * a high-confidence reaction NEVER beats a tool result. `judge` sits below the
  * deterministic tier; `correction`/`explicit` are grouped with the `reaction`
@@ -84,7 +86,7 @@ function tierRank(source) {
     return SOURCE_TIER_RANK.get(source) ?? 3;
 }
 /**
- * Outcome-severity ordering for the same-tier EQUAL-confidence tie-break (WR-01):
+ * Outcome-severity ordering for the same-tier EQUAL-confidence tie-break:
  * HIGHER value wins a tie. A `failure` (then a `corrected` soft-failure) beats a
  * `success`/`unknown` of equal confidence within the SAME tier — the conservative
  * verdict, so a real tool/node failure is NEVER silently masked by an
@@ -133,47 +135,65 @@ export function createSqliteOutcomeStore(deps) {
     const { db, logger } = deps;
     // --- Prepared statements (parameterized; reused across calls) ---
     // Insert keyed on the (tenant_id, agent_id, trajectory_id, source, observed_at) UNIQUE
-    // tuple. On conflict, MERGE the two attribution columns rather than drop the row:
-    // `recalled_ids` (memory:recall_used) and `used_skill_ids` (memory:skill_used) are written
-    // as SEPARATE source:"explicit" carriers at post-execution, so when their `observed_at`
-    // lands in the SAME millisecond they collide on this tuple — a plain DO NOTHING then
-    // SILENTLY dropped whichever lost the race, intermittently losing one credit on any turn
-    // that BOTH recalled memory AND reused a skill (the ~1/3 reuse-credit miss). COALESCE keeps
-    // each column's first non-null value, so the two carriers MERGE onto one row instead of one
-    // dropping. A genuine replay (identical tuple, same columns) COALESCEs to the same values —
-    // still a no-op; a tool/pipeline collision (both id-columns null) is a no-op on these SETs and
-    // never touches outcome/confidence, so fusion is byte-identical. All columns are bound `?`.
-    const insertStmt = db.prepare("INSERT INTO outcome_events (id, tenant_id, agent_id, session_id, trajectory_id, outcome, source, confidence, sender_trust, recalled_ids, used_skill_ids, observed_at) " +
-        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
+    // tuple. On conflict, MERGE the attribution columns rather than drop the row:
+    // `recalled_ids` (memory:recall_used), `used_skill_ids` (memory:skill_used), and
+    // `procedure_descriptor` (orchestrate:run_summary) are written as SEPARATE
+    // source:"explicit" carriers at post-execution, so when their `observed_at` lands in the
+    // SAME millisecond they collide on this tuple — a plain DO NOTHING then SILENTLY dropped
+    // whichever lost the race, intermittently losing one credit on any turn that BOTH recalled
+    // memory AND reused a skill (the ~1/3 reuse-credit miss). COALESCE keeps each column's
+    // first non-null value, so the carriers MERGE onto one row instead of one dropping. A
+    // genuine replay (identical tuple, same columns) COALESCEs to the same values — still a
+    // no-op; a tool/pipeline collision (all id-columns null) is a no-op on these SETs and never
+    // touches outcome/confidence, so fusion is byte-identical. All columns are bound `?`.
+    // AGGREGATE EDGE (procedure_descriptor): COALESCE only MERGES carriers that COLLIDE on the
+    // UNIQUE tuple (a same-millisecond observed_at). Two orchestrate runs in ONE turn land as two
+    // DISTINCT rows — same trajectory_id but different observed_at — so ON CONFLICT never fires and
+    // COALESCE never merges them; the per-turn descriptor is instead resolved at READ time by the
+    // listStmt's MAX(procedure_descriptor) (see there). A set-union across a turn's runs is a
+    // deliberate non-goal for this advisory, single-run-common case.
+    const insertStmt = db.prepare("INSERT INTO outcome_events (id, tenant_id, agent_id, session_id, trajectory_id, outcome, source, confidence, sender_trust, recalled_ids, used_skill_ids, procedure_descriptor, observed_at) " +
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) " +
         "ON CONFLICT(tenant_id, agent_id, trajectory_id, source, observed_at) DO UPDATE SET " +
         "recalled_ids = COALESCE(excluded.recalled_ids, recalled_ids), " +
-        "used_skill_ids = COALESCE(excluded.used_skill_ids, used_skill_ids)");
+        "used_skill_ids = COALESCE(excluded.used_skill_ids, used_skill_ids), " +
+        "procedure_descriptor = COALESCE(excluded.procedure_descriptor, procedure_descriptor)");
     // Scoped read for resolve(): the `tenant_id = ? AND agent_id = ?` filter is the
-    // load-bearing isolation boundary (SEC-01); every value is a bound `?` param.
-    // `ORDER BY observed_at ASC, id ASC` makes the multi-row scan STABLE across runs
-    // (WR-01): without it an unindexed scan can return same-tier rows in any order, so
+    // load-bearing isolation boundary; every value is a bound `?` param.
+    // `ORDER BY observed_at ASC, id ASC` makes the multi-row scan STABLE across runs:
+    // without it an unindexed scan can return same-tier rows in any order, so
     // an equal-confidence tie-break that keyed on `rows[0]` flipped run-to-run.
-    const readStmt = db.prepare("SELECT id, session_id, trajectory_id, outcome, source, confidence, sender_trust, recalled_ids, used_skill_ids, observed_at " +
+    const readStmt = db.prepare("SELECT id, session_id, trajectory_id, outcome, source, confidence, sender_trust, recalled_ids, used_skill_ids, procedure_descriptor, observed_at " +
         "FROM outcome_events WHERE tenant_id = ? AND agent_id = ? AND trajectory_id = ? " +
         "ORDER BY observed_at ASC, id ASC");
     // Age-based prune: DELETE every row older than the cutoff, wrapped in a
-    // transaction (mirror observability-reset.ts:54-67). Implemented in Task 3.
+    // transaction (mirror observability-reset.ts:54-67).
     const pruneStmt = db.prepare("DELETE FROM outcome_events WHERE observed_at < ?");
     const pruneTx = db.transaction((cutoff) => pruneStmt.run(cutoff).changes);
-    // Per-turn enumeration for the WS2 synthesis source: the DISTINCT
+    // Per-turn enumeration for the synthesis source: the DISTINCT
     // (trajectory_id, session_id) pairs for the scope, most-recent-first, bounded
     // (anti-DoS, mirrors the review source's DEFAULT_MAX_CONVERSATIONS cap). GROUP BY
     // collapses one turn's multiple source rows to a single pair; MAX(observed_at)
     // is the recency key. These are the SAME per-turn `traceId`s `resolve()` keys on
     // — the synthesis source emits THESE so resolve() actually finds rows.
-    const listStmt = db.prepare("SELECT trajectory_id AS t, session_id AS s, MAX(observed_at) AS ts FROM outcome_events " +
+    // MAX(procedure_descriptor) surfaces the turn's content-free descriptor carrier
+    // across its multiple source rows (the carrier is one `source:"explicit"` row; the
+    // tool/pipeline siblings are NULL, which MAX ignores) — the read-back the reflection
+    // source attaches onto its per-turn ReflectionSourceTrajectory. NULL when no procedure ran.
+    // For a turn with MULTIPLE orchestrate runs (each run writes its OWN carrier row under the same
+    // trajectory_id), MAX returns the lexicographically-LARGEST descriptor JSON — a deterministic
+    // but ARBITRARY pick among the turn's runs (NOT first- or last-run). Faithful multi-run-per-turn
+    // attribution is a non-goal for this advisory, single-run-common case.
+    const listStmt = db.prepare("SELECT trajectory_id AS t, session_id AS s, MAX(observed_at) AS ts, MAX(procedure_descriptor) AS d FROM outcome_events " +
         "WHERE tenant_id = ? AND agent_id = ? GROUP BY trajectory_id, session_id ORDER BY ts DESC LIMIT ?");
     return {
         async observe(obs) {
             const startMs = systemNowMs();
             try {
                 const id = outcomeRowId(obs);
-                insertStmt.run(id, obs.tenantId, obs.agentId, obs.sessionId, obs.trajectoryId, obs.outcome, obs.source, obs.confidence, obs.senderTrust ?? null, obs.recalledIds && obs.recalledIds.length > 0 ? JSON.stringify(obs.recalledIds) : null, obs.usedSkillIds && obs.usedSkillIds.length > 0 ? JSON.stringify(obs.usedSkillIds) : null, obs.observedAt);
+                insertStmt.run(id, obs.tenantId, obs.agentId, obs.sessionId, obs.trajectoryId, obs.outcome, obs.source, obs.confidence, obs.senderTrust ?? null, obs.recalledIds && obs.recalledIds.length > 0 ? JSON.stringify(obs.recalledIds) : null, obs.usedSkillIds && obs.usedSkillIds.length > 0 ? JSON.stringify(obs.usedSkillIds) : null, obs.procedureDescriptor && obs.procedureDescriptor.length > 0
+                    ? JSON.stringify(obs.procedureDescriptor)
+                    : null, obs.observedAt);
                 const durationMs = systemNowMs() - startMs;
                 logger?.debug({
                     step: "outcome-observe",
@@ -200,7 +220,7 @@ export function createSqliteOutcomeStore(deps) {
             const startMs = systemNowMs();
             const { tenantId, agentId } = scope;
             // Fail-closed on an unresolved (tenant, agent) scope — NEVER widen to a
-            // shared/global pool (SEC-01 / T-198-05, the get_current_schema() leak
+            // shared/global pool (the get_current_schema() leak
             // vector). An empty id is a precondition violation, surfaced as err().
             if (tenantId === "" || agentId === "") {
                 logger?.warn({
@@ -216,25 +236,23 @@ export function createSqliteOutcomeStore(deps) {
                     return err(new Error(parsed.error.message));
                 const rows = parsed.value;
                 // Fail-closed unknown: a finished trajectory with no resolvable signal
-                // fuses to `unknown` and derives NO learning (OUTCOME-05); the coverage
-                // metric (Plan 04) must NOT count this as resolved.
+                // fuses to `unknown` and derives NO learning; the coverage
+                // metric must NOT count this as resolved.
                 if (rows.length === 0) {
                     logger?.debug({ step: "outcome-resolve", resolved: false, durationMs: systemNowMs() - startMs }, "Outcome resolve — no signal (fail-closed unknown)");
                     return ok({ outcome: "unknown", confidence: 0, sources: [], recalledIds: [], usedSkillIds: [] });
                 }
-                // Precedence-first, then confidence, then RECENCY (OUTCOME-05 / WR-01 /
-                // live-2026-06-18 fix): pick the highest-precedence tier present, then the
-                // MAX-confidence row WITHIN that tier, and on a same-tier EQUAL-confidence TIE
-                // prefer the MOST RECENT observation (the turn's TERMINAL state). So a transient
-                // tool failure the turn RECOVERED from (failure → later success) resolves to
-                // `success`, not `failure`. Pre-fix this was severity-wins (`failure` always beat
-                // an equal-confidence `success`), which mis-resolved EVERY self-corrected turn to
-                // failure → excluded it from skill synthesis AND penalized the memories/skills
-                // that produced the correct answer (live VPS: ~half of successful turns, because
-                // Comis's own tool-policy guards manufacture transient failures). On an EXACT
-                // observed_at tie (genuinely simultaneous signals — e.g. concurrent DAG-node
-                // siblings) severity STILL wins, so a real concurrent failure is never masked. A
-                // high-confidence reaction still never overrides a deterministic tool result.
+                // Precedence-first, then confidence, then RECENCY: pick the highest-precedence
+                // tier present, then the MAX-confidence row WITHIN that tier, and on a same-tier
+                // EQUAL-confidence TIE prefer the MOST RECENT observation (the turn's TERMINAL
+                // state). So a transient tool failure the turn RECOVERED from (failure → later
+                // success) resolves to `success`, not `failure` — resolving a self-corrected turn
+                // to failure would wrongly exclude it from skill synthesis AND penalize the
+                // memories/skills that produced the correct answer (Comis's own tool-policy guards
+                // routinely manufacture transient failures). On an EXACT observed_at tie (genuinely
+                // simultaneous signals — e.g. concurrent DAG-node siblings) severity STILL wins, so
+                // a real concurrent failure is never masked. A high-confidence reaction still never
+                // overrides a deterministic tool result.
                 let winner = rows[0];
                 for (const row of rows) {
                     const rt = tierRank(row.source);
@@ -255,7 +273,7 @@ export function createSqliteOutcomeStore(deps) {
                 // Attribution: union+dedup recalledIds AND usedSkillIds across ALL rows (any
                 // source may carry either). The used_skill_ids column is written at observe()
                 // (:199) when the daemon threads a memory:skill_used attribution into the call
-                // (setup-learning.ts, Plan 07) — the loop is no longer write-only. The two loops
+                // (setup-learning.ts) — the loop is no longer write-only. The two loops
                 // are byte-mirrors (same parseIdList graceful-degrade over the JSON TEXT column).
                 const recalledSet = new Set();
                 for (const row of rows)
@@ -293,15 +311,15 @@ export function createSqliteOutcomeStore(deps) {
                 return err(error);
             }
         },
-        // prune() — implemented in Task 3 (age-based housekeeping). Wired here so the
-        // port type is total; the proven cutoff math + transaction land in Task 3.
+        // prune() — age-based housekeeping. Deletes every row older than the cutoff in
+        // one transaction.
         prune(retentionDays) {
             const cutoff = systemNowMs() - retentionDays * 86400000;
             return { changes: pruneTx(cutoff) };
         },
         // READ. The per-turn trajectory identities the ledger holds for this scope —
-        // see the port doc + the live-2026-06-18 synthesis-source fix. Fail-closed on
-        // an unresolved scope exactly like resolve() (never a shared/global pool).
+        // see the port doc. Fail-closed on an unresolved scope exactly like resolve()
+        // (never a shared/global pool).
         async listTrajectoryIds(scope) {
             const { tenantId, agentId } = scope;
             if (tenantId === "" || agentId === "") {
@@ -311,7 +329,17 @@ export function createSqliteOutcomeStore(deps) {
                 const parsed = trajectoryIdRowMapper.parseRows(listStmt.all(tenantId, agentId, MAX_LISTED_TRAJECTORIES));
                 if (!parsed.ok)
                     return err(new Error(parsed.error.message));
-                return ok(parsed.value.map((r) => ({ trajectoryId: r.t, sessionId: r.s })));
+                return ok(parsed.value.map((r) => {
+                    // Read the content-free procedure descriptor back per turn. `parseIdList` reuses the
+                    // recalled/used-skill graceful-degrade posture ([] on NULL or corrupt JSON, never a
+                    // throw); an empty list maps to ABSENT so the field is OMITTED when no procedure ran.
+                    const descriptor = parseIdList(r.d);
+                    return {
+                        trajectoryId: r.t,
+                        sessionId: r.s,
+                        ...(descriptor.length > 0 ? { procedureDescriptor: descriptor } : {}),
+                    };
+                }));
             }
             catch (e) {
                 const error = e instanceof Error ? e : new Error(String(e));

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

@@ -13,7 +13,7 @@
  *   current REGARDLESS of recency; equal trust tiebreaks by recency (newer
  *   `t_occurred`|`t_ingested` wins); the LOSER is SOFT-CLOSED (`t_valid_end` +
  *   `expired_at` set), NEVER deleted. Same object is idempotent corroboration (no
- *   new history row). Non-overlapping occurred intervals coexist (Graphiti's
+ *   new history row). Non-overlapping occurred intervals coexist (the
  *   interval-overlap guard).
  * - `asOf(t, scope, mode)` is the bi-temporal as-of read:
  *   `"valid"` (default) queries the VALID-time window (`t_valid_start <= t AND
@@ -24,7 +24,7 @@
  *   appears in one but not the other at a chosen `t`. Both scoped.
  * - `currentTruth(scope, cap)` is the DEFAULT-RECALL read:
  *   only `t_valid_end IS NULL` rows — superseded losers and recorded-but-not-
- *   believed rows are DEFAULT-FILTERED out (the Graphiti opt-in-leak fix). As-of
+ *   believed rows are DEFAULT-FILTERED out (the stale-fact leak fix). As-of
  *   history is reachable only via an explicit `asOf(t)`. Scoped, capped.
  * - `spreadLane(seedSubjects, scope, maxDepth, fanOut, cap)` is the read-side
  *   graph-spread lane: a bounded `WITH RECURSIVE walk`
@@ -43,7 +43,7 @@
  * memories(id)` `ON DELETE CASCADE` fire (deleting a source memory drops its
  * derived triples; no orphan-sweep job).
  *
- * ## Isolation is the load-bearing security boundary (the §5.2 pattern)
+ * ## Isolation is the load-bearing security boundary
  *
  * Comis runs many agents in one DB. BOTH the write (the INSERT) and the read
  * (`asOf`, and the `spreadLane` CTE) filter on `(tenant_id, agent_id)` —

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

@@ -15,7 +15,7 @@
  *   current REGARDLESS of recency; equal trust tiebreaks by recency (newer
  *   `t_occurred`|`t_ingested` wins); the LOSER is SOFT-CLOSED (`t_valid_end` +
  *   `expired_at` set), NEVER deleted. Same object is idempotent corroboration (no
- *   new history row). Non-overlapping occurred intervals coexist (Graphiti's
+ *   new history row). Non-overlapping occurred intervals coexist (the
  *   interval-overlap guard).
  * - `asOf(t, scope, mode)` is the bi-temporal as-of read:
  *   `"valid"` (default) queries the VALID-time window (`t_valid_start <= t AND
@@ -26,7 +26,7 @@
  *   appears in one but not the other at a chosen `t`. Both scoped.
  * - `currentTruth(scope, cap)` is the DEFAULT-RECALL read:
  *   only `t_valid_end IS NULL` rows — superseded losers and recorded-but-not-
- *   believed rows are DEFAULT-FILTERED out (the Graphiti opt-in-leak fix). As-of
+ *   believed rows are DEFAULT-FILTERED out (the stale-fact leak fix). As-of
  *   history is reachable only via an explicit `asOf(t)`. Scoped, capped.
  * - `spreadLane(seedSubjects, scope, maxDepth, fanOut, cap)` is the read-side
  *   graph-spread lane: a bounded `WITH RECURSIVE walk`
@@ -45,7 +45,7 @@
  * memories(id)` `ON DELETE CASCADE` fire (deleting a source memory drops its
  * derived triples; no orphan-sweep job).
  *
- * ## Isolation is the load-bearing security boundary (the §5.2 pattern)
+ * ## Isolation is the load-bearing security boundary
  *
  * Comis runs many agents in one DB. BOTH the write (the INSERT) and the read
  * (`asOf`, and the `spreadLane` CTE) filter on `(tenant_id, agent_id)` —
@@ -104,7 +104,7 @@ const DEFAULT_CURRENT_TRUTH_CAP = 256;
 /**
  * Two occurred windows OVERLAP iff each starts on/before the other ends
  * (half-open-friendly inclusive test). Only meaningful when BOTH rows carry a
- * full `[t_occurred .. t_occurred_end]` range — Graphiti's interval-overlap
+ * full `[t_occurred .. t_occurred_end]` range — the interval-overlap
  * guard: a contradiction is only real when the windows overlap; disjoint windows
  * are two facts true at DIFFERENT times (both stay current, neither closes).
  */
@@ -182,7 +182,7 @@ export function createSqliteTripleStore(deps) {
     const asOfTxnSelect = db.prepare("SELECT * FROM memory_triples " +
         "WHERE tenant_id = ? AND agent_id = ? " +
         "AND t_ingested <= ? AND (expired_at IS NULL OR expired_at > ?)");
-    // Default-recall current-truth read (the Graphiti opt-in-leak fix).
+    // Default-recall current-truth read (the stale-fact leak fix).
     // ONLY `t_valid_end IS NULL` rows are believed NOW: superseded losers (soft-
     // closed) and recorded-but-not-believed rows (inserted already-closed by the
     // invalidation write path) are DEFAULT-FILTERED out. Newest-valid first, capped.
@@ -195,7 +195,7 @@ export function createSqliteTripleStore(deps) {
     // triple whose `object` is the node AND that carries a source_memory_id, then
     // join `memories` re-asserting the FULL (tenant, agent) scope (self-sufficient
     // hydrate — no fail-open if the CTE is ever refactored). Bound params only.
-    // FORGET-01 (CR-01): the ALWAYS-ON `evicted_at IS NULL` recall exclusion (`m.` alias —
+    // The ALWAYS-ON `evicted_at IS NULL` recall exclusion (`m.` alias —
     // `memories` is joined as `m`). This is the RECALL-side hydration (graph-spread →
     // MemorySearchResult[] → createMemoryRecall → the prompt), so a soft-evicted reached-node
     // source memory MUST be omitted here. The bi-temporal asOf reads (asOfSelect /
@@ -257,7 +257,7 @@ export function createSqliteTripleStore(deps) {
                         return "corroborated";
                     }
                     // 2c. Different object = a candidate contradiction.
-                    // Interval-overlap guard (Graphiti): when BOTH rows carry a FULL
+                    // Interval-overlap guard: when BOTH rows carry a FULL
                     // occurred range, it is a contradiction ONLY if the windows overlap.
                     // Disjoint windows = two facts true at different times → the new row
                     // ALSO becomes current-truth (neither closes).
@@ -361,7 +361,7 @@ export function createSqliteTripleStore(deps) {
             try {
                 // The DEFAULT-RECALL read: only `t_valid_end IS NULL` rows (believed
                 // NOW) — superseded losers + recorded-but-not-believed rows are
-                // default-filtered out (the Graphiti opt-in-leak fix). Scoped + capped;
+                // default-filtered out (the stale-fact leak fix). Scoped + capped;
                 // both the (tenant, agent) filter and the cap are bound `?` params.
                 const rows = currentTruthSelect.all(tenantId, agentId, cap);
                 const parsed = tripleRowMapper.parseRows(rows);

package/node_modules/@comis/memory/dist/types.d.ts

@@ -72,18 +72,18 @@ export interface SessionRow {
     metadata: string;
 }
 /**
- * Raw row shape for the `lcd_messages` table (LCD lossless store, Phase 127, F1).
+ * Raw row shape for the `lcd_messages` table (LCD lossless store).
  *
  * Snake_case DB-row shape — NOT the public API (consumers use the `LcdMessage`
- * DTO from `@comis/core`, reconstructed via the parts-codec). Carries the R4
+ * DTO from `@comis/core`, reconstructed via the parts-codec). Carries the
  * tenant/agent/session isolation columns (`conversation_id` is the composite,
- * the three broken-out columns let Phase 132 filter on the SAME schema without
- * a migration — threat T-127-06). Paired 1:1 with `LcdMessageRowSchema` in
+ * the three broken-out columns let a scoped read filter on the SAME schema without
+ * a migration). Paired 1:1 with `LcdMessageRowSchema` in
  * `./row-schemas.js` via the `row-schemas.test.ts` drift guard.
  */
 export interface LcdMessageRow {
     id: string;
-    /** tenant+agent+session composite scope key (R4; enforced Phase 132). */
+    /** tenant+agent+session composite scope key. */
     conversation_id: string;
     tenant_id: string;
     agent_id: string;
@@ -98,11 +98,11 @@ export interface LcdMessageRow {
     created_at: number;
 }
 /**
- * Raw row shape for the `lcd_message_parts` table (LCD lossless store, Phase 127, F1).
+ * Raw row shape for the `lcd_message_parts` table (LCD lossless store).
  *
  * One row per structured block. The typed tool columns are the queryable
- * projection; the verbatim canonical pi-ai block (plus the F3 reasoning marker
- * and the F2 message envelope) always lives JSON-encoded in `metadata`. Paired
+ * projection; the verbatim canonical pi-ai block (plus the reasoning marker
+ * and the message envelope) always lives JSON-encoded in `metadata`. Paired
  * 1:1 with `LcdMessagePartRowSchema` in `./row-schemas.js` via the drift guard.
  */
 export interface LcdMessagePartRow {
@@ -156,26 +156,26 @@ export interface NamedGraphRow {
     deleted_at: number | null;
 }
 /**
- * Raw row shape for the `lcd_summaries` table (LCD compaction store, Phase 129, C3).
+ * Raw row shape for the `lcd_summaries` table (LCD compaction store).
  *
  * Snake_case DB-row shape — NOT the public API (consumers use the `LcdSummary`
- * DTO from `@comis/core`). One row per depth-0 LEAF summary; carries the R4
- * tenant/agent/session isolation columns so Phase 132 filters on the SAME
- * schema with no migration (threat T-129-04). `taint`/`fallback` are the SQLite
+ * DTO from `@comis/core`). One row per depth-0 LEAF summary; carries the
+ * tenant/agent/session isolation columns so a scoped read filters on the SAME
+ * schema with no migration. `taint`/`fallback` are the SQLite
  * bool 0/1 integers; `file_ids` is JSON-encoded TEXT. Paired 1:1 with
  * `LcdSummaryRowSchema` in `./row-schemas.js` via the `row-schemas.test.ts`
  * drift guard.
  */
 export interface LcdSummaryRow {
     summary_id: string;
-    /** tenant+agent+session composite scope key (R4; enforced Phase 132). */
+    /** tenant+agent+session composite scope key. */
     conversation_id: string;
     tenant_id: string;
     agent_id: string;
     session_key: string;
-    /** Closed union TEXT: `leaf` (depth-0) for 129. */
+    /** Closed union TEXT: `leaf` (depth-0). */
     kind: string;
-    /** 0 for 129 (leaf); depth>0 is Phase 130. */
+    /** 0 for a leaf; depth>0 is the condensed tier. */
     depth: number;
     /** Min `created_at` of the covered messages. */
     earliest_at: number;
@@ -189,7 +189,7 @@ export interface LcdSummaryRow {
     content: string;
     /** JSON-encoded string[] of covered file references. */
     file_ids: string;
-    /** 0/1 untrusted-content flag (enforcement is Phase 132). */
+    /** 0/1 untrusted-content flag. */
     taint: number;
     /** 0/1 deterministic Level-3-truncation marker. */
     fallback: number;
@@ -197,12 +197,11 @@ export interface LcdSummaryRow {
     created_at: number;
 }
 /**
- * Raw row shape for the `lcd_summary_messages` table (LCD compaction store,
- * Phase 129, C3).
+ * Raw row shape for the `lcd_summary_messages` table (LCD compaction store).
  *
  * The leaf→message link — one row per (summary, covered message). The
  * `message_id` FK is `ON DELETE RESTRICT` so a summarized `lcd_messages` row can
- * never be deleted (losslessness; Pitfall 5). Paired 1:1 with
+ * never be deleted (losslessness). Paired 1:1 with
  * `LcdSummaryMessageRowSchema` via the drift guard.
  */
 export interface LcdSummaryMessageRow {
@@ -210,8 +209,7 @@ export interface LcdSummaryMessageRow {
     message_id: string;
 }
 /**
- * Raw row shape for the `lcd_summary_parents` table (LCD condensed tier,
- * Phase 130, C2).
+ * Raw row shape for the `lcd_summary_parents` table (LCD condensed tier).
  *
  * The condensed→child summary edge — one row per (condensed parent summary,
  * child summary it links). Mirrors `LcdSummaryMessageRow` but BOTH endpoints
@@ -225,10 +223,9 @@ export interface LcdSummaryParentRow {
     child_summary_id: string;
 }
 /**
- * Raw row shape for the `lcd_context_items` table (LCD compaction store,
- * Phase 129, C3).
+ * Raw row shape for the `lcd_context_items` table (LCD compaction store).
  *
- * One row per item of the ordered model-facing view; carries the R4 scoping
+ * One row per item of the ordered model-facing view; carries the scoping
  * columns. `ordinal` is dense + gap-free per conversation (a UNIQUE
  * `(conversation_id, ordinal)` index enforces it); `ref_kind` is the closed
  * `message`|`summary` discriminator; `ref_id` points at the referenced
@@ -237,7 +234,7 @@ export interface LcdSummaryParentRow {
  */
 export interface LcdContextItemRow {
     id: string;
-    /** tenant+agent+session composite scope key (R4; enforced Phase 132). */
+    /** tenant+agent+session composite scope key. */
     conversation_id: string;
     tenant_id: string;
     agent_id: string;

package/node_modules/@comis/memory/dist/video-job-row-schema.d.ts

@@ -1,6 +1,6 @@
 /**
- * Zod row schema for the `video_jobs` table — the durable async VideoJobStore
- * (Phase 189, JOB-01). SSOT for the file-internal `VideoJobDbRow` interface in
+ * Zod row schema for the `video_jobs` table — the durable async VideoJobStore.
+ * SSOT for the file-internal `VideoJobDbRow` interface in
  * `video-job-store.ts`.
  *
  * Lives in its OWN module (NOT `row-schemas.ts`) because that file is at the
@@ -12,7 +12,7 @@
  *     store's `rowToRecord` maps `?? undefined` at the domain boundary.
  *   - INTEGER timestamps → `z.number()`; REAL cost/progress → `z.number().nullable()`.
  *
- * SECURITY (T-189-02): the column set is the opaque provider jobId + routing +
+ * SECURITY: the column set is the opaque provider jobId + routing +
  * state + cost + path ONLY — NO key/token/secret/bearer column. The provider
  * credential is held by the boot-bound adapter and is NEVER persisted here.
  *
@@ -45,7 +45,7 @@ export declare const VideoJobDbRowSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type VideoJobDbRow = z.infer<typeof VideoJobDbRowSchema>;
 /**
- * Single-column projection for the CR-01 `incrementDeliveryAttempt` read-back —
+ * Single-column projection for the `incrementDeliveryAttempt` read-back —
  * the bumped `deliver_attempts` value re-read in the same synchronous turn as the
  * atomic UPDATE. A dedicated schema (vs. the full-row `VideoJobDbRowSchema`) so
  * the SELECT can project ONE column and still go through `createRowMapper`

package/node_modules/@comis/memory/dist/video-job-row-schema.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Zod row schema for the `video_jobs` table — the durable async VideoJobStore
- * (Phase 189, JOB-01). SSOT for the file-internal `VideoJobDbRow` interface in
+ * Zod row schema for the `video_jobs` table — the durable async VideoJobStore.
+ * SSOT for the file-internal `VideoJobDbRow` interface in
  * `video-job-store.ts`.
  *
  * Lives in its OWN module (NOT `row-schemas.ts`) because that file is at the
@@ -13,7 +13,7 @@
  *     store's `rowToRecord` maps `?? undefined` at the domain boundary.
  *   - INTEGER timestamps → `z.number()`; REAL cost/progress → `z.number().nullable()`.
  *
- * SECURITY (T-189-02): the column set is the opaque provider jobId + routing +
+ * SECURITY: the column set is the opaque provider jobId + routing +
  * state + cost + path ONLY — NO key/token/secret/bearer column. The provider
  * credential is held by the boot-bound adapter and is NEVER persisted here.
  *
@@ -33,8 +33,8 @@ export const VideoJobDbRowSchema = z.strictObject({
     channel_type: z.string().nullable(),
     channel_id: z.string().nullable(),
     trace_id: z.string().nullable(),
-    // OBS-04 (Phase 192): the off-turn recorder fold key. Nullable — old rows
-    // (pre-192, or in-flight at upgrade time) are NULL → offline-only
+    // The off-turn recorder fold key. Nullable — old rows
+    // (in-flight at upgrade time) are NULL → offline-only
     // reconstruction. The strictObject above REJECTS a column the DDL adds without
     // this line, so the schema + the ensureVideoJobTable DDL move in lockstep.
     session_key: z.string().nullable(),
@@ -45,9 +45,9 @@ export const VideoJobDbRowSchema = z.strictObject({
     actual_cost_usd: z.number().nullable(),
     media_path: z.string().nullable(),
     progress: z.number().nullable(),
-    // The markFailed errorKind; the Plan-03 status handler surfaces it as `error`.
+    // The markFailed errorKind; the status handler surfaces it as `error`.
     last_error: z.string().nullable(),
-    // CR-01: persisted redelivery counter. NOT NULL DEFAULT 0 in the DDL, so it is
+    // Persisted redelivery counter. NOT NULL DEFAULT 0 in the DDL, so it is
     // always a number (never null) — the poller bounds the redelivery loop against
     // it and dead-letters the row to `failed` once it exceeds maxDeliveryAttempts.
     deliver_attempts: z.number(),
@@ -55,7 +55,7 @@ export const VideoJobDbRowSchema = z.strictObject({
     updated_at_ms: z.number(),
 });
 /**
- * Single-column projection for the CR-01 `incrementDeliveryAttempt` read-back —
+ * Single-column projection for the `incrementDeliveryAttempt` read-back —
  * the bumped `deliver_attempts` value re-read in the same synchronous turn as the
  * atomic UPDATE. A dedicated schema (vs. the full-row `VideoJobDbRowSchema`) so
  * the SELECT can project ONE column and still go through `createRowMapper`