comisai 1.0.44 → 1.0.46

package/node_modules/@comis/agent/dist/provider/tool-schema/normalize.js

@@ -35,12 +35,12 @@ export function setToolNormalizationLogger(l) {
     logger = l;
 }
 /**
- * Once-per-boot-per-provider INFO latch (GBNF-03). A boot-time SNAPSHOT
+ * Once-per-boot-per-provider INFO latch. A boot-time SNAPSHOT
  * summary, not a recurring event: the daemon process IS the boot, so a
  * module-level latch gives once-per-boot semantics with zero new wiring
  * (the logger is latched at boot via setToolNormalizationLogger, wired in
- * setup-agents-registry.ts). Counts + names only — never schema bodies
- * (I7). Per-turn detail stays at trace.
+ * setup-agents-registry.ts). Counts + names only — never schema bodies.
+ * Per-turn detail stays at trace.
  */
 const gbnfSummaryLoggedForProvider = new Set();
 /**
@@ -114,10 +114,10 @@ export function normalizeToolSchemasForProvider(tools, ctx) {
     const isGemini = caps.providerFamily === "google";
     const isXai = ctx.compat?.toolSchemaProfile === "xai";
     // GBNF gate derives SOLELY from the explicit compat profile — never from
-    // the provider name or baseUrl (D-08). The gbnfConstrain authoring gate
+    // the provider name or baseUrl. The gbnfConstrain authoring gate
     // arrives SEPARATELY in ctx.gbnfConstrain (threaded from
-    // config.orchestration.authoring.gbnfConstrain at the executor call site,
-    // CR-01); this pipeline only honors what arrives in ctx.
+    // config.orchestration.authoring.gbnfConstrain at the executor call
+    // site); this pipeline only honors what arrives in ctx.
     const isGbnf = ctx.compat?.toolSchemaProfile === "gbnf";
     const providerLower = ctx.provider.toLowerCase();
     // Determine keyword stripping: exact match first, then Gemini family fallback
@@ -128,12 +128,12 @@ export function normalizeToolSchemasForProvider(tools, ctx) {
     const keywordStripProvider = exactSet
         ? providerLower
         : (isGemini ? "google" : providerLower);
-    // AUTHOR-03 (174-05): the gbnfConstrain authoring gate. GBNF-eligible providers
+    // The gbnfConstrain authoring gate. GBNF-eligible providers
     // are the local/default family — EXACTLY the set the early-return below treats
     // as "no cleaning needed" (no keyword set, not gemini, not xai). When the
     // operator flips `config.orchestration.authoring.gbnfConstrain` on, Layer 3.5
     // engages for these providers to harden the raw pipeline escape hatch even
-    // when they are not pinned to the explicit gbnf profile. Gated D-08-strict:
+    // when they are not pinned to the explicit gbnf profile. Strictly gated:
     // gbnfEligible EXCLUDES cloud families (anthropic/google/xai), so the flag
     // never infers GBNF from a cloud provider name. `applyGbnf` (NOT `isGbnf`)
     // drives every Layer 3.5 site below.
@@ -159,9 +159,9 @@ export function normalizeToolSchemasForProvider(tools, ctx) {
             const result = stripProviderKeywords(schema, keywordStripProvider);
             schema = result.schema;
             if (result.strippedKeywords.length > 0) {
-                // Fix B (log-review): demoted debug → trace. Fires per tool per
-                // request — dominated debug-mode logs at one-per-tool-per-turn
-                // cadence (~30 lines/turn on agents with 30+ tools registered).
+                // Trace, not debug: this fires per tool per request and would
+                // dominate debug-mode logs at one-per-tool-per-turn cadence
+                // (~30 lines/turn on agents with 30+ tools registered).
                 // The stripped-keyword set is deterministic per (provider, tool)
                 // pair; if an operator needs the detail, trace recovers it.
                 logger?.trace({
@@ -179,11 +179,11 @@ export function normalizeToolSchemasForProvider(tools, ctx) {
             schema = stripXaiUnsupportedKeywords(schema);
         // Layer 3.5: GBNF structural transforms for llama.cpp-family local
         // providers (removal/relaxation only — pattern/format deliberately
-        // survive; reactive stripping on grammar-400 lives in the executor,
-        // GBNF-02). `applyGbnf` = the gbnf profile OR the gbnfConstrain authoring
-        // gate on a gbnf-eligible provider (174-05); FLAGS-OFF ⇒ === isGbnf.
+        // survive; reactive stripping on grammar-400 lives in the executor).
+        // `applyGbnf` = the gbnf profile OR the gbnfConstrain authoring
+        // gate on a gbnf-eligible provider; FLAGS-OFF ⇒ === isGbnf.
         if (applyGbnf) {
-            // CR-01 (175-REVIEW): force the Layer-4 top-level object contract
+            // Force the Layer-4 top-level object contract
             // BEFORE the gbnf transforms. T4 (missing-type injection) fires on
             // typeless nodes and infers "string" for a bare/description-only TOP
             // LEVEL (`parameters: {}` — a real no-arg-tool shape from sloppy MCP
@@ -195,9 +195,9 @@ export function normalizeToolSchemasForProvider(tools, ctx) {
             const gbnfResult = cleanSchemaForGbnf(schema);
             schema = gbnfResult.schema;
             if (gbnfResult.depthLimited) {
-                // WR-03 fail-safe surfaced: subtrees beyond the walk's depth cap
-                // passed through un-transformed (never a crash). Content-free per
-                // I7 — tool name + cap only, no schema bodies.
+                // Fail-safe surfaced: subtrees beyond the walk's depth cap
+                // passed through un-transformed (never a crash). Content-free —
+                // tool name + cap only, no schema bodies.
                 logger?.warn({
                     toolName: tool.name,
                     provider: ctx.provider,
@@ -225,9 +225,9 @@ export function normalizeToolSchemasForProvider(tools, ctx) {
         schema = ensureTopLevelObjectSingle(schema);
         return { ...tool, parameters: schema };
     });
-    // Once-per-boot INFO summary (GBNF-03): the FIRST transforming call per
+    // Once-per-boot INFO summary: the FIRST transforming call per
     // provider emits one content-free summary line (counts + names + the
-    // closed transform vocabulary, never schema bodies — I7); subsequent
+    // closed transform vocabulary, never schema bodies); subsequent
     // calls stay at the per-tool trace above.
     if (applyGbnf &&
         gbnfTransformedTools.length > 0 &&

package/node_modules/@comis/agent/dist/rag/cosine.d.ts

@@ -1,12 +1,7 @@
 /**
  * Cosine similarity — a pure, no-NaN vector-proximity util on the recall HOT PATH
- * (`rag/mmr.ts` → `rag/memory-recall.ts`).
- *
- * Relocated here in v2.31 Phase 225 (FOLD/D-04): it formerly lived in
- * `memory-consolidation-clustering.ts` and was the sole survivor of that file
- * once the standalone consolidation/reasoning jobs were deleted. Keeping it as a
- * `rag/`-local pure util removes the cross-file dependency the deleted jobs no
- * longer justify, while preserving the byte-identical behaviour `mmr.ts` relies on.
+ * (`rag/mmr.ts` → `rag/memory-recall.ts`). Kept as a `rag/`-local pure util so
+ * the hot path carries no cross-file dependency.
  *
  * @module
  */

