billion-context-pi 0.1.63 → 0.1.64-pr.357.148

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import { type Config, type Prompts } from "acp-kernel";
 import type { CompressReasoningConfig } from "./reasoning-drop.js";
+import type { DegenerationGuardConfig } from "./degeneration.js";
 import type { ThrottleRetryConfig } from "./throttle-retry.js";
 /** Per-role delegate defaults. Lets long-lived automation pin a cheaper or
  *  more capable model and a thinking level per delegate role, so the main
@@ -222,6 +223,15 @@ export interface AdapterConfig {
      *  warn=3, abort=5. Stops greedy small models looping on byte-identical
      *  tool calls (issue #308). */
     repetitionGuard?: boolean | RepetitionGuardConfig;
+    /** Character-level degenerate-repeat guard (see DegenerationGuardConfig).
+     *  Collapses long single-codepoint runs (e.g. 4655×「【」) in assistant
+     *  text/thinking of the outgoing view and injects a one-shot recovery notice
+     *  after a degenerated turn — breaking the abort loop where pi replays the
+     *  degenerated thinking back to the provider on every request (issue #351).
+     *  Distinct from `repetitionGuard`, which is tool-call level. Accepts a
+     *  boolean shorthand (`false` disables) or an object. Default: enabled,
+     *  minRun=200. */
+    degenerationGuard?: boolean | DegenerationGuardConfig;
     /** Legacy flat alias for `delegate.displayUsage`. Kept for backward
      *  compatibility with existing acp.json files. Prefer `delegate.displayUsage`. */
     displayUsage?: "merged" | "separate";

package/dist/degeneration.d.ts

