comisai 1.0.45 → 1.0.46

package/node_modules/@comis/agent/dist/context-engine/lcd-budget-eviction.d.ts

@@ -1,13 +1,12 @@
 /**
- * LCD budget-eviction unit (Phase 129, A3) — the PURE step-atomic newest-kept fill.
+ * LCD budget-eviction unit — the PURE step-atomic newest-kept fill.
  *
  * {@link evictHistoryUnderBudget} shrinks ONLY the evictable history prefix at the
- * documented `lcd-assembler.ts:110-119` seam: the assembler splits `history`
- * (evictable) from `freshTail` (protected, A1), and this function trims `history`
+ * documented `lcd-assembler.ts` seam: the assembler splits `history`
+ * (evictable) from `freshTail` (protected), and this function trims `history`
  * to fit the available token budget while the assembler concatenates the fresh tail
- * unconditionally — so the live tool exchange always ships even when over budget
- * (A3 "always included even when over budget"). The A3 seam shape the assembler
- * (Plan 05) uses:
+ * unconditionally — so the live tool exchange always ships even when over budget.
+ * The seam shape the assembler uses:
  *
  *   const evictable = historyPrefixForTail(history, liveMessages, tailStart);
  *   const budgeted  = evictHistoryUnderBudget(evictableWithTokens, availableHistoryTokens);
@@ -23,12 +22,12 @@
  * exceed; the kept steps (in original order) are the result. If even the single
  * newest step cannot fit, the WHOLE evictable prefix is dropped (`[]`) — never a
  * half step. This guarantees the kept array never starts with an orphan
- * `toolResult` (T-129-12): the assembler's `sanitizeToolUseResultPairing` (step 6)
- * is the backstop, but A3's contract is to AVOID the split, which this does.
+ * `toolResult`: the assembler's `sanitizeToolUseResultPairing` (step 6)
+ * is the backstop, but this unit's contract is to AVOID the split, which this does.
  *
- * Token authority (Pitfall 2 / T-129-13): tokens are SUPPLIED per message — the
- * caller (Plan 05) sources `tokens` from the stored `LcdMessage.tokenCount` for
- * store-sourced history (counts F3 thinking) and from `estimateMessageTokens` for
+ * Token authority: tokens are SUPPLIED per message — the assembler
+ * sources `tokens` from the stored `LcdMessage.tokenCount` for
+ * store-sourced history (which includes thinking tokens) and from `estimateMessageTokens` for
  * live/fresh-tail messages. This function does NOT re-estimate (which would
  * under-count by excluding thinking), keeping it both pure and budget-correct.
  *
@@ -46,13 +45,13 @@ export interface BudgetItem {
     /** Pre-computed token count for this message (the budget authority). */
     tokens: number;
     /**
-     * WR-01 (Phase 174-04): the durable `lcd_messages.id` of a store-resolved message-ref,
-     * carried from `resolveContextItem` so the DEPTH-01 relevance pass can match a `searchLcd`
+     * The durable `lcd_messages.id` of a store-resolved message-ref,
+     * carried from `resolveContextItem` so the relevance pass can match a `searchLcd`
      * hit to this band item by the hit's STABLE `refId` (= `lcd_messages.id`) instead of a
      * fragile snippet-substring. Absent for live/synthetic items (the fresh tail, a coalesced
      * summary message, a unit fixture) — those simply never id-match and fall to recency, which
      * is the correct floor. The recency fill (`evictHistoryUnderBudget`) NEVER reads this, so
-     * the frontier/mid recency path stays byte-identical (LOCKED #2).
+     * the frontier/mid recency path stays byte-identical.
      */
     lcdId?: string;
 }
