comisai 1.0.44 → 1.0.46

package/node_modules/@comis/agent/dist/executor/executor-tool-pipeline.js

@@ -57,7 +57,7 @@ export function decodeHtmlEntitiesInParams(params) {
 export function applyJitGuideWrapping(params) {
     return createJitGuideWrapper(params.tools, params.deliveredGuides, params.logger);
 }
-/** Apply schema pruning for nano-class models (behavior-neutral: old small=<=32K → new nano). */
+/** Apply schema pruning for nano-class models (only the "nano" capability class is pruned). */
 export function applySchemasPruning(params) {
     if (params.capabilityClass !== "nano")
         return params.tools;
@@ -169,7 +169,7 @@ export function applyProviderNormalization(params) {
         provider: params.provider,
         modelId: params.modelId,
         compat: params.compat,
-        // AUTHOR-03 (CR-01): forward the authoring gate so the Layer 3.5 GBNF
+        // Forward the authoring gate so the Layer 3.5 GBNF
         // transform actually engages on gbnf-eligible providers when the operator
         // flips it on. Absent ⇒ undefined ⇒ FLAGS-OFF byte-identical.
         gbnfConstrain: params.gbnfConstrain,
@@ -178,7 +178,7 @@ export function applyProviderNormalization(params) {
     // (agent-loop.js prepareToolCall → validateToolArguments) — the correct interception
     // point for argument normalization. We compose two normalizations into it:
     //   1. xAI/Grok HTML-entity decode (provider-gated), then
-    //   2. per-field stringified-JSON coercion (F-3, universal): a small model emits
+    //   2. per-field stringified-JSON coercion (universal): a small model emits
     //      e.g. memory_manage {ids:"[\"uuid\"]"} — the SDK validator coerces stringified
     //      primitives but NOT arrays/objects, so the call was rejected and the model
     //      fabricated a result. Coerce array/object fields back to structured values,
@@ -202,7 +202,7 @@ export function applyProviderNormalization(params) {
 }
 /**
  * Re-apply the session's reactive pattern/format strip AFTER provider
- * normalization (CR-02). The strip-retry handler
+ * normalization. The strip-retry handler
  * (tool-schema-unsupported-handler.ts) mutates THIS turn's wire objects for
  * the in-flight retry, but every subsequent turn rebuilds `parameters` from
  * the pre-strip schema snapshot — and gbnf normalization constructs

package/node_modules/@comis/agent/dist/executor/gemini-cache-injector.js

@@ -70,7 +70,7 @@ export function createGeminiCacheInjector(config, logger) {
                     const tools = configObj.tools;
                     const toolConfig = configObj.toolConfig;
                     // Estimate tokens from cacheable content
-                    // flat-by-design: JSON envelope size heuristic for implicit-cache decisions, not budget/fit math (TOK-01)
+                    // flat-by-design: JSON envelope size heuristic for implicit-cache decisions, not budget/fit math (no script factor)
                     const estimatedTokens = Math.ceil(JSON.stringify({ systemInstruction, tools, toolConfig }).length / CHARS_PER_TOKEN_RATIO_STRUCTURED);
                     // Compute content hash for cache invalidation
                     const contentHash = computeCacheContentHash(systemInstruction, tools ?? [], toolConfig);

package/node_modules/@comis/agent/dist/executor/goal-planner.d.ts

@@ -1,13 +1,12 @@
 /**
- * goal-planner.ts — R5 pre-execution planner (DEFERRED on M2).
+ * goal-planner.ts — pre-execution planner (deliberately a stub).
  *
- * R5 builds the GoalChecklist that seeds R1 (GoalAnchor) and R4 (critic).
- * The Phase 149 gap report showed false-success = 0% in isolation; the M2
- * baseline suggests the GoalAnchor alone may suffice. This stub preserves
- * the "planning" operation type wiring (Plan 01) and provides the correct
- * module boundary; full implementation deferred until M2 gap analysis
- * (Phase 157 or a dedicated fix-forward phase) confirms the GoalAnchor is
- * insufficient.
+ * The planner builds the GoalChecklist that seeds the GoalAnchor and the
+ * verification critic. Measured false-success in isolation was 0%, which
+ * suggests the GoalAnchor alone suffices. This stub preserves
+ * the "planning" operation type wiring and provides the correct
+ * module boundary; a full implementation is deferred until evidence shows
+ * the GoalAnchor is insufficient.
  *
  * Do NOT use: any external LLM call, compatibility shims, or deprecated annotations.
  */
@@ -22,7 +21,7 @@ export type GoalPlannerDeps = Record<string, never>;
  * createGoalPlanner — factory returning a planner function.
  *
  * STUB: currently returns an empty checklist (no LLM call).
- * The "planning" operation type (Plan 01) is registered; the full
- * completeSimple seam implementation is deferred to M2 analysis.
+ * The "planning" operation type is registered; the full
+ * completeSimple seam implementation is deferred (see the module JSDoc).
  */
 export declare function createGoalPlanner(_deps: GoalPlannerDeps): (_request: string) => Promise<GoalChecklist>;

package/node_modules/@comis/agent/dist/executor/goal-planner.js

@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * goal-planner.ts — R5 pre-execution planner (DEFERRED on M2).
+ * goal-planner.ts — pre-execution planner (deliberately a stub).
  *
- * R5 builds the GoalChecklist that seeds R1 (GoalAnchor) and R4 (critic).
- * The Phase 149 gap report showed false-success = 0% in isolation; the M2
- * baseline suggests the GoalAnchor alone may suffice. This stub preserves
- * the "planning" operation type wiring (Plan 01) and provides the correct
- * module boundary; full implementation deferred until M2 gap analysis
- * (Phase 157 or a dedicated fix-forward phase) confirms the GoalAnchor is
- * insufficient.
+ * The planner builds the GoalChecklist that seeds the GoalAnchor and the
+ * verification critic. Measured false-success in isolation was 0%, which
+ * suggests the GoalAnchor alone suffices. This stub preserves
+ * the "planning" operation type wiring and provides the correct
+ * module boundary; a full implementation is deferred until evidence shows
+ * the GoalAnchor is insufficient.
  *
  * Do NOT use: any external LLM call, compatibility shims, or deprecated annotations.
  */
@@ -16,13 +15,13 @@
  * createGoalPlanner — factory returning a planner function.
  *
  * STUB: currently returns an empty checklist (no LLM call).
- * The "planning" operation type (Plan 01) is registered; the full
- * completeSimple seam implementation is deferred to M2 analysis.
+ * The "planning" operation type is registered; the full
+ * completeSimple seam implementation is deferred (see the module JSDoc).
  */
 export function createGoalPlanner(_deps) {
     return async function buildChecklist(_request) {
-        // R5 DEFERRED: return empty checklist so callers degrade gracefully.
-        // The GoalAnchor (R1) already provides the checklist from the executor plan;
+        // Deferred: return an empty checklist so callers degrade gracefully.
+        // The GoalAnchor already provides the checklist from the executor plan;
         // the critic reads executionPlanRef.current.steps directly (see verification-gate.ts).
         return { items: [] };
     };

package/node_modules/@comis/agent/dist/executor/jit-guide-injector.js

@@ -65,8 +65,9 @@ export function wrapToolResultWithGuide(toolName, result, deliveredGuides, logge
     // Rationale: if the first call to a guided tool errors (validation,
     // approval-required, etc.) and we mutate deliveredGuides here, a later
     // successful call finds the slot "consumed" and silently skips its guide.
-    // That's invisible and was the root cause of the NVDA team-agent session
-    // never seeing TOOL_GUIDES["agents_manage"]. Mutate only on success.
+    // That failure mode is invisible — the session simply never sees the
+    // guide (observed live with TOOL_GUIDES["agents_manage"]). Mutate only
+    // on success.
     // Step 1 — collect candidate guides (read-only on deliveredGuides)
     const toolGuide = getToolGuideWithSchema(toolName);
     const wantsTool = !!toolGuide && !deliveredGuides.has(toolName);

package/node_modules/@comis/agent/dist/executor/later-queue.d.ts

@@ -1,20 +1,19 @@
 /**
- * STREAM-02 — the `'later'`-priority between-turns queue (push-completion).
+ * The `'later'`-priority between-turns queue (push-completion).
  *
  * Paces work WITHOUT polling token-burn. In-turn (`'now'`) work runs inline;
  * `'later'` work is DEFERRED past the current turn and surfaced via
  * PUSH-COMPLETION — when a deferred item finishes, it ANNOUNCES on the injected
  * `onComplete` callback (the announce-on-done pattern), so the model is
- * NOTIFIED rather than re-prompting in a poll loop (T-221-STREAM-02: a poll
+ * NOTIFIED rather than re-prompting in a poll loop (a poll
  * loop burns tokens every turn it re-checks). The deferred fire is scheduled on
  * the injected {@link TimerPort} and `.unref()`'d, so a pending `'later'` item
- * never holds the event loop / blocks graceful daemon drain (T-221-STREAM-03).
+ * never holds the event loop / blocks graceful daemon drain.
  *
  * ---------------------------------------------------------------------------
- * Q-STREAM-1 Wave-0 SPIKE findings (Task 0) — recorded here per the plan so
- * Tasks 1-2 implement against a confirmed seam:
+ * Design notes — recorded here so changes build against a confirmed seam:
  *
- *   STREAM-01 ordering decision: ASSERT-ONLY (no net-new ordering buffer was
+ *   Ordering decision: ASSERT-ONLY (no net-new ordering buffer is
  *   needed at the message-array level). The SDK
  *   (@earendil-works/pi-coding-agent 0.79.3, exact-pinned in
  *   packages/agent/package.json) already "appends persisted tool results in
@@ -24,12 +23,12 @@
  *   `createMutationSerializer` (./tool-parallelism.ts:109) wraps `execute()`
  *   WITHOUT reordering results — read-only tools pass through concurrently
  *   (tool-parallelism.ts:116), stateful tools serialize through the mutex. So
- *   the cache-stable ordering holds. STREAM-01 therefore PINS that contract
+ *   the cache-stable ordering holds, and the contract is PINNED
  *   with an explicit, tested order-preserving collector
  *   (`createOrderPreservingResultBuffer`, ./tool-parallelism.ts) rather than
- *   adding a redundant message-array buffer.
+ *   a redundant message-array buffer.
  *
- *   STREAM-02 reuse decision: NET-NEW MODULE (this file), REUSING the
+ *   Reuse decision: NET-NEW MODULE (this file), REUSING the
  *   coordinator-progress-fork ANNOUNCE-ON-DONE pattern, not the fork module
  *   itself. coordinator-progress-fork.ts (../spawn/coordinator-progress-fork.ts)
  *   schedules on an injected TimerPort, `.unref()`s the handle
@@ -42,15 +41,10 @@
  *
  *   Pipeline hook: the mutation serializer is invoked via
  *   `applyMutationSerializer` (./executor-tool-pipeline.ts:329) at
- *   ./executor-tool-assembly.ts:776. STREAM-01's contract lives at that
+ *   ./executor-tool-assembly.ts:776. The ordering contract lives at that
  *   boundary. This `'later'` queue is a standalone between-turns scheduler the
  *   executor loop drives — it is NOT wired into the hot per-turn tool-assembly
  *   path, so it adds zero lines to that path.
- *
- *   Capped files confirmed UNTOUCHED: sub-agent-runner.ts (2643 lines, at its
- *   per-file cap) and prompt-assembly.ts (2035 lines, at its per-file cap)
- *   receive NO new lines — STREAM-01 lands in tool-parallelism.ts (231 lines)
- *   and STREAM-02 in this new file.
  * ---------------------------------------------------------------------------
  *
  * INTERNAL to @comis/agent — driven by the executor loop. Not re-exported from
@@ -94,7 +88,7 @@ export interface LaterCompletion<T = unknown> {
      */
     result?: T;
     /**
-     * The error the item's `run()` threw, if any (WR-03). Present ONLY on a failed
+     * The error the item's `run()` threw, if any. Present ONLY on a failed
      * item — a successful completion carries `result` and no `error`. This is the
      * error channel that lets a throwing item be ANNOUNCED (never swallowed, never
      * escaping enqueue/the timer) so the parent can distinguish failure from
@@ -114,7 +108,7 @@ export interface LaterQueueDeps<T = unknown> {
      * PUSH-COMPLETION callback (announce-on-done): invoked with the
      * {@link LaterCompletion} when an item finishes — for `'now'` items
      * synchronously at enqueue, for `'later'` items when the deferred timer
-     * fires. This is the "announce, don't poll" surface (T-221-STREAM-02).
+     * fires. This is the "announce, don't poll" surface.
      */
     onComplete: (completion: LaterCompletion<T>) => void;
     /** Override the between-turns deferral (default {@link DEFAULT_LATER_DELAY_MS}). */
@@ -142,6 +136,6 @@ export interface LaterQueue<T = unknown> {
 /**
  * Create a {@link LaterQueue}. See the module doc for the full
  * push-completion / no-poll / unref'd-timer / priority contract and the
- * Q-STREAM-1 spike findings.
+ * design notes.
  */
 export declare function createLaterQueue<T = unknown>(deps: LaterQueueDeps<T>): LaterQueue<T>;

package/node_modules/@comis/agent/dist/executor/later-queue.js

@@ -9,7 +9,7 @@ export const DEFAULT_LATER_DELAY_MS = 60_000;
 /**
  * Create a {@link LaterQueue}. See the module doc for the full
  * push-completion / no-poll / unref'd-timer / priority contract and the
- * Q-STREAM-1 spike findings.
+ * design notes.
  */
 export function createLaterQueue(deps) {
     const { timers, onComplete } = deps;
@@ -17,7 +17,7 @@ export function createLaterQueue(deps) {
     // Pending deferred timers, keyed by item id so cancel() can drop them all.
     const pending = new Map();
     /**
-     * Run an item's `run()` and ANNOUNCE its outcome through `onComplete` (WR-03).
+     * Run an item's `run()` and ANNOUNCE its outcome through `onComplete`.
      * A thrown error is caught and announced as `{ id, error }` — it NEVER escapes
      * (so a 'now' throw cannot propagate out of enqueue into the executor loop, and
      * a 'later' throw cannot become an unhandled timer exception). A success
@@ -38,13 +38,13 @@ export function createLaterQueue(deps) {
                 // In-turn work: run inline, push-complete synchronously. This is why a
                 // 'now' item enqueued AFTER a 'later' item still runs first — the
                 // 'later' item is only scheduled, never run inline. A throw is isolated
-                // and announced as an error (WR-03) — it never escapes enqueue.
+                // and announced as an error — it never escapes enqueue.
                 safeRun(item);
                 return;
             }
             // 'later': defer past this turn on an unref'd, cancelable timer. When it
             // fires it runs the work and ANNOUNCES (push-completion) — no poll loop.
-            // A throw inside the deferred work is isolated + announced (WR-03), so the
+            // A throw inside the deferred work is isolated + announced, so the
             // item never strands silently and never crashes the timer.
             const handle = timers.setTimeout(() => {
                 pending.delete(item.id);

package/node_modules/@comis/agent/dist/executor/lcd-bootstrap-sweep.d.ts

@@ -1,5 +1,5 @@
 /**
- * DEPTH-03 bootstrap crash-recovery sweep (Plan 174-03).
+ * Bootstrap crash-recovery sweep.
  *
  * Closes the mid-turn crash gap: when the daemon is killed AFTER the JSONL
  * trajectory write but BEFORE the `afterTurn` ingest, those messages never reach
@@ -12,18 +12,18 @@
  * NOT reimplemented here:
  *   - EXACTLY-ONCE is the cursor: the sweep bumps `ingestedLiveLen` to
  *     `live.length`; the subsequent first-turn afterTurn then sees the cursor
- *     already there and appends only genuinely-new messages (Pitfall 6 — no
+ *     already there and appends only genuinely-new messages (no
  *     double-append, no seq collision).
  *   - FAIL-CLOSED on ambiguous transcript identity is the existing
  *     `isScopeSafeForIngest` guard inside `ingestTurnGuarded` (an empty security
  *     column OR conversationId≠sessionKey → refuse + onFailClosed), extending the
  *     `live_store_divergence` family — a mis-derived session key can never
- *     silently reattach this transcript to a prior conversation (T-132-04-02).
- *   - LCD-IS-TRUTH: this is a one-way catch-up SWEEP. The design (§11.3)
+ *     silently reattach this transcript to a prior conversation.
+ *   - LCD-IS-TRUTH: this is a one-way catch-up SWEEP. The design
  *     explicitly REJECTS reconciling the JSONL and the store as co-equal
  *     authorities (no comparison of the JSONL's byte position / modification time
  *     / content hash); the durable LCD store is the single source of truth and is
- *     only appended to, never rewritten or deleted (F1 losslessness).
+ *     only appended to, never rewritten or deleted (losslessness).
  *
  * The new code vs the afterTurn site is only: (1) this distinct trigger that runs
  * ONCE at session start before the first turn, and (2) a distinct content-free

package/node_modules/@comis/agent/dist/executor/lcd-bootstrap-sweep.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * DEPTH-03 bootstrap crash-recovery sweep (Plan 174-03).
+ * Bootstrap crash-recovery sweep.
  *
  * Closes the mid-turn crash gap: when the daemon is killed AFTER the JSONL
  * trajectory write but BEFORE the `afterTurn` ingest, those messages never reach
@@ -13,18 +13,18 @@
  * NOT reimplemented here:
  *   - EXACTLY-ONCE is the cursor: the sweep bumps `ingestedLiveLen` to
  *     `live.length`; the subsequent first-turn afterTurn then sees the cursor
- *     already there and appends only genuinely-new messages (Pitfall 6 — no
+ *     already there and appends only genuinely-new messages (no
  *     double-append, no seq collision).
  *   - FAIL-CLOSED on ambiguous transcript identity is the existing
  *     `isScopeSafeForIngest` guard inside `ingestTurnGuarded` (an empty security
  *     column OR conversationId≠sessionKey → refuse + onFailClosed), extending the
  *     `live_store_divergence` family — a mis-derived session key can never
- *     silently reattach this transcript to a prior conversation (T-132-04-02).
- *   - LCD-IS-TRUTH: this is a one-way catch-up SWEEP. The design (§11.3)
+ *     silently reattach this transcript to a prior conversation.
+ *   - LCD-IS-TRUTH: this is a one-way catch-up SWEEP. The design
  *     explicitly REJECTS reconciling the JSONL and the store as co-equal
  *     authorities (no comparison of the JSONL's byte position / modification time
  *     / content hash); the durable LCD store is the single source of truth and is
- *     only appended to, never rewritten or deleted (F1 losslessness).
+ *     only appended to, never rewritten or deleted (losslessness).
  *
  * The new code vs the afterTurn site is only: (1) this distinct trigger that runs
  * ONCE at session start before the first turn, and (2) a distinct content-free
@@ -84,7 +84,7 @@ export async function bootstrapLcdSweep(args) {
             timestamp: clock.now(),
         });
     }, 
-    // onDivergence: the WR-01 genuine in-session shrink skip (live shorter than
+    // onDivergence: the genuine in-session shrink skip (live shorter than
     // the cursor within the same epoch) — surfaced as a content-free
     // live_store_divergence health signal, same as the afterTurn site.
     () => {
@@ -98,8 +98,8 @@ export async function bootstrapLcdSweep(args) {
         });
     }, 
     // onRebase: a detected epoch re-base that continued appending at the store's
-    // max seq (the v2.17 RR6 path, now also reachable at bootstrap) — a correct
-    // continuation, not degradation. Content-free session_rebase.
+    // max seq (the same rebase path the afterTurn ingest takes, also reachable
+    // at bootstrap) — a correct continuation, not degradation. Content-free session_rebase.
     () => {
         eventBus.emit("context:dag_degraded", {
             conversationId: scope.conversationId,

package/node_modules/@comis/agent/dist/executor/lcd-compaction-helpers.d.ts

@@ -1,11 +1,11 @@
 /**
  * Small store-read helpers for the LCD leaf pass, extracted from
  * lcd-compaction-trigger.ts (file-size invariant: ≤800 lines — the trigger sits
- * at the cap once the OBS-01 summary_language_mismatch emit lands). BYTE-IDENTICAL
- * relocations — same signatures, same bodies, same R4 scoping; no behavior change.
+ * at the cap). BYTE-IDENTICAL
+ * relocations — same signatures, same bodies, same scoping; no behavior change.
  *
  * Both read the injected `ContextStorePort` agent+tenant-scoped via `scope`
- * (WR-02 / 132-03) and are pure beyond that read.
+ * and are pure beyond that read.
  *
  * @module
  */
@@ -13,12 +13,12 @@ import type { ContextStorePort, ContextStoreScope } from "@comis/core";
 /**
  * The most recent summary's content for continuity (the leaf summarizer's 8th
  * param), or undefined when none exists. The read is agent + tenant scoped via
- * `scope` (WR-02). Returns the last summary of ANY kind.
+ * `scope`. Returns the last summary of ANY kind.
  */
 export declare function previousSummaryContent(store: ContextStorePort, scope: ContextStoreScope): string | undefined;
 /**
  * Map the selected chunk's first/last covered message id to the contiguous
- * `context_items` ordinal window `[startOrdinal, endOrdinal]` (the C3 window),
+ * `context_items` ordinal window `[startOrdinal, endOrdinal]`,
  * using the `ordinalById` map built by `resolveContext` from the SAME resolved
  * view the chunk was selected from. `startOrdinal` is the ordinal of the chunk's
  * FIRST message id; `endOrdinal` the LAST. Because both the chunk and the map

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

@@ -2,18 +2,18 @@
 /**
  * Small store-read helpers for the LCD leaf pass, extracted from
  * lcd-compaction-trigger.ts (file-size invariant: ≤800 lines — the trigger sits
- * at the cap once the OBS-01 summary_language_mismatch emit lands). BYTE-IDENTICAL
- * relocations — same signatures, same bodies, same R4 scoping; no behavior change.
+ * at the cap). BYTE-IDENTICAL
+ * relocations — same signatures, same bodies, same scoping; no behavior change.
  *
  * Both read the injected `ContextStorePort` agent+tenant-scoped via `scope`
- * (WR-02 / 132-03) and are pure beyond that read.
+ * and are pure beyond that read.
  *
  * @module
  */
 /**
  * The most recent summary's content for continuity (the leaf summarizer's 8th
  * param), or undefined when none exists. The read is agent + tenant scoped via
- * `scope` (WR-02). Returns the last summary of ANY kind.
+ * `scope`. Returns the last summary of ANY kind.
  */
 export function previousSummaryContent(store, scope) {
     const summaries = store.getSummaries(scope);
@@ -23,7 +23,7 @@ export function previousSummaryContent(store, scope) {
 }
 /**
  * Map the selected chunk's first/last covered message id to the contiguous
- * `context_items` ordinal window `[startOrdinal, endOrdinal]` (the C3 window),
+ * `context_items` ordinal window `[startOrdinal, endOrdinal]`,
  * using the `ordinalById` map built by `resolveContext` from the SAME resolved
  * view the chunk was selected from. `startOrdinal` is the ordinal of the chunk's
  * FIRST message id; `endOrdinal` the LAST. Because both the chunk and the map

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

@@ -1,12 +1,12 @@
 /**
- * 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.
  *
@@ -14,26 +14,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
  */
@@ -48,11 +48,11 @@ import type { SummaryRefRun } from "../context-engine/lcd-condense.js";
 export interface LeafPassOptions {
     /** Utilization fraction that triggers a leaf pass (`contextThreshold`, 0.75). */
     contextThreshold: number;
-    /** Chunk token cap for one leaf (`leafChunkTokens`, 20_000). SUMW-01: clamped
+    /** Chunk token cap for one leaf (`leafChunkTokens`, 20_000). Clamped
      *  PER PASS (in runOneLeafPass) to the RESOLVED summarizer's window minus
      *  `leafTargetTokens` + `SUMMARIZER_PROMPT_OVERHEAD_TOKENS`, floored at
      *  MIN_SHRINKABLE and finite-guarded (an invalid window keeps this configured
-     *  cap — never an unbounded chunk; review WR-05). */
+     *  cap — never an unbounded chunk). */
     leafChunkTokens: number;
     /** Summary token target (`leafTargetTokens`, 1_200) → the SDK `reserveTokens`. */
     leafTargetTokens: number;
@@ -61,7 +61,7 @@ export interface LeafPassOptions {
     /** The model's context window W (the utilization denominator). */
     windowTokens: number;
     /**
-     * B-2: hard cap on leaf passes per afterTurn drain (the infinite-loop backstop).
+     * Hard cap on leaf passes per afterTurn drain (the infinite-loop backstop).
      * The drain re-resolves the view each iteration and stops on the FIRST of:
      * utilization ≤ contextThreshold, a no-progress guard, OR this cap. Optional —
      * defaults to {@link LCD_MAX_LEAF_PASSES_PER_TURN} when absent so existing
@@ -74,8 +74,8 @@ export interface LeafPassOptions {
 /**
  * The model-facing context resolved from the `context_items` view (the SAME
  * source the assembler budgets, `lcd-assembler.ts:101-114,161-168`). This is the
- * single source of truth for BOTH the utilization gate (CR-02) and the chunk
- * selection / ordinal-window mapping (CR-01) — sourcing either half from the raw
+ * single source of truth for BOTH the utilization gate and the chunk
+ * selection / ordinal-window mapping — sourcing either half from the raw
  * lossless `getMessages()` set is the defect that let the trigger fire forever
  * (raw never shrinks) yet make no progress (it re-selects the already-collapsed
  * oldest and fails the ordinal-window lookup).
@@ -89,35 +89,34 @@ export interface ResolvedContext {
      * pass collapses the NEXT chunk instead of re-hitting the first one.
      */
     history: LeafChunkItem[];
-    /** Message id → its `context_items` ordinal (for the exact C3 window). */
+    /** Message id → its `context_items` ordinal (for the exact covered window). */
     ordinalById: Map<string, number>;
     /**
      * Total tokens of the RESOLVED view = every summary-ref + surviving
      * message-ref `tokenCount` — what the model actually sees, so utilization
-     * reflects prior compaction (CR-02), not the un-compacted raw history.
+     * reflects prior compaction, not the un-compacted raw history.
      */
     resolvedTokens: number;
     /**
-     * The per-depth CONTIGUOUS summary-ref runs (Phase 130, C2): every maximal
+     * The per-depth CONTIGUOUS summary-ref runs: every maximal
      * run of `summary`-refs sharing one `depth`; a run BREAKS at any message-ref
      * or depth change. Condense selection reads this list, so utilization, leaf
      * selection AND condense selection all come from ONE resolved read (the "one
      * resolved view is source of truth" invariant); a run is contiguous by
-     * construction, so a condense window can never span a non-contiguous fanout
-     * (Pitfall 3 / T-130-08).
+     * construction, so a condense window can never span a non-contiguous fanout.
      */
     summaryRunsByDepth: SummaryRefRun[];
     /**
      * The SAME oldest-first `getSummaries` snapshot the runs/utilization derive
-     * from (WR-01). The condense trigger reads `previousSummary` from THIS array
+     * from. The condense trigger reads `previousSummary` from THIS array
      * — never a second `getSummaries` call — so the whole pass observes one
      * resolved view; a later, diverged snapshot can never re-decide continuity.
      */
     summaries: LcdSummary[];
 }
 /**
- * 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
@@ -127,9 +126,9 @@ export interface ResolvedContext {
  */
 export declare function resolveContext(store: ContextStorePort, scope: ContextStoreScope): ResolvedContext;
 /**
- * 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).
@@ -138,7 +137,7 @@ export declare function resolveContext(store: ContextStorePort, scope: ContextSt
  * 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
@@ -147,9 +146,9 @@ export declare function resolveContext(store: ContextStorePort, scope: ContextSt
  * @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.
  */
@@ -173,16 +172,16 @@ export interface RunLeafPassAfterTurnParams {
      * — the wiring gate, mirroring how the ingest gates on `deps.contextStore`.
      */
     getSummarizerDeps: (() => 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 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). */
+     *  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;
@@ -193,7 +192,7 @@ export interface RunLeafPassAfterTurnParams {
  * 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}.
  *