@@ -0,0 +1,98 @@
+import type { SessionMessageEntry } from "@earendil-works/pi-coding-agent";
+type AgentMessage = SessionMessageEntry["message"];
+/** [#351] Character-level degenerate-repeat guard. Models occasionally
+ *  degenerate into long single-codepoint runs (observed in the wild: a
+ *  5968-char thinking block ending in 4655 consecutive 「【」, escalating over
+ *  turns until the turn aborts). This is distinct from `repetitionGuard`
+ *  (issue #308), which breaks byte-identical TOOL-CALL loops; here the
+ *  attractor is inside the generated text/thinking itself.
+ *
+ *  Why the adapter must act: pi replays prior assistant thinking back to the
+ *  provider on every subsequent request (openai-completions sends it as
+ *  `reasoning_content`, or as plain text when `requiresThinkingAsText`), and
+ *  an aborted turn's partial message persists in the session log. A
+ *  degenerated tail therefore rides along every later prompt, where the model
+ *  sees its own previous output ending in thousands of repeated characters —
+ *  a continuation bias that re-triggers the same degeneration, aborting the
+ *  next turn too. The session dies in an abort loop with no recovery path.
+ *
+ *  The pass below collapses runs >= minRun in assistant text/thinking of the
+ *  OUTGOING view (persisted history is never modified) and appends a one-shot
+ *  recovery notice while the degenerated message is the most recent assistant
+ *  turn. Position-based self-limiting: a fresh model turn makes the old
+ *  message non-last, so the notice stops appearing without any persistent
+ *  state (and cannot accumulate — #223 lesson). */
+export interface DegenerationGuardConfig {
+    /** Master switch. Default: true. `false` disables the pass entirely
+     *  (kill-switch). */
+    enabled?: boolean;
+    /** Minimum length of a single-codepoint run (counted in codepoints) before
+     *  it is treated as degeneration. Legitimate single-char runs in coding
+     *  sessions (markdown hrules, dotted leaders, comment banners) stay well
+     *  under this; observed pre-degeneration drift maxed at ~60 before the
+     *  catastrophic 4655×「【」 run. Default: 200. Values below 8 are raised to
+     *  8: the collapse marker must stay shorter than any detectable run, and a
+     *  sub-8 threshold would start matching ordinary dotted leaders/hrules. */
+    minRun?: number;
+}
+export declare const DEFAULT_DEGENERATION_GUARD: Required<DegenerationGuardConfig>;
+/** Resolve the guard config, handling the boolean shorthand (`false`
+ *  disables). Invalid minRun values (< 2 or non-numeric) fall back to the
+ *  default with a logged warning — they never fail the session. Valid values
+ *  below MIN_VALID_MIN_RUN are raised to it. */
+export declare function resolveDegenerationGuard(cfg?: boolean | DegenerationGuardConfig): Required<DegenerationGuardConfig>;
+/** One maximal run of a repeated codepoint. */
+export interface DegenerateRun {
+    /** The repeated codepoint (string of length 1 or 2 — surrogate pairs kept whole). */
+    char: string;
+    /** Run length in codepoints. */
+    count: number;
+    /** UTF-16 index of the run start in the original string. */
+    index: number;
+}
+/** Find maximal runs of a single repeated codepoint with length >= minRun.
+ *  Codepoint-safe: surrogate pairs count as one unit, so a run of astral
+ *  characters is detected like any other. Returns [] for empty input or
+ *  minRun < 2 (a "run" shorter than 2 carries no signal). */
+export declare function findDegenerateRuns(text: string, minRun: number): DegenerateRun[];
+/** Collapse every degenerate run in `text` into a short marker that names the
+ *  character and its original count. Pure, idempotent, fail-safe. Returns the
+ *  input unchanged when there is nothing to collapse. */
+export declare function collapseDegenerateRuns(text: string, minRun: number): string;
+/** Evidence of one rewritten message: which blocks changed and what was collapsed. */
+export interface CollapseEvidence {
+    /** Index of the rewritten message in the input array. */
+    msgIndex: number;
+    /** Block kinds rewritten ("content" for string content, else "text"/"thinking"). */
+    blocks: string[];
+    /** Runs collapsed across those blocks. */
+    runs: DegenerateRun[];
+}
+/** Request-time pass: collapse degenerate single-codepoint runs in ASSISTANT
+ *  messages' text/thinking blocks (string content included). Every position is
+ *  scanned — including the current turn's partial assistant message, which is
+ *  exactly the one pi will replay back to the provider on the next request.
+ *  Tool-call arguments are never touched (rewriting them would desync the
+ *  model's view from the call that actually executed). Pure: returns the same
+ *  array reference when nothing changed; idempotent; fail-safe (any error
+ *  returns the input unchanged). Persisted history is never modified. */
+export declare function collapseAssistantDegeneration(messages: AgentMessage[], cfg?: boolean | DegenerationGuardConfig): {
+    messages: AgentMessage[];
+    evidence: CollapseEvidence[];
+};
+/** Scan backward for the LAST assistant message and collect its degenerate
+ *  runs. Call it with the PERSISTED originals in session order (not the
+ *  outgoing view): thinking-only aborted turns never reach the outgoing view
+ *  (projectMessage drops them), yet they are still "the previous turn".
+ *  Returns null when absent or clean. Gates the recovery notice: because the
+ *  notice fires only while the degenerated message is the most recent
+ *  assistant turn, it self-limits — once the model produces a new turn the
+ *  old message is no longer last and the notice disappears on the next
+ *  rebuild (no persistent state needed). */
+export declare function lastAssistantRuns(messages: AgentMessage[], minRun: number): DegenerateRun[] | null;
+/** One-shot recovery notice appended while a degenerated assistant message is
+ *  the most recent turn: tells the model the repeated segment carries no
+ *  information and was truncated, and to resume from the last valid step
+ *  instead of continuing the attractor. */
+export declare function degenerationNotice(runs: DegenerateRun[]): AgentMessage;
+export {};

package/dist/index.js

@@ -10,7 +10,7 @@ import { readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join12 } from "path";
 
