flavor-code 1.4.0-beta.4 → 1.4.0-beta.6

package/dist/desktop/main.js

@@ -4234,6 +4234,7 @@ import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync as r
 import { createHash as createHash21, randomUUID as randomUUID25 } from "crypto";
 import { homedir as homedir3, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
 import { basename as basename9, dirname as dirname22, join as join38, relative as relative25, resolve as resolve36, sep as sep25 } from "path";
+import { performance } from "perf_hooks";
 
 // src/agent/subagents.ts
 import { z as z10 } from "zod";
@@ -5628,10 +5629,6 @@ var ContextManager = class _ContextManager {
       }
       return microcompact.changed;
     }
-    if (this.#consecutiveAutoCompactFailures >= 3) {
-      rollbackMicrocompact();
-      return false;
-    }
     try {
       const compacted = await this.#compactConversation(signal);
       if (compacted) {
@@ -6095,10 +6092,10 @@ function within(root, candidate) {
 
 // src/context/summarizer.ts
 async function summarizeWithModel(options) {
-  const maxAttempts = options.maxPromptTooLongAttempts ?? 3;
-  if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) throw new Error("maxPromptTooLongAttempts must be positive");
   options.signal?.throwIfAborted();
   let groups = groupMessagesByApiRound(options.messages);
+  const maxAttempts = options.maxPromptTooLongAttempts ?? Math.max(1, Math.ceil(Math.log2(Math.max(1, groups.length))) + 1);
+  if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) throw new Error("maxPromptTooLongAttempts must be positive");
   let lastOverflow;
   let progress = 20;
   reportProgress(options.onProgress, progress);
@@ -6139,7 +6136,7 @@ async function summarizeWithModel(options) {
     if (terminalError.code !== "context_overflow") throw terminalError;
     lastOverflow = terminalError;
     if (attempt >= maxAttempts || groups.length <= 1) throw terminalError;
-    groups = groups.slice(1);
+    groups = groups.slice(Math.max(1, Math.floor(groups.length / 2)));
   }
   throw lastOverflow ?? new Error("Compact summary failed");
 }
@@ -11503,7 +11500,7 @@ var MEMORY_RESTART_EXIT_CODE = 75;
 var MEMORY_RESTART_MARKER_FILE = "memory-restart.json";
 var MEMORY_RESTART_WINDOW_MS = 60 * 60 * 1e3;
 var MEMORY_RESTART_MIN_GAP_MS = 5 * 60 * 1e3;
-var MEMORY_RESTART_CONTINUATION_TTL_MS = 10 * 60 * 1e3;
+var MEMORY_RESTART_CONTINUATION_TTL_MS = 24 * 60 * 60 * 1e3;
 var rotationActive = false;
 function markMemoryRotation() {
   rotationActive = true;
@@ -11709,7 +11706,7 @@ function extendBudget(input, dimensions, approvedAt) {
   return LoopStateSchema.parse({
     ...state,
     updatedAt: approvedAt,
-    budget: { ...state.budget, cycleCheckpoint, tokenCheckpoint, approvals }
+    budget: { ...state.budget, cycleCheckpoint, tokenCheckpoint, approvals: approvals.slice(-64) }
   });
 }
 function rejectBudget(input, terminalReason) {
@@ -11836,6 +11833,7 @@ ${lastCompletedCycle.verification.summary}`;
           });
           let workerError;
           let workerMemoryPressure = false;
+          let workerIterationLimit = false;
           for await (const event of this.#options.runWorker({
             goal,
             cycle,
@@ -11848,8 +11846,9 @@ ${lastCompletedCycle.verification.summary}`;
               cycleOutputTokens += event.outputTokens;
             }
             if (event.type === "error") {
-              workerError = event.error.message;
+              workerError = event.error;
               if (event.error.code === "memory_pressure") workerMemoryPressure = true;
+              if (event.error.code === "iteration_limit") workerIterationLimit = true;
             }
             if (event.type === "text") workerText = `${workerText}${event.text}`.slice(-16e3);
             if (this.#options.hallucinationGuard !== void 0) {
@@ -11862,7 +11861,8 @@ ${lastCompletedCycle.verification.summary}`;
             yield { type: "worker-event", event };
           }
           if (workerMemoryPressure) return;
-          if (workerError !== void 0) {
+          if (workerError !== void 0 && !workerIterationLimit && !isResumableWorkerError(workerError)) {
+            const status = workerError.code === "cancelled" ? "cancelled" : "failed";
             state = LoopStateSchema.parse({
               ...state,
               budget: {
@@ -11872,8 +11872,8 @@ ${lastCompletedCycle.verification.summary}`;
                 outputTokens: state.budget.outputTokens + cycleOutputTokens
               }
             });
