flavor-code 1.4.0-beta.3 → 1.4.0-beta.5

package/dist/desktop/main.js

@@ -1,8 +1,8 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
 import { createHash as createHash28, randomUUID as randomUUID29 } from "crypto";
-import { readFile as readFile40, stat as stat19, writeFile as writeFile19 } from "fs/promises";
-import { basename as basename12, dirname as dirname23, join as join50, resolve as resolve43 } from "path";
+import { readFile as readFile41, stat as stat20, writeFile as writeFile19 } from "fs/promises";
+import { basename as basename12, dirname as dirname23, join as join51, resolve as resolve43 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { app, BrowserWindow as BrowserWindow2, clipboard, dialog, ipcMain, Menu, nativeImage, Notification, shell } from "electron";
 
@@ -303,6 +303,10 @@ var FlavorConfigSchema = z2.object({
     maxTokens: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(5e5),
     isolation: z2.literal("auto").default("auto")
   }).prefault({}),
+  goal: z2.object({
+    maxRounds: z2.number().int().positive().max(1e4).default(100),
+    maxStallStreak: z2.number().int().positive().max(100).default(3)
+  }).prefault({}),
   context: z2.object({
     windowTokens: z2.number().int().positive().default(2e5),
     reservedOutputTokens: z2.number().int().nonnegative().default(2e4),
@@ -4225,11 +4229,11 @@ ${summarizeReport(report2)}`).join("\n\n")
 }
 
 // src/production.ts
-import { readFile as readFile28 } from "fs/promises";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { readFile as readFile29 } from "fs/promises";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
 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 join37, relative as relative25, resolve as resolve36, sep as sep25 } from "path";
+import { basename as basename9, dirname as dirname22, join as join38, relative as relative25, resolve as resolve36, sep as sep25 } from "path";
 
 // src/agent/subagents.ts
 import { z as z10 } from "zod";
@@ -5572,6 +5576,18 @@ var ContextManager = class _ContextManager {
   estimatedTokens() {
     return estimateMessageTokens(this.messagesForModel());
   }
+  /** Retained sizes for the rotation census: what this context holds right now. */
+  census() {
+    const chars = (messages) => messages.reduce((sum, entry2) => sum + modelContentText(entry2.content).length, 0);
+    return {
+      messages: this.#messages.length,
+      messageChars: chars(this.#messages),
+      visibilityEntries: this.#visibilityLog.length,
+      visibilityChars: this.#visibilityLog.reduce((sum, record3) => sum + record3.content.length, 0),
+      transientEntries: this.#activeTransientSystem.size,
+      transientChars: chars([...this.#activeTransientSystem.values()])
+    };
+  }
   needsCompaction() {
     if (modelVisibleText(this.messagesForModel()).length >= this.#compactAtChars) return true;
     return calculateContextPressure(this.#currentTokenUsage(), this.#compaction).shouldAutoCompact;
@@ -5612,10 +5628,6 @@ var ContextManager = class _ContextManager {
       }
       return microcompact.changed;
     }
-    if (this.#consecutiveAutoCompactFailures >= 3) {
-      rollbackMicrocompact();
-      return false;
-    }
     try {
       const compacted = await this.#compactConversation(signal);
       if (compacted) {
@@ -6079,10 +6091,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);
@@ -6123,7 +6135,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");
 }
@@ -6140,8 +6152,75 @@ function reportProgress(callback, percentage) {
   }
 }
 
-// src/agent/loop.ts
+// src/utils/heap.ts
 import { getHeapStatistics } from "v8";
+import { totalmem } from "os";
+var MEMORY_PRESSURE_HEAP_RATIO = 0.8;
+var MEMORY_ROTATION_HEAP_RATIO = 0.6;
+var MEMORY_PRESSURE_RSS_RATIO = 0.75;
+var MEMORY_ROTATION_RSS_RATIO = 0.6;
+var ROTATION_PRECHECK_RATIO = 0.45;
+function readHeap() {
+  const heapLimit = getHeapStatistics().heap_size_limit;
+  const heapUsed = process.memoryUsage().heapUsed;
+  return { heapUsed, heapLimit, ratio: heapLimit > 0 ? heapUsed / heapLimit : 0 };
+}
+function forceFullGc() {
+  const gc = globalThis.gc;
+  if (typeof gc !== "function") return false;
+  gc();
+  gc();
+  return true;
+}
+function ratioOf(heapLimit, heapUsed) {
+  return heapLimit > 0 ? heapUsed / heapLimit : 0;
+}
+function effectiveMemoryLimit() {
+  const physical = totalmem();
+  const constrained = process.constrainedMemory?.() ?? 0;
+  return constrained > 0 ? Math.min(physical, constrained) : physical;
+}
+function withRss(reading, gcVerified) {
+  const usage = process.memoryUsage();
+  const memoryLimit = effectiveMemoryLimit();
+  return {
+    ...reading,
+    gcVerified,
+    rss: usage.rss,
+    memoryLimit,
+    rssRatio: ratioOf(memoryLimit, usage.rss),
+    external: usage.external,
+    arrayBuffers: usage.arrayBuffers
+  };
+}
+function verifiedHeapPressure(threshold) {
+  const raw = readHeap();
+  const before = withRss(raw, false);
+  const rssThreshold = threshold >= MEMORY_PRESSURE_HEAP_RATIO ? MEMORY_PRESSURE_RSS_RATIO : threshold;
+  if ((raw.heapLimit <= 0 || raw.ratio < threshold) && (before.rssRatio ?? 0) < rssThreshold) return void 0;
+  if (!forceFullGc()) return before;
+  const heapUsed = process.memoryUsage().heapUsed;
+  const ratio = ratioOf(raw.heapLimit, heapUsed);
+  const verified = withRss({ heapUsed, heapLimit: raw.heapLimit, ratio, verifiedRatio: ratio }, true);
+  if (ratio < threshold && (verified.rssRatio ?? 0) < rssThreshold) return void 0;
+  return verified;
+}
+function heapRotationNeeded() {
+  const raw = readHeap();
+  const before = withRss(raw, false);
+  if ((raw.heapLimit <= 0 || raw.ratio < ROTATION_PRECHECK_RATIO) && (before.rssRatio ?? 0) < ROTATION_PRECHECK_RATIO) return void 0;
+  if (!forceFullGc()) {
+    return raw.ratio >= MEMORY_PRESSURE_HEAP_RATIO || (before.rssRatio ?? 0) >= MEMORY_PRESSURE_RSS_RATIO ? before : void 0;
+  }
+  const heapUsed = process.memoryUsage().heapUsed;
+  const ratio = ratioOf(raw.heapLimit, heapUsed);
+  const verified = withRss({ heapUsed, heapLimit: raw.heapLimit, ratio, verifiedRatio: ratio }, true);
+  if (ratio < MEMORY_ROTATION_HEAP_RATIO && (verified.rssRatio ?? 0) < MEMORY_ROTATION_RSS_RATIO) return void 0;
+  return verified;
+}
+function heapSnapshotWarranted(_reading) {
+  return process.env.FLAVOR_HEAP_SNAPSHOT_ON_ROTATE === "1";
+}
 
 // src/models/structured.ts
 import { z as z12 } from "zod";
@@ -6560,7 +6639,6 @@ function envMaxIterations() {
   if (!Number.isInteger(parsed) || parsed <= 0) return void 0;
   return parsed;
 }
-var MEMORY_PRESSURE_HEAP_RATIO = 0.8;
 function memoryPressureError(heapUsed, heapLimit) {
   if (heapLimit <= 0 || heapUsed < heapLimit * MEMORY_PRESSURE_HEAP_RATIO) return void 0;
   const mb = (bytes) => Math.round(bytes / 1048576);
@@ -6570,7 +6648,12 @@ function memoryPressureError(heapUsed, heapLimit) {
   };
 }
 function currentMemoryPressure() {
-  return memoryPressureError(process.memoryUsage().heapUsed, getHeapStatistics().heap_size_limit);
+  const reading = verifiedHeapPressure(MEMORY_PRESSURE_HEAP_RATIO);
+  if (reading === void 0) return void 0;
+  return memoryPressureError(reading.heapUsed, reading.heapLimit) ?? {
+    code: "memory_pressure",
+    message: `Process RSS reached ${Math.round((reading.rssRatio ?? 0) * 100)}% of the available memory limit; stopping before system OOM`
+  };
 }
 var AgentLoop = class {
   #options;
@@ -8393,6 +8476,10 @@ var HarnessJournal = class {
   get records() {
     return this.#records.map((record3) => structuredClone(record3));
   }
+  /** Retained record count for the rotation census. */
+  get recordCount() {
+    return this.#records.length;
+  }
   admitQueue(kind, payload) {
     QueueKindSchema.parse(kind);
     const id = randomUUID8();
@@ -8669,19 +8756,38 @@ function jsonSafeRecord(value) {
   return JSON.parse(json);
 }
 function hashJson(value) {
-  return createHash6("sha256").update(stableJson(value)).digest("hex");
-}
-function recordHash(record3) {
-  const { hash: _hash, ...unsigned } = record3;
-  return hashJson(unsigned);
+  const hash = createHash6("sha256");
+  stableHashInto(hash, value);
+  return hash.digest("hex");
 }
-function stableJson(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+function stableHashInto(hash, value) {
+  if (Array.isArray(value)) {
+    hash.update("[");
+    for (let index = 0; index < value.length; index += 1) {
+      if (index > 0) hash.update(",");
+      stableHashInto(hash, value[index]);
+    }
+    hash.update("]");
+    return;
+  }
   if (typeof value === "object" && value !== null) {
     const object = value;
-    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object[key])}`).join(",")}}`;
+    hash.update("{");
+    const keys = Object.keys(object).sort();
+    for (let index = 0; index < keys.length; index += 1) {
+      const key = keys[index];
+      if (index > 0) hash.update(",");
+      hash.update(`${JSON.stringify(key)}:`);
+      stableHashInto(hash, object[key]);
+    }
+    hash.update("}");
+    return;
   }
-  return JSON.stringify(value) ?? String(value);
+  hash.update(JSON.stringify(value) ?? String(value));
+}
+function recordHash(record3) {
+  const { hash: _hash, ...unsigned } = record3;
+  return hashJson(unsigned);
 }
 function assertSessionId(value) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value)) throw new Error("Invalid session id");
@@ -11387,6 +11493,81 @@ async function initializeFlavor(cwd) {
   return { path, created: existing === void 0, content, facts };
 }
 
+// src/utils/memory-restart.ts
+import { join as join14 } from "path";
+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 = 24 * 60 * 60 * 1e3;
+var rotationActive = false;
+function markMemoryRotation() {
+  rotationActive = true;
+}
+function memoryRotationActive() {
+  return rotationActive;
+}
+function clearMemoryRotation() {
+  rotationActive = false;
+}
+function memoryRestartMarkerPath(workspace) {
+  return join14(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
+}
+function nextMemoryRestartMarker(previous, sessionId, now, continuation) {
+  const previousWindowStart = previous?.windowStartedAt ?? previous?.requestedAt;
+  const reusable = previous !== void 0 && previous.sessionId === sessionId && previousWindowStart !== void 0 && now.getTime() - Date.parse(previousWindowStart) < MEMORY_RESTART_WINDOW_MS && Number.isInteger(previous.attempts) && previous.attempts > 0;
+  return {
+    sessionId,
+    windowStartedAt: reusable ? previousWindowStart : now.toISOString(),
+    requestedAt: now.toISOString(),
+    attempts: reusable ? previous.attempts + 1 : 1,
+    ...continuation === void 0 ? {} : { continuation }
+  };
+}
+function consumedMemoryRestartMarker(marker) {
+  return {
+    sessionId: marker.sessionId,
+    ...marker.windowStartedAt === void 0 ? {} : { windowStartedAt: marker.windowStartedAt },
+    requestedAt: marker.requestedAt,
+    attempts: marker.attempts
+  };
+}
+function rotationCooldownActive(marker, sessionId, now) {
+  return marker !== void 0 && marker.sessionId === sessionId && now.getTime() - Date.parse(marker.requestedAt) < MEMORY_RESTART_MIN_GAP_MS;
+}
+function pendingContinuation(marker, sessionId, now) {
+  if (marker === void 0 || marker.sessionId !== sessionId) return void 0;
+  if (now.getTime() - Date.parse(marker.requestedAt) > MEMORY_RESTART_CONTINUATION_TTL_MS) return void 0;
+  const continuation = marker.continuation;
+  if (continuation === void 0) return void 0;
+  if (continuation.kind !== "loop" && continuation.kind !== "goal") return void 0;
+  if (typeof continuation.id !== "string" || continuation.id.length === 0) return void 0;
+  return continuation;
+}
+function parseMemoryRestartMarker(json) {
+  try {
+    const value = JSON.parse(json);
+    if (typeof value.sessionId !== "string" || typeof value.requestedAt !== "string" || typeof value.attempts !== "number") {
+      return void 0;
+    }
+    const continuation = value.continuation;
+    if (continuation !== void 0 && (typeof continuation !== "object" || continuation === null || continuation.kind !== "loop" && continuation.kind !== "goal" || typeof continuation.id !== "string")) {
+      return void 0;
+    }
+    const windowStartedAt = value.windowStartedAt;
+    if (windowStartedAt !== void 0 && typeof windowStartedAt !== "string") return void 0;
+    return {
+      sessionId: value.sessionId,
+      ...windowStartedAt === void 0 ? {} : { windowStartedAt },
+      requestedAt: value.requestedAt,
+      attempts: value.attempts,
+      ...continuation === void 0 ? {} : { continuation }
+    };
+  } catch {
+    return void 0;
+  }
+}
+
 // src/skills/builtin-loop.ts
 function buildLoopCyclePrompt(input) {
   return [
@@ -11467,6 +11648,14 @@ var LoopStateSchema = z20.object({
     approvals: z20.array(LoopApprovalSchema)
   }).strict(),
   cycles: z20.array(LoopCycleEvidenceSchema),
+  /** Completed worker awaiting host verification; avoids replaying tool work after rotation. */
+  pendingCycle: z20.object({
+    cycle: z20.number().int().positive(),
+    startedAt: z20.string().datetime({ offset: true }),
+    inputTokens: z20.number().int().nonnegative(),
+    outputTokens: z20.number().int().nonnegative(),
+    workerText: z20.string().max(16e3)
+  }).strict().nullable().optional(),
   terminalReason: z20.string().optional()
 }).strict();
 var LoopEventSchema = z20.object({
@@ -11516,7 +11705,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) {
@@ -11555,15 +11744,45 @@ var LoopOrchestrator = class {
         tokenCheckpoint: this.#options.config.maxTokens,
         approvals: []
       },
-      cycles: []
+      cycles: [],
+      pendingCycle: null
     });
     await this.#options.persistence.create(state);
+    yield* this.#execute(state, request.goal, request.signal);
+  }
+  /**
+   * Continue a loop whose process rotated onto a fresh heap. The persisted
+   * state decides where to pick up; an interrupted cycle simply runs again.
+   */
+  async *resume(request) {
+    const persistence = this.#options.persistence;
+    if (persistence.load === void 0) throw new Error("Loop persistence does not support resume");
+    let state;
+    try {
+      state = await persistence.load(request.loopId);
+    } catch (error) {
+      yield { type: "loop-terminal", loopId: request.loopId, status: "failed", reason: message(error) };
+      return;
+    }
+    if (state.status !== "running") {
+      const status = state.status;
+      yield { type: "loop-terminal", loopId: state.loopId, status, reason: state.terminalReason ?? "The loop is not running." };
+      return;
+    }
+    yield* this.#execute(state, state.goal, request.signal);
+  }
+  async *#execute(initialState, goal, signal) {
+    const now = this.#options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    const loopId = initialState.loopId;
+    let state = initialState;
     try {
+      await this.#options.onMemoryCheckpoint?.(loopId);
+      if (memoryRotationActive()) return;
       const workspaceResolution = await this.#options.prepareWorkspace({
         root: this.#options.workspace,
         loopId,
-        goal: request.goal,
-        signal: request.signal
+        goal,
+        signal
       });
       if (workspaceResolution.kind === "needs_human") {
         state = await this.#terminal(state, "needs_human", workspaceResolution.reason, now());
@@ -11581,67 +11800,90 @@ var LoopOrchestrator = class {
         cycleCheckpoint: state.budget.cycleCheckpoint,
         tokenCheckpoint: state.budget.tokenCheckpoint
       };
-      let previousVerification = plan.commands.length === 0 ? {
+      const lastCompletedCycle = state.cycles.at(-1);
+      let previousVerification = lastCompletedCycle?.verification ?? (plan.commands.length === 0 ? {
         passed: false,
         commands: [],
         summary: `${plan.needsHumanReason ?? "No deterministic verification command was found."} Inspect the project and establish a meaningful project-native deterministic check; never add a trivial pass-through verifier.`
-      } : void 0;
-      let previousFailureSignature;
-      let repeatedFailures = 0;
+      } : void 0);
+      let previousFailureSignature = lastCompletedCycle === void 0 ? void 0 : `${lastCompletedCycle.workspaceFingerprint}
+${lastCompletedCycle.verification.summary}`;
+      let repeatedFailures = previousFailureSignature === void 0 ? 0 : countTrailingFailureSignature(state.cycles, previousFailureSignature);
       while (state.status === "running") {
-        request.signal.throwIfAborted();
-        const cycle = state.budget.cyclesUsed + 1;
-        const startedAt = now();
-        await this.#options.persistence.append({ version: 1, type: "cycle_started", timestamp: startedAt, loopId, payload: { cycle } });
-        yield { type: "loop-cycle-start", loopId, cycle };
-        const prompt = buildLoopCyclePrompt({
-          goal: request.goal,
-          cycle,
-          ...previousVerification === void 0 ? {} : {
-            memory: `Previous host verification: ${previousVerification.summary}`,
-            verification: previousVerification
-          }
-        });
-        let cycleInputTokens = 0;
-        let cycleOutputTokens = 0;
-        let workerError;
-        let workerText = "";
-        for await (const event of this.#options.runWorker({
-          goal: request.goal,
-          cycle,
-          workspace: executionWorkspace.root,
-          prompt,
-          signal: request.signal
-        })) {
-          if (event.type === "usage") {
-            cycleInputTokens += event.inputTokens;
-            cycleOutputTokens += event.outputTokens;
-          }
-          if (event.type === "error") workerError = event.error.message;
-          if (event.type === "text") workerText += event.text;
-          if (this.#options.hallucinationGuard !== void 0) {
-            if (event.type === "tool-start") {
-              this.#options.hallucinationGuard.recordToolCall(event.name, event.input, event.id);
-            } else if (event.type === "tool-end") {
-              this.#options.hallucinationGuard.recordToolResult(event.name, event.result, event.id);
+        signal.throwIfAborted();
+        await this.#options.onCycleBoundary?.(loopId);
+        if (memoryRotationActive()) return;
+        const pendingCycle = state.pendingCycle;
+        const cycle = pendingCycle?.cycle ?? state.budget.cyclesUsed + 1;
+        const startedAt = pendingCycle?.startedAt ?? now();
+        let cycleInputTokens = pendingCycle?.inputTokens ?? 0;
+        let cycleOutputTokens = pendingCycle?.outputTokens ?? 0;
+        let workerText = pendingCycle?.workerText ?? "";
+        if (pendingCycle === void 0 || pendingCycle === null) {
+          await this.#options.persistence.append({ version: 1, type: "cycle_started", timestamp: startedAt, loopId, payload: { cycle } });
+          yield { type: "loop-cycle-start", loopId, cycle };
+          const prompt = buildLoopCyclePrompt({
+            goal,
+            cycle,
+            ...previousVerification === void 0 ? {} : {
+              memory: `Previous host verification: ${previousVerification.summary}`,
+              verification: previousVerification
+            }
+          });
+          let workerError;
+          let workerMemoryPressure = false;
+          let workerIterationLimit = false;
+          for await (const event of this.#options.runWorker({
+            goal,
+            cycle,
+            workspace: executionWorkspace.root,
+            prompt,
+            signal
+          })) {
+            if (event.type === "usage") {
+              cycleInputTokens += event.inputTokens;
+              cycleOutputTokens += event.outputTokens;
+            }
+            if (event.type === "error") {
+              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) {
+              if (event.type === "tool-start") {
+                this.#options.hallucinationGuard.recordToolCall(event.name, event.input, event.id);
+              } else if (event.type === "tool-end") {
+                this.#options.hallucinationGuard.recordToolResult(event.name, event.result, event.id);
+              }
+            }
+            yield { type: "worker-event", event };
+          }
+          if (workerMemoryPressure) return;
+          if (workerError !== void 0 && !workerIterationLimit && !isResumableWorkerError(workerError)) {
+            const status = workerError.code === "cancelled" ? "cancelled" : "failed";
+            state = LoopStateSchema.parse({
+              ...state,
+              budget: {
+                ...state.budget,
+                cyclesUsed: cycle,
+                inputTokens: state.budget.inputTokens + cycleInputTokens,
+                outputTokens: state.budget.outputTokens + cycleOutputTokens
+              }
+            });
+            state = await this.#terminal(state, status, workerError.message, now());
+            yield { type: "loop-terminal", loopId, status, reason: workerError.message };
+            return;
           }
-          yield { type: "worker-event", event };
-        }
-        if (workerError !== void 0) {
           state = LoopStateSchema.parse({
             ...state,
-            budget: {
-              ...state.budget,
-              cyclesUsed: cycle,
-              inputTokens: state.budget.inputTokens + cycleInputTokens,
-              outputTokens: state.budget.outputTokens + cycleOutputTokens
-            }
+            pendingCycle: { cycle, startedAt, inputTokens: cycleInputTokens, outputTokens: cycleOutputTokens, workerText },
+            updatedAt: now()
           });
-          state = await this.#terminal(state, "failed", workerError, now());
-          yield { type: "loop-terminal", loopId, status: "failed", reason: workerError };
-          return;
+          await this.#options.persistence.save(state);
         }
+        await this.#options.onMemoryCheckpoint?.(loopId);
+        if (memoryRotationActive()) return;
         if (plan.commands.length === 0) {
           plan = await this.#options.inferVerification(executionWorkspace.root);
           if (plan.commands.length > 0) {
@@ -11661,8 +11903,22 @@ var LoopOrchestrator = class {
           passed: false,
           commands: [],
           summary: plan.needsHumanReason ?? "No deterministic verification command was found after the discovery cycle."
-        } : await this.#options.runVerifier(plan, executionWorkspace.root, request.signal);
+        } : await this.#options.runVerifier(plan, executionWorkspace.root, signal);
+        await this.#options.onMemoryCheckpoint?.(loopId);
+        if (memoryRotationActive()) return;
         const fingerprint2 = await this.#options.fingerprint(executionWorkspace.root);
+        let guardWarnings = [];
+        if (evidence.passed && this.#options.hallucinationGuard !== void 0) {
+          try {
+            await this.#options.onMemoryCheckpoint?.(loopId);
+            if (memoryRotationActive()) return;
+            const report = await this.#options.hallucinationGuard.evaluate(goal, workerText);
+            await this.#options.onMemoryCheckpoint?.(loopId);
+            if (memoryRotationActive()) return;
+            guardWarnings = [...report.blockingReasons, ...report.warnings];
+          } catch {
+          }
+        }
         const completedAt = now();
         state = LoopStateSchema.parse({
           ...state,
@@ -11681,7 +11937,8 @@ var LoopOrchestrator = class {
             outputTokens: cycleOutputTokens,
             workspaceFingerprint: fingerprint2,
             verification: evidence
-          }]
+          }].slice(-64),
+          pendingCycle: null
         });
         await this.#options.persistence.save(state);
         await this.#options.persistence.append({
@@ -11699,20 +11956,6 @@ var LoopOrchestrator = class {
           return;
         }
         if (evidence.passed) {
-          let guardWarnings = [];
-          if (this.#options.hallucinationGuard !== void 0) {
-            try {
-              const report = await this.#options.hallucinationGuard.evaluate(request.goal, workerText);
-              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;
-            } catch {
-            }
-          }
           const reason = [evidence.summary, ...guardWarnings].filter(Boolean).join("; ");
           state = await this.#terminal(state, "succeeded", reason, now());
           yield { type: "loop-terminal", loopId, status: "succeeded", reason };
@@ -11723,8 +11966,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;
@@ -11738,7 +11981,7 @@ ${evidence.summary}`;
             cycleCheckpoint: state.budget.cycleCheckpoint,
             tokenCheckpoint: state.budget.tokenCheckpoint
           };
