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

package/dist/{chunk-6MNOZ2TX.js → chunk-DCNUBQCH.js}

@@ -2,10 +2,15 @@
 import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
 import {
   MEMORY_RESTART_EXIT_CODE,
+  consumedMemoryRestartMarker,
+  markMemoryRotation,
   memoryRestartMarkerPath,
+  memoryRotationActive,
   nextMemoryRestartMarker,
-  parseMemoryRestartMarker
-} from "./chunk-CIVPKHF4.js";
+  parseMemoryRestartMarker,
+  pendingContinuation,
+  rotationCooldownActive
+} from "./chunk-LKQTBL3R.js";
 import {
   PERMISSION_MODES,
   PermissionModeSchema,
@@ -18,7 +23,7 @@ import {
   redactConfig,
   setProjectMcpServerDisabled,
   updateProtectedFile
-} from "./chunk-URUVFECH.js";
+} from "./chunk-KQMKY7C5.js";
 import {
   AuditLogger,
   appendUsageLog,
@@ -32,7 +37,7 @@ import {
   resolveLanguage,
   setUsageSession,
   usageLogPath
-} from "./chunk-3WCDZ6ZL.js";
+} from "./chunk-ZJCAQXA7.js";
 
 // src/models/types.ts
 function modelContentText(content) {
@@ -75,12 +80,12 @@ function normalizeProviderError(error) {
 
 // src/utils/async.ts
 function withTimeout(promise, ms) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      resolve31({ timedOut: true, value: void 0 });
+      resolve32({ timedOut: true, value: void 0 });
     }, ms);
     timer.unref?.();
     promise.then(
@@ -88,7 +93,7 @@ function withTimeout(promise, ms) {
         if (!settled) {
           settled = true;
           clearTimeout(timer);
-          resolve31({ timedOut: false, value });
+          resolve32({ timedOut: false, value });
         }
       },
       (error) => {
@@ -103,13 +108,13 @@ function withTimeout(promise, ms) {
 }
 function awaitWithSignal(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const onAbort = () => reject(signal.reason);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve31(value);
+        resolve32(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -572,9 +577,7 @@ function redactSecrets(input, secrets) {
 
 // src/init/project.ts
 import { lstat, mkdir, readdir, readFile, realpath, writeFile } from "fs/promises";
-import { copyFileSync, mkdirSync, readdirSync } from "fs";
-import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join, relative as relative2, sep as sep2 } from "path";
-import { fileURLToPath } from "url";
+import { basename, isAbsolute as isAbsolute2, join, relative as relative2, sep as sep2 } from "path";
 var GENERATED_START = "<!-- flavor-code:start -->";
 var GENERATED_END = "<!-- flavor-code:end -->";
 var MAX_MANIFEST_BYTES = 1e6;
@@ -1025,29 +1028,8 @@ async function createExampleFlavorConfig(cwd) {
   };
   await writeFile(configPath, JSON.stringify(example, null, 2) + "\n");
 }
-var ASTGRAPH_SRC_DIR = join(dirname2(fileURLToPath(import.meta.url)), "astgraph");
-async function copyAstgraphPlugin(cwd) {
-  const pluginDir = join(cwd, ".flavor", "plugins", "astgraph");
-  try {
-    await lstat(pluginDir);
-    return;
-  } catch (error) {
-    if (!isMissingPathError(error)) throw error;
-  }
-  copyDirectory(ASTGRAPH_SRC_DIR, pluginDir);
-}
-function copyDirectory(from, to) {
-  mkdirSync(to, { recursive: true, mode: 448 });
-  for (const entry2 of readdirSync(from, { withFileTypes: true })) {
-    const source = join(from, entry2.name);
-    const target = join(to, entry2.name);
-    if (entry2.isDirectory()) copyDirectory(source, target);
-    else if (entry2.isFile()) copyFileSync(source, target);
-  }
-}
 async function initializeFlavor(cwd) {
   await ensureFlavorDirectories(cwd);
-  await copyAstgraphPlugin(cwd);
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
   const path = join(cwd, "FLAVOR.md");
@@ -1069,12 +1051,12 @@ async function initializeFlavor(cwd) {
 
 // src/utils/version.ts
 import { readFileSync } from "fs";
-import { dirname as dirname3, join as join2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
 var cached;
 function packageVersion() {
   if (cached !== void 0) return cached;
-  let directory = dirname3(fileURLToPath2(import.meta.url));
+  let directory = dirname2(fileURLToPath(import.meta.url));
   for (; ; ) {
     try {
       const manifest = JSON.parse(readFileSync(join2(directory, "package.json"), "utf8"));
@@ -1084,7 +1066,7 @@ function packageVersion() {
       }
     } catch {
     }
-    const parent = dirname3(directory);
+    const parent = dirname2(directory);
     if (parent === directory) break;
     directory = parent;
   }
@@ -1879,7 +1861,7 @@ function addText(turn, text, onNewLine = false) {
 import { createHash, randomUUID } from "crypto";
 import { execFile } from "child_process";
 import { lstat as lstat2, mkdir as mkdir2, open, readFile as readFile2, readdir as readdir2, rename, rm, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname4, join as join3, relative as relative3, resolve as resolve2, sep as sep3 } from "path";
+import { dirname as dirname3, join as join3, relative as relative3, resolve as resolve2, sep as sep3 } 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;
@@ -1965,7 +1947,7 @@ var WorkspaceCheckpointStore = class {
     for (const file of checkpoint.files) {
       const target = contained(this.#workspace, file.path);
       const object = objects.get(file.digest);
-      await mkdir2(dirname4(target), { recursive: true });
+      await mkdir2(dirname3(target), { recursive: true });
       const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
       await writeFile2(temporary, object, { mode: file.mode });
       await rename(temporary, target);
@@ -2037,7 +2019,7 @@ function contained(workspace, path) {
   return absolute;
 }
 async function atomicJson(path, value) {
-  await mkdir2(dirname4(path), { recursive: true });
+  await mkdir2(dirname3(path), { recursive: true });
   const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
   await writeFile2(temporary, `${JSON.stringify(value)}
 `, { encoding: "utf8", mode: 384 });
@@ -2050,7 +2032,7 @@ function isCode(error, code) {
 // src/session/tree.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname5, join as join4, resolve as resolve3 } from "path";
+import { dirname as dirname4, join as join4, resolve as resolve3 } from "path";
 var MAX_SESSION_HISTORY_NODES = 100;
 var MAX_SESSION_HISTORY_CONTEXT_CHARS = 2e6;
 var SessionHistory = class _SessionHistory {
@@ -2084,6 +2066,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));
   }
@@ -2155,7 +2141,7 @@ var SessionHistory = class _SessionHistory {
       leafId: this.#leafId,
       nodes: this.#nodes
     };
-    await mkdir3(dirname5(this.#path), { recursive: true });
+    await mkdir3(dirname4(this.#path), { recursive: true });
     const temporary = `${this.#path}.${process.pid}.${randomUUID2()}.tmp`;
     await writeFile3(temporary, `${JSON.stringify(document)}
 `, { encoding: "utf8", mode: 384 });
@@ -2201,7 +2187,7 @@ function isCode2(error, code) {
 // src/tools/search.ts
 import { spawn } from "child_process";
 import { open as open2, opendir, stat } from "fs/promises";
-import { dirname as dirname6, isAbsolute as isAbsolute3, relative as relative4, resolve as resolve4, sep as sep4 } from "path";
+import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve4, sep as sep4 } from "path";
 import { rgPath as bundledRgPath } from "@vscode/ripgrep";
 import createIgnore from "ignore";
 import { z } from "zod";
@@ -2292,8 +2278,9 @@ var GlobInput = z.object({
   limit: z.coerce.number().int().positive().max(1e5).nullable().optional()
 });
 var GrepInput = z.object({
-  pattern: z.string().min(1),
-  path: z.string().min(1).describe('Workspace-relative search path. Use JSON null, not the string "null", for the workspace root.').nullable().optional(),
+  pattern: z.string().min(1).describe("Regular expression without / delimiters, or literal text when fixedStrings=true."),
+  fixedStrings: BooleanInput.describe("Match literal text, useful for Markdown links and paths containing regex punctuation.").nullable().optional(),
+  path: z.string().min(1).describe("Workspace-relative file or directory. A file restricts the search to that file. Use glob for multiple filenames and JSON null for the workspace root.").nullable().optional(),
   glob: z.string().min(1).nullable().optional(),
   fileType: z.enum(FILE_TYPES).nullable().optional(),
   includeIgnored: BooleanInput.describe("Include files excluded by .gitignore or .ignore. Git metadata remains excluded.").nullable().optional(),
@@ -2342,7 +2329,7 @@ function createGrepTool(workspace, options = {}) {
   const resources = searchResources(options);
   return {
     name: "Grep",
-    description: `Search workspace text with a regular expression. fileType must be one of: ${FILE_TYPES.join(", ")}.`,
+    description: `Search workspace text with a regular expression or fixedStrings=true for literal text. Zero matches is a successful search, not a path error. fileType must be one of: ${FILE_TYPES.join(", ")}.`,
     inputSchema: GrepInput,
     paths: (input) => [scope(root, searchPath(input.path))],
     summarize: (input) => {
@@ -2350,10 +2337,10 @@ function createGrepTool(workspace, options = {}) {
       const where = path ? ` in ${path}` : "";
       const kind = input.fileType ? ` [${input.fileType}]` : "";
       const ignored2 = input.includeIgnored === true ? " (including ignored files)" : "";
-      return `pattern: /${input.pattern}/${kind}${where}${ignored2}`;
+      return `pattern: ${input.fixedStrings === true ? JSON.stringify(input.pattern) : `/${input.pattern}/`}${kind}${where}${ignored2}`;
     },
     execute: async (input, signal) => {
-      const expression = new RegExp(input.pattern);
+      const expression = new RegExp(input.fixedStrings === true ? input.pattern.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&") : input.pattern);
       const limit = input.limit ?? options.defaultLimit ?? DEFAULT_RESULT_LIMIT;
       const context = input.context ?? 0;
       const start = await resolveGrepPath(root, searchPath(input.path));
@@ -2404,10 +2391,12 @@ async function rgGrep(root, start, input, context, signal, executable, argsPrefi
   }
   const args = ["--json", "--line-number", "--column", "--sort", "path", "--hidden", "--glob", "!.git", "--glob", "!.git/**", "--max-filesize", String(maxFileBytes), "--context", String(context)];
   if (input.includeIgnored === true) args.push("--no-ignore");
+  if (input.fixedStrings === true) args.push("--fixed-strings");
   if (input.glob !== void 0 && input.glob !== null) args.push("--glob", input.glob);
   else for (const extension of typeExtensions ?? []) args.push("--glob", `*${extension}`);
   args.push("--regexp", input.pattern, "--", relative4(root, start) || ".");
   const matches = [];
+  const matcher = input.glob == null ? void 0 : globRegex(input.glob);
   const ignoreLayers = input.includeIgnored === true ? [] : await collectIgnoreLayers(root, start, signal, resources, ignoreBudget);
   const parser = delimitedParser(10, (record) => {
     if (record.length === 0) return true;
@@ -2420,6 +2409,7 @@ async function rgGrep(root, start, input, context, signal, executable, argsPrefi
     const lineWithEnding = tryDecodeUtf8(lineValue);
     if (decodedPath === void 0 || lineWithEnding === void 0) return true;
     const path = normalizePath(decodedPath).replace(/^\.\//, "");
+    if (matcher !== void 0 && !matcher.test(path)) return true;
     if (typeExtensions !== void 0 && !typeExtensions.some((extension) => path.endsWith(extension))) return true;
     if (ignored(path, false, ignoreLayers)) return true;
     const text = lineWithEnding.replace(/\r?\n$/, "");
@@ -2544,7 +2534,12 @@ async function nodeFiles(root, start, signal, accept, limit, resources, ignoreBu
     }
     ignores.length = ruleCount;
   }
-  await walk(start);
+  if ((await stat(start)).isFile()) {
+    const path = normalizedRelative(root, start);
+    if (!isGitMetadataPath(root, start) && (includeIgnored || !ignored(path, false, ignores)) && accept(path)) output.push(path);
+  } else {
+    await walk(start);
+  }
   return output;
 }
 async function collectIgnoreLayers(root, start, signal, resources, ignoreBudget) {
@@ -2574,7 +2569,7 @@ async function collectIgnoreLayers(root, start, signal, resources, ignoreBudget)
       if (!ignored(path, true, layers)) await walk(absolute);
     }
   }
-  await walk(start);
+  if (!(await stat(start)).isFile()) await walk(start);
   return layers;
 }
 async function loadIgnoreFiles(directory, base, rules, budget, signal) {
@@ -2694,8 +2689,12 @@ async function resolveGrepPath(root, path = ".") {
   const candidate = scope(root, path);
   try {
     const info = await stat(candidate);
-    if (info.isFile()) return dirname6(candidate);
-  } catch {
+    if (!info.isFile() && !info.isDirectory()) throw new Error("Search path must be a file or directory");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Search path does not exist: ${path}. Use Glob to find the file; put filename patterns in glob, not path.`);
+    }
+    throw error;
   }
   return candidate;
 }
@@ -3645,6 +3644,7 @@ var FlavorSession = class {
   #pendingCoWorkStarts = [];
   #activeSteeringDurableIds = /* @__PURE__ */ new Set();
   #durableResumeStarted = false;
+  #continuationResumeStarted = false;
   #permissionBaseline;
   #activeSubmission;
   constructor(services) {
@@ -3665,6 +3665,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"]) {
@@ -3814,6 +3818,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;
   }
@@ -3896,7 +3901,8 @@ var FlavorSession = class {
         skillNames,
         this.#services.managedToolCommands().map(({ name }) => name)
       );
-      if (command !== null) await this.#dispatch(command, controller.signal);
+      if (submission.continuation !== void 0) await this.#runContinuation(submission.continuation, controller.signal);
+      else if (command !== null) await this.#dispatch(command, controller.signal);
       else for await (const event of this.#services.run(prompt, controller.signal, {
         getSteeringMessages: () => this.#drainMessages("steer", true).map((item) => item.text),
         ...decision.additionalContext === void 0 ? {} : { additionalContext: decision.additionalContext },
@@ -4154,6 +4160,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);
@@ -4200,9 +4233,9 @@ Address this now (for example run the required verification or fix), then finish
   }
   #waitForPlanningIdle(key) {
     if (!this.#activePlanning.has(key)) return Promise.resolve();
-    return new Promise((resolve31) => {
+    return new Promise((resolve32) => {
       const check = () => {
-        if (!this.#activePlanning.has(key)) resolve31();
+        if (!this.#activePlanning.has(key)) resolve32();
         else this.#planningIdleWaiters.add(check);
       };
       this.#planningIdleWaiters.add(check);
@@ -4321,8 +4354,8 @@ async function fetchLatestVersion(options = {}) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const fetchImpl = options.fetchImpl ?? ((url, init) => fetch(url, init));
   let timer;
-  const timeout = new Promise((resolve31) => {
-    timer = setTimeout(() => resolve31(void 0), timeoutMs);
+  const timeout = new Promise((resolve32) => {
+    timer = setTimeout(() => resolve32(void 0), timeoutMs);
     timer.unref?.();
   });
   try {
@@ -4447,7 +4480,7 @@ var PluginManifestSchema = z4.object({
 }).strict();
 
 // src/tools/shell.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 import { basename as basename2, delimiter as delimiter2, isAbsolute as isAbsolute5, join as join5, relative as relative5, resolve as resolve6, sep as sep5 } from "path";
 import { z as z6 } from "zod";
@@ -4490,7 +4523,7 @@ function resolveWindowsCommand(command, cwd, env) {
     ...pathValue.split(";").filter(Boolean).map((entry2) => resolve5(unquote(entry2), command))
   ];
   for (const base of bases) {
-    const candidates = extname(base).length > 0 ? [base] : [base, ...pathExt.map((extension) => `${base}${extension}`)];
+    const candidates = extname(base).length > 0 ? [base] : [...pathExt.map((extension) => `${base}${extension}`), base];
     for (const candidate of candidates) {
       if (isRegularFile(candidate)) return resolve5(candidate);
     }
@@ -4568,7 +4601,7 @@ function createJobTools(registry) {
       inputSchema: IdInput,
       paths: () => [],
       execute: async (input, _signal, context) => {
-        registry.kill(input.id, owner(context));
+        await registry.kill(input.id, owner(context));
         return registry.read(input.id, owner(context));
       },
       presentResult: (output) => jobPresentation("kill", output)
@@ -4608,11 +4641,51 @@ function owner(context) {
   return context?.ownerId ?? context?.agent ?? "main";
 }
 
+// src/utils/process-tree.ts
+import { spawn as spawn2 } from "child_process";
+async function terminateProcessTree(pid) {
+  if (pid === void 0) return;
+  if (process.platform === "win32") {
+    await new Promise((resolve32) => {
+      const child = spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], { shell: false, windowsHide: true });
+      const finish = () => {
+        clearTimeout(timer);
+        resolve32();
+      };
+      const timer = setTimeout(finish, 5e3);
+      timer.unref();
+      child.once("error", finish);
+      child.once("close", finish);
+    });
+    try {
+      process.kill(pid);
+    } catch {
+    }
+  } else {
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    await new Promise((resolve32) => setTimeout(resolve32, 250));
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+
 // src/tools/shell.ts
 var DEFAULT_MAX_OUTPUT_BYTES = 1048576;
 var DEFAULT_SHELL_TIMEOUT_MS = 10 * 6e4;
 var ELLIPSIS = "\u2026";
-var TERMINATION_GRACE_MS = 250;
 var TERMINATION_FAILURE_MS = 5e3;
 var STREAM_CLOSE_GRACE_MS = 500;
 var ShellInput = z6.object({
@@ -4631,12 +4704,6 @@ function normalizeShellCommand(input) {
   if ((executable === "cmd" || executable === "cmd.exe") && /^\/[ck]$/iu.test(args[0] ?? "")) {
     return { command, args: [args[0], ...args.slice(1).map(unquoteToken)] };
   }
-  if ((executable === "pwsh" || executable === "pwsh.exe" || executable === "powershell" || executable === "powershell.exe") && /^(?:-c|-command)$/iu.test(args[0] ?? "") && args.length > 1) {
-    return { command, args: [args[0], ...args.slice(1).map(unquoteToken)] };
-  }
-  if (/^(?:sh|bash|zsh|fish)$/iu.test(executable) && args[0] === "-c" && args[1] !== void 0) {
-    return { command, args: [args[0], unquoteToken(args[1]), ...args.slice(2)] };
-  }
   if (!/\s/u.test(command) || containsShellSyntax(command)) return { command, args };
   const tokens = tokenizeCommandLine(command);
   if (tokens.length <= 1) return { command, args };
@@ -4754,7 +4821,8 @@ function shellInvocation(input, cwd, environment) {
         const payload = serializeCmdPayload(input.args.slice(commandFlag + 1));
         return {
           command: resolved,
-          args: [...input.args.slice(0, commandFlag + 1), `chcp 65001>nul & ${payload}`]
+          args: [...input.args.slice(0, commandFlag + 1), `chcp 65001>nul & ${payload}`],
+          windowsVerbatimArguments: true
         };
       }
     }
@@ -4770,7 +4838,8 @@ function shellInvocation(input, cwd, environment) {
   if (shell.kind === "posix") return { command: shell.command, args: ["-c", script] };
   if (shell.kind === "cmd") return {
     command: shell.command,
-    args: ["/d", "/s", "/c", `chcp 65001>nul & ${script}`]
+    args: ["/d", "/s", "/c", `chcp 65001>nul & ${script}`],
+    windowsVerbatimArguments: true
   };
   const encoded = Buffer.from(script, "utf16le").toString("base64");
   return {
@@ -4793,8 +4862,8 @@ function executionEnvironmentCommand(environment, command, args) {
 function structuredShellScript(shell, command, args) {
   if (shell.kind === "posix") return [command, ...args].map(posixQuote).join(" ");
   if (shell.kind === "cmd") return serializeCmdCommand([command, ...args]);
-  const invocation = `& ${psQuote(command)}${args.length > 0 ? ` ${args.map(psQuote).join(" ")}` : ""}`;
-  return `$ErrorActionPreference='Stop'; try { ${invocation}; if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 0 } } catch { [Console]::Error.WriteLine($_.Exception.Message); exit 127 }`;
+  const invocation = `& ${psQuote(command)}${args.length > 0 ? ` ${args.map((arg) => /^-[A-Za-z][A-Za-z0-9-]*$/u.test(arg) ? arg : psQuote(arg)).join(" ")}` : ""}`;
+  return `$ErrorActionPreference='Stop'; try { ${invocation}; if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 0 } } catch { [Console]::Error.WriteLine($_.Exception.Message); if ($_.Exception -is [System.Management.Automation.CommandNotFoundException]) { exit 127 } else { exit 1 } }`;
 }
 function posixQuote(value) {
   return `'${value.replace(/'/gu, `'"'"'`)}'`;
@@ -4827,7 +4896,7 @@ ${result.stderr}`;
     return {
       kind: "command-not-found",
       message: `Executable "${command}" was not found by the selected runtime shell.`,
-      hint: "Use a command available on PATH, or pass an existing executable path without surrounding quotes."
+      hint: "Use a command available on PATH, or pass an existing executable path without surrounding quotes. For an unavailable PowerShell cmdlet, check Get-Command and its module in the selected shell; do not keep retrying the same command."
     };
   }
   if (code === "EACCES" || /(?:permission denied|access is denied|拒绝访问)/iu.test(detail)) {
@@ -4836,11 +4905,11 @@ ${result.stderr}`;
   if (/(?:no such file or directory|cannot find (?:the )?path|system cannot find|系统找不到指定的路径)/iu.test(detail)) {
     return { kind: "path-not-found", message: "The command referenced a path that does not exist." };
   }
-  if (/(?:syntax error|unexpected token|parsererror|语法错误)/iu.test(detail)) {
+  if (/(?:syntax\s*error|unexpected token|parsererror|unterminated (?:regexp|string)|语法错误)/iu.test(detail)) {
     return {
       kind: "shell-syntax",
-      message: "The selected runtime shell rejected the command syntax.",
-      hint: "Pass normal arguments through args; reserve shell syntax for pipes, redirects, and operators."
+      message: "The command or interpreter rejected the syntax.",
+      hint: 'Pass normal arguments through args. For JavaScript use command="node", args=["-e", "<complete script>"] without an extra shell or surrounding quotes. Legacy Windows PowerShell can strip quotes when forwarding native arguments.'
     };
   }
   return {
@@ -4862,7 +4931,7 @@ function createShellTool(workspace, options = {}) {
   }
   return {
     name: "Shell",
-    description: "Run a bounded command reliably inside the workspace. Pass a bare executable in command and one unquoted logical value per args entry; shell syntax is supported only when command contains pipes, redirects, or operators. stdout/stderr are returned verbatim and failures include a structured diagnostic. background=true returns a managed job id.",
+    description: 'Run a bounded command reliably inside the workspace. Pass a bare executable in command and one logical value per args entry, without adding surrounding shell quotes. For Node scripts use command="node", args=["-e", "<complete JavaScript>"]; do not wrap native commands in cmd /c or PowerShell -Command unless shell syntax is needed, since legacy PowerShell can strip embedded quotes. Use Grep for text searches and Read/Edit for file changes. stdout/stderr are returned verbatim and failures include a structured diagnostic. background=true returns a managed job id.',
     inputSchema: ShellInput,
     paths: (input) => [workingDirectory(root, input.cwd ?? void 0)],
     summarize: (input) => [input.command, ...input.args].join(" "),
@@ -4962,7 +5031,7 @@ async function executeShell(root, input, cancellation, maxBytes, environment = p
       return;
     }
     const invocation = shellInvocation(input, cwd, environment);
-    const child = spawn2(invocation.command, invocation.args, {
+    const child = spawn3(invocation.command, invocation.args, {
       cwd,
       shell: false,
       windowsHide: true,
@@ -4989,7 +5058,7 @@ async function executeShell(root, input, cancellation, maxBytes, environment = p
         void finishResolve(observedExitCode ?? child.exitCode, observedSignal ?? child.signalCode);
         return;
       }
-      termination = terminateTree(child.pid);
+      termination = terminateProcessTree(child.pid);
       terminalTimer = setTimeout(() => finishReject(new Error(`Process did not close after ${reason} termination`)), TERMINATION_FAILURE_MS);
       terminalTimer.unref();
     };
@@ -5149,52 +5218,6 @@ function workingDirectory(root, cwd = ".") {
   if (delta === ".." || delta.startsWith(`..${sep5}`) || isAbsolute5(delta)) throw new Error("Working directory is outside the workspace");
   return candidate;
 }
-async function terminateTree(pid) {
-  if (pid === void 0) return;
-  if (process.platform === "win32") {
-    await waitForProcess(spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], { shell: false, windowsHide: true }));
-    try {
-      process.kill(pid);
-    } catch {
-    }
-  } else {
-    try {
-      process.kill(-pid, "SIGTERM");
-    } catch {
-      try {
-        process.kill(pid, "SIGTERM");
-      } catch {
-      }
-    }
-    await delay(TERMINATION_GRACE_MS);
-    try {
-      process.kill(-pid, "SIGKILL");
-    } catch {
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {
-      }
-    }
-  }
-}
-function waitForProcess(child) {
-  return new Promise((resolvePromise) => {
-    let settled = false;
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolvePromise();
-    };
-    const timer = setTimeout(finish, TERMINATION_FAILURE_MS);
-    timer.unref();
-    child.once("error", finish);
-    child.once("close", finish);
-  });
-}
-function delay(milliseconds) {
-  return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
-}
 function decodeOutput(buffer) {
   const encoding = outputEncoding(buffer);
   return new TextDecoder(encoding).decode(buffer);
@@ -5478,7 +5501,7 @@ function errorMessage(error) {
 }
 
 // src/utils/crash-guard.ts
-import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { mkdirSync, writeFileSync } from "fs";
 import { join as join7 } from "path";
 var installed = false;
 var crashing = false;
@@ -5518,7 +5541,7 @@ function installCrashGuard(options = {}) {
   const writeCrashLog = (kind, detail) => {
     try {
       const dir = crashLogDir();
-      mkdirSync2(dir, { recursive: true });
+      mkdirSync(dir, { recursive: true });
       const path = join7(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
       writeFileSync(path, [
         `kind: ${kind}`,
@@ -5573,7 +5596,7 @@ ${reason.stack ?? ""}`;
 }
 
 // src/execution/docker.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { relative as relative7, resolve as resolve8, sep as sep7, win32 } from "path";
 function buildDockerInvocation(options) {
   const workspace = options.workspace;
@@ -5632,7 +5655,7 @@ function runDockerInvocation(invocation, signal, timeoutMs, maxOutputBytes = DEF
       resolvePromise({ exitCode: null, signal: null, stdout: "", stderr: "", terminationReason: "cancelled" });
       return;
     }
-    const child = spawn3(invocation.command, invocation.args, { windowsHide: true, shell: false });
+    const child = spawn4(invocation.command, invocation.args, { windowsHide: true, shell: false });
     const stdout = new BoundedUtf8Output(maxOutputBytes);
     const stderr = new BoundedUtf8Output(maxOutputBytes);
     let reason = null;
@@ -5741,13 +5764,13 @@ import { createHash as createHash3 } from "crypto";
 import { Socket as Socket2 } from "net";
 import { tmpdir } from "os";
 import { join as join9 } from "path";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 
 // src/pals/broker.ts
 import { createHash as createHash2, randomUUID as randomUUID5, timingSafeEqual } from "crypto";
 import { chmod as chmod2, lstat as lstat4, mkdir as mkdir6, unlink as unlink3 } from "fs/promises";
 import { createServer, Socket } from "net";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname6 } from "path";
 
 // src/pals/auth.ts
 import { randomBytes, randomUUID as randomUUID3 } from "crypto";
@@ -5798,7 +5821,7 @@ function validatePalAuthToken(token) {
 // src/pals/lifecycle.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { mkdir as mkdir5, open as open4, readFile as readFile6, rename as rename3, stat as stat3, unlink as unlink2 } from "fs/promises";
-import { dirname as dirname7 } from "path";
+import { dirname as dirname5 } from "path";
 function defaultProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return true;
   try {
@@ -5819,7 +5842,7 @@ function parseMetadata(value) {
 }
 async function acquirePalFileLock(options) {
   if (await options.endpointLive()) return void 0;
-  await mkdir5(dirname7(options.path), { recursive: true, mode: 448 });
+  await mkdir5(dirname5(options.path), { recursive: true, mode: 448 });
   const pid = options.pid ?? process.pid;
   const now = options.now ?? Date.now;
   const nonce = randomUUID4();
@@ -5883,12 +5906,12 @@ var BrokerStateError = class extends Error {
 };
 var WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\";
 function canConnect(address) {
-  return new Promise((resolve31) => {
+  return new Promise((resolve32) => {
     const socket = new Socket();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve31(connected);
+      resolve32(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -5937,7 +5960,7 @@ var PalBrokerServer = class {
     this.authToken ??= await loadOrCreatePalAuthToken(this.authHome === void 0 ? {} : { home: this.authHome });
     try {
       await this.prepareAddress();
-      await new Promise((resolve31, reject) => {
+      await new Promise((resolve32, reject) => {
         const onError = (error) => {
           this.server.off("listening", onListening);
           reject(error);
@@ -5946,7 +5969,7 @@ var PalBrokerServer = class {
           this.server.off("error", onError);
           this.started = true;
           this.ownsAddress = true;
-          resolve31();
+          resolve32();
         };
         this.server.once("error", onError);
         this.server.once("listening", onListening);
@@ -5974,7 +5997,7 @@ var PalBrokerServer = class {
     const ownsAddress = this.ownsAddress;
     for (const connection of this.connections) connection.socket.destroy();
     if (this.started) {
-      await new Promise((resolve31) => this.server.close(() => resolve31()));
+      await new Promise((resolve32) => this.server.close(() => resolve32()));
       this.started = false;
     }
     this.ownsAddress = false;
@@ -5983,7 +6006,7 @@ var PalBrokerServer = class {
   }
   async prepareAddress() {
     if (isWindowsPipeAddress(this.address, this.platform)) return;
-    const parent = dirname8(this.address);
+    const parent = dirname6(this.address);
     await mkdir6(parent, { recursive: true, mode: 448 });
     await chmod2(parent, 448);
     this.endpointLock = await acquirePalFileLock({
@@ -5993,8 +6016,8 @@ var PalBrokerServer = class {
     });
     if (this.endpointLock === void 0) throw new Error(`Pals endpoint '${this.address}' is active or owned`);
     try {
-      const stat11 = await lstat4(this.address);
-      if (!stat11.isSocket()) throw new Error(`Refusing to unlink '${this.address}' because it is not a socket`);
+      const stat12 = await lstat4(this.address);
+      if (!stat12.isSocket()) throw new Error(`Refusing to unlink '${this.address}' because it is not a socket`);
       await unlink3(this.address);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -6007,8 +6030,8 @@ var PalBrokerServer = class {
   }
   async unlinkKnownSocket() {
     try {
-      const stat11 = await lstat4(this.address);
-      if (stat11.isSocket()) await unlink3(this.address);
+      const stat12 = await lstat4(this.address);
+      if (stat12.isSocket()) await unlink3(this.address);
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
@@ -6642,16 +6665,16 @@ var PalBrokerState = class {
 
 // src/pals/broker-cli.ts
 var startupAttempts = /* @__PURE__ */ new Map();
-function delay2(milliseconds) {
-  return new Promise((resolve31) => setTimeout(resolve31, milliseconds));
+function delay(milliseconds) {
+  return new Promise((resolve32) => setTimeout(resolve32, milliseconds));
 }
 function canConnect2(address) {
-  return new Promise((resolve31) => {
+  return new Promise((resolve32) => {
     const socket = new Socket2();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve31(connected);
+      resolve32(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -6674,7 +6697,7 @@ async function spawnPalBrokerProcess(options) {
   const lock = await acquirePalFileLock({ path: lockPath, endpointLive: () => canConnect2(address) });
   if (lock === void 0) return;
   try {
-    const child = spawn4(options.executable, [...options.args], {
+    const child = spawn5(options.executable, [...options.args], {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -6682,7 +6705,7 @@ async function spawnPalBrokerProcess(options) {
     });
     child.unref();
     const deadline = Date.now() + 5e3;
-    while (Date.now() < deadline && !await canConnect2(address)) await delay2(25);
+    while (Date.now() < deadline && !await canConnect2(address)) await delay(25);
     if (!await canConnect2(address)) throw new Error(`Pals broker process did not become ready at '${address}'`);
   } finally {
     await lock.release();
@@ -6694,8 +6717,8 @@ async function runPalBroker(options) {
   const sweepIntervalMs = options.sweepIntervalMs ?? 5e3;
   const idleShutdownMs = options.idleShutdownMs ?? 3e4;
   let resolveClosed;
-  const closed = new Promise((resolve31) => {
-    resolveClosed = resolve31;
+  const closed = new Promise((resolve32) => {
+    resolveClosed = resolve32;
   });
   let closing;
   const timer = setInterval(() => {
@@ -6729,17 +6752,17 @@ async function ensureOnce(options) {
   const deadline = Date.now() + timeoutMs;
   do {
     if (await canConnect2(options.address)) return;
-    await delay2(retryDelayMs);
+    await delay(retryDelayMs);
   } while (Date.now() < deadline);
   throw new Error(`Timed out waiting for pals broker at '${options.address}'`);
 }
 
 // src/production.ts
-import { readFile as readFile23 } from "fs/promises";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { readFile as readFile24 } from "fs/promises";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "fs";
 import { createHash as createHash18, randomUUID as randomUUID20 } from "crypto";
 import { homedir as homedir3, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
-import { basename as basename7, dirname as dirname19, join as join29, relative as relative21, resolve as resolve30, sep as sep21 } from "path";
+import { basename as basename7, dirname as dirname17, join as join30, relative as relative22, resolve as resolve31, sep as sep22 } from "path";
 
 // src/agent/subagents.ts
 import { z as z9 } from "zod";
@@ -7159,7 +7182,7 @@ var TaskPlanSchema = z10.object({
       }
       dependencies.add(dependency);
     }
-    if (task.status === "completed") {
+    if (task.status === "completed" || task.status === "in_progress") {
       const incomplete = task.dependencies.find((dependency) => plan.tasks.find((candidate) => candidate.id === dependency)?.status !== "completed");
       if (incomplete !== void 0) {
         context.addIssue({
@@ -7188,7 +7211,7 @@ function updatePlanTask(plan, input) {
   if (!isValidTransition(previousStatus, update.status)) {
     throw new Error(`Invalid task transition for ${update.taskId}: ${previousStatus} -> ${update.status}`);
   }
-  if (update.status === "completed") {
+  if (update.status === "completed" || update.status === "in_progress") {
     const incomplete = current.tasks[index].dependencies.find((dependency) => current.tasks.find((task) => task.id === dependency)?.status !== "completed");
     if (incomplete !== void 0) throw new Error(`Task ${update.taskId} has an incomplete dependency: ${incomplete}`);
   }
@@ -7213,6 +7236,7 @@ function isValidTransition(from, to) {
   if (from === "in_progress") {
     return to === "completed" || to === "failed" || to === "blocked" || to === "cancelled";
   }
+  if (from === "blocked" || from === "failed") return to === "pending" || to === "in_progress" || to === "cancelled";
   return false;
 }
 function normalizeAbandonedPlan(plan) {
@@ -7696,6 +7720,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, record) => sum + record.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;
@@ -8085,7 +8121,7 @@ function providerValidMessages(input) {
 // src/context/workspace-instructions.ts
 import { createHash as createHash5 } from "crypto";
 import { lstat as lstat5, readFile as readFile7, realpath as realpath2 } from "fs/promises";
-import { dirname as dirname9, isAbsolute as isAbsolute7, relative as relative8, resolve as resolve9, sep as sep8 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute7, relative as relative8, resolve as resolve9, sep as sep8 } from "path";
 var NAMES = ["AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
 var ROOT_NAMES = ["AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
 var WorkspaceInstructions = class {
@@ -8113,7 +8149,7 @@ var WorkspaceInstructions = class {
         const depth = depthOf(this.#root, current);
         directories.set(current, depth);
         if (current === this.#root) break;
-        current = dirname9(current);
+        current = dirname7(current);
       }
     }
     const ordered = [...directories].map(([path, depth]) => ({ path, depth })).sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path));
@@ -8187,9 +8223,9 @@ ${document.content}
 };
 async function directoryForPath(path) {
   try {
-    return (await lstat5(path)).isDirectory() ? path : dirname9(path);
+    return (await lstat5(path)).isDirectory() ? path : dirname7(path);
   } catch {
-    return dirname9(path);
+    return dirname7(path);
   }
 }
 function depthOf(root, path) {
@@ -8264,8 +8300,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 z11 } from "zod";
@@ -8288,8 +8391,8 @@ function withStructuredOutput(options) {
   if (retry.backoffMs.length < retry.maxRetries) {
     throw new Error("Structured output backoffMs must provide one delay per retry");
   }
-  for (const delay3 of retry.backoffMs.slice(0, retry.maxRetries)) {
-    if (!Number.isSafeInteger(delay3) || delay3 < 0) {
+  for (const delay2 of retry.backoffMs.slice(0, retry.maxRetries)) {
+    if (!Number.isSafeInteger(delay2) || delay2 < 0) {
       throw new Error("Structured output retry delays must be non-negative integers");
     }
   }
@@ -8650,10 +8753,10 @@ function sanitize(message2, secrets) {
 }
 function waitForRetry(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve31();
+      resolve32();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -8684,7 +8787,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);
@@ -8694,7 +8796,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;
@@ -8724,6 +8831,15 @@ var AgentLoop = class {
   get iterationLimitMode() {
     return this.#iterationLimitMode;
   }
+  get maxIterations() {
+    return this.#options.maxIterations;
+  }
+  get softLimitFactor() {
+    return this.#options.softLimitFactor;
+  }
+  get extendIterations() {
+    return this.#options.extendIterations;
+  }
   setModel(modelId) {
     this.#options.registry.get(modelId);
     this.#options.modelId = modelId;
@@ -9291,10 +9407,10 @@ function serializeToolInput(input) {
 }
 function waitForRetry2(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve31();
+      resolve32();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -9504,8 +9620,9 @@ var ToolRuntime = class {
     }
   }
   async execute(call, context) {
+    if (this.#disposed) return { ok: false, error: { code: "runtime_disposed", message: "ToolRuntime is disposed" } };
     const definition = this.#tools.get(call.name);
-    const journalId = definition === void 0 || this.#journal === void 0 ? void 0 : this.#journal.start(call.name, call.input, definition.retrySafe === true || definition.readOnly === true);
+    const journalId = definition === void 0 || this.#journal === void 0 ? void 0 : this.#journal.start(call.name, call.input, definition.retrySafe === true || definition.readOnly === true || getToolCategory(call.name) === "read");
     try {
       const result = await this.#execute(call, context);
       if (journalId !== void 0) this.#journal?.complete(journalId, result);
@@ -9532,6 +9649,10 @@ var ToolRuntime = class {
     if (tool === void 0) return { ok: false, error: { code: "unknown_tool", message: `Unknown tool: ${call.name}` } };
     const signal = context.signal ?? new AbortController().signal;
     const toolCallId = call.id ?? randomUUID7();
+    if (tool.agents !== void 0 && !tool.agents.includes(context.agent)) {
+      return this.#fail(toolCallId, tool.name, call.input, context.agent, "permission_denied", `Tool ${tool.name} is not available to ${context.agent} agents`);
+    }
+    if (signal.aborted) return this.#fail(toolCallId, tool.name, call.input, context.agent, "cancelled", message(signal.reason));
     const validation = this.normalize(call);
     if (!validation.ok) {
       return this.#fail(toolCallId, call.name, call.input, context.agent, validation.error.code, validation.error.message);
@@ -9639,17 +9760,37 @@ var ToolRuntime = class {
       } catch (error) {
         return this.#fail(toolCallId, tool.name, input, context.agent, "invalid_output", message(error));
       }
-      const declaredPresentation = tool.presentResult?.(rawOutput, input);
-      const presentation = declaredPresentation ?? getToolPresentation(rawOutput);
-      const rendered = tool.renderForModel?.(rawOutput, input);
+      const warnings = [];
+      let presentation = getToolPresentation(rawOutput);
+      try {
+        presentation = tool.presentResult?.(rawOutput, input) ?? presentation;
+      } catch (error) {
+        warnings.push(`Tool succeeded; result presentation failed: ${message(error)}`);
+      }
+      let rendered;
+      try {
+        rendered = tool.renderForModel?.(rawOutput, input);
+      } catch (error) {
+        warnings.push(`Tool succeeded; result rendering failed: ${message(error)}`);
+      }
       const output = rendered === void 0 ? await this.#limitOutput(tool.name, rawOutput) : rawOutput;
       const content = rendered === void 0 ? void 0 : await this.#limitText(tool.name, rendered);
-      const additionalContext = await this.#afterSuccess?.(tool.name, tool.paths(input), input, rawOutput, context);
-      await this.#hooks.emit({
-        version: 1,
-        type: "PostToolUse",
-        payload: { toolCallId, tool: tool.name, input, agent: context.agent, output }
-      });
+      let additionalContext = [];
+      try {
+        additionalContext = await this.#afterSuccess?.(tool.name, tool.paths(input), input, rawOutput, context) ?? [];
+      } catch (error) {
+        warnings.push(`Tool succeeded; context update failed: ${message(error)}`);
+      }
+      try {
+        await this.#hooks.emit({
+          version: 1,
+          type: "PostToolUse",
+          payload: { toolCallId, tool: tool.name, input, agent: context.agent, output }
+        });
+      } catch (error) {
+        warnings.push(`Tool succeeded; PostToolUse hook failed: ${message(error)}`);
+      }
+      additionalContext = [...additionalContext, ...warnings];
       return {
         ok: true,
         output,
@@ -9680,17 +9821,23 @@ var ToolRuntime = class {
     const preview = headTailPreview(serialized, previewChars);
     this.#turnOutputChars += preview.length;
     const directory = join10(this.#workspace, ".flavor", "tool-results");
-    await mkdir7(directory, { recursive: true });
     const filename2 = `${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID7()}-${safeFilename(tool)}.txt`;
     const savedTo = join10(directory, filename2);
-    await writeFile4(savedTo, serialized, "utf8");
+    let storage;
+    try {
+      await mkdir7(directory, { recursive: true });
+      await writeFile4(savedTo, serialized, "utf8");
+      storage = { savedTo };
+    } catch (error) {
+      storage = { storageError: `Tool succeeded, but the full output could not be saved: ${message(error)}` };
+    }
     return {
       truncated: true,
       reason,
       preview,
       originalChars: serialized.length,
       previewChars: preview.length,
-      savedTo
+      ...storage
     };
   }
   callPresentation(call) {
@@ -9891,6 +10038,8 @@ var LocalHarness = class {
         agent,
         ownerId,
         ...maxIterations === void 0 ? {} : { maxIterations },
+        ...this.#options.softLimitFactor === void 0 ? {} : { softLimitFactor: this.#options.softLimitFactor },
+        ...this.#options.extendIterations === void 0 ? {} : { extendIterations: this.#options.extendIterations },
         ...isMain && this.#options.hasActiveProgress !== void 0 ? { hasActiveProgress: this.#options.hasActiveProgress } : {},
         ...isMain && this.#options.hallucinationGuard !== void 0 ? { hallucinationGuard: this.#options.hallucinationGuard } : {},
         ...this.#options.modelJournal === void 0 ? {} : { modelJournal: this.#options.modelJournal }
@@ -9920,7 +10069,7 @@ function toModelTool(tool) {
 
 // src/harness/journal.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
-import { closeSync, constants as constants3, existsSync as existsSync4, fsyncSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync, statSync as statSync2, truncateSync, unlinkSync, writeSync } from "fs";
+import { closeSync, constants as constants3, existsSync as existsSync4, fsyncSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync, statSync as statSync2, truncateSync, unlinkSync, writeSync } from "fs";
 import { join as join11, relative as relative9, resolve as resolve11, sep as sep9 } from "path";
 import { z as z14 } from "zod";
 
@@ -10013,7 +10162,7 @@ var HarnessJournal = class {
     const workspace = resolve11(options.workspace);
     const directory = join11(workspace, ".flavor", "sessions");
     assertSessionId(options.sessionId);
-    mkdirSync3(directory, { recursive: true, mode: 448 });
+    mkdirSync2(directory, { recursive: true, mode: 448 });
     assertWithin(workspace, directory);
     const canonicalWorkspace = realpathSync2.native(workspace);
     const canonicalDirectory = realpathSync2.native(directory);
@@ -10030,6 +10179,10 @@ var HarnessJournal = class {
   get records() {
     return this.#records.map((record) => structuredClone(record));
   }
+  /** Retained record count for the rotation census. */
+  get recordCount() {
+    return this.#records.length;
+  }
   admitQueue(kind, payload) {
     QueueKindSchema.parse(kind);
     const id = randomUUID8();
@@ -10306,19 +10459,38 @@ function jsonSafeRecord(value) {
   return JSON.parse(json);
 }
 function hashJson(value) {
-  return createHash6("sha256").update(stableJson(value)).digest("hex");
-}
-function recordHash(record) {
-  const { hash: _hash, ...unsigned } = record;
-  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(record) {
+  const { hash: _hash, ...unsigned } = record;
+  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");
@@ -10332,7 +10504,7 @@ function isWithin2(root, target) {
 }
 
 // src/hooks/bus.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { randomUUID as randomUUID9 } from "crypto";
 var DEFAULT_TIMEOUT_MS2 = 1e4;
 var DEFAULT_MAX_OUTPUT_BYTES2 = 1048576;
@@ -10439,10 +10611,10 @@ function decoratePayload(payload, envelope) {
   return envelope === void 0 ? payload : { ...payload, ...envelope };
 }
 function runShellHandler(descriptor, event, signal) {
-  return new Promise((resolve31, reject) => {
+  return new Promise((resolve32, reject) => {
     const env = { ...process.env, ...descriptor.env };
     const invocation = prepareSpawnInvocation(descriptor.command, descriptor.args ?? [], { env });
-    const child = spawn5(invocation.command, invocation.args, {
+    const child = spawn6(invocation.command, invocation.args, {
       env,
       shell: false,
       detached: process.platform !== "win32",
@@ -10459,7 +10631,7 @@ function runShellHandler(descriptor, event, signal) {
       if (settled) return;
       settled = true;
       signal.removeEventListener("abort", onAbort);
-      terminateProcessTree(child);
+      terminateProcessTree2(child);
       reject(error);
     };
     const append = (stream, chunk) => {
@@ -10485,7 +10657,7 @@ function runShellHandler(descriptor, event, signal) {
         return;
       }
       try {
-        resolve31(HookDecisionSchema.parse(JSON.parse(stdout)));
+        resolve32(HookDecisionSchema.parse(JSON.parse(stdout)));
       } catch (error) {
         reject(error);
       }
@@ -10493,10 +10665,10 @@ function runShellHandler(descriptor, event, signal) {
     child.stdin.end(JSON.stringify(event));
   });
 }
-function terminateProcessTree(child) {
+function terminateProcessTree2(child) {
   if (child.pid === void 0) return;
   if (process.platform === "win32") {
-    const killer = spawn5("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+    const killer = spawn6("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
       stdio: "ignore",
       windowsHide: true
     });
@@ -10682,14 +10854,14 @@ async function createIslandControlServer(options) {
       void dispatch(line, socket, options, token);
     });
   });
-  await new Promise((resolve31, reject) => {
+  await new Promise((resolve32, reject) => {
     const onError = (error) => {
       server.removeListener("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve31();
+      resolve32();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -10760,17 +10932,17 @@ function write(socket, payload) {
   }
 }
 function closeServer(server) {
-  return new Promise((resolve31) => {
+  return new Promise((resolve32) => {
     try {
-      server.close(() => resolve31());
+      server.close(() => resolve32());
     } catch {
-      resolve31();
+      resolve32();
     }
   });
 }
 
 // src/evolve/service.ts
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 import { writeFile as writeFile8 } from "fs/promises";
 import { join as join15 } from "path";
 import { z as z16 } from "zod";
@@ -10790,7 +10962,7 @@ import { z as z15 } from "zod";
 
 // src/plugins/worker-host.ts
 import { realpath as realpath3 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { dirname as dirname8 } from "path";
 import { Worker } from "worker_threads";
 var DEFAULT_ACTIVATION_TIMEOUT_MS = 1e4;
 var DEFAULT_INVOCATION_TIMEOUT_MS = 3e4;
@@ -10798,7 +10970,7 @@ var DEFAULT_MAX_OLD_SPACE_MB = 128;
 var DEFAULT_SHUTDOWN_TIMEOUT_MS = 5e3;
 async function startPluginSandbox(options) {
   const entryPath = await realpath3(options.entryPath);
-  const pluginRoot = await realpath3(options.pluginRoot ?? dirname10(entryPath));
+  const pluginRoot = await realpath3(options.pluginRoot ?? dirname8(entryPath));
   const activationTimeoutMs = options.activationTimeoutMs ?? DEFAULT_ACTIVATION_TIMEOUT_MS;
   const invocationTimeoutMs = options.invocationTimeoutMs ?? DEFAULT_INVOCATION_TIMEOUT_MS;
   let configJson;
@@ -11618,7 +11790,7 @@ async function revertFixPlugin(workspace, name) {
 // src/evolve/store.ts
 import { createHash as createHash9 } from "crypto";
 import { appendFile, mkdir as mkdir9, readFile as readFile9, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname11, join as join14 } from "path";
+import { dirname as dirname9, join as join14 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
@@ -11647,7 +11819,7 @@ async function readJsonLines(file) {
   }
 }
 async function writeJsonLines(file, records) {
-  await mkdir9(dirname11(file), { recursive: true, mode: 448 });
+  await mkdir9(dirname9(file), { recursive: true, mode: 448 });
   const body = records.map((record) => JSON.stringify(record)).join("\n");
   await writeFile7(file, body.length > 0 ? `${body}
 ` : "", { encoding: "utf8", mode: 384 });
@@ -11675,7 +11847,7 @@ async function readRules(file) {
   }
 }
 async function writeRules(file, rules) {
-  await mkdir9(dirname11(file), { recursive: true, mode: 448 });
+  await mkdir9(dirname9(file), { recursive: true, mode: 448 });
   await writeFile7(file, JSON.stringify(rules, null, 2), { encoding: "utf8", mode: 384 });
 }
 var EvolveStore = class {
@@ -11915,9 +12087,9 @@ var USAGE = [
   "  clear     reset signals, done markers, and verified markers"
 ].join("\n");
 function runCommand(command, cwd, timeoutMs) {
-  return new Promise((resolve31) => {
+  return new Promise((resolve32) => {
     const isWindows = process.platform === "win32";
-    const child = spawn6(isWindows ? "cmd.exe" : "/bin/sh", isWindows ? ["/d", "/s", "/c", command] : ["-c", command], {
+    const child = spawn7(isWindows ? "cmd.exe" : "/bin/sh", isWindows ? ["/d", "/s", "/c", command] : ["-c", command], {
       cwd,
       windowsHide: true
     });
@@ -11925,7 +12097,7 @@ function runCommand(command, cwd, timeoutMs) {
     let stderr = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve31({ ok: false, stdout, stderr: `${stderr}
+      resolve32({ ok: false, stdout, stderr: `${stderr}
 [killed: exceeded ${timeoutMs}ms]`, code: "timeout" });
     }, timeoutMs);
     child.stdout.on("data", (chunk) => {
@@ -11936,12 +12108,12 @@ function runCommand(command, cwd, timeoutMs) {
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve31({ ok: false, stdout, stderr: `${stderr}
+      resolve32({ ok: false, stdout, stderr: `${stderr}
 ${error.message}`, code: "spawn" });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve31({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
+      resolve32({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
     });
   });
 }
@@ -12312,10 +12484,12 @@ ${result.stderr.slice(-4e3)}` : ""}`;
         name: "evolve_improve",
         description: "Implement a fix for one repeated tool failure. Default kind=plugin scaffolds the fix-<tool>/ plugin dir and writes PLAN.md with instructions for implementing, verifying, reloading, and testing it. kind=prompt_rule instead stores a concise guardrail rule (from `implementation`) that is injected into future system prompts and closes the suggestion. Use when the model proposes a concrete fix for a suggestion in the system prompt.",
         inputSchema,
-        paths: () => [],
-        execute: async (input) => {
+        paths: (input) => [join15(workspace, ".flavor", "evolve"), ...input.kind === "prompt_rule" ? [] : [join15(workspace, ".flavor", "plugins")]],
+        execute: async (input, signal) => {
+          signal.throwIfAborted();
           const { suggestionId, implementation, kind } = input;
           const suggestions = await openWithTrends(100);
+          signal.throwIfAborted();
           const suggestion = suggestions.find((item) => item.id === suggestionId);
           if (suggestion === void 0) throw new Error(`No open suggestion with id "${suggestionId}".`);
           if (kind === "prompt_rule") {
@@ -12432,6 +12606,14 @@ var LoopStateSchema = z17.object({
     approvals: z17.array(LoopApprovalSchema)
   }).strict(),
   cycles: z17.array(LoopCycleEvidenceSchema),
+  /** Completed worker awaiting host verification; avoids replaying tool work after rotation. */
+  pendingCycle: z17.object({
+    cycle: z17.number().int().positive(),
+    startedAt: z17.string().datetime({ offset: true }),
+    inputTokens: z17.number().int().nonnegative(),
+    outputTokens: z17.number().int().nonnegative(),
+    workerText: z17.string().max(16e3)
+  }).strict().nullable().optional(),
   terminalReason: z17.string().optional()
 }).strict();
 var LoopEventSchema = z17.object({
@@ -12520,15 +12702,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());
@@ -12546,67 +12758,87 @@ 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;
+          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.message;
+              if (event.error.code === "memory_pressure") workerMemoryPressure = 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) {
+            state = LoopStateSchema.parse({
+              ...state,
+              budget: {
+                ...state.budget,
+                cyclesUsed: cycle,
+                inputTokens: state.budget.inputTokens + cycleInputTokens,
+                outputTokens: state.budget.outputTokens + cycleOutputTokens
+              }
+            });
+            state = await this.#terminal(state, "failed", workerError, now());
+            yield { type: "loop-terminal", loopId, status: "failed", reason: workerError };
+            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) {
@@ -12626,8 +12858,28 @@ 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;
+            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 completedAt = now();
         state = LoopStateSchema.parse({
           ...state,
@@ -12646,7 +12898,8 @@ var LoopOrchestrator = class {
             outputTokens: cycleOutputTokens,
             workspaceFingerprint: fingerprint2,
             verification: evidence
-          }]
+          }],
+          pendingCycle: null
         });
         await this.#options.persistence.save(state);
         await this.#options.persistence.append({
@@ -12664,20 +12917,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 };
@@ -12703,7 +12942,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());
@@ -12730,8 +12969,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 };
     }
@@ -12749,6 +12989,16 @@ ${evidence.summary}`;
     return state;
   }
 };
+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";
@@ -12816,6 +13066,11 @@ var GoalStateSchema = z18.object({
   planPath: z18.string().nullable(),
   verifyRounds: z18.number().int().min(0),
   workerRounds: z18.number().int().min(0),
+  /** Worker output checkpoint used to resume verification without rerunning tools. */
+  pendingVerification: z18.object({
+    round: z18.number().int().positive(),
+    finalResponse: z18.string().max(16e3)
+  }).strict().nullable().optional(),
   lastGaps: z18.array(GapSchema),
   gapFingerprint: z18.string(),
   stallStreak: z18.number().int().min(0),
@@ -12861,6 +13116,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 }];
@@ -12872,6 +13128,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") {
@@ -12978,7 +13235,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 = [];
@@ -12995,7 +13252,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 = "";
@@ -13005,6 +13263,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;
@@ -13159,7 +13418,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",
@@ -13168,6 +13427,7 @@ var GoalOrchestrator = class {
       planPath: null,
       verifyRounds: 0,
       workerRounds: 0,
+      pendingVerification: null,
       lastGaps: [],
       gapFingerprint: "",
       stallStreak: 0,
@@ -13176,87 +13436,147 @@ 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 planPath;
-    try {
-      request.signal.throwIfAborted();
-      plan = await runPlanner({
-        registry: this.#options.registry,
-        modelId: this.#options.plannerModelId,
-        objective: request.goal,
-        signal: request.signal
-      });
-      planPath = await writePlanFile(workspace, plan);
-      await persistState({ plan, planPath, contractHash: contractHash(request.goal, plan) });
-      yield { type: "goal-plan-created", plan, planPath };
-    } 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;
+    if (state.plan === null) {
       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;
-          }
-        }
+        signal.throwIfAborted();
+        await memoryCheckpoint();
+        plan = await runPlanner({
+          registry: this.#options.registry,
+          modelId: this.#options.plannerModelId,
+          objective: state.objective,
+          signal,
+          onProgress: memoryCheckpoint
+        });
+        planPath = await writePlanFile(workspace, plan);
+        await persistState({ phase: "executing", plan, planPath, contractHash: contractHash(state.objective, plan) });
+        yield { type: "goal-plan-created", plan, planPath };
       } catch (error) {
-        workerError = message(error);
-      }
-      if (workerError !== void 0) {
-        const reason = `Worker error in round ${round}: ${workerError}`;
+        if (memoryRotationActive()) return;
+        const reason = `Goal planning failed: ${message(error)}`;
         await persistState({ phase: "complete", status: "failed" });
+        yield { type: "goal-plan-failed", reason };
         yield { type: "goal-failed", reason };
         return;
       }
-      await persistState({ phase: "verifying", status: "active", verifyRounds: round });
+    } else {
+      plan = state.plan;
+      planPath = state.planPath ?? await writePlanFile(workspace, plan);
+      await persistState({ phase: "executing", status: "active", ...state.planPath === null ? { planPath } : {} });
+    }
+    let priorGaps = state.lastGaps;
+    let priorFingerprint = state.gapFingerprint;
+    let stallStreak = state.stallStreak;
+    const startRound = resumeStartRound(state);
+    for (let round = startRound; 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;
+        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.message;
+              if (event.error.code === "memory_pressure") workerMemoryPressure = true;
+              break;
+            }
+          }
+        } catch (error) {
+          if (memoryRotationActive()) return;
+          workerError = message(error);
+        }
+        if (workerMemoryPressure) return;
+        if (workerError !== void 0) {
+          const reason = `Worker error in round ${round}: ${workerError}`;
+          await persistState({ phase: "complete", status: "failed" });
+          yield { type: "goal-failed", reason };
+          return;
+        }
+        await persistState({
+          phase: "verifying",
+          status: "active",
+          pendingVerification: { round, finalResponse }
+        });
+      }
       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 }
@@ -13280,14 +13600,17 @@ var GoalOrchestrator = class {
           modelId: this.#options.classifierModelId,
           skepticCount: this.#options.skepticCount,
           workspace,
-          signal: request.signal
+          signal,
+          onProgress: memoryCheckpoint
         });
       } catch (error) {
+        if (memoryRotationActive()) return;
         outcome = {
           type: "blocked",
           reason: `Classifier infrastructure error: ${message(error)}`
         };
       }
+      await persistState({ verifyRounds: round, pendingVerification: null });
       yield {
         type: "goal-verdict",
         round,
@@ -13347,6 +13670,12 @@ 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);
+}
 async function writePlanFile(workspace, plan) {
   const dir = join17(workspace, ".flavor");
   const planPath = join17(dir, "goal-plan.md");
@@ -13426,8 +13755,8 @@ function formatPriorGaps(gaps) {
 // src/goal/store.ts
 import { constants as constants4 } from "fs";
 import { randomUUID as randomUUID11 } from "crypto";
-import { lstat as lstat7, mkdir as mkdir11, open as open6, rename as rename4, rm as rm4 } from "fs/promises";
-import { dirname as dirname12, join as join18, relative as relative11, resolve as resolve14, sep as sep11 } from "path";
+import { lstat as lstat7, mkdir as mkdir11, open as open6, readFile as readFile11, rename as rename4, rm as rm4, stat as stat6 } from "fs/promises";
+import { dirname as dirname10, join as join18, relative as relative11, resolve as resolve14, sep as sep11 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -13440,7 +13769,7 @@ var GoalStore = class {
   }
   async save(input) {
     const state = GoalStateSchema.parse(input);
-    await assertNoSymlink(this.#workspace, dirname12(this.#root));
+    await assertNoSymlink(this.#workspace, dirname10(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
     const target = join18(this.#root, `${state.id}.json`);
@@ -13463,6 +13792,28 @@ var GoalStore = class {
       await rm4(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, dirname10(this.#root));
+    await assertNoSymlink(this.#workspace, this.#root);
+    const target = join18(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 (isCode3(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 = resolve14(target);
@@ -13474,7 +13825,7 @@ async function assertNoSymlink(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname12(cursor);
+    cursor = dirname10(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -13489,7 +13840,7 @@ function isCode3(error, code) {
 }
 
 // src/loop/isolation.ts
-import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile11 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile12 } from "fs/promises";
 import { join as join19, resolve as resolve15 } 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;
@@ -13549,7 +13900,7 @@ async function ensureWorktreeDirectoryIgnored(root) {
   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;
   }
@@ -13560,8 +13911,8 @@ async function ensureWorktreeDirectoryIgnored(root) {
 
 // src/loop/store.ts
 import { constants as constants5 } from "fs";
-import { lstat as lstat8, mkdir as mkdir13, open as open7, readFile as readFile12, realpath as realpath5, rename as rename5, rm as rm5, stat as stat6 } from "fs/promises";
-import { dirname as dirname13, join as join20, relative as relative12, resolve as resolve16, sep as sep12 } from "path";
+import { lstat as lstat8, mkdir as mkdir13, open as open7, readFile as readFile13, realpath as realpath5, rename as rename5, rm as rm5, stat as stat7 } from "fs/promises";
+import { dirname as dirname11, join as join20, relative as relative12, resolve as resolve16, sep as sep12 } 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;
@@ -13611,9 +13962,9 @@ var LoopStore = class {
     const directory = await this.#safeExisting(loopId);
     const target = join20(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;
@@ -13643,7 +13994,7 @@ var LoopStore = class {
   }
   async #prepare(loopId) {
     validateId(loopId);
-    await assertNoSymlink2(this.#workspace, dirname13(this.#root));
+    await assertNoSymlink2(this.#workspace, dirname11(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
     const directory = join20(this.#root, loopId);
@@ -13676,7 +14027,7 @@ async function assertNoSymlink2(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname13(cursor);
+    cursor = dirname11(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -13702,7 +14053,7 @@ function isCode4(error, code) {
 }
 
 // src/loop/verifier.ts
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 import { join as join21 } from "path";
 var SCRIPT_PRIORITY = ["test", "typecheck", "lint", "build", "smoke:install"];
 async function inferVerificationPlan(workspace) {
@@ -13781,7 +14132,7 @@ function isUnconditionalPassThrough(script) {
 }
 async function optionalText(path) {
   try {
-    return await readFile13(path, "utf8");
+    return await readFile14(path, "utf8");
   } catch (error) {
     if (isCode5(error, "ENOENT")) return void 0;
     throw error;
@@ -13802,7 +14153,7 @@ function isCode5(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) {
@@ -14039,7 +14390,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) {
@@ -14259,7 +14610,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");
@@ -14271,7 +14622,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 [
@@ -14908,8 +15259,8 @@ var OAuthCallbackAuthProvider = class {
   async #startCallbackServer(expectedState, signal) {
     let serverResolve;
     let serverReject;
-    const codePromise = new Promise((resolve31, reject) => {
-      serverResolve = resolve31;
+    const codePromise = new Promise((resolve32, reject) => {
+      serverResolve = resolve32;
       serverReject = reject;
     });
     const server = createServer3((req, res) => {
@@ -14943,7 +15294,7 @@ var OAuthCallbackAuthProvider = class {
       );
       serverResolve(code);
     });
-    return new Promise((resolve31, reject) => {
+    return new Promise((resolve32, reject) => {
       server.once("error", (error) => {
         reject(new Error(`OAuth callback server failed: ${error.message}`));
       });
@@ -14960,7 +15311,7 @@ var OAuthCallbackAuthProvider = class {
         signal.addEventListener("abort", () => {
           serverReject(new Error("OAuth flow aborted"));
         }, { once: true });
-        resolve31({ redirectUri, promise: codePromise });
+        resolve32({ redirectUri, promise: codePromise });
       });
     });
   }
@@ -15042,7 +15393,7 @@ function escapeHtml(text) {
 }
 
 // src/auth/store.ts
-import { dirname as dirname14 } from "path";
+import { dirname as dirname12 } from "path";
 async function retainOnlyCredentials(store, keepCredentialId) {
   const tokens = await store.load();
   const retained = Object.fromEntries(Object.entries(tokens).filter(([id]) => id === keepCredentialId));
@@ -15053,7 +15404,7 @@ function createFileTokenStore(filePath) {
   const store = {
     tokens: {},
     async load() {
-      const key = await loadOrCreateConfigKey(dirname14(filePath));
+      const key = await loadOrCreateConfigKey(dirname12(filePath));
       const result = await readRecoverableFile(filePath, (raw) => parseTokens(decryptDocument(raw, key)));
       const tokens = result?.value ?? {};
       baseline = { ...tokens };
@@ -15061,7 +15412,7 @@ function createFileTokenStore(filePath) {
       return tokens;
     },
     async save(tokens) {
-      const key = await loadOrCreateConfigKey(dirname14(filePath));
+      const key = await loadOrCreateConfigKey(dirname12(filePath));
       const removals = Object.keys(baseline).filter((providerId) => !(providerId in tokens));
       const upserts = Object.fromEntries(Object.entries(tokens).filter(
         ([providerId, token]) => !sameToken(baseline[providerId], token)
@@ -15102,7 +15453,7 @@ function isStoredToken(value) {
 }
 
 // src/permissions/policy.ts
-import { readFile as readFile16 } from "fs/promises";
+import { readFile as readFile17 } from "fs/promises";
 import { join as join22, resolve as resolve18 } from "path";
 import { z as z20 } from "zod";
 var DecisionSchema2 = z20.enum(["allow", "ask", "deny"]);
@@ -15148,7 +15499,7 @@ async function loadPermissionPolicy(options) {
   for (const source of sources) {
     let raw;
     try {
-      raw = await readFile16(source.path, "utf8");
+      raw = await readFile17(source.path, "utf8");
     } catch (error) {
       if (isCode6(error, "ENOENT")) continue;
       throw error;
@@ -15890,10 +16241,14 @@ function createSkillResourceTool(registry) {
     name: "SkillResource",
     description: "Read a bounded resource explicitly referenced by a discovered skill; scripts are returned as data and never executed",
     inputSchema: SkillResourceInput,
+    readOnly: true,
     paths: () => [],
     execute: async (input, signal) => {
       signal.throwIfAborted();
-      const skill = (await registry.discover()).find((candidate) => candidate.name === input.skill);
+      const requested = input.skill.trim();
+      const alias = requested.includes(":") ? requested.slice(requested.lastIndexOf(":") + 1) : requested;
+      const discovered = await registry.discover();
+      const skill = discovered.find((candidate) => candidate.name === requested) ?? discovered.find((candidate) => candidate.name === alias);
       if (skill === void 0) throw new Error(`Unknown skill: ${input.skill}`);
       const capability = await registry.resolveResource(skill, input.reference);
       const content = await registry.readResource(capability);
@@ -15910,8 +16265,8 @@ function createSkillResourceTool(registry) {
 
 // src/session/store.ts
 import { constants as constants7 } from "fs";
-import { lstat as lstat10, mkdir as mkdir14, open as open8, readFile as readFile17, readdir as readdir7, realpath as realpath7, rename as rename6, rm as rm6, stat as stat7 } from "fs/promises";
-import { basename as basename4, dirname as dirname15, join as join23, relative as relative14, resolve as resolve20, sep as sep14 } from "path";
+import { lstat as lstat10, mkdir as mkdir14, open as open8, readFile as readFile18, readdir as readdir7, realpath as realpath7, rename as rename6, rm as rm6, stat as stat8 } from "fs/promises";
+import { basename as basename4, dirname as dirname13, join as join23, relative as relative14, resolve as resolve20, sep as sep14 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 import { z as z22 } from "zod";
 var SESSION_VERSION = 4;
@@ -16108,7 +16463,7 @@ var SessionStore = class {
           release: async () => {
             if (released) return;
             try {
-              if (await readFile17(path, "utf8") === token) await rm6(path, { force: true });
+              if (await readFile18(path, "utf8") === token) await rm6(path, { force: true });
             } catch (error) {
               if (!isCode7(error, "ENOENT")) throw error;
             }
@@ -16265,7 +16620,7 @@ var SessionStore = class {
     }
   }
   async #prepareDirectory() {
-    await assertNoSymlink3(this.#workspace, dirname15(this.#sessions));
+    await assertNoSymlink3(this.#workspace, dirname13(this.#sessions));
     await mkdir14(this.#sessions, { recursive: true, mode: 448 });
     await this.#assertSafeExistingDirectory();
   }
@@ -16302,14 +16657,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 && isProcessAlive(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);
@@ -16342,10 +16697,10 @@ function isProcessAlive(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");
 }
@@ -16493,7 +16848,7 @@ async function assertNoSymlink3(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname15(cursor);
+    cursor = dirname13(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -16535,11 +16890,70 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
   return output;
 }
 
+// src/utils/rotation-census.ts
+import { mkdirSync as mkdirSync3, readdirSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join24 } 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 writeRotationCensus(workspace, census) {
+  try {
+    const directory = join24(workspace, ".flavor", "tmp");
+    mkdirSync3(directory, { recursive: true });
+    const path = join24(directory, `${CENSUS_PREFIX}${Date.now()}.json`);
+    writeFileSync2(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 writeRotationHeapSnapshot(workspace) {
+  try {
+    const directory = join24(workspace, ".flavor", "tmp");
+    mkdirSync3(directory, { recursive: true });
+    const path = join24(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(join24(directory, name));
+    } catch {
+    }
+  }
+}
+
 // src/sleep/organizer.ts
 import { constants as constants8 } from "fs";
 import { randomUUID as randomUUID14 } from "crypto";
 import { lstat as lstat11, mkdir as mkdir15, open as open9, readdir as readdir8, realpath as realpath8, rename as rename7, rm as rm7 } from "fs/promises";
-import { isAbsolute as isAbsolute10, join as join24, relative as relative15, resolve as resolve21, sep as sep15 } from "path";
+import { isAbsolute as isAbsolute10, join as join25, relative as relative15, resolve as resolve21, sep as sep15 } from "path";
 import { z as z23 } from "zod";
 var DateKeySchema = z23.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = z23.object({
@@ -16594,7 +17008,7 @@ var ProjectSleepOrganizer = class {
   #generate;
   constructor(options) {
     this.#workspace = resolve21(options.workspace);
-    this.#sleepDirectory = join24(this.#workspace, ".flavor", "sleep");
+    this.#sleepDirectory = join25(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -16603,7 +17017,7 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join24(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join25(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
       lock = await open9(lockPath, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
@@ -16638,7 +17052,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 = join24(this.#sleepDirectory, filename2);
+      const path = join25(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path, markdown);
       return { status: "written", date, path, sessionCount: documents.length };
@@ -16680,7 +17094,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join24(this.#workspace, ".flavor");
+    const flavorDirectory = join25(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir15(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -16694,7 +17108,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 = join24(this.#sleepDirectory, `.${randomUUID14()}.tmp`);
+    const temporary = join25(this.#sleepDirectory, `.${randomUUID14()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
@@ -16767,14 +17181,14 @@ var ProjectSleepScheduler = class {
     const next = new Date(now);
     next.setDate(next.getDate() + 1);
     next.setHours(0, 0, 0, 0);
-    const delay3 = Math.max(1, next.getTime() - now.getTime());
+    const delay2 = Math.max(1, next.getTime() - now.getTime());
     const targetDate = localDateKey(now);
     this.#dailyTimer = setTimeout(() => {
       this.#dailyTimer = void 0;
       if (this.#disposed) return;
       this.#enqueue(targetDate);
       this.#scheduleNextMidnight();
-    }, delay3);
+    }, delay2);
     this.#dailyTimer.unref?.();
   }
   #enqueue(date) {
@@ -17068,8 +17482,8 @@ function computeSessionStats(documents) {
 
 // src/tools/files.ts
 import { constants as constants9 } from "fs";
-import { mkdir as mkdir16, open as open10, readFile as readFile18, realpath as realpath9, rename as rename8, rm as rm8, stat as stat8 } from "fs/promises";
-import { dirname as dirname16, isAbsolute as isAbsolute11, relative as relative16, resolve as resolve22, sep as sep16 } from "path";
+import { mkdir as mkdir16, open as open10, readFile as readFile19, realpath as realpath9, rename as rename8, rm as rm8, stat as stat9 } from "fs/promises";
+import { dirname as dirname14, isAbsolute as isAbsolute11, relative as relative16, resolve as resolve22, sep as sep16 } from "path";
 import { randomUUID as randomUUID15 } from "crypto";
 import { z as z24 } from "zod";
 
@@ -17187,8 +17601,12 @@ var ReadInput2 = z24.object({
   force: z24.union([z24.boolean(), z24.string().refine((value) => value === "true" || value === "false")]).nullable().optional()
 });
 var WriteInput = z24.object({ path: z24.string().min(1), content: z24.string() });
-var EditInput = z24.object({ path: z24.string().min(1), oldText: z24.string().min(1), newText: z24.string() });
-var ApplyPatchInput = z24.object({ patch: z24.string().min(1) });
+var EditInput = z24.object({
+  path: z24.string().min(1),
+  oldText: z24.string().min(1).describe("Copy exact current file text from Read, without displayed line numbers or diff prefixes. Include enough context for one unique match."),
+  newText: z24.string()
+});
+var ApplyPatchInput = z24.object({ patch: z24.string().min(1).describe("One-file unified diff with --- a/path, +++ b/path and @@ hunk headers. Use /dev/null as the old path to create a file.") });
 var FileObservationStore = class {
   #versions = /* @__PURE__ */ new Map();
   get(path) {
@@ -17217,7 +17635,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}`);
@@ -17231,9 +17649,9 @@ function createReadTool(workspace, options = {}) {
       const windowBytes = rangeRequested ? Math.max(maxBytes, Math.min(info.size, MAX_READ_BYTES)) : maxBytes;
       const contents = await readBounded2(path, windowBytes, signal, openFile2);
       if (isBinary(contents)) throw new Error("Cannot read binary file as text");
-      const textEnd = utf8SafeEnd(contents, windowBytes);
+      const textEnd = contents.length > windowBytes ? utf8SafeEnd(contents, windowBytes) : contents.length;
       const truncated = contents.length > windowBytes;
-      const text = contents.subarray(0, textEnd).toString("utf8").replaceAll("\r\n", "\n");
+      const text = decodeFileText(contents.subarray(0, textEnd)).replaceAll("\r\n", "\n");
       options.observations?.set(path, versionOfStat(info));
       const lines = text.split("\n");
       if (lines.at(-1) === "") lines.pop();
@@ -17309,7 +17727,7 @@ function createEditTool(workspace, options = {}) {
   const guard = createPathGuard(workspace);
   return {
     name: "Edit",
-    description: "Replace one unique exact text match",
+    description: "Replace one unique exact text match, accepting LF or CRLF input. Read the file before editing; after a mismatch, re-read with force=true and copy the current text instead of retrying the same oldText.",
     inputSchema: EditInput,
     paths: (input) => [guard.lexical(input.path)],
     execute: async (input, signal) => {
@@ -17319,14 +17737,14 @@ function createEditTool(workspace, options = {}) {
       const expected = await expectedMutationVersion(path, options.observations);
       const contents = await readText(path);
       const hasCRLF = contents.includes("\r\n");
-      const norm = (s) => hasCRLF ? s.replace(/\r\n/g, "\n") : s;
+      const norm = (s) => s.replace(/\r\n/g, "\n");
       const contentsLF = norm(contents);
       const oldTextLF = norm(input.oldText);
       const newTextLF = norm(input.newText);
       const first = contentsLF.indexOf(oldTextLF);
-      const second = first < 0 ? -1 : contentsLF.indexOf(oldTextLF, first + oldTextLF.length);
+      const second = first < 0 ? -1 : contentsLF.indexOf(oldTextLF, first + 1);
       if (first < 0 || second >= 0) {
-        const diagnosis = buildEditDiagnosis(contentsLF, oldTextLF, first, second);
+        const diagnosis = buildEditDiagnosis(contentsLF, oldTextLF, second);
         throw new Error(diagnosis);
       }
       const updatedLF = contentsLF.slice(0, first) + newTextLF + contentsLF.slice(first + oldTextLF.length);
@@ -17346,7 +17764,7 @@ function createApplyPatchTool(workspace, options = {}) {
   const guard = createPathGuard(workspace);
   return {
     name: "ApplyPatch",
-    description: "Apply a workspace-limited unified diff, relocating hunks only by unique exact context",
+    description: "Apply a single-file workspace-limited unified diff, relocating hunks only by unique exact context. Submit separate calls for multiple files.",
     inputSchema: ApplyPatchInput,
     paths: (input) => parsePatch(input.patch).map((file) => guard.lexical(file.path)),
     execute: async (input, signal) => {
@@ -17411,7 +17829,7 @@ function createPathGuard(workspace) {
           break;
         } catch (error) {
           if (!isMissing3(error)) throw error;
-          const parent = dirname16(ancestor);
+          const parent = dirname14(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
         }
@@ -17422,12 +17840,19 @@ function createPathGuard(workspace) {
 }
 async function atomicWrite(path, content, signal, expectedVersion) {
   abortIfNeeded(signal);
-  await mkdir16(dirname16(path), { recursive: true });
+  await mkdir16(dirname14(path), { recursive: true });
   const temporary = `${path}.${randomUUID15()}.tmp`;
+  let mode;
+  try {
+    mode = (await stat9(path)).mode & 511;
+  } catch (error) {
+    if (!isMissing3(error)) throw error;
+  }
   try {
     const handle = await open10(temporary, constants9.O_CREAT | constants9.O_EXCL | constants9.O_WRONLY, 384);
     try {
       await handle.writeFile(content, "utf8");
+      if (mode !== void 0) await handle.chmod(mode);
       await handle.sync();
     } finally {
       await handle.close();
@@ -17442,9 +17867,16 @@ async function atomicWrite(path, content, signal, expectedVersion) {
   }
 }
 async function readText(path) {
-  const contents = await readFile18(path);
+  const contents = await readFile19(path);
   if (isBinary(contents)) throw new Error("Cannot edit binary file as text");
-  return contents.toString("utf8");
+  return decodeFileText(contents);
+}
+function decodeFileText(contents) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(contents);
+  } catch {
+    throw new Error("File is not valid UTF-8 text. Convert its encoding before using Read/Edit/ApplyPatch to avoid corrupting its contents.");
+  }
 }
 var ABSENT_VERSION = "absent";
 async function expectedMutationVersion(path, observations) {
@@ -17461,7 +17893,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 (isMissing3(error)) return ABSENT_VERSION;
     throw error;
@@ -17472,7 +17904,7 @@ function versionOfStat(info) {
 }
 async function readOptionalPresentationText(path) {
   try {
-    const contents = await readFile18(path);
+    const contents = await readFile19(path);
     return isBinary(contents) ? { exists: true } : { exists: true, text: contents.toString("utf8") };
   } catch (error) {
     return isMissing3(error) ? { exists: false } : { exists: true };
@@ -17654,11 +18086,12 @@ function patchPath(header) {
   const raw = header.split("	", 1)[0].trim();
   return raw.startsWith("a/") || raw.startsWith("b/") ? raw.slice(2) : raw;
 }
-function buildEditDiagnosis(contentsLF, oldTextLF, first, second) {
+function buildEditDiagnosis(contentsLF, oldTextLF, second) {
   let diagnosis = "oldText must match exactly once";
   if (second >= 0) {
-    const count = contentsLF.split(oldTextLF).length - 1;
-    diagnosis += ` \u2014 matched ${count} times in the file`;
+    let count = 0;
+    for (let index = contentsLF.indexOf(oldTextLF); index >= 0; index = contentsLF.indexOf(oldTextLF, index + 1)) count += 1;
+    diagnosis += ` \u2014 matched ${count} times in the file. No changes made. Include more surrounding text to select one occurrence.`;
     return diagnosis;
   }
   const oldLines = oldTextLF.split("\n");
@@ -17694,7 +18127,8 @@ ${snippet}
 First lines of file:
 ${fileSnippet}`;
   }
-  return diagnosis;
+  return `${diagnosis}
+No changes made. Use Read with force=true to retrieve current text, or Grep with fixedStrings=true to locate it. Copy oldText exactly without line-number prefixes; do not repeat the same failed edit.`;
 }
 function applyHunks(original, hunks) {
   const hasCRLF = original.includes("\r\n");
@@ -17785,6 +18219,19 @@ import { isIP } from "net";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { z as z25 } from "zod";
+
+// src/utils/abort.ts
+function waitWithSignal(operation, signal) {
+  if (signal === void 0) return operation;
+  return new Promise((resolve32, reject) => {
+    const abort2 = () => reject(signal.reason);
+    if (signal.aborted) abort2();
+    else signal.addEventListener("abort", abort2, { once: true });
+    operation.then(resolve32, reject).finally(() => signal.removeEventListener("abort", abort2));
+  });
+}
+
+// src/tools/web.ts
 var WebFetchInput = z25.object({
   url: z25.string().url().max(8192),
   timeoutMs: z25.coerce.number().int().positive().max(12e4).optional(),
@@ -17830,7 +18277,12 @@ function createWebSearchTool(provider = createDefaultWebSearchProvider()) {
     summarize: (input) => input.query,
     presentCall: (input) => ({ kind: "web", title: `Searching: ${input.query}` }),
     permissions: () => ({ paths: [] }),
-    execute: async (input, signal) => ({ query: input.query, results: [...await provider.search(input.query, input.maxResults ?? 8, signal)] }),
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
+      const maxResults = input.maxResults ?? 8;
+      const results = await waitWithSignal(provider.search(input.query, maxResults, signal), signal);
+      return { query: input.query, results: [...results].slice(0, maxResults) };
+    },
     renderForModel: (output) => output.results.length === 0 ? `No web results found for: ${output.query}` : output.results.map((item, index) => `${index + 1}. ${item.title}
 ${item.url}
 ${item.snippet}`).join("\n\n"),
@@ -17875,10 +18327,14 @@ var MultiSourceWebSearchProvider = class {
   }
 };
 async function fetchPublic(initialUrl, options) {
+  options.signal.throwIfAborted();
+  const deadline = AbortSignal.timeout(options.timeoutMs);
+  options = { ...options, signal: AbortSignal.any([options.signal, deadline]) };
   let current = new URL(initialUrl);
   for (let redirects = 0; redirects <= 5; redirects += 1) {
+    options.signal.throwIfAborted();
     validateUrl(current);
-    const addresses = await lookup(normalizedHostname(current.hostname), { all: true, verbatim: true });
+    const addresses = await waitWithSignal(lookup(normalizedHostname(current.hostname), { all: true, verbatim: true }), options.signal);
     if (addresses.length === 0) throw new Error("Host did not resolve");
     if (addresses.some((entry2) => isBlockedResolvedAddress(entry2.address, current.hostname))) {
       throw new Error("Blocked private or special network destination");
@@ -17890,7 +18346,13 @@ async function fetchPublic(initialUrl, options) {
       continue;
     }
     const contentType = response.contentType;
-    const decoded = new TextDecoder(charset(contentType), { fatal: false }).decode(response.body);
+    let decoder;
+    try {
+      decoder = new TextDecoder(charset(contentType), { fatal: false });
+    } catch {
+      decoder = new TextDecoder("utf-8");
+    }
+    const decoded = decoder.decode(response.body);
     const content = !options.rawHtml && /text\/html|application\/xhtml\+xml/i.test(contentType) ? htmlToText(decoded) : decoded;
     return { url: current.href, status: response.status, contentType, content, truncated: response.truncated };
   }
@@ -17925,8 +18387,8 @@ async function requestAddress(url, address, options) {
       const status = response.statusCode ?? 0;
       const location = response.headers.location;
       if (location !== void 0 && [301, 302, 303, 307, 308].includes(status)) {
-        response.resume();
         finish({ status, contentType: "", body: new Uint8Array(), truncated: false, redirect: location });
+        response.destroy();
         return;
       }
       const chunks = [];
@@ -17942,7 +18404,11 @@ async function requestAddress(url, address, options) {
         const accepted = chunk.subarray(0, options.maxBytes - bytes);
         chunks.push(accepted);
         bytes += accepted.length;
-        if (accepted.length < chunk.length) truncated = true;
+        if (accepted.length < chunk.length) {
+          truncated = true;
+          finish({ status, contentType: String(response.headers["content-type"] ?? "application/octet-stream"), body: Buffer.concat(chunks), truncated });
+          response.destroy();
+        }
       });
       response.once("end", () => finish({
         status,
@@ -18088,11 +18554,11 @@ function charset(contentType) {
 }
 
 // src/tools/lsp.ts
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { access as access2, constants as constants10, readFile as readFile19 } from "fs/promises";
-import { basename as basename5, dirname as dirname17, extname as extname2, isAbsolute as isAbsolute12, relative as relative17, resolve as resolve23, sep as sep17 } from "path";
-import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
+import { access as access2, constants as constants10, readFile as readFile20 } from "fs/promises";
+import { basename as basename5, dirname as dirname15, extname as extname2, isAbsolute as isAbsolute12, relative as relative17, resolve as resolve23, sep as sep17 } from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "url";
 import { z as z26 } from "zod";
 var LSP_REQUEST_TIMEOUT_MS = 15e3;
 var LspConnection = class {
@@ -18104,12 +18570,14 @@ var LspConnection = class {
   #nextId = 1;
   #disposed = false;
   #initError;
+  #shutdownPromise;
   constructor(command, args, cwd) {
     const invocation = prepareSpawnInvocation(command, args, { cwd });
-    this.#process = spawn7(invocation.command, invocation.args, {
+    this.#process = spawn8(invocation.command, invocation.args, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
+      detached: process.platform !== "win32",
       ...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments }
     });
     this.#process.on("error", (err) => {
@@ -18118,9 +18586,15 @@ var LspConnection = class {
     });
     this.#process.once("exit", (code, signal) => {
       const reason = signal !== null ? `LSP server "${command}" exited with signal ${signal}` : `LSP server "${command}" exited with code ${code}`;
-      this.#rejectAll(new Error(reason));
+      this.#initError = new Error(reason);
+      this.#rejectAll(this.#initError);
     });
     this.#process.stdout.on("data", (chunk) => this.#buffer.feed(chunk, this.#onMessage));
+    this.#process.stderr.resume();
+    this.#process.stdin.on("error", (error) => {
+      this.#initError = error;
+      this.#rejectAll(error);
+    });
   }
   async initialize(rootUri) {
     if (this.#initError !== void 0) throw this.#initError;
@@ -18142,67 +18616,84 @@ var LspConnection = class {
     if (initResult === void 0) throw new Error("LSP initialize returned no capabilities");
     this.#notify("initialized", {});
   }
-  async findReferences(uri, line, character) {
+  async findReferences(uri, line, character, signal) {
+    signal?.throwIfAborted();
     await this.#syncDocument(uri);
     const result = await this.#request("textDocument/references", {
       textDocument: { uri },
       position: { line, character },
       context: { includeDeclaration: false }
-    });
+    }, signal);
     if (result === null || result === void 0) return [];
     if (!Array.isArray(result)) return [];
     return result.filter(isLocation);
   }
-  async hover(uri, line, character) {
+  async hover(uri, line, character, signal) {
+    signal?.throwIfAborted();
     await this.#syncDocument(uri);
     const result = await this.#request("textDocument/hover", {
       textDocument: { uri },
       position: { line, character }
-    });
+    }, signal);
     if (result === null || result === void 0) return null;
     if (typeof result === "object" && "contents" in result) {
       return result;
     }
     return null;
   }
-  async diagnostics(uri) {
+  async diagnostics(uri, signal) {
+    signal?.throwIfAborted();
     await this.#syncDocument(uri);
     const result = await this.#request("textDocument/diagnostic", {
       textDocument: { uri }
-    });
+    }, signal);
     if (result === null || result === void 0) return [];
     const items = result?.items ?? result;
     if (!Array.isArray(items)) return [];
     return items.filter(isDiagnostic);
   }
-  async shutdown() {
-    if (this.#disposed) return;
+  shutdown() {
+    if (this.#shutdownPromise !== void 0) return this.#shutdownPromise;
     this.#disposed = true;
-    try {
-      await this.#request("shutdown", null);
-    } catch {
-    }
-    this.#notify("exit", null);
-    this.#process.kill();
     this.#rejectAll(new Error("LSP connection disposed"));
+    this.#shutdownPromise = (async () => {
+      await terminateProcessTree(this.#process.pid);
+      this.#process.stdin.destroy();
+      this.#process.stdout.destroy();
+      this.#process.stderr.destroy();
+    })();
+    return this.#shutdownPromise;
   }
   // -- JSON-RPC core -------------------------------------------------------
-  async #request(method, params) {
+  async #request(method, params, signal) {
     if (this.#disposed) throw new Error("LSP connection disposed");
+    if (this.#initError !== void 0) throw this.#initError;
+    signal?.throwIfAborted();
     const id = this.#nextId++;
     const request = { jsonrpc: "2.0", id, method, params };
-    const timeout = AbortSignal.timeout(LSP_REQUEST_TIMEOUT_MS);
-    const promise = new Promise((resolve31, reject) => {
-      this.#pending.set(id, { resolve: resolve31, reject });
-      timeout.addEventListener("abort", () => {
-        if (this.#pending.has(id)) {
-          this.#pending.delete(id);
-          reject(new Error(`LSP request "${method}" timed out after ${LSP_REQUEST_TIMEOUT_MS}ms`));
+    let timer;
+    let onAbort;
+    const promise = new Promise((resolve32, reject) => {
+      this.#pending.set(id, { resolve: resolve32, reject });
+      timer = setTimeout(() => reject(new Error(`LSP request "${method}" timed out after ${LSP_REQUEST_TIMEOUT_MS}ms`)), LSP_REQUEST_TIMEOUT_MS);
+      timer.unref();
+      onAbort = () => {
+        try {
+          this.#notify("$/cancelRequest", { id });
+        } catch {
         }
-      }, { once: true });
+        reject(signal?.reason);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
     });
-    this.#send(request);
-    return promise;
+    try {
+      this.#send(request);
+      return await promise;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+      if (onAbort !== void 0) signal?.removeEventListener("abort", onAbort);
+      this.#pending.delete(id);
+    }
   }
   #notify(method, params) {
     const notification = { jsonrpc: "2.0", method, params };
@@ -18222,6 +18713,7 @@ var LspConnection = class {
     } catch {
       return;
     }
+    if (typeof parsed !== "object" || parsed === null) return;
     if ("method" in parsed) {
       if ("id" in parsed) this.#handleServerRequest(parsed);
       return;
@@ -18257,8 +18749,8 @@ var LspConnection = class {
   async #syncDocumentNow(uri) {
     const url = new URL(uri);
     if (url.protocol !== "file:") return;
-    const filePath = fileURLToPath3(url);
-    const text = await readFile19(filePath, "utf8");
+    const filePath = fileURLToPath2(url);
+    const text = await readFile20(filePath, "utf8");
     const current = this.#documents.get(uri);
     if (current === void 0) {
       this.#documents.set(uri, { text, version: 1 });
@@ -18310,7 +18802,7 @@ var LspBuffer = class {
   }
 };
 var TYPESCRIPT_CLI = resolve23(
-  dirname17(fileURLToPath3(import.meta.resolve("typescript/package.json"))),
+  dirname15(fileURLToPath2(import.meta.resolve("typescript/package.json"))),
   "lib",
   "tsc.js"
 );
@@ -18345,6 +18837,8 @@ var KNOWN_SERVERS = [
   }
 ];
 var RealLspManager = class {
+  #disposed = false;
+  #disposal;
   #workspace;
   #connections = /* @__PURE__ */ new Map();
   #pendingStarts = /* @__PURE__ */ new Map();
@@ -18356,27 +18850,32 @@ var RealLspManager = class {
     this.#onStatus = options.onStatus;
   }
   dispose() {
-    for (const [, connection] of this.#connections) {
-      connection.shutdown().catch(() => {
-      });
-    }
+    if (this.#disposal !== void 0) return this.#disposal;
+    this.#disposed = true;
+    const shutdowns = [...this.#connections.values()].map((connection) => connection.shutdown());
+    shutdowns.push(...[...this.#pendingStarts.values()].map(async (start) => {
+      const connection = await start;
+      await connection.shutdown();
+    }));
     this.#connections.clear();
     this.#pendingStarts.clear();
+    this.#disposal = Promise.allSettled(shutdowns).then(() => void 0);
+    return this.#disposal;
   }
-  async findReferences(uri, line, character) {
-    const connection = await this.#getConnection(uri);
-    if (connection === void 0) return [];
-    return connection.findReferences(uri, line, character);
+  async findReferences(uri, line, character, signal) {
+    signal?.throwIfAborted();
+    const connection = await waitWithSignal(this.#getConnection(uri), signal);
+    return connection.findReferences(uri, line, character, signal);
   }
-  async hover(uri, line, character) {
-    const connection = await this.#getConnection(uri);
-    if (connection === void 0) return null;
-    return connection.hover(uri, line, character);
+  async hover(uri, line, character, signal) {
+    signal?.throwIfAborted();
+    const connection = await waitWithSignal(this.#getConnection(uri), signal);
+    return connection.hover(uri, line, character, signal);
   }
-  async diagnostics(uri) {
-    const connection = await this.#getConnection(uri);
-    if (connection === void 0) return [];
-    return connection.diagnostics(uri);
+  async diagnostics(uri, signal) {
+    signal?.throwIfAborted();
+    const connection = await waitWithSignal(this.#getConnection(uri), signal);
+    return connection.diagnostics(uri, signal);
   }
   #languageForUri(uri) {
     try {
@@ -18392,20 +18891,25 @@ var RealLspManager = class {
     return void 0;
   }
   async #getConnection(uri) {
+    if (this.#disposed) throw new Error("LSP manager is disposed");
     const language = this.#languageForUri(uri);
-    if (language === void 0) return void 0;
+    if (language === void 0) throw new Error(`No language server configured for ${uri}; use Read/Grep or the project compiler`);
     const existing = this.#connections.get(language);
     if (existing !== void 0) return existing;
     const pending = this.#pendingStarts.get(language);
     if (pending !== void 0) return pending;
     const config = this.#serverConfigs.find((c) => c.language === language);
-    if (config === void 0) return void 0;
+    if (config === void 0) throw new Error(`No language server configured for ${language}`);
     const hasRoot = config.rootFiles.some((file) => existsSync5(resolve23(this.#workspace, file)));
-    if (!hasRoot) return void 0;
+    if (!hasRoot) throw new Error(`Cannot start ${language} language server: workspace needs ${config.rootFiles.join(" or ")}`);
     const startPromise = this.#startServer(config);
     this.#pendingStarts.set(language, startPromise);
     try {
       const connection = await startPromise;
+      if (this.#disposed) {
+        await connection.shutdown();
+        throw new Error("LSP manager is disposed");
+      }
       this.#connections.set(language, connection);
       return connection;
     } finally {
@@ -18423,6 +18927,7 @@ var RealLspManager = class {
       await connection.initialize(rootUri);
       this.#onStatus?.(`${config.language} Language Server ready (${config.command})`);
     } catch (error) {
+      await connection.shutdown();
       this.#onStatus?.(`${config.language} Language Server failed: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
@@ -18431,13 +18936,13 @@ var RealLspManager = class {
 };
 var LspFindRefsInput = z26.object({
   file: z26.string().min(1),
-  line: z26.coerce.number().int().nonnegative(),
-  character: z26.coerce.number().int().nonnegative()
+  line: z26.coerce.number().int().nonnegative().describe("Zero-based line number (first line is 0)."),
+  character: z26.coerce.number().int().nonnegative().describe("Zero-based UTF-16 character offset.")
 });
 var LspHoverInput = z26.object({
   file: z26.string().min(1),
-  line: z26.coerce.number().int().nonnegative(),
-  character: z26.coerce.number().int().nonnegative()
+  line: z26.coerce.number().int().nonnegative().describe("Zero-based line number (first line is 0)."),
+  character: z26.coerce.number().int().nonnegative().describe("Zero-based UTF-16 character offset.")
 });
 var LspDiagnosticsInput = z26.object({
   file: z26.string().min(1)
@@ -18463,10 +18968,11 @@ function createLspTools(workspace, options = {}) {
     inputSchema: LspFindRefsInput,
     paths: (input) => [guard(input.file)],
     summarize: (input) => `${basename5(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
-    execute: async (input, _signal) => {
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
       const path = guard(input.file);
       const uri = toUri(path);
-      const refs = await manager.findReferences(uri, input.line, input.character);
+      const refs = await waitWithSignal(manager.findReferences(uri, input.line, input.character, signal), signal);
       if (refs.length === 0) return `No references found at ${input.file}:${input.line}:${input.character}`;
       return refs.map((loc) => {
         const filePath = uriToPath(loc.uri);
@@ -18480,12 +18986,14 @@ function createLspTools(workspace, options = {}) {
     inputSchema: LspHoverInput,
     paths: (input) => [guard(input.file)],
     summarize: (input) => `${basename5(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
-    execute: async (input, _signal) => {
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
       const path = guard(input.file);
       const uri = toUri(path);
-      const info = await manager.hover(uri, input.line, input.character);
+      const info = await waitWithSignal(manager.hover(uri, input.line, input.character, signal), signal);
       if (info === null) return `No hover information at ${input.file}:${input.line}:${input.character}`;
-      const contents = typeof info.contents === "string" ? info.contents : info.contents.value;
+      const parts = Array.isArray(info.contents) ? info.contents : [info.contents];
+      const contents = parts.map((part) => typeof part === "string" ? part : part.value).join("\n\n");
       return contents;
     }
   };
@@ -18495,10 +19003,11 @@ function createLspTools(workspace, options = {}) {
     inputSchema: LspDiagnosticsInput,
     paths: (input) => [guard(input.file)],
     summarize: (input) => `${basename5(input.file)}${langTag(input.file)}`,
-    execute: async (input, _signal) => {
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
       const path = guard(input.file);
       const uri = toUri(path);
-      const diags = await manager.diagnostics(uri);
+      const diags = await waitWithSignal(manager.diagnostics(uri, signal), signal);
       if (diags.length === 0) return `No diagnostics for ${input.file}`;
       return diags.map((d) => {
         const severity = severityLabel(d.severity);
@@ -18517,6 +19026,14 @@ function languageIdForPath(filePath) {
       return "typescript";
     case ".cts":
       return "typescript";
+    case ".py":
+    case ".pyi":
+    case ".pyx":
+      return "python";
+    case ".rs":
+      return "rust";
+    case ".go":
+      return "go";
     default:
       return "typescript";
   }
@@ -18528,7 +19045,7 @@ function isWithin7(root, candidate) {
 function uriToPath(uri) {
   try {
     const url = new URL(uri);
-    if (url.protocol === "file:") return decodeURIComponent(url.pathname);
+    if (url.protocol === "file:") return fileURLToPath2(url);
   } catch {
   }
   return uri;
@@ -18555,12 +19072,14 @@ function severityLabel(severity) {
 }
 
 // src/git/service.ts
-async function git2(workspace, args, timeoutMs = 3e4) {
-  const result = await execFileNoThrow("git", ["-C", workspace, ...args], { timeout: timeoutMs, useCwd: false });
+async function git2(workspace, args, timeoutMs = 3e4, signal) {
+  signal?.throwIfAborted();
+  const result = await execFileNoThrow("git", ["-C", workspace, ...args], { timeout: timeoutMs, useCwd: false, ...signal === void 0 ? {} : { signal } });
+  signal?.throwIfAborted();
   return { ok: result.code === 0, stdout: result.stdout, stderr: result.stderr, code: result.code };
 }
-async function isGitRepository(workspace) {
-  const result = await git2(workspace, ["rev-parse", "--is-inside-work-tree"], 2e3);
+async function isGitRepository(workspace, signal) {
+  const result = await git2(workspace, ["rev-parse", "--is-inside-work-tree"], 2e3, signal);
   return result.ok && result.stdout.trim() === "true";
 }
 function gitFailure(result, action) {
@@ -18597,19 +19116,19 @@ async function changeSummary(workspace) {
   };
 }
 async function stagedDiff(workspace, maxChars = 96e3) {
-  const stat11 = await git2(workspace, ["diff", "--staged", "--stat"]);
+  const stat12 = 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: stat11.stdout.trim(),
+    stat: stat12.stdout.trim(),
     truncated: text.length > maxChars
   };
 }
 async function uncommittedDiff(workspace, maxChars = 96e3) {
-  const stat11 = await git2(workspace, ["diff", "HEAD", "--stat"]);
+  const stat12 = 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);
@@ -18617,7 +19136,7 @@ async function uncommittedDiff(workspace, maxChars = 96e3) {
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat11.stdout.trim(),
+    stat: stat12.stdout.trim(),
     untracked: summary2.untrackedFiles
   };
 }
@@ -18638,16 +19157,21 @@ async function commit(workspace, commitMessage) {
   const head = await git2(workspace, ["log", "-1", "--pretty=%h %s"]);
   return head.stdout.trim() || "committed";
 }
-async function fileHistory(workspace, path, limit) {
+async function fileHistory(workspace, path, limit, signal) {
   const args = [
+    "--literal-pathspecs",
     "log",
     `--max-count=${limit}`,
     "--date=short",
     "--pretty=format:%h%x1f%ad%x1f%an%x1f%s",
     ...path === void 0 ? [] : ["--follow", "--", path]
   ];
-  const result = await git2(workspace, args, 15e3);
-  if (!result.ok) throw gitFailure(result, "log");
+  const result = await git2(workspace, args, 15e3, signal);
+  if (!result.ok) {
+    const head = await git2(workspace, ["rev-parse", "--verify", "HEAD"], 2e3, signal);
+    if (!head.ok && await isGitRepository(workspace, signal)) return [];
+    throw gitFailure(result, "log");
+  }
   return result.stdout.split("\n").filter((line) => line.trim().length > 0).map((line) => {
     const [hash = "", date = "", author = "", ...subject] = line.split("");
     return { hash, date, author, subject: subject.join("") };
@@ -18909,17 +19433,17 @@ ${explanation}` : "";
 }
 
 // src/desktop/astgraph-service.ts
-import { stat as stat9 } from "fs/promises";
+import { stat as stat10 } from "fs/promises";
 import { createRequire as nodeCreateRequire } from "module";
-import { join as join25, resolve as resolve24 } from "path";
+import { join as join26, resolve as resolve24 } 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 = join25(resolve24(workspace), ".flavor", "astgraph", "index.db");
+    this.#path = join26(resolve24(workspace), ".flavor", "astgraph", "index.db");
   }
   async status() {
-    if ((await stat9(this.#path).catch(() => void 0))?.isFile() !== true) {
+    if ((await stat10(this.#path).catch(() => void 0))?.isFile() !== true) {
       return { available: false, path: this.#path, files: 0, nodes: 0, edges: 0 };
     }
     return this.#read((db) => {
@@ -18986,24 +19510,33 @@ function mapNode(value) {
 
 // src/git/tools.ts
 import { z as z28 } from "zod";
+import { isAbsolute as isAbsolute13, relative as relative18, resolve as resolve25, sep as sep18 } from "path";
 var GitHistoryInput = z28.object({
-  path: z28.string().describe("File to inspect; omit for the whole repository history").optional(),
-  limit: z28.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
+  path: z28.string().min(1).describe("Workspace-relative or absolute file path; omit for the whole repository history").optional(),
+  limit: z28.coerce.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
 });
 function createGitHistoryTool(workspace) {
+  const root = resolve25(workspace);
+  const file = (path) => {
+    const absolute = resolve25(root, path);
+    const delta = relative18(root, absolute);
+    if (delta === ".." || delta.startsWith(`..${sep18}`) || isAbsolute13(delta)) throw new Error("GitHistory path is outside the workspace");
+    return absolute;
+  };
   return {
     name: "GitHistory",
     description: "Show git commit history for the repository or for one file (follows renames). Use to understand when and why code changed.",
     inputSchema: GitHistoryInput,
     readOnly: true,
-    paths: (input) => input.path === void 0 ? [] : [input.path],
+    paths: (input) => input.path === void 0 ? [root] : [file(input.path)],
     summarize: (input) => input.path ?? "repository",
     renderForModel: (output) => output,
     async execute(input, signal) {
       signal.throwIfAborted();
-      if (!await isGitRepository(workspace)) throw new Error("Not a git repository");
+      const path = input.path === void 0 ? void 0 : relative18(root, file(input.path));
+      if (!await isGitRepository(root, signal)) throw new Error("Not a git repository");
       const limit = input.limit ?? 20;
-      const entries = await fileHistory(workspace, input.path, limit);
+      const entries = await fileHistory(root, path, limit, signal);
       if (entries.length === 0) {
         return input.path === void 0 ? "No commits found." : `No commits found for ${input.path} (the file may be untracked).`;
       }
@@ -19066,7 +19599,8 @@ var QuestionBridge = class {
   }
   async #askRelayed(questions, signal) {
     try {
-      const answers = await this.#relay(questions, signal);
+      const answers = await waitWithSignal(this.#relay(questions, signal), signal);
+      signal.throwIfAborted();
       if (answers !== void 0) {
         this.#active = false;
         return answers;
@@ -19078,10 +19612,15 @@ var QuestionBridge = class {
     }
   }
   #askLocally(questions, signal) {
-    return new Promise((resolve31, reject) => {
+    if (signal.aborted) {
+      this.#active = false;
+      return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve32, reject) => {
       const onAbort = () => {
         this.#pending = void 0;
         this.#active = false;
+        this.#onChange?.();
         reject(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason)));
       };
       signal.addEventListener("abort", onAbort, { once: true });
@@ -19092,7 +19631,7 @@ var QuestionBridge = class {
           this.#pending = void 0;
           this.#active = false;
           this.#onChange?.();
-          resolve31(answers);
+          resolve32(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
@@ -19184,8 +19723,8 @@ function createTodoWriteTool() {
 
 // src/tools/managed.ts
 import { randomUUID as randomUUID16 } from "crypto";
-import { link as link2, lstat as lstat12, mkdir as mkdir17, readFile as readFile20, readdir as readdir9, unlink as unlink5, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname18, join as join26, resolve as resolve25 } from "path";
+import { link as link2, lstat as lstat12, mkdir as mkdir17, readFile as readFile21, readdir as readdir9, unlink as unlink5, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname16, join as join27, resolve as resolve26 } from "path";
 import { z as z31 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -19227,9 +19766,9 @@ var ManagedToolStore = class {
   #entries = /* @__PURE__ */ new Map();
   #diagnostics = [];
   constructor(options) {
-    this.#workspace = resolve25(options.workspace);
-    this.#projectRoot = join26(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join26(resolve25(options.home), ".flavor-code", "tools");
+    this.#workspace = resolve26(options.workspace);
+    this.#projectRoot = join27(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join27(resolve26(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -19276,7 +19815,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join26(this.directory(input.scope), filename(input.name));
+    const path = join27(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record, void 0, 2)}
 `);
@@ -19301,7 +19840,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 [join26(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join27(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -19314,12 +19853,12 @@ var ManagedToolStore = class {
       return;
     }
     for (const name of names) {
-      const path = join26(root, name);
+      const path = join27(root, name);
       try {
         const info = await lstat12(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 record = ManagedToolRecordSchema.parse(JSON.parse(await readFile20(path, "utf8")));
+        const record = ManagedToolRecordSchema.parse(JSON.parse(await readFile21(path, "utf8")));
         if (record.scope !== scope2) throw new Error(`Managed tool record scope must match its ${scope2} directory`);
         const key = scopedKey(scope2, record.name);
         if (this.#entries.has(key)) throw new Error(`Duplicate managed tool name in ${scope2} scope: ${record.name}`);
@@ -19469,7 +20008,7 @@ ${sourceUrl}`
   }
 }
 async function writeExclusive(path, content) {
-  await mkdir17(dirname18(path), { recursive: true });
+  await mkdir17(dirname16(path), { recursive: true });
   const temporary = `${path}.${randomUUID16()}.tmp`;
   try {
     await writeFile10(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
@@ -20232,8 +20771,8 @@ ${total}`;
 
 // src/memory/store.ts
 import { createHash as createHash16 } from "crypto";
-import { readFile as readFile21, rm as rm9 } from "fs/promises";
-import { resolve as resolve26, join as join27, relative as relative18, sep as sep18 } from "path";
+import { readFile as readFile22, rm as rm9 } from "fs/promises";
+import { resolve as resolve27, join as join28, relative as relative19, sep as sep19 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -20335,10 +20874,10 @@ var MemoryStore = class {
   constructor(options) {
     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 = resolve26(options.workspace);
-    this.#memoryRoot = join27(this.workspace, ".flavor", "memory");
-    this.path = join27(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join27(this.#memoryRoot, "behavior.json");
+    this.workspace = resolve27(options.workspace);
+    this.#memoryRoot = join28(this.workspace, ".flavor", "memory");
+    this.path = join28(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join28(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -20556,14 +21095,14 @@ var MemoryStore = class {
     });
   }
   async #readTaskItem(reference) {
-    const document = decodeTask(await readFile21(this.#resolveContentPath(reference.contentPath), "utf8"));
+    const document = decodeTask(await readFile22(this.#resolveContentPath(reference.contentPath), "utf8"));
     return document.items.find((item) => item.id === reference.id)?.content ?? reference.summary;
   }
   #resolveContentPath(contentPath) {
     if (!/^tasks\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.md$/.test(contentPath)) throw new Error("Invalid memory content path");
-    const path = resolve26(this.#memoryRoot, ...contentPath.split("/"));
-    const rel = relative18(this.#memoryRoot, path);
-    if (rel === ".." || rel.startsWith(`..${sep18}`)) throw new Error("Memory content path escapes the memory directory");
+    const path = resolve27(this.#memoryRoot, ...contentPath.split("/"));
+    const rel = relative19(this.#memoryRoot, path);
+    if (rel === ".." || rel.startsWith(`..${sep19}`)) throw new Error("Memory content path escapes the memory directory");
     return path;
   }
   async #updateIndex(update) {
@@ -21032,8 +21571,8 @@ function createExecutionEnvironment(workspace, config) {
 }
 
 // src/ide/client.ts
-import { readFile as readFile22, readdir as readdir10, stat as stat10 } from "fs/promises";
-import { basename as basename6, join as join28, relative as relative19, resolve as resolve27, sep as sep19 } from "path";
+import { readFile as readFile23, readdir as readdir10, stat as stat11 } from "fs/promises";
+import { basename as basename6, join as join29, relative as relative20, resolve as resolve28, sep as sep20 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -21044,8 +21583,8 @@ var FlavorIdeClient = class {
   #sessionId;
   #eventTail = Promise.resolve();
   constructor(options) {
-    this.#workspace = resolve27(options.workspace);
-    this.#home = resolve27(options.home);
+    this.#workspace = resolve28(options.workspace);
+    this.#home = resolve28(options.home);
     this.#environment = options.environment ?? process.env;
     this.#fetch = options.fetch ?? fetch;
   }
@@ -21129,7 +21668,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join28(this.#home, ".flavor-code", "ide");
+    const directory = join29(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir10(directory)).filter((name) => name.endsWith(".lock"));
@@ -21137,9 +21676,9 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join28(directory, name);
+      const path = join29(directory, name);
       try {
-        const [contents, info] = await Promise.all([readFile22(path, "utf8"), stat10(path)]);
+        const [contents, info] = await Promise.all([readFile23(path, "utf8"), stat11(path)]);
         const lock = parseLockfile(contents);
         return lock === void 0 ? void 0 : { lock, modified: info.mtimeMs };
       } catch {
@@ -21243,21 +21782,22 @@ function parsePort(value) {
   return Number.isInteger(port) && port > 0 && port <= 65535 ? port : void 0;
 }
 function isWithin8(parent, child) {
-  const base = normalize(resolve27(parent));
-  const target = normalize(resolve27(child));
-  return target === base || target.startsWith(`${base}${sep19}`);
+  const base = normalize(resolve28(parent));
+  const target = normalize(resolve28(child));
+  return target === base || target.startsWith(`${base}${sep20}`);
 }
 function normalize(path) {
   const normalized = path.normalize("NFC");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function relativeDisplay(workspace, filePath) {
-  const path = relative19(workspace, filePath).replaceAll("\\", "/");
+  const path = relative20(workspace, filePath).replaceAll("\\", "/");
   return path && !path.startsWith("../") ? path : basename6(filePath);
 }
 
 // src/jobs/registry.ts
 import { randomUUID as randomUUID17 } from "crypto";
+var OUTPUT_SLICE_SLACK_CHARS = 64 * 1024;
 var JobRegistry = class {
   #jobs = /* @__PURE__ */ new Map();
   #maxOutputChars;
@@ -21271,11 +21811,12 @@ var JobRegistry = class {
   }
   create(input) {
     this.#pruneCompleted();
+    if (this.#jobs.size >= this.#maxJobs) throw new Error(`Background job limit (${this.#maxJobs}) reached; wait for or cancel an existing job first`);
     const id = `job-${randomUUID17().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
-    const done = new Promise((resolve31) => {
-      settle = resolve31;
+    const done = new Promise((resolve32) => {
+      settle = resolve32;
     });
     const record = {
       id,
@@ -21285,7 +21826,8 @@ var JobRegistry = class {
       updatedAt: now,
       outputChars: 0,
       truncated: false,
-      output: "",
+      chunks: [],
+      windowChars: 0,
       outputStart: 0,
       settle,
       done
@@ -21296,11 +21838,16 @@ var JobRegistry = class {
       id,
       append: (text) => {
         if (record.state !== "running" || text === "") return;
-        record.output += text;
+        record.chunks.push(text);
+        record.windowChars += text.length;
         record.outputChars += text.length;
-        if (record.output.length > this.#maxOutputChars) {
-          const removed = record.output.length - this.#maxOutputChars;
-          record.output = record.output.slice(removed);
+        if (record.outputChars > this.#maxOutputChars) record.truncated = true;
+        if (record.windowChars > this.#maxOutputChars + OUTPUT_SLICE_SLACK_CHARS) {
+          const joined = record.chunks.join("");
+          const kept = joined.slice(joined.length - this.#maxOutputChars);
+          const removed = joined.length - kept.length;
+          record.chunks = [kept];
+          record.windowChars = kept.length;
           record.outputStart += removed;
           record.truncated = true;
         }
@@ -21309,7 +21856,7 @@ var JobRegistry = class {
       },
       complete: (result = {}) => this.#finish(
         record,
-        result.exitCode !== void 0 && result.exitCode !== null && result.exitCode !== 0 ? "failed" : "completed",
+        result.error !== void 0 || result.exitCode !== void 0 && result.exitCode !== null && result.exitCode !== 0 ? "failed" : "completed",
         result
       ),
       fail: (error) => this.#finish(record, "failed", { error: error instanceof Error ? error.message : String(error) }),
@@ -21321,25 +21868,40 @@ 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();
     const job = this.#owned(id, owner2);
     if (job.state !== "running") return snapshot2(job);
-    if (signal === void 0) return job.done;
-    return Promise.race([job.done, new Promise((_resolve, reject) => {
-      if (signal.aborted) {
-        reject(signal.reason);
-        return;
-      }
-      signal.addEventListener("abort", () => reject(signal.reason), { once: true });
-    })]);
+    return waitWithSignal(job.done, signal);
   }
   kill(id, owner2) {
     const job = this.#owned(id, owner2);
     if (job.state !== "running") return;
-    void job.cancel?.();
+    try {
+      const cancellation = job.cancel?.();
+      if (cancellation !== void 0) return cancellation.then(
+        () => this.#finish(job, "cancelled", {}),
+        (error) => this.#finish(job, "failed", { error: `Cancellation failed: ${error instanceof Error ? error.message : String(error)}` })
+      );
+    } catch (error) {
+      this.#finish(job, "failed", { error: `Cancellation failed: ${error instanceof Error ? error.message : String(error)}` });
+      return;
+    }
     this.#finish(job, "cancelled", {});
   }
   subscribe(listener) {
@@ -21399,7 +21961,7 @@ function snapshot2(job) {
 // src/terminal/service.ts
 import { randomUUID as randomUUID18 } from "crypto";
 import { createRequire as nodeCreateRequire2 } from "module";
-import { isAbsolute as isAbsolute13, relative as relative20, resolve as resolve28, sep as sep20 } from "path";
+import { isAbsolute as isAbsolute14, relative as relative21, resolve as resolve29, sep as sep21 } from "path";
 var TerminalService = class {
   #root;
   #factory;
@@ -21407,10 +21969,11 @@ var TerminalService = class {
   #maxOutputChars;
   #sessions = /* @__PURE__ */ new Map();
   constructor(workspace, options = {}) {
-    this.#root = resolve28(workspace);
+    this.#root = resolve29(workspace);
     this.#factory = options.factory ?? defaultFactory;
     this.#jobs = options.jobs;
     this.#maxOutputChars = options.maxOutputChars ?? 2e5;
+    if (!Number.isSafeInteger(this.#maxOutputChars) || this.#maxOutputChars <= 0) throw new Error("maxOutputChars must be a positive integer");
   }
   open(input) {
     const cwd = workspacePath(this.#root, input.cwd ?? ".");
@@ -21437,7 +22000,13 @@ var TerminalService = class {
       truncated: false,
       disposables: []
     };
-    const job = this.#jobs?.create({ kind: "terminal", owner: input.owner, label: shell, cancel: () => this.close(id, input.owner) });
+    let job;
+    try {
+      job = this.#jobs?.create({ kind: "terminal", owner: input.owner, label: shell, cancel: () => this.close(id, input.owner) });
+    } catch (error) {
+      pty.kill();
+      throw error;
+    }
     if (job !== void 0) {
       jobId = job.id;
       record.jobId = job.id;
@@ -21463,10 +22032,10 @@ var TerminalService = class {
     return { ...snapshot3(record), ...jobId === void 0 ? {} : { jobId } };
   }
   write(id, owner2, data2) {
-    this.#owned(id, owner2).pty.write(data2);
+    this.#running(id, owner2).pty.write(data2);
   }
   resize(id, owner2, columns, rows) {
-    this.#owned(id, owner2).pty.resize(columns, rows);
+    this.#running(id, owner2).pty.resize(columns, rows);
   }
   read(id, owner2, cursor = 0) {
     const record = this.#owned(id, owner2);
@@ -21497,6 +22066,11 @@ var TerminalService = class {
     if (record.owner !== owner2) throw new Error("Terminal owner mismatch");
     return record;
   }
+  #running(id, owner2) {
+    const record = this.#owned(id, owner2);
+    if (record.state !== "running") throw new Error(`Terminal ${id} is ${record.state}; use TerminalOpen to start a new session`);
+    return record;
+  }
 };
 function snapshot3(record) {
   return {
@@ -21525,15 +22099,15 @@ function cleanEnvironment(environment) {
   return Object.fromEntries(Object.entries(environment).filter((entry2) => entry2[1] !== void 0));
 }
 function workspacePath(root, input) {
-  const path = resolve28(root, input);
-  const delta = relative20(root, path);
-  if (delta === ".." || delta.startsWith(`..${sep20}`) || isAbsolute13(delta)) throw new Error("Terminal cwd is outside the workspace");
+  const path = resolve29(root, input);
+  const delta = relative21(root, path);
+  if (delta === ".." || delta.startsWith(`..${sep21}`) || isAbsolute14(delta)) throw new Error("Terminal cwd is outside the workspace");
   return path;
 }
 
 // src/tools/terminal.ts
 import { z as z33 } from "zod";
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } from "path";
 var Id = z33.string().regex(/^term-[a-f0-9-]+$/);
 var OpenInput = z33.object({ cwd: z33.string().optional(), shell: z33.string().optional(), args: z33.array(z33.string()).optional(), columns: z33.coerce.number().int().min(10).max(500).optional(), rows: z33.coerce.number().int().min(2).max(300).optional() });
 var OptionalBoolean = z33.union([z33.boolean(), z33.string().refine((value) => value === "true" || value === "false")]);
@@ -21547,8 +22121,8 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       name: "TerminalOpen",
       description: "Open a persistent interactive pseudo-terminal in the workspace",
       inputSchema: OpenInput,
-      paths: (input) => [resolve29(workspace, input.cwd ?? ".")],
-      permissions: (input) => ({ paths: [resolve29(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve29(workspace, input.cwd ?? ".") }),
+      paths: (input) => [resolve30(workspace, input.cwd ?? ".")],
+      permissions: (input) => ({ paths: [resolve30(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve30(workspace, input.cwd ?? ".") }),
       execute: async (input, _signal, context) => terminals.open({
         owner: owner(context),
         ...input.cwd === void 0 ? {} : { cwd: input.cwd },
@@ -21577,7 +22151,7 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       inputSchema: ReadInput3,
       paths: () => [],
       execute: async (input, _signal, context) => terminals.read(input.id, owner(context), input.cursor ?? 0),
-      renderForModel: (output) => output.output,
+      renderForModel: (output) => JSON.stringify(output),
       presentResult: (output) => {
         const result = output;
         return {
@@ -21774,8 +22348,8 @@ var PalClient = class {
       let disconnectTimer;
       await Promise.race([
         this.request({ version: 1, type: "disconnect", requestId: randomUUID19() }).catch(() => void 0),
-        new Promise((resolve31) => {
-          disconnectTimer = setTimeout(resolve31, Math.min(this.requestTimeoutMs, 250));
+        new Promise((resolve32) => {
+          disconnectTimer = setTimeout(resolve32, Math.min(this.requestTimeoutMs, 250));
         })
       ]);
       if (disconnectTimer !== void 0) clearTimeout(disconnectTimer);
@@ -21821,7 +22395,7 @@ var PalClient = class {
     return presence;
   }
   openSocket() {
-    return new Promise((resolve31, reject) => {
+    return new Promise((resolve32, reject) => {
       let settled = false;
       const rejectConnection = (error) => {
         if (settled) return;
@@ -21844,7 +22418,7 @@ var PalClient = class {
         settled = true;
         if (this.connectingReject === rejectConnection) this.connectingReject = void 0;
         socket.off("error", onInitialError);
-        resolve31();
+        resolve32();
       };
       const onInitialError = (error) => {
         socket.off("connect", onConnect);
@@ -21875,12 +22449,12 @@ var PalClient = class {
     if (this.closed || socket === void 0 || socket.destroyed || !socket.writable) {
       return Promise.reject(new Error(this.closed ? "Pal client is closed" : "Pal client is not connected"));
     }
-    return new Promise((resolve31, reject) => {
+    return new Promise((resolve32, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(request.requestId);
         reject(new Error(`Pal request '${request.type}' timed out`));
       }, this.requestTimeoutMs);
-      this.pending.set(request.requestId, { resolve: resolve31, reject, timer });
+      this.pending.set(request.requestId, { resolve: resolve32, reject, timer });
       let frame;
       try {
         frame = encodeControlFrame(BrokerRequestSchema.parse(request));
@@ -21984,12 +22558,12 @@ var PalClient = class {
   }
   scheduleReconnect() {
     if (this.reconnectTimer !== void 0 || this.closed) return;
-    const delay3 = this.reconnectDelayMs;
+    const delay2 = this.reconnectDelayMs;
     this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, this.reconnectMaxDelayMs);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = void 0;
       void this.start().catch(() => this.scheduleReconnect());
-    }, delay3);
+    }, delay2);
     this.reconnectTimer.unref?.();
   }
 };
@@ -22091,6 +22665,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const recipientId = await assertSendTarget(client, input.target, input.coWorkId);
+        signal.throwIfAborted();
         return client.sendChat(recipientId, shareGuard.protect(input.message));
       }
     },
@@ -22114,6 +22689,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         assertRequiredParticipant(await client.coWorkStatus(input.plan.coWorkId), options.selfId);
+        signal.throwIfAborted();
         const plan = CoWorkPlanSchema.parse({
           ...input.plan,
           goal: shareGuard.protect(input.plan.goal),
@@ -22130,11 +22706,13 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         let state = await assertCurrentToken(client, input);
+        signal.throwIfAborted();
         assertRequiredParticipant(state, options.selfId);
         if (!state.planAcceptedParticipantIds.includes(options.selfId)) {
           state = await client.coWorkAction({ type: "cowork-plan-accept", ...input });
         }
         if (state.readyParticipantIds.includes(options.selfId) || state.phase === "running") return state;
+        signal.throwIfAborted();
         return client.coWorkAction({ type: "cowork-ready", ...input });
       }
     },
@@ -22148,6 +22726,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const recipientId = await assertSendTarget(client, input.target, input.coWorkId);
+        signal.throwIfAborted();
         return client.sendChat(recipientId, `[co-work ${input.coWorkId} progress] ${shareGuard.protect(input.detail)}`);
       }
     },
@@ -22161,6 +22740,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const state = await assertCurrentToken(client, input);
+        signal.throwIfAborted();
         assertRequiredParticipant(state, options.selfId);
         if (state.phase !== "running" || !state.acceptedParticipantIds.includes(options.selfId) || !state.readyParticipantIds.includes(options.selfId)) {
           throw new Error("A required participant must be accepted, ready, and running before reporting completion");
@@ -22178,6 +22758,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const state = await assertCurrentToken(client, input);
+        signal.throwIfAborted();
         assertRequiredParticipant(state, options.selfId);
         if (state.integrationOwnerId !== options.selfId) throw new Error("Only the broker-designated integration owner can finalize integration");
         if (state.phase !== "verifying") throw new Error("Co-work is not ready for integration verification");
@@ -22284,8 +22865,8 @@ var ApprovalBridge = class {
   }
 };
 async function createProductionRuntime(options) {
-  const workspace = resolve30(options.workspace ?? process.cwd());
-  const home = resolve30(options.home ?? homedir3());
+  const workspace = resolve31(options.workspace ?? process.cwd());
+  const home = resolve31(options.home ?? homedir3());
   const environment = options.environment ?? process.env;
   const ide = new FlavorIdeClient({ workspace, home, environment });
   const ideReady = ide.initialize();
@@ -22459,6 +23040,7 @@ async function createProductionRuntime(options) {
   const executionEnvironment = createExecutionEnvironment(workspace, config.execution);
   const jobs = new JobRegistry();
   const terminals = new TerminalService(workspace, { jobs });
+  const lspManager = new RealLspManager({ workspace, onStatus: (message2) => emitOutput({ type: "notice", message: message2 }) });
   const observations = new FileObservationStore();
   const workspaceInstructions = new WorkspaceInstructions(workspace);
   const fileMutationOptions = {
@@ -22482,9 +23064,7 @@ async function createProductionRuntime(options) {
     createWebSearchTool(),
     ...createJobTools(jobs),
     ...createTerminalTools(terminals, workspace),
-    ...createLspTools(workspace, {
-      onStatus: (message2) => emitOutput({ type: "notice", message: message2 })
-    }),
+    ...createLspTools(workspace, { manager: lspManager }),
     ...options.approvalPolicy === "deny" ? [] : [createAskUserQuestionTool(askUserQuestionHandler)],
     createTaskOutputTool(),
     createTodoWriteTool()
@@ -22529,8 +23109,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join29(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join29(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join30(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join30(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
@@ -22639,7 +23219,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join29(tmpdir4(), `flavor-code-pals-${createHash18("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join30(tmpdir4(), `flavor-code-pals-${createHash18("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -22750,8 +23330,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join29(home, ".flavor-code", "skills")],
-      projectRoots: [join29(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join30(home, ".flavor-code", "skills")],
+      projectRoots: [join30(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -22759,7 +23339,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(join29(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join30(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -23021,6 +23601,8 @@ async function createProductionRuntime(options) {
       permissionPolicy,
       maxIterationsMain: config.maxIterations.main,
       maxIterationsSubagent: config.maxIterations.subagent,
+      softLimitFactor: config.maxIterations.softLimitFactor,
+      extendIterations: config.maxIterations.extendBy,
       hasActiveProgress,
       afterToolSuccess: async (_tool, paths, _input, _output, context) => workspaceInstructions.discover(paths, context.ownerId ?? context.agent),
       toolJournal: {
@@ -23342,7 +23924,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join29(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join30(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -23412,6 +23994,8 @@ async function createProductionRuntime(options) {
         permissionPolicy,
         maxIterationsMain: config.maxIterations.main,
         maxIterationsSubagent: config.maxIterations.subagent,
+        softLimitFactor: config.maxIterations.softLimitFactor,
+        extendIterations: config.maxIterations.extendBy,
         loopMode: true,
         afterToolSuccess: async (_tool, paths, _input, _output, context) => loopInstructions.discover(paths, context.ownerId ?? context.agent),
         toolJournal: {
@@ -23448,12 +24032,83 @@ 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 {
+      }
+      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 }),
@@ -23490,9 +24145,11 @@ async function createProductionRuntime(options) {
       plannerModelId: mainModel,
       classifierModelId: mainModel,
       skepticCount: 3,
-      maxRounds: 5,
-      maxStallStreak: 2,
+      maxRounds: config.goal.maxRounds,
+      maxStallStreak: config.goal.maxStallStreak,
       persistence: goalStore,
+      onRoundBoundary: (goalId) => maybeRotateAtBoundary({ kind: "goal", id: goalId }),
+      onMemoryCheckpoint: (goalId) => maybeRotateAtBoundary({ kind: "goal", id: goalId }),
       verifyHost: async (signal) => runVerificationPlan(
         await inferVerificationPlan(workspace),
         workspace,
@@ -23587,30 +24244,49 @@ 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(),
       mcp: async (command, signal) => {
         signal.throwIfAborted();
         const manager = await mcpReady;
@@ -23701,10 +24377,10 @@ async function createProductionRuntime(options) {
       explain: (query, focus, signal, onText) => runExplain({
         graph: new DesktopAstGraphService(workspace),
         readFile: async (path) => {
-          const root = resolve30(workspace);
-          const abs = resolve30(root, path);
-          if (abs !== root && !abs.startsWith(root + sep21)) throw new Error(`path outside workspace: ${path}`);
-          return readFile23(abs, "utf8");
+          const root = resolve31(workspace);
+          const abs = resolve31(root, path);
+          if (abs !== root && !abs.startsWith(root + sep22)) throw new Error(`path outside workspace: ${path}`);
+          return readFile24(abs, "utf8");
         },
         history: async (path, limit) => fileHistory(workspace, path, limit),
         questions,
@@ -23716,7 +24392,7 @@ async function createProductionRuntime(options) {
       }, query, focus, signal),
       audit: async (toolFilter) => {
         try {
-          const raw = await readFile23(auditLogger.path, "utf8");
+          const raw = await readFile24(auditLogger.path, "utf8");
           const lines = raw.trim().split("\n").filter((line) => line.length > 0);
           const entries = lines.map((line) => {
             try {
@@ -23756,7 +24432,7 @@ ${summary2}`;
       doctor: async () => formatDoctorReport(await runDoctor({ workspace, home, environment })),
       usage: async () => {
         try {
-          const raw = await readFile23(usageLogPath(), "utf8");
+          const raw = await readFile24(usageLogPath(), "utf8");
           return formatUsageSummary(summarizeUsage(parseUsageEntries(raw)));
         } catch (error) {
           if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
@@ -23909,7 +24585,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join29(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join30(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -23956,7 +24632,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join29(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join30(home, ".flavor-code", "auth.json"));
         const tokens = await tokenStore.load();
         const hadCredentials = Object.keys(tokens).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -24055,6 +24731,7 @@ ${renderMemoryDocument(entries)}`;
         if (executionEnvironment !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "execution-environment", executionEnvironment.dispose());
         if (islandControlServer !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "island-control", islandControlServer.close());
         terminals.dispose();
+        await boundedStep(stepTimeoutMs, diagnostics, "language-servers", lspManager.dispose());
         await boundedStep(stepTimeoutMs, diagnostics, "jobs", jobs.dispose());
         auditLogger.close();
         evolveService.dispose();
@@ -24095,6 +24772,7 @@ ${renderMemoryDocument(entries)}`;
       if (sleepScheduler !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "sleep-scheduler", sleepScheduler.dispose());
       if (executionEnvironment !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "execution-environment", executionEnvironment.dispose());
       terminals.dispose();
+      await boundedStep(stepTimeoutMs, diagnostics, "language-servers", lspManager.dispose());
       await boundedStep(stepTimeoutMs, diagnostics, "jobs", jobs.dispose());
       unsubscribeCollaboration?.();
       pendingCollaborationEvents.length = 0;
@@ -24147,10 +24825,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;
@@ -24248,13 +24932,13 @@ async function workspaceFingerprint(workspace) {
   let remaining = 5 * 1024 * 1024;
   for (const name of untracked.stdout.split("\0").filter(Boolean).sort()) {
     if (name === ".flavor/loops" || name.startsWith(".flavor/loops/")) continue;
-    const path = resolve30(workspace, name);
-    const relativePath = relative21(resolve30(workspace), path);
-    if (relativePath === ".." || relativePath.startsWith(`..${sep21}`)) continue;
+    const path = resolve31(workspace, name);
+    const relativePath = relative22(resolve31(workspace), path);
+    if (relativePath === ".." || relativePath.startsWith(`..${sep22}`)) continue;
     hash.update(name);
     if (remaining <= 0) continue;
     try {
-      const content = await readFile23(path);
+      const content = await readFile24(path);
       const slice = content.subarray(0, remaining);
       hash.update(slice);
       remaining -= slice.length;
@@ -24366,7 +25050,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;
@@ -24374,7 +25067,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;
@@ -24382,14 +25078,43 @@ function requestMemoryRestart(workspace, sessionId, emitOutput) {
       previous = parseMemoryRestartMarker(readFileSync3(markerPath, "utf8"));
     } catch {
     }
-    mkdirSync4(dirname19(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(dirname17(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomUUID20()}.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.";
@@ -24484,7 +25209,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(join29(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join30(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -24753,7 +25478,7 @@ async function generateSleepReview(registry, modelId, prompt, signal) {
 }
 async function optionalText2(path) {
   try {
-    return await readFile23(path, "utf8");
+    return await readFile24(path, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
     throw error;
@@ -24838,7 +25563,17 @@ 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-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}` };