package/node_modules/@comis/agent/dist/rag/cosine.js

@@ -1,13 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
  * Cosine similarity — a pure, no-NaN vector-proximity util on the recall HOT PATH
- * (`rag/mmr.ts` → `rag/memory-recall.ts`).
- *
- * Relocated here in v2.31 Phase 225 (FOLD/D-04): it formerly lived in
- * `memory-consolidation-clustering.ts` and was the sole survivor of that file
- * once the standalone consolidation/reasoning jobs were deleted. Keeping it as a
- * `rag/`-local pure util removes the cross-file dependency the deleted jobs no
- * longer justify, while preserving the byte-identical behaviour `mmr.ts` relies on.
+ * (`rag/mmr.ts` → `rag/memory-recall.ts`). Kept as a `rag/`-local pure util so
+ * the hot path carries no cross-file dependency.
  *
  * @module
  */

package/node_modules/@comis/agent/dist/rag/hybrid-memory-injector.d.ts

@@ -12,7 +12,7 @@ import type { MemorySearchResult, WrapExternalContentOptions } from "@comis/core
 /**
  * Remove the leading inline-recall block from a user message's text. The single
  * source of truth for carving this TRANSIENT cross-session recall back out before
- * it is persisted into the LCD F1 lossless store — the store must keep the actual
+ * it is persisted into the LCD lossless store — the store must keep the actual
  * conversation, not the per-turn rendered prompt's recalled memory (which would
  * bloat the store, cross-contaminate the session, and feed back into later
  * recall). A no-op when no block is present.
@@ -21,10 +21,11 @@ export declare function stripInlineRecalledMemory(text: string): string;
 /**
  * Split a user message's text into its leading inline-recall block and the rest.
  * Returns `{ recall: null, rest: text }` when no block is present. Used by the
- * request-body layer (cache #C4) to move the TRANSIENT recall block onto the
+ * request-body caching layer to move the TRANSIENT recall block onto the
  * UNCACHED tail (a separate trailing content block, after the cache fence) so it
  * is visible to the model yet never cached — preventing the cached-prefix mutation
- * that occurs when C-FIX-3 strips the recall the turn after it goes historical.
+ * that occurs when the request-body layer strips the recall the turn after it
+ * goes historical.
  */
 export declare function extractInlineRecalledMemory(text: string): {
     recall: string | null;

package/node_modules/@comis/agent/dist/rag/hybrid-memory-injector.js

@@ -24,7 +24,7 @@ const INLINE_RECALL_BLOCK_RE = /^\s*\[Relevant context from memory: [\s\S]*? \(r
 /**
  * Remove the leading inline-recall block from a user message's text. The single
  * source of truth for carving this TRANSIENT cross-session recall back out before
- * it is persisted into the LCD F1 lossless store — the store must keep the actual
+ * it is persisted into the LCD lossless store — the store must keep the actual
  * conversation, not the per-turn rendered prompt's recalled memory (which would
  * bloat the store, cross-contaminate the session, and feed back into later
  * recall). A no-op when no block is present.
@@ -35,10 +35,11 @@ export function stripInlineRecalledMemory(text) {
 /**
  * Split a user message's text into its leading inline-recall block and the rest.
  * Returns `{ recall: null, rest: text }` when no block is present. Used by the
- * request-body layer (cache #C4) to move the TRANSIENT recall block onto the
+ * request-body caching layer to move the TRANSIENT recall block onto the
  * UNCACHED tail (a separate trailing content block, after the cache fence) so it
  * is visible to the model yet never cached — preventing the cached-prefix mutation
- * that occurs when C-FIX-3 strips the recall the turn after it goes historical.
+ * that occurs when the request-body layer strips the recall the turn after it
+ * goes historical.
  */
 export function extractInlineRecalledMemory(text) {
     const m = INLINE_RECALL_BLOCK_RE.exec(text);

package/node_modules/@comis/agent/dist/rag/memory-recall.js

@@ -38,7 +38,7 @@ import { captureRecallObservability } from "./recall-observability.js";
 import { applyProvenanceDownweighting } from "./recall-provenance.js";
 import { gateLanes, resolveEffectiveBaseFloor, logPrefilterDrops, passesBaseFloor } from "./recall-security-prefilter.js";
 import { vectorLaneCouldContribute, } from "./recall-record.js";
-// The R3 base-score floor predicate (FAIL-CLOSED, WR-02) lives in
+// The base-score floor predicate (FAIL-CLOSED) lives in
 // recall-security-prefilter.ts (the module that owns the security floor); re-exported here
 // so existing consumers (memory-recall-floor.test.ts) import it from ./memory-recall.js unchanged.
 export { passesBaseFloor } from "./recall-security-prefilter.js";
@@ -84,7 +84,7 @@ export function createMemoryRecall(deps, cfg) {
                 else if (!p.ok) {
                     deps.logger.warn({
                         agentId,
-                        // WR-03: durationMs required per AGENTS.md §2.7 on every WARN at a boundary crossing.
+                        // durationMs is required per AGENTS.md §2.7 on every WARN at a boundary crossing.
                         durationMs: deps.clock.now() - pinnedStart,
                         errorKind: "internal",
                         hint: "pinned lane read failed; proceeding without pinned memories",
@@ -109,11 +109,11 @@ export function createMemoryRecall(deps, cfg) {
             // The lane-reweight closure: OFF (intent === undefined) → returns `base` unchanged (byte-
             // identity); ON → base × intentMultiplier(intent, lane) (1.0 for any unboosted pair).
             const laneWeight = (base, lane) => intent !== undefined ? base * intentMultiplier(intent, lane) : base;
-            // RETR-04 (Phase 173): resolve the security-gate inputs ONCE so gateLanes() can
+            // Resolve the security-gate inputs ONCE so gateLanes() can
             //   pre-filter EVERY candidate supply (trust + arbiter-scoped baseFloor) BEFORE any fusion
             //   touches it, accumulating content-free dropped ids into prefilterAcc. effectiveBaseFloor:
-            //   explicit floor wins; else 0.15 when relevanceFirst; else 0 → frontier/mid byte-identical
-            //   (LOCKED #2). Why baseFloor must be pre-fusion: recall-security-prefilter.ts doc; §17 S6.
+            //   explicit floor wins; else 0.15 when relevanceFirst; else 0 → frontier/mid byte-identical.
+            //   Why baseFloor must be pre-fusion: see the recall-security-prefilter.ts module doc.
             const allowed = new Set(cfg.includeTrustLevels);
             const effectiveBaseFloor = resolveEffectiveBaseFloor(cfg.baseFloor, cfg.relevanceFirst);
             const prefilterAcc = { trustDroppedIds: [], floorDroppedIds: [] };
@@ -164,7 +164,7 @@ export function createMemoryRecall(deps, cfg) {
                 const vectorWeight = laneWeight(cfg.lanes?.vector.weight ?? 1.5, "vector");
                 ftsCandidates = laneRes.value.fts.length;
                 vectorCandidates = laneRes.value.vector.length;
-                // RETR-04 (Phase 173): gate the RAW fts/vector lanes BEFORE the within-recall fuse()
+                // Gate the RAW fts/vector lanes BEFORE the within-recall fuse()
                 //   below — the load-bearing placement (fuse() inflates a rank-1 sub-floor candidate's
                 //   score past any later floor; gating raw lanes uses the TRUE pre-fusion relevance).
                 //   Byte-identity preserved by gateLanes when floor 0 + all-allowed. See module doc.
@@ -212,7 +212,7 @@ export function createMemoryRecall(deps, cfg) {
                 // The split is NOT observable on this path (search() returns ONE merged list),
                 // so vectorCandidates stays its honest initial value — the recall layer cannot break
                 // out a true vector count here. The searchLanes path above sets the real count.
-                // RETR-04 (Phase 173): gate the single merged search lane (its `score` is the genuine
+                // Gate the single merged search lane (its `score` is the genuine
                 //   per-result relevance — search()->hybridSearch fused internally but returns one list
                 //   with no second inflation). Byte-identity preserved when floor 0 + all-allowed.
                 const gatedSearchLanes = gateLanes([{ results: searched.value, weight: 1.0 }], allowed, effectiveBaseFloor, prefilterAcc);
@@ -359,9 +359,9 @@ export function createMemoryRecall(deps, cfg) {
                 // Reweight the graph-spread lane (1.0 off; no boosted intent today → 1.0).
                 graphSpreadCandidates = await appendGraphSpreadLane(lanes, deps.tripleStore, laneWeight(gs.weight, "graphSpread"), cfg.maxResults, gs.maxDepth, gs.fanOut, seedSubjects, sessionKey, agentId, deps.logger);
             }
-            // RETR-04 (Phase 173): gate upstream of the FINAL fuse() — the appended entity/temporal/
+            // Gate upstream of the FINAL fuse() — the appended entity/temporal/
             //   causal/graph-spread (T4 KG) lanes against trust + baseFloor, so a high fused rank can
-            //   never resurrect a dropped KG candidate (design §17 S6). The base lane is already gated
+            //   never resurrect a dropped KG candidate. The base lane is already gated
             //   → re-gating it is a no-op. The downstream trust filter (Step 5) + baseFloor (Step 4b)
             //   are RETAINED as defense in depth. Full rationale: recall-security-prefilter.ts doc.
             const gatedLanes = gateLanes(lanes, allowed, effectiveBaseFloor, prefilterAcc);
@@ -493,8 +493,8 @@ export function createMemoryRecall(deps, cfg) {
                             agentId,
                             rerankCandidates: docs.length,
                             errorKind: "dependency",
-                            // §2.7: carry the underlying reranker cause so a real outage is
-                            // diagnosable. §2.2 (W11): MESSAGE at WARN — the full Error
+                            // AGENTS.md §2.7: carry the underlying reranker cause so a real outage is
+                            // diagnosable. AGENTS.md §2.2: MESSAGE at WARN — the full Error
                             // (with stack) rides the DEBUG line below, not this WARN.
                             err: scored.error.message,
                             hint,
@@ -539,22 +539,22 @@ export function createMemoryRecall(deps, cfg) {
                     breakdownById.set(r.entry.id, r.breakdown);
                 ranked = scored;
             }
-            // 4b. R3 BASE-SCORE FLOOR — drop memories whose pre-boost base score is below the
+            // 4b. BASE-SCORE FLOOR — drop memories whose pre-boost base score is below the
             //     effective floor. Runs AFTER scoreWithBreakdown() (breakdownById populated)
             //     so the filter accesses the EXACT breakdown.base — not the boosted r.score.
             //     Boosts (recency/temporal/proof/trust/usefulness) CANNOT resurrect a memory
-            //     whose raw cosine/RRF base sits below the floor (T-153-poison mitigation).
-            //     FAIL-CLOSED-ON-MISSING-BASE (WR-02): a memory with no recorded breakdown.base
+            //     whose raw cosine/RRF base sits below the floor (memory-poisoning mitigation).
+            //     FAIL-CLOSED-ON-MISSING-BASE: a memory with no recorded breakdown.base
             //     cannot be proven above the floor, so it is DROPPED (passesBaseFloor takes no
             //     r.score fallback — on the rerank path r.score is the CE probability, a higher
             //     scale that would let an inflated low-base poison survive). This is a security gate.
             //
-            //     RETR-04 / WR-02 ARBITER-SCOPED FAIL-CLOSED (Phase 173) — DEFENSE IN DEPTH: the
+            //     ARBITER-SCOPED FAIL-CLOSED — DEFENSE IN DEPTH: the
             //     baseFloor already ran UPSTREAM of fuse() against each candidate's genuine
-            //     pre-fusion relevance (the RETR-04 pre-filter), so for the fused list this gate is
+            //     pre-fusion relevance (the security pre-filter), so for the fused list this gate is
             //     normally a no-op. It is RETAINED unchanged as defense in depth (a future lane that
             //     bypasses the pre-filter is still floored here). Reuses the arbiter-scoped
-            //     `effectiveBaseFloor` resolved before fuse(); 0 → skipped (frontier/mid, LOCKED #2).
+            //     `effectiveBaseFloor` resolved before fuse(); 0 → skipped (frontier/mid).
             if (effectiveBaseFloor > 0) {
                 ranked = ranked.filter((r) => passesBaseFloor(breakdownById.get(r.entry.id), effectiveBaseFloor));
             }
@@ -602,7 +602,7 @@ export function createMemoryRecall(deps, cfg) {
                     }, "mmr embedding read fallback");
                 }
             }
-            // 5c. POST-FUSION PROVENANCE PASS (DIST-03). Optional, NON-FATAL, DEFAULT-OFF.
+            // 5c. POST-FUSION PROVENANCE PASS. Optional, NON-FATAL, DEFAULT-OFF.
             //     Runs AFTER mmrRerank (the rerank order has committed) and BEFORE dedup +
             //     observability capture. When a distilled summary (tag "lcd_distilled") is in
             //     the ranked set, down-weight same-conversation paired memories whose covered
@@ -614,7 +614,7 @@ export function createMemoryRecall(deps, cfg) {
             //     WARN — recall results are NEVER affected. TYPE-only provenanceStore port
             //     (the agent↛memory build cut).
             //
-            //     LIVE AS OF PHASE 173 (C2): provenanceStore is now injected at the
+            //     LIVE WIRING: provenanceStore is injected at the
             //     composition root (setup-memory builds the concrete LcdProvenanceReadStore
             //     and threads it daemon → setup-agents → pi-executor → prompt-assembly →
             //     here), and the distillation runner stamps the `summary:<id>` tag, so the
@@ -628,8 +628,8 @@ export function createMemoryRecall(deps, cfg) {
                         agentId: agentId ?? sessionKey.agentId ?? "default",
                         // conversationId/sessionKey are not load-bearing for the (tenant, agent)-scoped
                         // getProvenanceForSummary read, but the port takes a full scope — fill them from
-                        // the session key so the adapter's R4 filter has the complete context.
-                        // IN-02 fix: formatSessionKey (not String(sessionKey) → "[object Object]").
+                        // the session key so the adapter's scope filter has the complete context.
+                        // Must be formatSessionKey (not String(sessionKey) → "[object Object]").
                         conversationId: sessionKey.channelId ?? "",
                         sessionKey: formatSessionKey(sessionKey),
                     };
@@ -654,7 +654,7 @@ export function createMemoryRecall(deps, cfg) {
             // PREPEND pinned entries — bounded, already fetched at Step 0.
             // Pinned entries are ALWAYS returned first, regardless of fused score.
             // They were excluded from the MMR/dedup pipeline above (Step 5b-pre).
-            // CR-04: filter pinned entries through the trust allowlist BEFORE prepending.
+            // Filter pinned entries through the trust allowlist BEFORE prepending.
             // A pinned entry with a trustLevel outside cfg.includeTrustLevels must NOT inject.
             // DEFAULT-OFF: when pinnedResults is empty this is a no-op (no prepend).
             const filteredPinnedResults = pinnedResults.length > 0

package/node_modules/@comis/agent/dist/rag/mmr.js

@@ -1,4 +1,4 @@
-import { cosine } from "./cosine.js"; // reuse — pure, no-NaN (relocated rag-local util, v2.31 D-04)
+import { cosine } from "./cosine.js"; // reuse — pure, no-NaN rag-local util
 /**
  * Greedy Maximal Marginal Relevance (MMR) re-rank. Diversifies a relevance-ranked
  * candidate list by trading relevance against similarity-to-already-selected:

package/node_modules/@comis/agent/dist/rag/query-understanding.d.ts

@@ -40,7 +40,7 @@ export declare function classifyIntent(query: string): Intent;
  *   - `preference`  → up-weights the `entity` lane (preferences are entity-associative — the
  *                     person↔preference links the entity lane surfaces).
  *   - `enumeration` → NEUTRAL on every lane: enumeration's payoff is DIVERSITY, which is handled
- *                     by the MMR-λ knob, NOT a lane weight (documented design fork).
+ *                     by the MMR-λ knob, NOT a lane weight (a deliberate design fork).
  *   - `factual`     → NEUTRAL everywhere (the default-lookup byte-identity case).
  *
  * The switch over the closed {@link Intent} union carries an exhaustive `const _exhaustive: never`
@@ -49,8 +49,8 @@ export declare function classifyIntent(query: string): Intent;
  */
 export declare function intentMultiplier(intent: Intent, lane: ReweightLane): number;
 /**
- * Expand a query STRING via the bounded {@link SYNONYM_MAP} (whole-query expansion — the
- * locked fork). For each token, up to {@link SYNONYM_FANOUT_CAP} mapped expansion phrases are
+ * Expand a query STRING via the bounded {@link SYNONYM_MAP} (whole-query expansion, by
+ * design). For each token, up to {@link SYNONYM_FANOUT_CAP} mapped expansion phrases are
  * appended (so buildFtsQuery's OR-join surfaces both the original term and its synonyms), then the
  * whole token list is de-duplicated and re-joined with single spaces.
  *

package/node_modules/@comis/agent/dist/rag/query-understanding.js

@@ -100,7 +100,7 @@ const TARGETED_BOOST = 1.5;
  *   - `preference`  → up-weights the `entity` lane (preferences are entity-associative — the
  *                     person↔preference links the entity lane surfaces).
  *   - `enumeration` → NEUTRAL on every lane: enumeration's payoff is DIVERSITY, which is handled
- *                     by the MMR-λ knob, NOT a lane weight (documented design fork).
+ *                     by the MMR-λ knob, NOT a lane weight (a deliberate design fork).
  *   - `factual`     → NEUTRAL everywhere (the default-lookup byte-identity case).
  *
  * The switch over the closed {@link Intent} union carries an exhaustive `const _exhaustive: never`
@@ -131,7 +131,7 @@ export function intentMultiplier(intent, lane) {
 const SYNONYM_FANOUT_CAP = 3;
 /**
  * A SMALL, BOUNDED static synonym/acronym table (project/domain acronyms + a few common
- * synonyms) — NOT a generated thesaurus (the locked "bounded static map" decision). Keyed by a
+ * synonyms) — deliberately a bounded static map, NOT a generated thesaurus. Keyed by a
  * lowercase token; the value is the expansion phrase(s) appended to the query. Expansions are
  * plain tokens (no FTS5 special chars) so the OR-join in buildFtsQuery stays injection-safe.
  */
@@ -147,8 +147,8 @@ const SYNONYM_MAP = {
     ci: ["continuous integration"],
 };
 /**
- * Expand a query STRING via the bounded {@link SYNONYM_MAP} (whole-query expansion — the
- * locked fork). For each token, up to {@link SYNONYM_FANOUT_CAP} mapped expansion phrases are
+ * Expand a query STRING via the bounded {@link SYNONYM_MAP} (whole-query expansion, by
+ * design). For each token, up to {@link SYNONYM_FANOUT_CAP} mapped expansion phrases are
  * appended (so buildFtsQuery's OR-join surfaces both the original term and its synonyms), then the
  * whole token list is de-duplicated and re-joined with single spaces.
  *

package/node_modules/@comis/agent/dist/rag/recall-attribution.js

@@ -64,10 +64,10 @@ function isStopword(t) {
  * Lowercase, split on any run of non-(letter|number) codepoints, and keep
  * non-empty tokens. Unicode-aware: `\p{L}` matches Hebrew/Arabic/Cyrillic/CJK
  * letters (not just `a-z`), so a non-Latin memory and an overlapping non-Latin
- * response tokenize to real terms instead of collapsing to nothing (OBS-01
- * de-Anglicization — the prior ASCII-only character class stripped every
- * non-ASCII letter, forcing non-Latin attribution permanently to 0). Diacritic-Latin
- * tokens (`café`) now survive whole — intentional; the I1 byte-identity pin is
+ * response tokenize to real terms instead of collapsing to nothing (an
+ * ASCII-only character class would strip every non-ASCII letter, forcing
+ * non-Latin attribution permanently to 0). Diacritic-Latin
+ * tokens (`café`) survive whole — intentional; the byte-identity pin is
  * pure-ASCII, which this split leaves unchanged. Deterministic and
  * allocation-bounded by the input length; a single split on a fixed char-class
  * with the `u` flag — no nested quantifiers, no backtracking surface (no ReDoS).
@@ -86,7 +86,7 @@ function tokenize(text) {
  * <2 tokens or when every adjacent pair is stopword-only. The stopword test is
  * Latin-gated (`isStopword`) so a non-Latin bigram is never dropped as
  * "pure-stopword" — a two-word Hebrew/Arabic/Cyrillic phrase always yields a
- * bigram (OBS-01).
+ * bigram.
  */
 function significantBigrams(tokens) {
     const out = [];
@@ -121,7 +121,7 @@ export function attributeRecallUsage(recalled, response, opts) {
         const memTokens = tokenize(mem.content);
         // Significant unigrams: content words not in the stopword set. The stopword
         // filter is Latin-gated (isStopword) — a non-Latin token is always
-        // significant (OBS-01: never dropped by the English STOPWORDS set).
+        // significant (never dropped by the English STOPWORDS set).
         const memSignificant = memTokens.filter((t) => !isStopword(t));
         const memSignificantSet = new Set(memSignificant);
         // Bigrams preserve phrase structure but drop pure-stopword pairs (so a

package/node_modules/@comis/agent/dist/rag/recall-observability.js

@@ -59,8 +59,8 @@ export function captureRecallObservability(deps, cfg, ctx) {
         }));
     }
     catch (e) {
-        // PROMOTE-01 (§2.7 / invariant I4): a failing recall-trace recorder silently
-        // BLINDS the recall lens (RECALL-02 reads this trace). It is a failure branch
+        // A failing recall-trace recorder silently BLINDS the recall lens (the recall
+        // diagnostics read this trace). It is a failure branch
         // carrying hint+errorKind, so it belongs at WARN — diagnosable at the DEFAULT
         // level, not contingent on logLevel:debug having been set before the incident.
         deps.logger.warn({
@@ -83,7 +83,7 @@ export function captureRecallObservability(deps, cfg, ctx) {
         (ctx.entityCandidates > 0 ? 1 : 0) +
         // Include the temporal lane so the counts-only memory:recalled event no longer
         // under-reports the active lane count by one when the temporal lane contributes. The
-        // rich recall-trace record already counts lanes.temporal (:575); this aligns the event.
+        // rich recall-trace record already counts lanes.temporal; this aligns the event.
         (ctx.temporalCandidates > 0 ? 1 : 0) +
         // Likewise include the causal lane so the event's lane count counts the 5th
         // lane when it contributes (the rich trace record already counts lanes.causal).
@@ -121,9 +121,8 @@ export function captureRecallObservability(deps, cfg, ctx) {
         }
     }
     catch (e) {
-        // PROMOTE-01 (§2.7 / invariant I4): a failing memory:recalled/reranked emit blinds
-        // the trajectory + fleet recall signals (RECALL-01). Failure branch with hint+
-        // errorKind → WARN, visible at the default level.
+        // A failing memory:recalled/reranked emit blinds the trajectory + fleet recall
+        // signals. Failure branch with hint+errorKind → WARN, visible at the default level.
         deps.logger.warn({
             agentId: ctx.agentId,
             err: e instanceof Error ? e : new Error(String(e)),

package/node_modules/@comis/agent/dist/rag/recall-provenance.d.ts

@@ -1,5 +1,5 @@
 /**
- * applyProvenanceDownweighting — the DIST-03 post-fusion provenance down-weighting
+ * applyProvenanceDownweighting — the post-fusion provenance down-weighting
  * pass, extracted from memory-recall.ts (which crossed the 800-line cap when the
  * pass was added inline; mirrors the recall-causal-lane / recall-graph-spread-lane
  * extractions). PURE, synchronous, NON-DELETING helper.
@@ -8,7 +8,7 @@
  * (× {@link PROVENANCE_DOWNWEIGHT_FACTOR}) the same-conversation paired/source memories
  * the distilled summary subsumes — so the lossy summary does not double-count with its
  * own paired source rows in the recall budget. The memory is DEMOTED, never deleted:
- * it stays accessible, just ranked lower. CR-01 (Phase 173-05): the demotion RE-SORTS the
+ * it stays accessible, just ranked lower. The demotion RE-SORTS the
  * returned array by descending score (STABLE — index tiebreaker) so it is observable in
  * RANK, not merely in the `score` field — nothing downstream re-sorts (deduplicateResults
  * preserves order; the hybrid injector consumes the array in order), so without the re-sort
@@ -25,11 +25,11 @@
  * Architecture cut (agent↛memory): TYPE-only imports from @comis/core. This file NEVER
  * imports @comis/memory.
  *
- * LIVE AS OF PHASE 173 (C2): the caller's `provenanceStore` is now injected at the
- * composition root (setup-memory builds the concrete LcdProvenanceReadStore and threads it
- * to createMemoryRecall) and the distillation runner stamps the `summary:<id>` tag, so the
- * PROVENANCE-PRECISE branch is the primary selector. The helper itself is UNCHANGED — it
- * remains a byte-identical no-op when no lcd_distilled result is present.
+ * The caller's `provenanceStore` is injected at the composition root (setup-memory
+ * builds the concrete LcdProvenanceReadStore and threads it to createMemoryRecall) and
+ * the distillation runner stamps the `summary:<id>` tag, so the PROVENANCE-PRECISE
+ * branch is the primary selector. The helper remains a byte-identical no-op when no
+ * lcd_distilled result is present.
  *
  * @module
  */
@@ -45,7 +45,7 @@ export declare const SUMMARY_TAG_PREFIX = "summary:";
  */
 export declare const PROVENANCE_DOWNWEIGHT_FACTOR = 0.5;
 /**
- * POST-FUSION PROVENANCE DOWN-WEIGHTING (DIST-03, read-side).
+ * POST-FUSION PROVENANCE DOWN-WEIGHTING (read-side).
  *
  * Given the post-MMR ranked candidates, when one or more carries the `lcd_distilled`
  * tag, demote the same-conversation paired memories the distilled summary subsumes.
@@ -54,18 +54,18 @@ export declare const PROVENANCE_DOWNWEIGHT_FACTOR = 0.5;
  *  1. PROVENANCE-PRECISE (load-bearing `getProvenanceForSummary`): for any distilled
  *     summary that carries a `summary:<id>` tag, query the provenance read store for
  *     that summaryId and down-weight the returned `memoryId`s that appear in `ranked`.
- *     PRIMARY as of 173-04 (the distillation runner stamps the tag).
- *  2. SESSION HEURISTIC (FALLBACK ONLY — IN-03, Phase 173-05): down-weight every
+ *     PRIMARY selector (the distillation runner stamps the tag).
+ *  2. SESSION HEURISTIC (FALLBACK ONLY): down-weight every
  *     NON-distilled candidate sharing the distilled summary's `source.sessionKey`. This is
  *     over-broad (it cannot distinguish a legitimately-distinct same-session memory from a
  *     genuinely-subsumed one — neither MemorySource nor the provenance row carries the
  *     covered time range), so it is GATED behind the ABSENCE of a usable `summary:<id>` tag:
  *     when branch (1) can select precisely it OWNS the selection and branch (2) is SKIPPED;
  *     the heuristic fires only for a distilled row that has no precise tag (older rows / a
- *     write that skipped it). This stops the now-effective re-sort (CR-01) from suppressing
+ *     write that skipped it). This stops the re-sort from suppressing
  *     legitimately-distinct same-session recall.
  *
- * W6 PRECEDENCE FIX: `candidateIsDistilled` is computed as a SEPARATE boolean BEFORE
+ * PRECEDENCE GUARD: `candidateIsDistilled` is computed as a SEPARATE boolean BEFORE
  * the `&&`-chain, so the predicate `candidate.id !== summary.id && !candidateIsDistilled`
  * is unambiguous — the distilled summary itself, and any OTHER lcd_distilled entry, are
  * NEVER added to the down-weight set (the `&&`/`||` precedence trap cannot fire).
@@ -73,6 +73,6 @@ export declare const PROVENANCE_DOWNWEIGHT_FACTOR = 0.5;
  * @param ranked          The post-MMR scored candidates (NOT mutated; a new array is
  *                        returned only when ≥1 candidate is down-weighted).
  * @param provenanceStore The injected provenance read port (the caller proved it defined).
- * @param scope           The (tenant, agent)-scoped ContextStoreScope for the R4 read.
+ * @param scope           The (tenant, agent)-scoped ContextStoreScope for the provenance read.
  */
 export declare function applyProvenanceDownweighting(ranked: MemorySearchResult[], provenanceStore: LcdProvenanceReadStore, scope: ContextStoreScope): MemorySearchResult[];