-            state = await this.#terminal(state, "failed", workerError, now());
-            yield { type: "loop-terminal", loopId, status: "failed", reason: workerError };
+            state = await this.#terminal(state, status, workerError.message, now());
+            yield { type: "loop-terminal", loopId, status, reason: workerError.message };
             return;
           }
           state = LoopStateSchema.parse({
@@ -11916,13 +11916,7 @@ ${lastCompletedCycle.verification.summary}`;
             const report = await this.#options.hallucinationGuard.evaluate(goal, workerText);
             await this.#options.onMemoryCheckpoint?.(loopId);
             if (memoryRotationActive()) return;
-            if (!report.passed) {
-              const guardReason = report.blockingReasons.join("; ") || "Hallucination guard blocked completion.";
-              state = await this.#terminal(state, "failed", guardReason, now());
-              yield { type: "loop-terminal", loopId, status: "failed", reason: guardReason };
-              return;
-            }
-            guardWarnings = report.warnings;
+            guardWarnings = [...report.blockingReasons, ...report.warnings];
           } catch {
           }
         }
@@ -11944,7 +11938,7 @@ ${lastCompletedCycle.verification.summary}`;
             outputTokens: cycleOutputTokens,
             workspaceFingerprint: fingerprint2,
             verification: evidence
-          }],
+          }].slice(-64),
           pendingCycle: null
         });
         await this.#options.persistence.save(state);
