comisai 1.0.44 → 1.0.46

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/breakpoint-placement.js

@@ -54,11 +54,11 @@ export function placeSingleBreakpoint(messages, retention, skipCacheWrite) {
 /**
  * Place cache breakpoints at strategic positions within the messages array.
  *
- * Budget = 4 − system − SDK-auto(last message) = 2 Comis message markers (cache C-FIX-4):
+ * Budget = 4 − system − SDK-auto(last message) = 2 Comis message markers:
  * - Semi-stable ANCHOR: a FIXED early boundary — the compaction summary if present, else the
- *   2nd user message (cache C-FIX-10). Pinned (never moves) so it is cached once and never
- *   re-written. A cheap durable fallback; superseded the drifting 50%-token/C-FIX-2b anchor
- *   whose movement churn became the dominant waste once #C2/#C4 removed the recurring drops.
+ *   2nd user message. Pinned (never moves) so it is cached once and never
+ *   re-written. A cheap durable fallback; a fixed anchor beats a drifting one (e.g. a
+ *   50%-token split) because every anchor move re-writes the whole [0..anchor] prefix.
  * - RECENT: the second-to-last user message, adjacent to the SDK's last-message marker; the
  *   load-bearing marker whose fresh write caches the whole growing prefix.
  *
@@ -78,10 +78,10 @@ export function placeCacheBreakpoints(messages, options) {
     let placed = 0;
     // Anthropic honors at most 4 cache_control breakpoints. TWO are already consumed outside
     // this function: the SYSTEM/tools prefix marker AND the SDK's auto-marker on the LAST message
-    // (the tail). So Comis may place at most 2 message markers — placing 3 pushed the total to 5,
-    // and Anthropic SILENTLY DROPPED the tail-reaching markers, freezing the cache at the early
-    // markers and re-writing the entire growing suffix every turn (O(N²); cache C-FIX-4, 2026-06-18,
-    // confirmed live: single-tail marker read 54961→142941). Budget = 4 − system − SDK = 2.
+    // (the tail). So Comis may place at most 2 message markers — placing 3 pushes the total to 5,
+    // and Anthropic SILENTLY DROPS the tail-reaching markers, freezing the cache at the early
+    // markers and re-writing the entire growing suffix every turn (O(N²); confirmed
+    // live: single-tail marker read 54961→142941). Budget = 4 − system − SDK = 2.
     const remaining = Math.min(maxBreakpoints, 2);
     // Find the second-to-last user message for breakpoint #3
     let secondToLastUserIdx = -1;
@@ -116,15 +116,15 @@ export function placeCacheBreakpoints(messages, options) {
     // Uses content-aware char/token ratio: structured content (tool results,
     // tool use JSON) tokenizes at ~3 chars/token; natural language at ~4.
     //
-    // Deliberately UNFACTORED (TOK-01): this measure feeds only cache-marker
+    // Deliberately UNFACTORED (flat-by-design): this measure feeds only cache-marker
     // PLACEMENT — the relative 50% cumulative split (factor approximately
     // cancels: same measure in numerator and denominator) and the absolute
     // `>= minTokens` minimum-cacheable gates, where a dense-script under-count
     // merely skips/defers a breakpoint (cache efficiency, never budget/fit;
     // an over-placed marker on a too-small segment is equally a provider
     // no-op). Factoring it would shift WHERE markers land for dense scripts —
-    // a live-measurable cache-behavior change deferred to the multilingual
-    // milestone's later phases (Phase 181 candidate), not a correctness fix.
+    // a live-measurable cache-behavior change deliberately deferred, not a
+    // correctness fix.
     function estimateTokensInRange(start, end) {
         let tokens = 0;
         for (let i = start; i <= end && i < messages.length; i++) {
@@ -137,20 +137,20 @@ export function placeCacheBreakpoints(messages, options) {
                     : false;
             const ratio = isStructured ? CHARS_PER_TOKEN_RATIO_STRUCTURED : CHARS_PER_TOKEN_RATIO;
             if (typeof content === "string") {
-                // flat-by-design: cache-placement heuristic, never budget/fit — see function docstring (TOK-01)
+                // flat-by-design: cache-placement heuristic, never budget/fit — see function docstring
                 tokens += Math.ceil(content.length / ratio);
             }
             else if (Array.isArray(content)) {
                 for (const block of content) {
                     if (typeof block.text === "string") {
-                        // flat-by-design: cache-placement heuristic, never budget/fit — see function docstring (TOK-01)
+                        // flat-by-design: cache-placement heuristic, never budget/fit — see function docstring
                         tokens += Math.ceil(block.text.length / ratio);
                     }
                     // tool_result blocks nest text inside block.content[]
                     if (Array.isArray(block.content)) {
                         for (const inner of block.content) {
                             if (typeof inner.text === "string") {
-                                // flat-by-design: cache-placement heuristic, never budget/fit — see function docstring (TOK-01)
+                                // flat-by-design: cache-placement heuristic, never budget/fit — see function docstring
                                 tokens += Math.ceil(inner.text.length / ratio);
                             }
                         }
@@ -162,16 +162,16 @@ export function placeCacheBreakpoints(messages, options) {
     }
     // Semi-stable anchor: a STABLE early boundary cached ONCE as a durable fallback.
     //
-    // cache C-FIX-10 (2026-06-19): this SUPERSEDES the C-FIX-2b "latest user ≤ block W" + 50%-token
-    // anchor. Those provided a LARGE fallback for the recurring read-drops of the pre-#C2/#C4 era,
-    // but the anchor MOVED — the 50%-token point drifted, and there was a one-time 50%→pinned regime
-    // jump when the conversation crossed the ~20-block lookback threshold — and EVERY move re-writes
-    // [0..anchor]. Once #C2 (replay-thinking) + #C4 (inline-recall) eliminated the recurring drops,
-    // that big moving anchor became pure overhead. A FIXED anchor that never re-writes wins (live A/B,
-    // 2 rounds, identical coding+recall session: cache-WRITE −~20%, READ +~3%). The recent + SDK
-    // markers carry the bulk; the anchor is just a cheap, never-rewritten fallback. Prefer a
-    // compaction summary (a natural stable boundary); otherwise pin to the 2nd user message — a FIXED
-    // position (the conversation is append-only, so it never moves turn-to-turn).
+    // The anchor is deliberately FIXED, never a moving boundary (e.g. a 50%-cumulative-token
+    // split): a moving anchor drifts turn-to-turn — plus a one-time regime jump when the
+    // conversation crosses the ~20-block lookback threshold — and EVERY move re-writes
+    // [0..anchor]. With the replay-thinking and inline-recall strips eliminating recurring
+    // cached-prefix drops, a big moving anchor is pure overhead. A FIXED anchor that never
+    // re-writes wins (live A/B, 2 rounds, identical coding+recall session: cache-WRITE −~20%,
+    // READ +~3%). The recent + SDK markers carry the bulk; the anchor is just a cheap,
+    // never-rewritten fallback. Prefer a compaction summary (a natural stable boundary);
+    // otherwise pin to the 2nd user message — a FIXED position (the conversation is
+    // append-only, so it never moves turn-to-turn).
     let semiStableIdx = -1;
     for (let i = 0; i < messages.length; i++) {
         const msg = messages[i];
@@ -204,7 +204,7 @@ export function placeCacheBreakpoints(messages, options) {
             semiStableIdx = -1;
     }
     // Breakpoint #1 (semi-stable anchor): a stable early boundary (compaction summary or the
-    // C-FIX-2b-anchored ≤window-block position). Caches [0..semiStable] as a durable fallback.
+    // pinned 2nd-user-message position). Caches [0..semiStable] as a durable fallback.
     if (semiStableIdx >= 0 && placed < remaining) {
         const tokensToPoint = estimateTokensInRange(0, semiStableIdx);
         if (tokensToPoint >= minTokens) {
@@ -216,8 +216,8 @@ export function placeCacheBreakpoints(messages, options) {
     // ADJACENT to the SDK's last-message marker. This is the load-bearing marker: its fresh write
     // caches [0..recent] (the WHOLE prefix — a fresh write does not need a nearby prior breakpoint),
     // and it chains the SDK tail marker + the previous turn's cache (≤window apart) so the cached
-    // prefix advances with the conversation. cache C-FIX-4 (2026-06-18): this was previously placed
-    // AFTER the bridge and dropped when the budget filled, stranding the tail → O(N²) re-writes.
+    // prefix advances with the conversation. Placement priority is load-bearing: if this marker
+    // loses the budget race to earlier candidates, the tail is stranded → O(N²) re-writes.
     if (secondToLastUserIdx >= 0 && placed < remaining) {
         const startFrom = semiStableIdx >= 0 ? semiStableIdx + 1 : 0;
         const tokensInRange = estimateTokensInRange(startFrom, secondToLastUserIdx);
@@ -236,13 +236,13 @@ export function placeCacheBreakpoints(messages, options) {
             placed++;
         }
     }
-    // NOTE (cache C-FIX-4, 2026-06-18): the former mid-point + lookback-gap-bridge breakpoints were
-    // REMOVED. They were added (C-FIX-2) to keep every inter-marker gap ≤ the 20-block window, but
-    // live evidence disproved the premise: a fresh cache write at a breakpoint caches the WHOLE prefix
-    // up to it regardless of distance from the prior breakpoint, so the gap does NOT cause a miss.
-    // What DID cause the freeze was placing too many markers (semi-stable + bridge + recent = 3),
-    // which — with the system marker and the SDK's auto-marker on the last message — exceeded
-    // Anthropic's 4-breakpoint limit, so the tail-reaching markers were silently dropped. Capping
+    // NOTE: there are deliberately NO mid-point / lookback-gap-bridge breakpoints. Keeping every
+    // inter-marker gap ≤ the 20-block window sounds necessary, but live evidence disproves the
+    // premise: a fresh cache write at a breakpoint caches the WHOLE prefix up to it regardless of
+    // distance from the prior breakpoint, so the gap does NOT cause a miss.
+    // What DOES cause a cache freeze is placing too many markers (semi-stable + bridge + recent = 3),
+    // which — with the system marker and the SDK's auto-marker on the last message — exceeds
+    // Anthropic's 4-breakpoint limit, so the tail-reaching markers are silently dropped. Capping
     // Comis to 2 (anchor + recent) keeps the total at 4 and lets the recent marker reach the tail.
     return placed;
 }

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/cache-breakpoints.d.ts

@@ -44,8 +44,8 @@ export declare const sessionPrefixStability: Map<string, {
     callCount?: number;
     /** Call indices where a non-benign cached-region message mutation was observed.
      *  Windowed (recent only) so a ONCE-PER-TURN mutation accumulates across turn
-     *  boundaries even though within-turn calls are clean (the #C2 blind spot: the
-     *  consecutive counter reset on benign within-turn growth, so it never fired). */
+     *  boundaries even though within-turn calls are clean (a consecutive counter
+     *  would reset on benign within-turn growth and never fire). */
     cacheMutations?: number[];
 }>;
 export declare function clearSessionPrefixStability(sessionKey: string): void;

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/cache-breakpoints.js

