flavor-code 1.3.19 → 1.3.21

package/dist/{chunk-PF457XCH.js → chunk-Z62P4LL7.js}

@@ -18,7 +18,7 @@ import {
   redactConfig,
   setProjectMcpServerDisabled,
   updateProtectedFile
-} from "./chunk-HJOCNKPN.js";
+} from "./chunk-RPFWB45Y.js";
 import {
   AuditLogger,
   appendUsageLog,
@@ -72,12 +72,12 @@ function normalizeProviderError(error) {
 
 // src/utils/async.ts
 function withTimeout(promise, ms) {
-  return new Promise((resolve29, reject) => {
+  return new Promise((resolve30, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      resolve29({ timedOut: true, value: void 0 });
+      resolve30({ timedOut: true, value: void 0 });
     }, ms);
     timer.unref?.();
     promise.then(
@@ -85,7 +85,7 @@ function withTimeout(promise, ms) {
         if (!settled) {
           settled = true;
           clearTimeout(timer);
-          resolve29({ timedOut: false, value });
+          resolve30({ timedOut: false, value });
         }
       },
       (error) => {
@@ -100,13 +100,13 @@ function withTimeout(promise, ms) {
 }
 function awaitWithSignal(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve29, reject) => {
+  return new Promise((resolve30, reject) => {
     const onAbort = () => reject(signal.reason);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve29(value);
+        resolve30(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -2733,7 +2733,7 @@ var SearchSpawnError = class extends Error {
   }
   fallbackSafe;
 };
-function delimitedParser(delimiter, onRecord) {
+function delimitedParser(delimiter2, onRecord) {
   let pending = Buffer.alloc(0);
   let stopped = false;
   return {
@@ -2742,7 +2742,7 @@ function delimitedParser(delimiter, onRecord) {
       pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
       let offset = 0;
       while (true) {
-        const end = pending.indexOf(delimiter, offset);
+        const end = pending.indexOf(delimiter2, offset);
         if (end < 0) break;
         if (!onRecord(pending.subarray(offset, end))) {
           stopped = true;
@@ -4194,9 +4194,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((resolve29) => {
+    return new Promise((resolve30) => {
       const check = () => {
-        if (!this.#activePlanning.has(key)) resolve29();
+        if (!this.#activePlanning.has(key)) resolve30();
         else this.#planningIdleWaiters.add(check);
       };
       this.#planningIdleWaiters.add(check);
@@ -4303,6 +4303,101 @@ function requiredPals(service) {
   return service;
 }
 
+// src/utils/crash-guard.ts
+import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join5 } from "path";
+var installed = false;
+var crashing = false;
+var crashCleanups = /* @__PURE__ */ new Set();
+function registerCrashCleanup(cleanup) {
+  crashCleanups.add(cleanup);
+  return () => {
+    crashCleanups.delete(cleanup);
+  };
+}
+async function runCrashCleanups(timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) throw new Error("Crash cleanup timeout must be non-negative");
+  const cleanup = Promise.allSettled([...crashCleanups].map(async (callback) => callback()));
+  if (timeoutMs === 0) return;
+  let timer;
+  try {
+    await Promise.race([
+      cleanup,
+      new Promise((resolvePromise) => {
+        timer = setTimeout(resolvePromise, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function installCrashGuard(options = {}) {
+  if (installed) return;
+  installed = true;
+  const crashLogDir = () => {
+    try {
+      return join5((options.workspace ?? process.cwd)(), ".flavor");
+    } catch {
+      return process.cwd();
+    }
+  };
+  const writeCrashLog = (kind, detail) => {
+    try {
+      const dir = crashLogDir();
+      mkdirSync2(dir, { recursive: true });
+      const path = join5(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
+      writeFileSync(path, [
+        `kind: ${kind}`,
+        `version: ${process.version}`,
+        `platform: ${process.platform}`,
+        `time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        "",
+        detail
+      ].join("\n"), { encoding: "utf8", mode: 384 });
+      return path;
+    } catch {
+      return void 0;
+    }
+  };
+  const restoreTerminal = () => {
+    try {
+      if (process.stdout.isTTY === true) process.stdout.write("\x1B[?25h\x1B[?1049l");
+    } catch {
+    }
+  };
+  const describe = (reason) => {
+    if (reason instanceof Error) return `${reason.name}: ${reason.message}
+${reason.stack ?? ""}`;
+    return String(reason);
+  };
+  const crash = (kind, reason) => {
+    if (crashing) {
+      process.exit(1);
+      return;
+    }
+    crashing = true;
+    const detail = describe(reason);
+    const logPath = writeCrashLog(kind, detail);
+    restoreTerminal();
+    try {
+      const safe = redactErrorText(detail.split("\n").slice(0, 3).join("\n"));
+      process.stderr.write(`flavor crashed (${kind}): ${safe}
+`);
+      if (logPath !== void 0) process.stderr.write(`crash log: ${logPath}
+`);
+    } catch {
+    }
+    const cleanupTimeoutMs = options.cleanupTimeoutMs ?? 1e3;
+    const watchdog = setTimeout(() => process.exit(1), cleanupTimeoutMs + 50);
+    void runCrashCleanups(cleanupTimeoutMs).finally(() => {
+      clearTimeout(watchdog);
+      process.exit(1);
+    });
+  };
+  process.on("unhandledRejection", (reason) => crash("unhandledRejection", reason));
+  process.on("uncaughtException", (error) => crash("uncaughtException", error));
+}
+
 // src/execution/docker.ts
 import { spawn as spawn2 } from "child_process";
 import { relative as relative5, resolve as resolve5, sep as sep5, win32 } from "path";
@@ -4401,7 +4496,7 @@ function runInvocation(invocation, signal, timeoutMs) {
 import { createHash as createHash3 } from "crypto";
 import { Socket as Socket2 } from "net";
 import { tmpdir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { spawn as spawn3 } from "child_process";
 
 // src/pals/broker.ts
@@ -4414,16 +4509,16 @@ import { dirname as dirname8 } from "path";
 import { randomBytes, randomUUID as randomUUID3 } from "crypto";
 import { chmod, link, mkdir as mkdir4, open as open3, readFile as readFile4, unlink } from "fs/promises";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var PAL_AUTH_TOKEN_BYTES = 32;
 var TOKEN_PATTERN = /^[a-f0-9]{64}$/;
 async function loadOrCreatePalAuthToken(options = {}) {
-  const directory = join5(options.home ?? homedir(), ".flavor-code", "pals");
-  const tokenPath = join5(directory, "auth-token");
+  const directory = join6(options.home ?? homedir(), ".flavor-code", "pals");
+  const tokenPath = join6(directory, "auth-token");
   await mkdir4(directory, { recursive: true, mode: 448 });
   await chmod(directory, 448);
   const token = (options.random ?? randomBytes)(PAL_AUTH_TOKEN_BYTES).toString("hex");
-  const temporaryPath = join5(directory, `.auth-token-${process.pid}-${randomUUID3()}.tmp`);
+  const temporaryPath = join6(directory, `.auth-token-${process.pid}-${randomUUID3()}.tmp`);
   let handle;
   try {
     handle = await open3(temporaryPath, "wx", 384);
@@ -4544,12 +4639,12 @@ var BrokerStateError = class extends Error {
 };
 var WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\";
 function canConnect(address) {
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     const socket = new Socket();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve29(connected);
+      resolve30(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -4598,7 +4693,7 @@ var PalBrokerServer = class {
     this.authToken ??= await loadOrCreatePalAuthToken(this.authHome === void 0 ? {} : { home: this.authHome });
     try {
       await this.prepareAddress();
-      await new Promise((resolve29, reject) => {
+      await new Promise((resolve30, reject) => {
         const onError = (error) => {
           this.server.off("listening", onListening);
           reject(error);
@@ -4607,7 +4702,7 @@ var PalBrokerServer = class {
           this.server.off("error", onError);
           this.started = true;
           this.ownsAddress = true;
-          resolve29();
+          resolve30();
         };
         this.server.once("error", onError);
         this.server.once("listening", onListening);
@@ -4635,7 +4730,7 @@ var PalBrokerServer = class {
     const ownsAddress = this.ownsAddress;
     for (const connection of this.connections) connection.socket.destroy();
     if (this.started) {
-      await new Promise((resolve29) => this.server.close(() => resolve29()));
+      await new Promise((resolve30) => this.server.close(() => resolve30()));
       this.started = false;
     }
     this.ownsAddress = false;
@@ -5304,15 +5399,15 @@ var PalBrokerState = class {
 // src/pals/broker-cli.ts
 var startupAttempts = /* @__PURE__ */ new Map();
 function delay(milliseconds) {
-  return new Promise((resolve29) => setTimeout(resolve29, milliseconds));
+  return new Promise((resolve30) => setTimeout(resolve30, milliseconds));
 }
 function canConnect2(address) {
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     const socket = new Socket2();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve29(connected);
+      resolve30(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -5321,7 +5416,7 @@ function canConnect2(address) {
 }
 function startupLockPath(address) {
   const digest = createHash3("sha256").update(address, "utf8").digest("hex").slice(0, 24);
-  return join6(tmpdir(), `flavor-code-pals-${digest}.startup.lock`);
+  return join7(tmpdir(), `flavor-code-pals-${digest}.startup.lock`);
 }
 async function spawnProductionBroker(address) {
   const entry2 = process.argv[1];
@@ -5355,8 +5450,8 @@ async function runPalBroker(options) {
   const sweepIntervalMs = options.sweepIntervalMs ?? 5e3;
   const idleShutdownMs = options.idleShutdownMs ?? 3e4;
   let resolveClosed;
-  const closed = new Promise((resolve29) => {
-    resolveClosed = resolve29;
+  const closed = new Promise((resolve30) => {
+    resolveClosed = resolve30;
   });
   let closing;
   const timer = setInterval(() => {
@@ -5397,10 +5492,10 @@ async function ensureOnce(options) {
 
 // src/production.ts
 import { readFile as readFile22 } from "fs/promises";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { createHash as createHash18, randomUUID as randomUUID20 } from "crypto";
 import { homedir as homedir2, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
-import { basename as basename6, dirname as dirname19, join as join26, relative as relative20, resolve as resolve28, sep as sep20 } from "path";
+import { basename as basename6, dirname as dirname19, join as join27, relative as relative20, resolve as resolve29, sep as sep20 } from "path";
 
 // src/agent/subagents.ts
 import { z as z5 } from "zod";
@@ -7311,10 +7406,10 @@ function sanitize(message2, secrets) {
 }
 function waitForRetry(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve29, reject) => {
+  return new Promise((resolve30, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve29();
+      resolve30();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -7952,10 +8047,10 @@ function serializeToolInput(input) {
 }
 function waitForRetry2(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve29, reject) => {
+  return new Promise((resolve30, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve29();
+      resolve30();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -8033,7 +8128,7 @@ function redactClassifierText(value) {
 // src/tools/runtime.ts
 import { randomUUID as randomUUID7 } from "crypto";
 import { mkdir as mkdir7, writeFile as writeFile4 } from "fs/promises";
-import { basename as basename2, join as join7, resolve as resolve7 } from "path";
+import { basename as basename2, join as join8, resolve as resolve7 } from "path";
 import { z as z9 } from "zod";
 
 // src/tools/types.ts
@@ -8340,10 +8435,10 @@ var ToolRuntime = class {
     const reason = perToolExceeded && turnExceeded ? "per_tool_and_turn_limit" : perToolExceeded ? "per_tool_limit" : "turn_limit";
     const preview = headTailPreview(serialized, previewChars);
     this.#turnOutputChars += preview.length;
-    const directory = join7(this.#workspace, ".flavor", "tool-results");
+    const directory = join8(this.#workspace, ".flavor", "tool-results");
     await mkdir7(directory, { recursive: true });
     const filename2 = `${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID7()}-${safeFilename(tool)}.txt`;
-    const savedTo = join7(directory, filename2);
+    const savedTo = join8(directory, filename2);
     await writeFile4(savedTo, serialized, "utf8");
     return {
       truncated: true,
@@ -8581,8 +8676,8 @@ function toModelTool(tool) {
 
 // src/harness/journal.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
-import { closeSync, constants, existsSync as existsSync2, fsyncSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
-import { join as join8, relative as relative7, resolve as resolve8, sep as sep7 } from "path";
+import { closeSync, constants, existsSync as existsSync2, fsyncSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
+import { join as join9, relative as relative7, resolve as resolve8, sep as sep7 } from "path";
 import { z as z10 } from "zod";
 
 // src/harness/invariants.ts
@@ -8672,14 +8767,14 @@ var HarnessJournal = class {
   #records = [];
   constructor(options) {
     const workspace = resolve8(options.workspace);
-    const directory = join8(workspace, ".flavor", "sessions");
+    const directory = join9(workspace, ".flavor", "sessions");
     assertSessionId(options.sessionId);
-    mkdirSync2(directory, { recursive: true, mode: 448 });
+    mkdirSync3(directory, { recursive: true, mode: 448 });
     assertWithin(workspace, directory);
     const canonicalWorkspace = realpathSync2.native(workspace);
     const canonicalDirectory = realpathSync2.native(directory);
     if (!isWithin2(canonicalWorkspace, canonicalDirectory)) throw new Error("Harness journal directory escapes the workspace");
-    this.#path = join8(canonicalDirectory, `${options.sessionId}.events.jsonl`);
+    this.#path = join9(canonicalDirectory, `${options.sessionId}.events.jsonl`);
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
     this.#maxBytes = options.maxBytes ?? MAX_JOURNAL_BYTES;
     if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes < 1024) throw new Error("maxBytes must be an integer of at least 1024");
@@ -9055,6 +9150,64 @@ var HookDecisionSchema = z11.object({
   additionalContext: z11.string().optional()
 });
 
+// src/utils/spawn-executable.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { extname, isAbsolute as isAbsolute5, resolve as resolve9 } from "path";
+var WINDOWS_EXECUTABLE = /\.(?:com|exe)$/iu;
+var WINDOWS_CMD_SHIM = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/iu;
+var CMD_META = /([()\][%!^"`<>&|;, *?])/gu;
+function prepareSpawnInvocation(command, args, options = {}) {
+  if ((options.platform ?? process.platform) !== "win32") return { command, args: [...args] };
+  const env = options.env ?? process.env;
+  const commandFile = resolveWindowsCommand(command, options.cwd, env);
+  if (commandFile === void 0 || WINDOWS_EXECUTABLE.test(commandFile)) {
+    return { command: commandFile ?? command, args: [...args] };
+  }
+  const doubleEscape = WINDOWS_CMD_SHIM.test(commandFile);
+  const shellCommand = [escapeCmdCommand(commandFile), ...args.map((arg) => escapeCmdArgument(arg, doubleEscape))].join(" ");
+  return {
+    command: environmentValue(env, "ComSpec") ?? "cmd.exe",
+    args: ["/d", "/s", "/c", `"${shellCommand}"`],
+    windowsVerbatimArguments: true
+  };
+}
+function resolveWindowsCommand(command, cwd, env) {
+  const pathValue = environmentValue(env, "PATH") ?? "";
+  const pathExt = (environmentValue(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  const hasPath = isAbsolute5(command) || /[\\/]/u.test(command);
+  const bases = hasPath ? [isAbsolute5(command) ? command : resolve9(cwd ?? process.cwd(), command)] : pathValue.split(";").filter(Boolean).map((entry2) => resolve9(unquote(entry2), command));
+  for (const base of bases) {
+    const candidates = extname(base).length > 0 ? [base] : [base, ...pathExt.map((extension) => `${base}${extension}`)];
+    for (const candidate of candidates) {
+      if (isRegularFile(candidate)) return resolve9(candidate);
+    }
+  }
+  return void 0;
+}
+function environmentValue(env, name) {
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key === void 0 ? void 0 : env[key];
+}
+function unquote(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
+}
+function isRegularFile(path) {
+  try {
+    return existsSync3(path) && statSync2(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function escapeCmdCommand(value) {
+  return value.replace(CMD_META, "^$1");
+}
+function escapeCmdArgument(value, doubleEscapeMetaCharacters) {
+  let escaped = value.replace(/(?=(\\+?)?)\1"/gu, '$1$1\\"').replace(/(?=(\\+?)?)\1$/gu, "$1$1");
+  escaped = `"${escaped}"`.replace(CMD_META, "^$1");
+  return doubleEscapeMetaCharacters ? escaped.replace(CMD_META, "^$1") : escaped;
+}
+
 // src/hooks/bus.ts
 var DEFAULT_TIMEOUT_MS = 1e4;
 var DEFAULT_MAX_OUTPUT_BYTES = 1048576;
@@ -9161,13 +9314,16 @@ function decoratePayload(payload, envelope) {
   return envelope === void 0 ? payload : { ...payload, ...envelope };
 }
 function runShellHandler(descriptor, event, signal) {
-  return new Promise((resolve29, reject) => {
-    const child = spawn4(descriptor.command, [...descriptor.args ?? []], {
-      env: { ...process.env, ...descriptor.env },
+  return new Promise((resolve30, reject) => {
+    const env = { ...process.env, ...descriptor.env };
+    const invocation = prepareSpawnInvocation(descriptor.command, descriptor.args ?? [], { env });
+    const child = spawn4(invocation.command, invocation.args, {
+      env,
       shell: false,
       detached: process.platform !== "win32",
       windowsHide: true,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      ...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments }
     });
     const maxOutputBytes = descriptor.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
     let stdout = "";
@@ -9204,7 +9360,7 @@ function runShellHandler(descriptor, event, signal) {
         return;
       }
       try {
-        resolve29(HookDecisionSchema.parse(JSON.parse(stdout)));
+        resolve30(HookDecisionSchema.parse(JSON.parse(stdout)));
       } catch (error) {
         reject(error);
       }
@@ -9356,7 +9512,7 @@ function createIncidentReporter(options) {
 import { createHash as createHash7, randomUUID as randomUUID10 } from "crypto";
 import { chmod as chmod3, unlink as unlink4 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { createServer as createServer2 } from "net";
 var MAX_REQUEST_BYTES = 64 * 1024;
 var SOCKET_TIMEOUT_MS = 1e4;
@@ -9364,7 +9520,7 @@ function islandControlEndpoint(sessionId, platform = process.platform) {
   const digest = createHash7("sha256").update(`${process.pid}\0${sessionId}`).digest("hex").slice(0, 20);
   if (platform === "win32") return `\\\\.\\pipe\\flavor-island-control-${digest}`;
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  return join9(tmpdir2(), `flavor-island-control-${uid}-${digest}.sock`);
+  return join10(tmpdir2(), `flavor-island-control-${uid}-${digest}.sock`);
 }
 async function createIslandControlServer(options) {
   const platform = options.platform ?? process.platform;
@@ -9401,14 +9557,14 @@ async function createIslandControlServer(options) {
       void dispatch(line, socket, options, token);
     });
   });
-  await new Promise((resolve29, reject) => {
+  await new Promise((resolve30, reject) => {
     const onError = (error) => {
       server.removeListener("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve29();
+      resolve30();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -9479,11 +9635,11 @@ function write(socket, payload) {
   }
 }
 function closeServer(server) {
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     try {
-      server.close(() => resolve29());
+      server.close(() => resolve30());
     } catch {
-      resolve29();
+      resolve30();
     }
   });
 }
@@ -9491,19 +9647,19 @@ function closeServer(server) {
 // src/evolve/service.ts
 import { spawn as spawn5 } from "child_process";
 import { writeFile as writeFile8 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { z as z14 } from "zod";
 
 // src/evolve/loader.ts
 import { cp, mkdir as mkdir8, mkdtemp, readdir as readdir4, rm as rm2, stat as stat4, writeFile as writeFile6 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join10, resolve as resolve10 } from "path";
+import { join as join11, resolve as resolve11 } from "path";
 
 // src/plugins/host.ts
 import { createHash as createHash8 } from "crypto";
 import { lstatSync, realpathSync as realpathSync3 } from "fs";
 import { lstat as lstat5, open as open5, readFile as readFile7, readdir as readdir3, realpath as realpath4, stat as stat3, writeFile as writeFile5 } from "fs/promises";
-import { isAbsolute as isAbsolute5, relative as relative8, resolve as resolve9, sep as sep8 } from "path";
+import { isAbsolute as isAbsolute6, relative as relative8, resolve as resolve10, sep as sep8 } from "path";
 import { pathToFileURL } from "url";
 import { z as z13 } from "zod";
 
@@ -9821,7 +9977,7 @@ var PluginHost = class {
     const roots = [];
     for (const directory of directories) {
       try {
-        for (const entry2 of await readdir3(directory, { withFileTypes: true })) if (entry2.isDirectory()) roots.push(resolve9(directory, entry2.name));
+        for (const entry2 of await readdir3(directory, { withFileTypes: true })) if (entry2.isDirectory()) roots.push(resolve10(directory, entry2.name));
       } catch (error) {
         this.#diagnose(directory, error, directory);
       }
@@ -9854,7 +10010,7 @@ var PluginHost = class {
       const rootInfo = await lstat5(inputRoot);
       if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) throw new Error("Plugin root must be a static directory");
       const root = await realpath4(inputRoot);
-      const rawManifest = await readManifest(resolve9(root, MANIFEST));
+      const rawManifest = await readManifest(resolve10(root, MANIFEST));
       if (typeof rawManifest === "object" && rawManifest !== null && "name" in rawManifest && typeof rawManifest.name === "string") {
         diagnosticLabel = rawManifest.name;
       }
@@ -10040,7 +10196,7 @@ var PluginHost = class {
       assertActive();
       const permission = `filesystem:${operation}`;
       if (!manifest.permissions.includes(permission)) throw new Error(`Plugin ${manifest.name} lacks ${permission} permission`);
-      const path = resolve9(rawPath);
+      const path = resolve10(rawPath);
       const authorized = await this.#options.authorizeFilesystem?.({ plugin: manifest.name, operation, path });
       assertActive();
       if (authorized !== true) throw new Error(`Filesystem ${operation} denied for plugin ${manifest.name}`);
@@ -10171,14 +10327,14 @@ function assertSnapshot(expected, actual, label) {
   for (const key of ["dev", "ino", "mode", "size", "mtimeNs", "ctimeNs"]) if (expected[key] !== actual[key]) throw new Error(`${label} changed during validation`);
 }
 function resolveContained(root, value, label) {
-  if (isAbsolute5(value)) throw new Error(`${label} must be relative to the plugin root`);
-  const candidate = resolve9(root, value);
+  if (isAbsolute6(value)) throw new Error(`${label} must be relative to the plugin root`);
+  const candidate = resolve10(root, value);
   assertContained(root, candidate, label);
   return candidate;
 }
 function assertContained(root, candidate, label) {
   const delta = relative8(root, candidate);
-  if (delta === ".." || delta.startsWith(`..${sep8}`) || isAbsolute5(delta)) throw new Error(`${label} escapes the plugin root`);
+  if (delta === ".." || delta.startsWith(`..${sep8}`) || isAbsolute6(delta)) throw new Error(`${label} escapes the plugin root`);
 }
 function scopedLogger(logger, plugin) {
   const prefix = `[plugin:${plugin}] `;
@@ -10221,17 +10377,17 @@ function compare(left, right) {
 }
 
 // src/evolve/loader.ts
-var PLUGIN_DIR = join10(".flavor", "plugins");
-var VERSIONS_DIR = join10(".flavor", "plugins", ".versions");
+var PLUGIN_DIR = join11(".flavor", "plugins");
+var VERSIONS_DIR = join11(".flavor", "plugins", ".versions");
 function sanitizePluginName(tool) {
   const base = String(tool ?? "fix").replace(/[^a-z0-9-]/gi, "-").toLowerCase();
   return base.startsWith("fix-") ? base : `fix-${base}`;
 }
 function fixPluginDir(workspace, name) {
-  return resolve10(workspace, PLUGIN_DIR, name);
+  return resolve11(workspace, PLUGIN_DIR, name);
 }
 function versionsDirFor(workspace, name) {
-  return resolve10(workspace, VERSIONS_DIR, name);
+  return resolve11(workspace, VERSIONS_DIR, name);
 }
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
@@ -10266,8 +10422,8 @@ export function activate(ctx) {
 async function scaffoldFixPlugin(workspace, name) {
   const dir = fixPluginDir(workspace, name);
   await mkdir8(dir, { recursive: true });
-  const manifestPath = join10(dir, "flavor-plugin.json");
-  const entryPath = join10(dir, "index.js");
+  const manifestPath = join11(dir, "flavor-plugin.json");
+  const entryPath = join11(dir, "index.js");
   try {
     await writeFile6(manifestPath, SCAFFOLD_MANIFEST(name), { encoding: "utf8", flag: "wx" });
     await writeFile6(entryPath, SCAFFOLD_ENTRY(name), { encoding: "utf8", flag: "wx" });
@@ -10287,9 +10443,9 @@ async function verifyFixPlugin(workspace, name) {
     return { ok: false, provided: [], tools: [], commands: [], error: `Plugin "${name}" not found.` };
   }
   const collected = { tools: [], commands: [] };
-  const sandbox = await mkdtemp(join10(tmpdir3(), "flavor-evolve-verify-"));
+  const sandbox = await mkdtemp(join11(tmpdir3(), "flavor-evolve-verify-"));
   try {
-    await cp(pluginRoot, join10(sandbox, name), { recursive: true });
+    await cp(pluginRoot, join11(sandbox, name), { recursive: true });
     const host = new PluginHost({
       projectPluginDirs: [sandbox],
       sandbox: true,
@@ -10340,7 +10496,7 @@ async function verifyFixPlugin(workspace, name) {
 }
 async function snapshotFixPlugin(workspace, name) {
   const pluginRoot = fixPluginDir(workspace, name);
-  const snapshotRoot = join10(versionsDirFor(workspace, name), timestamp());
+  const snapshotRoot = join11(versionsDirFor(workspace, name), timestamp());
   await mkdir8(snapshotRoot, { recursive: true });
   await cp(pluginRoot, snapshotRoot, { recursive: true });
   return snapshotRoot;
@@ -10361,7 +10517,7 @@ async function revertFixPlugin(workspace, name) {
   }
   const snapshots = entries.filter((entry2) => !entry2.startsWith(".")).sort();
   if (snapshots.length === 0) throw new Error(`Plugin "${name}" has no snapshot to restore.`);
-  const latest = join10(versionsRoot, snapshots[snapshots.length - 1]);
+  const latest = join11(versionsRoot, snapshots[snapshots.length - 1]);
   await rm2(pluginRoot, { recursive: true, force: true });
   await mkdir8(pluginRoot, { recursive: true });
   await cp(latest, pluginRoot, { recursive: true });
@@ -10371,7 +10527,7 @@ async function revertFixPlugin(workspace, name) {
 // src/evolve/store.ts
 import { createHash as createHash9 } from "crypto";
 import { appendFile, mkdir as mkdir9, readFile as readFile8, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname11, join as join11 } from "path";
+import { dirname as dirname11, join as join12 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
@@ -10444,12 +10600,12 @@ var EvolveStore = class {
   #queue = Promise.resolve();
   constructor(options) {
     const { workspace, maxSignals = 400, maxRules = 20 } = options;
-    this.dir = join11(workspace, ".flavor", "evolve");
-    this.signalsFile = join11(this.dir, "signals.jsonl");
-    this.reflectionsFile = join11(this.dir, "reflections.jsonl");
-    this.doneFile = join11(this.dir, "done.json");
-    this.verifiedFile = join11(this.dir, "verified.json");
-    this.rulesFile = join11(this.dir, "rules.json");
+    this.dir = join12(workspace, ".flavor", "evolve");
+    this.signalsFile = join12(this.dir, "signals.jsonl");
+    this.reflectionsFile = join12(this.dir, "reflections.jsonl");
+    this.doneFile = join12(this.dir, "done.json");
+    this.verifiedFile = join12(this.dir, "verified.json");
+    this.rulesFile = join12(this.dir, "rules.json");
     this.maxSignals = maxSignals;
     this.maxRules = maxRules;
   }
@@ -10668,7 +10824,7 @@ var USAGE = [
   "  clear     reset signals, done markers, and verified markers"
 ].join("\n");
 function runCommand(command, cwd, timeoutMs) {
-  return new Promise((resolve29) => {
+  return new Promise((resolve30) => {
     const isWindows = process.platform === "win32";
     const child = spawn5(isWindows ? "cmd.exe" : "/bin/sh", isWindows ? ["/d", "/s", "/c", command] : ["-c", command], {
       cwd,
@@ -10678,7 +10834,7 @@ function runCommand(command, cwd, timeoutMs) {
     let stderr = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve29({ ok: false, stdout, stderr: `${stderr}
+      resolve30({ ok: false, stdout, stderr: `${stderr}
 [killed: exceeded ${timeoutMs}ms]`, code: "timeout" });
     }, timeoutMs);
     child.stdout.on("data", (chunk) => {
@@ -10689,12 +10845,12 @@ function runCommand(command, cwd, timeoutMs) {
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve29({ ok: false, stdout, stderr: `${stderr}
+      resolve30({ ok: false, stdout, stderr: `${stderr}
 ${error.message}`, code: "spawn" });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve29({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
+      resolve30({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
     });
   });
 }
@@ -10988,7 +11144,7 @@ function createEvolveService(options) {
         if (suggestion === void 0) return `No open suggestion with id "${suggestionId}". Use /evolve suggest to list them.`;
         const name = sanitizePluginName(suggestion.tool);
         const dir = await scaffoldFixPlugin(workspace, name);
-        await writeFile8(join12(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
+        await writeFile8(join13(dir, "PLAN.md"), buildPlan(suggestion, name, "See the repeated failure below; describe your fix in PLAN.md."), "utf8");
         await snapshotFixPlugin(workspace, name);
         return [
           `suggestion ${suggestion.id}: ${suggestion.tool} x${suggestion.count} \u2014 ${suggestion.error}`,
@@ -11079,7 +11235,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
           }
           const name = sanitizePluginName(suggestion.tool);
           const dir = await scaffoldFixPlugin(workspace, name);
-          await writeFile8(join12(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
+          await writeFile8(join13(dir, "PLAN.md"), buildPlan(suggestion, name, implementation), "utf8");
           await snapshotFixPlugin(workspace, name);
           return [
             `Scaffolded fix plugin at ${dir} for suggestion [${suggestion.id}] (${suggestion.tool} x${suggestion.count}).`,
@@ -11502,7 +11658,7 @@ ${evidence.summary}`;
 // src/goal/orchestrator.ts
 import { createHash as createHash11 } from "crypto";
 import { writeFile as writeFile9, mkdir as mkdir10 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/goal/types.ts
 import { z as z16 } from "zod";
@@ -11667,7 +11823,7 @@ function extractJson(text) {
 // src/goal/classifier.ts
 import { createHash as createHash10 } from "crypto";
 import { readFile as readFile9 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function buildSkepticPrompt(evidence, plan, index) {
   const criteriaList = plan.criteria.map((c) => `  ${c.id}. [${c.type}] ${c.description}`).join("\n");
   return [
@@ -11844,7 +12000,7 @@ function computeFingerprint(gaps) {
 }
 async function collectEvidence(workspace, objective, finalResponse, priorGaps, contractHash2 = createHash10("sha256").update(objective).digest("hex"), hostVerification) {
   const workspaceState = await collectWorkspaceState(workspace);
-  const planPath = join13(workspace, ".flavor", "goal-plan.md");
+  const planPath = join14(workspace, ".flavor", "goal-plan.md");
   let planFile = null;
   try {
     planFile = await readFile9(planPath, "utf8");
@@ -12097,8 +12253,8 @@ function contractHash(objective, plan) {
   return createHash11("sha256").update(JSON.stringify({ objective, plan })).digest("hex");
 }
 async function writePlanFile(workspace, plan) {
-  const dir = join14(workspace, ".flavor");
-  const planPath = join14(dir, "goal-plan.md");
+  const dir = join15(workspace, ".flavor");
+  const planPath = join15(dir, "goal-plan.md");
   await mkdir10(dir, { recursive: true });
   const criteriaText = plan.criteria.map((c) => `- [${c.type}] AC-${c.id}: ${c.description}`).join("\n");
   const content = [
@@ -12176,15 +12332,15 @@ function formatPriorGaps(gaps) {
 import { constants as constants2 } from "fs";
 import { randomUUID as randomUUID11 } from "crypto";
 import { lstat as lstat6, mkdir as mkdir11, open as open6, rename as rename4, rm as rm4 } from "fs/promises";
-import { dirname as dirname12, join as join15, relative as relative9, resolve as resolve11, sep as sep9 } from "path";
+import { dirname as dirname12, join as join16, relative as relative9, resolve as resolve12, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
   #root;
   #maxBytes;
   constructor(options) {
-    this.#workspace = resolve11(options.workspace);
-    this.#root = join15(this.#workspace, ".flavor", "goals");
+    this.#workspace = resolve12(options.workspace);
+    this.#root = join16(this.#workspace, ".flavor", "goals");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
   }
   async save(input) {
@@ -12192,13 +12348,13 @@ var GoalStore = class {
     await assertNoSymlink(this.#workspace, dirname12(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
-    const target = join15(this.#root, `${state.id}.json`);
+    const target = join16(this.#root, `${state.id}.json`);
     const body = `${JSON.stringify(state, null, 2)}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) {
       throw new Error(`Goal state exceeds maximum size of ${this.#maxBytes} bytes`);
     }
-    const temporary = join15(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
+    const temporary = join16(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
       handle = await open6(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY, 384);
@@ -12214,8 +12370,8 @@ var GoalStore = class {
   }
 };
 async function assertNoSymlink(root, target) {
-  let cursor = resolve11(target);
-  const stop = resolve11(root);
+  let cursor = resolve12(target);
+  const stop = resolve12(root);
   const value = relative9(stop, cursor);
   if (value === ".." || value.startsWith(`..${sep9}`) || value.includes(":")) {
     throw new Error("Goal path escapes workspace");
@@ -12239,7 +12395,7 @@ function isCode3(error, code) {
 
 // src/loop/isolation.ts
 import { appendFile as appendFile2, mkdir as mkdir12, readFile as readFile10 } from "fs/promises";
-import { join as join16, resolve as resolve12 } from "path";
+import { join as join17, resolve as resolve13 } from "path";
 var CODE_CHANGE = /\b(?:fix|implement|add|update|change|modify|refactor|build|create|remove|delete|write|migrate)\b|修复|实现|添加|更新|修改|重构|创建|删除|迁移/i;
 var READ_ONLY = /\b(?:review|analy[sz]e|inspect|explain|research|investigate|audit|summari[sz]e|report)\b|调研|分析|审查|检查|解释|研究|总结|报告/i;
 function inferGoalIntent(goal) {
@@ -12249,7 +12405,7 @@ function inferGoalIntent(goal) {
 }
 async function prepareLoopWorkspace(options) {
   options.signal?.throwIfAborted();
-  const root = resolve12(options.root);
+  const root = resolve13(options.root);
   const intent = inferGoalIntent(options.goal);
   if (intent === "read_only") return { kind: "ready", workspace: { root, mode: "current" } };
   const inside = await git(root, ["rev-parse", "--is-inside-work-tree"]);
@@ -12262,8 +12418,8 @@ async function prepareLoopWorkspace(options) {
     return { kind: "needs_human", reason: "The workspace has uncommitted changes that a new worktree would omit." };
   }
   options.signal?.throwIfAborted();
-  const worktrees = join16(root, ".worktrees");
-  const path = join16(worktrees, `loop-${options.loopId}`);
+  const worktrees = join17(root, ".worktrees");
+  const path = join17(worktrees, `loop-${options.loopId}`);
   const branch = `loop/${options.loopId}`;
   try {
     await ensureWorktreeDirectoryIgnored(root);
@@ -12292,9 +12448,9 @@ async function ensureWorktreeDirectoryIgnored(root) {
   if (ignored2.code === 0) return;
   const commonDirectory = await git(root, ["rev-parse", "--git-common-dir"]);
   if (commonDirectory.code !== 0) throw new Error(commonDirectory.stderr.trim() || "Git common directory is unavailable");
-  const gitDirectory = resolve12(root, commonDirectory.stdout.trim());
-  const infoDirectory = join16(gitDirectory, "info");
-  const excludePath = join16(infoDirectory, "exclude");
+  const gitDirectory = resolve13(root, commonDirectory.stdout.trim());
+  const infoDirectory = join17(gitDirectory, "info");
+  const excludePath = join17(infoDirectory, "exclude");
   await mkdir12(infoDirectory, { recursive: true });
   let existing = "";
   try {
@@ -12310,7 +12466,7 @@ async function ensureWorktreeDirectoryIgnored(root) {
 // src/loop/store.ts
 import { constants as constants3 } from "fs";
 import { lstat as lstat7, mkdir as mkdir13, open as open7, readFile as readFile11, realpath as realpath5, rename as rename5, rm as rm5, stat as stat5 } from "fs/promises";
-import { dirname as dirname13, join as join17, relative as relative10, resolve as resolve13, sep as sep10 } from "path";
+import { dirname as dirname13, join as join18, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
 import { randomUUID as randomUUID12 } from "crypto";
 var LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_MAX_BYTES2 = 5 * 1024 * 1024;
@@ -12320,8 +12476,8 @@ var LoopStore = class {
   #maxBytes;
   #appendTails = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.#workspace = resolve13(options.workspace);
-    this.#root = join17(this.#workspace, ".flavor", "loops");
+    this.#workspace = resolve14(options.workspace);
+    this.#root = join18(this.#workspace, ".flavor", "loops");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES2;
   }
   async create(state) {
@@ -12338,11 +12494,11 @@ var LoopStore = class {
     const state = LoopStateSchema.parse(input);
     await this.#assertWorkspace(state.workspace);
     const directory = await this.#prepare(state.loopId);
-    const target = join17(directory, "state.json");
+    const target = join18(directory, "state.json");
     const body = `${JSON.stringify(state, null, 2)}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Loop state exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join17(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
+    const temporary = join18(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
       handle = await open7(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
@@ -12358,7 +12514,7 @@ var LoopStore = class {
   }
   async load(loopId) {
     const directory = await this.#safeExisting(loopId);
-    const target = join17(directory, "state.json");
+    const target = join18(directory, "state.json");
     try {
       const metadata = await stat5(target);
       if (!metadata.isFile() || metadata.size > this.#maxBytes) throw new Error("Loop state is not a bounded regular file");
@@ -12378,7 +12534,7 @@ var LoopStore = class {
     const previous = this.#appendTails.get(event.loopId) ?? Promise.resolve();
     const next = previous.catch(() => void 0).then(async () => {
       const directory = await this.#prepare(event.loopId);
-      const path = join17(directory, "events.jsonl");
+      const path = join18(directory, "events.jsonl");
       const handle = await open7(path, constants3.O_CREAT | constants3.O_APPEND | constants3.O_WRONLY, 384);
       try {
         await handle.writeFile(`${JSON.stringify(event)}
@@ -12395,7 +12551,7 @@ var LoopStore = class {
     await assertNoSymlink2(this.#workspace, dirname13(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join17(this.#root, loopId);
+    const directory = join18(this.#root, loopId);
     await mkdir13(directory, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
@@ -12403,7 +12559,7 @@ var LoopStore = class {
   async #safeExisting(loopId) {
     validateId(loopId);
     await assertNoSymlink2(this.#workspace, this.#root);
-    const directory = join17(this.#root, loopId);
+    const directory = join18(this.#root, loopId);
     await assertNoSymlink2(this.#workspace, directory);
     return directory;
   }
@@ -12419,8 +12575,8 @@ function validateId(loopId) {
   if (!LOOP_ID.test(loopId)) throw new Error("Invalid loop id");
 }
 async function assertNoSymlink2(root, target) {
-  let cursor = resolve13(target);
-  const stop = resolve13(root);
+  let cursor = resolve14(target);
+  const stop = resolve14(root);
   if (!isWithin3(stop, cursor)) throw new Error("Loop path escapes workspace");
   const chain = [];
   while (cursor !== stop) {
@@ -12436,14 +12592,14 @@ async function assertNoSymlink2(root, target) {
   }
 }
 function isWithin3(root, path) {
-  const value = relative10(resolve13(root), resolve13(path));
+  const value = relative10(resolve14(root), resolve14(path));
   return value === "" || !value.startsWith(`..${sep10}`) && value !== ".." && !value.includes(":");
 }
 async function canonical(path) {
   try {
-    return await realpath5(resolve13(path));
+    return await realpath5(resolve14(path));
   } catch {
-    return resolve13(path);
+    return resolve14(path);
   }
 }
 function isCode4(error, code) {
@@ -12452,11 +12608,11 @@ function isCode4(error, code) {
 
 // src/loop/verifier.ts
 import { readFile as readFile12 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/tools/shell.ts
 import { spawn as spawn6, spawnSync } from "child_process";
-import { isAbsolute as isAbsolute6, relative as relative11, resolve as resolve14, sep as sep11 } from "path";
+import { isAbsolute as isAbsolute7, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
 import { z as z18 } from "zod";
 
 // src/tools/jobs.ts
@@ -12609,7 +12765,7 @@ function buildWindowsCommandLine(kind, commandLine, command, args) {
   return `chcp 65001>nul & ${executable} -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`;
 }
 function createShellTool(workspace, options = {}) {
-  const root = resolve14(workspace);
+  const root = resolve15(workspace);
   const maxBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES2;
   const defaultTimeoutMs = options.defaultTimeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS;
   if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) throw new Error("maxOutputBytes must be a positive integer");
@@ -12908,9 +13064,9 @@ function backgroundFlag(value) {
   return value === true || value === "true";
 }
 function workingDirectory(root, cwd = ".") {
-  const candidate = resolve14(root, cwd);
+  const candidate = resolve15(root, cwd);
   const delta = relative11(root, candidate);
-  if (delta === ".." || delta.startsWith(`..${sep11}`) || isAbsolute6(delta)) throw new Error("Working directory is outside the workspace");
+  if (delta === ".." || delta.startsWith(`..${sep11}`) || isAbsolute7(delta)) throw new Error("Working directory is outside the workspace");
   return candidate;
 }
 async function terminateTree(pid) {
@@ -13020,13 +13176,13 @@ var SCRIPT_PRIORITY = ["test", "typecheck", "lint", "build", "smoke:install"];
 async function inferVerificationPlan(workspace) {
   const commands = [];
   const seen = /* @__PURE__ */ new Set();
-  const packageJson = await optionalJson(join18(workspace, "package.json"));
+  const packageJson = await optionalJson(join19(workspace, "package.json"));
   const scripts = isRecord2(packageJson?.scripts) ? packageJson.scripts : {};
   for (const name of SCRIPT_PRIORITY) {
     if (typeof scripts[name] !== "string" || isUnconditionalPassThrough(scripts[name])) continue;
     add(commands, seen, npmScript(name));
   }
-  const flavor = await optionalText(join18(workspace, "FLAVOR.md"));
+  const flavor = await optionalText(join19(workspace, "FLAVOR.md"));
   if (flavor !== void 0) {
     for (const match of flavor.matchAll(/^- `([^`]+)`\s*$/gm)) {
       const parsed = parseTrustedCommand(match[1] ?? "");
@@ -13993,7 +14149,7 @@ function isRecord3(value) {
 }
 
 // src/mcp/sdk.ts
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import {
   getDefaultEnvironment,
@@ -14015,7 +14171,7 @@ async function connectSdkMcpClient(input, dependencies = DEFAULT_DEPENDENCIES) {
     command: config.command,
     args: [...config.args],
     env: { ...dependencies.defaultEnvironment(), ...config.env },
-    cwd: resolve15(input.workspace, config.cwd ?? "."),
+    cwd: resolve16(input.workspace, config.cwd ?? "."),
     // MCP servers frequently log startup banners to stderr. Inheriting that
     // stream corrupts Ink's input area, so connection errors are surfaced
     // through McpManager diagnostics instead.
@@ -14220,8 +14376,8 @@ var OAuthCallbackAuthProvider = class {
   async #startCallbackServer(expectedState, signal) {
     let serverResolve;
     let serverReject;
-    const codePromise = new Promise((resolve29, reject) => {
-      serverResolve = resolve29;
+    const codePromise = new Promise((resolve30, reject) => {
+      serverResolve = resolve30;
       serverReject = reject;
     });
     const server = createServer3((req, res) => {
@@ -14255,7 +14411,7 @@ var OAuthCallbackAuthProvider = class {
       );
       serverResolve(code);
     });
-    return new Promise((resolve29, reject) => {
+    return new Promise((resolve30, reject) => {
       server.once("error", (error) => {
         reject(new Error(`OAuth callback server failed: ${error.message}`));
       });
@@ -14272,7 +14428,7 @@ var OAuthCallbackAuthProvider = class {
         signal.addEventListener("abort", () => {
           serverReject(new Error("OAuth flow aborted"));
         }, { once: true });
-        resolve29({ redirectUri, promise: codePromise });
+        resolve30({ redirectUri, promise: codePromise });
       });
     });
   }
@@ -14415,7 +14571,7 @@ function isStoredToken(value) {
 
 // src/permissions/policy.ts
 import { readFile as readFile15 } from "fs/promises";
-import { join as join19, resolve as resolve16 } from "path";
+import { join as join20, resolve as resolve17 } from "path";
 import { z as z20 } from "zod";
 var DecisionSchema2 = z20.enum(["allow", "ask", "deny"]);
 var PrefixSchema = z20.array(z20.string().min(1).max(1024)).min(1).max(64);
@@ -14451,10 +14607,10 @@ var CompiledPermissionPolicy = class {
 };
 async function loadPermissionPolicy(options) {
   const sources = [
-    ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve16(options.managedPath) }],
-    { tier: "user", path: join19(resolve16(options.home), ".flavor-code", "permissions.json") },
-    { tier: "project", path: join19(resolve16(options.workspace), ".flavor", "permissions.json") },
-    { tier: "local", path: join19(resolve16(options.workspace), ".flavor", "permissions.local.json") }
+    ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve17(options.managedPath) }],
+    { tier: "user", path: join20(resolve17(options.home), ".flavor-code", "permissions.json") },
+    { tier: "project", path: join20(resolve17(options.workspace), ".flavor", "permissions.json") },
+    { tier: "local", path: join20(resolve17(options.workspace), ".flavor", "permissions.local.json") }
   ];
   const rules = [];
   for (const source of sources) {
@@ -14676,7 +14832,7 @@ function data(value) {
 // src/skills/registry.ts
 import { constants as constants4 } from "fs";
 import { lstat as lstat8, open as defaultOpen, readdir as readdir5, realpath as realpath6 } from "fs/promises";
-import { isAbsolute as isAbsolute7, relative as relative12, resolve as resolve17, sep as sep12 } from "path";
+import { isAbsolute as isAbsolute8, relative as relative12, resolve as resolve18, sep as sep12 } from "path";
 import { marked } from "marked";
 import { parseDocument } from "yaml";
 var SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -14801,13 +14957,13 @@ var SkillRegistry = class {
     const record = await this.#recordFor(skill);
     const normalized = normalizeReference(reference);
     const parts = normalized.split("/");
-    if (isAbsolute7(reference) || parts.includes("..") || parts.length !== 2 || !RESOURCE_DIRECTORIES.has(parts[0] ?? "") || !RESOURCE_NAME.test(parts[1] ?? "")) {
+    if (isAbsolute8(reference) || parts.includes("..") || parts.length !== 2 || !RESOURCE_DIRECTORIES.has(parts[0] ?? "") || !RESOURCE_NAME.test(parts[1] ?? "")) {
       throw new Error(`Resource reference escapes the skill root or is not a direct resource: ${reference}`);
     }
     const body = await this.loadBody(record.metadata);
     const references = extractResourceReferences(body);
     if (!references.has(normalized)) throw new Error(`Skill resource is not directly referenced: ${reference}`);
-    const candidate = resolve17(record.metadata.root, ...parts);
+    const candidate = resolve18(record.metadata.root, ...parts);
     const file = await openVerifiedFile(candidate, record.metadata.root, "Resource", this.#options.openFile);
     try {
       if (file.snapshot.size > BigInt(this.#options.maxResourceBytes)) throw new Error(`Skill resource is too large: ${reference}`);
@@ -14836,7 +14992,7 @@ var SkillRegistry = class {
   async #discoverSource(roots, source) {
     const found = [];
     for (const configuredRoot of roots) {
-      const root = resolve17(configuredRoot);
+      const root = resolve18(configuredRoot);
       let entries;
       let physicalRoot = root;
       try {
@@ -14851,13 +15007,13 @@ var SkillRegistry = class {
       }
       entries.sort((left, right) => compareCodePoints(left.name, right.name));
       for (const entry2 of entries) {
-        const skillRoot = resolve17(root, entry2.name);
+        const skillRoot = resolve18(root, entry2.name);
         try {
           if (entry2.isSymbolicLink()) throw new Error("Symlinked skill directories are not allowed");
           if (!entry2.isDirectory()) continue;
           const physicalSkillRoot = await realpath6(skillRoot);
           if (!isWithin4(physicalRoot, physicalSkillRoot)) throw new Error("Skill directory escapes its registry root");
-          const skillFile = resolve17(skillRoot, "SKILL.md");
+          const skillFile = resolve18(skillRoot, "SKILL.md");
           const parsed = await readFrontmatterFile(
             skillFile,
             physicalSkillRoot,
@@ -15059,7 +15215,7 @@ function decodeUtf82(content, label) {
 }
 function isWithin4(root, candidate) {
   const delta = relative12(root, candidate);
-  return delta === "" || delta !== ".." && !delta.startsWith(`..${sep12}`) && !isAbsolute7(delta);
+  return delta === "" || delta !== ".." && !delta.startsWith(`..${sep12}`) && !isAbsolute8(delta);
 }
 function isMissing2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -15223,7 +15379,7 @@ function createSkillResourceTool(registry) {
 // src/session/store.ts
 import { constants as constants5 } from "fs";
 import { lstat as lstat9, mkdir as mkdir14, open as open8, readFile as readFile16, readdir as readdir6, realpath as realpath7, rename as rename6, rm as rm6, stat as stat6 } from "fs/promises";
-import { basename as basename3, dirname as dirname15, join as join20, relative as relative13, resolve as resolve18, sep as sep13 } from "path";
+import { basename as basename3, dirname as dirname15, join as join21, relative as relative13, resolve as resolve19, sep as sep13 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 import { z as z22 } from "zod";
 var SESSION_VERSION = 4;
@@ -15343,14 +15499,15 @@ var SessionDocumentSchema = SessionBaseSchema.extend({
   }).strict(),
   timeline: TimelineSchema
 }).strict();
+var INVALID_SESSION_LOCK_STALE_MS = 3e4;
 var SessionStore = class {
   #workspace;
   #sessions;
   #maxBytes;
   #maxSessions;
   constructor(options) {
-    this.#workspace = resolve18(options.workspace);
-    this.#sessions = join20(this.#workspace, ".flavor", "sessions");
+    this.#workspace = resolve19(options.workspace);
+    this.#sessions = join21(this.#workspace, ".flavor", "sessions");
     this.#maxBytes = options.maxBytes ?? DEFAULT_MAX_SESSION_BYTES;
     if (!Number.isSafeInteger(this.#maxBytes) || this.#maxBytes < 256) throw new Error("maxBytes must be an integer of at least 256");
     this.#maxSessions = options.maxSessions ?? 50;
@@ -15382,7 +15539,7 @@ var SessionStore = class {
     const body = `${lines.join("\n")}
 `;
     if (Buffer.byteLength(body) > this.#maxBytes) throw new Error(`Session exceeds maximum size of ${this.#maxBytes} bytes`);
-    const temporary = join20(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
+    const temporary = join21(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
     let handle;
     try {
       handle = await open8(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
@@ -15397,6 +15554,47 @@ var SessionStore = class {
     }
     await this.#prune().catch(() => void 0);
   }
+  /** Hold this lease for the full lifetime of a writable session runtime. */
+  async acquireLease(sessionId) {
+    SessionIdSchema.parse(sessionId);
+    await this.#prepareDirectory();
+    const path = join21(this.#sessions, `.${sessionId}.lock`);
+    const token = JSON.stringify({ pid: process.pid, nonce: randomUUID13(), createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      let handle;
+      let created = false;
+      try {
+        handle = await open8(path, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
+        created = true;
+        await handle.writeFile(token, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = void 0;
+        let released = false;
+        return {
+          sessionId,
+          release: async () => {
+            if (released) return;
+            try {
+              if (await readFile16(path, "utf8") === token) await rm6(path, { force: true });
+            } catch (error) {
+              if (!isCode7(error, "ENOENT")) throw error;
+            }
+            released = true;
+          }
+        };
+      } catch (error) {
+        await handle?.close().catch(() => void 0);
+        if (created) await rm6(path, { force: true }).catch(() => void 0);
+        if (!isCode7(error, "EEXIST")) throw error;
+        const owner2 = await reclaimStaleSessionLock(path);
+        if (owner2 !== void 0) {
+          throw new Error(`Session "${sessionId}" is already active in process ${owner2}. Close that session before resuming it here.`);
+        }
+      }
+    }
+    throw new Error(`Session "${sessionId}" could not acquire its writer lease because the lock kept changing`);
+  }
   async load(sessionId) {
     if (sessionId === void 0) {
       const [latest] = await this.list();
@@ -15494,29 +15692,37 @@ var SessionStore = class {
       if (isCode7(error, "ENOENT")) return;
       throw error;
     }
+    const owner2 = await reclaimStaleSessionLock(join21(this.#sessions, `.${sessionId}.lock`));
+    if (owner2 !== void 0) throw new Error(`Session "${sessionId}" is active in process ${owner2} and cannot be deleted`);
     const path = this.#path(sessionId);
     try {
       const metadata = await lstat9(path);
       if (!metadata.isFile()) throw new Error("Session path is not a regular file");
       await rm6(path);
-      await rm6(join20(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm6(join21(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     } catch (error) {
       if (!isCode7(error, "ENOENT")) throw error;
     }
   }
   #path(sessionId) {
     SessionIdSchema.parse(sessionId);
-    const path = resolve18(this.#sessions, `${sessionId}.jsonl`);
+    const path = resolve19(this.#sessions, `${sessionId}.jsonl`);
     if (!isWithin5(this.#sessions, path)) throw new Error("Invalid session id");
     return path;
   }
   async #prune() {
     const entries = await this.list();
     if (entries.length <= this.#maxSessions) return;
-    const excess = entries.slice(this.#maxSessions);
-    for (const entry2 of excess) {
+    let retained = 0;
+    for (const entry2 of entries) {
+      const owner2 = await reclaimStaleSessionLock(join21(this.#sessions, `.${entry2.sessionId}.lock`));
+      if (owner2 !== void 0) continue;
+      if (retained < this.#maxSessions) {
+        retained += 1;
+        continue;
+      }
       await rm6(this.#path(entry2.sessionId), { force: true }).catch(() => void 0);
-      await rm6(join20(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm6(join21(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     }
   }
   async #assertWorkspace(stored) {
@@ -15562,6 +15768,47 @@ function storedSessionVersion(raw) {
   const candidate = first.__meta === true ? first.version : JSON.parse(trimmed).version;
   return typeof candidate === "number" && Number.isInteger(candidate) ? candidate : 0;
 }
+async function reclaimStaleSessionLock(path) {
+  try {
+    const token = await readFile16(path, "utf8");
+    const metadata = await stat6(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 readFile16(path, "utf8") !== token) return void 0;
+    const stale = `${path}.stale-${process.pid}-${randomUUID13()}`;
+    try {
+      await rename6(path, stale);
+      await rm6(stale, { force: true });
+    } catch (error) {
+      if (!isCode7(error, "ENOENT")) throw error;
+    }
+    return void 0;
+  } catch (error) {
+    if (isCode7(error, "ENOENT")) return void 0;
+    throw error;
+  }
+}
+function parseSessionLockOwner(token) {
+  try {
+    const value = JSON.parse(token);
+    if (typeof value !== "object" || value === null || !("pid" in value)) return void 0;
+    const pid = value.pid;
+    return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isCode7(error, "EPERM");
+  }
+}
 async function boundedRead(path, maxBytes) {
   const metadata = await stat6(path);
   if (!metadata.isFile()) throw new Error("Session path is not a regular file");
@@ -15708,8 +15955,8 @@ function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function assertNoSymlink3(root, target) {
-  let cursor = resolve18(target);
-  const stop = resolve18(root);
+  let cursor = resolve19(target);
+  const stop = resolve19(root);
   if (!isWithin5(stop, cursor)) throw new Error("Session path escapes the workspace");
   const chain = [];
   while (cursor !== stop) {
@@ -15725,14 +15972,14 @@ async function assertNoSymlink3(root, target) {
   }
 }
 function isWithin5(root, path) {
-  const value = relative13(resolve18(root), resolve18(path));
+  const value = relative13(resolve19(root), resolve19(path));
   return value === "" || !value.startsWith(`..${sep13}`) && value !== ".." && !value.includes(":");
 }
 async function canonical2(path) {
   try {
-    return await realpath7(resolve18(path));
+    return await realpath7(resolve19(path));
   } catch {
-    return resolve18(path);
+    return resolve19(path);
   }
 }
 function isCode7(error, code) {
@@ -15760,7 +16007,7 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 import { constants as constants6 } from "fs";
 import { randomUUID as randomUUID14 } from "crypto";
 import { lstat as lstat10, mkdir as mkdir15, open as open9, readdir as readdir7, realpath as realpath8, rename as rename7, rm as rm7 } from "fs/promises";
-import { isAbsolute as isAbsolute8, join as join21, relative as relative14, resolve as resolve19, sep as sep14 } from "path";
+import { isAbsolute as isAbsolute9, join as join22, relative as relative14, resolve as resolve20, sep as sep14 } from "path";
 import { z as z23 } from "zod";
 var DateKeySchema = z23.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = z23.object({
@@ -15814,8 +16061,8 @@ var ProjectSleepOrganizer = class {
   #sessions;
   #generate;
   constructor(options) {
-    this.#workspace = resolve19(options.workspace);
-    this.#sleepDirectory = join21(this.#workspace, ".flavor", "sleep");
+    this.#workspace = resolve20(options.workspace);
+    this.#sleepDirectory = join22(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -15824,7 +16071,7 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join21(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join22(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
       lock = await open9(lockPath, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -15859,7 +16106,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 = join21(this.#sleepDirectory, filename2);
+      const path = join22(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path, markdown);
       return { status: "written", date, path, sessionCount: documents.length };
@@ -15901,7 +16148,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join21(this.#workspace, ".flavor");
+    const flavorDirectory = join22(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir15(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -15915,7 +16162,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     return (await readdir7(this.#sleepDirectory, { withFileTypes: true })).some((entry2) => entry2.isFile() && entry2.name.startsWith(prefix) && entry2.name.endsWith(".md"));
   }
   async #atomicWrite(path, content) {
-    const temporary = join21(this.#sleepDirectory, `.${randomUUID14()}.tmp`);
+    const temporary = join22(this.#sleepDirectory, `.${randomUUID14()}.tmp`);
     let handle;
     try {
       handle = await open9(temporary, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
@@ -16239,8 +16486,8 @@ async function assertNotSymlink(path) {
 function isWithin6(root, candidate) {
   const path = relative14(root, candidate);
   if (path === "") return true;
-  if (path === ".." || path.startsWith(`..${sep14}`) || isAbsolute8(path)) return false;
-  return process.platform !== "win32" || resolve19(root, path).toLowerCase().startsWith(`${resolve19(root).toLowerCase()}${sep14}`);
+  if (path === ".." || path.startsWith(`..${sep14}`) || isAbsolute9(path)) return false;
+  return process.platform !== "win32" || resolve20(root, path).toLowerCase().startsWith(`${resolve20(root).toLowerCase()}${sep14}`);
 }
 function hasCode(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
@@ -16290,7 +16537,7 @@ function computeSessionStats(documents) {
 // src/tools/files.ts
 import { constants as constants7 } from "fs";
 import { mkdir as mkdir16, open as open10, readFile as readFile17, realpath as realpath9, rename as rename8, rm as rm8, stat as stat7 } from "fs/promises";
-import { dirname as dirname16, isAbsolute as isAbsolute9, relative as relative15, resolve as resolve20, sep as sep15 } from "path";
+import { dirname as dirname16, isAbsolute as isAbsolute10, relative as relative15, resolve as resolve21, sep as sep15 } from "path";
 import { randomUUID as randomUUID15 } from "crypto";
 import { z as z24 } from "zod";
 
@@ -16607,9 +16854,9 @@ function createApplyPatchTool(workspace, options = {}) {
   };
 }
 function createPathGuard(workspace) {
-  const root = resolve20(workspace);
+  const root = resolve21(workspace);
   const lexical = (input) => {
-    const candidate = resolve20(root, input);
+    const candidate = resolve21(root, input);
     if (!within2(root, candidate)) throw new Error("Path is outside the workspace");
     return candidate;
   };
@@ -16779,7 +17026,7 @@ async function readBounded2(path, maxBytes, signal, openFile2) {
 }
 function within2(root, candidate) {
   const delta = relative15(root, candidate);
-  return delta === "" || !delta.startsWith(`..${sep15}`) && delta !== ".." && !isAbsolute9(delta);
+  return delta === "" || !delta.startsWith(`..${sep15}`) && delta !== ".." && !isAbsolute10(delta);
 }
 function forceFlag(value) {
   return value === true || value === "true";
@@ -17310,9 +17557,9 @@ function charset(contentType) {
 
 // src/tools/lsp.ts
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { access, constants as constants8, readFile as readFile18 } from "fs/promises";
-import { basename as basename4, dirname as dirname17, extname, isAbsolute as isAbsolute10, relative as relative16, resolve as resolve21, sep as sep16 } from "path";
+import { basename as basename4, dirname as dirname17, extname as extname2, isAbsolute as isAbsolute11, relative as relative16, resolve as resolve22, sep as sep16 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
 import { z as z26 } from "zod";
 var LSP_REQUEST_TIMEOUT_MS = 15e3;
@@ -17326,10 +17573,12 @@ var LspConnection = class {
   #disposed = false;
   #initError;
   constructor(command, args, cwd) {
-    this.#process = spawn7(command, args, {
+    const invocation = prepareSpawnInvocation(command, args, { cwd });
+    this.#process = spawn7(invocation.command, invocation.args, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
+      windowsHide: true,
+      ...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments }
     });
     this.#process.on("error", (err) => {
       this.#initError = new Error(`LSP server "${command}" failed to start: ${err.message}`);
@@ -17411,8 +17660,8 @@ var LspConnection = class {
     const id = this.#nextId++;
     const request = { jsonrpc: "2.0", id, method, params };
     const timeout = AbortSignal.timeout(LSP_REQUEST_TIMEOUT_MS);
-    const promise = new Promise((resolve29, reject) => {
-      this.#pending.set(id, { resolve: resolve29, reject });
+    const promise = new Promise((resolve30, reject) => {
+      this.#pending.set(id, { resolve: resolve30, reject });
       timeout.addEventListener("abort", () => {
         if (this.#pending.has(id)) {
           this.#pending.delete(id);
@@ -17528,7 +17777,7 @@ var LspBuffer = class {
     }
   }
 };
-var TYPESCRIPT_CLI = resolve21(
+var TYPESCRIPT_CLI = resolve22(
   dirname17(fileURLToPath3(import.meta.resolve("typescript/package.json"))),
   "lib",
   "tsc.js"
@@ -17570,7 +17819,7 @@ var RealLspManager = class {
   #serverConfigs;
   #onStatus;
   constructor(options) {
-    this.#workspace = resolve21(options.workspace);
+    this.#workspace = resolve22(options.workspace);
     this.#serverConfigs = options.serverConfigs ?? KNOWN_SERVERS;
     this.#onStatus = options.onStatus;
   }
@@ -17619,7 +17868,7 @@ var RealLspManager = class {
     if (pending !== void 0) return pending;
     const config = this.#serverConfigs.find((c) => c.language === language);
     if (config === void 0) return void 0;
-    const hasRoot = config.rootFiles.some((file) => existsSync3(resolve21(this.#workspace, file)));
+    const hasRoot = config.rootFiles.some((file) => existsSync4(resolve22(this.#workspace, file)));
     if (!hasRoot) return void 0;
     const startPromise = this.#startServer(config);
     this.#pendingStarts.set(language, startPromise);
@@ -17662,10 +17911,10 @@ var LspDiagnosticsInput = z26.object({
   file: z26.string().min(1)
 });
 function createLspTools(workspace, options = {}) {
-  const root = resolve21(workspace);
+  const root = resolve22(workspace);
   const manager = options.manager ?? new RealLspManager({ workspace: root, onStatus: options.onStatus });
   const guard = (input) => {
-    const candidate = resolve21(root, input);
+    const candidate = resolve22(root, input);
     if (!isWithin7(root, candidate)) throw new Error("Path is outside the workspace");
     return candidate;
   };
@@ -17729,7 +17978,7 @@ function createLspTools(workspace, options = {}) {
   return [findRefs, hover, diagnostics];
 }
 function languageIdForPath(filePath) {
-  switch (extname(filePath).toLowerCase()) {
+  switch (extname2(filePath).toLowerCase()) {
     case ".tsx":
       return "typescriptreact";
     case ".mts":
@@ -17742,7 +17991,7 @@ function languageIdForPath(filePath) {
 }
 function isWithin7(root, candidate) {
   const delta = relative16(root, candidate);
-  return delta === "" || !delta.startsWith(`..${sep16}`) && delta !== ".." && !isAbsolute10(delta);
+  return delta === "" || !delta.startsWith(`..${sep16}`) && delta !== ".." && !isAbsolute11(delta);
 }
 function uriToPath(uri) {
   try {
@@ -18130,12 +18379,12 @@ ${explanation}` : "";
 // src/desktop/astgraph-service.ts
 import { stat as stat8 } from "fs/promises";
 import { createRequire as nodeCreateRequire } from "module";
-import { join as join22, resolve as resolve22 } from "path";
+import { join as join23, resolve as resolve23 } 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 = join22(resolve22(workspace), ".flavor", "astgraph", "index.db");
+    this.#path = join23(resolve23(workspace), ".flavor", "astgraph", "index.db");
   }
   async status() {
     if ((await stat8(this.#path).catch(() => void 0))?.isFile() !== true) {
@@ -18297,7 +18546,7 @@ var QuestionBridge = class {
     }
   }
   #askLocally(questions, signal) {
-    return new Promise((resolve29, reject) => {
+    return new Promise((resolve30, reject) => {
       const onAbort = () => {
         this.#pending = void 0;
         this.#active = false;
@@ -18311,7 +18560,7 @@ var QuestionBridge = class {
           this.#pending = void 0;
           this.#active = false;
           this.#onChange?.();
-          resolve29(answers);
+          resolve30(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
@@ -18404,7 +18653,7 @@ function createTodoWriteTool() {
 // src/tools/managed.ts
 import { randomUUID as randomUUID16 } from "crypto";
 import { link as link2, lstat as lstat11, mkdir as mkdir17, readFile as readFile19, readdir as readdir8, unlink as unlink5, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname18, join as join23, resolve as resolve23 } from "path";
+import { dirname as dirname18, join as join24, resolve as resolve24 } from "path";
 import { z as z31 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -18446,9 +18695,9 @@ var ManagedToolStore = class {
   #entries = /* @__PURE__ */ new Map();
   #diagnostics = [];
   constructor(options) {
-    this.#workspace = resolve23(options.workspace);
-    this.#projectRoot = join23(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join23(resolve23(options.home), ".flavor-code", "tools");
+    this.#workspace = resolve24(options.workspace);
+    this.#projectRoot = join24(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join24(resolve24(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -18495,7 +18744,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join23(this.directory(input.scope), filename(input.name));
+    const path = join24(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record, void 0, 2)}
 `);
@@ -18520,7 +18769,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 [join23(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join24(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -18533,7 +18782,7 @@ var ManagedToolStore = class {
       return;
     }
     for (const name of names) {
-      const path = join23(root, name);
+      const path = join24(root, name);
       try {
         const info = await lstat11(path);
         if (!info.isFile() || info.isSymbolicLink()) throw new Error("Managed tool record must be a regular file");
@@ -19452,7 +19701,7 @@ ${total}`;
 // src/memory/store.ts
 import { createHash as createHash16 } from "crypto";
 import { readFile as readFile20, rm as rm9 } from "fs/promises";
-import { resolve as resolve24, join as join24, relative as relative17, sep as sep17 } from "path";
+import { resolve as resolve25, join as join25, relative as relative17, sep as sep17 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -19554,10 +19803,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 = resolve24(options.workspace);
-    this.#memoryRoot = join24(this.workspace, ".flavor", "memory");
-    this.path = join24(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join24(this.#memoryRoot, "behavior.json");
+    this.workspace = resolve25(options.workspace);
+    this.#memoryRoot = join25(this.workspace, ".flavor", "memory");
+    this.path = join25(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join25(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -19780,7 +20029,7 @@ var MemoryStore = class {
   }
   #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 = resolve24(this.#memoryRoot, ...contentPath.split("/"));
+    const path = resolve25(this.#memoryRoot, ...contentPath.split("/"));
     const rel = relative17(this.#memoryRoot, path);
     if (rel === ".." || rel.startsWith(`..${sep17}`)) throw new Error("Memory content path escapes the memory directory");
     return path;
@@ -20252,7 +20501,7 @@ function createExecutionEnvironment(workspace, config) {
 
 // src/ide/client.ts
 import { readFile as readFile21, readdir as readdir9, stat as stat9 } from "fs/promises";
-import { basename as basename5, join as join25, relative as relative18, resolve as resolve25, sep as sep18 } from "path";
+import { basename as basename5, join as join26, relative as relative18, resolve as resolve26, sep as sep18 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -20263,8 +20512,8 @@ var FlavorIdeClient = class {
   #sessionId;
   #eventTail = Promise.resolve();
   constructor(options) {
-    this.#workspace = resolve25(options.workspace);
-    this.#home = resolve25(options.home);
+    this.#workspace = resolve26(options.workspace);
+    this.#home = resolve26(options.home);
     this.#environment = options.environment ?? process.env;
     this.#fetch = options.fetch ?? fetch;
   }
@@ -20348,7 +20597,7 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join25(this.#home, ".flavor-code", "ide");
+    const directory = join26(this.#home, ".flavor-code", "ide");
     let entries;
     try {
       entries = (await readdir9(directory)).filter((name) => name.endsWith(".lock"));
@@ -20356,7 +20605,7 @@ var FlavorIdeClient = class {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join25(directory, name);
+      const path = join26(directory, name);
       try {
         const [contents, info] = await Promise.all([readFile21(path, "utf8"), stat9(path)]);
         const lock = parseLockfile(contents);
@@ -20462,8 +20711,8 @@ function parsePort(value) {
   return Number.isInteger(port) && port > 0 && port <= 65535 ? port : void 0;
 }
 function isWithin8(parent, child) {
-  const base = normalize(resolve25(parent));
-  const target = normalize(resolve25(child));
+  const base = normalize(resolve26(parent));
+  const target = normalize(resolve26(child));
   return target === base || target.startsWith(`${base}${sep18}`);
 }
 function normalize(path) {
@@ -20493,8 +20742,8 @@ var JobRegistry = class {
     const id = `job-${randomUUID17().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
-    const done = new Promise((resolve29) => {
-      settle = resolve29;
+    const done = new Promise((resolve30) => {
+      settle = resolve30;
     });
     const record = {
       id,
@@ -20618,7 +20867,7 @@ function snapshot2(job) {
 // src/terminal/service.ts
 import { randomUUID as randomUUID18 } from "crypto";
 import { createRequire as nodeCreateRequire2 } from "module";
-import { isAbsolute as isAbsolute11, relative as relative19, resolve as resolve26, sep as sep19 } from "path";
+import { isAbsolute as isAbsolute12, relative as relative19, resolve as resolve27, sep as sep19 } from "path";
 var TerminalService = class {
   #root;
   #factory;
@@ -20626,7 +20875,7 @@ var TerminalService = class {
   #maxOutputChars;
   #sessions = /* @__PURE__ */ new Map();
   constructor(workspace, options = {}) {
-    this.#root = resolve26(workspace);
+    this.#root = resolve27(workspace);
     this.#factory = options.factory ?? defaultFactory;
     this.#jobs = options.jobs;
     this.#maxOutputChars = options.maxOutputChars ?? 2e5;
@@ -20744,15 +20993,15 @@ function cleanEnvironment(environment) {
   return Object.fromEntries(Object.entries(environment).filter((entry2) => entry2[1] !== void 0));
 }
 function workspacePath(root, input) {
-  const path = resolve26(root, input);
+  const path = resolve27(root, input);
   const delta = relative19(root, path);
-  if (delta === ".." || delta.startsWith(`..${sep19}`) || isAbsolute11(delta)) throw new Error("Terminal cwd is outside the workspace");
+  if (delta === ".." || delta.startsWith(`..${sep19}`) || isAbsolute12(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 resolve27 } from "path";
+import { resolve as resolve28 } 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")]);
@@ -20766,8 +21015,8 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       name: "TerminalOpen",
       description: "Open a persistent interactive pseudo-terminal in the workspace",
       inputSchema: OpenInput,
-      paths: (input) => [resolve27(workspace, input.cwd ?? ".")],
-      permissions: (input) => ({ paths: [resolve27(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve27(workspace, input.cwd ?? ".") }),
+      paths: (input) => [resolve28(workspace, input.cwd ?? ".")],
+      permissions: (input) => ({ paths: [resolve28(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve28(workspace, input.cwd ?? ".") }),
       execute: async (input, _signal, context) => terminals.open({
         owner: owner(context),
         ...input.cwd === void 0 ? {} : { cwd: input.cwd },
@@ -20993,8 +21242,8 @@ var PalClient = class {
       let disconnectTimer;
       await Promise.race([
         this.request({ version: 1, type: "disconnect", requestId: randomUUID19() }).catch(() => void 0),
-        new Promise((resolve29) => {
-          disconnectTimer = setTimeout(resolve29, Math.min(this.requestTimeoutMs, 250));
+        new Promise((resolve30) => {
+          disconnectTimer = setTimeout(resolve30, Math.min(this.requestTimeoutMs, 250));
         })
       ]);
       if (disconnectTimer !== void 0) clearTimeout(disconnectTimer);
@@ -21040,7 +21289,7 @@ var PalClient = class {
     return presence;
   }
   openSocket() {
-    return new Promise((resolve29, reject) => {
+    return new Promise((resolve30, reject) => {
       let settled = false;
       const rejectConnection = (error) => {
         if (settled) return;
@@ -21063,7 +21312,7 @@ var PalClient = class {
         settled = true;
         if (this.connectingReject === rejectConnection) this.connectingReject = void 0;
         socket.off("error", onInitialError);
-        resolve29();
+        resolve30();
       };
       const onInitialError = (error) => {
         socket.off("connect", onConnect);
@@ -21094,12 +21343,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((resolve29, reject) => {
+    return new Promise((resolve30, 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: resolve29, reject, timer });
+      this.pending.set(request.requestId, { resolve: resolve30, reject, timer });
       let frame;
       try {
         frame = encodeControlFrame(BrokerRequestSchema.parse(request));
@@ -21503,8 +21752,8 @@ var ApprovalBridge = class {
   }
 };
 async function createProductionRuntime(options) {
-  const workspace = resolve28(options.workspace ?? process.cwd());
-  const home = resolve28(options.home ?? homedir2());
+  const workspace = resolve29(options.workspace ?? process.cwd());
+  const home = resolve29(options.home ?? homedir2());
   const environment = options.environment ?? process.env;
   const ide = new FlavorIdeClient({ workspace, home, environment });
   const ideReady = ide.initialize();
@@ -21747,8 +21996,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join26(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join26(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join27(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join27(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
@@ -21823,6 +22072,7 @@ async function createProductionRuntime(options) {
   let collaborationEventPump;
   let collaborationEventsOpen = true;
   let islandControlServer;
+  let sessionLease;
   const pumpCollaborationEvents = () => {
     if (collaborationEventPump !== void 0 || collaborationSession === void 0 || deliverCollaborationEvent === void 0) return;
     collaborationEventPump = (async () => {
@@ -21856,7 +22106,7 @@ async function createProductionRuntime(options) {
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join26(tmpdir4(), `flavor-code-pals-${createHash18("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join27(tmpdir4(), `flavor-code-pals-${createHash18("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -21967,8 +22217,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join26(home, ".flavor-code", "skills")],
-      projectRoots: [join26(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join27(home, ".flavor-code", "skills")],
+      projectRoots: [join27(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -21976,7 +22226,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(join26(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join27(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -22001,6 +22251,7 @@ async function createProductionRuntime(options) {
     const subagentStartedAt = {};
     const subagentElapsedMs = {};
     let sessionId = recovered?.sessionId ?? `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID20().slice(0, 8)}`;
+    sessionLease = await sessionStore.acquireLease(sessionId);
     hookSessionId = sessionId;
     let harnessJournal = new HarnessJournal({ workspace, sessionId });
     const harnessRecovery = harnessJournal.recover();
@@ -22318,7 +22569,7 @@ async function createProductionRuntime(options) {
       maxEntryChars: config.memory.maxEntryChars,
       scoreThreshold: config.memory.scoreThreshold,
       autoStoreThreshold: config.memory.autoStoreThreshold,
-      maxCandidates: Math.min(config.memory.maxCandidatesPerTask, 1),
+      maxCandidates: config.memory.maxCandidatesPerTask,
       ...config.language === void 0 ? {} : { language: config.language },
       generate: (prompt, signal) => generateMemoryExtraction(registry, childModel, prompt, signal)
     }) : void 0;
@@ -22557,7 +22808,7 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join26(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join27(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
@@ -22916,8 +23167,8 @@ async function createProductionRuntime(options) {
       explain: (query, focus, signal, onText) => runExplain({
         graph: new DesktopAstGraphService(workspace),
         readFile: async (path) => {
-          const root = resolve28(workspace);
-          const abs = resolve28(root, path);
+          const root = resolve29(workspace);
+          const abs = resolve29(root, path);
           if (abs !== root && !abs.startsWith(root + sep20)) throw new Error(`path outside workspace: ${path}`);
           return readFile22(abs, "utf8");
         },
@@ -22998,7 +23249,12 @@ ${summary2}`;
         for (const key of Object.keys(subagentStartedAt)) delete subagentStartedAt[key];
         for (const key of Object.keys(subagentElapsedMs)) delete subagentElapsedMs[key];
         const previousIdeSessionId = ideSessionId;
-        sessionId = `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID20().slice(0, 8)}`;
+        const nextSessionId = `session-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "").slice(0, 17)}-${randomUUID20().slice(0, 8)}`;
+        const nextLease = await sessionStore.acquireLease(nextSessionId);
+        const previousLease = sessionLease;
+        sessionLease = nextLease;
+        sessionId = nextSessionId;
+        await previousLease?.release();
         hookSessionId = sessionId;
         harnessJournal = new HarnessJournal({ workspace, sessionId });
         setUsageSession(sessionId);
@@ -23118,7 +23374,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join26(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join27(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -23165,7 +23421,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join26(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join27(home, ".flavor-code", "auth.json"));
         const tokens = await tokenStore.load();
         const hadCredentials = Object.keys(tokens).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -23245,24 +23501,13 @@ ${renderMemoryDocument(entries)}`;
       setPermissionProfile: (profile) => harness.setPermissionProfile(profile)
     };
     let disposed = false;
-    return {
-      session,
-      services,
-      authorization,
-      approvals,
-      memoryReviews,
-      restoredTranscript,
-      jobs: { list: () => jobs.list(), read: (id, owner2, cursor) => jobs.read(id, owner2, cursor), subscribe: (listener) => jobs.subscribe(listener) },
-      get sessionId() {
-        return sessionId;
-      },
-      get diagnostics() {
-        return diagnostics.map((item) => redactSecrets(item, secrets));
-      },
-      async dispose() {
-        if (disposed) return;
-        disposed = true;
-        const stepTimeoutMs = options.shutdownStepTimeoutMs ?? DEFAULT_SHUTDOWN_STEP_TIMEOUT_MS;
+    let unregisterCrashCleanup = () => void 0;
+    const disposeRuntime = async () => {
+      if (disposed) return;
+      disposed = true;
+      unregisterCrashCleanup();
+      const stepTimeoutMs = options.shutdownStepTimeoutMs ?? DEFAULT_SHUTDOWN_STEP_TIMEOUT_MS;
+      try {
         collaborationEventsOpen = false;
         unsubscribeCollaboration?.();
         if (collaborationEventPump !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "collaboration-event-pump", collaborationEventPump);
@@ -23281,8 +23526,29 @@ ${renderMemoryDocument(entries)}`;
         memoryReviews.dispose();
         if (collaborationClient !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "collaboration-close", collaborationClient.close());
         await cleanupProduction(approvals, questions, pluginHost, mcpManager, harness, { stepTimeoutMs });
+      } finally {
+        const lease = sessionLease;
+        sessionLease = void 0;
+        await lease?.release();
       }
     };
+    unregisterCrashCleanup = registerCrashCleanup(disposeRuntime);
+    return {
+      session,
+      services,
+      authorization,
+      approvals,
+      memoryReviews,
+      restoredTranscript,
+      jobs: { list: () => jobs.list(), read: (id, owner2, cursor) => jobs.read(id, owner2, cursor), subscribe: (listener) => jobs.subscribe(listener) },
+      get sessionId() {
+        return sessionId;
+      },
+      get diagnostics() {
+        return diagnostics.map((item) => redactSecrets(item, secrets));
+      },
+      dispose: disposeRuntime
+    };
   } catch (primaryError) {
     collaborationEventsOpen = false;
     mcpDiscarded = true;
@@ -23303,6 +23569,12 @@ ${renderMemoryDocument(entries)}`;
     } catch (cleanupError) {
       attachCleanupError(primaryError, cleanupError);
     }
+    try {
+      await sessionLease?.release();
+    } catch (leaseError) {
+      attachCleanupError(primaryError, leaseError);
+    }
+    sessionLease = void 0;
     throw primaryError;
   }
 }
@@ -23441,8 +23713,8 @@ 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 = resolve28(workspace, name);
-    const relativePath = relative20(resolve28(workspace), path);
+    const path = resolve29(workspace, name);
+    const relativePath = relative20(resolve29(workspace), path);
     if (relativePath === ".." || relativePath.startsWith(`..${sep20}`)) continue;
     hash.update(name);
     if (remaining <= 0) continue;
@@ -23575,8 +23847,8 @@ function requestMemoryRestart(workspace, sessionId, emitOutput) {
       previous = parseMemoryRestartMarker(readFileSync3(markerPath, "utf8"));
     } catch {
     }
-    mkdirSync3(dirname19(markerPath), { recursive: true });
-    writeFileSync(markerPath, `${JSON.stringify(nextMemoryRestartMarker(previous, sessionId, /* @__PURE__ */ new Date()))}
+    mkdirSync4(dirname19(markerPath), { recursive: true });
+    writeFileSync2(markerPath, `${JSON.stringify(nextMemoryRestartMarker(previous, sessionId, /* @__PURE__ */ new Date()))}
 `, "utf8");
   } catch {
   }
@@ -23677,7 +23949,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(join26(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join27(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -24113,6 +24385,7 @@ export {
   isDestructiveTool,
   redactErrorText,
   redactSecrets,
+  prepareSpawnInvocation,
   PluginManifestSchema,
   initializeFlavor,
   DEFAULT_MAX_OUTPUT_BYTES2 as DEFAULT_MAX_OUTPUT_BYTES,
@@ -24132,6 +24405,7 @@ export {
   COMMAND_DESCRIPTIONS,
   AgentMessageQueue,
   FlavorSession,
+  installCrashGuard,
   classifyMemoryHeat,
   MemoryStore,
   buildDockerInvocation,