@@ -11973,8 +11967,8 @@ ${evidence.summary}`;
         repeatedFailures = failureSignature === previousFailureSignature ? repeatedFailures + 1 : 1;
         previousFailureSignature = failureSignature;
         previousVerification = evidence;
-        if (repeatedFailures >= 3) {
-          const reason = "The same verification failure repeated three times without material workspace progress.";
+        if (this.#options.maxNoProgressCycles !== void 0 && repeatedFailures >= this.#options.maxNoProgressCycles) {
+          const reason = `The same verification failure repeated ${this.#options.maxNoProgressCycles} times without material workspace progress.`;
           state = await this.#terminal(state, "no_progress", reason, now());
           yield { type: "loop-terminal", loopId, status: "no_progress", reason };
           return;
@@ -12035,6 +12029,9 @@ ${evidence.summary}`;
     return state;
   }
 };
+function isResumableWorkerError(error) {
+  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "cancelled" && error.code !== "memory_pressure";
+}
 function countTrailingFailureSignature(cycles, signature) {
   let count = 0;
   for (let index = cycles.length - 1; index >= 0; index -= 1) {
@@ -12523,26 +12520,37 @@ var GoalOrchestrator = class {
     let plan;
     let planPath2;
     if (state.plan === null) {
-      try {
-        signal.throwIfAborted();
-        await memoryCheckpoint();
-        plan = await runPlanner({
-          registry: this.#options.registry,
-          modelId: this.#options.plannerModelId,
-          objective: state.objective,
-          signal,
-          onProgress: memoryCheckpoint
-        });
-        planPath2 = await writePlanFile(workspace, plan);
-        await persistState({ phase: "executing", plan, planPath: planPath2, contractHash: contractHash(state.objective, plan) });
-        yield { type: "goal-plan-created", plan, planPath: planPath2 };
-      } catch (error) {
-        if (memoryRotationActive()) return;
-        const reason = `Goal planning failed: ${message(error)}`;
-        await persistState({ phase: "complete", status: "failed" });
-        yield { type: "goal-plan-failed", reason };
-        yield { type: "goal-failed", reason };
-        return;
+      let planningAttempt = 0;
+      while (true) {
+        try {
+          signal.throwIfAborted();
+          await memoryCheckpoint();
+          plan = await runPlanner({
+            registry: this.#options.registry,
+            modelId: this.#options.plannerModelId,
+            objective: state.objective,
+            signal,
+            onProgress: memoryCheckpoint
+          });
+          planPath2 = await writePlanFile(workspace, plan);
+          await persistState({ phase: "executing", plan, planPath: planPath2, contractHash: contractHash(state.objective, plan) });
+          yield { type: "goal-plan-created", plan, planPath: planPath2 };
+          break;
+        } catch (error) {
+          if (memoryRotationActive()) return;
+          const normalized = normalizeProviderError(error);
+          if (!isResumableStageError(normalized)) {
+            const reason = `Goal planning failed: ${normalized.message}`;
+            await persistState({ phase: "complete", status: "failed" });
+            yield { type: "goal-plan-failed", reason };
+            yield { type: "goal-failed", reason };
+            return;
+          }
+          planningAttempt += 1;
+          const delayMs = stageRetryDelay(this.#options, planningAttempt);
+          yield { type: "goal-stage-retry", stage: "planning", attempt: planningAttempt, reason: normalized.message, delayMs };
+          await waitForStageRetry(delayMs, signal);
+        }
       }
     } else {
       plan = state.plan;
@@ -12553,7 +12561,7 @@ var GoalOrchestrator = class {
     let priorFingerprint = state.gapFingerprint;
     let stallStreak = state.stallStreak;
     const startRound = resumeStartRound(state);
-    for (let round = startRound; round <= this.#options.maxRounds; round++) {
+    for (let round = startRound; this.#options.maxRounds === void 0 || round <= this.#options.maxRounds; round++) {
       signal.throwIfAborted();
       await this.#options.onRoundBoundary?.(state.id);
       if (memoryRotationActive()) return;
@@ -12573,6 +12581,7 @@ var GoalOrchestrator = class {
         yield { type: "goal-worker-start", round };
         let workerError;
         let workerMemoryPressure = false;
+        let workerIterationLimit = false;
         try {
           for await (const event of this.#options.runWorker({
             goal: state.objective,
@@ -12585,18 +12594,19 @@ var GoalOrchestrator = class {
             yield { type: "goal-worker-event", round, event };
             if (event.type === "text") finalResponse = `${finalResponse}${event.text}`.slice(-16e3);
             if (event.type === "error") {
-              workerError = event.error.message;
+              workerError = event.error;
               if (event.error.code === "memory_pressure") workerMemoryPressure = true;
+              if (event.error.code === "iteration_limit") workerIterationLimit = true;
               break;
             }
           }
         } catch (error) {
           if (memoryRotationActive()) return;
-          workerError = message(error);
+          workerError = { code: "unknown", message: message(error) };
         }
         if (workerMemoryPressure) return;
-        if (workerError !== void 0) {
-          const reason = `Worker error in round ${round}: ${workerError}`;
+        if (workerError !== void 0 && !workerIterationLimit && !isResumableWorkerError2(workerError)) {
+          const reason = `Worker error in round ${round}: ${workerError.message}`;
           await persistState({ phase: "complete", status: "failed" });
           yield { type: "goal-failed", reason };
           return;
@@ -12626,7 +12636,7 @@ var GoalOrchestrator = class {
         round,
         workspaceDiffHash: evidence.workspaceDiffHash,
         ...hostVerification === void 0 ? {} : { hostVerification }
-      }] });
+      }].slice(-64) });
       let outcome;
       if (plan.kind === "code-change" && hostVerification !== void 0 && !hostVerification.passed) {
         if (hostVerification.commands.length === 0) {
@@ -12640,21 +12650,32 @@ var GoalOrchestrator = class {
             fingerprint: createHash11("sha256").update(hostVerification.summary).digest("hex").slice(0, 16)
           };
         }
-      } else try {
-        outcome = await runClassifier(evidence, plan, {
-          registry: this.#options.registry,
-          modelId: this.#options.classifierModelId,
-          skepticCount: this.#options.skepticCount,
-          workspace,
-          signal,
-          onProgress: memoryCheckpoint
-        });
-      } catch (error) {
-        if (memoryRotationActive()) return;
-        outcome = {
-          type: "blocked",
-          reason: `Classifier infrastructure error: ${message(error)}`
-        };
+      } else {
+        let classifierAttempt = 0;
+        while (true) {
+          try {
+            outcome = await runClassifier(evidence, plan, {
+              registry: this.#options.registry,
+              modelId: this.#options.classifierModelId,
+              skepticCount: this.#options.skepticCount,
+              workspace,
+              signal,
+              onProgress: memoryCheckpoint
+            });
+            break;
+          } catch (error) {
+            if (memoryRotationActive()) return;
+            const normalized = normalizeProviderError(error);
+            if (!isResumableStageError(normalized)) {
+              outcome = { type: "blocked", reason: `Classifier infrastructure error: ${normalized.message}` };
+              break;
+            }
+            classifierAttempt += 1;
+            const delayMs = stageRetryDelay(this.#options, classifierAttempt);
+            yield { type: "goal-stage-retry", stage: "classification", attempt: classifierAttempt, reason: normalized.message, delayMs };
+            await waitForStageRetry(delayMs, signal);
+          }
+        }
       }
       await persistState({ verifyRounds: round, pendingVerification: null });
       yield {
@@ -12676,7 +12697,7 @@ var GoalOrchestrator = class {
       }
       if (outcome.fingerprint === priorFingerprint) {
         stallStreak++;
-        if (stallStreak >= this.#options.maxStallStreak) {
+        if (this.#options.maxStallStreak !== void 0 && stallStreak >= this.#options.maxStallStreak) {
           await persistState({
             phase: "complete",
             status: "failed",
@@ -12722,6 +12743,31 @@ function resumeStartRound(state) {
   }
   return state.verifyRounds >= state.workerRounds ? state.workerRounds + 1 : Math.max(state.workerRounds, 1);
 }
+function isResumableWorkerError2(error) {
+  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "cancelled" && error.code !== "memory_pressure";
+}
+function isResumableStageError(error) {
+  return error.code !== "authentication" && error.code !== "model_not_found" && error.code !== "cancelled" && error.code !== "memory_pressure";
+}
+function stageRetryDelay(options, attempt) {
+  const delayMs = options.stageRetryDelayMs?.(attempt) ?? Math.min(6e4, 1e3 * 2 ** Math.min(attempt - 1, 6));
+  return Number.isSafeInteger(delayMs) && delayMs >= 0 ? delayMs : 1e3;
+}
+function waitForStageRetry(delayMs, signal) {
+  signal.throwIfAborted();
+  if (delayMs === 0) return Promise.resolve();
+  return new Promise((resolvePromise, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason instanceof Error ? signal.reason : new Error("Goal cancelled"));
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolvePromise();
+    }, delayMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 async function writePlanFile(workspace, plan) {
   const dir = join16(workspace, ".flavor");
   const planPath2 = join16(dir, "goal-plan.md");
@@ -13868,6 +13914,7 @@ function incompleteUtf8SuffixLength(buffer) {
 
 // src/loop/verifier.ts
 var SCRIPT_PRIORITY = ["test", "typecheck", "lint", "build", "smoke:install"];
+var MAX_PERSISTED_VERIFICATION_STREAM_BYTES = 1024;
 async function inferVerificationPlan(workspace) {
   const commands = [];
   const seen = /* @__PURE__ */ new Set();
@@ -13903,9 +13950,9 @@ async function runVerificationPlan(plan, workspace, signal, executionEnvironment
       command: item.command,
       args: item.args,
       exitCode: result.exitCode,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      truncated: result.truncated
+      stdout: boundedEvidenceTail(result.stdout),
+      stderr: boundedEvidenceTail(result.stderr),
+      truncated: result.truncated || Buffer.byteLength(result.stdout, "utf8") > MAX_PERSISTED_VERIFICATION_STREAM_BYTES || Buffer.byteLength(result.stderr, "utf8") > MAX_PERSISTED_VERIFICATION_STREAM_BYTES
     });
     if (result.exitCode !== 0) {
       return { passed: false, commands, summary: `${item.label} failed with exit code ${String(result.exitCode)}.` };
@@ -13913,6 +13960,14 @@ async function runVerificationPlan(plan, workspace, signal, executionEnvironment
   }
   return { passed: true, commands, summary: `Passed ${commands.length} deterministic verification command(s).` };
 }
+function boundedEvidenceTail(value) {
+  const encoded = Buffer.from(value, "utf8");
+  if (encoded.byteLength <= MAX_PERSISTED_VERIFICATION_STREAM_BYTES) return value;
+  const prefix = Buffer.from("\u2026\n", "utf8");
+  let start = encoded.byteLength - (MAX_PERSISTED_VERIFICATION_STREAM_BYTES - prefix.byteLength);
+  while (start < encoded.byteLength && (encoded[start] & 192) === 128) start += 1;
+  return `${prefix.toString("utf8")}${encoded.subarray(start).toString("utf8")}`;
+}
 function npmScript(name) {
   return name === "test" ? { label: name, command: "npm", args: ["test"] } : { label: name, command: "npm", args: ["run", name] };
 }
@@ -14071,6 +14126,35 @@ var AuditLogger = class {
   }
 };
 
+// src/utils/abort.ts
+function waitWithSignal(operation, signal) {
+  if (signal === void 0) return operation;
+  return new Promise((resolve44, reject) => {
+    const abort2 = () => reject(signal.reason);
+    if (signal.aborted) abort2();
+    else signal.addEventListener("abort", abort2, { once: true });
+    operation.then(resolve44, reject).finally(() => signal.removeEventListener("abort", abort2));
+  });
+}
+function createScopedAbortSignal(parent) {
+  const controller2 = new AbortController();
+  let disposed = false;
+  const abort2 = () => {
+    if (!controller2.signal.aborted) controller2.abort(parent?.reason);
+  };
+  if (parent?.aborted) abort2();
+  else parent?.addEventListener("abort", abort2, { once: true });
+  return {
+    signal: controller2.signal,
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      parent?.removeEventListener("abort", abort2);
+      abort2();
+    }
+  };
+}
+
 // src/models/anthropic.ts
 var CLAUDE_CLIENT_HEADERS = {
   "User-Agent": "claude-cli/2.1.0 (external, cli)",
@@ -14193,6 +14277,7 @@ var AnthropicModelAdapter = class {
     void appendUsageLog(line);
   }
   async *stream(request) {
+    const requestAbort = createScopedAbortSignal(request.signal);
     let inputTokens = 0;
     let outputTokens = 0;
     let hasUsage = false;
@@ -14316,13 +14401,13 @@ var AnthropicModelAdapter = class {
       };
       let stream;
       try {
-        stream = await this.client.messages.create(body, { signal: request.signal });
+        stream = await this.client.messages.create(body, { signal: requestAbort.signal });
       } catch (error) {
         if (this.thinkingBudget > 0 && !this.#thinkingRejected && isThinkingParamRejected(error)) {
           this.#thinkingRejected = true;
           delete body.thinking;
           stripThinkingBlocks(body.messages);
-          stream = await this.client.messages.create(body, { signal: request.signal });
+          stream = await this.client.messages.create(body, { signal: requestAbort.signal });
         } else {
           throw error;
         }
@@ -14434,6 +14519,8 @@ var AnthropicModelAdapter = class {
         };
       }
       yield { type: "error", error: normalizeProviderError(error) };
+    } finally {
+      requestAbort.dispose();
     }
   }
 };
@@ -14578,6 +14665,7 @@ var OpenAIModelAdapter = class {
     void appendUsageLog(line);
   }
   async *stream(request) {
+    const requestAbort = createScopedAbortSignal(request.signal);
     const callIds = /* @__PURE__ */ new Map();
     const pendingCalls = /* @__PURE__ */ new Map();
     const emittedCalls = /* @__PURE__ */ new Set();
@@ -14594,7 +14682,7 @@ var OpenAIModelAdapter = class {
           strict: tool.strict ?? true
         }))
       };
-      const stream = this.client.responses.stream(body, { signal: request.signal });
+      const stream = this.client.responses.stream(body, { signal: requestAbort.signal });
       for await (const event of stream) {
         if (event.type === "response.output_item.added" && event.item?.type === "function_call" && event.output_index !== void 0 && event.item.call_id) {
           callIds.set(event.output_index, event.item.call_id);
@@ -14688,6 +14776,8 @@ var OpenAIModelAdapter = class {
       }
     } catch (error) {
       yield { type: "error", error: normalizeProviderError(error) };
+    } finally {
+      requestAbort.dispose();
     }
   }
 };
@@ -16183,6 +16273,11 @@ function appendThinkingText(previous, delta) {
 // src/ui/transcript.ts
 var MAX_TRANSCRIPT_TURNS = 200;
 var MAX_TRANSCRIPT_CHARS = 2e6;
+var MAX_ACTIVE_TRANSCRIPT_BLOCKS = 160;
+var MAX_ACTIVE_ASSISTANT_CHARS = 64e3;
+var MAX_TRANSCRIPT_BLOCK_TEXT_CHARS = 16e3;
+var MAX_TRANSCRIPT_TOOL_VALUE_CHARS = 16e3;
+var MAX_TRANSCRIPT_PRESENTATION_CHARS = 32e3;
 function createTranscriptState() {
   return { completed: [], nextId: 1 };
 }
@@ -16543,11 +16638,9 @@ function applyTaskSnapshot(turn, snapshot4, includeTerminal = true) {
     else blocks[index] = block;
   }
   return {
-    ...turn,
+    ...withBlocks(turn, blocks),
     taskSnapshot: snapshot4,
-    suppressedTaskIds: [...suppressed],
-    blocks,
-    statusLines: blocks.filter((block) => block.kind === "status").map((block) => block.text)
+    suppressedTaskIds: [...suppressed]
   };
 }
 function terminalTaskIds(snapshot4) {
@@ -16561,13 +16654,10 @@ function upsertStatus(state, block) {
   if (state.active === void 0) return state;
   const blocks = [...state.active.blocks];
   const index = blocks.findIndex((item) => item.kind === "status" && item.id === block.id);
-  if (index < 0) blocks.push(block);
-  else blocks[index] = block;
-  return { ...state, active: {
-    ...state.active,
-    statusLines: blocks.filter((item) => item.kind === "status").map((item) => item.text),
-    blocks
-  } };
+  const bounded2 = boundedTranscriptBlock(block);
+  if (index < 0) blocks.push(bounded2);
+  else blocks[index] = bounded2;
+  return { ...state, active: withBlocks(state.active, blocks) };
 }
 function finishActive(state) {
   if (state.active === void 0) return state;
@@ -16591,16 +16681,12 @@ function attachThinking(turn, text) {
     ...block,
     thinkingText: appendThinkingText(block.thinkingText, text)
   };
-  return { ...turn, blocks };
+  return withBlocks(turn, blocks);
 }
 function withoutModelActivity(turn, id) {
   const blocks = turn.blocks.filter((block) => block.kind !== "status" || block.activity !== "model" || id !== void 0 && block.id !== id);
   if (blocks.length === turn.blocks.length) return turn;
-  return {
-    ...turn,
-    blocks,
-    statusLines: blocks.filter((block) => block.kind === "status").map((block) => block.text)
-  };
+  return withBlocks(turn, blocks);
 }
 function restoreTranscriptState(state) {
   const completed = state.completed.map(cloneTurn);
@@ -16702,15 +16788,18 @@ function cloneTurn(turn) {
 function upsertTurnStatus(turn, block) {
   const blocks = [...turn.blocks];
   const index = blocks.findIndex((item) => item.kind === "status" && item.id === block.id);
-  if (index < 0) blocks.push(block);
-  else blocks[index] = block;
+  const bounded2 = boundedTranscriptBlock(block);
+  if (index < 0) blocks.push(bounded2);
+  else blocks[index] = bounded2;
   return withBlocks(turn, blocks);
 }
 function withBlocks(turn, blocks) {
+  const bounded2 = blocks.length <= MAX_ACTIVE_TRANSCRIPT_BLOCKS ? blocks : blocks.slice(-MAX_ACTIVE_TRANSCRIPT_BLOCKS);
   return {
     ...turn,
-    blocks,
-    statusLines: blocks.filter((block) => block.kind === "status").map((block) => block.text)
+    assistantText: tailText(turn.assistantText, MAX_ACTIVE_ASSISTANT_CHARS),
+    blocks: bounded2,
+    statusLines: bounded2.filter((block) => block.kind === "status").map((block) => block.text)
   };
 }
 function appendLine(text, line) {
@@ -16724,19 +16813,95 @@ function stripRetryBlocks(turn) {
     if (block.id.startsWith("structured-retry:")) return false;
     return true;
   });
-  return {
-    ...turn,
-    blocks,
-    statusLines: blocks.filter((item) => item.kind === "status").map((item) => item.text)
-  };
+  return withBlocks(turn, blocks);
 }
 function addText(turn, text, onNewLine = false) {
-  const assistantText = onNewLine ? appendLine(turn.assistantText, text) : turn.assistantText + text;
+  const assistantText = tailText(
+    onNewLine ? appendLine(turn.assistantText, text) : turn.assistantText + text,
+    MAX_ACTIVE_ASSISTANT_CHARS
+  );
   const blocks = [...turn.blocks];
   const last = blocks[blocks.length - 1];
-  if (!onNewLine && last?.kind === "text") blocks[blocks.length - 1] = { kind: "text", text: last.text + text };
-  else blocks.push({ kind: "text", text });
-  return { ...turn, assistantText, blocks };
+  if (!onNewLine && last?.kind === "text") {
+    blocks[blocks.length - 1] = { kind: "text", text: tailText(last.text + text, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) };
+  } else {
+    blocks.push({ kind: "text", text: tailText(text, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) });
+  }
+  return withBlocks({ ...turn, assistantText }, blocks);
+}
+function boundedTranscriptBlock(block) {
+  const presentation = block.presentation === void 0 ? void 0 : boundedTranscriptPresentation(block.presentation);
+  const tool = block.tool === void 0 ? void 0 : {
+    name: block.tool.name,
+    input: boundedTranscriptValue(block.tool.input),
+    ...block.tool.result === void 0 ? {} : {
+      result: {
+        ok: block.tool.result.ok,
+        ...block.tool.result.output === void 0 ? {} : { output: boundedTranscriptValue(block.tool.result.output) },
+        ...block.tool.result.content === void 0 ? {} : {
+          content: tailText(block.tool.result.content, MAX_TRANSCRIPT_TOOL_VALUE_CHARS)
+        },
+        ...block.tool.result.presentation === void 0 ? {} : {
+          presentation: boundedTranscriptPresentation(block.tool.result.presentation)
+        },
+        ...block.tool.result.additionalContext === void 0 ? {} : {
+          additionalContext: block.tool.result.additionalContext.slice(-20).map((item) => tailText(item, MAX_TRANSCRIPT_TOOL_VALUE_CHARS))
+        },
+        ...block.tool.result.error === void 0 ? {} : { error: {
+          code: block.tool.result.error.code,
+          message: tailText(block.tool.result.error.message, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS)
+        } }
+      }
+    }
+  };
+  return {
+    ...block,
+    text: tailText(block.text, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS),
+    ...block.hint === void 0 ? {} : { hint: tailText(block.hint, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) },
+    ...block.details === void 0 ? {} : { details: tailText(block.details, MAX_TRANSCRIPT_BLOCK_TEXT_CHARS) },
+    ...presentation === void 0 ? {} : { presentation },
+    ...tool === void 0 ? {} : { tool }
+  };
+}
+function boundedTranscriptPresentation(presentation) {
+  return jsonSize(presentation) <= MAX_TRANSCRIPT_PRESENTATION_CHARS ? presentation : {
+    kind: "generic",
+    title: "Tool output",
+    summary: "Large presentation omitted from the live transcript; the model-facing result remains available in context."
+  };
+}
+function boundedTranscriptValue(value) {
+  const chars = jsonSize(value);
+  if (chars <= MAX_TRANSCRIPT_TOOL_VALUE_CHARS) return value;
+  const record3 = typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+  const summary2 = { truncated: true, originalChars: chars };
+  for (const key of ["path", "command", "id", "name", "exitCode", "bytes", "replacements"]) {
+    const item = record3?.[key];
+    if (typeof item === "string") summary2[key] = tailText(item, 1e3);
+    else if (typeof item === "number" || typeof item === "boolean" || item === null) summary2[key] = item;
+  }
+  return summary2;
+}
+function jsonSize(value) {
+  try {
+    return JSON.stringify(value)?.length ?? 0;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+function tailText(text, limit) {
+  if (text.length <= limit) return text;
+  const marker = `\u2026 ${text.length - limit} earlier characters omitted \u2026
+`;
+  return marker.length >= limit ? text.slice(-limit) : marker + text.slice(-(limit - marker.length));
+}
+function transcriptCensus(state) {
+  const turns = [...state.completed, ...state.active === void 0 ? [] : [state.active]];
+  return {
+    turns: turns.length,
+    blocks: turns.reduce((total, turn) => total + turn.blocks.length, 0),
+    chars: jsonSize(state)
+  };
 }
 
 // src/session/store.ts
@@ -19721,19 +19886,6 @@ import { isIP } from "net";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { z as z31 } from "zod";
-
-// src/utils/abort.ts
-function waitWithSignal(operation, signal) {
-  if (signal === void 0) return operation;
-  return new Promise((resolve44, reject) => {
-    const abort2 = () => reject(signal.reason);
-    if (signal.aborted) abort2();
-    else signal.addEventListener("abort", abort2, { once: true });
-    operation.then(resolve44, reject).finally(() => signal.removeEventListener("abort", abort2));
-  });
-}
-
-// src/tools/web.ts
 var WebFetchInput = z31.object({
   url: z31.string().url().max(8192),
   timeoutMs: z31.coerce.number().int().positive().max(12e4).optional(),
@@ -22246,6 +22398,11 @@ var HELP = [
   "/co-work <pal> <goal> | status [id] | cancel <id> [reason]"
 ].join("\n");
 var MAX_STOP_DENIALS = 2;
+var RESUMABLE_TURN_BOUNDARIES = /* @__PURE__ */ new Set([
+  "iteration_limit",
+  "output_limit",
+  "context_overflow"
+]);
 var FlavorSession = class {
   #services;
   #active;
@@ -22477,6 +22634,7 @@ var FlavorSession = class {
       if (!initial) this.#outputQueuedSubmission(submission);
       initial = false;
       await this.#runSubmission(submission);
+      if (this.#services.rotationPending?.() === true) return;
       pending2.push(...this.#drainMessages("steer"), ...this.#drainMessages("followUp"));
     }
   }
@@ -22500,6 +22658,7 @@ var FlavorSession = class {
     this.#activeSubmission = submission;
     this.#interrupted = false;
     let outcome = "completed";
+    let resumableBoundary;
     let assistantSummary = "";
     let deliverables = [];
     try {
@@ -22536,7 +22695,10 @@ var FlavorSession = class {
         this.#services.output(event);
         if (event.type === "text") assistantSummary = `${assistantSummary}${event.text}`.slice(-2e3);
         if (event.type === "deliverables") deliverables = event.files.slice(0, 100);
-        if (event.type === "error") outcome = "failed";
+        if (event.type === "error") {
+          outcome = "failed";
+          if (RESUMABLE_TURN_BOUNDARIES.has(event.error.code)) resumableBoundary = event.error.code;
+        }
       }
       if (controller2.signal.aborted) outcome = "cancelled";
     } catch (error) {
@@ -22577,6 +22739,13 @@ var FlavorSession = class {
           }
         }
         try {
+          if (resumableBoundary !== void 0 && !this.#closed && !controller2.signal.aborted) {
+            const attempt = (submission.iterationContinuation ?? 0) + 1;
+            const text = `[automatic continuation after ${resumableBoundary} boundary; segment ${attempt}]
+Continue the unfinished task from the current conversation and workspace state. Do not repeat completed operations. Inspect existing results, finish the remaining work, and verify it before stopping.`;
+            this.#enqueueMessage("followUp", { text, displayText: text, iterationContinuation: attempt });
+            this.#notice(`Agent ${resumableBoundary} boundary reached; durable continuation ${attempt} queued.`);
+          }
           if (stopDecision?.decision === "deny" && typeof stopDecision.reason === "string" && stopDecision.reason.length > 0 && !this.#closed && outcome !== "cancelled" && outcome !== "denied") {
             if (this.#stopDenials < MAX_STOP_DENIALS) {
               this.#stopDenials += 1;
@@ -22773,7 +22942,7 @@ Address this now (for example run the required verification or fix), then finish
     });
   }
   #resumeDurableQueue() {
-    if (this.#durableResumeStarted || this.#closed || this.active || this.#pendingSubmissions > 0) return;
+    if (this.#durableResumeStarted || this.#closed || this.active || this.#pendingSubmissions > 0 || this.#services.rotationPending?.() === true) return;
     if (!this.#queue.hasPending) return;
     this.#durableResumeStarted = true;
     const submissions = [...this.#drainMessages("steer"), ...this.#drainMessages("followUp")];
@@ -22924,6 +23093,7 @@ function recoveredSubmission(value) {
   if (typeof input.text !== "string" || input.text.trim().length === 0) return void 0;
   if (typeof input.displayText !== "string") return void 0;
   if (input.controlOnly !== void 0 && typeof input.controlOnly !== "boolean") return void 0;
+  if (input.iterationContinuation !== void 0 && (!Number.isSafeInteger(input.iterationContinuation) || input.iterationContinuation < 1)) return void 0;
   if (input.coWorkPlanningKey !== void 0 && typeof input.coWorkPlanningKey !== "string") return void 0;
   if (input.remoteOrigin !== void 0) {
     const origin = input.remoteOrigin;
@@ -27701,6 +27871,18 @@ async function createProductionRuntime(options) {
         holders.sessionTree = { entries: sessionHistory.nodeCount };
       } catch {
       }
+      try {
+        const transcript = transcriptCensus(timelineState);
+        holders.transcript = { entries: transcript.blocks, chars: transcript.chars };
+        holders.transcriptTurns = { entries: transcript.turns };
+      } catch {
+      }
+      try {
+        holders.userTiming = {
+          entries: performance.getEntriesByType("measure").length + performance.getEntriesByType("mark").length
+        };
+      } catch {
+      }
       return holders;
     };
     const rotateForHeap = (continuation, reading) => {
@@ -27758,21 +27940,9 @@ async function createProductionRuntime(options) {
           await verifierEnvironment?.dispose();
         }
       },
-      confirmBudget: async (state, dimensions, signal) => {
-        if (options.approvalPolicy === "deny") return "unavailable";
-        const reached = dimensions.map((dimension) => dimension === "cycles" ? `${state.budget.cyclesUsed} cycles` : `${state.budget.inputTokens + state.budget.outputTokens} tokens`).join(" and ");
-        const next = dimensions.map((dimension) => dimension === "cycles" ? `${state.budget.cycleCheckpoint + state.config.cycleStep} cycles` : `${state.budget.tokenCheckpoint + state.config.tokenStep} tokens`).join(" and ");
-        const latestVerification = state.cycles.at(-1)?.verification.summary ?? "No host verification evidence yet.";
-        const answers = await questions.ask([{
-          header: "Loop budget",
-          question: `Loop ${state.loopId} reached ${reached}. Latest verification: ${latestVerification} Continue until the next checkpoint (${next})?`,
-          options: [
-            { label: "Continue", description: "Extend only the reached budget tranche and keep looping." },
-            { label: "Stop", description: "End this loop as budget exhausted." }
-          ]
-        }], signal);
-        return answers[0] === "Continue" ? "approved" : "rejected";
-      },
+      // Cycle/token values are telemetry checkpoint cadence, not an unattended
+      // execution cap. The user can still cancel explicitly at any time.
+      confirmBudget: async () => "approved",
       fingerprint: workspaceFingerprint,
       idFactory: () => `loop-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID25().slice(0, 8)}`
     });
@@ -27783,8 +27953,9 @@ async function createProductionRuntime(options) {
       plannerModelId: mainModel,
       classifierModelId: mainModel,
       skepticCount: 3,
-      maxRounds: config.goal.maxRounds,
-      maxStallStreak: config.goal.maxStallStreak,
+      // Production goals run until verified, explicitly cancelled, or blocked
+      // by a non-recoverable external condition. Numeric config values remain
+      // accepted for compatibility but no longer terminate autonomous work.
       persistence: goalStore,
       onRoundBoundary: (goalId) => maybeRotateAtBoundary({ kind: "goal", id: goalId }),
       onMemoryCheckpoint: (goalId) => maybeRotateAtBoundary({ kind: "goal", id: goalId }),
@@ -27925,6 +28096,7 @@ async function createProductionRuntime(options) {
         () => rotateForHeap(activeLongTask ?? { kind: "goal", id: goalId }, currentPressureReading())
       ),
       continuation: () => consumePendingContinuation(),
+      rotationPending: () => memoryRotationActive(),
       mcp: async (command, signal) => {
         signal.throwIfAborted();
         const manager = await mcpReady;
@@ -28482,6 +28654,8 @@ async function* loopSessionEvents(events, hooks) {
           totalInputTokens,
           totalOutputTokens
         };
+      } else if (event.event.type === "error" && isResumableLongTaskError(event.event.error.code)) {
+        yield { type: "warning", message: `Loop worker segment ended at ${event.event.error.code}; checkpointing and verifying before continuing.` };
       } else if (event.event.type !== "done") yield event.event;
       continue;
     }
@@ -28536,7 +28710,7 @@ function loopProgressEvent(event) {
       loopId: event.loopId,
       phase: "budget",
       state: "info",
-      message: `Confirmation required for ${event.dimensions.join(" and ")} budget.`
+      message: `${event.dimensions.join(" and ")} checkpoint reached; continuing automatically.`
     };
   }
   return {
@@ -28553,6 +28727,9 @@ function terminalProgressState(status) {
   if (status === "needs_human") return "info";
   return "failed";
 }
+function isResumableLongTaskError(code) {
+  return code !== "authentication" && code !== "model_not_found" && code !== "cancelled" && code !== "memory_pressure";
+}
 async function workspaceFingerprint(workspace) {
   const hash = createHash21("sha256");
   const diff = await execFileNoThrow(
@@ -29212,6 +29389,13 @@ async function* goalSessionEvents(events) {
       yield { type: "notice", message: `Resuming goal ${event.goalId} at round ${event.round} after a heap rotation.` };
       continue;
     }
+    if (event.type === "goal-stage-retry") {
+      yield {
+        type: "warning",
+        message: `Goal ${event.stage} attempt ${event.attempt} hit a recoverable boundary (${event.reason}); retrying in ${event.delayMs}ms.`
+      };
+      continue;
+    }
     if (event.type === "goal-plan-created") {
       yield { type: "notice", message: `Goal plan created (${event.plan.kind}) with ${event.plan.criteria.length} acceptance criteria.` };
       yield { type: "notice", message: `Plan file: ${event.planPath}` };
@@ -29238,6 +29422,8 @@ async function* goalSessionEvents(events) {
           totalInputTokens: event.event.usage.inputTokens,
           totalOutputTokens: event.event.usage.outputTokens
         };
+      } else if (event.event.type === "error" && isResumableLongTaskError(event.event.error.code)) {
+        yield { type: "warning", message: `Goal worker segment ended at ${event.event.error.code}; checkpointing and verifying before continuing.` };
       } else {
         yield event.event;
       }