@@ -241,7 +241,7 @@ export function maybePromoteBreakpoints(messages, tracker, sessionKey, threshold
     // Monotonicity guard: cannot promote to 1h if tools/system use 5m
     if (resolvedRetention !== "long")
         return 0;
-    // Non-Anthropic body guard (codex turn-abort regression 2026-06-14): the
+    // Non-Anthropic body guard (live-observed codex turn-abort regression): the
     // OpenAI responses / openai-codex request body has `input`, not a `messages`
     // array, so `messages` is undefined here. cache_control breakpoint promotion
     // is Anthropic-only — no-op rather than throw `reading 'length'`, which the

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/factory.js

@@ -68,15 +68,16 @@ export function createRequestBodyInjector(config, logger) {
                 ?? isAnthropicFamily(model.provider);
             const needsResponsesApiInjection = isResponsesApiProvider(model);
             // ALL OpenAI Responses-family providers drive the same `input` item array and need the
-            // auto-cached prefix stabilised (cache #C4-OAI): native openai (`openai-responses`),
+            // auto-cached prefix stabilised: native openai (`openai-responses`),
             // Azure (`azure-openai-responses`), and codex (`openai-codex-responses` /
             // provider:"openai-codex"). The cache-breakpoint machinery is correctly skipped for them
             // (running cache_control on a Responses body strips type:"function" tools -> backend 400);
             // we install onPayload only to defer the per-turn inline-recall block off the user turns
             // onto an uncached trailing item so the prefix does not collapse to the instructions+tools
-            // floor every time the recalled memory rotates (see the deferral block below). NOTE: this
-            // was previously gated `provider === "openai-codex"` only, which left the native `openai`
-            // provider (gpt-5.5 -> openai-responses) unstabilised — 5 floor-collapses live.
+            // floor every time the recalled memory rotates (see the deferral block below). NOTE: the
+            // gate must cover the whole Responses family — gating on `provider === "openai-codex"`
+            // alone leaves the native `openai` provider (gpt-5.5 -> openai-responses) unstabilised
+            // (5 floor-collapses observed live).
             const needsResponsesInputStabilizer = usesResponsesInputApi(model);
             if (!needsCacheBreakpoints && !needsResponsesApiInjection && !needsResponsesInputStabilizer) {
                 return next(model, context, options);
@@ -184,7 +185,7 @@ export function createRequestBodyInjector(config, logger) {
                         if (recallStripped > 0) {
                             logger.debug({ recallStripped, sessionKey: config.sessionKey }, "Stripped transient inline-recall from cached prefix");
                         }
-                        // cache break #C1/#C2: strip thinking from EVERY replayed assistant message
+                        // Strip thinking from EVERY replayed assistant message
                         // (including the active/last one) so the cached prefix matches the durable (LCD)
                         // no-thinking form and never mutates when an assistant transitions active→historical.
                         const thinkingStripped = stripReplayThinking(result.messages);
@@ -195,9 +196,9 @@ export function createRequestBodyInjector(config, logger) {
                             config.onContentModification?.();
                             logger.debug({ thinkingStripped, sessionKey: config.sessionKey }, "Stripped replay thinking from cached prefix");
                         }
-                        // cache #C4: move the current turn's inline-recall block onto the UNCACHED tail
+                        // Move the current turn's inline-recall block onto the UNCACHED tail
                         // (a trailing block after the cache fence) so it's visible to the model but never
-                        // cached — preventing the prefix mutation when C-FIX-3 strips it next turn.
+                        // cached — preventing the prefix mutation when the history strip removes it next turn.
                         const recallDeferred = deferRecallToUncachedTail(result.messages);
                         if (recallDeferred > 0) {
                             logger.debug({ recallDeferred, sessionKey: config.sessionKey }, "Deferred inline-recall to the uncached tail");
@@ -247,8 +248,8 @@ export function createRequestBodyInjector(config, logger) {
                     // Token-ceiling microcompact (size trigger)
                     if (needsCacheBreakpoints)
                         runTokenCeilingMicrocompact(result, config, logger);
-                    // Every-turn microcompact (EFF-01) -- unconditional Tier-0 pass, fence-protected
-                    // (EFF-03). Keeps the coordinator's context flat every turn, not just after an
+                    // Every-turn microcompact -- unconditional Tier-0 pass, fence-protected.
+                    // Keeps the coordinator's context flat every turn, not just after an
                     // idle gap; cache-stable (clears nothing at/below the fence; byte-stable placeholder).
                     if (needsCacheBreakpoints)
                         runEveryTurnMicrocompact(result, config, logger);
@@ -340,7 +341,7 @@ export function createRequestBodyInjector(config, logger) {
                     injectServiceTier(result, needsResponsesApiInjection, config.fastMode);
                     // Concern 4: store (Responses API + storeCompletions)
                     injectStoreFlag(result, needsResponsesApiInjection, config.storeCompletions);
-                    // Cache #C4-OAI: stabilise the OpenAI Responses auto-cached prefix.
+                    // Stabilise the OpenAI Responses auto-cached prefix.
                     // The per-turn inline-recall block ("[Relevant context from memory: ...]") is
                     // prepended to the CURRENT user turn (envelope-wrapper) but recall is TRANSIENT —
                     // the LCD/history rebuild emits each user turn CLEAN. So the latest user item is sent
@@ -361,11 +362,11 @@ export function createRequestBodyInjector(config, logger) {
                         // 1. Defensive: strip recall from any HISTORICAL user item (no-op when history is
                         //    already clean, which it is when recall is transient).
                         const strippedCount = stripTransientRecallFromResponsesInput(inputItems);
-                        // 2. Recall #C4-OAI: defer recall on the LATEST user item to a trailing (uncached,
+                        // 2. Recall deferral: defer recall on the LATEST user item to a trailing (uncached,
                         //    never persisted) item, so the latest item is byte-identical to its future
                         //    historical clean form and the auto-cached prefix never mutates at the turn boundary.
                         const deferred = deferRecallToTrailingResponsesItem(inputItems);
-                        // 3. Reasoning #C5-OAI: strip ALL replayed reasoning items — ONLY on the native
+                        // 3. Reasoning strip: strip ALL replayed reasoning items — ONLY on the native
                         //    openai / Azure Responses path (needsResponsesApiInjection). With `store:false`
                         //    the SDK keeps reasoning for recent turns but drops it from aging turns -> an
                         //    early-index prefix mutation -> floor-collapse. Removing them consistently every

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/marker-upgrade.d.ts

@@ -30,7 +30,7 @@ export interface UpgradeSdkMarkersParams {
      * otherwise pay the 1h premium for nothing.
      *
      * When undefined (caller has no counter wired), the gate is skipped
-     * to preserve legacy behavior — promotion fires as before.
+     * and promotion fires unconditionally.
      */
     callCount?: number;
     logger: ComisLogger;
@@ -44,8 +44,8 @@ export interface UpgradeSdkMarkersParams {
  *
  * The callCount gate prevents paying the 1h premium on first-turn writes
  * that may be evicted server-side before a second turn even fires. When
- * the caller does not supply callCount, the gate is skipped (legacy
- * behavior preserved).
+ * the caller does not supply callCount, the gate is skipped and promotion
+ * fires unconditionally.
  *
  * Mutates `result.system` and `result.tools` in place.
  */

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/marker-upgrade.js

@@ -32,8 +32,8 @@ function upgradeMarkers(blocks) {
  *
  * The callCount gate prevents paying the 1h premium on first-turn writes
  * that may be evicted server-side before a second turn even fires. When
- * the caller does not supply callCount, the gate is skipped (legacy
- * behavior preserved).
+ * the caller does not supply callCount, the gate is skipped and promotion
+ * fires unconditionally.
  *
  * Mutates `result.system` and `result.tools` in place.
  */
@@ -44,8 +44,8 @@ export function upgradeSdkMarkers(params) {
     // callCount gate: promote only from turn 2 onward.
     // First-turn writes that get evicted server-side would otherwise pay
     // the 1h premium for nothing. The gate is skipped when callCount is
-    // undefined to preserve behavior for callers that have not been
-    // updated yet.
+    // undefined so callers without a wired turn counter still get the
+    // promotion.
     if (callCount !== undefined && callCount < 2) {
         logger.debug({ modelId, sessionKey, callCount }, "SDK-UPGRADE: skipped 1h promotion on first-turn write (callCount<2)");
         return;

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/microcompact.d.ts

@@ -8,9 +8,9 @@
  *  - `runTokenCeilingMicrocompact`: token-budget trigger. Runs when the
  *    estimated context size exceeds the configured ceiling. Does NOT call
  *    `onAdaptiveRetentionReset` because the cache may still be warm.
- *  - `runEveryTurnMicrocompact` (EFF-01): UNCONDITIONAL every-turn pass. Runs
+ *  - `runEveryTurnMicrocompact`: UNCONDITIONAL every-turn pass. Runs
  *    on every turn regardless of TTL/ceiling so the long-running coordinator's
- *    context stays flat, not only after an idle gap. Fence-protected (EFF-03)
+ *    context stays flat, not only after an idle gap. Fence-protected
  *    and, like the ceiling trigger, does NOT reset adaptive retention (the cache
  *    may still be warm). Clears tool results only — never thinking blocks, which
  *    `stripReplayThinking` already handles on the cached prefix.
@@ -39,14 +39,14 @@ export declare function runTimeBasedMicrocompact(result: Record<string, unknown>
  */
 export declare function runTokenCeilingMicrocompact(result: Record<string, unknown>, config: RequestBodyInjectorConfig, logger: ComisLogger): void;
 /**
- * Every-turn microcompact (EFF-01) -- unconditional Tier-0 pass.
+ * Every-turn microcompact -- unconditional Tier-0 pass.
  *
  * Unlike the TTL and token-ceiling triggers (which only fire after an idle gap or
  * once the context crosses a size ceiling), this runs on EVERY turn so a long-running
  * coordinator's context stays flat continuously rather than only recovering after an
  * idle period. It clears stale compactable tool results beyond the keep window.
  *
- * Cache-stable (EFF-03): threads `getCacheFenceIndex()` so it never clears at/below
+ * Cache-stable: threads `getCacheFenceIndex()` so it never clears at/below
  * the cached prefix (a clear inside the fence would re-pay cache_creation on the whole
  * suffix every turn), keeps the last `observationKeepWindow` results, and -- because the
  * cleared-result placeholder is byte-stable and frozen by tool-call-id -- the cached

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/microcompact.js

@@ -9,9 +9,9 @@
  *  - `runTokenCeilingMicrocompact`: token-budget trigger. Runs when the
  *    estimated context size exceeds the configured ceiling. Does NOT call
  *    `onAdaptiveRetentionReset` because the cache may still be warm.
- *  - `runEveryTurnMicrocompact` (EFF-01): UNCONDITIONAL every-turn pass. Runs
+ *  - `runEveryTurnMicrocompact`: UNCONDITIONAL every-turn pass. Runs
  *    on every turn regardless of TTL/ceiling so the long-running coordinator's
- *    context stays flat, not only after an idle gap. Fence-protected (EFF-03)
+ *    context stays flat, not only after an idle gap. Fence-protected
  *    and, like the ceiling trigger, does NOT reset adaptive retention (the cache
  *    may still be warm). Clears tool results only — never thinking blocks, which
  *    `stripReplayThinking` already handles on the cached prefix.
@@ -67,7 +67,7 @@ export function runTokenCeilingMicrocompact(result, config, logger) {
     const msgs = result.messages;
     if (!Array.isArray(msgs))
         return;
-    // flat-by-design: aggregate in-request hygiene trigger over estimateContextChars; the request-body accounting roots (estimateBlockTokens) are factored (TOK-01)
+    // flat-by-design: aggregate in-request hygiene trigger over estimateContextChars; the request-body accounting roots (estimateBlockTokens) are factored
     const estimatedTokens = estimateContextChars(msgs) / CHARS_PER_TOKEN_RATIO;
     if (estimatedTokens <= config.microcompactTokenCeiling)
         return;
@@ -82,14 +82,14 @@ export function runTokenCeilingMicrocompact(result, config, logger) {
     }
 }
 /**
- * Every-turn microcompact (EFF-01) -- unconditional Tier-0 pass.
+ * Every-turn microcompact -- unconditional Tier-0 pass.
  *
  * Unlike the TTL and token-ceiling triggers (which only fire after an idle gap or
  * once the context crosses a size ceiling), this runs on EVERY turn so a long-running
  * coordinator's context stays flat continuously rather than only recovering after an
  * idle period. It clears stale compactable tool results beyond the keep window.
  *
- * Cache-stable (EFF-03): threads `getCacheFenceIndex()` so it never clears at/below
+ * Cache-stable: threads `getCacheFenceIndex()` so it never clears at/below
  * the cached prefix (a clear inside the fence would re-pay cache_creation on the whole
  * suffix every turn), keeps the last `observationKeepWindow` results, and -- because the
  * cleared-result placeholder is byte-stable and frozen by tool-call-id -- the cached

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/monotonic-ttl.d.ts

@@ -14,12 +14,12 @@
  * any marker, it emits a WARN log with `errorKind: "internal"` —
  * indicating an upstream placement bug to investigate.
  *
- * Background: commit 7d12f26b ("Fix E") added a 1h cache anchor for
- * user messages carrying `<<<UNTRUSTED_…>>>` blocks (large stable RAG
- * memory recall). When the UNTRUSTED block lands on the LAST user
- * message in a long conversation, `placeCacheBreakpoints` still places
- * a 5m marker on an earlier user message — violating monotonicity and
- * producing the production 400 at daemon.1.log:439:
+ * Background: the UNTRUSTED_ anchor (breakpoint-orchestration.ts) places
+ * a 1h cache marker on user messages carrying `<<<UNTRUSTED_…>>>` blocks
+ * (large stable RAG memory recall). When the UNTRUSTED block lands on the
+ * LAST user message in a long conversation, `placeCacheBreakpoints` can
+ * still place a 5m marker on an earlier user message — violating
+ * monotonicity and producing a live-observed production 400:
  *
  *   messages.10.content.0.cache_control.ttl:
  *     a ttl='1h' cache_control block must not come after a ttl='5m'

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/monotonic-ttl.js

@@ -15,12 +15,12 @@
  * any marker, it emits a WARN log with `errorKind: "internal"` —
  * indicating an upstream placement bug to investigate.
  *
- * Background: commit 7d12f26b ("Fix E") added a 1h cache anchor for
- * user messages carrying `<<<UNTRUSTED_…>>>` blocks (large stable RAG
- * memory recall). When the UNTRUSTED block lands on the LAST user
- * message in a long conversation, `placeCacheBreakpoints` still places
- * a 5m marker on an earlier user message — violating monotonicity and
- * producing the production 400 at daemon.1.log:439:
+ * Background: the UNTRUSTED_ anchor (breakpoint-orchestration.ts) places
+ * a 1h cache marker on user messages carrying `<<<UNTRUSTED_…>>>` blocks
+ * (large stable RAG memory recall). When the UNTRUSTED block lands on the
+ * LAST user message in a long conversation, `placeCacheBreakpoints` can
+ * still place a 5m marker on an earlier user message — violating
+ * monotonicity and producing a live-observed production 400:
  *
  *   messages.10.content.0.cache_control.ttl:
  *     a ttl='1h' cache_control block must not come after a ttl='5m'

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/prefix-stability.d.ts

@@ -24,7 +24,8 @@ import type { RequestBodyInjectorConfig } from "./types.js";
  * Run the prefix-stability diagnostic. Mutates the module-level
  * `sessionPrefixStability` map. Logs a WARN when a cached-region message mutates on
  * THRESHOLD+ calls within a recent WINDOW — catching both a persistent same-message
- * mutation and a once-per-turn mutation at a different message each turn (cache #C2),
- * across the FULL cached prefix (not just the previous fence region).
+ * mutation and a once-per-turn mutation at a different message each turn (the
+ * replay-thinking incident shape), across the FULL cached prefix (not just the
+ * previous fence region).
  */
 export declare function runPrefixStabilityDiagnostic(result: Record<string, unknown>, config: RequestBodyInjectorConfig, logger: ComisLogger): void;

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/prefix-stability.js

@@ -92,21 +92,21 @@ function firstDivergentMessage(prev, curr) {
 /**
  * Classify the cache-poison content carried by a divergent prefix message —
  * the known per-request-varying classes that destabilize the cached prefix.
- * Productizes the ad-hoc PREFIXDBG instrumentation used to root-cause C-FIX-3:
- * the next prefix-instability incident is diagnosable from this one WARN line.
+ * Productizes the ad-hoc instrumentation used to root-cause a live
+ * prefix-instability incident: the next one is diagnosable from this one WARN line.
  */
 function classifyPrefixMutation(msg, prevSig, currSig) {
     if (!msg)
         return "unknown";
     const classes = [];
-    // Structural delta first (the cause C-FIX-3's content-pattern classifier missed):
+    // Structural delta first (a cause a content-pattern-only classifier misses):
     // a thinking block disappearing or content shrinking between turns means microcompaction
     // (clearStaleThinkingBlocks / clearStaleToolResults) mutated a CACHED message.
     const p = parseSig(prevSig);
     const c = parseSig(currSig);
     if (p && c) {
         // r1→r0 = the inline-recall block was stripped as a user message went historical
-        // (C-FIX-3) — a one-time transient-by-design transition. Classify it FIRST and on its
+        // — a one-time transient-by-design transition. Classify it FIRST and on its
         // own so the diagnostic can treat it as benign (it would otherwise read as content-cleared).
         if (p.r > c.r)
             return "inline-recall";
@@ -131,8 +131,9 @@ function classifyPrefixMutation(msg, prevSig, currSig) {
  * Run the prefix-stability diagnostic. Mutates the module-level
  * `sessionPrefixStability` map. Logs a WARN when a cached-region message mutates on
  * THRESHOLD+ calls within a recent WINDOW — catching both a persistent same-message
- * mutation and a once-per-turn mutation at a different message each turn (cache #C2),
- * across the FULL cached prefix (not just the previous fence region).
+ * mutation and a once-per-turn mutation at a different message each turn (the
+ * replay-thinking incident shape), across the FULL cached prefix (not just the
+ * previous fence region).
  */
 export function runPrefixStabilityDiagnostic(result, config, logger) {
     if (!config.sessionKey || !Array.isArray(result.messages))
@@ -142,17 +143,17 @@ export function runPrefixStabilityDiagnostic(result, config, logger) {
         return;
     const msgs = result.messages;
     const lastIdx = msgs.length - 1;
-    // FULL-array per-message hashes/sigs (NOT fence-limited). The old Case-A check only
-    // re-verified [0..prev.fence] and was blind to a mutation in the newly-promoted
-    // (prev.fence, fence] region — exactly where cache #C2's thinking-strip transition lived.
+    // FULL-array per-message hashes/sigs (NOT fence-limited). A check that only
+    // re-verifies [0..prev.fence] is blind to a mutation in the newly-promoted
+    // (prev.fence, fence] region — exactly where the replay-thinking strip transition lives.
     const fullHashes = hashEachMessage(msgs, lastIdx);
     const fullSigs = structEachMessage(msgs, lastIdx);
     const prev = sessionPrefixStability.get(config.sessionKey);
     const callCount = (prev?.callCount ?? 0) + 1;
     // Accumulate cached-region mutations over a WINDOW of recent calls rather than
-    // CONSECUTIVE calls. cache #C2 mutated a DIFFERENT historical assistant at each turn
-    // boundary while within-turn calls were clean; the old consecutive counter reset on
-    // every benign within-turn call, so a once-per-turn mutation never reached its threshold.
+    // CONSECUTIVE calls. The replay-thinking incident mutated a DIFFERENT historical assistant
+    // at each turn boundary while within-turn calls were clean; a consecutive counter resets on
+    // every benign within-turn call, so a once-per-turn mutation never reaches its threshold.
     const WINDOW = 10;
     const THRESHOLD = 3;
     if (!prev || diagFenceIdx < prev.fenceIdx) {
@@ -169,8 +170,8 @@ export function runPrefixStabilityDiagnostic(result, config, logger) {
         const pSig = prev.fullSigs?.[fd];
         const cSig = fullSigs[fd];
         const mutationClass = classifyPrefixMutation(msgs[fd], pSig, cSig);
-        // inline-recall is transient BY DESIGN — C-FIX-3 strips it from a user message the turn
-        // AFTER it carried the current turn's recall. That is a one-time transition per message,
+        // inline-recall is transient BY DESIGN — the history strip removes it from a user message
+        // the turn AFTER it carried the current turn's recall. That is a one-time transition per message,
         // not a recurring bug, so it must NOT accumulate toward the WARN.
         if (!mutationClass.includes("inline-recall")) {
             mutations = [...mutations, callCount];
@@ -191,11 +192,11 @@ export function runPrefixStabilityDiagnostic(result, config, logger) {
 }
 /**
  * Emit the "Unstable prefix detected" WARN, naming the divergent prefix message and its
- * cache-poison class. Productized PREFIXDBG: an operator reading this one line knows WHICH
+ * cache-poison class. An operator reading this one line knows WHICH
  * message mutated and WHY (inline-recall / datetime-preamble / thinking-block / content-cleared),
  * instead of re-deriving it with ad-hoc logging. Fires on a windowed count of cached-region
  * mutations (not consecutive), so a ONCE-PER-TURN mutation at a different message each turn
- * (cache #C2) accumulates here instead of slipping past a consecutive counter.
+ * accumulates here instead of slipping past a consecutive counter.
  */
 function emitUnstableWarn(logger, sessionKey, mutationCount, window, firstDivergentIndex, prevSig, currSig, mutationClass) {
     logger.warn({
@@ -208,7 +209,7 @@ function emitUnstableWarn(logger, sessionKey, mutationCount, window, firstDiverg
         // operator sees exactly what changed at the divergent message without ad-hoc logging.
         prevSig,
         currSig,
-        hint: `Cached-prefix content mutated at message #${firstDivergentIndex} [${mutationClass}] (${mutationCount} cached-region mutations in the last ${window} calls): ${prevSig ?? "?"} → ${currSig ?? "?"}. Already-sent content inside the cache fence must be byte-stable — re-sending it changed wastes the cache write (see C-FIX-3 / stripReplayThinking). A once-per-turn mutation at a DIFFERENT message each turn still accumulates here.`,
+        hint: `Cached-prefix content mutated at message #${firstDivergentIndex} [${mutationClass}] (${mutationCount} cached-region mutations in the last ${window} calls): ${prevSig ?? "?"} → ${currSig ?? "?"}. Already-sent content inside the cache fence must be byte-stable — re-sending it changed wastes the cache write (see stripReplayThinking). A once-per-turn mutation at a DIFFERENT message each turn still accumulates here.`,
         errorKind: "internal",
     }, "Unstable prefix detected");
 }

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/store-flag.d.ts

@@ -28,10 +28,10 @@ export declare function isResponsesApiProvider(model: {
  *
  * Broader than {@link isResponsesApiProvider} — which intentionally covers only the two
  * providers that take service_tier/store injection. The recall-defer prefix stabilizer
- * (cache #C4-OAI) must run for ALL Responses providers: it was originally gated
- * `provider === "openai-codex"` only, so switching the agent to the native `openai` provider
- * (gpt-5.5 → `openai-responses`) silently left the defer OFF and the per-turn inline-recall
- * poisoned the auto-cached prefix again. Callers gate the actual mutation on
+ * must run for ALL Responses providers: gating it on `provider === "openai-codex"` alone
+ * silently leaves the native `openai` provider (gpt-5.5 → `openai-responses`) without the
+ * defer, and the per-turn inline-recall
+ * poisons the auto-cached prefix. Callers gate the actual mutation on
  * `Array.isArray(result.input)`, so this only needs to decide onPayload installation + intent.
  */
 export declare function usesResponsesInputApi(model: {

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/store-flag.js

@@ -33,10 +33,10 @@ export function isResponsesApiProvider(model) {
  *
  * Broader than {@link isResponsesApiProvider} — which intentionally covers only the two
  * providers that take service_tier/store injection. The recall-defer prefix stabilizer
- * (cache #C4-OAI) must run for ALL Responses providers: it was originally gated
- * `provider === "openai-codex"` only, so switching the agent to the native `openai` provider
- * (gpt-5.5 → `openai-responses`) silently left the defer OFF and the per-turn inline-recall
- * poisoned the auto-cached prefix again. Callers gate the actual mutation on
+ * must run for ALL Responses providers: gating it on `provider === "openai-codex"` alone
+ * silently leaves the native `openai` provider (gpt-5.5 → `openai-responses`) without the
+ * defer, and the per-turn inline-recall
+ * poisons the auto-cached prefix. Callers gate the actual mutation on
  * `Array.isArray(result.input)`, so this only needs to decide onPayload installation + intent.
  */
 export function usesResponsesInputApi(model) {

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/token-estimation.d.ts

@@ -10,8 +10,8 @@
  * `CHARS_PER_TOKEN_RATIO * scriptTokenFactor(text)`. For non-text blocks
  * (images, tool_use JSON) falls back to JSON.stringify length over the same
  * factored divisor — the factor always scans the EXACT string whose length
- * is divided (TOK-01). The 3.5 ratio better matches Anthropic's tokenizer
- * than the previously used 4.0 ratio; the script factor (1.0 for pure
+ * is divided. The 3.5 ratio matches Anthropic's tokenizer better than a
+ * naive 4.0; the script factor (1.0 for pure
  * ASCII, <1 for dense non-Latin scripts) keeps the estimate conservative
  * for Hebrew/Arabic/CJK content.
  *

package/node_modules/@comis/agent/dist/executor/stream-wrappers/request-body/token-estimation.js

@@ -13,8 +13,8 @@ import { CHARS_PER_TOKEN_RATIO } from "../../../context-engine/index.js";
  * `CHARS_PER_TOKEN_RATIO * scriptTokenFactor(text)`. For non-text blocks
  * (images, tool_use JSON) falls back to JSON.stringify length over the same
  * factored divisor — the factor always scans the EXACT string whose length
- * is divided (TOK-01). The 3.5 ratio better matches Anthropic's tokenizer
- * than the previously used 4.0 ratio; the script factor (1.0 for pure
+ * is divided. The 3.5 ratio matches Anthropic's tokenizer better than a
+ * naive 4.0; the script factor (1.0 for pure
  * ASCII, <1 for dense non-Latin scripts) keeps the estimate conservative
  * for Hebrew/Arabic/CJK content.
  *