@@ -65,7 +64,7 @@ export interface BudgetItem {
  * - Under-budget input is returned unchanged (every message kept).
  * - Over budget, the oldest whole steps are dropped until the kept suffix fits.
  * - If even the single newest step exceeds the budget, the entire prefix is
- *   dropped (`[]`) — the fresh tail still ships via the assembler (A3).
+ *   dropped (`[]`) — the fresh tail still ships via the assembler.
  * - `budgetTokens <= 0` returns `[]`.
  *
  * Pure: the input array is not mutated; the return is a new array; no I/O, no

package/node_modules/@comis/agent/dist/context-engine/lcd-budget-eviction.js

@@ -1,14 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * LCD budget-eviction unit (Phase 129, A3) — the PURE step-atomic newest-kept fill.
+ * LCD budget-eviction unit — the PURE step-atomic newest-kept fill.
  *
  * {@link evictHistoryUnderBudget} shrinks ONLY the evictable history prefix at the
- * documented `lcd-assembler.ts:110-119` seam: the assembler splits `history`
- * (evictable) from `freshTail` (protected, A1), and this function trims `history`
+ * documented `lcd-assembler.ts` seam: the assembler splits `history`
+ * (evictable) from `freshTail` (protected), and this function trims `history`
  * to fit the available token budget while the assembler concatenates the fresh tail
- * unconditionally — so the live tool exchange always ships even when over budget
- * (A3 "always included even when over budget"). The A3 seam shape the assembler
- * (Plan 05) uses:
+ * unconditionally — so the live tool exchange always ships even when over budget.
+ * The seam shape the assembler uses:
  *
  *   const evictable = historyPrefixForTail(history, liveMessages, tailStart);
  *   const budgeted  = evictHistoryUnderBudget(evictableWithTokens, availableHistoryTokens);
@@ -24,12 +23,12 @@
  * exceed; the kept steps (in original order) are the result. If even the single
  * newest step cannot fit, the WHOLE evictable prefix is dropped (`[]`) — never a
  * half step. This guarantees the kept array never starts with an orphan
- * `toolResult` (T-129-12): the assembler's `sanitizeToolUseResultPairing` (step 6)
- * is the backstop, but A3's contract is to AVOID the split, which this does.
+ * `toolResult`: the assembler's `sanitizeToolUseResultPairing` (step 6)
+ * is the backstop, but this unit's contract is to AVOID the split, which this does.
  *
- * Token authority (Pitfall 2 / T-129-13): tokens are SUPPLIED per message — the
- * caller (Plan 05) sources `tokens` from the stored `LcdMessage.tokenCount` for
- * store-sourced history (counts F3 thinking) and from `estimateMessageTokens` for
+ * Token authority: tokens are SUPPLIED per message — the assembler
+ * sources `tokens` from the stored `LcdMessage.tokenCount` for
+ * store-sourced history (which includes thinking tokens) and from `estimateMessageTokens` for
  * live/fresh-tail messages. This function does NOT re-estimate (which would
  * under-count by excluding thinking), keeping it both pure and budget-correct.
  *
@@ -48,7 +47,7 @@
  * - Under-budget input is returned unchanged (every message kept).
  * - Over budget, the oldest whole steps are dropped until the kept suffix fits.
  * - If even the single newest step exceeds the budget, the entire prefix is
- *   dropped (`[]`) — the fresh tail still ships via the assembler (A3).
+ *   dropped (`[]`) — the fresh tail still ships via the assembler.
  * - `budgetTokens <= 0` returns `[]`.
  *
  * Pure: the input array is not mutated; the return is a new array; no I/O, no

package/node_modules/@comis/agent/dist/context-engine/lcd-condense.d.ts

@@ -1,5 +1,5 @@
 /**
- * LCD condensation unit (Phase 130, C2) — the depth>0 summary-of-summaries.
+ * LCD condensation unit — the depth>0 summary-of-summaries.
  *
  * The SIBLING of `lcd-leaf-summarizer.ts`. Where the leaf pass condenses a
  * contiguous run of raw MESSAGES into a depth-0 leaf, this module condenses a
@@ -17,33 +17,33 @@
  *     depth-0 folds until a tier of contiguous depth-1 summaries reaches fanout,
  *     then THAT tier folds into depth-2, and so on. Returns `undefined` when no
  *     depth meets the effective fanout (the pass is a no-op). A run split by a
- *     message-ref is TWO separate runs (Pitfall 3): only a single contiguous run
- *     of length ≥ fanout qualifies — so the selected window can never span a
+ *     message-ref is TWO separate runs: only a single contiguous run of length
+ *     ≥ fanout qualifies — so the selected window can never span a
  *     non-contiguous fanout.
  *
  *  2. {@link summarizeCondensedChunk} — run the SAME mandatory 3-level escalation
  *     contract as `summarizeLeafChunk` (normal → aggressive → deterministic
  *     truncation), but with two differences: (a) the before-size is the STORED
- *     `Σ children.tokenCount` (NEVER a re-estimate of the concatenation — Pitfall
- *     2/5: the stored counts include F3 thinking the child leaves budgeted), and
+ *     `Σ children.tokenCount` (NEVER a re-estimate of the concatenation — the
+ *     stored counts include the thinking tokens the child leaves budgeted), and
  *     (b) the summarizer input is the child `content` strings (fed as ONE pseudo
  *     `user` message so the injected seam summarizes summaries-of-summaries). The
  *     produced `tokenCount` is ALWAYS strictly < `Σ children.tokenCount` (the
  *     escalation invariant) — an oversized/throwing summarizer falls through to a
  *     bounded, marker-prefixed Level-3 floor that re-uses the leaf's proven
- *     estimator-measured truncation loop (the WR-01/IN-03 fix: the BOUND is the
- *     token estimator itself, not a hand-derived chars-per-token ratio).
+ *     estimator-measured truncation loop (the BOUND is the token estimator
+ *     itself, not a hand-derived chars-per-token ratio).
  *
  * The LLM summarizer is INJECTED via the SAME {@link LeafSummarizerDeps} seam the
  * leaf pass uses (the `summarize` function summarizes whatever messages it is
- * given — a leaf chunk OR a single concatenated summary-of-summaries), so Phase
- * 132 swaps spend governance / a circuit breaker in ONE place for both tiers and
- * the trigger threads no new daemon dependency.
+ * given — a leaf chunk OR a single concatenated summary-of-summaries), so spend
+ * governance / a circuit breaker swap in at ONE place for both tiers and the
+ * trigger threads no new daemon dependency.
  *
  * Architecture cut (agent↛memory): this file imports ONLY agent-side modules +
- * the SDK + core TYPES; it NEVER imports `@comis/memory` (the build cut, Pitfall
- * 7). It NEVER logs child `content` or the produced summary `content` — ids,
- * counts, level, and durations only (AGENTS.md §2.2; T-130-09). It reads NO wall
+ * the SDK + core TYPES; it NEVER imports `@comis/memory` (the build cut). It
+ * NEVER logs child `content` or the produced summary `content` — ids,
+ * counts, level, and durations only (AGENTS.md §2.2). It reads NO wall
  * clock of its own — timestamps are derived purely upstream from the child rows.
  *
  * @module
@@ -54,7 +54,7 @@ import { type LeafSummarizer, type LeafSummarizerDeps } from "./lcd-leaf-summari
  * {@link LeafSummarizer} (the function summarizes whatever `AgentMessage[]` it is
  * handed — for condensation that is ONE pseudo-`user` message concatenating the
  * child summary content). Aliased (not re-declared) so the trigger can pass the
- * SAME `LeafSummarizerDeps` for both the leaf and condense passes (the Phase-132
+ * SAME `LeafSummarizerDeps` for both the leaf and condense passes (the
  * spend-governance swap point is shared).
  */
 export type CondenseSummarizer = LeafSummarizer;
@@ -81,8 +81,8 @@ export interface CondenseChildSummary {
     /**
      * Untrusted-content flag — propagated to the condensed parent (`taint = OR`).
      * Carried on the unit from the SINGLE resolved-view `getSummaries` snapshot so
-     * the trigger derives `taint` WITHOUT a second store read (WR-01: the one
-     * resolved view is the source of truth — a later, possibly-diverged snapshot
+     * the trigger derives `taint` WITHOUT a second store read (the one resolved
+     * view is the source of truth — a later, possibly-diverged snapshot
      * must never re-decide taint propagation).
      */
     taint: boolean;
@@ -90,8 +90,8 @@ export interface CondenseChildSummary {
 /**
  * One CONTIGUOUS same-depth run of summary-refs in the resolved `context_items`
  * view. A run BREAKS at any message-ref or at a depth change, so every run is a
- * single contiguous window `[startOrdinal, endOrdinal]` — the structural Pitfall-3
- * guard (a non-contiguous fanout can never form one run).
+ * single contiguous window `[startOrdinal, endOrdinal]` — the structural
+ * guarantee that a non-contiguous fanout can never form one run.
  */
 export interface SummaryRefRun {
     /** The shared depth of every child in this run. */
@@ -124,13 +124,13 @@ export interface CondenseSummaryResult {
  * the soft `condensedMinFanout` normally, dropping to the hard
  * `condensedMinFanoutHard` lower bound when context pressure is HIGH
  * (`pressureHigh`) — mirroring the leaf side's soft/hard knobs. Ties (multiple
- * qualifying runs at the same deepest depth — a Pitfall-3 layout where one depth
+ * qualifying runs at the same deepest depth — a layout where one depth
  * has several disjoint runs) break by the OLDEST run (lowest `startOrdinal`).
  * Returns `undefined` when no run meets the effective fanout (the pass is a no-op).
  *
- * DEEPEST, not shallowest (the FIX): selecting the shallowest always re-folded the
+ * DEEPEST, not shallowest: selecting the shallowest would always re-fold the
  * depth-0 leaves a turn keeps producing, so an accumulated contiguous run of
- * depth-1 summaries was never folded into depth-2 — max depth stuck at 1 forever.
+ * depth-1 summaries would never fold into depth-2 — max depth stuck at 1 forever.
  * Preferring the deepest QUALIFYING run means depth-0 keeps folding until a tier of
  * ≥fanout contiguous depth-1 summaries exists, at which point THAT tier (now the
  * deepest qualifying run) folds into depth-2, and so on — a bounded, monotone climb
@@ -139,8 +139,7 @@ export interface CondenseSummaryResult {
  * Because every {@link SummaryRefRun} is contiguous by construction (the
  * resolved-view walk breaks a run at any message-ref or depth change), the
  * returned run's `[startOrdinal, endOrdinal]` is always a contiguous
- * `context_items` window — a non-contiguous fanout can NEVER be selected
- * (Pitfall 3 / T-130-08).
+ * `context_items` window — a non-contiguous fanout can NEVER be selected.
  *
  * @param runs - the per-depth contiguous summary-ref runs from the resolved view
  * @param condensedMinFanout - the SOFT minimum run length (relaxed-pressure trigger)
@@ -152,19 +151,19 @@ export declare function selectCondensableTier(runs: SummaryRefRun[], condensedMi
 /**
  * Condense a contiguous run of child summaries via the mandatory 3-level
  * escalation. ALWAYS returns a summary whose token count is STRICTLY LESS than
- * the run's `Σ children.tokenCount` (the C2 escalation invariant) — accepting an
+ * the run's `Σ children.tokenCount` (the escalation invariant) — accepting an
  * LLM summary only when it actually reduces, and otherwise falling through to the
  * deterministic, bounded Level-3 truncation.
  *
  * Unlike `summarizeLeafChunk`, the summarizer input is the child `content`
  * strings concatenated into ONE pseudo-`user` message (a summary OF summaries)
  * and the before-size is the STORED `Σ children.tokenCount` — NEVER a re-estimate
- * of the concatenation (Pitfall 2/5: the stored counts include the F3 thinking
+ * of the concatenation (the stored counts include the thinking tokens
  * the child leaves budgeted at their own write time).
  *
- * B-4 (260605-ney): the EFFECTIVE summarize target is bounded below the run's
+ * The EFFECTIVE summarize target is bounded below the run's
  * rendered shrink ceiling ({@link computeShrinkBounds}) so the model is never asked
- * to write more than it compresses (the spurious-floor fix mirrored from the leaf),
+ * to write more than it compresses (the same spurious-floor guard as the leaf tier),
  * and the accept-test ceiling is the RENDERED 4:1 measure — self-consistent with
  * the candidate's units. The STORED `Σ children.tokenCount` stays the budget /
  * floor authority: the deterministic Level-3 floor must still beat it.
@@ -182,12 +181,12 @@ export declare function summarizeCondensedChunk(children: CondenseChildSummary[]
 /**
  * Construct the PRODUCTION {@link CondenseSummarizer} — the seam that wraps the
  * SDK `generateSummary` for the condense tier. Clones `buildLeafSummarizeFn`
- * (`lcd-leaf-summarizer.ts:576-604`) verbatim, swapping ONLY the instructions
+ * (`lcd-leaf-summarizer.ts`) verbatim, swapping ONLY the instructions
  * builder; the `generateSummary` 8-arg call shape is unchanged (`previousSummary`
- * is the 8th param). Phase 132 swaps THIS factory's output for a spend-governed /
- * circuit-broken variant — the same single seam as the leaf.
+ * is the 8th param). THIS factory's output is the single seam where a
+ * spend-governed / circuit-broken variant swaps in — the same seam as the leaf.
  *
- * B-5 twin (260605-ney): `generateSummary` needs a REAL pi-ai `Model<any>` (with
+ * `generateSummary` needs a REAL pi-ai `Model<any>` (with
  * the provider-client runtime it invokes), NOT the 4-field
  * {@link CompactionModelSnapshot} (which lacks that runtime and throws at call
  * time). The primary path resolves `deps.getRealModel()` — the executor-resolved

package/node_modules/@comis/agent/dist/context-engine/lcd-condense.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * LCD condensation unit (Phase 130, C2) — the depth>0 summary-of-summaries.
+ * LCD condensation unit — the depth>0 summary-of-summaries.
  *
  * The SIBLING of `lcd-leaf-summarizer.ts`. Where the leaf pass condenses a
  * contiguous run of raw MESSAGES into a depth-0 leaf, this module condenses a
@@ -18,33 +18,33 @@
  *     depth-0 folds until a tier of contiguous depth-1 summaries reaches fanout,
  *     then THAT tier folds into depth-2, and so on. Returns `undefined` when no
  *     depth meets the effective fanout (the pass is a no-op). A run split by a
- *     message-ref is TWO separate runs (Pitfall 3): only a single contiguous run
- *     of length ≥ fanout qualifies — so the selected window can never span a
+ *     message-ref is TWO separate runs: only a single contiguous run of length
+ *     ≥ fanout qualifies — so the selected window can never span a
  *     non-contiguous fanout.
  *
  *  2. {@link summarizeCondensedChunk} — run the SAME mandatory 3-level escalation
  *     contract as `summarizeLeafChunk` (normal → aggressive → deterministic
  *     truncation), but with two differences: (a) the before-size is the STORED
- *     `Σ children.tokenCount` (NEVER a re-estimate of the concatenation — Pitfall
- *     2/5: the stored counts include F3 thinking the child leaves budgeted), and
+ *     `Σ children.tokenCount` (NEVER a re-estimate of the concatenation — the
+ *     stored counts include the thinking tokens the child leaves budgeted), and
  *     (b) the summarizer input is the child `content` strings (fed as ONE pseudo
  *     `user` message so the injected seam summarizes summaries-of-summaries). The
  *     produced `tokenCount` is ALWAYS strictly < `Σ children.tokenCount` (the
  *     escalation invariant) — an oversized/throwing summarizer falls through to a
  *     bounded, marker-prefixed Level-3 floor that re-uses the leaf's proven
- *     estimator-measured truncation loop (the WR-01/IN-03 fix: the BOUND is the
- *     token estimator itself, not a hand-derived chars-per-token ratio).
+ *     estimator-measured truncation loop (the BOUND is the token estimator
+ *     itself, not a hand-derived chars-per-token ratio).
  *
  * The LLM summarizer is INJECTED via the SAME {@link LeafSummarizerDeps} seam the
  * leaf pass uses (the `summarize` function summarizes whatever messages it is
- * given — a leaf chunk OR a single concatenated summary-of-summaries), so Phase
- * 132 swaps spend governance / a circuit breaker in ONE place for both tiers and
- * the trigger threads no new daemon dependency.
+ * given — a leaf chunk OR a single concatenated summary-of-summaries), so spend
+ * governance / a circuit breaker swap in at ONE place for both tiers and the
+ * trigger threads no new daemon dependency.
  *
  * Architecture cut (agent↛memory): this file imports ONLY agent-side modules +
- * the SDK + core TYPES; it NEVER imports `@comis/memory` (the build cut, Pitfall
- * 7). It NEVER logs child `content` or the produced summary `content` — ids,
- * counts, level, and durations only (AGENTS.md §2.2; T-130-09). It reads NO wall
+ * the SDK + core TYPES; it NEVER imports `@comis/memory` (the build cut). It
+ * NEVER logs child `content` or the produced summary `content` — ids,
+ * counts, level, and durations only (AGENTS.md §2.2). It reads NO wall
  * clock of its own — timestamps are derived purely upstream from the child rows.
  *
  * @module
@@ -62,13 +62,13 @@ import { estimateMessageTokens, estimateMessageChars, } from "../safety/token-es
  * the soft `condensedMinFanout` normally, dropping to the hard
  * `condensedMinFanoutHard` lower bound when context pressure is HIGH
  * (`pressureHigh`) — mirroring the leaf side's soft/hard knobs. Ties (multiple
- * qualifying runs at the same deepest depth — a Pitfall-3 layout where one depth
+ * qualifying runs at the same deepest depth — a layout where one depth
  * has several disjoint runs) break by the OLDEST run (lowest `startOrdinal`).
  * Returns `undefined` when no run meets the effective fanout (the pass is a no-op).
  *
- * DEEPEST, not shallowest (the FIX): selecting the shallowest always re-folded the
+ * DEEPEST, not shallowest: selecting the shallowest would always re-fold the
  * depth-0 leaves a turn keeps producing, so an accumulated contiguous run of
- * depth-1 summaries was never folded into depth-2 — max depth stuck at 1 forever.
+ * depth-1 summaries would never fold into depth-2 — max depth stuck at 1 forever.
  * Preferring the deepest QUALIFYING run means depth-0 keeps folding until a tier of
  * ≥fanout contiguous depth-1 summaries exists, at which point THAT tier (now the
  * deepest qualifying run) folds into depth-2, and so on — a bounded, monotone climb
@@ -77,8 +77,7 @@ import { estimateMessageTokens, estimateMessageChars, } from "../safety/token-es
  * Because every {@link SummaryRefRun} is contiguous by construction (the
  * resolved-view walk breaks a run at any message-ref or depth change), the
  * returned run's `[startOrdinal, endOrdinal]` is always a contiguous
- * `context_items` window — a non-contiguous fanout can NEVER be selected
- * (Pitfall 3 / T-130-08).
+ * `context_items` window — a non-contiguous fanout can NEVER be selected.
  *
  * @param runs - the per-depth contiguous summary-ref runs from the resolved view
  * @param condensedMinFanout - the SOFT minimum run length (relaxed-pressure trigger)
@@ -113,19 +112,19 @@ export function selectCondensableTier(runs, condensedMinFanout, condensedMinFano
 /**
  * Condense a contiguous run of child summaries via the mandatory 3-level
  * escalation. ALWAYS returns a summary whose token count is STRICTLY LESS than
- * the run's `Σ children.tokenCount` (the C2 escalation invariant) — accepting an
+ * the run's `Σ children.tokenCount` (the escalation invariant) — accepting an
  * LLM summary only when it actually reduces, and otherwise falling through to the
  * deterministic, bounded Level-3 truncation.
  *
  * Unlike `summarizeLeafChunk`, the summarizer input is the child `content`
  * strings concatenated into ONE pseudo-`user` message (a summary OF summaries)
  * and the before-size is the STORED `Σ children.tokenCount` — NEVER a re-estimate
- * of the concatenation (Pitfall 2/5: the stored counts include the F3 thinking
+ * of the concatenation (the stored counts include the thinking tokens
  * the child leaves budgeted at their own write time).
  *
- * B-4 (260605-ney): the EFFECTIVE summarize target is bounded below the run's
+ * The EFFECTIVE summarize target is bounded below the run's
  * rendered shrink ceiling ({@link computeShrinkBounds}) so the model is never asked
- * to write more than it compresses (the spurious-floor fix mirrored from the leaf),
+ * to write more than it compresses (the same spurious-floor guard as the leaf tier),
  * and the accept-test ceiling is the RENDERED 4:1 measure — self-consistent with
  * the candidate's units. The STORED `Σ children.tokenCount` stays the budget /
  * floor authority: the deterministic Level-3 floor must still beat it.
@@ -136,8 +135,8 @@ export function selectCondensableTier(runs, condensedMinFanout, condensedMinFano
  * @returns the condensed summary + escalation level + token count
  */
 export async function summarizeCondensedChunk(children, deps, opts) {
-    // Before-size authority: the STORED per-child tokenCounts (Pitfall 2/5) — NOT a
-    // re-estimate of the concatenation (which would exclude the F3 thinking the
+    // Before-size authority: the STORED per-child tokenCounts — NOT a
+    // re-estimate of the concatenation (which would exclude the thinking tokens the
     // child leaves counted, under-stating the chunk and risking a non-shrinking
     // "reduction" that is actually larger than the real covered tokens). This stays
     // the BUDGET / floor authority — the deterministic Level-3 floor still beats it.
@@ -145,11 +144,11 @@ export async function summarizeCondensedChunk(children, deps, opts) {
     // The ONE pseudo-message the injected summarizer sees: the child summary
     // content strings, clearly separated. A summary OF summaries.
     const pseudoMessage = buildCondenseInput(children);
-    // B-4 (260605-ney): self-consistent shrink bounds from the run's RENDERED chars
+    // Self-consistent shrink bounds from the run's RENDERED chars
     // (the one concatenated pseudo-message — already prose). The accept ceiling is
     // measured the SAME way the candidate is (4:1), and the EFFECTIVE target is
     // bounded below the run so the summarizer is never asked to write more than it
-    // compresses (the dominant fix mirrored from the leaf tier).
+    // compresses (the same spurious-floor guard the leaf tier applies).
     const renderedChars = estimateMessageChars(pseudoMessage);
     const { shrinkCeilingTokens, effectiveReserveTokens } = computeShrinkBounds(renderedChars, opts.reserveTokens);
     // --- Level 1: full summarization, up to 1 + COMPACTION_MAX_RETRIES attempts.
@@ -202,7 +201,7 @@ function buildCondenseInput(children) {
 /**
  * Attempt one condensation summarizer call and accept it ONLY when the produced
  * summary is strictly smaller (in tokens) than `shrinkCeilingTokens` — the run's
- * RENDERED 4:1 measure (B-4, 260605-ney), so the candidate (a 4:1-prose user
+ * RENDERED 4:1 measure, so the candidate (a 4:1-prose user
  * string) and the ceiling are like-for-like units. Non-fatal: a throwing
  * summarizer is caught (WARN, errorKind `dependency`) and reported as "not
  * accepted" so the ladder escalates rather than failing. Mirrors `tryLevel` in
@@ -240,8 +239,8 @@ async function tryCondenseLevel(deps, pseudoMessage, opts, shrinkCeilingTokens,
  * LLM.
  *
  * The bound is the token ESTIMATOR ITSELF, not a hand-derived chars-per-token
- * ceiling (the WR-01 / IN-03 fix — copied from `buildDeterministicFallback` in
- * `lcd-leaf-summarizer.ts:476-507`): truncate the note in a loop that re-measures
+ * ceiling (matching `buildDeterministicFallback` in
+ * `lcd-leaf-summarizer.ts`): truncate the note in a loop that re-measures
  * with `estimateMessageTokens` until it is strictly below the ceiling. The marker
  * survives intact for any normal-size run; only a sub-marker run truncates it
  * (and a run too small to ever shrink is unreachable here — the trigger gates on
@@ -302,12 +301,12 @@ function buildCondenseInstructions(aggressive) {
 /**
  * Construct the PRODUCTION {@link CondenseSummarizer} — the seam that wraps the
  * SDK `generateSummary` for the condense tier. Clones `buildLeafSummarizeFn`
- * (`lcd-leaf-summarizer.ts:576-604`) verbatim, swapping ONLY the instructions
+ * (`lcd-leaf-summarizer.ts`) verbatim, swapping ONLY the instructions
  * builder; the `generateSummary` 8-arg call shape is unchanged (`previousSummary`
- * is the 8th param). Phase 132 swaps THIS factory's output for a spend-governed /
- * circuit-broken variant — the same single seam as the leaf.
+ * is the 8th param). THIS factory's output is the single seam where a
+ * spend-governed / circuit-broken variant swaps in — the same seam as the leaf.
  *
- * B-5 twin (260605-ney): `generateSummary` needs a REAL pi-ai `Model<any>` (with
+ * `generateSummary` needs a REAL pi-ai `Model<any>` (with
  * the provider-client runtime it invokes), NOT the 4-field
  * {@link CompactionModelSnapshot} (which lacks that runtime and throws at call
  * time). The primary path resolves `deps.getRealModel()` — the executor-resolved
@@ -321,7 +320,7 @@ function buildCondenseInstructions(aggressive) {
  */
 export function buildCondenseSummarizeFn(deps) {
     return async (messages, opts) => {
-        // B-5: resolve a REAL Model<any> for generateSummary — prefer the cheaper
+        // Resolve a REAL Model<any> for generateSummary — prefer the cheaper
         // override's real Model when present; else the PRIMARY real model (the
         // executor-resolved `resolvedModel`, via deps.getRealModel). The bare 4-field
         // CompactionModelSnapshot is NEVER passed to generateSummary (it lacks the

package/node_modules/@comis/agent/dist/context-engine/lcd-fresh-tail-bound.d.ts

@@ -1,20 +1,20 @@
 /**
- * Fresh-tail size bounding for the LCD `dag` assembler (B-8 + Issue-1).
+ * Fresh-tail size bounding for the LCD `dag` assembler.
  *
- * The fresh tail ships UNCONDITIONALLY (A1/A3) and the dag path runs neither
+ * The fresh tail ships UNCONDITIONALLY and the dag path runs neither
  * the observation masker nor the dead-content evictor (pipeline-only), so a
  * turn whose last steps carry a huge tool output — or a huge user/assistant
- * message (the Issue-1 session brick: one over-window message rides the fresh
+ * message (the session brick: one over-window message rides the fresh
  * tail forever) — would overflow the model window before any budget pass sees
  * it. This module bounds each oversized fresh-tail message via the shared
  * {@link createToolResultSizeGuard} factories (head+tail+honest marker — NOT
  * hand-rolled), with the per-message cap derived from the turn's
  * `availableHistoryTokens` (see {@link computeFreshTailCapChars}).
  *
- * Invariant reconciliation (the lcd-assembler call site enumerates A1/A2/A3):
- * the guards are referential no-ops below the cap; only text CONTENT shrinks
- * (no message removed/reordered, no `toolCallId` touched, non-text blocks
- * pass through); the LCD store keeps the full content losslessly so the
+ * Invariant reconciliation (the lcd-assembler call site enumerates the full
+ * list): the guards are referential no-ops below the cap; only text CONTENT
+ * shrinks (no message removed/reordered, no `toolCallId` touched, non-text
+ * blocks pass through); the LCD store keeps the full content losslessly so the
  * masked region stays `ctx_expand`-recoverable.
  *
  * Extracted from lcd-assembler.ts to keep that file under the 800-line cap.
@@ -25,25 +25,25 @@ import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { ComisLogger } from "@comis/core";
 /**
  * The per-message char cap for this turn's fresh-tail bounding:
- * `max(FLOOR, min(B-8 constant, 0.8 × H in chars))`. For frontier/mid H is
- * huge, so the cap degrades to the historical 100K-char B-8 constant —
- * byte-identical behavior there.
+ * `max(FLOOR, min(absolute per-result constant, 0.8 × H in chars))`. For
+ * frontier/mid H is huge, so the cap degrades to the absolute 100K-char
+ * {@link LCD_FRESH_TAIL_MAX_TOOL_RESULT_CHARS} constant.
  */
 export declare function computeFreshTailCapChars(availableHistoryTokens: number): number;
 /**
- * B-8 + Issue-1: bound oversized messages inside the unconditional fresh tail.
+ * Bound oversized messages inside the unconditional fresh tail.
  * Pure + non-mutating — for each fresh-tail message whose total TEXT exceeds
  * `cap`, run the matching shared {@link createToolResultSizeGuard} factory
  * (head+tail+honest marker) and return a NEW message carrying the truncated
- * content; every message that fits passes through REFERENTIALLY unchanged (A1
- * preserved for what fits). The guard's marker carries the lossless-recovery
- * hint via `toolHint`, so the model is honestly told the full content is
- * recoverable.
+ * content; every message that fits passes through REFERENTIALLY unchanged
+ * (verbatim fidelity preserved for what fits). The guard's marker carries the
+ * lossless-recovery hint via `toolHint`, so the model is honestly told the
+ * full content is recoverable.
  *
  * Covered roles:
- *  - `toolResult` (the original B-8 class — huge file reads / command dumps),
+ *  - `toolResult` (huge file reads / command dumps),
  *    via the default-marker guard;
- *  - `user` / `assistant` (the Issue-1 session-brick class — one pasted
+ *  - `user` / `assistant` (the session-brick class — one pasted
  *    document larger than the effective window), via the message-marker
  *    guard. String-shorthand content is bounded by round-tripping through a
  *    single text block and restored to string shape.
@@ -51,7 +51,7 @@ export declare function computeFreshTailCapChars(availableHistoryTokens: number)
  * Only text CONTENT shrinks here — no message is removed/reordered, no
  * `toolCallId` is touched, and non-text blocks (toolCall, image, …) pass
  * through the guard untouched — so the later `sanitizeToolUseResultPairing`
- * (A2) still re-pairs every result with its `tool_use`.
+ * still re-pairs every result with its `tool_use`.
  *
  * @param freshTail - the verbatim fresh-tail slice (the last N steps of the live array)
  * @param cap - the per-message char cap from {@link computeFreshTailCapChars}
@@ -64,46 +64,47 @@ export declare function boundFreshTailMessages(freshTail: AgentMessage[], cap: n
     charsRemoved: number;
 };
 /**
- * ISSUE #1 (2026-06-22): bound the PROTECTED fresh tail's TOTAL tokens to
+ * Bound the PROTECTED fresh tail's TOTAL tokens to
  * `residualTokens` by dropping the OLDEST whole STEP at a time, keeping the newest
  * contiguous run that fits. The fresh tail ships UNCONDITIONALLY (the eviction cannot
- * trim it), and {@link boundFreshTailMessages} (B-8) bounds only individual oversized
+ * trim it), and {@link boundFreshTailMessages} bounds only individual oversized
  * MESSAGES — not the SUM across turns — so on a tiny window where the system prompt
  * dominates, a handful of small recent turns accumulate past the residual and overflow
- * the window (the live nano failure: freshTail grew 1438→2369→3488…→exhaust). This
- * enforces the total directly.
+ * the window (the observed nano failure mode: freshTail grows 1438→2369→3488…→exhaust).
+ * This enforces the total directly.
  *
  * Operates on the ALREADY per-message-bounded fresh tail (call AFTER
- * boundFreshTailMessages) so a single oversized message B-8 shrank to fit is counted at
- * its bounded size, NOT dropped (Issue1-A/D). ALWAYS keeps the LAST step (the current
+ * boundFreshTailMessages) so a single oversized message the per-message guard shrank
+ * to fit is counted at its bounded size, NOT dropped. ALWAYS keeps the LAST step (the current
  * live turn ships even when it alone exceeds the residual — the pre-flight then degrades
  * it honestly as oversized_input, never silently). A STEP is a leading non-`toolResult`
  * message plus its immediately-following `toolResult`s (mirrors
  * lcd-budget-eviction.groupIntoSteps / freshTailBoundaryIndex) so a tool_use/tool_result
  * pair is never split. Pure: reads the input, returns a NEW array (or the same ref when
- * nothing is dropped — the A1 no-op for everything that fits).
+ * nothing is dropped — a verbatim no-op for everything that fits).
  *
- * @param freshTail - the per-message-bounded fresh-tail messages (B-8 output).
+ * @param freshTail - the per-message-bounded fresh-tail messages ({@link boundFreshTailMessages} output).
  * @param residualTokens - the room the protected tail may occupy (≈ window − S − floorHeadroom − preamble).
  * @returns the newest contiguous fresh-tail steps that fit (≥ the last step).
  */
 export declare function boundFreshTailTotalToResidual(freshTail: AgentMessage[], residualTokens: number): AgentMessage[];
 /**
- * ISSUE #1/#3/#3b: compute the protected-fresh-tail residual and trim the tail to it.
+ * Compute the protected-fresh-tail residual and trim the tail to it.
  *
  * The residual = effectiveWindow − systemTokens − FLOOR output headroom − preamble. The
  * floor headroom comes from {@link computeFloorOutputHeadroom} with the model's ACTUAL
- * reasoningStyle — the IDENTICAL value the pre-flight throws against (#3b: a native model
+ * reasoningStyle — the IDENTICAL value the pre-flight throws against (a native model
  * reserves the native "low" floor incl. the reasoning reserve; under-counting it ships a
  * tail the pre-flight exhausts on). The trim measures with the SAME factored estimator the
- * pre-flight uses (#3: estimator parity, no fudge). Frontier/mid: an Infinite window → the
- * residual is undefined → returns the tail UNCHANGED (no-op → byte-identical, LOCKED #2).
+ * pre-flight uses (estimator parity, no fudge). Frontier/mid: an Infinite window → the
+ * residual is undefined → returns the tail UNCHANGED (no-op → byte-identical, the locked
+ * frontier/mid contract).
  *
  * Owns the diagnostic DEBUG (`step:lcd-freshtail-bound`) so the assembler body stays thin
  * and the residual inputs (reasoningStyle / floorHeadroom / residual / before+after factored
- * sizes) are one-read visible — the obs-excellence loop for this bug class.
+ * sizes) are one-read visible from a single log line.
  *
- * @param freshTail - the per-message-bounded (B-8) fresh-tail messages.
+ * @param freshTail - the per-message-bounded fresh-tail messages.
  * @param ctx - window/S/reasoningStyle/preamble + logging context.
  * @returns the trimmed fresh tail (or the same reference on a no-op).
  */