-          const confirmation = await this.#options.confirmBudget(state, decision.dimensions, request.signal);
+          const confirmation = await this.#options.confirmBudget(state, decision.dimensions, signal);
           if (confirmation === "unavailable") {
             const reason = "Loop budget extension requires user confirmation.";
             state = await this.#terminal(state, "needs_human", reason, now());
@@ -11765,8 +12008,9 @@ ${evidence.summary}`;
         }
       }
     } catch (error) {
-      const status = request.signal.aborted ? "cancelled" : "failed";
-      const reason = request.signal.aborted ? "Loop cancelled by user." : message(error);
+      if (memoryRotationActive()) return;
+      const status = signal.aborted ? "cancelled" : "failed";
+      const reason = signal.aborted ? "Loop cancelled by user." : message(error);
       state = await this.#terminal(state, status, reason, now());
       yield { type: "loop-terminal", loopId, status, reason };
     }
@@ -11784,11 +12028,24 @@ ${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) {
+    const cycle = cycles[index];
+    if (`${cycle.workspaceFingerprint}
+${cycle.verification.summary}` !== signature) break;
+    count += 1;
+  }
+  return count;
+}
 
 // src/goal/orchestrator.ts
 import { createHash as createHash11 } from "crypto";
 import { writeFile as writeFile9, mkdir as mkdir10 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/goal/types.ts
 import { z as z21 } from "zod";
@@ -11851,6 +12108,11 @@ var GoalStateSchema = z21.object({
   planPath: z21.string().nullable(),
   verifyRounds: z21.number().int().min(0),
   workerRounds: z21.number().int().min(0),
+  /** Worker output checkpoint used to resume verification without rerunning tools. */
+  pendingVerification: z21.object({
+    round: z21.number().int().positive(),
+    finalResponse: z21.string().max(16e3)
+  }).strict().nullable().optional(),
   lastGaps: z21.array(GapSchema),
   gapFingerprint: z21.string(),
   stallStreak: z21.number().int().min(0),
@@ -11896,6 +12158,7 @@ ${objective}`
   ].join("\n");
 }
 async function runPlanner(options) {
+  await options.onProgress?.();
   const { adapter, model } = options.registry.get(options.modelId);
   const prompt = buildPlannerPrompt(options.objective);
   const messages = [{ role: "user", content: prompt }];
@@ -11907,6 +12170,7 @@ async function runPlanner(options) {
     tools: [],
     ...options.signal === void 0 ? {} : { signal: options.signal }
   })) {
+    await options.onProgress?.();
     if (event.type === "text") text += event.text;
     else if (event.type === "error") throw event.error;
     else if (event.type === "done") {
@@ -11953,7 +12217,7 @@ function extractJson(text) {
 // src/goal/classifier.ts
 import { createHash as createHash10 } from "crypto";
 import { readFile as readFile10 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function buildSkepticPrompt(evidence, plan, index) {
   const criteriaList = plan.criteria.map((c) => `  ${c.id}. [${c.type}] ${c.description}`).join("\n");
   return [
@@ -12013,7 +12277,7 @@ async function runClassifier(evidence, plan, options) {
   const skepticResults = await Promise.all(
     Array.from(
       { length: n },
-      (_, i) => runOneSkeptic(evidence, plan, i + 1, adapter, model, options.signal)
+      (_, i) => runOneSkeptic(evidence, plan, i + 1, adapter, model, options.signal, options.onProgress)
     )
   );
   const verdicts = [];
@@ -12030,7 +12294,8 @@ async function runClassifier(evidence, plan, options) {
   }
   return aggregate(verdicts);
 }
-async function runOneSkeptic(evidence, plan, index, adapter, model, signal) {
+async function runOneSkeptic(evidence, plan, index, adapter, model, signal, onProgress) {
+  await onProgress?.();
   const prompt = buildSkepticPrompt(evidence, plan, index);
   const messages = [{ role: "user", content: prompt }];
   let text = "";
@@ -12040,6 +12305,7 @@ async function runOneSkeptic(evidence, plan, index, adapter, model, signal) {
     tools: [],
     ...signal === void 0 ? {} : { signal }
   })) {
+    await onProgress?.();
     if (event.type === "text") text += event.text;
     else if (event.type === "error") throw event.error;
     else if (event.type === "done") break;
@@ -12130,7 +12396,7 @@ function computeFingerprint(gaps) {
 }
 async function collectEvidence(workspace, objective, finalResponse, priorGaps, contractHash2 = createHash10("sha256").update(objective).digest("hex"), hostVerification) {
   const workspaceState = await collectWorkspaceState(workspace);
-  const planPath2 = join14(workspace, ".flavor", "goal-plan.md");
+  const planPath2 = join15(workspace, ".flavor", "goal-plan.md");
   let planFile = null;
   try {
     planFile = await readFile10(planPath2, "utf8");
@@ -12194,7 +12460,7 @@ var GoalOrchestrator = class {
   async *run(request) {
     const timestamp2 = () => this.#options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
     const createdAt = timestamp2();
-    let state = {
+    const state = {
       id: this.#options.idFactory?.() ?? `goal-${Date.now().toString(36)}`,
       objective: request.goal,
       phase: "planning",
@@ -12203,6 +12469,7 @@ var GoalOrchestrator = class {
       planPath: null,
       verifyRounds: 0,
       workerRounds: 0,
+      pendingVerification: null,
       lastGaps: [],
       gapFingerprint: "",
       stallStreak: 0,
@@ -12211,91 +12478,164 @@ var GoalOrchestrator = class {
       createdAt,
       updatedAt: createdAt
     };
+    yield* this.#execute(state, request.signal);
+  }
+  /**
+   * Continue a goal whose process rotated onto a fresh heap. The persisted
+   * state decides where to pick up; an interrupted round simply runs again.
+   */
+  async *resume(request) {
+    const persistence = this.#options.persistence;
+    if (persistence === void 0 || persistence.load === void 0) {
+      throw new Error("Goal persistence does not support resume");
+    }
+    let state;
+    try {
+      state = await persistence.load(request.goalId);
+    } catch (error) {
+      yield { type: "goal-failed", reason: message(error) };
+      return;
+    }
+    if (state.status !== "active" && state.status !== "not_achieved") {
+      yield { type: "goal-failed", reason: `Goal "${state.id}" is ${state.status}; it cannot be resumed.` };
+      return;
+    }
+    yield { type: "goal-resumed", goalId: state.id, round: resumeStartRound(state) };
+    yield* this.#execute(state, request.signal);
+  }
+  async *#execute(initialState, signal) {
+    const timestamp2 = () => this.#options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+    let state = initialState;
     const persistState = async (patch) => {
       state = { ...state, ...patch, updatedAt: timestamp2() };
       await this.#options.persistence?.save(state);
     };
+    const memoryCheckpoint = async () => {
+      await this.#options.onMemoryCheckpoint?.(state.id);
+      if (memoryRotationActive()) throw new Error("Heap rotation requested");
+    };
     await persistState();
     const workspace = this.#options.workspace;
     let plan;
     let planPath2;
-    try {
-      request.signal.throwIfAborted();
-      plan = await runPlanner({
-        registry: this.#options.registry,
-        modelId: this.#options.plannerModelId,
-        objective: request.goal,
-        signal: request.signal
-      });
-      planPath2 = await writePlanFile(workspace, plan);
-      await persistState({ plan, planPath: planPath2, contractHash: contractHash(request.goal, plan) });
-      yield { type: "goal-plan-created", plan, planPath: planPath2 };
-    } catch (error) {
-      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 priorGaps = [];
-    let priorFingerprint = "";
-    let stallStreak = 0;
-    for (let round = 1; round <= this.#options.maxRounds; round++) {
-      request.signal.throwIfAborted();
-      const workerPrompt = buildWorkerPrompt(request.goal, plan, priorGaps, round);
-      await persistState({
-        phase: "executing",
-        status: "active",
-        workerRounds: round,
-        lastGaps: priorGaps,
-        gapFingerprint: priorFingerprint,
-        stallStreak
-      });
-      yield { type: "goal-worker-start", round };
-      let finalResponse = "";
-      let workerError;
-      try {
-        for await (const event of this.#options.runWorker({
-          goal: request.goal,
-          round,
-          workspace,
-          prompt: workerPrompt,
-          priorGaps: formatPriorGaps(priorGaps),
-          signal: request.signal
-        })) {
-          yield { type: "goal-worker-event", round, event };
-          if (event.type === "text") finalResponse += event.text;
-          if (event.type === "error") {
-            workerError = event.error.message;
-            break;
+    if (state.plan === null) {
+      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);
         }
-      } catch (error) {
-        workerError = message(error);
       }
-      if (workerError !== void 0) {
-        const reason = `Worker error in round ${round}: ${workerError}`;
-        await persistState({ phase: "complete", status: "failed" });
-        yield { type: "goal-failed", reason };
-        return;
+    } else {
+      plan = state.plan;
+      planPath2 = state.planPath ?? await writePlanFile(workspace, plan);
+      await persistState({ phase: "executing", status: "active", ...state.planPath === null ? { planPath: planPath2 } : {} });
+    }
+    let priorGaps = state.lastGaps;
+    let priorFingerprint = state.gapFingerprint;
+    let stallStreak = state.stallStreak;
+    const startRound = resumeStartRound(state);
+    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;
+      const pendingVerification = state.pendingVerification?.round === round ? state.pendingVerification : void 0;
+      let finalResponse = pendingVerification?.finalResponse ?? "";
+      if (pendingVerification === void 0) {
+        const workerPrompt = buildWorkerPrompt(state.objective, plan, priorGaps, round);
+        await persistState({
+          phase: "executing",
+          status: "active",
+          workerRounds: round,
+          pendingVerification: null,
+          lastGaps: priorGaps,
+          gapFingerprint: priorFingerprint,
+          stallStreak
+        });
+        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,
+            round,
+            workspace,
+            prompt: workerPrompt,
+            priorGaps: formatPriorGaps(priorGaps),
+            signal
+          })) {
+            yield { type: "goal-worker-event", round, event };
+            if (event.type === "text") finalResponse = `${finalResponse}${event.text}`.slice(-16e3);
+            if (event.type === "error") {
+              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 = { code: "unknown", message: message(error) };
+        }
+        if (workerMemoryPressure) return;
+        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;
+        }
+        await persistState({
+          phase: "verifying",
+          status: "active",
+          pendingVerification: { round, finalResponse }
+        });
       }
-      await persistState({ phase: "verifying", status: "active", verifyRounds: round });
       yield { type: "goal-verification-start", round };
-      const hostVerification = await this.#options.verifyHost?.(request.signal);
+      await this.#options.onMemoryCheckpoint?.(state.id);
+      if (memoryRotationActive()) return;
+      const hostVerification = await this.#options.verifyHost?.(signal);
+      await this.#options.onMemoryCheckpoint?.(state.id);
+      if (memoryRotationActive()) return;
       const evidence = await collectEvidence(
         workspace,
-        request.goal,
+        state.objective,
         finalResponse.slice(-4e3),
         // Last 4000 chars of response
         formatPriorGaps(priorGaps),
         state.contractHash,
         hostVerification
       );
-      await persistState({ evidenceRounds: [...state.evidenceRounds, {
+      await persistState({ evidenceRounds: [...state.evidenceRounds.filter((item) => item.round !== round), {
         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) {
@@ -12309,20 +12649,34 @@ 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: request.signal
-        });
-      } catch (error) {
-        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 {
         type: "goal-verdict",
         round,
@@ -12342,7 +12696,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",
@@ -12382,9 +12736,40 @@ var GoalOrchestrator = class {
 function contractHash(objective, plan) {
   return createHash11("sha256").update(JSON.stringify({ objective, plan })).digest("hex");
 }
+function resumeStartRound(state) {
+  if (state.pendingVerification !== void 0 && state.pendingVerification !== null) {
+    return state.pendingVerification.round;
+  }
+  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 = join15(workspace, ".flavor");
-  const planPath2 = join15(dir, "goal-plan.md");
+  const dir = join16(workspace, ".flavor");
+  const planPath2 = join16(dir, "goal-plan.md");
   await mkdir10(dir, { recursive: true });
   const criteriaText = plan.criteria.map((c) => `- [${c.type}] AC-${c.id}: ${c.description}`).join("\n");
   const content = [
@@ -12461,8 +12846,8 @@ function formatPriorGaps(gaps) {
 // src/goal/store.ts
 import { constants as constants4 } from "fs";
 import { randomUUID as randomUUID11 } from "crypto";
-import { lstat as lstat5, mkdir as mkdir11, open as open5, rename as rename4, rm as rm6 } from "fs/promises";
-import { dirname as dirname9, join as join16, relative as relative9, resolve as resolve12, sep as sep9 } from "path";
+import { lstat as lstat5, mkdir as mkdir11, open as open5, readFile as readFile11, rename as rename4, rm as rm6, stat as stat6 } from "fs/promises";
+import { dirname as dirname9, join as join17, relative as relative9, resolve as resolve12, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -12470,7 +12855,7 @@ var GoalStore = class {
   #maxBytes;
   constructor(options) {
     this.#workspace = resolve12(options.workspace);
-    this.#root = join16(this.#workspace, ".flavor", "goals");
+    this.#root = join17(this.#workspace, ".flavor", "goals");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   }
   async save(input) {
@@ -12478,13 +12863,13 @@ var GoalStore = class {
     await assertNoSymlink(this.#workspace, dirname9(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join16(this.#root, `${state.id}.json`);
+    const target = join17(this.#root, `${state.id}.json`);
     const body = `${JSON.stringify(state, null, 2)}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) {
       throw new Error(`Goal state exceeds maximum size of ${this.#maxBytes} bytes`);
     }
-    const temporary = join16(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
+    const temporary = join17(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
       handle = await open5(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
@@ -12498,6 +12883,28 @@ var GoalStore = class {
       await rm6(temporary, { force: true }).catch(() => void 0);
     }
   }
+  /** Reload a persisted goal so a rotated process can resume it. */
+  async load(goalId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(goalId)) {
+      throw new Error(`Goal "${goalId}" was not found`);
+    }
+    await assertNoSymlink(this.#workspace, dirname9(this.#root));
+    await assertNoSymlink(this.#workspace, this.#root);
+    const target = join17(this.#root, `${goalId}.json`);
+    try {
+      const metadata = await stat6(target);
+      if (!metadata.isFile() || metadata.size > this.#maxBytes) {
+        throw new Error("Goal state is not a bounded regular file");
+      }
+      const raw = await readFile11(target, "utf8");
+      return GoalStateSchema.parse(JSON.parse(raw));
+    } catch (error) {
+      if (isCode4(error, "ENOENT")) throw new Error(`Goal "${goalId}" was not found`);
+      const quarantine = `${target}.corrupt-${Date.now()}-${randomUUID11().slice(0, 8)}`;
+      await rename4(target, quarantine).catch(() => void 0);
+      throw new Error(`Goal "${goalId}" is corrupt and was quarantined`);
+    }
+  }
 };
 async function assertNoSymlink(root, target) {
   let cursor = resolve12(target);
@@ -12524,8 +12931,8 @@ function isCode4(error, code) {
 }
 
 // src/loop/isolation.ts
-import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile11 } from "fs/promises";
-import { join as join17, resolve as resolve13 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile12 } from "fs/promises";
+import { join as join18, resolve as resolve13 } from "path";
 var CODE_CHANGE = /\b(?:fix|implement|add|update|change|modify|refactor|build|create|remove|delete|write|migrate)\b|修复|实现|添加|更新|修改|重构|创建|删除|迁移/i;
 var READ_ONLY = /\b(?:review|analy[sz]e|inspect|explain|research|investigate|audit|summari[sz]e|report)\b|调研|分析|审查|检查|解释|研究|总结|报告/i;
 function inferGoalIntent(goal) {
@@ -12548,8 +12955,8 @@ async function prepareLoopWorkspace(options) {
     return { kind: "needs_human", reason: "The workspace has uncommitted changes that a new worktree would omit." };
   }
   options.signal?.throwIfAborted();
-  const worktrees = join17(root, ".worktrees");
-  const path = join17(worktrees, `loop-${options.loopId}`);
+  const worktrees = join18(root, ".worktrees");
+  const path = join18(worktrees, `loop-${options.loopId}`);
   const branch = `loop/${options.loopId}`;
   try {
     await ensureWorktreeDirectoryIgnored(root);
@@ -12579,12 +12986,12 @@ async function ensureWorktreeDirectoryIgnored(root) {
   const commonDirectory = await git(root, ["rev-parse", "--git-common-dir"]);
   if (commonDirectory.code !== 0) throw new Error(commonDirectory.stderr.trim() || "Git common directory is unavailable");
   const gitDirectory = resolve13(root, commonDirectory.stdout.trim());
-  const infoDirectory = join17(gitDirectory, "info");
-  const excludePath = join17(infoDirectory, "exclude");
+  const infoDirectory = join18(gitDirectory, "info");
+  const excludePath = join18(infoDirectory, "exclude");
   await mkdir12(infoDirectory, { recursive: true });
   let existing = "";
   try {
-    existing = await readFile11(excludePath, "utf8");
+    existing = await readFile12(excludePath, "utf8");
   } catch (error) {
     if (!(typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")) throw error;
   }
@@ -12595,8 +13002,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 
 // src/loop/store.ts
 import { constants as constants5 } from "fs";
-import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile12, realpath as realpath8, rename as rename5, rm as rm7, stat as stat6 } from "fs/promises";
-import { dirname as dirname10, join as join18, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
+import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile13, realpath as realpath8, rename as rename5, rm as rm7, stat as stat7 } from "fs/promises";
+import { dirname as dirname10, join as join19, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
 import { randomUUID as randomUUID12 } from "crypto";
 var LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_MAX_BYTES2 = 5 * 1024 * 1024;
@@ -12607,7 +13014,7 @@ var LoopStore = class {
   #appendTails = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#workspace = resolve14(options.workspace);
-    this.#root = join18(this.#workspace, ".flavor", "loops");
+    this.#root = join19(this.#workspace, ".flavor", "loops");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES2;
   }
   async create(state) {
@@ -12624,11 +13031,11 @@ var LoopStore = class {
     const state = LoopStateSchema.parse(input);
     await this.#assertWorkspace(state.workspace);
     const directory = await this.#prepare(state.loopId);
-    const target = join18(directory, "state.json");
+    const target = join19(directory, "state.json");
     const body = `${JSON.stringify(state, null, 2)}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Loop state exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join18(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
+    const temporary = join19(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
       handle = await open6(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
@@ -12644,11 +13051,11 @@ var LoopStore = class {
   }
   async load(loopId) {
     const directory = await this.#safeExisting(loopId);
-    const target = join18(directory, "state.json");
+    const target = join19(directory, "state.json");
     try {
-      const metadata = await stat6(target);
+      const metadata = await stat7(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) throw new Error("Loop state is not a bounded regular file");
-      const raw = await readFile12(target, "utf8");
+      const raw = await readFile13(target, "utf8");
       const state = LoopStateSchema.parse(JSON.parse(raw));
       await this.#assertWorkspace(state.workspace);
       return state;
@@ -12664,7 +13071,7 @@ var LoopStore = class {
     const previous = this.#appendTails.get(event.loopId) ?? Promise.resolve();
     const next = previous.catch(() => void 0).then(async () => {
       const directory = await this.#prepare(event.loopId);
-      const path = join18(directory, "events.jsonl");
+      const path = join19(directory, "events.jsonl");
       const handle = await open6(path, constants5.O_CREAT | constants5.O_APPEND | constants5.O_WRONLY, 384);
       try {
         await handle.writeFile(`${JSON.stringify(event)}
@@ -12681,7 +13088,7 @@ var LoopStore = class {
     await assertNoSymlink2(this.#workspace, dirname10(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join18(this.#root, loopId);
+    const directory = join19(this.#root, loopId);
     await mkdir13(directory, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
@@ -12689,7 +13096,7 @@ var LoopStore = class {
   async #safeExisting(loopId) {
     validateId(loopId);
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join18(this.#root, loopId);
+    const directory = join19(this.#root, loopId);
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
   }
@@ -12737,13 +13144,13 @@ function isCode5(error, code) {
 }
 
 // src/loop/verifier.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join20 } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join21 } from "path";
 
 // src/tools/shell.ts
 import { spawn as spawn4 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
-import { basename as basename5, delimiter as delimiter2, isAbsolute as isAbsolute9, join as join19, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
+import { basename as basename5, delimiter as delimiter2, isAbsolute as isAbsolute9, join as join20, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
 import { z as z23 } from "zod";
 
 // src/tools/jobs.ts
@@ -13406,7 +13813,7 @@ function decodeOutput(buffer) {
   return new TextDecoder(encoding).decode(buffer);
 }
 function shellEnvironment(root, environment) {
-  const localBin = join19(root, "node_modules", ".bin");
+  const localBin = join20(root, "node_modules", ".bin");
   if (!existsSync4(localBin)) return environment;
   const pathKey = Object.keys(environment).find((key) => key.toLowerCase() === "path") ?? "PATH";
   const current = environment[pathKey] ?? "";
@@ -13506,16 +13913,17 @@ 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();
-  const packageJson = await optionalJson(join20(workspace, "package.json"));
+  const packageJson = await optionalJson(join21(workspace, "package.json"));
   const scripts = isRecord3(packageJson?.scripts) ? packageJson.scripts : {};
   for (const name of SCRIPT_PRIORITY) {
     if (typeof scripts[name] !== "string" || isUnconditionalPassThrough(scripts[name])) continue;
     add(commands, seen, npmScript(name));
   }
-  const flavor = await optionalText(join20(workspace, "FLAVOR.md"));
+  const flavor = await optionalText(join21(workspace, "FLAVOR.md"));
   if (flavor !== void 0) {
     for (const match of flavor.matchAll(/^- `([^`]+)`\s*$/gm)) {
       const parsed = parseTrustedCommand(match[1] ?? "");
@@ -13541,9 +13949,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)}.` };
@@ -13551,6 +13959,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] };
 }
@@ -13582,7 +13998,7 @@ function isUnconditionalPassThrough(script) {
 }
 async function optionalText(path) {
   try {
-    return await readFile13(path, "utf8");
+    return await readFile14(path, "utf8");
   } catch (error) {
     if (isCode6(error, "ENOENT")) return void 0;
     throw error;
@@ -13603,7 +14019,7 @@ function isCode6(error, code) {
 
 // src/models/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile15 } from "fs/promises";
 
 // src/utils/json.ts
 function safeParseJson(input) {
@@ -13652,11 +14068,11 @@ function isEnvTruthy(value) {
 
 // src/utils/log.ts
 import { appendFile as appendFile3, mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname11, join as join21, resolve as resolve16 } from "path";
+import { dirname as dirname11, join as join22, resolve as resolve16 } from "path";
 var pending = Promise.resolve();
 var usagePending = Promise.resolve();
 function usageLogPath() {
-  return process.env.FLAVOR_USAGE_FILE ?? join21(process.cwd(), ".flavor", "usage.jsonl");
+  return process.env.FLAVOR_USAGE_FILE ?? join22(process.cwd(), ".flavor", "usage.jsonl");
 }
 var usageSessionId = "unknown";
 var truncateOnNextAppend = false;
@@ -13685,7 +14101,7 @@ var AuditLogger = class {
   #path;
   #closed = false;
   constructor(workspace) {
-    this.#path = join21(resolve16(workspace), ".flavor", "audit.jsonl");
+    this.#path = join22(resolve16(workspace), ".flavor", "audit.jsonl");
   }
   get path() {
     return this.#path;
@@ -13709,6 +14125,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)",
@@ -13831,6 +14276,7 @@ var AnthropicModelAdapter = class {
     void appendUsageLog(line);
   }
   async *stream(request) {
+    const requestAbort = createScopedAbortSignal(request.signal);
     let inputTokens = 0;
     let outputTokens = 0;
     let hasUsage = false;
@@ -13905,7 +14351,7 @@ var AnthropicModelAdapter = class {
             source: {
               type: "base64",
               media_type: block.mediaType,
-              data: (await readFile14(block.source.path)).toString("base64")
+              data: (await readFile15(block.source.path)).toString("base64")
             }
           }));
           if (message2.cacheBreakpoint && Array.isArray(content) && content.length > 0) {
@@ -13954,13 +14400,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;
         }
@@ -14072,6 +14518,8 @@ var AnthropicModelAdapter = class {
         };
       }
       yield { type: "error", error: normalizeProviderError(error) };
+    } finally {
+      requestAbort.dispose();
     }
   }
 };
@@ -14125,7 +14573,7 @@ function resolveCacheProfile(input) {
 
 // src/models/openai.ts
 import OpenAI from "openai";
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 async function toInput(message2) {
   if (message2.role === "tool") {
     if (!message2.toolCallId) throw new Error("Tool messages require toolCallId");
@@ -14137,7 +14585,7 @@ async function toInput(message2) {
   }
   const content = typeof message2.content === "string" ? message2.content : await Promise.all(message2.content.map(async (block) => block.type === "text" ? { type: "input_text", text: block.text } : {
     type: "input_image",
-    image_url: `data:${block.mediaType};base64,${(await readFile15(block.source.path)).toString("base64")}`,
+    image_url: `data:${block.mediaType};base64,${(await readFile16(block.source.path)).toString("base64")}`,
     detail: "auto"
   }));
   return [
@@ -14216,6 +14664,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();
@@ -14232,7 +14681,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);
@@ -14326,6 +14775,8 @@ var OpenAIModelAdapter = class {
       }
     } catch (error) {
       yield { type: "error", error: normalizeProviderError(error) };
+    } finally {
+      requestAbort.dispose();
     }
   }
 };
@@ -14559,7 +15010,7 @@ import {
 
 // src/utils/version.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname12, join as join22 } from "path";
+import { dirname as dirname12, join as join23 } from "path";
 import { fileURLToPath } from "url";
 var cached;
 function packageVersion() {
@@ -14567,7 +15018,7 @@ function packageVersion() {
   let directory = dirname12(fileURLToPath(import.meta.url));
   for (; ; ) {
     try {
-      const manifest = JSON.parse(readFileSync2(join22(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync2(join23(directory, "package.json"), "utf8"));
       if (typeof manifest.version === "string" && manifest.version.length > 0) {
         cached = manifest.version;
         return cached;
@@ -14994,8 +15445,8 @@ function isStoredToken(value) {
 }
 
 // src/permissions/policy.ts
-import { readFile as readFile16 } from "fs/promises";
-import { join as join23, resolve as resolve18 } from "path";
+import { readFile as readFile17 } from "fs/promises";
+import { join as join24, resolve as resolve18 } from "path";
 import { z as z25 } from "zod";
 var DecisionSchema2 = z25.enum(["allow", "ask", "deny"]);
 var PrefixSchema = z25.array(z25.string().min(1).max(1024)).min(1).max(64);
@@ -15032,15 +15483,15 @@ var CompiledPermissionPolicy = class {
 async function loadPermissionPolicy(options) {
   const sources = [
     ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve18(options.managedPath) }],
-    { tier: "user", path: join23(resolve18(options.home), ".flavor-code", "permissions.json") },
-    { tier: "project", path: join23(resolve18(options.workspace), ".flavor", "permissions.json") },
-    { tier: "local", path: join23(resolve18(options.workspace), ".flavor", "permissions.local.json") }
+    { tier: "user", path: join24(resolve18(options.home), ".flavor-code", "permissions.json") },
+    { tier: "project", path: join24(resolve18(options.workspace), ".flavor", "permissions.json") },
+    { tier: "local", path: join24(resolve18(options.workspace), ".flavor", "permissions.local.json") }
   ];
   const rules = [];
   for (const source of sources) {
     let raw;
     try {
-      raw = await readFile16(source.path, "utf8");
+      raw = await readFile17(source.path, "utf8");
     } catch (error) {
       if (isCode7(error, "ENOENT")) continue;
       throw error;
@@ -15806,8 +16257,8 @@ function createSkillResourceTool(registry) {
 
 // src/session/store.ts
 import { constants as constants7 } from "fs";
-import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile17, readdir as readdir6, realpath as realpath10, rename as rename6, rm as rm8, stat as stat7 } from "fs/promises";
-import { basename as basename6, dirname as dirname14, join as join24, relative as relative13, resolve as resolve20, sep as sep13 } from "path";
+import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile18, readdir as readdir6, realpath as realpath10, rename as rename6, rm as rm8, stat as stat8 } from "fs/promises";
+import { basename as basename6, dirname as dirname14, join as join25, relative as relative13, resolve as resolve20, sep as sep13 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 import { z as z27 } from "zod";
 
@@ -15821,6 +16272,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 };
 }
@@ -16181,11 +16637,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) {
@@ -16199,13 +16653,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;
@@ -16229,16 +16680,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);
@@ -16340,15 +16787,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) {
@@ -16362,19 +16812,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
@@ -16503,7 +17029,7 @@ var SessionStore = class {
   #maxSessions;
   constructor(options) {
     this.#workspace = resolve20(options.workspace);
-    this.#sessions = join24(this.#workspace, ".flavor", "sessions");
+    this.#sessions = join25(this.#workspace, ".flavor", "sessions");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_SESSION_BYTES;
     if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes < 256) throw new Error("maxBytes must be an integer of at least 256");
     this.#maxSessions = options.maxSessions ?? 50;
@@ -16535,7 +17061,7 @@ var SessionStore = class {
     const body = `${lines.join("\n")}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Session exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join24(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
+    const temporary = join25(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
     let handle;
     try {
       handle = await open7(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
@@ -16554,7 +17080,7 @@ var SessionStore = class {
   async acquireLease(sessionId) {
     SessionIdSchema.parse(sessionId);
     await this.#prepareDirectory();
-    const path = join24(this.#sessions, `.${sessionId}.lock`);
+    const path = join25(this.#sessions, `.${sessionId}.lock`);
     const token = JSON.stringify({ pid: process.pid, nonce: randomUUID13(), createdAt: (/* @__PURE__ */ new Date()).toISOString() });
     for (let attempt = 0; attempt < 3; attempt += 1) {
       let handle;
@@ -16572,7 +17098,7 @@ var SessionStore = class {
           release: async () => {
             if (released) return;
             try {
-              if (await readFile17(path, "utf8") === token) await rm8(path, { force: true });
+              if (await readFile18(path, "utf8") === token) await rm8(path, { force: true });
             } catch (error) {
               if (!isCode8(error, "ENOENT")) throw error;
             }
@@ -16688,14 +17214,14 @@ var SessionStore = class {
       if (isCode8(error, "ENOENT")) return;
       throw error;
     }
-    const owner2 = await reclaimStaleSessionLock(join24(this.#sessions, `.${sessionId}.lock`));
+    const owner2 = await reclaimStaleSessionLock(join25(this.#sessions, `.${sessionId}.lock`));
     if (owner2 !== void 0) throw new Error(`Session "${sessionId}" is active in process ${owner2} and cannot be deleted`);
     const path = this.#path(sessionId);
     try {
       const metadata = await lstat8(path);
       if (!metadata.isFile()) throw new Error("Session path is not a regular file");
       await rm8(path);
-      await rm8(join24(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join25(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     } catch (error) {
       if (!isCode8(error, "ENOENT")) throw error;
     }
@@ -16711,14 +17237,14 @@ var SessionStore = class {
     if (entries.length <= this.#maxSessions) return;
     let retained = 0;
     for (const entry2 of entries) {
-      const owner2 = await reclaimStaleSessionLock(join24(this.#sessions, `.${entry2.sessionId}.lock`));
+      const owner2 = await reclaimStaleSessionLock(join25(this.#sessions, `.${entry2.sessionId}.lock`));
       if (owner2 !== void 0) continue;
       if (retained < this.#maxSessions) {
         retained += 1;
         continue;
       }
       await rm8(this.#path(entry2.sessionId), { force: true }).catch(() => void 0);
-      await rm8(join24(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join25(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     }
   }
   async #assertWorkspace(stored) {
@@ -16766,14 +17292,14 @@ function storedSessionVersion(raw) {
 }
 async function reclaimStaleSessionLock(path) {
   try {
-    const token = await readFile17(path, "utf8");
-    const metadata = await stat7(path);
+    const token = await readFile18(path, "utf8");
+    const metadata = await stat8(path);
     const owner2 = parseSessionLockOwner(token);
     if (owner2 !== void 0 && isProcessAlive2(owner2)) return owner2;
     if (owner2 === void 0 && Date.now() - metadata.mtimeMs <= INVALID_SESSION_LOCK_STALE_MS) {
       throw new Error(`Session writer lock ${path} is incomplete or invalid; retry after the owning process exits`);
     }
-    if (await readFile17(path, "utf8") !== token) return void 0;
+    if (await readFile18(path, "utf8") !== token) return void 0;
     const stale = `${path}.stale-${process.pid}-${randomUUID13()}`;
     try {
       await rename6(path, stale);
@@ -16806,10 +17332,10 @@ function isProcessAlive2(pid) {
   }
 }
 async function boundedRead(path, maxBytes) {
-  const metadata = await stat7(path);
+  const metadata = await stat8(path);
   if (!metadata.isFile()) throw new Error("Session path is not a regular file");
   if (metadata.size > maxBytes) throw new Error(`Session exceeds maximum read size of ${maxBytes} bytes`);
-  const value = await readFile17(path);
+  const value = await readFile18(path);
   if (value.byteLength > maxBytes) throw new Error(`Session exceeds maximum read size of ${maxBytes} bytes`);
   return value.toString("utf8");
 }
@@ -17001,14 +17527,14 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 
 // src/session/tree.ts
 import { randomUUID as randomUUID15 } from "crypto";
-import { mkdir as mkdir17, readFile as readFile19, rename as rename8, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname16, join as join26, resolve as resolve22 } from "path";
+import { mkdir as mkdir17, readFile as readFile20, rename as rename8, writeFile as writeFile11 } from "fs/promises";
+import { dirname as dirname16, join as join27, resolve as resolve22 } from "path";
 
 // src/session/checkpoint.ts
 import { createHash as createHash15, randomUUID as randomUUID14 } from "crypto";
 import { execFile as execFile2 } from "child_process";
-import { lstat as lstat9, mkdir as mkdir16, open as open8, readFile as readFile18, readdir as readdir7, rename as rename7, rm as rm9, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname15, join as join25, relative as relative14, resolve as resolve21, sep as sep14 } from "path";
+import { lstat as lstat9, mkdir as mkdir16, open as open8, readFile as readFile19, readdir as readdir7, rename as rename7, rm as rm9, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname15, join as join26, relative as relative14, resolve as resolve21, sep as sep14 } from "path";
 var EXCLUDED = /* @__PURE__ */ new Set([".git", ".flavor", "node_modules", "dist", "build", "release", ".worktrees"]);
 var MAX_FILE_BYTES = 16 * 1024 * 1024;
 var MAX_TOTAL_BYTES = 128 * 1024 * 1024;
@@ -17021,9 +17547,9 @@ var WorkspaceCheckpointStore = class {
   #maxTotalBytes;
   constructor(options) {
     this.#workspace = resolve21(options.workspace);
-    this.#root = join25(this.#workspace, ".flavor", "checkpoints");
-    this.#objects = join25(this.#root, "objects");
-    this.#manifests = join25(this.#root, "manifests");
+    this.#root = join26(this.#workspace, ".flavor", "checkpoints");
+    this.#objects = join26(this.#root, "objects");
+    this.#manifests = join26(this.#root, "manifests");
     this.#maxFileBytes = options.maxFileBytes ?? MAX_FILE_BYTES;
     this.#maxTotalBytes = options.maxTotalBytes ?? MAX_TOTAL_BYTES;
   }
@@ -17041,9 +17567,9 @@ var WorkspaceCheckpointStore = class {
       if (info.size > this.#maxFileBytes) throw new Error(`Checkpoint file exceeds size limit: ${path}`);
       total += info.size;
       if (total > this.#maxTotalBytes) throw new Error("Checkpoint exceeds total size limit");
-      const content = await readFile18(absolute);
+      const content = await readFile19(absolute);
       const digest = createHash15("sha256").update(content).digest("hex");
-      const objectPath = join25(this.#objects, digest);
+      const objectPath = join26(this.#objects, digest);
       try {
         const handle = await open8(objectPath, "wx");
         try {
@@ -17063,12 +17589,12 @@ var WorkspaceCheckpointStore = class {
       ...label === void 0 || label.trim().length === 0 ? {} : { label: label.trim() },
       files
     };
-    await atomicJson(join25(this.#manifests, `${checkpoint.id}.json`), checkpoint);
+    await atomicJson(join26(this.#manifests, `${checkpoint.id}.json`), checkpoint);
     return checkpoint;
   }
   async load(id) {
     if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-    const value = JSON.parse(await readFile18(join25(this.#manifests, `${id}.json`), "utf8"));
+    const value = JSON.parse(await readFile19(join26(this.#manifests, `${id}.json`), "utf8"));
     if (value.version !== 1 || value.id !== id || !Array.isArray(value.files)) throw new Error("Invalid checkpoint manifest");
     for (const file of value.files) {
       contained(this.#workspace, file.path);
@@ -17080,7 +17606,7 @@ var WorkspaceCheckpointStore = class {
     const checkpoint = await this.load(id);
     const objects = /* @__PURE__ */ new Map();
     for (const file of checkpoint.files) {
-      const object = await readFile18(join25(this.#objects, file.digest));
+      const object = await readFile19(join26(this.#objects, file.digest));
       if (object.length !== file.size || createHash15("sha256").update(object).digest("hex") !== file.digest) {
         throw new Error(`Checkpoint object is corrupt: ${file.digest}`);
       }
@@ -17103,7 +17629,7 @@ var WorkspaceCheckpointStore = class {
   }
 };
 async function discoverFiles(workspace) {
-  if (await exists2(join25(workspace, ".git"))) {
+  if (await exists2(join26(workspace, ".git"))) {
     const listed = await gitFiles(workspace);
     return listed.filter((path) => !EXCLUDED.has(path.split("/")[0] ?? "")).sort();
   }
@@ -17112,7 +17638,7 @@ async function discoverFiles(workspace) {
     const entries = await readdir7(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (EXCLUDED.has(entry2.name)) continue;
-      const absolute = join25(directory, entry2.name);
+      const absolute = join26(directory, entry2.name);
       const path = normalizeRelative(relative14(workspace, absolute));
       if (entry2.isSymbolicLink()) throw new Error(`Checkpoint refuses symbolic link: ${path}`);
       if (entry2.isDirectory()) await walk(absolute);
@@ -17187,17 +17713,17 @@ var SessionHistory = class _SessionHistory {
   #leafId;
   #unrevert;
   constructor(options, document) {
-    this.#path = join26(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    this.#path = join27(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     this.#checkpoints = new WorkspaceCheckpointStore({ workspace: options.workspace });
     this.#restoreContext = options.restoreContext;
     this.#nodes = boundedNodes(document.nodes);
     this.#leafId = document.leafId !== null && this.#nodes.some((node) => node.id === document.leafId) ? document.leafId : this.#nodes.at(-1)?.id ?? null;
   }
   static async open(options) {
-    const path = join26(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    const path = join27(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     let document = { version: 1, sessionId: options.sessionId, leafId: null, nodes: [] };
     try {
-      const parsed = JSON.parse(await readFile19(path, "utf8"));
+      const parsed = JSON.parse(await readFile20(path, "utf8"));
       validate(parsed, options.sessionId);
       document = parsed;
     } catch (error) {
@@ -17210,6 +17736,10 @@ var SessionHistory = class _SessionHistory {
   get leafId() {
     return this.#leafId;
   }
+  /** Cheap retained-node count for the rotation census (no cloning). */
+  get nodeCount() {
+    return this.#nodes.length;
+  }
   tree() {
     return this.#nodes.map((node) => structuredClone(node));
   }
@@ -17324,35 +17854,70 @@ function isCode10(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
 
-// src/utils/memory-restart.ts
-import { join as join27 } from "path";
-var MEMORY_RESTART_EXIT_CODE = 75;
-var MEMORY_RESTART_MARKER_FILE = "memory-restart.json";
-var MEMORY_RESTART_WINDOW_MS = 30 * 60 * 1e3;
-function memoryRestartMarkerPath(workspace) {
-  return join27(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
+// src/utils/rotation-census.ts
+import { mkdirSync as mkdirSync2, readdirSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
+import { join as join28 } from "path";
+import { writeHeapSnapshot } from "v8";
+var CENSUS_PREFIX = "rotation-census-";
+var SNAPSHOT_PREFIX = "heap-";
+var KEEP_CENSUS_FILES = 5;
+var KEEP_SNAPSHOT_FILES = 2;
+function censusHeapBlock(reading) {
+  const usage = process.memoryUsage();
+  const mb = (bytes) => Math.round(bytes / 1048576);
+  return {
+    heapUsedMb: mb(reading.heapUsed),
+    heapLimitMb: mb(reading.heapLimit),
+    rawRatio: Number(reading.ratio.toFixed(3)),
+    ...reading.verifiedRatio === void 0 ? {} : { verifiedRatio: Number(reading.verifiedRatio.toFixed(3)) },
+    gcVerified: reading.gcVerified,
+    rssMb: mb(usage.rss),
+    externalMb: mb(usage.external),
+    arrayBuffersMb: mb(usage.arrayBuffers),
+    ...reading.memoryLimit === void 0 ? {} : { memoryLimitMb: mb(reading.memoryLimit) },
+    ...reading.rssRatio === void 0 ? {} : { rssRatio: Number(reading.rssRatio.toFixed(3)) }
+  };
 }
-function nextMemoryRestartMarker(previous, sessionId, now) {
-  const reusable = previous !== void 0 && previous.sessionId === sessionId && now.getTime() - Date.parse(previous.requestedAt) < MEMORY_RESTART_WINDOW_MS && Number.isInteger(previous.attempts) && previous.attempts > 0;
-  return { sessionId, requestedAt: now.toISOString(), attempts: reusable ? previous.attempts + 1 : 1 };
+function writeRotationCensus(workspace, census) {
+  try {
+    const directory = join28(workspace, ".flavor", "tmp");
+    mkdirSync2(directory, { recursive: true });
+    const path = join28(directory, `${CENSUS_PREFIX}${Date.now()}.json`);
+    writeFileSync(path, `${JSON.stringify(census, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    prune(directory, CENSUS_PREFIX, ".json", KEEP_CENSUS_FILES);
+    return path;
+  } catch {
+    return void 0;
+  }
 }
-function parseMemoryRestartMarker(json) {
+function writeRotationHeapSnapshot(workspace) {
   try {
-    const value = JSON.parse(json);
-    if (typeof value.sessionId !== "string" || typeof value.requestedAt !== "string" || typeof value.attempts !== "number") {
-      return void 0;
-    }
-    return { sessionId: value.sessionId, requestedAt: value.requestedAt, attempts: value.attempts };
+    const directory = join28(workspace, ".flavor", "tmp");
+    mkdirSync2(directory, { recursive: true });
+    const path = join28(directory, `${SNAPSHOT_PREFIX}${Date.now()}.heapsnapshot`);
+    writeHeapSnapshot(path);
+    prune(directory, SNAPSHOT_PREFIX, ".heapsnapshot", KEEP_SNAPSHOT_FILES);
+    return path;
   } catch {
     return void 0;
   }
 }
+function prune(directory, prefix, suffix, keep) {
+  const stale = readdirSync(directory).filter((name) => name.startsWith(prefix) && name.endsWith(suffix)).sort().slice(0, -keep);
+  for (const name of stale) {
+    try {
+      unlinkSync2(join28(directory, name));
+    } catch {
+    }
+  }
+}
 
 // src/sleep/organizer.ts
 import { constants as constants8 } from "fs";
 import { randomUUID as randomUUID16 } from "crypto";
 import { lstat as lstat10, mkdir as mkdir18, open as open9, readdir as readdir8, realpath as realpath11, rename as rename9, rm as rm10 } from "fs/promises";
-import { isAbsolute as isAbsolute11, join as join28, relative as relative15, resolve as resolve23, sep as sep15 } from "path";
+import { isAbsolute as isAbsolute11, join as join29, relative as relative15, resolve as resolve23, sep as sep15 } from "path";
 import { z as z28 } from "zod";
 var DateKeySchema = z28.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = z28.object({
@@ -17407,7 +17972,7 @@ var ProjectSleepOrganizer = class {
   #generate;
   constructor(options) {
     this.#workspace = resolve23(options.workspace);
-    this.#sleepDirectory = join28(this.#workspace, ".flavor", "sleep");
+    this.#sleepDirectory = join29(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -17416,7 +17981,7 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join28(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join29(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
       lock = await open9(lockPath, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
@@ -17451,7 +18016,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
       }
       if (review === void 0) throw lastError;
       const filename2 = `${date}-${filenameSummary(review.title)}.md`;
-      const path = join28(this.#sleepDirectory, filename2);
+      const path = join29(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path, markdown);
       return { status: "written", date, path, sessionCount: documents.length };
@@ -17493,7 +18058,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join28(this.#workspace, ".flavor");
+    const flavorDirectory = join29(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir18(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -17507,7 +18072,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     return (await readdir8(this.#sleepDirectory, { withFileTypes: true })).some((entry2) => entry2.isFile() && entry2.name.startsWith(prefix) && entry2.name.endsWith(".md"));
   }
   async #atomicWrite(path, content) {
-    const temporary = join28(this.#sleepDirectory, `.${randomUUID16()}.tmp`);
+    const temporary = join29(this.#sleepDirectory, `.${randomUUID16()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
@@ -17881,7 +18446,7 @@ function computeSessionStats(documents) {
 
 // src/tools/files.ts
 import { constants as constants9 } from "fs";
-import { mkdir as mkdir19, open as open10, readFile as readFile20, realpath as realpath12, rename as rename10, rm as rm11, stat as stat8 } from "fs/promises";
+import { mkdir as mkdir19, open as open10, readFile as readFile21, realpath as realpath12, rename as rename10, rm as rm11, stat as stat9 } from "fs/promises";
 import { dirname as dirname17, isAbsolute as isAbsolute12, relative as relative16, resolve as resolve24, sep as sep16 } from "path";
 import { randomUUID as randomUUID17 } from "crypto";
 import { z as z29 } from "zod";
@@ -18034,7 +18599,7 @@ function createReadTool(workspace, options = {}) {
     execute: async (input, signal) => {
       abortIfNeeded(signal);
       const path = await guard.existing(input.path);
-      const info = await stat8(path);
+      const info = await stat9(path);
       const maxBytes = input.maxBytes ?? MAX_READ_BYTES;
       if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0 || maxBytes > MAX_READ_BYTES) {
         throw new Error(`maxBytes must be a positive integer no greater than ${MAX_READ_BYTES}`);
@@ -18243,7 +18808,7 @@ async function atomicWrite(path, content, signal, expectedVersion) {
   const temporary = `${path}.${randomUUID17()}.tmp`;
   let mode;
   try {
-    mode = (await stat8(path)).mode & 511;
+    mode = (await stat9(path)).mode & 511;
   } catch (error) {
     if (!isMissing2(error)) throw error;
   }
@@ -18266,7 +18831,7 @@ async function atomicWrite(path, content, signal, expectedVersion) {
   }
 }
 async function readText(path) {
-  const contents = await readFile20(path);
+  const contents = await readFile21(path);
   if (isBinary(contents)) throw new Error("Cannot edit binary file as text");
   return decodeFileText(contents);
 }
@@ -18292,7 +18857,7 @@ async function assertMutationVersion(path, expected, observations) {
 }
 async function fileVersion(path) {
   try {
-    return versionOfStat(await stat8(path));
+    return versionOfStat(await stat9(path));
   } catch (error) {
     if (isMissing2(error)) return ABSENT_VERSION;
     throw error;
@@ -18303,7 +18868,7 @@ function versionOfStat(info) {
 }
 async function readOptionalPresentationText(path) {
   try {
-    const contents = await readFile20(path);
+    const contents = await readFile21(path);
     return isBinary(contents) ? { exists: true } : { exists: true, text: contents.toString("utf8") };
   } catch (error) {
     return isMissing2(error) ? { exists: false } : { exists: true };
@@ -18614,7 +19179,7 @@ function matchesLines(source, start, expected) {
 
 // src/tools/search.ts
 import { spawn as spawn5 } from "child_process";
-import { open as open11, opendir, stat as stat9 } from "fs/promises";
+import { open as open11, opendir, stat as stat10 } from "fs/promises";
 import { isAbsolute as isAbsolute13, relative as relative17, resolve as resolve25, sep as sep17 } from "path";
 import { rgPath as bundledRgPath } from "@vscode/ripgrep";
 import createIgnore from "ignore";
@@ -18962,7 +19527,7 @@ async function nodeFiles(root, start, signal, accept, limit, resources, ignoreBu
     }
     ignores.length = ruleCount;
   }
-  if ((await stat9(start)).isFile()) {
+  if ((await stat10(start)).isFile()) {
     const path = normalizedRelative(root, start);
     if (!isGitMetadataPath(root, start) && (includeIgnored || !ignored(path, false, ignores)) && accept(path)) output.push(path);
   } else {
@@ -18997,7 +19562,7 @@ async function collectIgnoreLayers(root, start, signal, resources, ignoreBudget)
       if (!ignored(path, true, layers)) await walk(absolute);
     }
   }
-  if (!(await stat9(start)).isFile()) await walk(start);
+  if (!(await stat10(start)).isFile()) await walk(start);
   return layers;
 }
 async function loadIgnoreFiles(directory, base, rules, budget, signal) {
@@ -19116,7 +19681,7 @@ function scope(root, path = ".") {
 async function resolveGrepPath(root, path = ".") {
   const candidate = scope(root, path);
   try {
-    const info = await stat9(candidate);
+    const info = await stat10(candidate);
     if (!info.isFile() && !info.isDirectory()) throw new Error("Search path must be a file or directory");
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -19320,19 +19885,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(),
@@ -19657,7 +20209,7 @@ function charset(contentType) {
 // src/tools/lsp.ts
 import { spawn as spawn6 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { access as access2, constants as constants10, readFile as readFile21 } from "fs/promises";
+import { access as access2, constants as constants10, readFile as readFile22 } from "fs/promises";
 import { basename as basename7, dirname as dirname18, extname as extname3, isAbsolute as isAbsolute14, relative as relative18, resolve as resolve26, sep as sep18 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "url";
 import { z as z32 } from "zod";
@@ -19851,7 +20403,7 @@ var LspConnection = class {
     const url = new URL(uri);
     if (url.protocol !== "file:") return;
     const filePath = fileURLToPath2(url);
-    const text = await readFile21(filePath, "utf8");
+    const text = await readFile22(filePath, "utf8");
     const current = this.#documents.get(uri);
     if (current === void 0) {
       this.#documents.set(uri, { text, version: 1 });
@@ -20217,19 +20769,19 @@ async function changeSummary(workspace) {
   };
 }
 async function stagedDiff(workspace, maxChars = 96e3) {
-  const stat20 = await git2(workspace, ["diff", "--staged", "--stat"]);
+  const stat21 = await git2(workspace, ["diff", "--staged", "--stat"]);
   const diff = await git2(workspace, ["diff", "--staged", "--no-ext-diff", "--no-color"]);
   if (!diff.ok) throw gitFailure(diff, "diff --staged");
   const text = diff.stdout;
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat20.stdout.trim(),
+    stat: stat21.stdout.trim(),
     truncated: text.length > maxChars
   };
 }
 async function uncommittedDiff(workspace, maxChars = 96e3) {
-  const stat20 = await git2(workspace, ["diff", "HEAD", "--stat"]);
+  const stat21 = await git2(workspace, ["diff", "HEAD", "--stat"]);
   const diff = await git2(workspace, ["diff", "HEAD", "--no-ext-diff", "--no-color"]);
   if (!diff.ok && !diff.stderr.includes("unknown revision")) throw gitFailure(diff, "diff HEAD");
   const summary2 = await changeSummary(workspace);
@@ -20237,7 +20789,7 @@ async function uncommittedDiff(workspace, maxChars = 96e3) {
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat20.stdout.trim(),
+    stat: stat21.stdout.trim(),
     untracked: summary2.untrackedFiles
   };
 }
@@ -20534,17 +21086,17 @@ ${explanation}` : "";
 }
 
 // src/desktop/astgraph-service.ts
-import { stat as stat10 } from "fs/promises";
+import { stat as stat11 } from "fs/promises";
 import { createRequire as nodeCreateRequire } from "module";
-import { join as join29, resolve as resolve27 } from "path";
+import { join as join30, resolve as resolve27 } from "path";
 var FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature";
 var DesktopAstGraphService = class {
   #path;
   constructor(workspace) {
-    this.#path = join29(resolve27(workspace), ".flavor", "astgraph", "index.db");
+    this.#path = join30(resolve27(workspace), ".flavor", "astgraph", "index.db");
   }
   async status() {
-    if ((await stat10(this.#path).catch(() => void 0))?.isFile() !== true) {
+    if ((await stat11(this.#path).catch(() => void 0))?.isFile() !== true) {
       return { available: false, path: this.#path, files: 0, nodes: 0, edges: 0 };
     }
     return this.#read((db) => {
@@ -20824,8 +21376,8 @@ function createTodoWriteTool() {
 
 // src/tools/managed.ts
 import { randomUUID as randomUUID18 } from "crypto";
-import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile22, readdir as readdir9, unlink as unlink3, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname19, join as join30, resolve as resolve29 } from "path";
+import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile23, readdir as readdir9, unlink as unlink3, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname19, join as join31, resolve as resolve29 } from "path";
 import { z as z37 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -20868,8 +21420,8 @@ var ManagedToolStore = class {
   #diagnostics = [];
   constructor(options) {
     this.#workspace = resolve29(options.workspace);
-    this.#projectRoot = join30(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join30(resolve29(options.home), ".flavor-code", "tools");
+    this.#projectRoot = join31(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join31(resolve29(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -20916,7 +21468,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join30(this.directory(input.scope), filename(input.name));
+    const path = join31(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record3, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record3, void 0, 2)}
 `);
@@ -20941,7 +21493,7 @@ var ManagedToolStore = class {
     if (!parsed.success) return [];
     const matches = this.#matching(parsed.data.name).filter((entry2) => parsed.data.scope === void 0 || entry2.scope === parsed.data.scope);
     if (matches.length > 0) return matches.map((entry2) => entry2.path);
-    return [join30(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join31(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -20954,12 +21506,12 @@ var ManagedToolStore = class {
       return;
     }
     for (const name of names) {
-      const path = join30(root, name);
+      const path = join31(root, name);
       try {
         const info = await lstat11(path);
         if (!info.isFile() || info.isSymbolicLink()) throw new Error("Managed tool record must be a regular file");
         if (info.size > MAX_RECORD_BYTES) throw new Error(`Managed tool record exceeds ${MAX_RECORD_BYTES} bytes`);
-        const record3 = ManagedToolRecordSchema.parse(JSON.parse(await readFile22(path, "utf8")));
+        const record3 = ManagedToolRecordSchema.parse(JSON.parse(await readFile23(path, "utf8")));
         if (record3.scope !== scope2) throw new Error(`Managed tool record scope must match its ${scope2} directory`);
         const key = scopedKey(scope2, record3.name);
         if (this.#entries.has(key)) throw new Error(`Duplicate managed tool name in ${scope2} scope: ${record3.name}`);
@@ -21845,6 +22397,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;
@@ -21868,6 +22425,7 @@ var FlavorSession = class {
   #pendingCoWorkStarts = [];
   #activeSteeringDurableIds = /* @__PURE__ */ new Set();
   #durableResumeStarted = false;
+  #continuationResumeStarted = false;
   #permissionBaseline;
   #activeSubmission;
   constructor(services) {
@@ -21888,6 +22446,10 @@ var FlavorSession = class {
   queueSnapshot() {
     return this.#queue.snapshot();
   }
+  /** True when start() admitted a persisted /loop or /goal continuation. */
+  get rotationContinuationResumed() {
+    return this.#continuationResumeStarted;
+  }
   clearQueue() {
     const snapshot4 = this.#queue.clear();
     for (const kind of ["steer", "followUp"]) {
@@ -22037,6 +22599,7 @@ var FlavorSession = class {
       if (decision.additionalContext !== void 0) await this.#services.addContext?.(decision.additionalContext);
       this.#started = true;
       this.#resumeDurableQueue();
+      this.#resumeRotationContinuation();
     });
     return this.#startPromise;
   }
@@ -22070,6 +22633,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"));
     }
   }
@@ -22093,6 +22657,7 @@ var FlavorSession = class {
     this.#activeSubmission = submission;
     this.#interrupted = false;
     let outcome = "completed";
+    let resumableBoundary;
     let assistantSummary = "";
     let deliverables = [];
     try {
@@ -22119,7 +22684,8 @@ var FlavorSession = class {
         skillNames,
         this.#services.managedToolCommands().map(({ name }) => name)
       );
-      if (command !== null) await this.#dispatch(command, controller2.signal);
+      if (submission.continuation !== void 0) await this.#runContinuation(submission.continuation, controller2.signal);
+      else if (command !== null) await this.#dispatch(command, controller2.signal);
       else for await (const event of this.#services.run(prompt, controller2.signal, {
         getSteeringMessages: () => this.#drainMessages("steer", true).map((item) => item.text),
         ...decision.additionalContext === void 0 ? {} : { additionalContext: decision.additionalContext },
@@ -22128,7 +22694,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) {
@@ -22169,6 +22738,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;
@@ -22365,7 +22941,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")];
@@ -22377,6 +22953,33 @@ Address this now (for example run the required verification or fix), then finish
       });
     }
   }
+  /**
+   * After a heap rotation the relaunched process inherits the same session and
+   * a marker continuation naming the /loop or /goal that was in flight. Resume
+   * it once here so a multi-day autonomous run survives the rotation instead of
+   * silently stopping at the boundary.
+   */
+  #resumeRotationContinuation() {
+    if (this.#continuationResumeStarted || this.#closed) return;
+    const continuation = this.#services.continuation?.();
+    if (continuation === void 0) return;
+    const supported = continuation.kind === "loop" ? this.#services.resumeLoop !== void 0 : this.#services.resumeGoal !== void 0;
+    if (!supported) return;
+    this.#continuationResumeStarted = true;
+    const displayText = `Resuming the interrupted ${continuation.kind} ${continuation.id} after a heap rotation.`;
+    this.#notice(displayText);
+    this.#enqueueNormalizedSubmission({ text: displayText, displayText, continuation }).catch((error) => {
+      this.#services.output({ type: "error", error: { code: "unknown", message: message(error) } });
+    });
+  }
+  async #runContinuation(continuation, signal) {
+    const stream = continuation.kind === "loop" ? this.#services.resumeLoop?.(continuation.id, signal) : this.#services.resumeGoal?.(continuation.id, signal);
+    if (stream === void 0) {
+      this.#notice(`The runtime cannot resume the interrupted ${continuation.kind} ${continuation.id}; start it again with /${continuation.kind}.`);
+      return;
+    }
+    for await (const event of stream) this.#services.output(event);
+  }
   #ackDurable(submission) {
     if (submission.durableId === void 0) return;
     this.#services.durableQueue?.ack(submission.durableId);
@@ -22489,6 +23092,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;
@@ -22534,9 +23138,9 @@ function requiredPals(service) {
 
 // src/doctor.ts
 import { constants as constants11 } from "fs";
-import { access as access3, lstat as lstat12, readFile as readFile23, readdir as readdir10, stat as stat11 } from "fs/promises";
+import { access as access3, lstat as lstat12, readFile as readFile24, readdir as readdir10, stat as stat12 } from "fs/promises";
 import { homedir } from "os";
-import { isAbsolute as isAbsolute16, join as join31, relative as relative20, resolve as resolve30, sep as sep20 } from "path";
+import { isAbsolute as isAbsolute16, join as join32, relative as relative20, resolve as resolve30, sep as sep20 } from "path";
 import { rgPath as bundledRgPath2 } from "@vscode/ripgrep";
 
 // src/utils/semver.ts
@@ -22583,7 +23187,7 @@ async function runDoctor(options = {}, dependencies2 = {}) {
   const checks = [];
   checks.push(runtimeCheck(nodeVersion, platform, arch));
   checks.push(await directoryCheck("workspace", workspace, false));
-  checks.push(await directoryCheck("state directory", join31(home, ".flavor-code"), true, home));
+  checks.push(await directoryCheck("state directory", join32(home, ".flavor-code"), true, home));
   let loaded;
   try {
     loaded = await (dependencies2.loadConfig ?? loadConfig)({
@@ -22609,8 +23213,8 @@ async function runDoctor(options = {}, dependencies2 = {}) {
     checks.push({ name: "shell", status: "fail", message: errorMessage3(error) });
   }
   checks.push(await pluginCheck([
-    join31(home, ".flavor-code", "plugins"),
-    join31(workspace, ".flavor", "plugins")
+    join32(home, ".flavor-code", "plugins"),
+    join32(workspace, ".flavor", "plugins")
   ]));
   try {
     const latest = await (dependencies2.fetchLatestVersion ?? fetchLatestVersion)({
@@ -22658,7 +23262,7 @@ function runtimeCheck(version, platform, arch) {
 }
 async function directoryCheck(name, path, mayBeCreated, parent = path) {
   try {
-    const info = await stat11(path);
+    const info = await stat12(path);
     if (!info.isDirectory()) return { name, status: "fail", message: `${path} is not a directory` };
     await access3(path, constants11.R_OK | constants11.W_OK);
     return { name, status: "pass", message: `${path} is readable and writable` };
@@ -22727,7 +23331,7 @@ async function pluginCheck(directories) {
       try {
         const rootInfo = await lstat12(root);
         if (rootInfo.isSymbolicLink()) throw new Error("plugin directory must not be a symbolic link");
-        const manifest = PluginManifestSchema.parse(JSON.parse(await readFile23(join31(root, "flavor-plugin.json"), "utf8")));
+        const manifest = PluginManifestSchema.parse(JSON.parse(await readFile24(join32(root, "flavor-plugin.json"), "utf8")));
         const main = resolve30(root, manifest.main);
         const delta = relative20(root, main);
         if (delta === ".." || delta.startsWith(`..${sep20}`) || isAbsolute16(delta)) throw new Error("plugin entry escapes its root");
@@ -22794,8 +23398,8 @@ var LANG_LABELS = /* @__PURE__ */ new Map([
 ]);
 
 // src/utils/crash-guard.ts
-import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { join as join32 } from "path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join33 } from "path";
 var installed = false;
 var crashing = false;
 var crashCleanups = /* @__PURE__ */ new Set();
@@ -22826,7 +23430,7 @@ function installCrashGuard(options = {}) {
   installed = true;
   const crashLogDir = () => {
     try {
-      return join32((options.workspace ?? process.cwd)(), ".flavor");
+      return join33((options.workspace ?? process.cwd)(), ".flavor");
     } catch {
       return process.cwd();
     }
@@ -22834,9 +23438,9 @@ function installCrashGuard(options = {}) {
   const writeCrashLog = (kind, detail) => {
     try {
       const dir = crashLogDir();
-      mkdirSync2(dir, { recursive: true });
-      const path = join32(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
-      writeFileSync(path, [
+      mkdirSync3(dir, { recursive: true });
+      const path = join33(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
+      writeFileSync2(path, [
         `kind: ${kind}`,
         `version: ${process.version}`,
         `platform: ${process.platform}`,
@@ -23606,8 +24210,8 @@ ${total}`;
 
 // src/memory/store.ts
 import { createHash as createHash17 } from "crypto";
-import { readFile as readFile24, rm as rm12 } from "fs/promises";
-import { resolve as resolve31, join as join33, relative as relative21, sep as sep21 } from "path";
+import { readFile as readFile25, rm as rm12 } from "fs/promises";
+import { resolve as resolve31, join as join34, relative as relative21, sep as sep21 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -23710,9 +24314,9 @@ var MemoryStore = class {
     if (!Number.isSafeInteger(options.maxEntries) || options.maxEntries < 1) throw new Error("maxEntries must be an integer of at least 1");
     if (!Number.isSafeInteger(options.maxEntryChars) || options.maxEntryChars < 1) throw new Error("maxEntryChars must be an integer of at least 1");
     this.workspace = resolve31(options.workspace);
-    this.#memoryRoot = join33(this.workspace, ".flavor", "memory");
-    this.path = join33(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join33(this.#memoryRoot, "behavior.json");
+    this.#memoryRoot = join34(this.workspace, ".flavor", "memory");
+    this.path = join34(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join34(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -23930,7 +24534,7 @@ var MemoryStore = class {
     });
   }
   async #readTaskItem(reference) {
-    const document = decodeTask(await readFile24(this.#resolveContentPath(reference.contentPath), "utf8"));
+    const document = decodeTask(await readFile25(this.#resolveContentPath(reference.contentPath), "utf8"));
     return document.items.find((item) => item.id === reference.id)?.content ?? reference.summary;
   }
   #resolveContentPath(contentPath) {
@@ -24570,8 +25174,8 @@ function createExecutionEnvironment(workspace, config) {
 }
 
 // src/ide/client.ts
-import { readFile as readFile25, readdir as readdir11, stat as stat12 } from "fs/promises";
-import { basename as basename8, join as join34, relative as relative23, resolve as resolve33, sep as sep23 } from "path";
+import { readFile as readFile26, readdir as readdir11, stat as stat13 } from "fs/promises";
+import { basename as basename8, join as join35, relative as relative23, resolve as resolve33, sep as sep23 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -24667,7 +25271,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join34(this.#home, ".flavor-code", "ide");
+    const directory = join35(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir11(directory)).filter((name) => name.endsWith(".lock"));
@@ -24675,9 +25279,9 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join34(directory, name);
+      const path = join35(directory, name);
       try {
-        const [contents, info] = await Promise.all([readFile25(path, "utf8"), stat12(path)]);
+        const [contents, info] = await Promise.all([readFile26(path, "utf8"), stat13(path)]);
         const lock = parseLockfile(contents);
         return lock === void 0 ? void 0 : { lock, modified: info.mtimeMs };
       } catch {
@@ -24796,6 +25400,7 @@ function relativeDisplay(workspace, filePath) {
 
 // src/jobs/registry.ts
 import { randomUUID as randomUUID19 } from "crypto";
+var OUTPUT_SLICE_SLACK_CHARS = 64 * 1024;
 var JobRegistry = class {
   #jobs = /* @__PURE__ */ new Map();
   #maxOutputChars;
@@ -24824,7 +25429,8 @@ var JobRegistry = class {
       updatedAt: now,
       outputChars: 0,
       truncated: false,
-      output: "",
+      chunks: [],
+      windowChars: 0,
       outputStart: 0,
       settle,
       done
@@ -24835,11 +25441,16 @@ var JobRegistry = class {
       id,
       append: (text) => {
         if (record3.state !== "running" || text === "") return;
-        record3.output += text;
+        record3.chunks.push(text);
+        record3.windowChars += text.length;
         record3.outputChars += text.length;
-        if (record3.output.length > this.#maxOutputChars) {
-          const removed = record3.output.length - this.#maxOutputChars;
-          record3.output = record3.output.slice(removed);
+        if (record3.outputChars > this.#maxOutputChars) record3.truncated = true;
+        if (record3.windowChars > this.#maxOutputChars + OUTPUT_SLICE_SLACK_CHARS) {
+          const joined = record3.chunks.join("");
+          const kept = joined.slice(joined.length - this.#maxOutputChars);
+          const removed = joined.length - kept.length;
+          record3.chunks = [kept];
+          record3.windowChars = kept.length;
           record3.outputStart += removed;
           record3.truncated = true;
         }
@@ -24860,8 +25471,20 @@ var JobRegistry = class {
   }
   read(id, owner2, cursor = 0) {
     const job = this.#owned(id, owner2);
-    const effective = Math.max(cursor, job.outputStart);
-    return { ...snapshot2(job), output: job.output.slice(effective - job.outputStart), cursor: job.outputStart + job.output.length };
+    const window = job.chunks.join("");
+    const dropped = Math.max(0, window.length - this.#maxOutputChars);
+    const effective = Math.max(cursor, job.outputStart + dropped);
+    return { ...snapshot2(job), output: window.slice(effective - job.outputStart), cursor: job.outputStart + window.length };
+  }
+  /** Retained sizes for the rotation census. */
+  census() {
+    let windowChars = 0;
+    let running = 0;
+    for (const job of this.#jobs.values()) {
+      windowChars += job.windowChars;
+      if (job.state === "running") running += 1;
+    }
+    return { jobs: this.#jobs.size, running, windowChars };
   }
   async wait(id, owner2, signal) {
     signal?.throwIfAborted();
@@ -25198,7 +25821,7 @@ function palSocketAddress(options) {
 import { createHash as createHash20 } from "crypto";
 import { Socket as Socket2 } from "net";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 import { spawn as spawn8 } from "child_process";
 
 // src/pals/broker.ts
@@ -25209,18 +25832,18 @@ import { dirname as dirname21 } from "path";
 
 // src/pals/auth.ts
 import { randomBytes as randomBytes3, randomUUID as randomUUID21 } from "crypto";
-import { chmod as chmod2, link as link2, mkdir as mkdir21, open as open12, readFile as readFile26, unlink as unlink4 } from "fs/promises";
+import { chmod as chmod2, link as link2, mkdir as mkdir21, open as open12, readFile as readFile27, unlink as unlink4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var PAL_AUTH_TOKEN_BYTES = 32;
 var TOKEN_PATTERN = /^[a-f0-9]{64}$/;
 async function loadOrCreatePalAuthToken(options = {}) {
-  const directory = join35(options.home ?? homedir2(), ".flavor-code", "pals");
-  const tokenPath = join35(directory, "auth-token");
+  const directory = join36(options.home ?? homedir2(), ".flavor-code", "pals");
+  const tokenPath = join36(directory, "auth-token");
   await mkdir21(directory, { recursive: true, mode: 448 });
   await chmod2(directory, 448);
   const token = (options.random ?? randomBytes3)(PAL_AUTH_TOKEN_BYTES).toString("hex");
-  const temporaryPath = join35(directory, `.auth-token-${process.pid}-${randomUUID21()}.tmp`);
+  const temporaryPath = join36(directory, `.auth-token-${process.pid}-${randomUUID21()}.tmp`);
   let handle;
   try {
     handle = await open12(temporaryPath, "wx", 384);
@@ -25243,7 +25866,7 @@ async function loadOrCreatePalAuthToken(options = {}) {
       if (error.code !== "ENOENT") throw error;
     });
   }
-  const stored = (await readFile26(tokenPath, "utf8")).trim();
+  const stored = (await readFile27(tokenPath, "utf8")).trim();
   if (!TOKEN_PATTERN.test(stored)) throw new Error("Pals authentication token store is invalid");
   await chmod2(tokenPath, 384);
   return stored;
@@ -25255,7 +25878,7 @@ function validatePalAuthToken(token) {
 
 // src/pals/lifecycle.ts
 import { randomUUID as randomUUID22 } from "crypto";
-import { mkdir as mkdir22, open as open13, readFile as readFile27, rename as rename11, stat as stat13, unlink as unlink5 } from "fs/promises";
+import { mkdir as mkdir22, open as open13, readFile as readFile28, rename as rename11, stat as stat14, unlink as unlink5 } from "fs/promises";
 import { dirname as dirname20 } from "path";
 function defaultProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return true;
@@ -25287,7 +25910,7 @@ async function acquirePalFileLock(options) {
     handle = await open13(options.path, "wx", 384);
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
-    const [contents, info] = await Promise.all([readFile27(options.path, "utf8").catch(() => ""), stat13(options.path).catch(() => void 0)]);
+    const [contents, info] = await Promise.all([readFile28(options.path, "utf8").catch(() => ""), stat14(options.path).catch(() => void 0)]);
     if (await options.endpointLive()) return void 0;
     const existing = parseMetadata(contents);
     if (existing !== void 0 && (options.processAlive ?? defaultProcessAlive)(existing.pid)) return void 0;
@@ -25317,7 +25940,7 @@ async function acquirePalFileLock(options) {
     await handle.close();
   }
   const release = async () => {
-    const current = parseMetadata(await readFile27(options.path, "utf8").catch(() => ""));
+    const current = parseMetadata(await readFile28(options.path, "utf8").catch(() => ""));
     if (current?.nonce !== nonce) return;
     await unlink5(options.path).catch((error) => {
       if (error.code !== "ENOENT") throw error;
@@ -25350,7 +25973,7 @@ function canConnect(address) {
 }
 function startupLockPath(address) {
   const digest = createHash20("sha256").update(address, "utf8").digest("hex").slice(0, 24);
-  return join36(tmpdir3(), `flavor-code-pals-${digest}.startup.lock`);
+  return join37(tmpdir3(), `flavor-code-pals-${digest}.startup.lock`);
 }
 async function spawnProductionBroker(address) {
   const entry2 = process.argv[1];
@@ -26293,8 +26916,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join37(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join37(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join38(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join38(workspace, ".flavor", "plugins")],
     config,
     // Existing project plugins (including astgraph and superharness) use Node.js
     // built-ins. The Worker/vm sandbox deliberately blocks those imports, so it
@@ -26403,7 +27026,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join37(tmpdir4(), `flavor-code-pals-${createHash21("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join38(tmpdir4(), `flavor-code-pals-${createHash21("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -26514,8 +27137,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join37(home, ".flavor-code", "skills")],
-      projectRoots: [join37(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join38(home, ".flavor-code", "skills")],
+      projectRoots: [join38(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -26523,7 +27146,7 @@ async function createProductionRuntime(options) {
     skillsReady.catch(() => void 0);
     tools.push(createSkillTool(skills), createSkillResourceTool(skills));
     if (options.extraTools !== void 0) tools.push(...options.extraTools);
-    const flavor = await optionalText2(join37(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join38(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -27108,7 +27731,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join37(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join38(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -27216,12 +27839,89 @@ async function createProductionRuntime(options) {
         await loopExecutionEnvironment?.dispose();
       }
     };
+    let activeLongTask;
+    const readMemoryRestartMarker = () => {
+      try {
+        return parseMemoryRestartMarker(readFileSync3(memoryRestartMarkerPath(workspace), "utf8"));
+      } catch {
+        return void 0;
+      }
+    };
+    const currentPressureReading = () => verifiedHeapPressure(MEMORY_PRESSURE_HEAP_RATIO) ?? { ...readHeap(), gcVerified: false };
+    const collectRotationHolders = () => {
+      const holders = {};
+      try {
+        const context = harness.main.context.census();
+        holders.context = { entries: context.messages, chars: context.messageChars };
+        holders.contextVisibility = { entries: context.visibilityEntries, chars: context.visibilityChars };
+        holders.contextTransient = { entries: context.transientEntries, chars: context.transientChars };
+      } catch {
+      }
+      try {
+        holders.journal = { entries: harnessJournal.recordCount };
+      } catch {
+      }
+      try {
+        const jobCensus = jobs.census();
+        holders.jobs = { entries: jobCensus.jobs, chars: jobCensus.windowChars };
+      } catch {
+      }
+      try {
+        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 {
+      }
+      return holders;
+    };
+    const rotateForHeap = (continuation, reading) => {
+      requestMemoryRestart(workspace, sessionId, emitOutput, {
+        ...continuation === void 0 ? {} : { continuation },
+        ...reading === void 0 ? {} : { reading },
+        holders: collectRotationHolders()
+      }, options.onMemoryRestartRequested);
+    };
+    const maybeRotateAtBoundary = (continuation) => {
+      activeLongTask = continuation;
+      const pressure = verifiedHeapPressure(MEMORY_PRESSURE_HEAP_RATIO);
+      if (pressure !== void 0) {
+        rotateForHeap(continuation, pressure);
+        return;
+      }
+      const reading = heapRotationNeeded();
+      if (reading === void 0) return;
+      if (rotationCooldownActive(readMemoryRestartMarker(), sessionId, /* @__PURE__ */ new Date())) return;
+      rotateForHeap(continuation, reading);
+    };
+    const maybeRotateAtTurnBoundary = () => {
+      const reading = heapRotationNeeded();
+      if (reading === void 0) return;
+      if (rotationCooldownActive(readMemoryRestartMarker(), sessionId, /* @__PURE__ */ new Date())) return;
+      rotateForHeap(void 0, reading);
+    };
+    const consumePendingContinuation = () => {
+      const marker = readMemoryRestartMarker();
+      const continuation = pendingContinuation(marker, sessionId, /* @__PURE__ */ new Date());
+      if (continuation === void 0 || marker === void 0) return void 0;
+      try {
+        const markerPath = memoryRestartMarkerPath(workspace);
+        writeMarkerAtomically(markerPath, consumedMemoryRestartMarker(marker));
+      } catch {
+      }
+      return continuation;
+    };
     const loopStore = new LoopStore({ workspace });
     const loopOrchestrator = new LoopOrchestrator({
       workspace,
       config: config.loop,
       persistence: loopStore,
       hallucinationGuard,
+      onCycleBoundary: (loopId) => maybeRotateAtBoundary({ kind: "loop", id: loopId }),
+      onMemoryCheckpoint: (loopId) => maybeRotateAtBoundary({ kind: "loop", id: loopId }),
       prepareWorkspace: (input) => prepareLoopWorkspace(input),
       inferVerification: inferVerificationPlan,
       runWorker: ({ workspace: executionWorkspace, prompt, signal }) => runLoopWorker({ workspace: executionWorkspace, prompt, signal }),
@@ -27233,21 +27933,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)}`
     });
@@ -27258,9 +27946,12 @@ async function createProductionRuntime(options) {
       plannerModelId: mainModel,
       classifierModelId: mainModel,
       skepticCount: 3,
-      maxRounds: 5,
-      maxStallStreak: 2,
+      // 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 }),
       verifyHost: async (signal) => runVerificationPlan(
         await inferVerificationPlan(workspace),
         workspace,
@@ -27355,30 +28046,50 @@ async function createProductionRuntime(options) {
           contextEpoch: harness.main.context.snapshot().epoch?.id ?? "legacy"
         });
         const turnId = harnessJournal.startTurn(turnConfig, { prompt, initialUserMessage: runOptions?.initialUserMessage });
-        return monitorMemoryRestart(durableTurn(persistAfter(runMain(
-          harness,
-          skills,
-          prompt,
-          signal,
-          selectedModels.mainError,
-          memoryStore === void 0 || !memoryHasRoutableEntries && userMemoryContext === void 0 ? void 0 : {
-            store: memoryStore,
-            taskId: memoryLifecycle.taskId ?? sessionId,
-            topK: config.memory.retrievalTopK,
-            maxChars: config.memory.maxPromptChars
-          },
-          runOptions?.getSteeringMessages,
-          runOptions?.initialUserMessage,
-          runOptions?.additionalContext,
-          ide
-        ), persist), harnessJournal, turnId, turnConfig), () => requestMemoryRestart(workspace, sessionId, emitOutput));
+        return monitorTurnMemory(
+          durableTurn(persistAfter(runMain(
+            harness,
+            skills,
+            prompt,
+            signal,
+            selectedModels.mainError,
+            memoryStore === void 0 || !memoryHasRoutableEntries && userMemoryContext === void 0 ? void 0 : {
+              store: memoryStore,
+              taskId: memoryLifecycle.taskId ?? sessionId,
+              topK: config.memory.retrievalTopK,
+              maxChars: config.memory.maxPromptChars
+            },
+            runOptions?.getSteeringMessages,
+            runOptions?.initialUserMessage,
+            runOptions?.additionalContext,
+            ide
+          ), persist), harnessJournal, turnId, turnConfig),
+          () => rotateForHeap(void 0, currentPressureReading()),
+          () => maybeRotateAtTurnBoundary()
+        );
       },
       runSkill: (skill, prompt, signal) => persistAfter(
         runExplicitSkill(harness, skills, skill, prompt, signal, selectedModels.mainError),
         persist
       ),
-      runLoop: (goal, signal) => runLoopSession(loopOrchestrator, hooks, goal, signal),
-      runGoal: (goal, signal) => persistEach(runGoalSession(goalOrchestrator, goal, signal), persist),
+      runLoop: (goal, signal) => monitorLongTaskRestart(
+        runLoopSession(loopOrchestrator, hooks, goal, signal),
+        () => rotateForHeap(activeLongTask, currentPressureReading())
+      ),
+      runGoal: (goal, signal) => monitorLongTaskRestart(
+        persistEach(runGoalSession(goalOrchestrator, goal, signal), persist),
+        () => rotateForHeap(activeLongTask, currentPressureReading())
+      ),
+      resumeLoop: (loopId, signal) => monitorLongTaskRestart(
+        runResumeLoopSession(loopOrchestrator, hooks, loopId, signal),
+        () => rotateForHeap(activeLongTask ?? { kind: "loop", id: loopId }, currentPressureReading())
+      ),
+      resumeGoal: (goalId, signal) => monitorLongTaskRestart(
+        persistEach(runResumeGoalSession(goalOrchestrator, goalId, signal), persist),
+        () => rotateForHeap(activeLongTask ?? { kind: "goal", id: goalId }, currentPressureReading())
+      ),
+      continuation: () => consumePendingContinuation(),
+      rotationPending: () => memoryRotationActive(),
       mcp: async (command, signal) => {
         signal.throwIfAborted();
         const manager = await mcpReady;
@@ -27472,7 +28183,7 @@ async function createProductionRuntime(options) {
           const root = resolve36(workspace);
           const abs = resolve36(root, path);
           if (abs !== root && !abs.startsWith(root + sep25)) throw new Error(`path outside workspace: ${path}`);
-          return readFile28(abs, "utf8");
+          return readFile29(abs, "utf8");
         },
         history: async (path, limit) => fileHistory(workspace, path, limit),
         questions,
@@ -27484,7 +28195,7 @@ async function createProductionRuntime(options) {
       }, query, focus, signal),
       audit: async (toolFilter) => {
         try {
-          const raw = await readFile28(auditLogger.path, "utf8");
+          const raw = await readFile29(auditLogger.path, "utf8");
           const lines = raw.trim().split("\n").filter((line) => line.length > 0);
           const entries = lines.map((line) => {
             try {
@@ -27524,7 +28235,7 @@ ${summary2}`;
       doctor: async () => formatDoctorReport(await runDoctor({ workspace, home, environment })),
       usage: async () => {
         try {
-          const raw = await readFile28(usageLogPath(), "utf8");
+          const raw = await readFile29(usageLogPath(), "utf8");
           return formatUsageSummary(summarizeUsage(parseUsageEntries(raw)));
         } catch (error) {
           if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
@@ -27677,7 +28388,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join37(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join38(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -27724,7 +28435,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join37(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join38(home, ".flavor-code", "auth.json"));
         const tokens2 = await tokenStore.load();
         const hadCredentials = Object.keys(tokens2).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -27917,10 +28628,16 @@ function formatMcpReconnect(server) {
   return `Failed to reconnect MCP server "${server.name}": ${server.error ?? "unknown error"}`;
 }
 async function* runLoopSession(orchestrator, hooks, goal, signal) {
+  yield* loopSessionEvents(orchestrator.run({ goal, signal }), hooks);
+}
+async function* runResumeLoopSession(orchestrator, hooks, loopId, signal) {
+  yield* loopSessionEvents(orchestrator.resume({ loopId, signal }), hooks);
+}
+async function* loopSessionEvents(events, hooks) {
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
   let latestVerification;
-  for await (const event of orchestrator.run({ goal, signal })) {
+  for await (const event of events) {
     if (event.type === "worker-event") {
       if (event.event.type === "usage") {
         totalInputTokens += event.event.inputTokens;
@@ -27930,6 +28647,8 @@ async function* runLoopSession(orchestrator, hooks, goal, signal) {
           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;
     }
@@ -27984,7 +28703,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 {
@@ -28001,6 +28720,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(
@@ -28024,7 +28746,7 @@ async function workspaceFingerprint(workspace) {
     hash.update(name);
     if (remaining <= 0) continue;
     try {
-      const content = await readFile28(path);
+      const content = await readFile29(path);
       const slice = content.subarray(0, remaining);
       hash.update(slice);
       remaining -= slice.length;
@@ -28136,7 +28858,16 @@ async function* durableTurn(source, journal, turnId, config) {
     }
   }
 }
-async function* monitorMemoryRestart(source, onRestartNeeded) {
+async function* monitorTurnMemory(source, onPressure, onBoundary) {
+  let pressure = false;
+  for await (const event of source) {
+    if (event.type === "error" && event.error.code === "memory_pressure") pressure = true;
+    yield event;
+  }
+  if (pressure) onPressure();
+  else onBoundary();
+}
+async function* monitorLongTaskRestart(source, onRestartNeeded) {
   let pressure = false;
   for await (const event of source) {
     if (event.type === "error" && event.error.code === "memory_pressure") pressure = true;
@@ -28144,7 +28875,10 @@ async function* monitorMemoryRestart(source, onRestartNeeded) {
   }
   if (pressure) onRestartNeeded();
 }
-function requestMemoryRestart(workspace, sessionId, emitOutput) {
+function requestMemoryRestart(workspace, sessionId, emitOutput, rotation, onRestartRequested) {
+  if (memoryRotationActive()) return;
+  markMemoryRotation();
+  const continuation = rotation?.continuation;
   try {
     const markerPath = memoryRestartMarkerPath(workspace);
     let previous;
@@ -28152,14 +28886,43 @@ function requestMemoryRestart(workspace, sessionId, emitOutput) {
       previous = parseMemoryRestartMarker(readFileSync3(markerPath, "utf8"));
     } catch {
     }
-    mkdirSync3(dirname22(markerPath), { recursive: true });
-    writeFileSync2(markerPath, `${JSON.stringify(nextMemoryRestartMarker(previous, sessionId, /* @__PURE__ */ new Date()))}
-`, "utf8");
+    writeMarkerAtomically(markerPath, nextMemoryRestartMarker(previous, sessionId, /* @__PURE__ */ new Date(), continuation));
   } catch {
   }
-  process.exitCode = MEMORY_RESTART_EXIT_CODE;
-  emitOutput({ type: "notice", message: "Memory watermark reached; the session is saved and Flavor is restarting with a fresh heap." });
-  emitOutput({ type: "exit" });
+  if (rotation?.reading !== void 0) {
+    const census = {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: continuation === void 0 ? "memory-pressure" : `heap-rotation:${continuation.kind}`,
+      sessionId,
+      heap: censusHeapBlock(rotation.reading),
+      holders: rotation.holders ?? {}
+    };
+    writeRotationCensus(workspace, census);
+    if (heapSnapshotWarranted(rotation.reading)) writeRotationHeapSnapshot(workspace);
+  }
+  emitOutput({
+    type: "notice",
+    message: continuation === void 0 ? "Memory watermark reached; the session is saved and Flavor is restarting with a fresh heap." : `Memory watermark reached; the session and the running ${continuation.kind} are saved, and Flavor is restarting with a fresh heap to continue it.`
+  });
+  if (onRestartRequested !== void 0) onRestartRequested(sessionId);
+  else {
+    process.exitCode = MEMORY_RESTART_EXIT_CODE;
+    emitOutput({ type: "exit" });
+  }
+}
+function writeMarkerAtomically(path, marker) {
+  mkdirSync4(dirname22(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomUUID25()}.tmp`;
+  try {
+    writeFileSync3(temporary, `${JSON.stringify(marker)}
+`, { encoding: "utf8", mode: 384 });
+    renameSync2(temporary, path);
+  } finally {
+    try {
+      unlinkSync3(temporary);
+    } catch {
+    }
+  }
 }
 async function runGitCommit(deps, hint, signal) {
   if (!await isGitRepository(deps.workspace)) return "Not a git repository \u2014 /commit needs git.";
@@ -28254,7 +29017,7 @@ async function registerConfiguredAdapters(providers, registry, environment, diag
   const configured = { ...providers };
   if (configured.openai === void 0 && environment.OPENAI_API_KEY) configured.openai = { type: "openai", apiKey: environment.OPENAI_API_KEY };
   if (configured.anthropic === void 0 && environment.ANTHROPIC_API_KEY) configured.anthropic = { type: "anthropic", apiKey: environment.ANTHROPIC_API_KEY };
-  const oauthTokenStore = createFileTokenStore(join37(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join38(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -28523,7 +29286,7 @@ async function generateSleepReview(registry, modelId, prompt, signal) {
 }
 async function optionalText2(path) {
   try {
-    return await readFile28(path, "utf8");
+    return await readFile29(path, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
     throw error;
@@ -28608,7 +29371,24 @@ function attachCleanupError(primary, cleanup) {
   }
 }
 async function* runGoalSession(orchestrator, goal, signal) {
-  for await (const event of orchestrator.run({ goal, signal })) {
+  yield* goalSessionEvents(orchestrator.run({ goal, signal }));
+}
+async function* runResumeGoalSession(orchestrator, goalId, signal) {
+  yield* goalSessionEvents(orchestrator.resume({ goalId, signal }));
+}
+async function* goalSessionEvents(events) {
+  for await (const event of events) {
+    if (event.type === "goal-resumed") {
+      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}` };
@@ -28635,6 +29415,8 @@ async function* runGoalSession(orchestrator, goal, signal) {
           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;
       }
@@ -28685,13 +29467,13 @@ function createMemoryTaskId() {
 
 // src/desktop/runtime-controller.ts
 import { createHash as createHash27 } from "crypto";
-import { mkdir as mkdir27, readFile as readFile36, readdir as readdir13, rm as rm15, stat as stat16, writeFile as writeFile17 } from "fs/promises";
+import { mkdir as mkdir27, readFile as readFile37, readdir as readdir13, rm as rm15, stat as stat17, writeFile as writeFile17 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename10, join as join47, resolve as resolve39 } from "path";
+import { basename as basename10, join as join48, resolve as resolve39 } from "path";
 
 // src/d2c/workflow.ts
 import { createHash as createHash22 } from "crypto";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 import { z as z42 } from "zod";
 
 // src/d2c/workflow-shared.ts
@@ -28837,7 +29619,7 @@ function reviewsFor(report, previous) {
 function implementationDirectory(report) {
   const source = report.implementation.source;
   if (!/^https?:\/\//i.test(source)) return source;
-  return join38("src", "d2c-output", report.task);
+  return join39("src", "d2c-output", report.task);
 }
 function createWorkflow(report, framework) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -28961,7 +29743,7 @@ function applyQualityIssueDecision(workflow, issueId2, decision) {
   };
 }
 function workflowPath(workspace, task) {
-  return join38(taskDir(workspace, task), "workflow.json");
+  return join39(taskDir(workspace, task), "workflow.json");
 }
 async function readWorkflow(workspace, task) {
   return (await readRecoverableFile(workflowPath(workspace, task), decodeWorkflow))?.value;
@@ -29214,8 +29996,8 @@ function confirmApiMapping(mapping, operationKey, operations) {
 }
 
 // src/d2c/modules.ts
-import { readFile as readFile29 } from "fs/promises";
-import { isAbsolute as isAbsolute18, join as join39, normalize as normalize2, posix, sep as sep26, win32 as win322 } from "path";
+import { readFile as readFile30 } from "fs/promises";
+import { isAbsolute as isAbsolute18, join as join40, normalize as normalize2, posix, sep as sep26, win32 as win322 } from "path";
 import { z as z43 } from "zod";
 var ModuleSchema = z43.object({
   id: z43.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
@@ -29234,13 +30016,13 @@ function safeSource(path) {
 }
 function d2cOutputDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error(`Invalid D2C task: ${task}`);
-  return join39(workspace, "src", "d2c-output", task);
+  return join40(workspace, "src", "d2c-output", task);
 }
 async function readD2cModules(workspace, task) {
   const project = d2cOutputDirectory(workspace, task);
   let raw;
   try {
-    raw = await readFile29(join39(project, "d2c.modules.json"), "utf8");
+    raw = await readFile30(join40(project, "d2c.modules.json"), "utf8");
   } catch {
     return [{ id: "page", label: task, sourceFiles: ["src/App.vue", "src/App.jsx"], keywords: [task] }];
   }
@@ -29260,8 +30042,8 @@ async function readD2cModules(workspace, task) {
 }
 
 // src/d2c/integration.ts
-import { mkdir as mkdir24, readFile as readFile30, writeFile as writeFile13 } from "fs/promises";
-import { join as join40 } from "path";
+import { mkdir as mkdir24, readFile as readFile31, writeFile as writeFile13 } from "fs/promises";
+import { join as join41 } from "path";
 function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -29397,19 +30179,19 @@ async def reset_acceptance(request: Request):
 }
 async function generateIntegrationArtifacts(projectDir, document, mappings, options = {}) {
   if (mappings.some((mapping) => mapping.status === "needs-confirmation")) throw new Error("Confirm every uncertain OpenAPI mapping before generating integration code");
-  const packagePath = join40(projectDir, "package.json");
+  const packagePath = join41(projectDir, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(await readFile30(packagePath, "utf8"));
+    pkg = JSON.parse(await readFile31(packagePath, "utf8"));
   } catch {
     throw new Error(`D2C integration requires a valid package.json at ${packagePath}`);
   }
   const scripts = options.pythonServer ? { ...record2(pkg.scripts) ?? {} } : { ...record2(pkg.scripts) ?? {}, mock: "node mock/server.mjs" };
   const dependencies2 = options.pythonServer ? { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9" } : { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9", express: "^5.2.1" };
   const selected = [...new Set(mappings.map((mapping) => mapping.operationKey))].map((key) => document.operations.find((operation) => operation.id === key)).filter((operation) => operation !== void 0);
-  const apiDir = join40(projectDir, "src", "api");
-  const mockDir = join40(projectDir, "mock");
-  const serverDir = join40(projectDir, "server");
+  const apiDir = join41(projectDir, "src", "api");
+  const mockDir = join41(projectDir, "mock");
+  const serverDir = join41(projectDir, "server");
   await Promise.all([
     mkdir24(apiDir, { recursive: true }),
     ...options.pythonServer ? [] : [mkdir24(mockDir, { recursive: true })],
@@ -29419,23 +30201,23 @@ async function generateIntegrationArtifacts(projectDir, document, mappings, opti
   if (options.pythonServer) files.push("server/main.py", "server/requirements.txt", "server/README.md", "server/flavor-runtime.json");
   else files.push("mock/server.mjs");
   await Promise.all([
-    writeFile13(join40(apiDir, "http.js"), `import axios from "axios";
+    writeFile13(join41(apiDir, "http.js"), `import axios from "axios";
 
 export const http = axios.create({ baseURL: import.meta.env.VITE_API_BASE_URL || ${JSON.stringify(document.baseUrl ?? "")}, timeout: 15000 });
 
 http.interceptors.response.use((response) => response, (error) => Promise.reject({ name: "ApiError", status: error.response?.status, message: error.response?.data?.message || error.message, cause: error }));
 `),
-    writeFile13(join40(apiDir, "d2c-api.js"), apiModule(selected)),
-    writeFile13(join40(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
+    writeFile13(join41(apiDir, "d2c-api.js"), apiModule(selected)),
+    writeFile13(join41(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
 `),
-    ...options.pythonServer ? [] : [writeFile13(join40(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
+    ...options.pythonServer ? [] : [writeFile13(join41(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
     writeFile13(packagePath, `${JSON.stringify({ ...pkg, scripts, dependencies: dependencies2 }, null, 2)}
 `),
     ...options.pythonServer ? [
-      writeFile13(join40(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
-      writeFile13(join40(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
-      writeFile13(join40(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
-      writeFile13(join40(serverDir, "flavor-runtime.json"), `${JSON.stringify({
+      writeFile13(join41(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
+      writeFile13(join41(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
+      writeFile13(join41(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
+      writeFile13(join41(serverDir, "flavor-runtime.json"), `${JSON.stringify({
         schema: 1,
         kind: "python-fastapi",
         cwd: "server",
@@ -29454,9 +30236,9 @@ http.interceptors.response.use((response) => response, (error) => Promise.reject
 
 // src/d2c/mock-runner.ts
 import { spawn as spawn9 } from "child_process";
-import { access as access4, readFile as readFile31 } from "fs/promises";
+import { access as access4, readFile as readFile32 } from "fs/promises";
 import { createServer as createServer5 } from "net";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 async function exists3(path) {
   try {
     await access4(path);
@@ -29564,7 +30346,7 @@ ${output.trim()}` : ""}`);
   }
 }
 async function runPythonBackend(projectDir, options) {
-  const serverDir = join41(projectDir, "server");
+  const serverDir = join42(projectDir, "server");
   if (options.installDependencies !== false) await installPython(serverDir, options.signal);
   const selectedPort = await port();
   const url = `http://127.0.0.1:${selectedPort}`;
@@ -29610,20 +30392,20 @@ ${managed.output().slice(-4e3)}`);
   };
 }
 async function runD2cMockServer(projectDir, options = {}) {
-  const runtimePath = join41(projectDir, "server", "flavor-runtime.json");
+  const runtimePath = join42(projectDir, "server", "flavor-runtime.json");
   if (await exists3(runtimePath)) {
     let runtime;
     try {
-      runtime = JSON.parse(await readFile31(runtimePath, "utf8"));
+      runtime = JSON.parse(await readFile32(runtimePath, "utf8"));
     } catch {
       throw new Error(`E2E backend runtime manifest is invalid at ${runtimePath}`);
     }
     if (runtime.schema !== 1 || runtime.kind !== "python-fastapi") throw new Error("Unsupported E2E backend runtime manifest");
     return runPythonBackend(projectDir, options);
   }
-  const serverPath = join41(projectDir, "mock", "server.mjs");
+  const serverPath = join42(projectDir, "mock", "server.mjs");
   if (!await exists3(serverPath)) throw new Error(`D2C mock server is not generated at ${serverPath}`);
-  if (options.installDependencies === false && !await exists3(join41(projectDir, "node_modules", "express", "package.json"))) {
+  if (options.installDependencies === false && !await exists3(join42(projectDir, "node_modules", "express", "package.json"))) {
     throw new Error("D2C mock server dependencies are not installed");
   }
   if (options.installDependencies !== false) await install(projectDir, options.signal);
@@ -29665,13 +30447,13 @@ ${managed.output().slice(-4e3)}`);
 
 // src/d2c/product.ts
 import { createHash as createHash24, randomUUID as randomUUID27 } from "crypto";
-import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile33, rename as rename13, stat as stat14, unlink as unlink7, writeFile as writeFile15 } from "fs/promises";
-import { join as join42 } from "path";
+import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile34, rename as rename13, stat as stat15, unlink as unlink7, writeFile as writeFile15 } from "fs/promises";
+import { join as join43 } from "path";
 import { z as z44 } from "zod";
 
 // src/e2e/prd-governance.ts
 import { createHash as createHash23, randomUUID as randomUUID26 } from "crypto";
-import { readFile as readFile32, rename as rename12, rm as rm13, writeFile as writeFile14 } from "fs/promises";
+import { readFile as readFile33, rename as rename12, rm as rm13, writeFile as writeFile14 } from "fs/promises";
 function hashPrd(markdown) {
   return createHash23("sha256").update(markdown, "utf8").digest("hex");
 }
@@ -29748,14 +30530,14 @@ function approvePrd(markdown, now = /* @__PURE__ */ new Date()) {
   return { hash: hashPrd(markdown), approvedAt: now.toISOString(), criteria };
 }
 async function assertApprovedPrd(path, approved) {
-  const current = await readFile32(path, "utf8");
+  const current = await readFile33(path, "utf8");
   if (hashPrd(current) !== approved.hash) {
     throw new Error("PRD_LOCK_VIOLATION: confirmed PRD content changed after approval");
   }
   return approved;
 }
 async function updatePrdSectionFile(path, input) {
-  const current = await readFile32(path, "utf8");
+  const current = await readFile33(path, "utf8");
   if (hashPrd(current) !== input.expectedHash) {
     throw new Error("PRD_EDIT_CONFLICT: the PRD changed; refresh before saving this section");
   }
@@ -29821,13 +30603,13 @@ var PlanSchema2 = z44.object({
 }).strict();
 function d2cProductDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error("Invalid D2C task name");
-  return join42(taskDir(workspace, task), "product");
+  return join43(taskDir(workspace, task), "product");
 }
 function d2cProductPrototypeDirectory(workspace, task) {
-  return join42(d2cProductDirectory(workspace, task), "prototype");
+  return join43(d2cProductDirectory(workspace, task), "prototype");
 }
 function planPath(workspace, task) {
-  return join42(taskDir(workspace, task), "product-plan.json");
+  return join43(taskDir(workspace, task), "product-plan.json");
 }
 function resolveD2cProductTechnology(requirement, fallbackFramework = "vue") {
   const frontendCandidates = [
@@ -29915,18 +30697,18 @@ function buildD2cProductOpenApi(task, modules) {
 `;
 }
 async function fileTimestamp(path) {
-  const info = await stat14(path).catch(() => void 0);
+  const info = await stat15(path).catch(() => void 0);
   return info?.isFile() ? info.mtime.toISOString() : void 0;
 }
 async function fileHash(path) {
-  const buffer = await readFile33(path).catch((error) => {
+  const buffer = await readFile34(path).catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
   return buffer === void 0 ? void 0 : createHash24("sha256").update(buffer).digest("hex");
 }
 async function validateAndNormalizePrototypeManifest(path) {
-  const raw = await readFile33(path, "utf8").catch((error) => {
+  const raw = await readFile34(path, "utf8").catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
@@ -30002,7 +30784,7 @@ async function createD2cProductPlan(workspace, input, now = () => /* @__PURE__ *
   });
 }
 async function readD2cProductPlan(workspace, task) {
-  const raw = await readFile33(planPath(workspace, task), "utf8").catch((error) => {
+  const raw = await readFile34(planPath(workspace, task), "utf8").catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
@@ -30010,16 +30792,16 @@ async function readD2cProductPlan(workspace, task) {
 }
 async function discoverD2cProductArtifacts(workspace, plan) {
   const product = d2cProductDirectory(workspace, plan.task);
-  const prdUpdatedAt = await fileTimestamp(join42(product, "prd.md"));
-  const prdHash = await fileHash(join42(product, "prd.md"));
-  const prototypeUpdatedAt = await fileTimestamp(join42(product, "prototype", "index.html"));
-  const prototypeHash = await fileHash(join42(product, "prototype", "index.html"));
-  const expectedManifest = join42(product, "prototype", "interaction-manifest.json");
+  const prdUpdatedAt = await fileTimestamp(join43(product, "prd.md"));
+  const prdHash = await fileHash(join43(product, "prd.md"));
+  const prototypeUpdatedAt = await fileTimestamp(join43(product, "prototype", "index.html"));
+  const prototypeHash = await fileHash(join43(product, "prototype", "index.html"));
+  const expectedManifest = join43(product, "prototype", "interaction-manifest.json");
   let manifestUpdatedAt = await fileTimestamp(expectedManifest);
   if (manifestUpdatedAt === void 0) {
-    const misplacedManifest = join42(product, "interaction-manifest.json");
+    const misplacedManifest = join43(product, "interaction-manifest.json");
     if (await fileTimestamp(misplacedManifest) !== void 0) {
-      await mkdir25(join42(product, "prototype"), { recursive: true });
+      await mkdir25(join43(product, "prototype"), { recursive: true });
       await copyFile2(misplacedManifest, expectedManifest);
       manifestUpdatedAt = await fileTimestamp(expectedManifest);
     }
@@ -30052,8 +30834,8 @@ async function readD2cProductPlanView(workspace, task) {
   if (stored === void 0) return void 0;
   const plan = await discoverD2cProductArtifacts(workspace, stored);
   if (plan.revision !== stored.revision) await writeD2cProductPlan(workspace, plan);
-  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile33(join42(taskDir(workspace, task), plan.prd.path), "utf8");
-  const manifestPath = join42(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
+  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile34(join43(taskDir(workspace, task), plan.prd.path), "utf8");
+  const manifestPath = join43(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
   const validationError = plan.phase === "design-generating" && await fileTimestamp(manifestPath) !== void 0 ? await validateAndNormalizePrototypeManifest(manifestPath) : void 0;
   return {
     plan,
@@ -30143,9 +30925,9 @@ ${prdMarkdown.slice(0, 2e4)}`
 
 // src/e2e/acceptance-baseline.ts
 import { createHash as createHash25 } from "crypto";
-import { readFile as readFile34 } from "fs/promises";
+import { readFile as readFile35 } from "fs/promises";
 async function fileArtifact(path) {
-  const content = await readFile34(path);
+  const content = await readFile35(path);
   return { path, hash: createHash25("sha256").update(content).digest("hex"), bytes: content.byteLength };
 }
 async function verifyAcceptanceArtifact(path, expected, label) {
@@ -30212,7 +30994,7 @@ function createAcceptanceEvidence(coverage, run, now = /* @__PURE__ */ new Date(
 
 // src/e2e/delivery-run.ts
 import { createHash as createHash26 } from "crypto";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 import { z as z45 } from "zod";
 var DELIVERY_NODE_IDS = ["requirement", "prd", "design", "d2c", "api", "acceptance", "delivery"];
 var ArtifactSchema = z45.object({
@@ -30329,7 +31111,7 @@ function completeDeliveryNode(run, node, outputs, now = /* @__PURE__ */ new Date
   return { ...run, nodes, updatedAt: timestamp2 };
 }
 function deliveryRunPath(workspace, task) {
-  return join43(taskDir(workspace, task), "delivery-run.json");
+  return join44(taskDir(workspace, task), "delivery-run.json");
 }
 function decodeDeliveryRun(raw) {
   return DeliveryRunSchema.parse(JSON.parse(raw));
@@ -30370,9 +31152,9 @@ async function updateDeliveryRun(workspace, task, expectedRevision, mutation) {
 }
 
 // src/skills/manager.ts
-import { lstat as lstat14, mkdir as mkdir26, readFile as readFile35, readdir as readdir12, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
+import { lstat as lstat14, mkdir as mkdir26, readFile as readFile36, readdir as readdir12, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { isAbsolute as isAbsolute19, join as join44, relative as relative26, resolve as resolve37, sep as sep27 } from "path";
+import { isAbsolute as isAbsolute19, join as join45, relative as relative26, resolve as resolve37, sep as sep27 } from "path";
 import { stringify } from "yaml";
 var SkillManager = class {
   #workspace;
@@ -30395,7 +31177,7 @@ var SkillManager = class {
   async create(draft) {
     const value = parseDraft(draft);
     const projectRoot = this.#projectRoot();
-    const directory = join44(projectRoot, value.name);
+    const directory = join45(projectRoot, value.name);
     await mkdir26(projectRoot, { recursive: true, mode: 448 });
     try {
       await mkdir26(directory, { mode: 448 });
@@ -30404,7 +31186,7 @@ var SkillManager = class {
       throw error;
     }
     try {
-      await writeFile16(join44(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
+      await writeFile16(join45(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
       await this.#persistEnabled(value.name, true);
       return this.get(value.name);
     } catch (error) {
@@ -30422,7 +31204,7 @@ var SkillManager = class {
       throw error;
     });
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Project skill path is not a real directory: ${validName}`);
-    const skillFile = join44(directory, "SKILL.md");
+    const skillFile = join45(directory, "SKILL.md");
     const fileInfo = await lstat14(skillFile);
     if (!fileInfo.isFile() || fileInfo.isSymbolicLink()) throw new Error(`Project skill file is not a real file: ${validName}`);
     await writeFile16(skillFile, renderSkill(value), { encoding: "utf8", mode: 384 });
@@ -30454,12 +31236,12 @@ var SkillManager = class {
   async #registry() {
     const loaded = await loadConfig({ cwd: this.#workspace, home: this.#home });
     const [globalPluginRoots, projectPluginRoots] = await Promise.all([
-      discoverPluginSkillRoots(join44(this.#home, ".flavor-code", "plugins")),
-      discoverPluginSkillRoots(join44(this.#workspace, ".flavor", "plugins"))
+      discoverPluginSkillRoots(join45(this.#home, ".flavor-code", "plugins")),
+      discoverPluginSkillRoots(join45(this.#workspace, ".flavor", "plugins"))
     ]);
     return {
       registry: new SkillRegistry({
-        globalRoots: [join44(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
+        globalRoots: [join45(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
         projectRoots: [this.#projectRoot(), ...projectPluginRoots]
       }),
       disabled: new Set(loaded.config.skills.disabled)
@@ -30475,10 +31257,10 @@ var SkillManager = class {
     };
   }
   #projectRoot() {
-    return join44(this.#workspace, ".flavor", "skills");
+    return join45(this.#workspace, ".flavor", "skills");
   }
   #projectSkillDirectory(name) {
-    return join44(this.#projectRoot(), name);
+    return join45(this.#projectRoot(), name);
   }
 };
 function parseName(value) {
@@ -30519,9 +31301,9 @@ async function discoverPluginSkillRoots(directory) {
   const roots = [];
   for (const entry2 of entries) {
     if (!entry2.isDirectory() || entry2.isSymbolicLink()) continue;
-    const pluginRoot = await realpath13(join44(directory, entry2.name));
+    const pluginRoot = await realpath13(join45(directory, entry2.name));
     try {
-      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile35(join44(pluginRoot, "flavor-plugin.json"), "utf8")));
+      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile36(join45(pluginRoot, "flavor-plugin.json"), "utf8")));
       for (const contribution of manifest.contributes.skillRoots) {
         const candidate = resolve37(pluginRoot, contribution.path);
         const info = await lstat14(candidate);
@@ -30596,11 +31378,11 @@ async function createProjectMemoryManager(options) {
 }
 
 // src/mcp/config-manager.ts
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 var ProjectMcpConfigManager = class {
   path;
   constructor(workspace) {
-    this.path = join45(workspace, ".flavor", "flavor.json");
+    this.path = join46(workspace, ".flavor", "flavor.json");
   }
   async list() {
     const document = await readRecoverableFile(this.path, (raw) => parseDocument2(this.path, raw));
@@ -30697,7 +31479,7 @@ function isRecord7(value) {
 }
 
 // src/desktop/model-config.ts
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 var DEFAULT_DESKTOP_MODELS = [
   {
     id: "anthropic:deepseek-v4-pro",
@@ -30718,7 +31500,7 @@ var DEFAULT_DESKTOP_MODELS = [
 ];
 async function loadDesktopModels(workspace, home) {
   try {
-    const tokens2 = await createFileTokenStore(join46(home, ".flavor-code", "auth.json")).load();
+    const tokens2 = await createFileTokenStore(join47(home, ".flavor-code", "auth.json")).load();
     const pkceModels = [];
     const knownPkce = /* @__PURE__ */ new Set();
     for (const token of Object.values(tokens2)) {
@@ -30786,7 +31568,7 @@ function protocolLabel(type) {
 
 // src/desktop/d2c-product-preview.ts
 import { createReadStream as createReadStream2 } from "fs";
-import { realpath as realpath14, stat as stat15 } from "fs/promises";
+import { realpath as realpath14, stat as stat16 } from "fs/promises";
 import { createServer as createServer6 } from "http";
 import { extname as extname4, isAbsolute as isAbsolute20, relative as relative27, resolve as resolve38, sep as sep28 } from "path";
 var MIME_TYPES = {
@@ -30811,7 +31593,7 @@ function isInside(root, candidate) {
 }
 async function startD2cProductPreview(rootDirectory) {
   const root = await realpath14(resolve38(rootDirectory));
-  const rootInfo = await stat15(root);
+  const rootInfo = await stat16(root);
   if (!rootInfo.isDirectory()) throw new Error("D2C product prototype directory is unavailable");
   const server = createServer6(async (request, response2) => {
     response2.setHeader("cache-control", "no-store");
@@ -30826,7 +31608,7 @@ async function startD2cProductPreview(rootDirectory) {
       if (!isInside(root, unresolved)) return sendNotFound(response2);
       const target = await realpath14(unresolved).catch(() => void 0);
       if (target === void 0 || !isInside(root, target)) return sendNotFound(response2);
-      const info = await stat15(target);
+      const info = await stat16(target);
       if (!info.isFile()) return sendNotFound(response2);
       response2.writeHead(200, {
         "content-length": info.size,
@@ -30863,33 +31645,33 @@ function pngDataUrl(png) {
 }
 async function detectD2cFramework(workspace, task) {
   try {
-    const pkg = JSON.parse(await readFile36(join47(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
+    const pkg = JSON.parse(await readFile37(join48(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
     return pkg.dependencies?.react === void 0 ? "vue" : "react";
   } catch {
     return "vue";
   }
 }
 function integrationDirectory(workspace, task) {
-  return join47(workspace, ".flavor", "d2c", task, "integration");
+  return join48(workspace, ".flavor", "d2c", task, "integration");
 }
 var D2C_BACKEND_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".cfg", ".env", ".ini", ".js", ".json", ".lock", ".mjs", ".py", ".toml", ".txt", ".yaml", ".yml"]);
 var D2C_BACKEND_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".venv", "__pycache__", "data", "node_modules", "venv"]);
 async function d2cBackendSourceFingerprint(project) {
-  const runtimeManifest = join47(project, "server", "flavor-runtime.json");
-  const realBackend = (await stat16(runtimeManifest).catch(() => void 0))?.isFile() === true;
-  const root = realBackend ? join47(project, "server") : join47(project, "mock");
-  if ((await stat16(root).catch(() => void 0))?.isDirectory() !== true) return void 0;
+  const runtimeManifest = join48(project, "server", "flavor-runtime.json");
+  const realBackend = (await stat17(runtimeManifest).catch(() => void 0))?.isFile() === true;
+  const root = realBackend ? join48(project, "server") : join48(project, "mock");
+  if ((await stat17(root).catch(() => void 0))?.isDirectory() !== true) return void 0;
   const files = [];
   const visit = async (directory) => {
     const entries = await readdir13(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (entry2.isDirectory()) {
-        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join47(directory, entry2.name));
+        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join48(directory, entry2.name));
         continue;
       }
       if (!entry2.isFile()) continue;
       const extension2 = entry2.name.includes(".") ? `.${entry2.name.split(".").pop().toLowerCase()}` : "";
-      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join47(directory, entry2.name));
+      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join48(directory, entry2.name));
     }
   };
   await visit(root);
@@ -30897,7 +31679,7 @@ async function d2cBackendSourceFingerprint(project) {
   for (const path of files.sort()) {
     hash.update(path.slice(root.length));
     hash.update("\0");
-    hash.update(await readFile36(path));
+    hash.update(await readFile37(path));
     hash.update("\0");
   }
   return hash.digest("hex");
@@ -30933,6 +31715,7 @@ var DesktopRuntimeController = class {
   #busy = false;
   #tasks;
   #disposeJobSubscription;
+  #memoryRestartPromise;
   #d2cMocks = /* @__PURE__ */ new Map();
   #d2cPreviews = /* @__PURE__ */ new Map();
   #d2cProductPreviews = /* @__PURE__ */ new Map();
@@ -31059,6 +31842,7 @@ var DesktopRuntimeController = class {
         this.#captureSessionOutput(event);
         this.#emit({ type: "session-output", sessionId: outputSessionId, event });
       },
+      onMemoryRestartRequested: (sessionId) => this.#scheduleMemoryRestart(sessionId),
       onApprovalChange: () => {
         if (this.#runtime !== void 0) this.#publishSnapshot();
       },
@@ -31443,8 +32227,8 @@ var DesktopRuntimeController = class {
     if (workflow === void 0 || !reviewProgress(workflow).complete || workflow.stage === "visual-review") {
       throw new Error("Complete visual review before importing OpenAPI");
     }
-    const moduleManifest = join47(d2cOutputDirectory(workspace, task), "d2c.modules.json");
-    const moduleManifestInfo = await stat16(moduleManifest).catch(() => void 0);
+    const moduleManifest = join48(d2cOutputDirectory(workspace, task), "d2c.modules.json");
+    const moduleManifestInfo = await stat17(moduleManifest).catch(() => void 0);
     if (moduleManifestInfo === void 0 || !moduleManifestInfo.isFile()) {
       throw new Error("D2C implementation must write d2c.modules.json before API mapping; ask the agent to split the project into modules first");
     }
@@ -31456,8 +32240,8 @@ var DesktopRuntimeController = class {
     await mkdir27(dir, { recursive: true });
     const hash = createHash27("sha256").update(raw).digest("hex");
     await Promise.all([
-      writeFile17(join47(dir, "swagger.json"), raw),
-      writeFile17(join47(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
+      writeFile17(join48(dir, "swagger.json"), raw),
+      writeFile17(join48(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
 `)
     ]);
     const next = {
@@ -31481,9 +32265,9 @@ var DesktopRuntimeController = class {
     const workspace = this.#workspace;
     if (workspace === void 0) throw new Error("Open a project before importing OpenAPI");
     await this.#assertProductPrdLocked(workspace, task);
-    const info = await stat16(sourcePath);
+    const info = await stat17(sourcePath);
     if (!info.isFile() || info.size > 8 * 1024 * 1024) throw new Error("OpenAPI JSON must be a file no larger than 8 MiB");
-    return this.#storeD2cOpenApi(workspace, task, basename10(sourcePath), await readFile36(sourcePath, "utf8"), false);
+    return this.#storeD2cOpenApi(workspace, task, basename10(sourcePath), await readFile37(sourcePath, "utf8"), false);
   }
   async getD2cIntegration(task) {
     const workspace = this.#workspace;
@@ -31492,8 +32276,8 @@ var DesktopRuntimeController = class {
     let workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi === void 0 && workflow !== void 0 && reviewProgress(workflow).complete && await readD2cProductPlanView(workspace, task) !== void 0) {
       const modules = await readD2cModules(workspace, task);
-      const productOpenApiPath = join47(taskDir(workspace, task), "product", "openapi.json");
-      const authored = await readFile36(productOpenApiPath, "utf8").catch(() => void 0);
+      const productOpenApiPath = join48(taskDir(workspace, task), "product", "openapi.json");
+      const authored = await readFile37(productOpenApiPath, "utf8").catch(() => void 0);
       const generated = authored === void 0;
       const prepared = await this.#storeD2cOpenApi(
         workspace,
@@ -31505,7 +32289,7 @@ var DesktopRuntimeController = class {
       return prepared;
     }
     if (workflow?.openapi === void 0 || workflow.mappings === void 0) return void 0;
-    const document = JSON.parse(await readFile36(join47(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
+    const document = JSON.parse(await readFile37(join48(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
     return { workflow, document, mappings: workflow.mappings };
   }
   async confirmD2cMapping(task, moduleId, operationKey) {
@@ -31572,7 +32356,7 @@ var DesktopRuntimeController = class {
     ].join("\n");
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery?.nodes.api.status === "running") {
-      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile36(join47(project, file)))));
+      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile37(join48(project, file)))));
       const completed = await updateDeliveryRun(
         workspace,
         task,
@@ -31599,8 +32383,8 @@ var DesktopRuntimeController = class {
     try {
       const fingerprint2 = await d2cBackendSourceFingerprint(project);
       if (fingerprint2 !== void 0) this.#d2cMockSourceFingerprints.set(task, fingerprint2);
-      const environmentPath = join47(project, ".env.local");
-      const existingEnvironment = await readFile36(environmentPath, "utf8").catch(() => "");
+      const environmentPath = join48(project, ".env.local");
+      const existingEnvironment = await readFile37(environmentPath, "utf8").catch(() => "");
       const environment = `${existingEnvironment.split(/\r?\n/).filter((line) => !/^\s*VITE_API_BASE_URL\s*=/.test(line)).join("\n").trim()}
 VITE_API_BASE_URL=${running.url}
 `.replace(/^\n/, "");
@@ -31680,8 +32464,8 @@ VITE_API_BASE_URL=${running.url}
     const readyPreview = this.#d2cPreviews.get(task);
     const readyMock = this.#d2cMocks.get(task);
     if (readyPreview === void 0 || readyMock === void 0) throw new Error("D2C preview or backend service is unavailable after synchronization");
-    const manifestPath = join47(taskDir(workspace, task), "design", "interaction-manifest.json");
-    const manifest = parseInteractionManifest(await readFile36(manifestPath, "utf8"));
+    const manifestPath = join48(taskDir(workspace, task), "design", "interaction-manifest.json");
+    const manifest = parseInteractionManifest(await readFile37(manifestPath, "utf8"));
     const baseline = await this.#verifyAcceptanceBaseline(workspace, task);
     const coverage = baseline === void 0 ? void 0 : verifyRequirementCoverage(baseline.approvedPrd.criteria, manifest);
     let executableManifest = manifest;
@@ -31692,7 +32476,7 @@ VITE_API_BASE_URL=${running.url}
       await mkdir27(planDir, { recursive: true });
       try {
         const observations = await this.#observeD2cPages(manifest, readyPreview.url);
-        const prd = await readFile36(join47(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
+        const prd = await readFile37(join48(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
         const apiContext = JSON.stringify({ openapi: workflow.openapi, mappings: workflow.mappings }, null, 2);
         const plan = await this.#d2cJudge.planInteractions({ task, seed: manifest, observations, ...prd === void 0 ? {} : { prd }, apiContext });
         executableManifest = mergeInteractionManifests(manifest, plan.manifest);
@@ -31703,9 +32487,9 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: executableManifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           pageAnalyses: plan.pageAnalyses
         };
-        await writeFile17(join47(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
+        await writeFile17(join48(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
-        await rm15(join47(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
+        await rm15(join48(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
       } catch (cause) {
         const detail = message(cause);
         review = {
@@ -31713,8 +32497,8 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: manifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           warning: `\u591A\u6A21\u6001\u81EA\u4E3B\u89C4\u5212\u5931\u8D25\uFF0C\u5DF2\u7EE7\u7EED\u6267\u884C\u5DF2\u786E\u8BA4\u7684\u8BBE\u8BA1\u5951\u7EA6\uFF1A${detail}`
         };
-        await rm15(join47(planDir, "autonomous-interaction-plan.json"), { force: true });
-        await writeFile17(join47(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
+        await rm15(join48(planDir, "autonomous-interaction-plan.json"), { force: true });
+        await writeFile17(join48(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
           schema: 1,
           stage: "planning",
           occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -31728,13 +32512,13 @@ VITE_API_BASE_URL=${running.url}
     let result = { ...rawResult, evidenceMode: review.mode };
     if (coverage !== void 0) {
       const evidence = createAcceptanceEvidence(coverage, result);
-      await writeFile17(join47(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
+      await writeFile17(join48(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       if (!evidence.passed) result = { ...result, passed: false, failures: Math.max(1, result.failures) };
     }
     const dir = integrationDirectory(workspace, task);
     await mkdir27(dir, { recursive: true });
-    await writeFile17(join47(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
+    await writeFile17(join48(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
 `);
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyInteractionRun(current, result));
     return { workflow: next, result, review };
@@ -31747,7 +32531,7 @@ VITE_API_BASE_URL=${running.url}
     if (mock === void 0 || !mock.exited() || result.failures === 0) return result;
     const output = mock.output().trim();
     try {
-      const dir = join47(d2cOutputDirectory(workspace, task), "mock-server.log");
+      const dir = join48(d2cOutputDirectory(workspace, task), "mock-server.log");
       await writeFile17(dir, `${output}
 `);
     } catch {
@@ -31842,7 +32626,7 @@ VITE_API_BASE_URL=${running.url}
     if (current === void 0) throw new Error("D2C product plan is unavailable");
     if (current.plan.approvedPrd !== void 0) throw new Error("The approved PRD is immutable and cannot be edited");
     if (current.plan.phase !== "prd-review") throw new Error("PRD sections can only be edited during PRD review");
-    const path = join47(taskDir(workspace, task), "product", "prd.md");
+    const path = join48(taskDir(workspace, task), "product", "prd.md");
     const updated = await updatePrdSectionFile(path, { sectionId, body, expectedHash });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await writeD2cProductPlan(workspace, {
@@ -31862,33 +32646,33 @@ VITE_API_BASE_URL=${running.url}
   async #assertProductPrdLocked(workspace, task) {
     const current = await readD2cProductPlanView(workspace, task);
     if (current?.plan.approvedPrd === void 0) return;
-    await assertApprovedPrd(join47(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
+    await assertApprovedPrd(join48(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
   }
   async #acceptancePaths(workspace, task) {
-    const product = join47(taskDir(workspace, task), "product");
-    const openapi = join47(product, "openapi.json");
+    const product = join48(taskDir(workspace, task), "product");
+    const openapi = join48(product, "openapi.json");
     return {
-      prd: join47(product, "prd.md"),
-      prototype: join47(product, "prototype", "index.html"),
-      interaction: join47(product, "prototype", "interaction-manifest.json"),
-      ...await stat16(openapi).catch(() => void 0) === void 0 ? {} : { openapi }
+      prd: join48(product, "prd.md"),
+      prototype: join48(product, "prototype", "index.html"),
+      interaction: join48(product, "prototype", "interaction-manifest.json"),
+      ...await stat17(openapi).catch(() => void 0) === void 0 ? {} : { openapi }
     };
   }
   async #verifyAcceptanceBaseline(workspace, task) {
     const product = await readD2cProductPlanView(workspace, task);
     if (product?.plan.approvedPrd === void 0) return void 0;
     await this.#assertProductPrdLocked(workspace, task);
-    const baseline = JSON.parse(await readFile36(join47(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
+    const baseline = JSON.parse(await readFile37(join48(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
     await verifyAcceptanceBaseline(await this.#acceptancePaths(workspace, task), baseline);
-    const design = join47(taskDir(workspace, task), "design");
+    const design = join48(taskDir(workspace, task), "design");
     await Promise.all([
-      verifyAcceptanceArtifact(join47(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
-      verifyAcceptanceArtifact(join47(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
+      verifyAcceptanceArtifact(join48(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
+      verifyAcceptanceArtifact(join48(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
     ]);
     const workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi !== void 0) {
       await verifyAcceptanceArtifact(
-        join47(taskDir(workspace, task), "integration", "swagger.json"),
+        join48(taskDir(workspace, task), "integration", "swagger.json"),
         { hash: workflow.openapi.hash },
         "runtime OpenAPI contract"
       );
@@ -31909,14 +32693,14 @@ VITE_API_BASE_URL=${running.url}
       throw new Error("D2C PRD is empty and cannot be accepted");
     }
     if (stage === "design" && accepted) {
-      const manifest = join47(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
-      const normalizedManifest = parseInteractionManifest(await readFile36(manifest, "utf8"));
+      const manifest = join48(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
+      const normalizedManifest = parseInteractionManifest(await readFile37(manifest, "utf8"));
       if (current.plan.approvedPrd === void 0) throw new Error("Approve the PRD before confirming the design");
       verifyRequirementCoverage(current.plan.approvedPrd.criteria, normalizedManifest);
       await writeFile17(manifest, `${JSON.stringify(normalizedManifest, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       const baseline = await captureAcceptanceBaseline(await this.#acceptancePaths(workspace, task), current.plan.approvedPrd);
-      await writeFile17(join47(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
+      await writeFile17(join48(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     }
     const plan = await writeD2cProductPlan(
@@ -31950,8 +32734,8 @@ VITE_API_BASE_URL=${running.url}
     const imported = await this.importD2cDesign(task, d2cProductPrototypeDirectory(workspace, task));
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery !== void 0) {
-      const prototype = await readFile36(join47(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
-      const interaction = await readFile36(join47(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
+      const prototype = await readFile37(join48(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
+      const interaction = await readFile37(join48(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
       const completed = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "design", [
         artifactRef("product/prototype/index.html", prototype),
         artifactRef("product/prototype/interaction-manifest.json", interaction)
@@ -32035,10 +32819,10 @@ VITE_API_BASE_URL=${running.url}
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyQualityJudgment(current, judgment));
     const qualityContent = `${JSON.stringify(judgment, null, 2)}
 `;
-    await writeFile17(join47(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
+    await writeFile17(join48(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
     const delivery = await readDeliveryRun(workspace, task);
     if (next.stage === "completed" && delivery?.nodes.acceptance.status === "running") {
-      const interactionContent = await readFile36(join47(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
+      const interactionContent = await readFile37(join48(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
       const accepted = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "acceptance", [
         artifactRef("integration/interaction-results.json", interactionContent),
         artifactRef("quality-judge.json", qualityContent)
@@ -32120,6 +32904,39 @@ VITE_API_BASE_URL=${running.url}
     await runtime.session.close();
     await runtime.dispose();
   }
+  /**
+   * Electron owns the process, so a heap rotation rebuilds only the production
+   * runtime. Disposing every holder and forcing GC gives the resumed /loop or
+   * /goal a clean live set without terminating the desktop application.
+   */
+  #scheduleMemoryRestart(sessionId) {
+    if (this.#memoryRestartPromise !== void 0) return;
+    const previous = this.#runtime;
+    this.#memoryRestartPromise = (async () => {
+      await previous?.session.whenIdle?.().catch(() => void 0);
+      if (previous === void 0 || this.#runtime !== previous) return;
+      await this.#disposeRuntime();
+      clearMemoryRotation();
+      const gc = globalThis.gc;
+      if (typeof gc === "function") {
+        gc();
+        gc();
+      }
+      await this.startSession(sessionId);
+      const resumed = this.#runtime;
+      if (resumed !== void 0) {
+        this.#busy = true;
+        this.#publishSnapshot();
+        await resumed.session.whenIdle?.();
+      }
+    })().catch((error) => {
+      this.#emit({ type: "runtime-error", sessionId, message: `Memory restart failed: ${message(error)}` });
+    }).finally(() => {
+      this.#memoryRestartPromise = void 0;
+      this.#busy = false;
+      this.#publishSnapshot();
+    });
+  }
   async #stopAllD2cMocks() {
     const running = [...this.#d2cMocks.values()];
     this.#d2cMocks.clear();
@@ -32237,7 +33054,7 @@ async function loginShellEnvironment(environment, platform = process.platform, d
 }
 
 // src/desktop/git-manager.ts
-import { readFile as readFile37, rm as rm16 } from "fs/promises";
+import { readFile as readFile38, rm as rm16 } from "fs/promises";
 import { isAbsolute as isAbsolute21, relative as relative28, resolve as resolve40 } from "path";
 function failure(action, stderr, stdout) {
   return new Error(`${action}\u5931\u8D25\uFF1A${(stderr.trim() || stdout.trim() || "\u672A\u77E5 Git \u9519\u8BEF").split("\n")[0]}`);
@@ -32269,7 +33086,7 @@ async function desktopGitDiff(workspace, path, staged = false) {
   if (file === void 0) throw new Error("\u8BE5\u6587\u4EF6\u5DF2\u4E0D\u5728\u53D8\u66F4\u5217\u8868\u4E2D");
   if (file.untracked) {
     const target = safeWorkspacePath(workspace, path);
-    const value = await readFile37(target, "utf8");
+    const value = await readFile38(target, "utf8");
     return value.length > 12e4 ? `${value.slice(0, 12e4)}
 \u2026[\u5185\u5BB9\u5DF2\u622A\u65AD]` : value;
   }
@@ -32331,13 +33148,13 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     return path.replaceAll("\\", "/");
   }));
   try {
-    const tree = JSON.parse(await readFile37(resolve40(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
+    const tree = JSON.parse(await readFile38(resolve40(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
     const leaf = tree.nodes?.find((node) => node.id === tree.leafId);
     const parent = leaf?.parentId == null ? void 0 : tree.nodes?.find((node) => node.id === leaf.parentId);
     if (leaf === void 0 || parent === void 0) return desktopGitReviewDiff(workspace, { scope: "last-turn", paths });
     const load = async (id) => {
       if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-      return JSON.parse(await readFile37(resolve40(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
+      return JSON.parse(await readFile38(resolve40(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
     };
     const [before, after] = await Promise.all([load(parent.checkpointId), load(leaf.checkpointId)]);
     const oldFiles = new Map(before.files.map((file) => [file.path, file.digest]));
@@ -32346,7 +33163,7 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     const object = async (digest) => {
       if (digest === void 0) return "";
       if (!/^[a-f0-9]{64}$/.test(digest)) throw new Error("Invalid checkpoint object");
-      const value = await readFile37(resolve40(workspace, ".flavor", "checkpoints", "objects", digest));
+      const value = await readFile38(resolve40(workspace, ".flavor", "checkpoints", "objects", digest));
       return value.includes(0) ? "[binary content]" : value.toString("utf8");
     };
     const chunks = await Promise.all(changed.map(async (path) => wholeFileDiff(path, await object(oldFiles.get(path)), await object(newFiles.get(path)))));
@@ -32385,8 +33202,8 @@ function safeGitTarget(value) {
 
 // src/desktop/worktree-manager.ts
 import { randomUUID as randomUUID28 } from "crypto";
-import { mkdir as mkdir28, readFile as readFile38, readdir as readdir14, rm as rm17, stat as stat17, writeFile as writeFile18 } from "fs/promises";
-import { basename as basename11, isAbsolute as isAbsolute22, join as join48, relative as relative29, resolve as resolve41, sep as sep29 } from "path";
+import { mkdir as mkdir28, readFile as readFile39, readdir as readdir14, rm as rm17, stat as stat18, writeFile as writeFile18 } from "fs/promises";
+import { basename as basename11, isAbsolute as isAbsolute22, join as join49, relative as relative29, resolve as resolve41, sep as sep29 } from "path";
 var DesktopWorktreeManager = class {
   #repository;
   #storage;
@@ -32432,8 +33249,8 @@ var DesktopWorktreeManager = class {
     }
     const values = await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => {
       try {
-        const stored = validateStored(JSON.parse(await readFile38(join48(this.#storage, name), "utf8")), this.#repository, this.#storage);
-        if ((await stat17(stored.path).catch(() => void 0))?.isDirectory() !== true) return void 0;
+        const stored = validateStored(JSON.parse(await readFile39(join49(this.#storage, name), "utf8")), this.#repository, this.#storage);
+        if ((await stat18(stored.path).catch(() => void 0))?.isDirectory() !== true) return void 0;
         const status = await git2(stored.path, ["status", "--porcelain"]);
         const merged = await git2(this.#repository, ["merge-base", "--is-ancestor", stored.branch, "HEAD"]);
         const { version: _version, ...item } = stored;
@@ -32466,7 +33283,7 @@ var DesktopWorktreeManager = class {
   }
   async #load(id) {
     const path = this.#metadataPath(id);
-    return validateStored(JSON.parse(await readFile38(path, "utf8")), this.#repository, this.#storage);
+    return validateStored(JSON.parse(await readFile39(path, "utf8")), this.#repository, this.#storage);
   }
   #metadataPath(id) {
     if (!/^worktree-[a-z0-9._-]{1,80}$/.test(id)) throw new Error("Invalid worktree id");
@@ -32494,9 +33311,9 @@ function validateStored(value, repository, storage) {
 }
 
 // src/desktop/workbench-service.ts
-import { readFile as readFile39, readdir as readdir15, stat as stat18 } from "fs/promises";
+import { readFile as readFile40, readdir as readdir15, stat as stat19 } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { join as join49, resolve as resolve42 } from "path";
+import { join as join50, resolve as resolve42 } from "path";
 var MAX_TEXT = 128e3;
 var MAX_ITEMS = 200;
 var DesktopWorkbenchService = class {
@@ -32529,11 +33346,11 @@ var DesktopWorkbenchService = class {
     return url.toString().replace(/\/$/, input.trim().endsWith("/") ? "/" : "");
   }
   async #goals() {
-    const root = join49(this.#workspace, ".flavor", "goals");
+    const root = join50(this.#workspace, ".flavor", "goals");
     const names = await readdir15(root).catch((error) => error.code === "ENOENT" ? [] : Promise.reject(error));
     const values = await Promise.all(names.filter((name) => /^goal-[A-Za-z0-9._-]+\.json$/.test(name)).slice(0, MAX_ITEMS).map(async (name) => {
       try {
-        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join49(root, name))));
+        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join50(root, name))));
       } catch {
         return void 0;
       }
@@ -32543,7 +33360,7 @@ var DesktopWorkbenchService = class {
   async #instructions() {
     const names = ["FLAVOR.md", "AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
     const items = await Promise.all(names.map(async (name) => {
-      const path = join49(this.#workspace, name);
+      const path = join50(this.#workspace, name);
       try {
         return { name, path, content: redactErrorText(await boundedRead2(path)) };
       } catch (error) {
@@ -32556,9 +33373,9 @@ var DesktopWorkbenchService = class {
   async #permissionFiles() {
     const candidates = [
       ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve42(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
-      { tier: "user", path: join49(this.#home, ".flavor-code", "permissions.json"), content: "" },
-      { tier: "project", path: join49(this.#workspace, ".flavor", "permissions.json"), content: "" },
-      { tier: "local", path: join49(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
+      { tier: "user", path: join50(this.#home, ".flavor-code", "permissions.json"), content: "" },
+      { tier: "project", path: join50(this.#workspace, ".flavor", "permissions.json"), content: "" },
+      { tier: "local", path: join50(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
     ];
     const values = await Promise.all(candidates.map(async (item) => {
       try {
@@ -32573,7 +33390,7 @@ var DesktopWorkbenchService = class {
   async #audit() {
     let raw;
     try {
-      raw = await boundedRead2(join49(this.#workspace, ".flavor", "audit.jsonl"));
+      raw = await boundedRead2(join50(this.#workspace, ".flavor", "audit.jsonl"));
     } catch (error) {
       if (error.code === "ENOENT") return [];
       throw error;
@@ -32588,7 +33405,7 @@ var DesktopWorkbenchService = class {
     }).reverse();
   }
   async #context(sessionId) {
-    const usage = await readJsonLines2(join49(this.#workspace, ".flavor", "usage.jsonl"));
+    const usage = await readJsonLines2(join50(this.#workspace, ".flavor", "usage.jsonl"));
     if (sessionId === void 0) return { visibility: [], usage };
     try {
       const document = await new SessionStore({ workspace: this.#workspace }).load(sessionId);
@@ -32599,10 +33416,10 @@ var DesktopWorkbenchService = class {
   }
 };
 async function boundedRead2(path) {
-  const info = await stat18(path);
+  const info = await stat19(path);
   if (!info.isFile()) throw new Error(`Expected a file: ${path}`);
   if (info.size > MAX_TEXT) throw new Error(`Workbench file exceeds ${MAX_TEXT} bytes: ${path}`);
-  return readFile39(path, "utf8");
+  return readFile40(path, "utf8");
 }
 async function readJsonLines2(path) {
   try {
@@ -32635,7 +33452,7 @@ var appMenu;
 var quitting = false;
 function logStartup(step, detail) {
   try {
-    const logPath = join50(dirname23(process.execPath), "flavor-code-startup.log");
+    const logPath = join51(dirname23(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);
@@ -32660,7 +33477,7 @@ var d2cEmbedded = createEmbeddedD2cAutomation(() => {
   };
 });
 var d2cJudgeClient = createD2cJudgeClient();
-var judgeStore = () => createD2cJudgeConfigStore(join50(app.getPath("userData"), "d2c-judge.json"));
+var judgeStore = () => createD2cJudgeConfigStore(join51(app.getPath("userData"), "d2c-judge.json"));
 function judgeImage(png) {
   const image = nativeImage.createFromBuffer(png);
   const size = image.getSize();
@@ -32686,7 +33503,7 @@ function sessionMetaKey(workspace, sessionId) {
 }
 function worktreeManager(workspace) {
   const key = createHash28("sha256").update(resolve43(workspace)).digest("hex").slice(0, 20);
-  return new DesktopWorktreeManager({ repository: workspace, storage: join50(app.getPath("userData"), "task-worktrees", key) });
+  return new DesktopWorktreeManager({ repository: workspace, storage: join51(app.getPath("userData"), "task-worktrees", key) });
 }
 function activeWorkingDirectory() {
   if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
@@ -32831,7 +33648,7 @@ function createDesktopController(workspace, owner2) {
         alias: `desktop-${basename12(workspace ?? runtimeOptions.workspace ?? "flavor")}`.slice(0, 64),
         optional: true,
         startBroker: (address) => {
-          const entry2 = app.isPackaged ? join50(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join50(moduleDirectory, "pals-broker-entry.js");
+          const entry2 = app.isPackaged ? join51(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join51(moduleDirectory, "pals-broker-entry.js");
           return spawnPalBrokerProcess({
             address,
             executable: process.execPath,
@@ -32853,11 +33670,11 @@ function createDesktopController(workspace, owner2) {
 var detachedController = createDesktopController();
 var controller = detachedController;
 function statePath() {
-  return join50(app.getPath("userData"), "desktop-state.json");
+  return join51(app.getPath("userData"), "desktop-state.json");
 }
 async function loadPersistedProjects() {
   try {
-    const raw = await readFile40(statePath(), "utf8");
+    const raw = await readFile41(statePath(), "utf8");
     if (raw.length > 1e5) return { projects: [] };
     const parsed = JSON.parse(raw);
     Object.assign(workbench, {
@@ -32898,7 +33715,7 @@ function validRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 async function assertDirectory(path) {
-  if (!(await stat19(path)).isDirectory()) throw new Error("The selected project is not a directory");
+  if (!(await stat20(path)).isDirectory()) throw new Error("The selected project is not a directory");
 }
 async function openWorkspace(path) {
   const workspace = resolve43(path);
@@ -33029,7 +33846,7 @@ async function chooseAndOpenWorkspace() {
 var cachedAppIconDataUrl;
 function appIconDataUrl() {
   if (cachedAppIconDataUrl !== void 0) return cachedAppIconDataUrl;
-  const icon = nativeImage.createFromPath(join50(app.getAppPath(), "assets", "icon.png"));
+  const icon = nativeImage.createFromPath(join51(app.getAppPath(), "assets", "icon.png"));
   if (icon.isEmpty()) return void 0;
   cachedAppIconDataUrl = icon.toDataURL();
   return cachedAppIconDataUrl;
@@ -33447,7 +34264,7 @@ function applicationMenu() {
   ]);
 }
 async function createWindow() {
-  const rendererPath = join50(app.getAppPath(), "dist", "desktop-renderer", "index.html");
+  const rendererPath = join51(app.getAppPath(), "dist", "desktop-renderer", "index.html");
   mainWindow = new BrowserWindow2({
     title: "Flavor Code",
     width: 1280,
@@ -33458,14 +34275,14 @@ async function createWindow() {
     show: false,
     ...desktopWindowChrome(),
     webPreferences: {
-      preload: join50(moduleDirectory, "preload.cjs"),
+      preload: join51(moduleDirectory, "preload.cjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
       webSecurity: true
     }
   });
-  const iconPath = join50(app.getAppPath(), "assets", "icon.png");
+  const iconPath = join51(app.getAppPath(), "assets", "icon.png");
   const icon = nativeImage.createFromPath(iconPath);
   if (!icon.isEmpty()) {
     mainWindow.setIcon(icon);