-// node_modules/acp-kernel/dist/chunk-JGNVAFFE.js
+// node_modules/acp-kernel/dist/chunk-6TAK7DSI.js
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 function defaultCountTokens(text) {
@@ -19,6 +19,12 @@ function defaultCountTokens(text) {
   const cjkCount = cjk?.length ?? 0;
   return cjkCount + Math.ceil((text.length - cjkCount) / 4);
 }
+function thinkingTokenValue(thinking) {
+  return typeof thinking === "number" && Number.isFinite(thinking) && thinking > 0 ? thinking : 0;
+}
+function countMessageTokens(message, countTokens = defaultCountTokens) {
+  return countTokens(message.text ?? "") + thinkingTokenValue(message.thinkingTokens);
+}
 function estimateTokensFast(text) {
   if (!text) return 0;
   return Math.ceil(text.length / 4);
@@ -1564,7 +1570,8 @@ function renderMessage(message, map, countTokens, strategy, snapshot = null) {
     "^" + escapeRegex(TAG_OPEN) + "[^>]*" + GT + escapeRegex(ref) + escapeRegex(TAG_CLOSE) + "\\n?"
   );
   const cleanText = (message.text || "").replace(ownTagRe, "");
-  const tokens = snapshot ? snapshot[ref] ?? (snapshot[ref] = countTokens(cleanText)) : countTokens(cleanText);
+  const textTokens = snapshot ? snapshot[ref] ?? (snapshot[ref] = countTokens(cleanText)) : countTokens(cleanText);
+  const tokens = textTokens + thinkingTokenValue(message.thinkingTokens);
   const type = classifyType(message);
   const prefix = acpTag(ref, tokens, type) + "\n";
   if (!cleanText) return { ...message, text: prefix };
@@ -1683,7 +1690,7 @@ function computeProtectedRefs(messages, state, config, countTokens = estimateTex
     if (isNeverPreserveRecent(msg)) continue;
     const ref = state.messageRefs.byRaw[msg.id];
     if (!ref || ref === "BLOCKED") continue;
-    visible.push({ ref, tokens: countTokens(msg.text ?? "") });
+    visible.push({ ref, tokens: countMessageTokens(msg, countTokens) });
   }
   if (preserveN > 0) {
     for (const m2 of visible.slice(-preserveN)) {
@@ -1726,7 +1733,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
       protectedMsgs.push({
         ref,
         gapBefore: skipSinceProtected,
-        tokens: countTokens(msg.text ?? ""),
+        tokens: countMessageTokens(msg, countTokens),
         tools: msg.toolName ? [msg.toolName] : []
       });
       skipSinceProtected = false;
@@ -1741,7 +1748,7 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
     compressibleMsgs.push({
       ref,
       gapBefore: skipSinceCompressible,
-      tokens: countTokens(msg.text ?? ""),
+      tokens: countMessageTokens(msg, countTokens),
       chars: (msg.text ?? "").length,
       isTool: isToolMessage(msg),
       isUser: msg.role === "user"
@@ -2387,7 +2394,7 @@ function applySingleRange(input) {
   let compressedTokens = 0;
   for (const id of filteredIds) {
     const message = input.messages.find((entry) => entry.id === id);
-    compressedTokens += input.countTokens(message?.text ?? "");
+    compressedTokens += message ? countMessageTokens(message, input.countTokens) : 0;
   }
   for (const consumedId of consumedBlockIds) {
     const consumed = blockById(input.state, consumedId);
@@ -2594,6 +2601,9 @@ function decideNudge(input) {
   const growthReady = firstSightMassReady || growthSinceReference >= growthFloor;
   const t2Count = tiers[2]?.targetBlocks.length ?? 0;
   const t3Count = tiers[3]?.targetBlocks.length ?? 0;
+  const tierCountUsageFloor = config.nudge.minContextLimitPct;
+  const t2CountReady = t2Count >= config.tiers.tier2Trigger && usage >= tierCountUsageFloor;
+  const t3CountReady = t3Count >= config.tiers.tier3Trigger && usage >= tierCountUsageFloor;
   if (pressure) {
     const candidates = [1];
     if (config.tiers.enabled) {
@@ -2616,19 +2626,19 @@ function decideNudge(input) {
     if (t1Eff >= nudgeGrowthTokens) {
       injectedTier = 1;
       injectedReason = `T1 effective ${t1Eff} >= ${nudgeGrowthTokens}, growth ${growthSinceReference}, usage ${Math.round(usage * 100)}%`;
-    } else if (config.tiers.enabled && (t2Count >= config.tiers.tier2Trigger || t2Pen >= tier2Threshold && t2Pen > t1Eff)) {
+    } else if (config.tiers.enabled && (t2CountReady || t2Pen >= tier2Threshold && t2Pen > t1Eff)) {
       const lastShown = state.nudge.lastShownByTier[2] ?? 0;
       const cadenceMet = lastShown === 0 || tokenCount - lastShown >= growthFloor;
       if (cadenceMet) {
         injectedTier = 2;
-        injectedReason = t2Count >= config.tiers.tier2Trigger ? `T2 distill ready: ${t2Count} tier-1 blocks >= tier2Trigger ${config.tiers.tier2Trigger} (${t2Pen} tokens), usage ${Math.round(usage * 100)}%` : `T2 distill ready: ${tiers[2].targetBlocks.length} tier-1 blocks (${t2Pen} tokens) >= ${tier2Threshold} (1.5x) and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
+        injectedReason = t2CountReady ? `T2 distill ready: ${t2Count} tier-1 blocks >= tier2Trigger ${config.tiers.tier2Trigger} (${t2Pen} tokens), usage ${Math.round(usage * 100)}%` : `T2 distill ready: ${tiers[2].targetBlocks.length} tier-1 blocks (${t2Pen} tokens) >= ${tier2Threshold} (1.5x) and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
       }
-    } else if (config.tiers.enabled && (t3Count >= config.tiers.tier3Trigger || t3Pen >= tier2Threshold && t3Pen > t2Pen && t3Pen > t1Eff)) {
+    } else if (config.tiers.enabled && (t3CountReady || t3Pen >= tier2Threshold && t3Pen > t2Pen && t3Pen > t1Eff)) {
       const lastShown = state.nudge.lastShownByTier[3] ?? 0;
       const cadenceMet = lastShown === 0 || tokenCount - lastShown >= growthFloor;
       if (cadenceMet) {
         injectedTier = 3;
-        injectedReason = t3Count >= config.tiers.tier3Trigger ? `T3 condense ready: ${t3Count} tier-2 blocks >= tier3Trigger ${config.tiers.tier3Trigger} (${t3Pen} tokens), usage ${Math.round(usage * 100)}%` : `T3 condense ready: ${tiers[3].targetBlocks.length} tier-2 blocks (${t3Pen} tokens) >= ${tier2Threshold} (1.5x) and > T2 ${t2Pen} and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
+        injectedReason = t3CountReady ? `T3 condense ready: ${t3Count} tier-2 blocks >= tier3Trigger ${config.tiers.tier3Trigger} (${t3Pen} tokens), usage ${Math.round(usage * 100)}%` : `T3 condense ready: ${tiers[3].targetBlocks.length} tier-2 blocks (${t3Pen} tokens) >= ${tier2Threshold} (1.5x) and > T2 ${t2Pen} and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
       }
     }
   }
@@ -2645,9 +2655,14 @@ function decideNudge(input) {
   } else {
     const tiersList = [1, 2, 3];
     const eligible = tiersList.filter((t) => config.tiers.enabled || t === 1);
-    const countReady = (t) => t === 2 ? t2Count >= config.tiers.tier2Trigger : t === 3 ? t3Count >= config.tiers.tier3Trigger : false;
+    const countReadyUngated = (t) => t === 2 ? t2Count >= config.tiers.tier2Trigger : t === 3 ? t3Count >= config.tiers.tier3Trigger : false;
+    const countReady = (t) => countReadyUngated(t) && usage >= tierCountUsageFloor;
     const ready = eligible.filter((t) => (tiers[t]?.pending ?? 0) >= nudgeGrowthTokens).map((t) => `T${t} ${tiers[t].pending}`);
-    const readyCount = eligible.filter((t) => (tiers[t]?.pending ?? 0) < nudgeGrowthTokens && countReady(t)).map((t) => `T${t} ${t === 2 ? t2Count : t3Count} blocks (count)`);
+    const readyCount = eligible.filter(
+      (t) => (tiers[t]?.pending ?? 0) < nudgeGrowthTokens && countReadyUngated(t)
+    ).map(
+      (t) => `T${t} ${t === 2 ? t2Count : t3Count} blocks (count${usage >= tierCountUsageFloor ? "" : ", usage-gated"})`
+    );
     const readyAll = [...ready, ...readyCount];
     const readyHint = readyAll.length > 0 ? `, ready: ${readyAll.join(", ")}` : "";
     const blocked = eligible.filter(
@@ -2709,7 +2724,7 @@ function computeContextBreakdown(messages, total, growth, countTokens) {
   const count = countTokens ?? ((t) => Math.ceil(t.length / 4));
   let system = 0, tool = 0, summaries = 0, code = 0, text = 0;
   for (const msg of messages) {
-    const tokens = count(msg.text ?? "");
+    const tokens = countMessageTokens(msg, count);
     if (msg.text?.startsWith("[Compressed conversation section]")) {
       summaries += tokens;
     } else if (msg.contentType === "tool-call" || msg.contentType === "tool-result") {
@@ -2871,7 +2886,7 @@ function collectVisible(messages, state, countTokens) {
     if (coveredIds.has(message.id)) return;
     const ref = refForRaw(state.messageRefs, message.id);
     if (!ref) return;
-    const tokens = countTokens(message.text ?? "");
+    const tokens = countMessageTokens(message, countTokens);
     const tool = isToolMessage(message) ? message.toolName ?? (message.toolCallId ? toolCallNames.get(message.toolCallId) : void 0) ?? "tool" : "text";
     if (tokens > 0) visible.push({ ref, tokens, tool, index });
   });
@@ -4088,6 +4103,8 @@ function projectMessage(message, id) {
     }];
   }
   if (role === "assistant") {
+    const thinking = thinkingTokenCount(msg.content);
+    const thinkingField = thinking > 0 ? { thinkingTokens: thinking } : {};
     const calls = allToolCalls(msg.content);
     if (calls.length > 0) {
       const textParts = extractText(msg.content);
@@ -4096,9 +4113,9 @@ function projectMessage(message, id) {
         const argStr = stringifyArgs(call.arguments);
         const text2 = argStr && textParts ? `${textParts}
 ${argStr}` : argStr || textParts;
-        return [{ id, role: "assistant", contentType: "tool-call", toolName: call.name, toolCallId: call.id, text: text2 }];
+        return [{ id, role: "assistant", contentType: "tool-call", toolName: call.name, toolCallId: call.id, text: text2, ...thinkingField }];
       }
-      return calls.map((call) => {
+      return calls.map((call, i) => {
         const argStr = stringifyArgs(call.arguments);
         return {
           id: `${id}#${call.id}`,
@@ -4106,13 +4123,14 @@ ${argStr}` : argStr || textParts;
           contentType: "tool-call",
           toolName: call.name,
           toolCallId: call.id,
-          text: argStr || textParts
+          text: argStr || textParts,
+          ...i === 0 ? thinkingField : {}
         };
       });
     }
     const text = extractText(msg.content);
     if (!text.trim()) return [];
-    return [{ id, role: "assistant", contentType: "text", text }];
+    return [{ id, role: "assistant", contentType: "text", text, ...thinkingField }];
   }
   const customText = extractText(msg.content) || fallbackText(msg);
   return customText.length > 0 ? [{ id, role: "user", contentType: "text", text: customText }] : [];
@@ -4140,6 +4158,15 @@ function extractText(content) {
   }
   return parts.join("\n");
 }
+function thinkingTokenCount(content) {
+  if (!Array.isArray(content)) return 0;
+  const parts = [];
+  for (const block of content) {
+    const b2 = block;
+    if (b2.type === "thinking" && typeof b2.thinking === "string") parts.push(b2.thinking);
+  }
+  return parts.length > 0 ? defaultCountTokens(parts.join("\n")) : 0;
+}
 function stripRefTag(text) {
   return text.replace(REF_TAG, "").replace(TRAILING_REF_TAG, "");
 }
@@ -4739,6 +4766,8 @@ var KNOWN = /* @__PURE__ */ new Set([
   "displayUsage",
   "throttleRetry",
   "outputHeadroomMaxPct",
+  "repetitionGuard",
+  "degenerationGuard",
   "prompts",
   "acknowledgePromptsRisk"
 ]);
@@ -9767,6 +9796,7 @@ function estimateTokens(messages, coveredIds, imageTokensById) {
     if (m2.toolName === "compress") continue;
     if (coveredIds?.has(m2.id)) continue;
     tokens += defaultCountTokens(m2.text ?? "");
+    tokens += m2.thinkingTokens ?? 0;
     const img = imageTokensById?.get(m2.id);
     if (img) tokens += img;
   }
@@ -16831,12 +16861,13 @@ async function statusReport(runtime, ctx) {
   const systemPromptTokens = systemPromptText ? defaultCountTokens(systemPromptText) : 0;
   const imageTokens = collectImageTokens(entries, modelSupportsImages(ctx.model));
   const imageTokensTotal = [...imageTokens.values()].reduce((a, b2) => a + b2, 0);
-  const sessionTokens = !anchorStale && realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : defaultCountTokens(coreMessages.map((m2) => m2.text ?? "").join("\n")) + imageTokensTotal;
+  const thinkingTokensTotal = coreMessages.reduce((sum, m2) => sum + (m2.thinkingTokens ?? 0), 0);
+  const sessionTokens = !anchorStale && realUsage?.tokens && realUsage.tokens > 0 ? realUsage.tokens : defaultCountTokens(coreMessages.map((m2) => m2.text ?? "").join("\n")) + imageTokensTotal + thinkingTokensTotal;
   const coveredIds = collectCoveredMessageIds(state);
   const sentTokens = estimateTokens(coreMessages, coveredIds, imageTokens) + systemPromptTokens;
   const viewSentTokens = adjustedTokenCount(runtime.core, coreMessages, state, config, sentTokens, imageTokens, systemPromptTokens);
   const turn = runtime.core.processTurn({ messages: coreMessages, state, config, tokenCount: anchorStale ? viewSentTokens : Math.max(viewSentTokens, realUsage?.tokens ?? 0) });
-  const versionStr = "0.1.63" ? `billion-context-pi@${"0.1.63"}` : void 0;
+  const versionStr = "0.1.64" ? `billion-context-pi@${"0.1.64"}` : void 0;
   let text = buildStatusPanel({
     version: versionStr,
     tokenCount: sessionTokens,
@@ -16844,7 +16875,7 @@ async function statusReport(runtime, ctx) {
     state: turn.state,
     nudge: turn.nudge,
     modelContextLimit: config.modelContextLimit,
-    unprunedTokens: coreMessages.reduce((sum, m2) => sum + defaultCountTokens(m2.text ?? "") + (imageTokens.get(m2.id) ?? 0), 0),
+    unprunedTokens: coreMessages.reduce((sum, m2) => sum + defaultCountTokens(m2.text ?? "") + (m2.thinkingTokens ?? 0) + (imageTokens.get(m2.id) ?? 0), 0),
     cacheUsages: cacheUsageSamples(entries ?? [])
   });
   const delegateUsage = getDelegateUsage();
@@ -16857,6 +16888,170 @@ async function statusReport(runtime, ctx) {
   return text;
 }
 
+// src/degeneration.ts
+var DEFAULT_DEGENERATION_GUARD = { enabled: true, minRun: 200 };
+var MIN_VALID_MIN_RUN = 8;
+function resolveDegenerationGuard(cfg) {
+  if (cfg === false) return { enabled: false, minRun: DEFAULT_DEGENERATION_GUARD.minRun };
+  const c = typeof cfg === "object" && cfg !== null ? cfg : {};
+  let minRun = DEFAULT_DEGENERATION_GUARD.minRun;
+  if (c.minRun !== void 0) {
+    const n = c.minRun;
+    if (typeof n === "number" && Number.isFinite(n) && n >= 2) {
+      minRun = Math.max(MIN_VALID_MIN_RUN, Math.floor(n));
+    } else {
+      logWarn("config", { event: "degeneration-guard-invalid", field: "minRun", value: n, fallback: DEFAULT_DEGENERATION_GUARD.minRun });
+    }
+  }
+  return { enabled: c.enabled !== false, minRun };
+}
+var preScreenMinRun = Number.NaN;
+var preScreenRe = null;
+function hasLongRun(text, minRun) {
+  const n = Math.floor(minRun);
+  if (preScreenRe === null || preScreenMinRun !== n) {
+    preScreenMinRun = n;
+    preScreenRe = new RegExp(`(.)\\1{${Math.max(n - 1, 0)},}`, "su");
+  }
+  return preScreenRe.test(text);
+}
+function findDegenerateRuns(text, minRun) {
+  const runs2 = [];
+  if (!text || !Number.isFinite(minRun) || minRun < 2) return runs2;
+  if (!hasLongRun(text, minRun)) return runs2;
+  const chars = Array.from(text);
+  let utf16 = 0;
+  let k = 0;
+  while (k < chars.length) {
+    const ch = chars[k];
+    let m2 = k + 1;
+    while (m2 < chars.length && chars[m2] === ch) m2++;
+    const count = m2 - k;
+    if (count >= minRun) runs2.push({ char: ch, count, index: utf16 });
+    utf16 += count * ch.length;
+    k = m2;
+  }
+  return runs2;
+}
+function describeChar(ch) {
+  if (ch === " ") return "space";
+  if (ch === "\n") return "newline";
+  if (ch === "	") return "tab";
+  if (ch === "\r") return "carriage-return";
+  const cp = ch.codePointAt(0) ?? 0;
+  if (cp < 32 || cp === 127) return `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+  return JSON.stringify(ch);
+}
+function applyRuns(text, runs2, minRun) {
+  const keep = Math.max(1, Math.min(3, minRun - 1));
+  let out = "";
+  let last = 0;
+  for (const r of runs2) {
+    out += text.slice(last, r.index);
+    out += `${r.char.repeat(keep)}\u2026 [${r.count}\xD7 identical chars cut \u2014 degenerate repeat]`;
+    last = r.index + r.count * r.char.length;
+  }
+  out += text.slice(last);
+  return out;
+}
+function collapseAssistantDegeneration(messages, cfg) {
+  const { enabled, minRun } = resolveDegenerationGuard(cfg);
+  if (!enabled || messages.length === 0) return { messages, evidence: [] };
+  try {
+    const evidence = [];
+    let changed = false;
+    const out = messages.slice();
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.role !== "assistant") continue;
+      const c = msg.content;
+      if (typeof c === "string") {
+        const runs3 = findDegenerateRuns(c, minRun);
+        if (runs3.length > 0) {
+          out[i] = { ...msg, content: applyRuns(c, runs3, minRun) };
+          evidence.push({ msgIndex: i, blocks: ["content"], runs: runs3 });
+          changed = true;
+        }
+        continue;
+      }
+      if (!Array.isArray(c)) continue;
+      const blocks = [];
+      const runs2 = [];
+      let blockChanged = false;
+      const nc = c.map((p) => {
+        const b2 = p;
+        if (b2?.type === "text" && typeof b2.text === "string") {
+          const r = findDegenerateRuns(b2.text, minRun);
+          if (r.length > 0) {
+            blockChanged = true;
+            blocks.push("text");
+            runs2.push(...r);
+            return { ...b2, text: applyRuns(b2.text, r, minRun) };
+          }
+          return p;
+        }
+        if (b2?.type === "thinking" && typeof b2.thinking === "string") {
+          const r = findDegenerateRuns(b2.thinking, minRun);
+          if (r.length > 0) {
+            blockChanged = true;
+            blocks.push("thinking");
+            runs2.push(...r);
+            return { ...b2, thinking: applyRuns(b2.thinking, r, minRun) };
+          }
+          return p;
+        }
+        return p;
+      });
+      if (blockChanged) {
+        out[i] = { ...msg, content: nc };
+        evidence.push({ msgIndex: i, blocks, runs: runs2 });
+        changed = true;
+      }
+    }
+    return { messages: changed ? out : messages, evidence };
+  } catch {
+    return { messages, evidence: [] };
+  }
+}
+function lastAssistantRuns(messages, minRun) {
+  try {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg.role !== "assistant") continue;
+      const runs2 = [];
+      const c = msg.content;
+      if (typeof c === "string") {
+        runs2.push(...findDegenerateRuns(c, minRun));
+      } else if (Array.isArray(c)) {
+        for (const p of c) {
+          const b2 = p;
+          if (b2?.type === "text" && typeof b2.text === "string") runs2.push(...findDegenerateRuns(b2.text, minRun));
+          else if (b2?.type === "thinking" && typeof b2.thinking === "string") runs2.push(...findDegenerateRuns(b2.thinking, minRun));
+        }
+      }
+      return runs2.length > 0 ? runs2 : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function degenerationNotice(runs2) {
+  const sorted = [...runs2].sort((a, b2) => b2.count - a.count);
+  const top = sorted[0];
+  const extra = sorted.length > 1 ? ` and ${sorted.length - 1} other repeated segment(s)` : "";
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `[ACP recovery notice] Your previous turn ended in degenerate generation: its output contained ${top.count} consecutive repetitions of ${describeChar(top.char)}${extra}. That repeated segment carries no information and has been truncated in the context above. Do not reproduce it or continue the pattern. Resume your task from your last valid step.`
+      }
+    ],
+    timestamp: Date.now()
+  };
+}
+
 // src/system-prompt.ts
 function buildAcpSystemPrompt(prompts) {
   return `
@@ -17370,7 +17565,7 @@ async function autoInstallLatest(latest, extDirOverride) {
       "--no-fund",
       "--no-save"
     ];
-    const prevVersion = (await readPackageJson(join11(extDir, "package.json")))?.version ?? "0.1.63";
+    const prevVersion = (await readPackageJson(join11(extDir, "package.json")))?.version ?? "0.1.64";
     const { code, stderr } = await runNpmImpl(installArgs(latest), { cwd: npmDir, timeout: 6e4 });
     if (code !== 0) {
       logWarn("update", {
@@ -17388,7 +17583,7 @@ async function autoInstallLatest(latest, extDirOverride) {
     }
     const verify = await verifyInstall(npmDir, latest);
     if (!verify.ok) {
-      const rollbackTo = SEMVER_RE.test(prevVersion) ? prevVersion : "0.1.63";
+      const rollbackTo = SEMVER_RE.test(prevVersion) ? prevVersion : "0.1.64";
       logWarn("update", { event: "auto-install-verify-failed", latest, reason: verify.reason, rollbackTo });
       const rb = await runNpmImpl(installArgs(rollbackTo), { cwd: npmDir, timeout: 6e4 });
       logInfo("update", { event: "rollback", from: latest, to: rollbackTo, ok: rb.code === 0 });
@@ -17463,7 +17658,7 @@ async function checkForUpdate(autoUpdate, notify) {
     }
     const latest = await fetchLatestVersion(tag);
     if (!latest) return;
-    const current = runtimeVersion ?? "0.1.63";
+    const current = runtimeVersion ?? "0.1.64";
     const hasUpdate = isVersionNewer(latest, current);
     debug.event("update-check", {
       current,
@@ -17641,7 +17836,7 @@ function wireSessionLifecycle(pi, runtime, standDownIfProxied) {
     setDelegatePolicy(DEFAULT_DELEGATE_POLICY);
     const sid = ctx.sessionManager.getSessionId();
     const modelInfo = ctx.model;
-    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.63" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
+    logInfo("session", { event: "start", sid, cwd: ctx.cwd, debug: runtime.adapter.debug ?? null, version: true ? "0.1.64" : null, model: modelInfo?.id ?? null, modelApi: modelInfo?.api ?? null, contextWindow: modelInfo?.contextWindow ?? null });
     try {
       await runtime.reloadConfig(ctx.cwd);
       const delegateCfg = resolveDelegate(runtime.adapter);
@@ -17684,6 +17879,7 @@ function wireSessionLifecycle(pi, runtime, standDownIfProxied) {
     closeLogStream();
   });
 }
+var lastDegNoticeKey = null;
 function wireContextTransform(pi, runtime, standDownIfProxied) {
   pi.on("context", async (event, ctx) => {
     if (runtime.refused) return;
@@ -17796,6 +17992,24 @@ function wireContextTransform(pi, runtime, standDownIfProxied) {
         debug.event("reasoning-drop", { sid, droppedChars, drop: reasoningDrop.drop, threshold: reasoningDrop.threshold });
       }
       rebuilt = droppedThinking;
+      const degCfg = resolveDegenerationGuard(runtime.adapter.degenerationGuard);
+      const tailRuns = degCfg.enabled ? lastAssistantRuns([...originalById.values()], degCfg.minRun) : null;
+      const deg = collapseAssistantDegeneration(rebuilt, degCfg);
+      if (deg.messages !== rebuilt) {
+        rebuilt = deg.messages;
+        const maxRun = deg.evidence.reduce((m2, e) => e.runs.reduce((x2, r) => Math.max(x2, r.count), m2), 0);
+        logWarn("degeneration", { sid, event: "runs-collapsed", msgs: deg.evidence.length, maxRun, minRun: degCfg.minRun });
+        debug.event("degeneration-collapsed", { sid, msgs: deg.evidence.length, maxRun });
+      }
+      if (tailRuns) {
+        rebuilt.push(degenerationNotice(tailRuns));
+        const top = [...tailRuns].sort((a, b2) => b2.count - a.count)[0];
+        logInfo("degeneration", { sid, event: "recovery-notice", maxRun: top.count });
+        if (ctx.hasUI && lastDegNoticeKey !== `${sid}:${top.count}:${top.char.codePointAt(0)}`) {
+          lastDegNoticeKey = `${sid}:${top.count}:${top.char.codePointAt(0)}`;
+          ctx.ui.notify(`[ACP] previous turn ended in degenerate generation (${top.count}\xD7 repeat) \u2014 the repeated segment was truncated above and a recovery notice injected.`);
+        }
+      }
       const debugOn2 = debug.enabled;
       const turnKey = lastUserMessageId(entries) ?? sid;
       const compressOutcomes = collectCompressOutcomes(entries, turnStartIndex(entries));