comisai 1.0.44 → 1.0.46

package/node_modules/@comis/agent/dist/executor/lcd-compaction-trigger.js

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * LCD afterTurn threshold-sweep trigger (Phase 129 dag-mode, C1/C3).
+ * LCD afterTurn threshold-sweep trigger (dag mode).
  *
- * Activates the previously-inert `contextThreshold` config: at the afterTurn
+ * Activates the `contextThreshold` config: at the afterTurn
  * (`postExecution`) boundary, when context utilization exceeds
  * `contextThreshold` (0.75 × W by default), fire a bounded leaf-pass drain —
- * select the oldest out-of-tail chunk, summarize it (the Plan-03 3-level
+ * select the oldest out-of-tail chunk, summarize it (the 3-level
  * escalation), and range-replace the covered `context_items` message-refs with
- * one summary-ref at the EXACT covered ordinal window (C3). Below the
+ * one summary-ref at the EXACT covered ordinal window. Below the
  * threshold, nothing fires. Lives in its own module because
  * `executor-post-execution.ts` is already at the file-size cap.
  *
@@ -15,26 +15,26 @@
  *   1. NON-FATAL: a summarizer / store failure must NEVER fail the live turn.
  *      The whole drain is wrapped in one try/catch → WARN (errorKind
  *      `dependency`) and returns; the call site simply awaits a promise that
- *      never rejects (T-129-18). The leaf summarizer's deterministic Level-3
+ *      never rejects. The leaf summarizer's deterministic Level-3
  *      truncation is the in-pass degrade; a store failure is the outer degrade.
  *   2. AGENT-SIDE TOKENS: utilization + chunk-size use the STORED per-message
  *      `tokenCount` (computed at ingest via `estimateMessageTokens`, counting
- *      the F3 `thinking` block — re-estimation under-counts). The store NEVER
- *      computes tokens (the 127 contract keeps core/memory estimator-free).
+ *      the `thinking` block — re-estimation under-counts). The store NEVER
+ *      computes tokens (the contract keeps core/memory estimator-free).
  *   3. INJECTED CLOCK: every timestamp comes from the supplied `now`, never the
  *      ambient wall-clock global (the globals gate; AGENTS.md §2.2).
  *
- * The C3 ordinal mapping is the tampering guard (T-129-22): the
+ * The ordinal mapping is the tampering guard: the
  * `[startOrdinal, endOrdinal]` window passed to `appendLeafSummary` is the
  * contiguous message-ref run covering the selected chunk; a wrong window
  * silently corrupts context_items ordering, so it is read back + asserted in
- * the RED test. Bounded (T-129-19): the drain is capped per turn; Phase 132
- * wraps the injected summarizer seam with spend governance + a breaker.
+ * the tests. Bounded: the drain is capped per turn; the injected
+ * summarizer seam is wrapped with spend governance + a breaker.
  *
  * Architecture cut (agent↛memory): imports ONLY core TYPES + the core
  * `partsToMessage` codec + the agent-side summarizer/estimator. The concrete
  * `createLcdStore` is daemon-injected (the build cut). NEVER logs message or
- * summary content — ids/counts/durations/level only (AGENTS.md §2.2; T-129-20).
+ * summary content — ids/counts/durations/level only (AGENTS.md §2.2).
  *
  * @module
  */
@@ -50,8 +50,8 @@ import { LCD_MAX_LEAF_PASSES_PER_TURN, SUMMARIZER_PROMPT_OVERHEAD_TOKENS } from
 import { clampFactorText, emitSummaryLanguageMismatch } from "../context-engine/compaction-zone-helpers.js";
 import { previousSummaryContent, chunkOrdinalWindow } from "./lcd-compaction-helpers.js";
 /**
- * Resolve the model-facing context from `context_items`. Token authority
- * (Pitfall 2): the STORED per-row/per-summary `tokenCount` (counts F3 thinking),
+ * Resolve the model-facing context from `context_items`. Token authority:
+ * the STORED per-row/per-summary `tokenCount` (counts the thinking block),
  * NOT a re-estimate of the reconstructed message (which would exclude thinking).
  * Mirrors the synthetic-session gate's `runOneLeafPass` driver — skip leading
  * summary-refs, take the contiguous message-ref run, and stop at the next summary
@@ -60,20 +60,20 @@ import { previousSummaryContent, chunkOrdinalWindow } from "./lcd-compaction-hel
  * utilization even though they are not selectable chunk items.
  */
 export function resolveContext(store, scope) {
-    // R4 (132-03): the three reads are scoped by (conversation, agent, tenant) so
-    // a leaf/condense pass observes ONLY the acting agent's view (WR-02) — the
+    // The three reads are scoped by (conversation, agent, tenant) so
+    // a leaf/condense pass observes ONLY the acting agent's view — the
     // SAME scope the afterTurn ingest stamped and the assembler reads with.
     const items = store.getContextItems(scope);
     const rowById = new Map(store.getMessages(scope).map((r) => [r.id, r]));
-    // Read `getSummaries` ONCE (WR-01) — it serves the utilization token sum
-    // (CR-02), the per-depth run construction (C2), and rides out on
+    // Read `getSummaries` ONCE — it serves the utilization token sum,
+    // the per-depth run construction, and rides out on
     // `ResolvedContext` so taint + previousSummary derive from this one snapshot.
     const summaries = store.getSummaries(scope);
     const summaryById = new Map(summaries.map((s) => [s.summaryId, s]));
     const history = [];
     const ordinalById = new Map();
     let resolvedTokens = 0;
-    // Per-depth contiguous summary-ref run accumulation (C2): `openRun` extends
+    // Per-depth contiguous summary-ref run accumulation: `openRun` extends
     // until the next item is a message-ref or a different-depth summary-ref, then
     // flushes into `summaryRunsByDepth`. The leaf half rides the SAME walk.
     const summaryRunsByDepth = [];
@@ -87,12 +87,12 @@ export function resolveContext(store, scope) {
     // The leaf-history collection STOPS after the first contiguous message run (it
     // never spans a summary boundary so the leaf window stays contiguous). The
     // condense-run + token accumulation walk the WHOLE view regardless — so a
-    // Pitfall-3 layout `[s0 m1 s2 s3 s4]` still captures the trailing s2..s4 run
+    // `[s0 m1 s2 s3 s4]` layout still captures the trailing s2..s4 run
     // even though the leaf walk stopped at s2. One read, two derived views.
     let leafWalkStopped = false;
     for (const item of items) {
         if (item.refKind !== "message") {
-            // A summary terminal. For utilization (CR-02) count its tokens across the
+            // A summary terminal. For utilization count its tokens across the
             // WHOLE view. For the CONDENSE half it is a candidate child: extend the open
             // same-depth run or start a new one (a depth change breaks the prior run).
             const summary = summaryById.get(item.refId);
@@ -106,7 +106,7 @@ export function resolveContext(store, scope) {
                     tokenCount: summary.tokenCount,
                     // Carry `taint` from THIS snapshot so the condense trigger reads
                     // `taint = OR(children)` off the selected run — never a second,
-                    // possibly-diverged getSummaries read (WR-01).
+                    // possibly-diverged getSummaries read.
                     taint: summary.taint,
                 };
                 if (openRun !== undefined && openRun.depth === summary.depth) {
@@ -132,7 +132,7 @@ export function resolveContext(store, scope) {
                 leafWalkStopped = true;
             continue;
         }
-        // A message-ref breaks any open summary run (Pitfall 3: a run never spans a
+        // A message-ref breaks any open summary run (a run never spans a
         // surviving message-ref).
         flushOpenRun();
         const row = rowById.get(item.refId);
@@ -157,10 +157,10 @@ export function resolveContext(store, scope) {
 }
 /**
  * Persist the deterministic (no-LLM) leaf floor for a chunk: nano structured
- * extraction (SUM-02 — carries LEAF_FALLBACK_SUMMARY_MARKER; shrink-guarded
+ * extraction (carries LEAF_FALLBACK_SUMMARY_MARKER; shrink-guarded
  * inside buildNanoStructuredExtraction) → appendLeafSummary (fallback:true) →
- * `context:dag_compacted` emit → completion INFO. Shared by the C5
- * capability-eviction branch and the review-WR-02 over-cap chunk branch.
+ * `context:dag_compacted` emit → completion INFO. Shared by the
+ * capability-eviction branch and the over-cap chunk branch.
  */
 function persistDeterministicLeafFloor(store, scope, chunkItems, chunkTokens, window, now, nowFn, passStart, logger, eventBus, completionMessage) {
     const nanoExtraction = buildNanoStructuredExtraction(chunkItems.map((it) => it.msg), chunkTokens);
@@ -178,7 +178,7 @@ function persistDeterministicLeafFloor(store, scope, chunkItems, chunkTokens, wi
         startOrdinal: window.startOrdinal,
         endOrdinal: window.endOrdinal,
     });
-    // O1 timing + dag_compacted event (counts only — never content).
+    // Pass timing + dag_compacted event (counts only — never content).
     const durationMs = Math.max(0, (nowFn?.() ?? now) - passStart);
     eventBus?.emit("context:dag_compacted", {
         conversationId: scope.conversationId,
@@ -196,20 +196,20 @@ function persistDeterministicLeafFloor(store, scope, chunkItems, chunkTokens, wi
 }
 /**
  * Run ONE leaf pass against the CURRENT store state and return whether it made
- * progress. Re-resolves the model-facing `context_items` view itself (CR-01/CR-02)
+ * progress. Re-resolves the model-facing `context_items` view itself
  * so a caller looping this observes its own prior compaction. Throws only on a
  * store/summarizer fault (the {@link maybeRunLeafPass} drain wraps the whole loop
  * in one try/catch so a throw in pass K never loses passes 1..K-1, which are
- * already committed atomically). All B-13 `lcd-leaf-gate` DEBUG lines live here so
+ * already committed atomically). All `lcd-leaf-gate` DEBUG lines live here so
  * they fire on EVERY drain iteration (a stalled drain stays diagnosable).
  */
 async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDeps, now, nowFn, logger, eventBus) {
     const conversationId = scope.conversationId;
-    // O1: per-pass START clock read (the injected clock CALLABLE — NEVER
+    // Per-pass START clock read (the injected clock CALLABLE — NEVER
     // Date.now()/performance.now(), the globals gate). A second read at emit gives
     // this pass's real elapsed; a scalar-only caller (no nowFn) degrades to 0.
     const passStart = nowFn?.() ?? now;
-    // Resolve the model-facing context from context_items (CR-01/CR-02): the
+    // Resolve the model-facing context from context_items: the
     // utilization gate AND chunk selection both read this resolved view — never the
     // raw lossless getMessages() set — so the pass observes prior compaction (a view
     // that fits under threshold goes inert) and selects LIVE message-refs that
@@ -223,13 +223,13 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
     // Utilization = resolved context tokens / W. The numerator is the RESOLVED view
     // (summary-ref tokens + surviving message-ref tokens), the same set the assembler
     // budgets — NOT the un-compacted raw history (which never shrinks). Tokens are
-    // the stored authority (Pitfall 2): a re-estimate would EXCLUDE F3 thinking.
+    // the stored authority: a re-estimate would EXCLUDE the thinking block.
     const utilization = resolvedTokens / opts.windowTokens;
     logger.debug({ conversationId, agentId: scope.agentId, step: "lcd-leaf-gate", historyLength: history.length, resolvedTokens, windowTokens: opts.windowTokens, utilization: Math.round(utilization * 1000) / 1000, contextThreshold: opts.contextThreshold }, "lcd leaf pass evaluated");
     if (utilization <= opts.contextThreshold)
         return { made: false, reason: "below-threshold" }; // drained.
-    // S4: build the set of security-pinned message ids (from markers on summarizerDeps).
-    // These messages are never selected as eviction candidates (S4 invariant).
+    // Build the set of security-pinned message ids (from markers on summarizerDeps).
+    // These messages are never selected as eviction candidates (the security-pinning invariant).
     let pinnedMessageIds;
     if (summarizerDeps.securityMarkers) {
         const pinned = history.filter((it) => 
@@ -242,12 +242,12 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
             logger.debug({ conversationId, agentId: scope.agentId, step: "lcd-leaf-gate", securityPinnedCount: pinned.length }, "S4: security-relevant messages excluded from LCD leaf eviction");
         }
     }
-    // SUMW-01: clamp the chunk cap to the RESOLVED summarizer's window
+    // Clamp the chunk cap to the RESOLVED summarizer's window
     // (override-aware — never the getModel() session-primary snapshot) minus the
     // summary target + prompt-template overhead + the ACTUAL previousSummary
-    // threaded into THIS pass's prompt (review WR-03: the flat 2_048 covers only
+    // threaded into THIS pass's prompt (the flat 2_048 covers only
     // the template — the last summary of any kind can be ~condense-target-sized,
-    // read per pass since each pass appends one). Review WR-05 finite guard
+    // read per pass since each pass appends one). Finite guard
     // (parity with the condense sibling's Number.isFinite no-op): a non-finite
     // candidate keeps the CONFIGURED cap — NaN would otherwise silently disable
     // selectLeafChunk's break condition and select the whole out-of-tail history.
@@ -260,17 +260,17 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
         ? Math.max(MIN_SHRINKABLE_LEAF_CHUNK_TOKENS, Math.min(opts.leafChunkTokens, capCandidate))
         : opts.leafChunkTokens;
     if (leafChunkCap < opts.leafChunkTokens) {
-        // Numbers only (I7) — a binding clamp is normal adaptive behavior, never WARN.
+        // Numbers only — a binding clamp is normal adaptive behavior, never WARN.
         logger.debug({ conversationId, agentId: scope.agentId, step: "lcd-leaf-gate", summarizerWindow, configuredLeafChunkTokens: opts.leafChunkTokens, clampedLeafChunkTokens: leafChunkCap }, "lcd leaf chunk cap clamped to the resolved summarizer window");
     }
     // Select the oldest out-of-tail chunk (pair-safe, capped at the CLAMPED cap)
     // from the RESOLVED message-ref run — so the selected ids always map back to a
     // context_items ordinal (the second-pass divergence is structurally gone).
-    // S4: pass pinnedMessageIds so pinned messages are excluded from chunk selection.
+    // Pass pinnedMessageIds so pinned messages are excluded from chunk selection.
     const chunk = selectLeafChunk(history, opts.freshTailTurns, leafChunkCap, pinnedMessageIds);
     if (chunk === undefined)
         return { made: false, reason: "no-chunk" }; // no evictable out-of-tail history.
-    // Skip a trivially-tiny chunk (WR-01): a chunk below the minimum shrinkable size
+    // Skip a trivially-tiny chunk: a chunk below the minimum shrinkable size
     // cannot be replaced by any non-empty summary that is STRICTLY smaller, so
     // summarizing it would only emit a degenerate (empty/larger) leaf. This is also a
     // drain NO-PROGRESS terminator: a re-resolve would re-select the SAME sub-minimum
@@ -284,7 +284,7 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
     const window = chunkOrdinalWindow(ordinalById, firstMessageId, lastMessageId);
     if (window === undefined) {
         // The selected message ids are not a resolvable message-ref window in the
-        // current view (a divergence). Skip rather than corrupt ordinals (C3) — and end
+        // current view (a divergence). Skip rather than corrupt ordinals — and end
         // the drain (a re-resolve would re-select the same unresolvable chunk).
         logger.warn({
             conversationId,
@@ -293,7 +293,7 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
             hint: "leaf chunk message ids did not resolve to a context_items ordinal window; skipping the pass to avoid corrupting ordering",
             errorKind: "precondition",
         }, "LCD leaf pass skipped: ordinal-window divergence");
-        // Phase 160 I1: content-free context:dag_degraded so the divergence persists
+        // Emit a content-free context:dag_degraded so the divergence persists
         // as a health_signal row (fleet-lens queryable), not a Pino-only WARN.
         // Identifiers + reason + timing only; injected clock (the globals gate).
         eventBus?.emit("context:dag_degraded", {
@@ -314,7 +314,7 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
     const chunkItems = chunk.messageIds
         .map((id) => idToItem.get(id))
         .filter((it) => it !== undefined);
-    // C4/C5: resolve compaction strategy based on capability class.
+    // Resolve the compaction strategy based on capability class.
     const compactionStrategy = resolveCompactionStrategy(summarizerDeps.capabilityClass ?? "frontier", summarizerDeps.preferEvictionByCapability ?? true, summarizerDeps.strongerSummarizerModel ?? "");
     const securityPinnedCount = pinnedMessageIds?.size ?? 0;
     // Emit context:compaction_routed for BOTH strategy branches (observability —
@@ -330,7 +330,7 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
     });
     if (compactionStrategy === "eviction" || compactionStrategy === "deterministic") {
         // Small/nano: skip LLM summarization — use the deterministic fallback
-        // (SUM-02 nano structured extraction; carries LEAF_FALLBACK_SUMMARY_MARKER).
+        // (nano structured extraction; carries LEAF_FALLBACK_SUMMARY_MARKER).
         logger.warn({
             conversationId,
             agentId: scope.agentId,
@@ -341,19 +341,19 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
         }, "C5: LCD leaf compaction capability gate — eviction selected");
         return persistDeterministicLeafFloor(store, scope, chunkItems, chunk.tokens, window, now, nowFn, passStart, logger, eventBus, "LCD leaf summary persisted (C5: deterministic eviction)");
     }
-    // Review WR-02: a single message larger than the clamped cap (selected via
+    // A single message larger than the clamped cap (selected via
     // selectLeafChunk's always-include-one rule, or a pair-safety extension past
     // the cap) makes every LLM attempt a guaranteed overflow — up to 4 failing
     // calls per pass, repeating each turn until the backlog drains. Go straight
     // to the bounded deterministic floor instead (no LLM; the full content stays
-    // losslessly in the message store). DEBUG, numbers only (I7).
+    // losslessly in the message store). DEBUG, numbers only.
     if (chunk.tokens > leafChunkCap) {
         logger.debug({ conversationId, agentId: scope.agentId, step: "lcd-leaf-gate", reason: "over-cap-chunk", chunkTokens: chunk.tokens, clampedLeafChunkTokens: leafChunkCap }, "lcd leaf chunk exceeds the resolved summarizer cap; deterministic floor (no LLM)");
-        return persistDeterministicLeafFloor(store, scope, chunkItems, chunk.tokens, window, now, nowFn, passStart, logger, eventBus, "LCD leaf summary persisted (SUMW-01: over-cap chunk — deterministic floor)");
+        return persistDeterministicLeafFloor(store, scope, chunkItems, chunk.tokens, window, now, nowFn, passStart, logger, eventBus, "LCD leaf summary persisted (over-cap chunk — deterministic floor)");
     }
     // Summarize (3-level escalation; non-fatal inside — always returns a result).
-    // SUM-02: resolve tier-aware effective leaf target (nano ≤256, small ≤400, mid ≤800, frontier uncapped).
-    // `previousSummary` is the SAME read the chunk-cap budget above accounted (WR-03).
+    // Resolve the tier-aware effective leaf target (nano ≤256, small ≤400, mid ≤800, frontier uncapped).
+    // `previousSummary` is the SAME read the chunk-cap budget above accounted.
     const effectiveLeafTarget = resolveSummaryTargetTokens(summarizerDeps.capabilityClass ?? "frontier", 0, // leaf depth is always 0
     opts.leafTargetTokens);
     const result = await summarizeLeafChunk(chunkItems, summarizerDeps, {
@@ -361,7 +361,7 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
         previousSummary,
     });
     // Persist + link + range-replace at the EXACT [startOrdinal, endOrdinal] window —
-    // one atomic store transaction (C3). The store recomputes the covered-run
+    // one atomic store transaction. The store recomputes the covered-run
     // descendantCount/time-range; we pass the chunk values as advisory + the exact
     // window the summary-ref replaces.
     store.appendLeafSummary({
@@ -378,7 +378,7 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
         startOrdinal: window.startOrdinal,
         endOrdinal: window.endOrdinal,
     });
-    // OBS-01 (Phase 180): the small-model G4 detector — a non-Latin chunk whose
+    // The small-model language-mismatch detector — a non-Latin chunk whose
     // leaf summary came back Latin emits context:summary_language_mismatch (depth
     // 0; source = the SAME chunk text the summarizer saw, never a store re-read).
     // Visibility only — guarded, content-free, never fails the pass.
@@ -387,11 +387,11 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
         sourceText: chunkItems.map((it) => clampFactorText(it.msg)).join(" "),
         summaryText: result.content, depth: 0, nowMs: now,
     });
-    // O1 (Phase 133): real per-pass timing — a SECOND injected-clock read at emit
+    // Real per-pass timing — a SECOND injected-clock read at emit
     // minus this pass's `passStart`. A scalar-only caller (no nowFn) degrades to 0.
     const durationMs = Math.max(0, (nowFn?.() ?? now) - passStart);
     // Emit the existing compaction event ONCE PER PASS (reuse, counts only — never
-    // content; honest per-pass counts, Pitfall 3).
+    // content; honest per-pass counts).
     eventBus?.emit("context:dag_compacted", {
         conversationId,
         agentId: scope.agentId,
@@ -417,9 +417,9 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
     return { made: true, reason: "compacted" };
 }
 /**
- * AfterTurn threshold sweep: a BOUNDED multi-pass leaf DRAIN (B-2). Loops
+ * AfterTurn threshold sweep: a BOUNDED multi-pass leaf DRAIN. Loops
  * {@link runOneLeafPass} — re-resolving the model-facing view each iteration so
- * it observes its own compaction (CR-02) — until the FIRST of: utilization ≤
+ * it observes its own compaction — until the FIRST of: utilization ≤
  * `contextThreshold` (drained), a no-progress guard (no chunk / sub-MIN_SHRINKABLE
  * chunk / ordinal-window divergence — re-resolving would re-select the SAME
  * chunk), or the hard `maxLeafPassesPerTurn` cap (the infinite-loop backstop).
@@ -428,7 +428,7 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
  * round-trip blocking the live turn — the cap guarantees a turn never fires
  * unbounded synchronous summarizer calls; a load the cap can't fully drain
  * keeps draining on the NEXT afterTurn (the gate stays armed) rather than
- * stalling at one pass forever (the B-2 stall this replaces).
+ * stalling at one pass forever.
  *
  * Non-fatal end-to-end (mirrors `ingestTurnGuarded`): the WHOLE loop is wrapped
  * in one try/catch → WARN → return, so a throw in pass K never fails the live
@@ -437,9 +437,9 @@ async function runOneLeafPass(store, scope, opts, summarizerWindow, summarizerDe
  * @param store          The injected core ContextStorePort (daemon-injected concrete store).
  * @param scope          The SECURITY scope columns (conversationId/tenantId/agentId/sessionKey).
  * @param opts           The gating + sizing knobs from `config.contextEngine` (incl. the optional cap).
- * @param summarizerDeps The injected summarizer + model getters (the 132 spend-governance seam). Absent ⇒ no-op.
+ * @param summarizerDeps The injected summarizer + model getters (the spend-governance seam). Absent ⇒ no-op.
  * @param now            Injected wall-clock ms (`deps.clock.now()`) — NEVER the ambient time global. Stamps `timestamp`.
- * @param nowFn          Injected clock CALLABLE (`deps.clock.now`) for the per-pass timing reads (O1). Absent ⇒ durationMs 0.
+ * @param nowFn          Injected clock CALLABLE (`deps.clock.now`) for the per-pass timing reads. Absent ⇒ durationMs 0.
  * @param logger         For the per-pass completion INFO + the non-fatal WARN.
  * @param eventBus       Optional bus to emit `context:dag_compacted` once per actual pass.
  */
@@ -455,14 +455,14 @@ export async function maybeRunLeafPass(store, scope, opts, summarizerDeps, now,
         return;
     }
     // The hard cap (the infinite-loop backstop): the supplied knob or the LOW default.
-    // Clamp to >= 1 so a misconfigured 0/negative still attempts one pass (degenerate
-    // single-pass — the prior behavior) rather than silently disabling compaction.
+    // Clamp to >= 1 so a misconfigured 0/negative still attempts one pass (a
+    // degenerate single-pass drain) rather than silently disabling compaction.
     const maxPasses = Math.max(1, Math.floor(opts.maxLeafPassesPerTurn ?? LCD_MAX_LEAF_PASSES_PER_TURN));
     try {
-        // SUMW-01 / review WR-05: resolve the summarizer window INSIDE the
+        // Resolve the summarizer window INSIDE the
         // never-rejects boundary — resolveSummarizerWindowTokens invokes the
         // caller-supplied getRealModel()/getModel(), and a throwing getter must
-        // degrade to the WARN below (T-129-18), never reject the live turn
+        // degrade to the WARN below, never reject the live turn
         // (parity with maybeRunCondensePass, which resolves inside its try). The
         // per-pass chunk-cap clamp derived from it lives in runOneLeafPass.
         const summarizerWindow = resolveSummarizerWindowTokens(summarizerDeps);
@@ -473,7 +473,7 @@ export async function maybeRunLeafPass(store, scope, opts, summarizerDeps, now,
         }
     }
     catch (err) {
-        // Non-fatal (T-129-18): any failure degrades to a WARN + return — the live turn
+        // Non-fatal: any failure degrades to a WARN + return — the live turn
         // is unaffected (mirror ingestTurnGuarded). errorKind `dependency` (a
         // summarizer/store failure is an external-dependency fault). Passes that already
         // committed before the throw are kept (each appendLeafSummary is atomic).
@@ -491,7 +491,7 @@ export async function maybeRunLeafPass(store, scope, opts, summarizerDeps, now,
  * Thin afterTurn call-site wiring for the leaf pass: resolve the summarizer deps,
  * gate on their presence, build {@link LeafPassOptions} from `config.contextEngine`
  * (defaulted via `ContextEngineConfigSchema`) with `windowTokens` taken from the
- * threaded per-turn `budgetWindowTokens` (SUMW-02 — the SAME budget window the
+ * threaded per-turn `budgetWindowTokens` (the SAME budget window the
  * assembler + preflight use, NOT the session model's configured window), then
  * delegate to {@link maybeRunLeafPass}.
  *
@@ -520,10 +520,10 @@ export async function runLeafPassAfterTurn(params) {
         leafChunkTokens: cfg.leafChunkTokens,
         leafTargetTokens: cfg.leafTargetTokens,
         freshTailTurns: cfg.freshTailTurns,
-        // SUMW-02: the utilization denominator W is the threaded per-turn budget
+        // The utilization denominator W is the threaded per-turn budget
         // window (min(reconciled contextWindow, class cap)) — never the summarizer
-        // snapshot's configured window, which armed ~4× late on capped small
-        // models (DIST-01). The maybeRunLeafPass finite-positive gate is unchanged.
+        // snapshot's configured window, which arms ~4× late on capped small
+        // models. The maybeRunLeafPass finite-positive gate is unchanged.
         windowTokens: budgetWindowTokens,
     }, summarizerDeps, now, nowFn, logger, eventBus);
 }

package/node_modules/@comis/agent/dist/executor/lcd-condense-trigger.d.ts

@@ -1,11 +1,11 @@
 /**
- * LCD afterTurn CONDENSE pass (Phase 130, C2) — the mirror of the leaf pass.
+ * LCD afterTurn CONDENSE pass — the mirror of the leaf pass.
  *
  * Where {@link maybeRunLeafPass} (lcd-compaction-trigger.ts) folds a contiguous
  * run of raw MESSAGES into a depth-0 leaf, this pass folds a contiguous run of
  * ≥`condensedMinFanout` same-depth SUMMARIES into one coarser depth+1 condensed
  * summary — turning the single-tier LCD compaction into a multi-tier zoomable
- * hierarchy (C2). It runs AFTER the leaf pass at the afterTurn boundary, so a turn
+ * hierarchy. It runs AFTER the leaf pass at the afterTurn boundary, so a turn
  * that just created the Nth leaf can immediately fold it.
  *
  * It lives in its OWN module (not in lcd-compaction-trigger.ts) to keep that file
@@ -13,37 +13,37 @@
  * ({@link resolveContext}) lives in the trigger and returns BOTH the leaf history
  * and the per-depth contiguous summary-ref runs, so utilization + leaf selection
  * + condense selection all read ONE `getContextItems`/`getMessages`/`getSummaries`
- * snapshot (the CR-01/CR-02 "one resolved view is source of truth" invariant).
+ * snapshot (the "one resolved view is source of truth" invariant).
  *
  * Three load-bearing contracts (mirroring {@link maybeRunLeafPass}):
  *   1. NON-FATAL: a summarizer / store failure must NEVER fail the live turn —
  *      the whole body is wrapped in one try/catch → WARN (errorKind `dependency`)
  *      and returns; the awaiting call site simply awaits a promise that never
- *      rejects (T-130-07). The condense summarizer's own deterministic Level-3
+ *      rejects. The condense summarizer's own deterministic Level-3
  *      truncation is the in-pass degrade; a store failure is the outer degrade.
  *   2. AGENT-SIDE TOKENS: the before-size is the STORED `Σ child.tokenCount` (each
  *      child summary's persisted `tokenCount`); the persisted condensed
  *      `tokenCount` is the condense summarizer's `tokenCount`. The store NEVER
- *      computes tokens (the 127 contract).
+ *      computes tokens (the contract keeps core/memory estimator-free).
  *   3. INJECTED CLOCK: the condensed `createdAt` comes from the supplied `now`,
  *      never the ambient wall-clock global (the globals gate; AGENTS.md §2.2).
  *
- * Pitfall 3 (contiguity) is enforced BY CONSTRUCTION: a {@link SummaryRefRun}
+ * Contiguity is enforced BY CONSTRUCTION: a {@link SummaryRefRun}
  * breaks at any message-ref or depth change, so {@link selectCondensableTier} can
  * only ever pick a CONTIGUOUS same-depth run, and the `[startOrdinal, endOrdinal]`
  * window is the run's own ordinals → the store range-replace cannot corrupt
- * ordering or merge a non-contiguous fanout (T-130-08).
+ * ordering or merge a non-contiguous fanout.
  *
- * Bounded (T-130-06): ONE condense pass per call. 130 fires inline + synchronously
- * (mirrors the 129 leaf pass); deferred/background condensation + bounded spend +
- * a circuit breaker are Phase 132 — so the whole pass lives behind THIS one
- * function for a clean 132 swap (the SAME injected-summarizer seam as the leaf).
+ * Bounded: ONE condense pass per call, fired inline + synchronously at the
+ * afterTurn boundary (mirrors the leaf pass). The whole pass lives behind THIS
+ * one function — the SAME injected-summarizer seam as the leaf — so
+ * deferred/background scheduling or spend/breaker governance can swap in cleanly.
  *
  * Architecture cut (agent↛memory): this module imports ONLY the CORE
  * `ContextStorePort`/`ContextStoreScope` TYPES + the agent-side condense
  * summarizer + the trigger's resolved-view walk. The concrete `createLcdStore` is
  * daemon-injected — this module NEVER imports the memory package directly. It
- * NEVER logs summary content — ids/counts/durations/level only (T-130-09).
+ * NEVER logs summary content — ids/counts/durations/level only.
  *
  * @module
  */
@@ -86,9 +86,9 @@ export interface CondensePassOptions {
  * @param store          The injected core ContextStorePort (daemon-injected concrete store).
  * @param scope          The SECURITY scope columns (conversationId/tenantId/agentId/sessionKey).
  * @param opts           The gating + sizing knobs from `config.contextEngine`.
- * @param summarizerDeps The injected summarizer + model getters (the 132 spend-governance seam). Absent ⇒ no-op.
+ * @param summarizerDeps The injected summarizer + model getters (the spend-governance seam). Absent ⇒ no-op.
  * @param now            Injected wall-clock ms (`deps.clock.now()`) — NEVER the ambient time global. Stamps `timestamp`.
- * @param nowFn          Injected clock CALLABLE (`deps.clock.now`) for the two pass-timing reads (O1). Absent ⇒ durationMs 0.
+ * @param nowFn          Injected clock CALLABLE (`deps.clock.now`) for the two pass-timing reads. Absent ⇒ durationMs 0.
  * @param logger         For the completion INFO + the non-fatal WARN.
  * @param eventBus       Optional bus to emit `context:dag_compacted` on a completed pass.
  */
@@ -112,16 +112,16 @@ export interface RunCondensePassAfterTurnParams {
      * condense pass is gated off cleanly (no trigger, no summary).
      */
     getCondenseSummarizerDeps: (() => LeafSummarizerDeps) | undefined;
-    /** SUMW-02: the turn's budget window — `computeTokenBudgetForProfile().windowTokens`
+    /** The turn's budget window — `computeTokenBudgetForProfile().windowTokens`
      *  = min(reconciled contextWindow, capability class cap), captured at the executor
-     *  BEFORE any dispose (a plain number — dispose-safe on the deferred C4 path). The
+     *  BEFORE any dispose (a plain number — dispose-safe on the deferred-compaction path). The
      *  utilization + pressureHigh denominator: one window truth with assembly +
      *  preflight. REQUIRED — an optional-with-fallback would silently restore the
-     *  configured-window denominator (the DIST-01 4×-late-arming bug class). */
+     *  configured-window denominator, which arms ~4× late on capability-capped small models. */
     budgetWindowTokens: number;
     /** Injected wall-clock ms (`deps.clock.now()`) — never the ambient time global. Stamps `timestamp`. */
     now: number;
-    /** Injected clock CALLABLE (`deps.clock.now`) for the O1 two-read pass timing. Absent ⇒ durationMs 0. */
+    /** Injected clock CALLABLE (`deps.clock.now`) for the two-read pass timing. Absent ⇒ durationMs 0. */
     nowFn?: () => number;
     /** For the trigger's completion INFO + non-fatal WARN. */
     logger: ComisLogger;
@@ -130,7 +130,7 @@ export interface RunCondensePassAfterTurnParams {
     /**
      * Optional callback fired immediately after store.appendCondensedSummary returns.
      * Receives the new summaryId, content, fallback flag, and depth.
-     * Phase 172-02 (DIST-01): this is the distillation hook seam — the runner fires
+     * This is the distillation hook seam — the runner fires
      * after each condensed summary is persisted.
      *
      * Non-fatal: callers MUST NOT depend on this callback throwing — if it throws,
@@ -143,8 +143,8 @@ export interface RunCondensePassAfterTurnParams {
  * Thin afterTurn call-site wiring for the condense pass: resolve the condense
  * summarizer deps, gate on their presence, build {@link CondensePassOptions} from
  * `config.contextEngine` (defaulted via `ContextEngineConfigSchema`) with
- * `windowTokens` taken from the threaded per-turn `budgetWindowTokens` (SUMW-02 —
- * the SAME budget window the assembler + preflight use, NOT the session model's
+ * `windowTokens` taken from the threaded per-turn `budgetWindowTokens` (the
+ * SAME budget window the assembler + preflight use, NOT the session model's
  * configured window), then delegate to {@link maybeRunCondensePass}. Clones
  * `runLeafPassAfterTurn`.
  *