flavor-code 1.3.23 → 1.4.0-beta.1

package/dist/desktop/main.js

@@ -1,8 +1,8 @@
 // src/desktop/main.ts
 import { appendFileSync } from "fs";
 import { createHash as createHash28, randomUUID as randomUUID29 } from "crypto";
-import { readFile as readFile39, stat as stat18, writeFile as writeFile19 } from "fs/promises";
-import { basename as basename11, dirname as dirname25, join as join48, resolve as resolve41 } from "path";
+import { readFile as readFile40, stat as stat19, writeFile as writeFile19 } from "fs/promises";
+import { basename as basename12, dirname as dirname25, join as join50, resolve as resolve42 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { app, BrowserWindow as BrowserWindow2, clipboard, dialog, ipcMain, Menu, nativeImage, Notification, shell } from "electron";
 
@@ -1990,7 +1990,7 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
         const ready = await candidate.executeJavaScript("document.readyState", false).catch(() => void 0);
         if (ready === "complete" || ready === "interactive") return candidate;
       }
-      await new Promise((resolve42) => setTimeout(resolve42, pollIntervalMs));
+      await new Promise((resolve43) => setTimeout(resolve43, pollIntervalMs));
     }
     throw new Error(`D2C embedded preview did not navigate within ${navigationTimeoutMs} ms: ${url}${observedUrl === void 0 ? "" : `; last observed ${observedUrl}`}${observedFrames.length === 0 ? "; no live frames" : `; live frames ${observedFrames.join(", ")}`}`);
   };
@@ -2005,13 +2005,13 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
     while (Date.now() <= deadline) {
       last = await frame(baseUrl).executeJavaScript(assertionScript(step), true);
       if (last.passed) return last;
-      await new Promise((resolve42) => setTimeout(resolve42, 50));
+      await new Promise((resolve43) => setTimeout(resolve43, 50));
     }
     return last;
   };
   const settleAfterAction = async (previousUrl) => {
     const origin = new URL(previousUrl).origin;
-    await new Promise((resolve42) => setTimeout(resolve42, Math.min(180, Math.max(20, visualDelayMs * 0.25))));
+    await new Promise((resolve43) => setTimeout(resolve43, Math.min(180, Math.max(20, visualDelayMs * 0.25))));
     const deadline = Date.now() + Math.min(2e3, navigationTimeoutMs);
     while (Date.now() <= deadline) {
       const candidate = host().mainFrame.framesInSubtree.find((item) => !item.isDestroyed() && sameOrigin(item.url, origin));
@@ -2019,7 +2019,7 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
         const ready = await candidate.executeJavaScript("document.readyState", false).catch(() => void 0);
         if (ready === "complete" || ready === "interactive") return candidate;
       }
-      await new Promise((resolve42) => setTimeout(resolve42, pollIntervalMs));
+      await new Promise((resolve43) => setTimeout(resolve43, pollIntervalMs));
     }
     throw new Error("D2C preview frame was unavailable after an interaction action");
   };
@@ -2106,7 +2106,7 @@ function createEmbeddedD2cAutomation(getHost, options = {}) {
             return result;
           },
           settle: async () => {
-            await new Promise((resolve42) => setTimeout(resolve42, 150));
+            await new Promise((resolve43) => setTimeout(resolve43, 150));
             requests = await frame(activeUrl).executeJavaScript(`performance.getEntriesByType("resource").filter((entry) => {
               try { return ["fetch", "xmlhttprequest"].includes(entry.initiatorType) && new URL(entry.name).origin === ${JSON.stringify(mockOrigin)}; } catch { return false; }
             }).length`, false).catch(() => 0);
@@ -2192,7 +2192,7 @@ function responseText(protocol, value) {
   }
   throw new Error("D2C Judge response did not contain text output");
 }
-function createD2cJudgeClient(fetcher = globalThis.fetch, retryDelay = (ms) => new Promise((resolve42) => setTimeout(resolve42, ms))) {
+function createD2cJudgeClient(fetcher = globalThis.fetch, retryDelay = (ms) => new Promise((resolve43) => setTimeout(resolve43, ms))) {
   const request = async (config, prompt, images, maxTokens) => {
     const openAi = config.protocol === "openai-compatible";
     const imageContent = openAi ? images.map((image) => ({ type: "image_url", image_url: { url: dataUrl(image), detail: "high" } })) : images.map((image) => ({ type: "image", source: { type: "base64", media_type: "image/png", data: image.toString("base64") } }));
@@ -2551,7 +2551,7 @@ import { z as z7 } from "zod";
 import { Worker } from "worker_threads";
 function comparePngsInWorker(left, right, signal) {
   signal?.throwIfAborted();
-  return new Promise((resolve42, reject) => {
+  return new Promise((resolve43, reject) => {
     const worker = new Worker(new URL("./pixel-worker.js", import.meta.url));
     let settled = false;
     const finish = (callback) => {
@@ -2569,7 +2569,7 @@ function comparePngsInWorker(left, right, signal) {
         finish(() => reject(new Error(value.error ?? "D2C pixel worker failed")));
         return;
       }
-      finish(() => resolve42({ ...value.result, heatmapPng: Buffer.from(value.result.heatmapPng) }));
+      finish(() => resolve43({ ...value.result, heatmapPng: Buffer.from(value.result.heatmapPng) }));
     });
     worker.once("error", (error) => finish(() => reject(error)));
     worker.once("exit", (code) => {
@@ -4225,11 +4225,11 @@ ${summarizeReport(report2)}`).join("\n\n")
 }
 
 // src/production.ts
-import { readFile as readFile27 } from "fs/promises";
+import { readFile as readFile28 } from "fs/promises";
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { createHash as createHash21, randomUUID as randomUUID25 } from "crypto";
-import { homedir as homedir2, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
-import { basename as basename8, dirname as dirname24, join as join35, relative as relative23, resolve as resolve34, sep as sep23 } from "path";
+import { homedir as homedir3, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
+import { basename as basename9, dirname as dirname24, join as join37, relative as relative24, resolve as resolve35, sep as sep24 } from "path";
 
 // src/agent/subagents.ts
 import { z as z10 } from "zod";
@@ -4442,12 +4442,12 @@ function hasCycle(nodes) {
 
 // src/utils/async.ts
 function withTimeout(promise, ms) {
-  return new Promise((resolve42, reject) => {
+  return new Promise((resolve43, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      resolve42({ timedOut: true, value: void 0 });
+      resolve43({ timedOut: true, value: void 0 });
     }, ms);
     timer.unref?.();
     promise.then(
@@ -4455,7 +4455,7 @@ function withTimeout(promise, ms) {
         if (!settled) {
           settled = true;
           clearTimeout(timer);
-          resolve42({ timedOut: false, value });
+          resolve43({ timedOut: false, value });
         }
       },
       (error) => {
@@ -4470,13 +4470,13 @@ function withTimeout(promise, ms) {
 }
 function awaitWithSignal3(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve42, reject) => {
+  return new Promise((resolve43, reject) => {
     const onAbort = () => reject(signal.reason);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve42(value);
+        resolve43(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -5000,7 +5000,7 @@ async function loadConfig(options) {
       process.env[key] = value;
     }
   }
-  await seedGlobalEnv(globalEnvPath);
+  if (options.seedGlobalEnv !== false) await seedGlobalEnv(globalEnvPath);
   const projectRead = await readJsonIfPresent(projectPath);
   const projectConfig = projectRead?.value;
   if (projectRead) sources.push(projectRead.source);
@@ -6525,10 +6525,10 @@ function sanitize(message2, secrets) {
 }
 function waitForRetry(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve42, reject) => {
+  return new Promise((resolve43, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve42();
+      resolve43();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -7166,10 +7166,10 @@ function serializeToolInput(input) {
 }
 function waitForRetry2(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve42, reject) => {
+  return new Promise((resolve43, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve42();
+      resolve43();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -8026,8 +8026,8 @@ var ToolRuntime = class {
     const limited = await this.#limitOutput(tool, content);
     return typeof limited === "string" ? limited : serializeToolOutput(limited);
   }
-  async #fail(toolCallId, tool, input, agent, code, errorMessage3) {
-    const result = { ok: false, error: { code, message: errorMessage3 } };
+  async #fail(toolCallId, tool, input, agent, code, errorMessage4) {
+    const result = { ok: false, error: { code, message: errorMessage4 } };
     try {
       await this.#hooks.emit({
         version: 1,
@@ -8715,16 +8715,16 @@ var HookDecisionSchema = z16.object({
 });
 
 // src/utils/spawn-executable.ts
-import { existsSync as existsSync3, statSync as statSync2 } from "fs";
-import { extname as extname2, isAbsolute as isAbsolute6, resolve as resolve9 } from "path";
-var WINDOWS_EXECUTABLE = /\.(?:com|exe)$/iu;
+import { accessSync, constants as constants3, existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { delimiter, extname as extname2, isAbsolute as isAbsolute6, resolve as resolve9 } from "path";
+var WINDOWS_BATCH = /\.(?:bat|cmd)$/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)) {
+  const commandFile = resolveExecutablePath(command, options);
+  if (commandFile === void 0 || !WINDOWS_BATCH.test(commandFile)) {
     return { command: commandFile ?? command, args: [...args] };
   }
   const doubleEscape = WINDOWS_CMD_SHIM.test(commandFile);
@@ -8735,11 +8735,22 @@ function prepareSpawnInvocation(command, args, options = {}) {
     windowsVerbatimArguments: true
   };
 }
+function resolveExecutablePath(command, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  if (platform === "win32") return resolveWindowsCommand(command, options.cwd, env);
+  const hasPath = isAbsolute6(command) || command.includes("/");
+  const bases = hasPath ? [isAbsolute6(command) ? command : resolve9(options.cwd ?? process.cwd(), command)] : (env.PATH ?? "").split(delimiter).filter(Boolean).map((entry2) => resolve9(entry2, command));
+  return bases.find(isExecutableFile);
+}
 function resolveWindowsCommand(command, cwd, env) {
   const pathValue = environmentValue(env, "PATH") ?? "";
   const pathExt = (environmentValue(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
   const hasPath = isAbsolute6(command) || /[\\/]/u.test(command);
-  const bases = hasPath ? [isAbsolute6(command) ? command : resolve9(cwd ?? process.cwd(), command)] : pathValue.split(";").filter(Boolean).map((entry2) => resolve9(unquote(entry2), command));
+  const bases = hasPath ? [isAbsolute6(command) ? command : resolve9(cwd ?? process.cwd(), command)] : [
+    resolve9(cwd ?? process.cwd(), command),
+    ...pathValue.split(";").filter(Boolean).map((entry2) => resolve9(unquote(entry2), command))
+  ];
   for (const base of bases) {
     const candidates = extname2(base).length > 0 ? [base] : [base, ...pathExt.map((extension2) => `${base}${extension2}`)];
     for (const candidate of candidates) {
@@ -8763,6 +8774,15 @@ function isRegularFile(path) {
     return false;
   }
 }
+function isExecutableFile(path) {
+  try {
+    if (!existsSync3(path) || !statSync2(path).isFile()) return false;
+    accessSync(path, constants3.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function escapeCmdCommand(value) {
   return value.replace(CMD_META, "^$1");
 }
@@ -8878,7 +8898,7 @@ function decoratePayload(payload, envelope) {
   return envelope === void 0 ? payload : { ...payload, ...envelope };
 }
 function runShellHandler(descriptor, event, signal) {
-  return new Promise((resolve42, reject) => {
+  return new Promise((resolve43, reject) => {
     const env = { ...process.env, ...descriptor.env };
     const invocation = prepareSpawnInvocation(descriptor.command, descriptor.args ?? [], { env });
     const child = spawn(invocation.command, invocation.args, {
@@ -8924,7 +8944,7 @@ function runShellHandler(descriptor, event, signal) {
         return;
       }
       try {
-        resolve42(HookDecisionSchema.parse(JSON.parse(stdout)));
+        resolve43(HookDecisionSchema.parse(JSON.parse(stdout)));
       } catch (error) {
         reject(error);
       }
@@ -8963,7 +8983,7 @@ function zodRecord(payload) {
 // src/utils/execFileNoThrow.ts
 import { execFile } from "child_process";
 function execFileNoThrow(file, args, options = {}) {
-  return new Promise((resolve42) => {
+  return new Promise((resolve43) => {
     const child = execFile(file, args, {
       timeout: options.timeout,
       cwd: options.useCwd === false ? void 0 : process.cwd(),
@@ -8971,7 +8991,7 @@ function execFileNoThrow(file, args, options = {}) {
       encoding: "utf8",
       windowsHide: true
     }, (error, stdout, stderr) => {
-      resolve42({
+      resolve43({
         stdout,
         stderr,
         code: typeof error?.code === "number" ? error.code : error ? 1 : 0,
@@ -9143,14 +9163,14 @@ async function createIslandControlServer(options) {
       void dispatch(line, socket, options, token);
     });
   });
-  await new Promise((resolve42, reject) => {
+  await new Promise((resolve43, reject) => {
     const onError = (error) => {
       server.removeListener("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve42();
+      resolve43();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -9221,11 +9241,11 @@ function write(socket, payload) {
   }
 }
 function closeServer(server) {
-  return new Promise((resolve42) => {
+  return new Promise((resolve43) => {
     try {
-      server.close(() => resolve42());
+      server.close(() => resolve43());
     } catch {
-      resolve42();
+      resolve43();
     }
   });
 }
@@ -10117,8 +10137,8 @@ import { dirname as dirname8, join as join11 } from "path";
 function normalizeError(message2) {
   return String(message2 ?? "").replace(/\s+/g, " ").replace(/"[^"]*"/g, '"\u2026"').replace(/`[^`]*`/g, '"\u2026"').trim().slice(0, 160);
 }
-function fingerprint(tool, errorCode, error) {
-  return createHash9("sha1").update(`${tool}::${errorCode ?? ""}::${normalizeError(error)}`).digest("hex").slice(0, 12);
+function fingerprint(tool, errorCode3, error) {
+  return createHash9("sha1").update(`${tool}::${errorCode3 ?? ""}::${normalizeError(error)}`).digest("hex").slice(0, 12);
 }
 function argKeys(args) {
   if (args === null || typeof args !== "object") return [];
@@ -10410,7 +10430,7 @@ var USAGE = [
   "  clear     reset signals, done markers, and verified markers"
 ].join("\n");
 function runCommand(command, cwd, timeoutMs) {
-  return new Promise((resolve42) => {
+  return new Promise((resolve43) => {
     const isWindows = process.platform === "win32";
     const child = spawn2(isWindows ? "cmd.exe" : "/bin/sh", isWindows ? ["/d", "/s", "/c", command] : ["-c", command], {
       cwd,
@@ -10420,7 +10440,7 @@ function runCommand(command, cwd, timeoutMs) {
     let stderr = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve42({ ok: false, stdout, stderr: `${stderr}
+      resolve43({ ok: false, stdout, stderr: `${stderr}
 [killed: exceeded ${timeoutMs}ms]`, code: "timeout" });
     }, timeoutMs);
     child.stdout.on("data", (chunk) => {
@@ -10431,12 +10451,12 @@ function runCommand(command, cwd, timeoutMs) {
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve42({ ok: false, stdout, stderr: `${stderr}
+      resolve43({ ok: false, stdout, stderr: `${stderr}
 ${error.message}`, code: "spawn" });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve42({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
+      resolve43({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
     });
   });
 }
@@ -10513,12 +10533,12 @@ function createEvolveService(options) {
       logger.warn(`prompt section failed \u2014 ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  async function captureFailure(tool, errorCode, message2, args) {
+  async function captureFailure(tool, errorCode3, message2, args) {
     toolErrors += 1;
     runToolErrors[tool] = (runToolErrors[tool] ?? 0) + 1;
     const { record: record3 } = await store.recordSignal({
       tool,
-      ...errorCode === void 0 ? {} : { errorCode },
+      ...errorCode3 === void 0 ? {} : { errorCode: errorCode3 },
       error: message2,
       args
     });
@@ -10559,8 +10579,12 @@ function createEvolveService(options) {
         try {
           const stderr = typeof shell2.stderr === "string" ? shell2.stderr : "";
           const stdout = typeof shell2.stdout === "string" ? shell2.stdout : "";
-          const message2 = stderr.trim().slice(0, 300) || stdout.trim().slice(0, 300) || (exitCode === void 0 ? "shell timed out" : `exit code ${exitCode}`);
-          await captureFailure(tool, exitCode === void 0 ? "shell_exit_timeout" : `shell_exit_${exitCode}`, message2, payload.input);
+          const diagnostic = shell2.diagnostic !== null && typeof shell2.diagnostic === "object" ? shell2.diagnostic : void 0;
+          const diagnosticMessage = typeof diagnostic?.message === "string" ? diagnostic.message : "";
+          const diagnosticKind = typeof diagnostic?.kind === "string" ? diagnostic.kind : void 0;
+          const message2 = diagnosticMessage.trim().slice(0, 300) || stderr.trim().slice(0, 300) || stdout.trim().slice(0, 300) || (exitCode === void 0 ? "shell timed out" : `exit code ${exitCode}`);
+          const errorCode3 = diagnosticKind === void 0 ? exitCode === void 0 ? "shell_exit_timeout" : `shell_exit_${exitCode}` : `shell_${diagnosticKind}`;
+          await captureFailure(tool, errorCode3, message2, payload.input);
         } catch (error) {
           logger.warn(`shell capture failed \u2014 ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -12412,7 +12436,7 @@ function formatPriorGaps(gaps) {
 }
 
 // src/goal/store.ts
-import { constants as constants3 } from "fs";
+import { constants as constants4 } from "fs";
 import { randomUUID as randomUUID11 } from "crypto";
 import { lstat as lstat5, mkdir as mkdir11, open as open5, rename as rename4, rm as rm6 } from "fs/promises";
 import { dirname as dirname10, join as join16, relative as relative9, resolve as resolve12, sep as sep9 } from "path";
@@ -12440,7 +12464,7 @@ var GoalStore = class {
     const temporary = join16(this.#root, `.${state.id}.${process.pid}.${randomUUID11()}.tmp`);
     let handle;
     try {
-      handle = await open5(temporary, constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY, 384);
+      handle = await open5(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
       await handle.writeFile(body, "utf8");
       await handle.sync();
       await handle.close();
@@ -12547,7 +12571,7 @@ async function ensureWorktreeDirectoryIgnored(root) {
 }
 
 // src/loop/store.ts
-import { constants as constants4 } from "fs";
+import { constants as constants5 } from "fs";
 import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile12, realpath as realpath8, rename as rename5, rm as rm7, stat as stat6 } from "fs/promises";
 import { dirname as dirname11, join as join18, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
 import { randomUUID as randomUUID12 } from "crypto";
@@ -12584,7 +12608,7 @@ var LoopStore = class {
     const temporary = join18(directory, `.state.${process.pid}.${randomUUID12()}.tmp`);
     let handle;
     try {
-      handle = await open6(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
+      handle = await open6(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
       await handle.writeFile(body, "utf8");
       await handle.sync();
       await handle.close();
@@ -12618,7 +12642,7 @@ var LoopStore = class {
     const next = previous.catch(() => void 0).then(async () => {
       const directory = await this.#prepare(event.loopId);
       const path = join18(directory, "events.jsonl");
-      const handle = await open6(path, constants4.O_CREAT | constants4.O_APPEND | constants4.O_WRONLY, 384);
+      const handle = await open6(path, constants5.O_CREAT | constants5.O_APPEND | constants5.O_WRONLY, 384);
       try {
         await handle.writeFile(`${JSON.stringify(event)}
 `, "utf8");
@@ -12691,11 +12715,12 @@ function isCode5(error, code) {
 
 // src/loop/verifier.ts
 import { readFile as readFile13 } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 
 // src/tools/shell.ts
-import { spawn as spawn3, spawnSync } from "child_process";
-import { isAbsolute as isAbsolute9, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
+import { spawn as spawn3 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { basename as basename5, delimiter as delimiter2, isAbsolute as isAbsolute9, join as join19, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
 import { z as z23 } from "zod";
 
 // src/tools/jobs.ts
@@ -12784,8 +12809,8 @@ var TERMINATION_GRACE_MS = 250;
 var TERMINATION_FAILURE_MS = 5e3;
 var STREAM_CLOSE_GRACE_MS = 500;
 var ShellInput = z23.object({
-  command: z23.string().min(1),
-  args: z23.array(z23.string()),
+  command: z23.string().trim().min(1).refine((value) => !value.includes("\0"), "command cannot contain a null byte").describe("Executable name or path. Put each argument in args; use a shell expression here only for pipes, redirects, or other shell syntax."),
+  args: z23.array(z23.string().refine((value) => !value.includes("\0"), "argument cannot contain a null byte").describe("One logical argument without surrounding shell quotes.")),
   cwd: z23.string().min(1).nullable().optional(),
   timeoutMs: z23.coerce.number().int().positive().max(864e5).nullable().optional(),
   // Accepts booleans and their string forms (weak-typed models emit "true");
@@ -12793,23 +12818,39 @@ var ShellInput = z23.object({
   background: z23.union([z23.boolean(), z23.string().refine((value) => value === "true" || value === "false")]).optional()
 });
 function normalizeShellCommand(input) {
-  const { command, args } = input;
-  if (!/\s/.test(command)) return { command, args: [...args] };
+  const command = unquoteToken(input.command.trim());
+  const args = [...input.args];
+  const executable = basename5(command).toLowerCase();
+  if ((executable === "cmd" || executable === "cmd.exe") && /^\/[ck]$/iu.test(args[0] ?? "")) {
+    return { command, args: [args[0], ...args.slice(1).map(unquoteToken)] };
+  }
+  if ((executable === "pwsh" || executable === "pwsh.exe" || executable === "powershell" || executable === "powershell.exe") && /^(?:-c|-command)$/iu.test(args[0] ?? "") && args.length > 1) {
+    return { command, args: [args[0], ...args.slice(1).map(unquoteToken)] };
+  }
+  if (/^(?:sh|bash|zsh|fish)$/iu.test(executable) && args[0] === "-c" && args[1] !== void 0) {
+    return { command, args: [args[0], unquoteToken(args[1]), ...args.slice(2)] };
+  }
+  if (!/\s/u.test(command) || containsShellSyntax(command)) return { command, args };
   const tokens2 = tokenizeCommandLine(command);
-  if (tokens2.length <= 1) return { command, args: [...args] };
+  if (tokens2.length <= 1) return { command, args };
   const head = unquoteToken(tokens2[0]);
-  if (head.includes("/") || head.includes("\\")) return { command, args: [...args] };
+  if (head.includes("/") || head.includes("\\")) return { command, args };
   return { command: head, args: [...tokens2.slice(1).map(unquoteToken), ...args] };
 }
 function tokenizeCommandLine(command) {
   const tokens2 = [];
   let current = "";
-  let inQuote = false;
-  for (const char of command) {
-    if (char === '"') {
-      inQuote = !inQuote;
+  let quote;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (char === "\\" && quote === '"' && command[index + 1] !== void 0) {
+      current += `${char}${command[index + 1]}`;
+      index += 1;
+    } else if (char === '"' || char === "'") {
+      if (quote === void 0) quote = char;
+      else if (quote === char) quote = void 0;
       current += char;
-    } else if (char === " " && !inQuote) {
+    } else if (/\s/u.test(char) && quote === void 0) {
       if (current !== "") {
         tokens2.push(current);
         current = "";
@@ -12822,33 +12863,190 @@ function tokenizeCommandLine(command) {
   return tokens2;
 }
 function unquoteToken(token) {
-  return token.length >= 2 && token.startsWith('"') && token.endsWith('"') ? token.slice(1, -1) : token;
+  const trimmed = token.trim();
+  if (trimmed.length < 2) return trimmed;
+  const first = trimmed[0];
+  return (first === '"' || first === "'") && trimmed.endsWith(first) ? trimmed.slice(1, -1) : trimmed;
+}
+function serializeCmdCommand(args) {
+  return args.map((arg) => {
+    const value = unquoteToken(arg);
+    return /[\s&|<>^()]/u.test(value) ? `"${value.replace(/"/gu, '""')}"` : value;
+  }).join(" ");
+}
+function serializeCmdPayload(args) {
+  if (args.length === 1) return unquoteToken(args[0]);
+  return args.map((arg) => /^(?:&&|\|\||[|&<>])$/u.test(arg) ? arg : serializeCmdCommand([arg])).join(" ");
+}
+function containsShellSyntax(command, platform = process.platform) {
+  let quote;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (quote !== void 0) {
+      if (char === quote) quote = void 0;
+      else if (char === "\\" && quote === '"') index += 1;
+      else if (char === "$" && quote === '"') return true;
+      continue;
+    }
+    if (char === "\\" && platform !== "win32") {
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/[|&;<>`$*?()\n\r]/u.test(char)) return true;
+    if (char === "[" && command.indexOf("]", index + 1) > index) return true;
+    if (char === "~" && (index === 0 || /\s/u.test(command[index - 1])) && /[\\/]/u.test(command[index + 1] ?? "")) return true;
+    if (platform === "win32" && char === "%" && /^%[A-Za-z_][A-Za-z0-9_]*%/u.test(command.slice(index))) return true;
+  }
+  return quote !== void 0;
 }
-var cachedWindowsShell;
-function hasExecutable(name) {
-  try {
-    return spawnSync("where", [name], { stdio: "ignore", windowsHide: true }).status === 0;
-  } catch {
-    return false;
+function hasUnmatchedShellQuote(command) {
+  let quote;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    if (char === "\\" && quote !== "'") {
+      index += 1;
+      continue;
+    }
+    if (char !== '"' && char !== "'") continue;
+    if (quote === void 0) quote = char;
+    else if (quote === char) quote = void 0;
   }
+  return quote !== void 0;
 }
-function detectWindowsShell() {
-  if (cachedWindowsShell !== void 0) return cachedWindowsShell;
-  cachedWindowsShell = hasExecutable("pwsh") ? "pwsh" : hasExecutable("powershell") ? "powershell" : "cmd";
-  return cachedWindowsShell;
+function resolveRuntimeShell(platform = process.platform, environment = process.env) {
+  if (platform === "win32") {
+    for (const candidate of ["pwsh", "powershell"]) {
+      const command2 = resolveExecutablePath(candidate, { platform: "win32", env: environment });
+      if (command2 !== void 0) return { kind: candidate, command: command2 };
+    }
+    const configured = environment.ComSpec ?? environment.COMSPEC ?? "cmd.exe";
+    const command = resolveExecutablePath(configured, { platform: "win32", env: environment });
+    return command === void 0 ? void 0 : { kind: "cmd", command };
+  }
+  for (const candidate of [environment.SHELL, "/bin/sh"]) {
+    if (!candidate) continue;
+    const command = resolveExecutablePath(candidate, { platform, env: environment });
+    if (command !== void 0) return { kind: "posix", command };
+  }
+  return void 0;
 }
 function psQuote(token) {
   return `'${token.replace(/'/g, "''")}'`;
 }
-function buildWindowsCommandLine(kind, commandLine, command, args) {
-  if (kind === "cmd") return `chcp 65001>nul & ${commandLine}`;
-  const executable = kind === "pwsh" ? "pwsh" : "powershell";
-  const script = `& ${psQuote(command)}${args.length > 0 ? ` ${args.map(psQuote).join(" ")}` : ""}; exit $LASTEXITCODE`;
+function shellInvocation(input, cwd, environment) {
+  const resolved = resolveExecutablePath(input.command, { cwd, env: environment });
+  if (resolved !== void 0) {
+    const executable = basename5(resolved).toLowerCase();
+    if (process.platform === "win32" && (executable === "cmd" || executable === "cmd.exe")) {
+      const commandFlag = input.args.findIndex((arg) => /^\/[ck]$/iu.test(arg));
+      if (commandFlag >= 0 && input.args[commandFlag + 1] !== void 0) {
+        const payload = serializeCmdPayload(input.args.slice(commandFlag + 1));
+        return {
+          command: resolved,
+          args: [...input.args.slice(0, commandFlag + 1), `chcp 65001>nul & ${payload}`]
+        };
+      }
+    }
+    return prepareSpawnInvocation(resolved, input.args, { cwd, env: environment });
+  }
+  const isScript = containsShellSyntax(input.command);
+  if (!isScript && (isAbsolute9(input.command) || /[\\/]/u.test(input.command))) {
+    return { command: input.command, args: [...input.args] };
+  }
+  const shell2 = resolveRuntimeShell(process.platform, environment);
+  if (shell2 === void 0) return { command: input.command, args: [...input.args] };
+  const script = isScript ? appendShellArguments(shell2, input.command, input.args) : structuredShellScript(shell2, input.command, input.args);
+  if (shell2.kind === "posix") return { command: shell2.command, args: ["-c", script] };
+  if (shell2.kind === "cmd") return {
+    command: shell2.command,
+    args: ["/d", "/s", "/c", `chcp 65001>nul & ${script}`]
+  };
   const encoded = Buffer.from(script, "utf16le").toString("base64");
-  return `chcp 65001>nul & ${executable} -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`;
+  return {
+    command: shell2.command,
+    args: ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand", encoded]
+  };
+}
+function appendShellArguments(shell2, script, args) {
+  if (args.length === 0) return script;
+  if (shell2.kind === "posix") return `${script} ${args.map(posixQuote).join(" ")}`;
+  if (shell2.kind === "cmd") return `${script} ${serializeCmdCommand(args)}`;
+  return `${script} ${args.map(psQuote).join(" ")}`;
+}
+var POSIX_SHELL_BUILTINS = /* @__PURE__ */ new Set([".", ":", "alias", "cd", "command", "eval", "exec", "export", "read", "set", "source", "trap", "type", "ulimit", "umask", "unalias", "unset", "wait"]);
+function executionEnvironmentCommand(environment, command, args) {
+  if (environment.kind !== "docker") return { command, args: [...args] };
+  const script = containsShellSyntax(command, "linux") ? appendShellArguments({ kind: "posix", command: "/bin/sh" }, command, args) : POSIX_SHELL_BUILTINS.has(command) ? structuredShellScript({ kind: "posix", command: "/bin/sh" }, command, args) : void 0;
+  return script === void 0 ? { command, args: [...args] } : { command: "/bin/sh", args: ["-c", script] };
+}
+function structuredShellScript(shell2, command, args) {
+  if (shell2.kind === "posix") return [command, ...args].map(posixQuote).join(" ");
+  if (shell2.kind === "cmd") return serializeCmdCommand([command, ...args]);
+  const invocation = `& ${psQuote(command)}${args.length > 0 ? ` ${args.map(psQuote).join(" ")}` : ""}`;
+  return `$ErrorActionPreference='Stop'; try { ${invocation}; if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 0 } } catch { [Console]::Error.WriteLine($_.Exception.Message); exit 127 }`;
+}
+function posixQuote(value) {
+  return `'${value.replace(/'/gu, `'"'"'`)}'`;
+}
+function withShellDiagnostic(result, command, spawnError) {
+  const diagnostic = classifyShellFailure(result, command, spawnError);
+  if (diagnostic === void 0) return result;
+  return { ...result, diagnostic };
+}
+function classifyShellFailure(result, command, spawnError) {
+  if (result.terminationReason === "timeout") return {
+    kind: "timeout",
+    message: `Command exceeded its timeout and was terminated.`,
+    hint: "Increase timeoutMs only if this command is expected to take longer."
+  };
+  if (result.terminationReason === "cancelled") return { kind: "cancelled", message: "Command was cancelled." };
+  if (result.exitCode === 0 && result.signal === null && spawnError === void 0) return void 0;
+  if (hasUnmatchedShellQuote(command)) return {
+    kind: "shell-syntax",
+    message: "The command contains an unmatched shell quote.",
+    hint: "Close the quoted value, or pass it as one unquoted args item when shell expansion is not required."
+  };
+  const detail = `${spawnError?.message ?? ""}
+${result.stderr}`;
+  const code = errorCode(spawnError);
+  if (code === "ENOENT" && (isAbsolute9(command) || /[\\/]/u.test(command))) {
+    return { kind: "path-not-found", message: `Executable path "${command}" does not exist.` };
+  }
+  if (code === "ENOENT" || /(?:not recognized as (?:an internal|(?:a|the) name)|command not found|not found\s*$|无法将.+识别为|不是内部或外部命令)/imu.test(detail)) {
+    return {
+      kind: "command-not-found",
+      message: `Executable "${command}" was not found by the selected runtime shell.`,
+      hint: "Use a command available on PATH, or pass an existing executable path without surrounding quotes."
+    };
+  }
+  if (code === "EACCES" || /(?:permission denied|access is denied|拒绝访问)/iu.test(detail)) {
+    return { kind: "permission-denied", message: `Command "${command}" could not be executed because access was denied.` };
+  }
+  if (/(?:no such file or directory|cannot find (?:the )?path|system cannot find|系统找不到指定的路径)/iu.test(detail)) {
+    return { kind: "path-not-found", message: "The command referenced a path that does not exist." };
+  }
+  if (/(?:syntax error|unexpected token|parsererror|语法错误)/iu.test(detail)) {
+    return {
+      kind: "shell-syntax",
+      message: "The selected runtime shell rejected the command syntax.",
+      hint: "Pass normal arguments through args; reserve shell syntax for pipes, redirects, and operators."
+    };
+  }
+  return {
+    kind: "non-zero-exit",
+    message: result.signal === null ? `Command exited with code ${result.exitCode ?? "unknown"}.` : `Command was terminated by signal ${result.signal}.`
+  };
+}
+function errorCode(error) {
+  return error instanceof Error && "code" in error ? String(error.code) : void 0;
 }
 function createShellTool(workspace, options = {}) {
   const root = resolve15(workspace);
+  const environment = shellEnvironment(root, options.environment ?? process.env);
   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");
@@ -12857,7 +13055,7 @@ function createShellTool(workspace, options = {}) {
   }
   return {
     name: "Shell",
-    description: "Run a bounded command with an argument array inside the workspace; background=true returns a managed job id",
+    description: "Run a bounded command reliably inside the workspace. Pass a bare executable in command and one unquoted logical value per args entry; shell syntax is supported only when command contains pipes, redirects, or operators. stdout/stderr are returned verbatim and failures include a structured diagnostic. background=true returns a managed job id.",
     inputSchema: ShellInput,
     paths: (input) => [workingDirectory(root, input.cwd ?? void 0)],
     summarize: (input) => [input.command, ...input.args].join(" "),
@@ -12878,7 +13076,7 @@ function createShellTool(workspace, options = {}) {
       jobKind: "shell",
       label: [input.command, ...input.args].join(" "),
       state: "running"
-    } : { kind: "terminal", variant: "command", title: [input.command, ...input.args].join(" "), command: [input.command, ...input.args].join(" "), stdout: output.stdout, stderr: output.stderr, exitCode: output.exitCode, state: output.terminationReason === "cancelled" ? "cancelled" : output.exitCode === 0 ? "completed" : "failed", truncated: output.truncated },
+    } : { kind: "terminal", variant: "command", title: [input.command, ...input.args].join(" "), command: [input.command, ...input.args].join(" "), stdout: output.stdout, stderr: output.stderr, ...output.diagnostic === void 0 ? {} : { diagnostic: output.diagnostic.message }, exitCode: output.exitCode, state: output.terminationReason === "cancelled" ? "cancelled" : output.exitCode === 0 ? "completed" : "failed", truncated: output.truncated },
     execute: async (input, signal, context) => {
       const normalized = normalizeShellCommand(input);
       const effective = { ...input, command: normalized.command, args: normalized.args };
@@ -12896,19 +13094,23 @@ function createShellTool(workspace, options = {}) {
           try {
             let result2;
             if (options.executionEnvironment === void 0) {
-              result2 = await executeShell(root, { ...effective, timeoutMs }, cancellation.signal, maxBytes, (stream, text) => job.append(stream === "stderr" ? `[stderr] ${text}` : text));
+              result2 = await executeShell(root, { ...effective, timeoutMs }, cancellation.signal, maxBytes, environment, (stream, text) => job.append(stream === "stderr" ? `[stderr] ${text}` : text));
             } else {
+              const invocation2 = executionEnvironmentCommand(options.executionEnvironment, effective.command, effective.args);
               const raw = await options.executionEnvironment.exec({
-                command: effective.command,
-                args: effective.args,
+                ...invocation2,
                 cwd: workingDirectory(root, effective.cwd ?? void 0),
-                timeoutMs
+                timeoutMs,
+                maxOutputBytes: maxBytes
               }, cancellation.signal);
-              job.append(raw.stdout);
-              if (raw.stderr !== "") job.append(`[stderr] ${raw.stderr}`);
-              result2 = { ...raw, truncated: false, truncation: { stdout: { truncated: false, originalBytes: Buffer.byteLength(raw.stdout), limitBytes: maxBytes }, stderr: { truncated: false, originalBytes: Buffer.byteLength(raw.stderr), limitBytes: maxBytes } } };
+              result2 = boundedExecutionResult(raw, maxBytes, effective.command);
+              job.append(result2.stdout);
+              if (result2.stderr !== "") job.append(`[stderr] ${result2.stderr}`);
             }
-            job.complete({ exitCode: result2.exitCode });
+            job.complete({
+              exitCode: result2.exitCode,
+              ...result2.diagnostic === void 0 ? {} : { error: result2.diagnostic.message }
+            });
           } catch (error) {
             job.fail(error);
           }
@@ -12930,32 +13132,20 @@ function createShellTool(workspace, options = {}) {
         };
       }
       if (options.executionEnvironment === void 0) {
-        return executeShell(root, { ...effective, timeoutMs }, signal, maxBytes);
+        return executeShell(root, { ...effective, timeoutMs }, signal, maxBytes, environment);
       }
+      const invocation = executionEnvironmentCommand(options.executionEnvironment, effective.command, effective.args);
       const result = await options.executionEnvironment.exec({
-        command: effective.command,
-        args: effective.args,
+        ...invocation,
         cwd: workingDirectory(root, effective.cwd ?? void 0),
-        timeoutMs
+        timeoutMs,
+        maxOutputBytes: maxBytes
       }, signal);
-      const stdout = new BoundedOutput(maxBytes);
-      const stderr = new BoundedOutput(maxBytes);
-      stdout.add(Buffer.from(result.stdout));
-      stderr.add(Buffer.from(result.stderr));
-      return {
-        ...result,
-        stdout: stdout.text(),
-        stderr: stderr.text(),
-        truncated: stdout.truncated || stderr.truncated,
-        truncation: {
-          stdout: stdout.metadata(),
-          stderr: stderr.metadata()
-        }
-      };
+      return boundedExecutionResult(result, maxBytes, effective.command);
     }
   };
 }
-async function executeShell(root, input, cancellation, maxBytes, onOutput) {
+async function executeShell(root, input, cancellation, maxBytes, environment = process.env, onOutput) {
   const cwd = workingDirectory(root, input.cwd ?? void 0);
   const stdout = new BoundedOutput(maxBytes);
   const stderr = new BoundedOutput(maxBytes);
@@ -12964,15 +13154,14 @@ async function executeShell(root, input, cancellation, maxBytes, onOutput) {
       reject(cancellation.reason);
       return;
     }
-    const quoteArg = (s) => s.includes(" ") ? `"${s.replace(/"/g, '""')}"` : s;
-    const quoted = input.args.map(quoteArg).join(" ");
-    const commandLine = quoted.length > 0 ? `${quoteArg(input.command)} ${quoted}` : quoteArg(input.command);
-    const shellCommandLine = process.platform === "win32" ? buildWindowsCommandLine(detectWindowsShell(), commandLine, input.command, input.args) : commandLine;
-    const child = spawn3(shellCommandLine, {
+    const invocation = shellInvocation(input, cwd, environment);
+    const child = spawn3(invocation.command, invocation.args, {
       cwd,
-      shell: true,
+      shell: false,
       windowsHide: true,
-      detached: process.platform !== "win32"
+      detached: process.platform !== "win32",
+      env: environment,
+      ...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments }
     });
     let exitObserved = false;
     let observedExitCode = null;
@@ -13033,12 +13222,12 @@ async function executeShell(root, input, cancellation, maxBytes, onOutput) {
       streamCloseTimer.unref();
     });
     child.once("error", (error) => {
-      finishReject(error);
+      void finishResolve(errorCode(error) === "ENOENT" ? 127 : 1, null, error);
     });
     child.once("close", (exitCode, signal) => {
       void finishResolve(exitCode, signal);
     });
-    async function finishResolve(exitCode, exitSignal) {
+    async function finishResolve(exitCode, exitSignal, spawnError) {
       if (settled) return;
       settled = true;
       cleanup();
@@ -13047,7 +13236,7 @@ async function executeShell(root, input, cancellation, maxBytes, onOutput) {
       const stderrTail = stderrDecoder?.end() ?? "";
       if (stdoutTail !== "") onOutput?.("stdout", stdoutTail);
       if (stderrTail !== "") onOutput?.("stderr", stderrTail);
-      resolvePromise({
+      resolvePromise(withShellDiagnostic({
         exitCode,
         signal: exitSignal,
         stdout: stdout.text(),
@@ -13055,7 +13244,7 @@ async function executeShell(root, input, cancellation, maxBytes, onOutput) {
         truncated: stdout.truncated || stderr.truncated,
         truncation: { stdout: stdout.metadata(), stderr: stderr.metadata() },
         terminationReason
-      });
+      }, input.command, spawnError));
     }
     function finishReject(error) {
       if (settled) return;
@@ -13113,7 +13302,7 @@ var BoundedOutput = class {
   text() {
     if (!this.truncated) return decodeOutput(this.#complete);
     const tail = Buffer.concat(this.#tailChunks).subarray(-this.#tailLimit);
-    const encoding = classifyUtf8(this.#complete) === "invalid" && process.platform === "win32" ? "gb18030" : "utf-8";
+    const encoding = outputEncoding(this.#complete);
     return `${decodePrefix(this.#head, encoding)}${ELLIPSIS}${decodeSuffix(tail, encoding)}`;
   }
 };
@@ -13123,14 +13312,15 @@ var AdaptiveOutputDecoder = class {
   write(chunk) {
     if (this.#decoder !== void 0) return this.#decoder.decode(chunk, { stream: true });
     this.#pending = Buffer.concat([this.#pending, chunk]);
-    if (this.#pending.every((byte) => byte < 128)) {
+    if (this.#pending.length === 1 && (this.#pending[0] === 255 || this.#pending[0] === 254)) return "";
+    if (!this.#pending.includes(0) && this.#pending.every((byte) => byte < 128)) {
       const ascii = this.#pending.toString("ascii");
       this.#pending = Buffer.alloc(0);
       return ascii;
     }
     const classification = classifyUtf8(this.#pending);
     if (classification === "incomplete") return "";
-    const encoding = classification === "valid" || process.platform !== "win32" ? "utf-8" : "gb18030";
+    const encoding = outputEncoding(this.#pending, classification);
     this.#decoder = new TextDecoder(encoding);
     const text = this.#decoder.decode(this.#pending, { stream: true });
     this.#pending = Buffer.alloc(0);
@@ -13199,9 +13389,56 @@ function delay2(milliseconds) {
   return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
 }
 function decodeOutput(buffer) {
-  const encoding = classifyUtf8(buffer) === "invalid" && process.platform === "win32" ? "gb18030" : "utf-8";
+  const encoding = outputEncoding(buffer);
   return new TextDecoder(encoding).decode(buffer);
 }
+function shellEnvironment(root, environment) {
+  const localBin = join19(root, "node_modules", ".bin");
+  if (!existsSync4(localBin)) return environment;
+  const pathKey = Object.keys(environment).find((key) => key.toLowerCase() === "path") ?? "PATH";
+  const current = environment[pathKey] ?? "";
+  const entries = current.split(delimiter2).filter(Boolean);
+  if (entries.some((entry2) => resolve15(entry2) === resolve15(localBin))) return environment;
+  return { ...environment, [pathKey]: [localBin, ...entries].join(delimiter2) };
+}
+function boundedExecutionResult(result, maxBytes, command) {
+  if (result.truncation !== void 0) {
+    return withShellDiagnostic({
+      ...result,
+      truncated: result.truncated ?? (result.truncation.stdout.truncated || result.truncation.stderr.truncated),
+      truncation: result.truncation
+    }, command);
+  }
+  const stdout = new BoundedOutput(maxBytes);
+  const stderr = new BoundedOutput(maxBytes);
+  stdout.add(Buffer.from(result.stdout));
+  stderr.add(Buffer.from(result.stderr));
+  return withShellDiagnostic({
+    ...result,
+    stdout: stdout.text(),
+    stderr: stderr.text(),
+    truncated: stdout.truncated || stderr.truncated,
+    truncation: { stdout: stdout.metadata(), stderr: stderr.metadata() }
+  }, command);
+}
+function outputEncoding(buffer, utf8 = classifyUtf8(buffer)) {
+  if (buffer.length >= 2) {
+    if (buffer[0] === 255 && buffer[1] === 254) return "utf-16le";
+    if (buffer[0] === 254 && buffer[1] === 255) return "utf-16be";
+  }
+  const sampleLength = Math.min(buffer.length, 256);
+  let evenZeros = 0;
+  let oddZeros = 0;
+  for (let index = 0; index < sampleLength; index += 1) {
+    if (buffer[index] !== 0) continue;
+    if (index % 2 === 0) evenZeros += 1;
+    else oddZeros += 1;
+  }
+  const threshold = Math.max(2, Math.floor(sampleLength / 8));
+  if (oddZeros >= threshold && oddZeros > evenZeros * 2) return "utf-16le";
+  if (evenZeros >= threshold && evenZeros > oddZeros * 2) return "utf-16be";
+  return utf8 === "valid" || process.platform !== "win32" ? "utf-8" : "gb18030";
+}
 function decodePrefix(buffer, encoding) {
   for (let end = buffer.length; end >= Math.max(0, buffer.length - 3); end -= 1) {
     const candidate = buffer.subarray(0, end);
@@ -13259,13 +13496,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(join19(workspace, "package.json"));
+  const packageJson = await optionalJson(join20(workspace, "package.json"));
   const scripts = isRecord3(packageJson?.scripts) ? packageJson.scripts : {};
   for (const name of SCRIPT_PRIORITY) {
     if (typeof scripts[name] !== "string" || isUnconditionalPassThrough(scripts[name])) continue;
     add(commands, seen, npmScript(name));
   }
-  const flavor = await optionalText(join19(workspace, "FLAVOR.md"));
+  const flavor = await optionalText(join20(workspace, "FLAVOR.md"));
   if (flavor !== void 0) {
     for (const match of flavor.matchAll(/^- `([^`]+)`\s*$/gm)) {
       const parsed = parseTrustedCommand(match[1] ?? "");
@@ -13402,11 +13639,11 @@ function isEnvTruthy(value) {
 
 // src/utils/log.ts
 import { appendFile as appendFile3, mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname12, join as join20, resolve as resolve16 } from "path";
+import { dirname as dirname12, join as join21, resolve as resolve16 } from "path";
 var pending = Promise.resolve();
 var usagePending = Promise.resolve();
 function usageLogPath() {
-  return process.env.FLAVOR_USAGE_FILE ?? join20(process.cwd(), ".flavor", "usage.jsonl");
+  return process.env.FLAVOR_USAGE_FILE ?? join21(process.cwd(), ".flavor", "usage.jsonl");
 }
 var usageSessionId = "unknown";
 var truncateOnNextAppend = false;
@@ -13435,7 +13672,7 @@ var AuditLogger = class {
   #path;
   #closed = false;
   constructor(workspace) {
-    this.#path = join20(resolve16(workspace), ".flavor", "audit.jsonl");
+    this.#path = join21(resolve16(workspace), ".flavor", "audit.jsonl");
   }
   get path() {
     return this.#path;
@@ -14309,7 +14546,7 @@ import {
 
 // src/utils/version.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname13, join as join21 } from "path";
+import { dirname as dirname13, join as join22 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cached;
 function packageVersion() {
@@ -14317,7 +14554,7 @@ function packageVersion() {
   let directory = dirname13(fileURLToPath2(import.meta.url));
   for (; ; ) {
     try {
-      const manifest = JSON.parse(readFileSync2(join21(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync2(join22(directory, "package.json"), "utf8"));
       if (typeof manifest.version === "string" && manifest.version.length > 0) {
         cached = manifest.version;
         return cached;
@@ -14550,8 +14787,8 @@ var OAuthCallbackAuthProvider = class {
   async #startCallbackServer(expectedState, signal) {
     let serverResolve;
     let serverReject;
-    const codePromise = new Promise((resolve42, reject) => {
-      serverResolve = resolve42;
+    const codePromise = new Promise((resolve43, reject) => {
+      serverResolve = resolve43;
       serverReject = reject;
     });
     const server = createServer3((req, res) => {
@@ -14585,7 +14822,7 @@ var OAuthCallbackAuthProvider = class {
       );
       serverResolve(code);
     });
-    return new Promise((resolve42, reject) => {
+    return new Promise((resolve43, reject) => {
       server.once("error", (error) => {
         reject(new Error(`OAuth callback server failed: ${error.message}`));
       });
@@ -14602,7 +14839,7 @@ var OAuthCallbackAuthProvider = class {
         signal.addEventListener("abort", () => {
           serverReject(new Error("OAuth flow aborted"));
         }, { once: true });
-        resolve42({ redirectUri, promise: codePromise });
+        resolve43({ redirectUri, promise: codePromise });
       });
     });
   }
@@ -14745,7 +14982,7 @@ function isStoredToken(value) {
 
 // src/permissions/policy.ts
 import { readFile as readFile16 } from "fs/promises";
-import { join as join22, resolve as resolve18 } from "path";
+import { join as join23, resolve as resolve18 } from "path";
 import { z as z25 } from "zod";
 var DecisionSchema2 = z25.enum(["allow", "ask", "deny"]);
 var PrefixSchema = z25.array(z25.string().min(1).max(1024)).min(1).max(64);
@@ -14782,9 +15019,9 @@ var CompiledPermissionPolicy = class {
 async function loadPermissionPolicy(options) {
   const sources = [
     ...options.managedPath === void 0 ? [] : [{ tier: "managed", path: resolve18(options.managedPath) }],
-    { tier: "user", path: join22(resolve18(options.home), ".flavor-code", "permissions.json") },
-    { tier: "project", path: join22(resolve18(options.workspace), ".flavor", "permissions.json") },
-    { tier: "local", path: join22(resolve18(options.workspace), ".flavor", "permissions.local.json") }
+    { tier: "user", path: join23(resolve18(options.home), ".flavor-code", "permissions.json") },
+    { tier: "project", path: join23(resolve18(options.workspace), ".flavor", "permissions.json") },
+    { tier: "local", path: join23(resolve18(options.workspace), ".flavor", "permissions.local.json") }
   ];
   const rules = [];
   for (const source of sources) {
@@ -14946,7 +15183,7 @@ function toolsSection(toolNames) {
   addToolRule(rules, toolNames, "ApplyPatch", "Use `ApplyPatch` only when an edit genuinely spans multiple regions of one file; hunks may relocate only when their exact context has one unique nearby match. Prefer `Edit` for a single small replacement \u2014 it is easier to get right.");
   addToolRule(rules, toolNames, "Glob", "Use `Glob` to find files by path pattern instead of shell directory crawling. Confirm the exact path before reading, searching, or editing; the search scope is limited to the workspace, so never pass absolute paths outside it. Set `includeIgnored: true` only when the user explicitly asks to inspect ignored files or an ignored path is required for the task.");
   addToolRule(rules, toolNames, "Grep", "Use `Grep` to search file contents instead of shell text-search commands. Set `includeIgnored: true` only when the user explicitly asks to inspect ignored files or an ignored path is required for the task.");
-  addToolRule(rules, toolNames, "Shell", "Use `Shell` for builds, tests, Git inspection, and commands without a dedicated tool. Keep commands scoped, non-interactive, and easy to audit.");
+  addToolRule(rules, toolNames, "Shell", "Use `Shell` for builds, tests, Git inspection, and commands without a dedicated tool. Pass only the executable name or path in `command`, and put each logical argument in its own `args` item without shell quotes. Put pipes, redirects, and operators in `command` only when shell syntax is actually required. Prefer `Glob` and `Grep` over platform-specific directory and text-search commands. Keep commands scoped, non-interactive, and easy to audit.");
   addToolRule(rules, toolNames, "LspFindRefs", "Use `LspFindRefs` to find all references to a symbol using the Language Server Protocol. Prefer this over Grep when you need precise semantic results.");
   addToolRule(rules, toolNames, "LspHover", "Use `LspHover` to get type information and documentation for a symbol at a cursor position.");
   addToolRule(rules, toolNames, "LspDiagnostics", "Use `LspDiagnostics` to read compiler and linter errors for a file. Always run this before claiming a code change is correct.");
@@ -15004,7 +15241,7 @@ function data(value) {
 }
 
 // src/skills/registry.ts
-import { constants as constants5 } from "fs";
+import { constants as constants6 } from "fs";
 import { lstat as lstat7, open as defaultOpen, readdir as readdir5, realpath as realpath9 } from "fs/promises";
 import { isAbsolute as isAbsolute10, relative as relative12, resolve as resolve19, sep as sep12 } from "path";
 import { marked } from "marked";
@@ -15329,8 +15566,8 @@ async function openVerifiedFile(path, root, label, opener, expected) {
   assertRegular(initial, label);
   const canonical3 = await realpath9(path);
   if (!isWithin4(root, canonical3)) throw new Error(`${label} escapes the skill root`);
-  const noFollow = typeof constants5.O_NOFOLLOW === "number" ? constants5.O_NOFOLLOW : 0;
-  const handle = await opener(canonical3, constants5.O_RDONLY | noFollow);
+  const noFollow = typeof constants6.O_NOFOLLOW === "number" ? constants6.O_NOFOLLOW : 0;
+  const handle = await opener(canonical3, constants6.O_RDONLY | noFollow);
   try {
     const opened = await handle.stat({ bigint: true });
     assertRegular(opened, label);
@@ -15551,9 +15788,9 @@ function createSkillResourceTool(registry) {
 }
 
 // src/session/store.ts
-import { constants as constants6 } from "fs";
+import { constants as constants7 } from "fs";
 import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile17, readdir as readdir6, realpath as realpath10, rename as rename6, rm as rm8, stat as stat7 } from "fs/promises";
-import { basename as basename5, dirname as dirname15, join as join23, relative as relative13, resolve as resolve20, sep as sep13 } from "path";
+import { basename as basename6, dirname as dirname15, join as join24, relative as relative13, resolve as resolve20, sep as sep13 } from "path";
 import { randomUUID as randomUUID13 } from "crypto";
 import { z as z27 } from "zod";
 
@@ -16249,7 +16486,7 @@ var SessionStore = class {
   #maxSessions;
   constructor(options) {
     this.#workspace = resolve20(options.workspace);
-    this.#sessions = join23(this.#workspace, ".flavor", "sessions");
+    this.#sessions = join24(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;
@@ -16281,10 +16518,10 @@ 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 = join23(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
+    const temporary = join24(this.#sessions, `.${document.sessionId}.${process.pid}.${randomUUID13()}.tmp`);
     let handle;
     try {
-      handle = await open7(temporary, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
+      handle = await open7(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
       await handle.writeFile(body, "utf8");
       await handle.sync();
       await handle.close();
@@ -16300,13 +16537,13 @@ var SessionStore = class {
   async acquireLease(sessionId) {
     SessionIdSchema.parse(sessionId);
     await this.#prepareDirectory();
-    const path = join23(this.#sessions, `.${sessionId}.lock`);
+    const path = join24(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 open7(path, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
+        handle = await open7(path, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
         created = true;
         await handle.writeFile(token, "utf8");
         await handle.sync();
@@ -16358,7 +16595,7 @@ var SessionStore = class {
       parsed = this.#parseSession(raw);
     } catch (error) {
       const quarantine = await this.#quarantine(path);
-      throw new Error(`Session "${sessionId}" is corrupt or incompatible and was quarantined as ${basename5(quarantine)}: ${message(error)}`);
+      throw new Error(`Session "${sessionId}" is corrupt or incompatible and was quarantined as ${basename6(quarantine)}: ${message(error)}`);
     }
     await this.#assertWorkspace(parsed.workspace.path);
     const storedVersion = storedSessionVersion(raw);
@@ -16434,14 +16671,14 @@ var SessionStore = class {
       if (isCode8(error, "ENOENT")) return;
       throw error;
     }
-    const owner2 = await reclaimStaleSessionLock(join23(this.#sessions, `.${sessionId}.lock`));
+    const owner2 = await reclaimStaleSessionLock(join24(this.#sessions, `.${sessionId}.lock`));
     if (owner2 !== void 0) throw new Error(`Session "${sessionId}" is active in process ${owner2} and cannot be deleted`);
     const path = this.#path(sessionId);
     try {
       const metadata = await lstat8(path);
       if (!metadata.isFile()) throw new Error("Session path is not a regular file");
       await rm8(path);
-      await rm8(join23(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join24(this.#sessions, `${sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     } catch (error) {
       if (!isCode8(error, "ENOENT")) throw error;
     }
@@ -16457,14 +16694,14 @@ var SessionStore = class {
     if (entries.length <= this.#maxSessions) return;
     let retained = 0;
     for (const entry2 of entries) {
-      const owner2 = await reclaimStaleSessionLock(join23(this.#sessions, `.${entry2.sessionId}.lock`));
+      const owner2 = await reclaimStaleSessionLock(join24(this.#sessions, `.${entry2.sessionId}.lock`));
       if (owner2 !== void 0) continue;
       if (retained < this.#maxSessions) {
         retained += 1;
         continue;
       }
       await rm8(this.#path(entry2.sessionId), { force: true }).catch(() => void 0);
-      await rm8(join23(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
+      await rm8(join24(this.#sessions, `${entry2.sessionId}.events.jsonl`), { force: true }).catch(() => void 0);
     }
   }
   async #assertWorkspace(stored) {
@@ -16494,7 +16731,7 @@ var SessionStore = class {
     const target = `${path}.v${version}.bak`;
     let handle;
     try {
-      handle = await open7(target, constants6.O_CREAT | constants6.O_EXCL | constants6.O_WRONLY, 384);
+      handle = await open7(target, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
       await handle.writeFile(raw, "utf8");
       await handle.sync();
     } catch (error) {
@@ -16748,13 +16985,13 @@ function sanitize2(input, seen = /* @__PURE__ */ new WeakSet()) {
 // src/session/tree.ts
 import { randomUUID as randomUUID15 } from "crypto";
 import { mkdir as mkdir17, readFile as readFile19, rename as rename8, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname17, join as join25, resolve as resolve22 } from "path";
+import { dirname as dirname17, join as join26, resolve as resolve22 } from "path";
 
 // src/session/checkpoint.ts
 import { createHash as createHash15, randomUUID as randomUUID14 } from "crypto";
 import { execFile as execFile2 } from "child_process";
 import { lstat as lstat9, mkdir as mkdir16, open as open8, readFile as readFile18, readdir as readdir7, rename as rename7, rm as rm9, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname16, join as join24, relative as relative14, resolve as resolve21, sep as sep14 } from "path";
+import { dirname as dirname16, join as join25, relative as relative14, resolve as resolve21, sep as sep14 } from "path";
 var EXCLUDED = /* @__PURE__ */ new Set([".git", ".flavor", "node_modules", "dist", "build", "release", ".worktrees"]);
 var MAX_FILE_BYTES = 16 * 1024 * 1024;
 var MAX_TOTAL_BYTES = 128 * 1024 * 1024;
@@ -16767,9 +17004,9 @@ var WorkspaceCheckpointStore = class {
   #maxTotalBytes;
   constructor(options) {
     this.#workspace = resolve21(options.workspace);
-    this.#root = join24(this.#workspace, ".flavor", "checkpoints");
-    this.#objects = join24(this.#root, "objects");
-    this.#manifests = join24(this.#root, "manifests");
+    this.#root = join25(this.#workspace, ".flavor", "checkpoints");
+    this.#objects = join25(this.#root, "objects");
+    this.#manifests = join25(this.#root, "manifests");
     this.#maxFileBytes = options.maxFileBytes ?? MAX_FILE_BYTES;
     this.#maxTotalBytes = options.maxTotalBytes ?? MAX_TOTAL_BYTES;
   }
@@ -16789,7 +17026,7 @@ var WorkspaceCheckpointStore = class {
       if (total > this.#maxTotalBytes) throw new Error("Checkpoint exceeds total size limit");
       const content = await readFile18(absolute);
       const digest = createHash15("sha256").update(content).digest("hex");
-      const objectPath = join24(this.#objects, digest);
+      const objectPath = join25(this.#objects, digest);
       try {
         const handle = await open8(objectPath, "wx");
         try {
@@ -16809,12 +17046,12 @@ var WorkspaceCheckpointStore = class {
       ...label === void 0 || label.trim().length === 0 ? {} : { label: label.trim() },
       files
     };
-    await atomicJson(join24(this.#manifests, `${checkpoint.id}.json`), checkpoint);
+    await atomicJson(join25(this.#manifests, `${checkpoint.id}.json`), checkpoint);
     return checkpoint;
   }
   async load(id) {
     if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-    const value = JSON.parse(await readFile18(join24(this.#manifests, `${id}.json`), "utf8"));
+    const value = JSON.parse(await readFile18(join25(this.#manifests, `${id}.json`), "utf8"));
     if (value.version !== 1 || value.id !== id || !Array.isArray(value.files)) throw new Error("Invalid checkpoint manifest");
     for (const file of value.files) {
       contained(this.#workspace, file.path);
@@ -16826,7 +17063,7 @@ var WorkspaceCheckpointStore = class {
     const checkpoint = await this.load(id);
     const objects = /* @__PURE__ */ new Map();
     for (const file of checkpoint.files) {
-      const object = await readFile18(join24(this.#objects, file.digest));
+      const object = await readFile18(join25(this.#objects, file.digest));
       if (object.length !== file.size || createHash15("sha256").update(object).digest("hex") !== file.digest) {
         throw new Error(`Checkpoint object is corrupt: ${file.digest}`);
       }
@@ -16849,7 +17086,7 @@ var WorkspaceCheckpointStore = class {
   }
 };
 async function discoverFiles(workspace) {
-  if (await exists2(join24(workspace, ".git"))) {
+  if (await exists2(join25(workspace, ".git"))) {
     const listed = await gitFiles(workspace);
     return listed.filter((path) => !EXCLUDED.has(path.split("/")[0] ?? "")).sort();
   }
@@ -16858,7 +17095,7 @@ async function discoverFiles(workspace) {
     const entries = await readdir7(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (EXCLUDED.has(entry2.name)) continue;
-      const absolute = join24(directory, entry2.name);
+      const absolute = join25(directory, entry2.name);
       const path = normalizeRelative(relative14(workspace, absolute));
       if (entry2.isSymbolicLink()) throw new Error(`Checkpoint refuses symbolic link: ${path}`);
       if (entry2.isDirectory()) await walk(absolute);
@@ -16933,14 +17170,14 @@ var SessionHistory = class _SessionHistory {
   #leafId;
   #unrevert;
   constructor(options, document) {
-    this.#path = join25(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    this.#path = join26(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     this.#checkpoints = new WorkspaceCheckpointStore({ workspace: options.workspace });
     this.#restoreContext = options.restoreContext;
     this.#nodes = boundedNodes(document.nodes);
     this.#leafId = document.leafId !== null && this.#nodes.some((node) => node.id === document.leafId) ? document.leafId : this.#nodes.at(-1)?.id ?? null;
   }
   static async open(options) {
-    const path = join25(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
+    const path = join26(resolve22(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     let document = { version: 1, sessionId: options.sessionId, leafId: null, nodes: [] };
     try {
       const parsed = JSON.parse(await readFile19(path, "utf8"));
@@ -17071,12 +17308,12 @@ function isCode10(error, code) {
 }
 
 // src/utils/memory-restart.ts
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var MEMORY_RESTART_EXIT_CODE = 75;
 var MEMORY_RESTART_MARKER_FILE = "memory-restart.json";
 var MEMORY_RESTART_WINDOW_MS = 30 * 60 * 1e3;
 function memoryRestartMarkerPath(workspace) {
-  return join26(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
+  return join27(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
 }
 function nextMemoryRestartMarker(previous, sessionId, now) {
   const reusable = previous !== void 0 && previous.sessionId === sessionId && now.getTime() - Date.parse(previous.requestedAt) < MEMORY_RESTART_WINDOW_MS && Number.isInteger(previous.attempts) && previous.attempts > 0;
@@ -17095,10 +17332,10 @@ function parseMemoryRestartMarker(json) {
 }
 
 // src/sleep/organizer.ts
-import { constants as constants7 } from "fs";
+import { constants as constants8 } from "fs";
 import { randomUUID as randomUUID16 } from "crypto";
 import { lstat as lstat10, mkdir as mkdir18, open as open9, readdir as readdir8, realpath as realpath11, rename as rename9, rm as rm10 } from "fs/promises";
-import { isAbsolute as isAbsolute11, join as join27, relative as relative15, resolve as resolve23, sep as sep15 } from "path";
+import { isAbsolute as isAbsolute11, join as join28, relative as relative15, resolve as resolve23, sep as sep15 } from "path";
 import { z as z28 } from "zod";
 var DateKeySchema = z28.string().regex(/^\d{4}-\d{2}-\d{2}$/);
 var ReviewSchema = z28.object({
@@ -17153,7 +17390,7 @@ var ProjectSleepOrganizer = class {
   #generate;
   constructor(options) {
     this.#workspace = resolve23(options.workspace);
-    this.#sleepDirectory = join27(this.#workspace, ".flavor", "sleep");
+    this.#sleepDirectory = join28(this.#workspace, ".flavor", "sleep");
     this.#sessions = options.sessions ?? new SessionStore({ workspace: this.#workspace });
     this.#generate = options.generate;
   }
@@ -17162,10 +17399,10 @@ var ProjectSleepOrganizer = class {
     signal.throwIfAborted();
     await this.#prepareDirectory();
     if (await this.#hasReport(date)) return { status: "exists", date };
-    const lockPath = join27(this.#sleepDirectory, `.${date}.lock`);
+    const lockPath = join28(this.#sleepDirectory, `.${date}.lock`);
     let lock;
     try {
-      lock = await open9(lockPath, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
+      lock = await open9(lockPath, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
     } catch (error) {
       if (hasCode(error, "EEXIST")) return { status: "locked", date };
       throw error;
@@ -17197,7 +17434,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 = join27(this.#sleepDirectory, filename2);
+      const path = join28(this.#sleepDirectory, filename2);
       const markdown = renderSleepReport(date, review, documents);
       await this.#atomicWrite(path, markdown);
       return { status: "written", date, path, sessionCount: documents.length };
@@ -17239,7 +17476,7 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     });
   }
   async #prepareDirectory() {
-    const flavorDirectory = join27(this.#workspace, ".flavor");
+    const flavorDirectory = join28(this.#workspace, ".flavor");
     await assertNotSymlink(flavorDirectory);
     await mkdir18(flavorDirectory, { recursive: true, mode: 448 });
     await assertNotSymlink(this.#sleepDirectory);
@@ -17253,10 +17490,10 @@ Previous output was invalid. Repair it and return strict JSON only.`;
     return (await readdir8(this.#sleepDirectory, { withFileTypes: true })).some((entry2) => entry2.isFile() && entry2.name.startsWith(prefix) && entry2.name.endsWith(".md"));
   }
   async #atomicWrite(path, content) {
-    const temporary = join27(this.#sleepDirectory, `.${randomUUID16()}.tmp`);
+    const temporary = join28(this.#sleepDirectory, `.${randomUUID16()}.tmp`);
     let handle;
     try {
-      handle = await open9(temporary, constants7.O_CREAT | constants7.O_EXCL | constants7.O_WRONLY, 384);
+      handle = await open9(temporary, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
       await handle.writeFile(content, "utf8");
       await handle.sync();
       await handle.close();
@@ -17626,7 +17863,7 @@ function computeSessionStats(documents) {
 }
 
 // src/tools/files.ts
-import { constants as constants8 } from "fs";
+import { constants as constants9 } from "fs";
 import { mkdir as mkdir19, open as open10, readFile as readFile20, realpath as realpath12, rename as rename10, rm as rm11, stat as stat8 } from "fs/promises";
 import { dirname as dirname18, isAbsolute as isAbsolute12, relative as relative16, resolve as resolve24, sep as sep16 } from "path";
 import { randomUUID as randomUUID17 } from "crypto";
@@ -17766,7 +18003,7 @@ var FileObservationStore = class {
 };
 function createReadTool(workspace, options = {}) {
   const guard = createPathGuard(workspace);
-  const openFile2 = options.openFile ?? ((path) => open10(path, constants8.O_RDONLY));
+  const openFile2 = options.openFile ?? ((path) => open10(path, constants9.O_RDONLY));
   const readHistory = /* @__PURE__ */ new Map();
   return {
     name: "Read",
@@ -17984,7 +18221,7 @@ async function atomicWrite(path, content, signal, expectedVersion) {
   await mkdir19(dirname18(path), { recursive: true });
   const temporary = `${path}.${randomUUID17()}.tmp`;
   try {
-    const handle = await open10(temporary, constants8.O_CREAT | constants8.O_EXCL | constants8.O_WRONLY, 384);
+    const handle = await open10(temporary, constants9.O_CREAT | constants9.O_EXCL | constants9.O_WRONLY, 384);
     try {
       await handle.writeFile(content, "utf8");
       await handle.sync();
@@ -18876,7 +19113,7 @@ var SearchSpawnError = class extends Error {
   }
   fallbackSafe;
 };
-function delimitedParser(delimiter2, onRecord) {
+function delimitedParser(delimiter4, onRecord) {
   let pending2 = Buffer.alloc(0);
   let stopped = false;
   return {
@@ -18885,7 +19122,7 @@ function delimitedParser(delimiter2, onRecord) {
       pending2 = pending2.length === 0 ? chunk : Buffer.concat([pending2, chunk]);
       let offset = 0;
       while (true) {
-        const end = pending2.indexOf(delimiter2, offset);
+        const end = pending2.indexOf(delimiter4, offset);
         if (end < 0) break;
         if (!onRecord(pending2.subarray(offset, end))) {
           stopped = true;
@@ -19337,9 +19574,9 @@ function charset(contentType) {
 
 // src/tools/lsp.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { access as access2, constants as constants9, readFile as readFile21 } from "fs/promises";
-import { basename as basename6, dirname as dirname20, extname as extname3, isAbsolute as isAbsolute14, relative as relative18, resolve as resolve26, sep as sep18 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { access as access2, constants as constants10, readFile as readFile21 } from "fs/promises";
+import { basename as basename7, dirname as dirname20, extname as extname3, isAbsolute as isAbsolute14, relative as relative18, resolve as resolve26, sep as sep18 } from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "url";
 import { z as z32 } from "zod";
 var LSP_REQUEST_TIMEOUT_MS = 15e3;
@@ -19440,8 +19677,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((resolve42, reject) => {
-      this.#pending.set(id, { resolve: resolve42, reject });
+    const promise = new Promise((resolve43, reject) => {
+      this.#pending.set(id, { resolve: resolve43, reject });
       timeout.addEventListener("abort", () => {
         if (this.#pending.has(id)) {
           this.#pending.delete(id);
@@ -19648,7 +19885,7 @@ var RealLspManager = class {
     if (pending2 !== void 0) return pending2;
     const config = this.#serverConfigs.find((c) => c.language === language);
     if (config === void 0) return void 0;
-    const hasRoot = config.rootFiles.some((file) => existsSync4(resolve26(this.#workspace, file)));
+    const hasRoot = config.rootFiles.some((file) => existsSync5(resolve26(this.#workspace, file)));
     if (!hasRoot) return void 0;
     const startPromise = this.#startServer(config);
     this.#pendingStarts.set(language, startPromise);
@@ -19662,7 +19899,7 @@ var RealLspManager = class {
   }
   async #startServer(config) {
     try {
-      await access2(config.command, constants9.X_OK);
+      await access2(config.command, constants10.X_OK);
     } catch {
     }
     const connection = new LspConnection(config.command, config.args, this.#workspace);
@@ -19710,7 +19947,7 @@ function createLspTools(workspace, options = {}) {
     description: "Find all references to a symbol at a file position using the Language Server Protocol",
     inputSchema: LspFindRefsInput,
     paths: (input) => [guard(input.file)],
-    summarize: (input) => `${basename6(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
+    summarize: (input) => `${basename7(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
     execute: async (input, _signal) => {
       const path = guard(input.file);
       const uri = toUri(path);
@@ -19727,7 +19964,7 @@ function createLspTools(workspace, options = {}) {
     description: "Get type information and documentation for a symbol at a file position using LSP",
     inputSchema: LspHoverInput,
     paths: (input) => [guard(input.file)],
-    summarize: (input) => `${basename6(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
+    summarize: (input) => `${basename7(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
     execute: async (input, _signal) => {
       const path = guard(input.file);
       const uri = toUri(path);
@@ -19742,7 +19979,7 @@ function createLspTools(workspace, options = {}) {
     description: "Read compiler and linter diagnostics for a file using LSP",
     inputSchema: LspDiagnosticsInput,
     paths: (input) => [guard(input.file)],
-    summarize: (input) => `${basename6(input.file)}${langTag(input.file)}`,
+    summarize: (input) => `${basename7(input.file)}${langTag(input.file)}`,
     execute: async (input, _signal) => {
       const path = guard(input.file);
       const uri = toUri(path);
@@ -19845,19 +20082,19 @@ async function changeSummary(workspace) {
   };
 }
 async function stagedDiff(workspace, maxChars = 96e3) {
-  const stat19 = await git2(workspace, ["diff", "--staged", "--stat"]);
+  const stat20 = await git2(workspace, ["diff", "--staged", "--stat"]);
   const diff = await git2(workspace, ["diff", "--staged", "--no-ext-diff", "--no-color"]);
   if (!diff.ok) throw gitFailure(diff, "diff --staged");
   const text = diff.stdout;
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat19.stdout.trim(),
+    stat: stat20.stdout.trim(),
     truncated: text.length > maxChars
   };
 }
 async function uncommittedDiff(workspace, maxChars = 96e3) {
-  const stat19 = await git2(workspace, ["diff", "HEAD", "--stat"]);
+  const stat20 = await git2(workspace, ["diff", "HEAD", "--stat"]);
   const diff = await git2(workspace, ["diff", "HEAD", "--no-ext-diff", "--no-color"]);
   if (!diff.ok && !diff.stderr.includes("unknown revision")) throw gitFailure(diff, "diff HEAD");
   const summary2 = await changeSummary(workspace);
@@ -19865,7 +20102,7 @@ async function uncommittedDiff(workspace, maxChars = 96e3) {
   return {
     diff: text.length > maxChars ? `${text.slice(0, maxChars)}
 \u2026[diff truncated]` : text,
-    stat: stat19.stdout.trim(),
+    stat: stat20.stdout.trim(),
     untracked: summary2.untrackedFiles
   };
 }
@@ -20159,12 +20396,12 @@ ${explanation}` : "";
 // src/desktop/astgraph-service.ts
 import { stat as stat10 } from "fs/promises";
 import { createRequire as nodeCreateRequire } from "module";
-import { join as join28, resolve as resolve27 } from "path";
+import { join as join29, resolve as resolve27 } from "path";
 var FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature";
 var DesktopAstGraphService = class {
   #path;
   constructor(workspace) {
-    this.#path = join28(resolve27(workspace), ".flavor", "astgraph", "index.db");
+    this.#path = join29(resolve27(workspace), ".flavor", "astgraph", "index.db");
   }
   async status() {
     if ((await stat10(this.#path).catch(() => void 0))?.isFile() !== true) {
@@ -20326,7 +20563,7 @@ var QuestionBridge = class {
     }
   }
   #askLocally(questions, signal) {
-    return new Promise((resolve42, reject) => {
+    return new Promise((resolve43, reject) => {
       const onAbort = () => {
         this.#pending = void 0;
         this.#active = false;
@@ -20340,7 +20577,7 @@ var QuestionBridge = class {
           this.#pending = void 0;
           this.#active = false;
           this.#onChange?.();
-          resolve42(answers);
+          resolve43(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
@@ -20433,7 +20670,7 @@ function createTodoWriteTool() {
 // src/tools/managed.ts
 import { randomUUID as randomUUID18 } from "crypto";
 import { link, lstat as lstat11, mkdir as mkdir20, readFile as readFile22, readdir as readdir9, unlink as unlink3, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname21, join as join29, resolve as resolve28 } from "path";
+import { dirname as dirname21, join as join30, resolve as resolve28 } from "path";
 import { z as z37 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -20476,8 +20713,8 @@ var ManagedToolStore = class {
   #diagnostics = [];
   constructor(options) {
     this.#workspace = resolve28(options.workspace);
-    this.#projectRoot = join29(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join29(resolve28(options.home), ".flavor-code", "tools");
+    this.#projectRoot = join30(this.#workspace, ".flavor", "tools");
+    this.#globalRoot = join30(resolve28(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -20524,7 +20761,7 @@ var ManagedToolStore = class {
       version: MANAGED_TOOL_VERSION,
       createdAt: this.#now()
     });
-    const path = join29(this.directory(input.scope), filename(input.name));
+    const path = join30(this.directory(input.scope), filename(input.name));
     const definition = compileDefinition(record3, input.scope, this.#workspace);
     await writeExclusive(path, `${JSON.stringify(record3, void 0, 2)}
 `);
@@ -20549,7 +20786,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 [join29(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
+    return [join30(this.directory(parsed.data.scope ?? "project"), filename(parsed.data.name))];
   }
   async #loadDirectory(scope2) {
     const root = this.directory(scope2);
@@ -20562,7 +20799,7 @@ var ManagedToolStore = class {
       return;
     }
     for (const name of names) {
-      const path = join29(root, name);
+      const path = join30(root, name);
       try {
         const info = await lstat11(path);
         if (!info.isFile() || info.isSymbolicLink()) throw new Error("Managed tool record must be a regular file");
@@ -21145,6 +21382,7 @@ var MVP_COMMANDS = [
   "exit",
   "audit",
   "usage",
+  "doctor",
   "loop",
   "goal",
   "evolve",
@@ -21435,7 +21673,7 @@ var HELP = [
   "/permissions <default|acceptEdits|plan|bypassPermissions|auto|bubble>",
   "/login                                  authenticate via OAuth PKCE",
   "/logout                                 clear stored OAuth credentials",
-  "/init  /config  /skills  /plugins  /hooks  /tasks",
+  "/init  /config  /skills  /plugins  /hooks  /tasks  /doctor",
   "/memory  /remember [type] <text>  /forget <text-or-id>  /forget-cold  /finish",
   "/checkpoint [label]  /tree  /rewind <node>  /unrevert  /fork <node>",
   "/compact  /clear  /help  /exit",
@@ -21917,6 +22155,7 @@ Address this now (for example run the required verification or fix), then finish
     else if (command.name === "hooks") this.#notice(format(this.#services.hooksStatus()));
     else if (command.name === "tasks") this.#notice(format(this.#services.tasks()));
     else if (command.name === "audit") this.#notice(await this.#services.audit(command.toolFilter));
+    else if (command.name === "doctor") this.#notice(await required(this.#services.doctor, "doctor")());
     else if (command.name === "evolve") this.#notice(await this.#services.evolve(command.args));
     else if (command.name === "usage") this.#notice(await this.#services.usage());
     else if (command.name === "clear") {
@@ -22029,9 +22268,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((resolve42) => {
+    return new Promise((resolve43) => {
       const check2 = () => {
-        if (!this.#activePlanning.has(key)) resolve42();
+        if (!this.#activePlanning.has(key)) resolve43();
         else this.#planningIdleWaiters.add(check2);
       };
       this.#planningIdleWaiters.add(check2);
@@ -22138,6 +22377,225 @@ function requiredPals(service) {
   return service;
 }
 
+// src/doctor.ts
+import { constants as constants11 } from "fs";
+import { access as access3, lstat as lstat12, readFile as readFile23, readdir as readdir10, stat as stat11 } from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute as isAbsolute15, join as join31, relative as relative19, resolve as resolve29, sep as sep19 } from "path";
+import { rgPath as bundledRgPath2 } from "@vscode/ripgrep";
+
+// src/utils/semver.ts
+import { gt as semverGt, gte as semverGte, valid as semverValid } from "semver";
+function gte(a, b) {
+  return semverGte(a, b, { loose: true });
+}
+
+// src/update/check.ts
+var NPM_PACKAGE_NAME = "flavor-code";
+var REGISTRY_LATEST_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+var DEFAULT_TIMEOUT_MS2 = 3e3;
+async function fetchLatestVersion(options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const fetchImpl = options.fetchImpl ?? ((url, init) => fetch(url, init));
+  let timer;
+  const timeout = new Promise((resolve43) => {
+    timer = setTimeout(() => resolve43(void 0), timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    const response2 = await Promise.race([
+      fetchImpl(REGISTRY_LATEST_URL, { signal: AbortSignal.timeout(timeoutMs) }),
+      timeout
+    ]);
+    if (response2 === void 0 || !response2.ok) return void 0;
+    const body = await Promise.race([response2.json(), timeout]);
+    return typeof body?.version === "string" ? body.version : void 0;
+  } catch {
+    return void 0;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+
+// src/doctor.ts
+async function runDoctor(options = {}, dependencies2 = {}) {
+  const workspace = resolve29(options.workspace ?? process.cwd());
+  const home = resolve29(options.home ?? homedir());
+  const environment = options.environment ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const nodeVersion = options.nodeVersion ?? process.version;
+  const checks = [];
+  checks.push(runtimeCheck(nodeVersion, platform, arch));
+  checks.push(await directoryCheck("workspace", workspace, false));
+  checks.push(await directoryCheck("state directory", join31(home, ".flavor-code"), true, home));
+  let loaded;
+  try {
+    loaded = await (dependencies2.loadConfig ?? loadConfig)({
+      cwd: workspace,
+      home,
+      environment,
+      seedGlobalEnv: false
+    });
+    checks.push({
+      name: "configuration",
+      status: "pass",
+      message: loaded.sources.length === 0 ? "defaults are valid; no config files found" : `valid (${loaded.sources.length} source${loaded.sources.length === 1 ? "" : "s"})`
+    });
+  } catch (error) {
+    checks.push({ name: "configuration", status: "fail", message: errorMessage3(error) });
+  }
+  checks.push(providerCheck(loaded?.config, environment));
+  checks.push(await searchCheck(dependencies2.rgPath ?? bundledRgPath2));
+  try {
+    const shell2 = await (dependencies2.probeShell ?? probeShell)(platform, environment);
+    checks.push(shell2 === void 0 ? { name: "shell", status: "fail", message: "no usable command shell found" } : { name: "shell", status: "pass", message: shell2 });
+  } catch (error) {
+    checks.push({ name: "shell", status: "fail", message: errorMessage3(error) });
+  }
+  checks.push(await pluginCheck([
+    join31(home, ".flavor-code", "plugins"),
+    join31(workspace, ".flavor", "plugins")
+  ]));
+  try {
+    const latest = await (dependencies2.fetchLatestVersion ?? fetchLatestVersion)({
+      timeoutMs: options.registryTimeoutMs ?? 3e3
+    });
+    checks.push(latest === void 0 ? { name: "npm registry", status: "warn", message: "unreachable or returned an invalid response" } : { name: "npm registry", status: "pass", message: `reachable; latest flavor-code is v${latest}` });
+  } catch (error) {
+    checks.push({ name: "npm registry", status: "warn", message: errorMessage3(error) });
+  }
+  const summary2 = {
+    passed: checks.filter(({ status }) => status === "pass").length,
+    warnings: checks.filter(({ status }) => status === "warn").length,
+    failed: checks.filter(({ status }) => status === "fail").length
+  };
+  return {
+    version: packageVersion(),
+    platform,
+    arch,
+    workspace,
+    checks,
+    summary: summary2,
+    ok: summary2.failed === 0
+  };
+}
+function formatDoctorReport(report) {
+  const labels = { pass: "ok", warn: "warn", fail: "fail" };
+  const lines = [
+    `Flavor Doctor v${report.version}`,
+    `Platform: ${report.platform} ${report.arch}`,
+    `Workspace: ${report.workspace}`,
+    "",
+    ...report.checks.map((check2) => `[${labels[check2.status]}] ${check2.name}: ${check2.message}`),
+    "",
+    `Summary: ${report.summary.passed} passed, ${report.summary.warnings} warning${report.summary.warnings === 1 ? "" : "s"}, ${report.summary.failed} failed`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function runtimeCheck(version, platform, arch) {
+  const major = Number.parseInt(version.replace(/^v/u, "").split(".")[0] ?? "", 10);
+  if (!Number.isInteger(major) || !gte(`${major}.0.0`, "20.0.0")) {
+    return { name: "runtime", status: "fail", message: `Node ${version} is unsupported; Node 20+ is required` };
+  }
+  return { name: "runtime", status: "pass", message: `Node ${version} (${platform} ${arch})` };
+}
+async function directoryCheck(name, path, mayBeCreated, parent = path) {
+  try {
+    const info = await stat11(path);
+    if (!info.isDirectory()) return { name, status: "fail", message: `${path} is not a directory` };
+    await access3(path, constants11.R_OK | constants11.W_OK);
+    return { name, status: "pass", message: `${path} is readable and writable` };
+  } catch (error) {
+    if (mayBeCreated && errorCode2(error) === "ENOENT") {
+      try {
+        await access3(parent, constants11.R_OK | constants11.W_OK);
+        return { name, status: "pass", message: `${path} can be created` };
+      } catch (parentError) {
+        return { name, status: "fail", message: errorMessage3(parentError) };
+      }
+    }
+    return { name, status: "fail", message: errorMessage3(error) };
+  }
+}
+function providerCheck(config, environment) {
+  if (config === void 0) return { name: "providers", status: "warn", message: "skipped because configuration is invalid" };
+  const configured = Object.keys(config.providers);
+  const environmentProviders = [
+    environment.OPENAI_API_KEY ? "openai env" : void 0,
+    environment.ANTHROPIC_API_KEY ? "anthropic env" : void 0
+  ].filter((value) => value !== void 0);
+  if (configured.length === 0 && environmentProviders.length === 0) {
+    return { name: "providers", status: "warn", message: "no provider or API credential detected" };
+  }
+  const parts = [
+    configured.length > 0 ? `${configured.length} configured` : void 0,
+    environmentProviders.length > 0 ? environmentProviders.join(", ") : void 0
+  ].filter((value) => value !== void 0);
+  return { name: "providers", status: "pass", message: parts.join("; ") };
+}
+async function searchCheck(path) {
+  try {
+    await access3(path, constants11.R_OK);
+    return { name: "search", status: "pass", message: `bundled ripgrep found at ${path}` };
+  } catch (error) {
+    return { name: "search", status: "fail", message: `bundled ripgrep is unavailable: ${errorMessage3(error)}` };
+  }
+}
+async function probeShell(platform, environment) {
+  const shell2 = resolveRuntimeShell(platform, environment);
+  if (shell2 === void 0) return void 0;
+  const sentinel = "flavor-shell-ok";
+  const args = shell2.kind === "posix" ? ["-c", `printf '${sentinel}'`] : shell2.kind === "cmd" ? ["/d", "/s", "/c", `echo|set /p=${sentinel}`] : ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", `[Console]::Out.Write('${sentinel}')`];
+  const result = await execFileNoThrow(shell2.command, args, { timeout: 2e3, useCwd: false, env: environment });
+  if (result.code !== 0 || result.stdout !== sentinel) {
+    const detail = result.stderr.trim() || result.error || `unexpected output ${JSON.stringify(result.stdout)}`;
+    throw new Error(`${shell2.command} was found but failed its execution probe: ${detail}`);
+  }
+  return `${shell2.command} (${shell2.kind}; execution probe passed)`;
+}
+async function pluginCheck(directories) {
+  let valid = 0;
+  const diagnostics = [];
+  for (const directory of directories) {
+    let entries;
+    try {
+      entries = await readdir10(directory, { withFileTypes: true });
+    } catch (error) {
+      if (errorCode2(error) !== "ENOENT") diagnostics.push(`${directory}: ${errorMessage3(error)}`);
+      continue;
+    }
+    for (const entry2 of entries) {
+      if (!entry2.isDirectory() || entry2.name.startsWith(".")) continue;
+      const root = resolve29(directory, entry2.name);
+      try {
+        const rootInfo = await lstat12(root);
+        if (rootInfo.isSymbolicLink()) throw new Error("plugin directory must not be a symbolic link");
+        const manifest = PluginManifestSchema.parse(JSON.parse(await readFile23(join31(root, "flavor-plugin.json"), "utf8")));
+        const main = resolve29(root, manifest.main);
+        const delta = relative19(root, main);
+        if (delta === ".." || delta.startsWith(`..${sep19}`) || isAbsolute15(delta)) throw new Error("plugin entry escapes its root");
+        const mainInfo = await lstat12(main);
+        if (!mainInfo.isFile() || mainInfo.isSymbolicLink()) throw new Error("plugin entry must be a regular file");
+        valid += 1;
+      } catch (error) {
+        diagnostics.push(`${entry2.name}: ${errorMessage3(error)}`);
+      }
+    }
+  }
+  if (diagnostics.length > 0) {
+    return { name: "plugins", status: "warn", message: `${valid} valid; ${diagnostics.join("; ")}` };
+  }
+  return { name: "plugins", status: "pass", message: valid === 0 ? "no project or global plugins found" : `${valid} manifest${valid === 1 ? "" : "s"} valid` };
+}
+function errorCode2(error) {
+  return error instanceof Error && "code" in error ? String(error.code) : void 0;
+}
+function errorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/utils/intl.ts
 function detectSystemLocale() {
   try {
@@ -22182,7 +22640,7 @@ var LANG_LABELS = /* @__PURE__ */ new Map([
 
 // src/utils/crash-guard.ts
 import { mkdirSync as mkdirSync3, writeFileSync } from "fs";
-import { join as join30 } from "path";
+import { join as join32 } from "path";
 var installed = false;
 var crashing = false;
 var crashCleanups = /* @__PURE__ */ new Set();
@@ -22213,7 +22671,7 @@ function installCrashGuard(options = {}) {
   installed = true;
   const crashLogDir = () => {
     try {
-      return join30((options.workspace ?? process.cwd)(), ".flavor");
+      return join32((options.workspace ?? process.cwd)(), ".flavor");
     } catch {
       return process.cwd();
     }
@@ -22222,7 +22680,7 @@ function installCrashGuard(options = {}) {
     try {
       const dir = crashLogDir();
       mkdirSync3(dir, { recursive: true });
-      const path = join30(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
+      const path = join32(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
       writeFileSync(path, [
         `kind: ${kind}`,
         `version: ${process.version}`,
@@ -22721,14 +23179,14 @@ var RetryMonitor = class {
   recordCall(toolName, params) {
     this.#slidingWindow.push(toolName, params);
   }
-  recordError(toolName, params, errorCode) {
+  recordError(toolName, params, errorCode3) {
     void params;
     const existing = this.#errorStates.get(toolName);
     if (existing === void 0) {
-      this.#errorStates.set(toolName, { retryCount: 1, lastErrorCode: errorCode });
+      this.#errorStates.set(toolName, { retryCount: 1, lastErrorCode: errorCode3 });
     } else {
       existing.retryCount += 1;
-      existing.lastErrorCode = errorCode;
+      existing.lastErrorCode = errorCode3;
     }
   }
   recordSuccess(toolName) {
@@ -22993,8 +23451,8 @@ ${total}`;
 
 // src/memory/store.ts
 import { createHash as createHash17 } from "crypto";
-import { readFile as readFile23, rm as rm12 } from "fs/promises";
-import { resolve as resolve29, join as join31, relative as relative19, sep as sep19 } from "path";
+import { readFile as readFile24, rm as rm12 } from "fs/promises";
+import { resolve as resolve30, join as join33, relative as relative20, sep as sep20 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -23096,10 +23554,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 = resolve29(options.workspace);
-    this.#memoryRoot = join31(this.workspace, ".flavor", "memory");
-    this.path = join31(this.#memoryRoot, "MEMORY.md");
-    this.#behaviorPath = join31(this.#memoryRoot, "behavior.json");
+    this.workspace = resolve30(options.workspace);
+    this.#memoryRoot = join33(this.workspace, ".flavor", "memory");
+    this.path = join33(this.#memoryRoot, "MEMORY.md");
+    this.#behaviorPath = join33(this.#memoryRoot, "behavior.json");
     this.#maxEntries = options.maxEntries;
     this.#maxEntryChars = options.maxEntryChars;
   }
@@ -23317,14 +23775,14 @@ var MemoryStore = class {
     });
   }
   async #readTaskItem(reference) {
-    const document = decodeTask(await readFile23(this.#resolveContentPath(reference.contentPath), "utf8"));
+    const document = decodeTask(await readFile24(this.#resolveContentPath(reference.contentPath), "utf8"));
     return document.items.find((item) => item.id === reference.id)?.content ?? reference.summary;
   }
   #resolveContentPath(contentPath) {
     if (!/^tasks\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.md$/.test(contentPath)) throw new Error("Invalid memory content path");
-    const path = resolve29(this.#memoryRoot, ...contentPath.split("/"));
-    const rel = relative19(this.#memoryRoot, path);
-    if (rel === ".." || rel.startsWith(`..${sep19}`)) throw new Error("Memory content path escapes the memory directory");
+    const path = resolve30(this.#memoryRoot, ...contentPath.split("/"));
+    const rel = relative20(this.#memoryRoot, path);
+    if (rel === ".." || rel.startsWith(`..${sep20}`)) throw new Error("Memory content path escapes the memory directory");
     return path;
   }
   async #updateIndex(update) {
@@ -23782,13 +24240,13 @@ var MemoryReviewBridge = class {
 
 // src/execution/docker.ts
 import { spawn as spawn6 } from "child_process";
-import { relative as relative20, resolve as resolve30, sep as sep20, win32 } from "path";
+import { relative as relative21, resolve as resolve31, sep as sep21, win32 } from "path";
 function buildDockerInvocation(options) {
   const workspace = options.workspace;
   const cwd = options.request.cwd;
   const windows = /^[A-Za-z]:[\\/]/.test(workspace);
-  const delta = windows ? win32.relative(workspace, cwd) : relative20(resolve30(workspace), resolve30(cwd));
-  if (delta === ".." || delta.startsWith(`..${windows ? "\\" : sep20}`)) throw new Error("Docker cwd escapes workspace");
+  const delta = windows ? win32.relative(workspace, cwd) : relative21(resolve31(workspace), resolve31(cwd));
+  if (delta === ".." || delta.startsWith(`..${windows ? "\\" : sep21}`)) throw new Error("Docker cwd escapes workspace");
   const containerCwd = delta.length === 0 ? "/workspace" : `/workspace/${delta.replaceAll("\\", "/")}`;
   const args = [
     "run",
@@ -23826,53 +24284,123 @@ var DockerExecutionEnvironment = class {
   }
   exec(request, signal) {
     const invocation = buildDockerInvocation({ ...this.#options, request });
-    return (this.#options.run ?? runInvocation)(invocation, signal, request.timeoutMs);
+    return (this.#options.run ?? runDockerInvocation)(invocation, signal, request.timeoutMs, request.maxOutputBytes);
   }
   async dispose() {
   }
 };
-function runInvocation(invocation, signal, timeoutMs) {
+var DEFAULT_DOCKER_MAX_OUTPUT_BYTES = 1048576;
+var DOCKER_TERMINATION_GRACE_MS = 250;
+var DOCKER_TERMINATION_FAILURE_MS = 5e3;
+function runDockerInvocation(invocation, signal, timeoutMs, maxOutputBytes = DEFAULT_DOCKER_MAX_OUTPUT_BYTES) {
   return new Promise((resolvePromise) => {
     if (signal?.aborted) {
       resolvePromise({ exitCode: null, signal: null, stdout: "", stderr: "", terminationReason: "cancelled" });
       return;
     }
     const child = spawn6(invocation.command, invocation.args, { windowsHide: true, shell: false });
-    const stdout = [];
-    const stderr = [];
+    const stdout = new BoundedUtf8Output(maxOutputBytes);
+    const stderr = new BoundedUtf8Output(maxOutputBytes);
     let reason = null;
     let settled = false;
+    let forceTimer;
+    let failureTimer;
     const finish = (result) => {
       if (settled) return;
       settled = true;
       if (timer !== void 0) clearTimeout(timer);
+      if (forceTimer !== void 0) clearTimeout(forceTimer);
+      if (failureTimer !== void 0) clearTimeout(failureTimer);
       signal?.removeEventListener("abort", abort2);
       resolvePromise(result);
     };
+    const collected = (exitCode, closedSignal) => ({
+      exitCode,
+      signal: closedSignal,
+      stdout: stdout.text(),
+      stderr: stderr.text(),
+      terminationReason: reason,
+      truncated: stdout.truncated || stderr.truncated,
+      truncation: { stdout: stdout.metadata(), stderr: stderr.metadata() }
+    });
     const stop = (next) => {
+      if (reason !== null || settled) return;
       reason = next;
-      child.kill();
+      child.kill("SIGTERM");
+      forceTimer = setTimeout(() => child.kill("SIGKILL"), DOCKER_TERMINATION_GRACE_MS);
+      forceTimer.unref();
+      failureTimer = setTimeout(() => finish(collected(null, null)), DOCKER_TERMINATION_FAILURE_MS);
+      failureTimer.unref();
     };
     const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => stop("timeout"), timeoutMs);
     timer?.unref();
     const abort2 = () => stop("cancelled");
     signal?.addEventListener("abort", abort2, { once: true });
-    child.stdout.on("data", (value) => stdout.push(value));
-    child.stderr.on("data", (value) => stderr.push(value));
+    child.stdout.on("data", (value) => stdout.add(value));
+    child.stderr.on("data", (value) => stderr.add(value));
     child.once("error", (error) => {
-      finish({ exitCode: 127, signal: null, stdout: "", stderr: error.message, terminationReason: reason });
+      stderr.add(Buffer.from(error.message));
+      finish(collected(127, null));
     });
     child.once("close", (code, closedSignal) => {
-      finish({
-        exitCode: code,
-        signal: closedSignal,
-        stdout: Buffer.concat(stdout).toString("utf8"),
-        stderr: Buffer.concat(stderr).toString("utf8"),
-        terminationReason: reason
-      });
+      finish(collected(code, closedSignal));
     });
   });
 }
+var BoundedUtf8Output = class {
+  #limit;
+  #headLimit;
+  #tailLimit;
+  #head = Buffer.alloc(0);
+  #tailChunks = [];
+  #tailBytes = 0;
+  #complete = Buffer.alloc(0);
+  #bytes = 0;
+  constructor(limit) {
+    this.#limit = Number.isSafeInteger(limit) && limit > 0 ? limit : DEFAULT_DOCKER_MAX_OUTPUT_BYTES;
+    this.#headLimit = Math.ceil(this.#limit / 2);
+    this.#tailLimit = Math.floor(this.#limit / 2);
+  }
+  get truncated() {
+    return this.#bytes > this.#limit;
+  }
+  add(chunk) {
+    this.#bytes += chunk.length;
+    if (this.#complete.length < this.#limit) {
+      this.#complete = Buffer.concat([this.#complete, chunk]).subarray(0, this.#limit);
+    }
+    if (this.#head.length < this.#headLimit) {
+      this.#head = Buffer.concat([this.#head, chunk.subarray(0, this.#headLimit - this.#head.length)]);
+    }
+    if (this.#tailLimit > 0) {
+      this.#tailChunks.push(chunk);
+      this.#tailBytes += chunk.length;
+      if (this.#tailBytes >= this.#tailLimit * 2) {
+        const merged = Buffer.concat(this.#tailChunks).subarray(-this.#tailLimit);
+        this.#tailChunks = [merged];
+        this.#tailBytes = merged.length;
+      }
+    }
+  }
+  metadata() {
+    return { truncated: this.truncated, originalBytes: this.#bytes, limitBytes: this.#limit };
+  }
+  text() {
+    if (!this.truncated) return this.#complete.toString("utf8");
+    const tail = Buffer.concat(this.#tailChunks).subarray(-this.#tailLimit);
+    return `${decodeUtf8Edge(this.#head, "prefix")}\u2026${decodeUtf8Edge(tail, "suffix")}`;
+  }
+};
+function decodeUtf8Edge(buffer, edge) {
+  for (let offset = 0; offset <= Math.min(3, buffer.length); offset += 1) {
+    const candidate = edge === "prefix" ? buffer.subarray(0, buffer.length - offset) : buffer.subarray(offset);
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(candidate);
+    } catch {
+    }
+  }
+  return new TextDecoder("utf-8").decode(buffer);
+}
 
 // src/execution/factory.ts
 function createExecutionEnvironment(workspace, config) {
@@ -23887,8 +24415,8 @@ function createExecutionEnvironment(workspace, config) {
 }
 
 // src/ide/client.ts
-import { readFile as readFile24, readdir as readdir10, stat as stat11 } from "fs/promises";
-import { basename as basename7, join as join32, relative as relative21, resolve as resolve31, sep as sep21 } from "path";
+import { readFile as readFile25, readdir as readdir11, stat as stat12 } from "fs/promises";
+import { basename as basename8, join as join34, relative as relative22, resolve as resolve32, sep as sep22 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -23899,8 +24427,8 @@ var FlavorIdeClient = class {
   #sessionId;
   #eventTail = Promise.resolve();
   constructor(options) {
-    this.#workspace = resolve31(options.workspace);
-    this.#home = resolve31(options.home);
+    this.#workspace = resolve32(options.workspace);
+    this.#home = resolve32(options.home);
     this.#environment = options.environment ?? process.env;
     this.#fetch = options.fetch ?? fetch;
   }
@@ -23984,17 +24512,17 @@ var FlavorIdeClient = class {
       };
       if (await this.#healthy(configured)) return configured;
     }
-    const directory = join32(this.#home, ".flavor-code", "ide");
+    const directory = join34(this.#home, ".flavor-code", "ide");
     let entries;
     try {
-      entries = (await readdir10(directory)).filter((name) => name.endsWith(".lock"));
+      entries = (await readdir11(directory)).filter((name) => name.endsWith(".lock"));
     } catch {
       return void 0;
     }
     const candidates = (await Promise.all(entries.map(async (name) => {
-      const path = join32(directory, name);
+      const path = join34(directory, name);
       try {
-        const [contents, info] = await Promise.all([readFile24(path, "utf8"), stat11(path)]);
+        const [contents, info] = await Promise.all([readFile25(path, "utf8"), stat12(path)]);
         const lock = parseLockfile(contents);
         return lock === void 0 ? void 0 : { lock, modified: info.mtimeMs };
       } catch {
@@ -24098,17 +24626,17 @@ function parsePort(value) {
   return Number.isInteger(port2) && port2 > 0 && port2 <= 65535 ? port2 : void 0;
 }
 function isWithin8(parent, child) {
-  const base = normalize(resolve31(parent));
-  const target = normalize(resolve31(child));
-  return target === base || target.startsWith(`${base}${sep21}`);
+  const base = normalize(resolve32(parent));
+  const target = normalize(resolve32(child));
+  return target === base || target.startsWith(`${base}${sep22}`);
 }
 function normalize(path) {
   const normalized = path.normalize("NFC");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function relativeDisplay(workspace, filePath) {
-  const path = relative21(workspace, filePath).replaceAll("\\", "/");
-  return path && !path.startsWith("../") ? path : basename7(filePath);
+  const path = relative22(workspace, filePath).replaceAll("\\", "/");
+  return path && !path.startsWith("../") ? path : basename8(filePath);
 }
 
 // src/jobs/registry.ts
@@ -24129,8 +24657,8 @@ var JobRegistry = class {
     const id = `job-${randomUUID19().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
-    const done = new Promise((resolve42) => {
-      settle = resolve42;
+    const done = new Promise((resolve43) => {
+      settle = resolve43;
     });
     const record3 = {
       id,
@@ -24254,7 +24782,7 @@ function snapshot2(job) {
 // src/terminal/service.ts
 import { randomUUID as randomUUID20 } from "crypto";
 import { createRequire as nodeCreateRequire2 } from "module";
-import { isAbsolute as isAbsolute15, relative as relative22, resolve as resolve32, sep as sep22 } from "path";
+import { isAbsolute as isAbsolute16, relative as relative23, resolve as resolve33, sep as sep23 } from "path";
 var TerminalService = class {
   #root;
   #factory;
@@ -24262,7 +24790,7 @@ var TerminalService = class {
   #maxOutputChars;
   #sessions = /* @__PURE__ */ new Map();
   constructor(workspace, options = {}) {
-    this.#root = resolve32(workspace);
+    this.#root = resolve33(workspace);
     this.#factory = options.factory ?? defaultFactory;
     this.#jobs = options.jobs;
     this.#maxOutputChars = options.maxOutputChars ?? 2e5;
@@ -24380,15 +24908,15 @@ function cleanEnvironment(environment) {
   return Object.fromEntries(Object.entries(environment).filter((entry2) => entry2[1] !== void 0));
 }
 function workspacePath(root, input) {
-  const path = resolve32(root, input);
-  const delta = relative22(root, path);
-  if (delta === ".." || delta.startsWith(`..${sep22}`) || isAbsolute15(delta)) throw new Error("Terminal cwd is outside the workspace");
+  const path = resolve33(root, input);
+  const delta = relative23(root, path);
+  if (delta === ".." || delta.startsWith(`..${sep23}`) || isAbsolute16(delta)) throw new Error("Terminal cwd is outside the workspace");
   return path;
 }
 
 // src/tools/terminal.ts
 import { z as z40 } from "zod";
-import { resolve as resolve33 } from "path";
+import { resolve as resolve34 } from "path";
 var Id = z40.string().regex(/^term-[a-f0-9-]+$/);
 var OpenInput = z40.object({ cwd: z40.string().optional(), shell: z40.string().optional(), args: z40.array(z40.string()).optional(), columns: z40.coerce.number().int().min(10).max(500).optional(), rows: z40.coerce.number().int().min(2).max(300).optional() });
 var OptionalBoolean = z40.union([z40.boolean(), z40.string().refine((value) => value === "true" || value === "false")]);
@@ -24402,8 +24930,8 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       name: "TerminalOpen",
       description: "Open a persistent interactive pseudo-terminal in the workspace",
       inputSchema: OpenInput,
-      paths: (input) => [resolve33(workspace, input.cwd ?? ".")],
-      permissions: (input) => ({ paths: [resolve33(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve33(workspace, input.cwd ?? ".") }),
+      paths: (input) => [resolve34(workspace, input.cwd ?? ".")],
+      permissions: (input) => ({ paths: [resolve34(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve34(workspace, input.cwd ?? ".") }),
       execute: async (input, _signal, context) => terminals.open({
         owner: owner(context),
         ...input.cwd === void 0 ? {} : { cwd: input.cwd },
@@ -24499,29 +25027,29 @@ function palSocketAddress(options) {
 import { createHash as createHash20 } from "crypto";
 import { Socket as Socket2 } from "net";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 import { spawn as spawn7 } from "child_process";
 
 // src/pals/broker.ts
 import { createHash as createHash19, randomUUID as randomUUID23, timingSafeEqual } from "crypto";
-import { chmod as chmod3, lstat as lstat12, mkdir as mkdir23, unlink as unlink6 } from "fs/promises";
+import { chmod as chmod3, lstat as lstat13, mkdir as mkdir23, unlink as unlink6 } from "fs/promises";
 import { createServer as createServer4, Socket } from "net";
 import { dirname as dirname23 } from "path";
 
 // src/pals/auth.ts
 import { randomBytes as randomBytes3, randomUUID as randomUUID21 } from "crypto";
-import { chmod as chmod2, link as link2, mkdir as mkdir21, open as open12, readFile as readFile25, unlink as unlink4 } from "fs/promises";
-import { homedir } from "os";
-import { join as join33 } from "path";
+import { chmod as chmod2, link as link2, mkdir as mkdir21, open as open12, readFile as readFile26, unlink as unlink4 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join35 } from "path";
 var PAL_AUTH_TOKEN_BYTES = 32;
 var TOKEN_PATTERN = /^[a-f0-9]{64}$/;
 async function loadOrCreatePalAuthToken(options = {}) {
-  const directory = join33(options.home ?? homedir(), ".flavor-code", "pals");
-  const tokenPath = join33(directory, "auth-token");
+  const directory = join35(options.home ?? homedir2(), ".flavor-code", "pals");
+  const tokenPath = join35(directory, "auth-token");
   await mkdir21(directory, { recursive: true, mode: 448 });
   await chmod2(directory, 448);
   const token = (options.random ?? randomBytes3)(PAL_AUTH_TOKEN_BYTES).toString("hex");
-  const temporaryPath = join33(directory, `.auth-token-${process.pid}-${randomUUID21()}.tmp`);
+  const temporaryPath = join35(directory, `.auth-token-${process.pid}-${randomUUID21()}.tmp`);
   let handle;
   try {
     handle = await open12(temporaryPath, "wx", 384);
@@ -24544,7 +25072,7 @@ async function loadOrCreatePalAuthToken(options = {}) {
       if (error.code !== "ENOENT") throw error;
     });
   }
-  const stored = (await readFile25(tokenPath, "utf8")).trim();
+  const stored = (await readFile26(tokenPath, "utf8")).trim();
   if (!TOKEN_PATTERN.test(stored)) throw new Error("Pals authentication token store is invalid");
   await chmod2(tokenPath, 384);
   return stored;
@@ -24556,7 +25084,7 @@ function validatePalAuthToken(token) {
 
 // src/pals/lifecycle.ts
 import { randomUUID as randomUUID22 } from "crypto";
-import { mkdir as mkdir22, open as open13, readFile as readFile26, rename as rename11, stat as stat12, unlink as unlink5 } from "fs/promises";
+import { mkdir as mkdir22, open as open13, readFile as readFile27, rename as rename11, stat as stat13, unlink as unlink5 } from "fs/promises";
 import { dirname as dirname22 } from "path";
 function defaultProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return true;
@@ -24588,7 +25116,7 @@ async function acquirePalFileLock(options) {
     handle = await open13(options.path, "wx", 384);
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
-    const [contents, info] = await Promise.all([readFile26(options.path, "utf8").catch(() => ""), stat12(options.path).catch(() => void 0)]);
+    const [contents, info] = await Promise.all([readFile27(options.path, "utf8").catch(() => ""), stat13(options.path).catch(() => void 0)]);
     if (await options.endpointLive()) return void 0;
     const existing = parseMetadata(contents);
     if (existing !== void 0 && (options.processAlive ?? defaultProcessAlive)(existing.pid)) return void 0;
@@ -24618,7 +25146,7 @@ async function acquirePalFileLock(options) {
     await handle.close();
   }
   const release = async () => {
-    const current = parseMetadata(await readFile26(options.path, "utf8").catch(() => ""));
+    const current = parseMetadata(await readFile27(options.path, "utf8").catch(() => ""));
     if (current?.nonce !== nonce) return;
     await unlink5(options.path).catch((error) => {
       if (error.code !== "ENOENT") throw error;
@@ -24634,15 +25162,15 @@ async function acquirePalFileLock(options) {
 // src/pals/broker-cli.ts
 var startupAttempts = /* @__PURE__ */ new Map();
 function delay3(milliseconds) {
-  return new Promise((resolve42) => setTimeout(resolve42, milliseconds));
+  return new Promise((resolve43) => setTimeout(resolve43, milliseconds));
 }
 function canConnect(address) {
-  return new Promise((resolve42) => {
+  return new Promise((resolve43) => {
     const socket = new Socket2();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve42(connected);
+      resolve43(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -24651,7 +25179,7 @@ function canConnect(address) {
 }
 function startupLockPath(address) {
   const digest = createHash20("sha256").update(address, "utf8").digest("hex").slice(0, 24);
-  return join34(tmpdir3(), `flavor-code-pals-${digest}.startup.lock`);
+  return join36(tmpdir3(), `flavor-code-pals-${digest}.startup.lock`);
 }
 async function spawnProductionBroker(address) {
   const entry2 = process.argv[1];
@@ -24833,8 +25361,8 @@ var PalClient = class {
       let disconnectTimer;
       await Promise.race([
         this.request({ version: 1, type: "disconnect", requestId: randomUUID24() }).catch(() => void 0),
-        new Promise((resolve42) => {
-          disconnectTimer = setTimeout(resolve42, Math.min(this.requestTimeoutMs, 250));
+        new Promise((resolve43) => {
+          disconnectTimer = setTimeout(resolve43, Math.min(this.requestTimeoutMs, 250));
         })
       ]);
       if (disconnectTimer !== void 0) clearTimeout(disconnectTimer);
@@ -24880,7 +25408,7 @@ var PalClient = class {
     return presence;
   }
   openSocket() {
-    return new Promise((resolve42, reject) => {
+    return new Promise((resolve43, reject) => {
       let settled = false;
       const rejectConnection = (error) => {
         if (settled) return;
@@ -24903,7 +25431,7 @@ var PalClient = class {
         settled = true;
         if (this.connectingReject === rejectConnection) this.connectingReject = void 0;
         socket.off("error", onInitialError);
-        resolve42();
+        resolve43();
       };
       const onInitialError = (error) => {
         socket.off("connect", onConnect);
@@ -24934,12 +25462,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((resolve42, reject) => {
+    return new Promise((resolve43, 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: resolve42, reject, timer });
+      this.pending.set(request.requestId, { resolve: resolve43, reject, timer });
       let frame;
       try {
         frame = encodeControlFrame(BrokerRequestSchema.parse(request));
@@ -25304,7 +25832,7 @@ function createPromptEnvironment(input = {}) {
     date: Number.isNaN(now.getTime()) ? "unknown" : localDateKey(now),
     platform: promptEnvironmentValue(input.platform ?? process.platform),
     osVersion: promptEnvironmentValue(input.osVersion ?? `${osVersion()} ${osRelease()}`),
-    shell: promptEnvironmentValue(input.shell ?? process.env.ComSpec ?? process.env.SHELL),
+    shell: promptEnvironmentValue(input.shell ?? resolveRuntimeShell()?.command),
     isGitRepository: input.isGitRepository ?? "unknown"
   };
 }
@@ -25343,8 +25871,8 @@ var ApprovalBridge = class {
   }
 };
 async function createProductionRuntime(options) {
-  const workspace = resolve34(options.workspace ?? process.cwd());
-  const home = resolve34(options.home ?? homedir2());
+  const workspace = resolve35(options.workspace ?? process.cwd());
+  const home = resolve35(options.home ?? homedir3());
   const environment = options.environment ?? process.env;
   const ide = new FlavorIdeClient({ workspace, home, environment });
   const ideReady = ide.initialize();
@@ -25534,6 +26062,7 @@ async function createProductionRuntime(options) {
     createGitHistoryTool(workspace),
     createShellTool(workspace, {
       jobs,
+      environment,
       ...executionEnvironment === void 0 ? {} : { executionEnvironment }
     }),
     createWebFetchTool(),
@@ -25587,8 +26116,8 @@ async function createProductionRuntime(options) {
   const registeredProviders = registration.registered;
   let effectiveLlm = registration.effectiveLlm;
   const pluginHost = new PluginHost({
-    globalPluginDirs: [join35(home, ".flavor-code", "plugins")],
-    projectPluginDirs: [join35(workspace, ".flavor", "plugins")],
+    globalPluginDirs: [join37(home, ".flavor-code", "plugins")],
+    projectPluginDirs: [join37(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
@@ -25692,12 +26221,12 @@ async function createProductionRuntime(options) {
   try {
     if (options.collaboration !== void 0) {
       const collaboration = options.collaboration;
-      const defaultAlias = `${basename8(workspace) || "flavor"}-${collaboration.instanceId.slice(0, 8)}`.slice(0, 64);
+      const defaultAlias = `${basename9(workspace) || "flavor"}-${collaboration.instanceId.slice(0, 8)}`.slice(0, 64);
       const alias = PalAliasSchema.parse(collaboration.alias?.trim() || defaultAlias);
       const address = palSocketAddress({
         platform: process.platform,
         userScope: home,
-        runtimeDir: join35(tmpdir4(), `flavor-code-pals-${createHash21("sha256").update(home).digest("hex").slice(0, 16)}`)
+        runtimeDir: join37(tmpdir4(), `flavor-code-pals-${createHash21("sha256").update(home).digest("hex").slice(0, 16)}`)
       });
       const baseCollaborationClient = collaboration.client ?? collaboration.createClient?.({
         instanceId: collaboration.instanceId,
@@ -25808,8 +26337,8 @@ async function createProductionRuntime(options) {
       diagnostics.push(`MCP servers could not start: ${message(error)}`);
     });
     const skills = new SkillRegistry({
-      globalRoots: [join35(home, ".flavor-code", "skills")],
-      projectRoots: [join35(workspace, ".flavor", "skills"), ...pluginSkillRoots],
+      globalRoots: [join37(home, ".flavor-code", "skills")],
+      projectRoots: [join37(workspace, ".flavor", "skills"), ...pluginSkillRoots],
       authorizeResource: async () => true,
       disabledNames: config.skills.disabled
     });
@@ -25817,7 +26346,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(join35(workspace, "FLAVOR.md"));
+    const flavor = await optionalText2(join37(workspace, "FLAVOR.md"));
     const instructionBaseline = await workspaceInstructions.baseline();
     let memoryContext;
     if (memoryStore !== void 0) {
@@ -25998,7 +26527,7 @@ async function createProductionRuntime(options) {
       now: /* @__PURE__ */ new Date(),
       platform: process.platform,
       osVersion: `${osVersion()} ${osRelease()}`,
-      shell: environment.ComSpec ?? environment.SHELL ?? "unknown",
+      shell: resolveRuntimeShell(process.platform, environment)?.command ?? "unknown",
       isGitRepository: await gitRepository
     });
     const createContext = (agent, agentTools, contextModelId, parentContext) => {
@@ -26327,8 +26856,8 @@ async function createProductionRuntime(options) {
         modelId,
         agent,
         providerError,
-        errorCode,
-        errorMessage: errorMessage3,
+        errorCode: errorCode3,
+        errorMessage: errorMessage4,
         attempt,
         maxAttempts,
         purpose,
@@ -26343,8 +26872,8 @@ async function createProductionRuntime(options) {
           event: "ModelCallFailure",
           model: typeof modelId === "string" ? modelId : void 0,
           agent: typeof agent === "string" ? agent : void 0,
-          errorCode: typeof errorCode === "string" ? errorCode : void 0,
-          errorMessage: typeof errorMessage3 === "string" ? errorMessage3 : void 0,
+          errorCode: typeof errorCode3 === "string" ? errorCode3 : void 0,
+          errorMessage: typeof errorMessage4 === "string" ? errorMessage4 : void 0,
           attempt: typeof attempt === "number" ? attempt : void 0,
           maxAttempts: typeof maxAttempts === "number" ? maxAttempts : void 0,
           purpose: typeof purpose === "string" ? purpose : void 0,
@@ -26387,6 +26916,7 @@ async function createProductionRuntime(options) {
         createGrepTool(input.workspace),
         createShellTool(input.workspace, {
           jobs,
+          environment,
           ...loopExecutionEnvironment === void 0 ? {} : { executionEnvironment: loopExecutionEnvironment }
         }),
         createWebFetchTool(),
@@ -26399,13 +26929,13 @@ async function createProductionRuntime(options) {
         evolveService.toolDefinition(),
         ...mcpTools
       ];
-      const loopFlavor = await optionalText2(join35(input.workspace, "FLAVOR.md"));
+      const loopFlavor = await optionalText2(join37(input.workspace, "FLAVOR.md"));
       const loopInstructionBaseline = await loopInstructions.baseline();
       const loopEnvironment = createPromptEnvironment({
         now: /* @__PURE__ */ new Date(),
         platform: process.platform,
         osVersion: `${osVersion()} ${osRelease()}`,
-        shell: environment.ComSpec ?? environment.SHELL ?? "unknown",
+        shell: resolveRuntimeShell(process.platform, environment)?.command ?? "unknown",
         isGitRepository: await detectGitRepository(input.workspace)
       });
       let compactionInputTokens = 0;
@@ -26758,10 +27288,10 @@ async function createProductionRuntime(options) {
       explain: (query, focus, signal, onText) => runExplain({
         graph: new DesktopAstGraphService(workspace),
         readFile: async (path) => {
-          const root = resolve34(workspace);
-          const abs = resolve34(root, path);
-          if (abs !== root && !abs.startsWith(root + sep23)) throw new Error(`path outside workspace: ${path}`);
-          return readFile27(abs, "utf8");
+          const root = resolve35(workspace);
+          const abs = resolve35(root, path);
+          if (abs !== root && !abs.startsWith(root + sep24)) throw new Error(`path outside workspace: ${path}`);
+          return readFile28(abs, "utf8");
         },
         history: async (path, limit) => fileHistory(workspace, path, limit),
         questions,
@@ -26773,7 +27303,7 @@ async function createProductionRuntime(options) {
       }, query, focus, signal),
       audit: async (toolFilter) => {
         try {
-          const raw = await readFile27(auditLogger.path, "utf8");
+          const raw = await readFile28(auditLogger.path, "utf8");
           const lines = raw.trim().split("\n").filter((line) => line.length > 0);
           const entries = lines.map((line) => {
             try {
@@ -26810,9 +27340,10 @@ ${summary2}`;
           return `Failed to read audit log: ${message(error)}`;
         }
       },
+      doctor: async () => formatDoctorReport(await runDoctor({ workspace, home, environment })),
       usage: async () => {
         try {
-          const raw = await readFile27(usageLogPath(), "utf8");
+          const raw = await readFile28(usageLogPath(), "utf8");
           return formatUsageSummary(summarizeUsage(parseUsageEntries(raw)));
         } catch (error) {
           if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
@@ -26965,7 +27496,7 @@ ${renderMemoryDocument(entries)}`;
           return `Provider "${providerName}" is missing authorizationUrl, tokenUrl, or clientId.`;
         }
         try {
-          const tokenStore = createFileTokenStore(join35(home, ".flavor-code", "auth.json"));
+          const tokenStore = createFileTokenStore(join37(home, ".flavor-code", "auth.json"));
           const credentialId = oauthCredentialId(oauthConfig.tokenUrl, oauthConfig.clientId);
           await migrateLegacyOAuthToken(tokenStore, providerName, credentialId);
           const oauth = new OAuthCallbackAuthProvider({
@@ -27012,7 +27543,7 @@ ${renderMemoryDocument(entries)}`;
         }
       },
       async logout() {
-        const tokenStore = createFileTokenStore(join35(home, ".flavor-code", "auth.json"));
+        const tokenStore = createFileTokenStore(join37(home, ".flavor-code", "auth.json"));
         const tokens2 = await tokenStore.load();
         const hadCredentials = Object.keys(tokens2).length > 0 || effectiveLlm !== void 0;
         if (!hadCredentials) {
@@ -27304,13 +27835,13 @@ async function workspaceFingerprint(workspace) {
   let remaining = 5 * 1024 * 1024;
   for (const name of untracked.stdout.split("\0").filter(Boolean).sort()) {
     if (name === ".flavor/loops" || name.startsWith(".flavor/loops/")) continue;
-    const path = resolve34(workspace, name);
-    const relativePath = relative23(resolve34(workspace), path);
-    if (relativePath === ".." || relativePath.startsWith(`..${sep23}`)) continue;
+    const path = resolve35(workspace, name);
+    const relativePath = relative24(resolve35(workspace), path);
+    if (relativePath === ".." || relativePath.startsWith(`..${sep24}`)) continue;
     hash.update(name);
     if (remaining <= 0) continue;
     try {
-      const content = await readFile27(path);
+      const content = await readFile28(path);
       const slice = content.subarray(0, remaining);
       hash.update(slice);
       remaining -= slice.length;
@@ -27540,7 +28071,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(join35(home, ".flavor-code", "auth.json"));
+  const oauthTokenStore = createFileTokenStore(join37(home, ".flavor-code", "auth.json"));
   const registered = [];
   let effectiveLlm;
   for (const [name, provider] of Object.entries(configured)) {
@@ -27809,7 +28340,7 @@ async function generateSleepReview(registry, modelId, prompt, signal) {
 }
 async function optionalText2(path) {
   try {
-    return await readFile27(path, "utf8");
+    return await readFile28(path, "utf8");
   } catch (error) {
     if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
     throw error;
@@ -27971,13 +28502,13 @@ function createMemoryTaskId() {
 
 // src/desktop/runtime-controller.ts
 import { createHash as createHash27 } from "crypto";
-import { mkdir as mkdir27, readFile as readFile35, readdir as readdir12, rm as rm15, stat as stat15, writeFile as writeFile17 } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { basename as basename9, join as join45, resolve as resolve37 } from "path";
+import { mkdir as mkdir27, readFile as readFile36, readdir as readdir13, rm as rm15, stat as stat16, writeFile as writeFile17 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { basename as basename10, join as join47, resolve as resolve38 } from "path";
 
 // src/d2c/workflow.ts
 import { createHash as createHash22 } from "crypto";
-import { join as join36 } from "path";
+import { join as join38 } from "path";
 import { z as z42 } from "zod";
 
 // src/d2c/workflow-shared.ts
@@ -28123,7 +28654,7 @@ function reviewsFor(report, previous) {
 function implementationDirectory(report) {
   const source = report.implementation.source;
   if (!/^https?:\/\//i.test(source)) return source;
-  return join36("src", "d2c-output", report.task);
+  return join38("src", "d2c-output", report.task);
 }
 function createWorkflow(report, framework) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -28247,7 +28778,7 @@ function applyQualityIssueDecision(workflow, issueId2, decision) {
   };
 }
 function workflowPath(workspace, task) {
-  return join36(taskDir(workspace, task), "workflow.json");
+  return join38(taskDir(workspace, task), "workflow.json");
 }
 async function readWorkflow(workspace, task) {
   return (await readRecoverableFile(workflowPath(workspace, task), decodeWorkflow))?.value;
@@ -28500,8 +29031,8 @@ function confirmApiMapping(mapping, operationKey, operations) {
 }
 
 // src/d2c/modules.ts
-import { readFile as readFile28 } from "fs/promises";
-import { isAbsolute as isAbsolute16, join as join37, normalize as normalize2, posix, sep as sep24, win32 as win322 } from "path";
+import { readFile as readFile29 } from "fs/promises";
+import { isAbsolute as isAbsolute17, join as join39, normalize as normalize2, posix, sep as sep25, win32 as win322 } from "path";
 import { z as z43 } from "zod";
 var ModuleSchema = z43.object({
   id: z43.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
@@ -28513,20 +29044,20 @@ var ModuleSchema = z43.object({
 }).strict();
 var ManifestSchema3 = z43.object({ schema: z43.literal(1), modules: z43.array(ModuleSchema).min(1).max(500) }).passthrough();
 function safeSource(path) {
-  if (isAbsolute16(path) || posix.isAbsolute(path) || win322.isAbsolute(path) || path.includes("\0")) return false;
+  if (isAbsolute17(path) || posix.isAbsolute(path) || win322.isAbsolute(path) || path.includes("\0")) return false;
   const value = normalize2(path);
   const portableSegments = path.replaceAll("\\", "/").split("/");
-  return value !== ".." && !value.startsWith(`..${sep24}`) && !portableSegments.includes("..");
+  return value !== ".." && !value.startsWith(`..${sep25}`) && !portableSegments.includes("..");
 }
 function d2cOutputDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error(`Invalid D2C task: ${task}`);
-  return join37(workspace, "src", "d2c-output", task);
+  return join39(workspace, "src", "d2c-output", task);
 }
 async function readD2cModules(workspace, task) {
   const project = d2cOutputDirectory(workspace, task);
   let raw;
   try {
-    raw = await readFile28(join37(project, "d2c.modules.json"), "utf8");
+    raw = await readFile29(join39(project, "d2c.modules.json"), "utf8");
   } catch {
     return [{ id: "page", label: task, sourceFiles: ["src/App.vue", "src/App.jsx"], keywords: [task] }];
   }
@@ -28546,8 +29077,8 @@ async function readD2cModules(workspace, task) {
 }
 
 // src/d2c/integration.ts
-import { mkdir as mkdir24, readFile as readFile29, writeFile as writeFile13 } from "fs/promises";
-import { join as join38 } from "path";
+import { mkdir as mkdir24, readFile as readFile30, writeFile as writeFile13 } from "fs/promises";
+import { join as join40 } from "path";
 function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -28683,19 +29214,19 @@ async def reset_acceptance(request: Request):
 }
 async function generateIntegrationArtifacts(projectDir, document, mappings, options = {}) {
   if (mappings.some((mapping) => mapping.status === "needs-confirmation")) throw new Error("Confirm every uncertain OpenAPI mapping before generating integration code");
-  const packagePath = join38(projectDir, "package.json");
+  const packagePath = join40(projectDir, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(await readFile29(packagePath, "utf8"));
+    pkg = JSON.parse(await readFile30(packagePath, "utf8"));
   } catch {
     throw new Error(`D2C integration requires a valid package.json at ${packagePath}`);
   }
   const scripts = options.pythonServer ? { ...record2(pkg.scripts) ?? {} } : { ...record2(pkg.scripts) ?? {}, mock: "node mock/server.mjs" };
   const dependencies2 = options.pythonServer ? { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9" } : { ...record2(pkg.dependencies) ?? {}, axios: "^1.7.9", express: "^5.2.1" };
   const selected = [...new Set(mappings.map((mapping) => mapping.operationKey))].map((key) => document.operations.find((operation) => operation.id === key)).filter((operation) => operation !== void 0);
-  const apiDir = join38(projectDir, "src", "api");
-  const mockDir = join38(projectDir, "mock");
-  const serverDir = join38(projectDir, "server");
+  const apiDir = join40(projectDir, "src", "api");
+  const mockDir = join40(projectDir, "mock");
+  const serverDir = join40(projectDir, "server");
   await Promise.all([
     mkdir24(apiDir, { recursive: true }),
     ...options.pythonServer ? [] : [mkdir24(mockDir, { recursive: true })],
@@ -28705,23 +29236,23 @@ async function generateIntegrationArtifacts(projectDir, document, mappings, opti
   if (options.pythonServer) files.push("server/main.py", "server/requirements.txt", "server/README.md", "server/flavor-runtime.json");
   else files.push("mock/server.mjs");
   await Promise.all([
-    writeFile13(join38(apiDir, "http.js"), `import axios from "axios";
+    writeFile13(join40(apiDir, "http.js"), `import axios from "axios";
 
 export const http = axios.create({ baseURL: import.meta.env.VITE_API_BASE_URL || ${JSON.stringify(document.baseUrl ?? "")}, timeout: 15000 });
 
 http.interceptors.response.use((response) => response, (error) => Promise.reject({ name: "ApiError", status: error.response?.status, message: error.response?.data?.message || error.message, cause: error }));
 `),
-    writeFile13(join38(apiDir, "d2c-api.js"), apiModule(selected)),
-    writeFile13(join38(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
+    writeFile13(join40(apiDir, "d2c-api.js"), apiModule(selected)),
+    writeFile13(join40(apiDir, "d2c-bindings.json"), `${JSON.stringify({ schema: 1, generatedAt: (/* @__PURE__ */ new Date()).toISOString(), mappings }, null, 2)}
 `),
-    ...options.pythonServer ? [] : [writeFile13(join38(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
+    ...options.pythonServer ? [] : [writeFile13(join40(mockDir, "server.mjs"), mockModule({ ...document, operations: selected }))],
     writeFile13(packagePath, `${JSON.stringify({ ...pkg, scripts, dependencies: dependencies2 }, null, 2)}
 `),
     ...options.pythonServer ? [
-      writeFile13(join38(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
-      writeFile13(join38(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
-      writeFile13(join38(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
-      writeFile13(join38(serverDir, "flavor-runtime.json"), `${JSON.stringify({
+      writeFile13(join40(serverDir, "main.py"), pythonServerModule({ ...document, operations: selected })),
+      writeFile13(join40(serverDir, "requirements.txt"), "fastapi>=0.116,<1\nuvicorn[standard]>=0.35,<1\nsqlalchemy>=2.0,<3\n"),
+      writeFile13(join40(serverDir, "README.md"), "# Python API service\n\nThis is the real integration service, not a mock. Development defaults to SQLite through `DATABASE_URL=sqlite:///./data/app.db`. Set the same environment variable to a SQLAlchemy MySQL or PostgreSQL URL for deployment; keep schema changes in migrations instead of database-specific SQL. Flavor Code starts the service automatically for acceptance.\n"),
+      writeFile13(join40(serverDir, "flavor-runtime.json"), `${JSON.stringify({
         schema: 1,
         kind: "python-fastapi",
         cwd: "server",
@@ -28740,12 +29271,12 @@ http.interceptors.response.use((response) => response, (error) => Promise.reject
 
 // src/d2c/mock-runner.ts
 import { spawn as spawn8 } from "child_process";
-import { access as access3, readFile as readFile30 } from "fs/promises";
+import { access as access4, readFile as readFile31 } from "fs/promises";
 import { createServer as createServer5 } from "net";
-import { join as join39 } from "path";
+import { join as join41 } from "path";
 async function exists3(path) {
   try {
-    await access3(path);
+    await access4(path);
     return true;
   } catch {
     return false;
@@ -28850,7 +29381,7 @@ ${output.trim()}` : ""}`);
   }
 }
 async function runPythonBackend(projectDir, options) {
-  const serverDir = join39(projectDir, "server");
+  const serverDir = join41(projectDir, "server");
   if (options.installDependencies !== false) await installPython(serverDir, options.signal);
   const selectedPort = await port();
   const url = `http://127.0.0.1:${selectedPort}`;
@@ -28896,20 +29427,20 @@ ${managed.output().slice(-4e3)}`);
   };
 }
 async function runD2cMockServer(projectDir, options = {}) {
-  const runtimePath = join39(projectDir, "server", "flavor-runtime.json");
+  const runtimePath = join41(projectDir, "server", "flavor-runtime.json");
   if (await exists3(runtimePath)) {
     let runtime;
     try {
-      runtime = JSON.parse(await readFile30(runtimePath, "utf8"));
+      runtime = JSON.parse(await readFile31(runtimePath, "utf8"));
     } catch {
       throw new Error(`E2E backend runtime manifest is invalid at ${runtimePath}`);
     }
     if (runtime.schema !== 1 || runtime.kind !== "python-fastapi") throw new Error("Unsupported E2E backend runtime manifest");
     return runPythonBackend(projectDir, options);
   }
-  const serverPath = join39(projectDir, "mock", "server.mjs");
+  const serverPath = join41(projectDir, "mock", "server.mjs");
   if (!await exists3(serverPath)) throw new Error(`D2C mock server is not generated at ${serverPath}`);
-  if (options.installDependencies === false && !await exists3(join39(projectDir, "node_modules", "express", "package.json"))) {
+  if (options.installDependencies === false && !await exists3(join41(projectDir, "node_modules", "express", "package.json"))) {
     throw new Error("D2C mock server dependencies are not installed");
   }
   if (options.installDependencies !== false) await install(projectDir, options.signal);
@@ -28951,13 +29482,13 @@ ${managed.output().slice(-4e3)}`);
 
 // src/d2c/product.ts
 import { createHash as createHash24, randomUUID as randomUUID27 } from "crypto";
-import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile32, rename as rename13, stat as stat13, unlink as unlink7, writeFile as writeFile15 } from "fs/promises";
-import { join as join40 } from "path";
+import { copyFile as copyFile2, mkdir as mkdir25, readFile as readFile33, rename as rename13, stat as stat14, unlink as unlink7, writeFile as writeFile15 } from "fs/promises";
+import { join as join42 } from "path";
 import { z as z44 } from "zod";
 
 // src/e2e/prd-governance.ts
 import { createHash as createHash23, randomUUID as randomUUID26 } from "crypto";
-import { readFile as readFile31, rename as rename12, rm as rm13, writeFile as writeFile14 } from "fs/promises";
+import { readFile as readFile32, rename as rename12, rm as rm13, writeFile as writeFile14 } from "fs/promises";
 function hashPrd(markdown) {
   return createHash23("sha256").update(markdown, "utf8").digest("hex");
 }
@@ -29034,14 +29565,14 @@ function approvePrd(markdown, now = /* @__PURE__ */ new Date()) {
   return { hash: hashPrd(markdown), approvedAt: now.toISOString(), criteria };
 }
 async function assertApprovedPrd(path, approved) {
-  const current = await readFile31(path, "utf8");
+  const current = await readFile32(path, "utf8");
   if (hashPrd(current) !== approved.hash) {
     throw new Error("PRD_LOCK_VIOLATION: confirmed PRD content changed after approval");
   }
   return approved;
 }
 async function updatePrdSectionFile(path, input) {
-  const current = await readFile31(path, "utf8");
+  const current = await readFile32(path, "utf8");
   if (hashPrd(current) !== input.expectedHash) {
     throw new Error("PRD_EDIT_CONFLICT: the PRD changed; refresh before saving this section");
   }
@@ -29107,13 +29638,13 @@ var PlanSchema2 = z44.object({
 }).strict();
 function d2cProductDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error("Invalid D2C task name");
-  return join40(taskDir(workspace, task), "product");
+  return join42(taskDir(workspace, task), "product");
 }
 function d2cProductPrototypeDirectory(workspace, task) {
-  return join40(d2cProductDirectory(workspace, task), "prototype");
+  return join42(d2cProductDirectory(workspace, task), "prototype");
 }
 function planPath(workspace, task) {
-  return join40(taskDir(workspace, task), "product-plan.json");
+  return join42(taskDir(workspace, task), "product-plan.json");
 }
 function resolveD2cProductTechnology(requirement, fallbackFramework = "vue") {
   const frontendCandidates = [
@@ -29201,18 +29732,18 @@ function buildD2cProductOpenApi(task, modules) {
 `;
 }
 async function fileTimestamp(path) {
-  const info = await stat13(path).catch(() => void 0);
+  const info = await stat14(path).catch(() => void 0);
   return info?.isFile() ? info.mtime.toISOString() : void 0;
 }
 async function fileHash(path) {
-  const buffer = await readFile32(path).catch((error) => {
+  const buffer = await readFile33(path).catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
   return buffer === void 0 ? void 0 : createHash24("sha256").update(buffer).digest("hex");
 }
 async function validateAndNormalizePrototypeManifest(path) {
-  const raw = await readFile32(path, "utf8").catch((error) => {
+  const raw = await readFile33(path, "utf8").catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
@@ -29288,7 +29819,7 @@ async function createD2cProductPlan(workspace, input, now = () => /* @__PURE__ *
   });
 }
 async function readD2cProductPlan(workspace, task) {
-  const raw = await readFile32(planPath(workspace, task), "utf8").catch((error) => {
+  const raw = await readFile33(planPath(workspace, task), "utf8").catch((error) => {
     if (error.code === "ENOENT") return void 0;
     throw error;
   });
@@ -29296,16 +29827,16 @@ async function readD2cProductPlan(workspace, task) {
 }
 async function discoverD2cProductArtifacts(workspace, plan) {
   const product = d2cProductDirectory(workspace, plan.task);
-  const prdUpdatedAt = await fileTimestamp(join40(product, "prd.md"));
-  const prdHash = await fileHash(join40(product, "prd.md"));
-  const prototypeUpdatedAt = await fileTimestamp(join40(product, "prototype", "index.html"));
-  const prototypeHash = await fileHash(join40(product, "prototype", "index.html"));
-  const expectedManifest = join40(product, "prototype", "interaction-manifest.json");
+  const prdUpdatedAt = await fileTimestamp(join42(product, "prd.md"));
+  const prdHash = await fileHash(join42(product, "prd.md"));
+  const prototypeUpdatedAt = await fileTimestamp(join42(product, "prototype", "index.html"));
+  const prototypeHash = await fileHash(join42(product, "prototype", "index.html"));
+  const expectedManifest = join42(product, "prototype", "interaction-manifest.json");
   let manifestUpdatedAt = await fileTimestamp(expectedManifest);
   if (manifestUpdatedAt === void 0) {
-    const misplacedManifest = join40(product, "interaction-manifest.json");
+    const misplacedManifest = join42(product, "interaction-manifest.json");
     if (await fileTimestamp(misplacedManifest) !== void 0) {
-      await mkdir25(join40(product, "prototype"), { recursive: true });
+      await mkdir25(join42(product, "prototype"), { recursive: true });
       await copyFile2(misplacedManifest, expectedManifest);
       manifestUpdatedAt = await fileTimestamp(expectedManifest);
     }
@@ -29338,8 +29869,8 @@ async function readD2cProductPlanView(workspace, task) {
   if (stored === void 0) return void 0;
   const plan = await discoverD2cProductArtifacts(workspace, stored);
   if (plan.revision !== stored.revision) await writeD2cProductPlan(workspace, plan);
-  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile32(join40(taskDir(workspace, task), plan.prd.path), "utf8");
-  const manifestPath = join40(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
+  const prdMarkdown = plan.prd === void 0 ? void 0 : await readFile33(join42(taskDir(workspace, task), plan.prd.path), "utf8");
+  const manifestPath = join42(d2cProductDirectory(workspace, task), "prototype", "interaction-manifest.json");
   const validationError = plan.phase === "design-generating" && await fileTimestamp(manifestPath) !== void 0 ? await validateAndNormalizePrototypeManifest(manifestPath) : void 0;
   return {
     plan,
@@ -29429,9 +29960,9 @@ ${prdMarkdown.slice(0, 2e4)}`
 
 // src/e2e/acceptance-baseline.ts
 import { createHash as createHash25 } from "crypto";
-import { readFile as readFile33 } from "fs/promises";
+import { readFile as readFile34 } from "fs/promises";
 async function fileArtifact(path) {
-  const content = await readFile33(path);
+  const content = await readFile34(path);
   return { path, hash: createHash25("sha256").update(content).digest("hex"), bytes: content.byteLength };
 }
 async function verifyAcceptanceArtifact(path, expected, label) {
@@ -29498,7 +30029,7 @@ function createAcceptanceEvidence(coverage, run, now = /* @__PURE__ */ new Date(
 
 // src/e2e/delivery-run.ts
 import { createHash as createHash26 } from "crypto";
-import { join as join41 } from "path";
+import { join as join43 } from "path";
 import { z as z45 } from "zod";
 var DELIVERY_NODE_IDS = ["requirement", "prd", "design", "d2c", "api", "acceptance", "delivery"];
 var ArtifactSchema = z45.object({
@@ -29615,7 +30146,7 @@ function completeDeliveryNode(run, node, outputs, now = /* @__PURE__ */ new Date
   return { ...run, nodes, updatedAt: timestamp2 };
 }
 function deliveryRunPath(workspace, task) {
-  return join41(taskDir(workspace, task), "delivery-run.json");
+  return join43(taskDir(workspace, task), "delivery-run.json");
 }
 function decodeDeliveryRun(raw) {
   return DeliveryRunSchema.parse(JSON.parse(raw));
@@ -29656,16 +30187,16 @@ async function updateDeliveryRun(workspace, task, expectedRevision, mutation) {
 }
 
 // src/skills/manager.ts
-import { lstat as lstat13, mkdir as mkdir26, readFile as readFile34, readdir as readdir11, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { isAbsolute as isAbsolute17, join as join42, relative as relative24, resolve as resolve35, sep as sep25 } from "path";
+import { lstat as lstat14, mkdir as mkdir26, readFile as readFile35, readdir as readdir12, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { isAbsolute as isAbsolute18, join as join44, relative as relative25, resolve as resolve36, sep as sep26 } from "path";
 import { stringify } from "yaml";
 var SkillManager = class {
   #workspace;
   #home;
   constructor(options) {
-    this.#workspace = resolve35(options.workspace);
-    this.#home = resolve35(options.home ?? homedir3());
+    this.#workspace = resolve36(options.workspace);
+    this.#home = resolve36(options.home ?? homedir4());
   }
   async list() {
     const { registry, disabled } = await this.#registry();
@@ -29681,7 +30212,7 @@ var SkillManager = class {
   async create(draft) {
     const value = parseDraft(draft);
     const projectRoot = this.#projectRoot();
-    const directory = join42(projectRoot, value.name);
+    const directory = join44(projectRoot, value.name);
     await mkdir26(projectRoot, { recursive: true, mode: 448 });
     try {
       await mkdir26(directory, { mode: 448 });
@@ -29690,7 +30221,7 @@ var SkillManager = class {
       throw error;
     }
     try {
-      await writeFile16(join42(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
+      await writeFile16(join44(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
       await this.#persistEnabled(value.name, true);
       return this.get(value.name);
     } catch (error) {
@@ -29703,13 +30234,13 @@ var SkillManager = class {
     const value = parseDraft(draft);
     if (value.name !== validName) throw new Error("Rename is not supported; create a new skill instead");
     const directory = this.#projectSkillDirectory(validName);
-    const info = await lstat13(directory).catch((error) => {
+    const info = await lstat14(directory).catch((error) => {
       if (isCode11(error, "ENOENT")) throw new Error(`Project skill not found: ${validName}`);
       throw error;
     });
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Project skill path is not a real directory: ${validName}`);
-    const skillFile = join42(directory, "SKILL.md");
-    const fileInfo = await lstat13(skillFile);
+    const skillFile = join44(directory, "SKILL.md");
+    const fileInfo = await lstat14(skillFile);
     if (!fileInfo.isFile() || fileInfo.isSymbolicLink()) throw new Error(`Project skill file is not a real file: ${validName}`);
     await writeFile16(skillFile, renderSkill(value), { encoding: "utf8", mode: 384 });
     return this.get(validName);
@@ -29717,7 +30248,7 @@ var SkillManager = class {
   async delete(name) {
     const validName = parseName(name);
     const directory = this.#projectSkillDirectory(validName);
-    const info = await lstat13(directory).catch((error) => {
+    const info = await lstat14(directory).catch((error) => {
       if (isCode11(error, "ENOENT")) throw new Error(`Project skill not found: ${validName}`);
       throw error;
     });
@@ -29740,12 +30271,12 @@ var SkillManager = class {
   async #registry() {
     const loaded = await loadConfig({ cwd: this.#workspace, home: this.#home });
     const [globalPluginRoots, projectPluginRoots] = await Promise.all([
-      discoverPluginSkillRoots(join42(this.#home, ".flavor-code", "plugins")),
-      discoverPluginSkillRoots(join42(this.#workspace, ".flavor", "plugins"))
+      discoverPluginSkillRoots(join44(this.#home, ".flavor-code", "plugins")),
+      discoverPluginSkillRoots(join44(this.#workspace, ".flavor", "plugins"))
     ]);
     return {
       registry: new SkillRegistry({
-        globalRoots: [join42(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
+        globalRoots: [join44(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
         projectRoots: [this.#projectRoot(), ...projectPluginRoots]
       }),
       disabled: new Set(loaded.config.skills.disabled)
@@ -29761,10 +30292,10 @@ var SkillManager = class {
     };
   }
   #projectRoot() {
-    return join42(this.#workspace, ".flavor", "skills");
+    return join44(this.#workspace, ".flavor", "skills");
   }
   #projectSkillDirectory(name) {
-    return join42(this.#projectRoot(), name);
+    return join44(this.#projectRoot(), name);
   }
 };
 function parseName(value) {
@@ -29797,7 +30328,7 @@ function isCode11(error, code) {
 async function discoverPluginSkillRoots(directory) {
   let entries;
   try {
-    entries = await readdir11(directory, { withFileTypes: true });
+    entries = await readdir12(directory, { withFileTypes: true });
   } catch (error) {
     if (isCode11(error, "ENOENT")) return [];
     throw error;
@@ -29805,16 +30336,16 @@ async function discoverPluginSkillRoots(directory) {
   const roots = [];
   for (const entry2 of entries) {
     if (!entry2.isDirectory() || entry2.isSymbolicLink()) continue;
-    const pluginRoot = await realpath13(join42(directory, entry2.name));
+    const pluginRoot = await realpath13(join44(directory, entry2.name));
     try {
-      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile34(join42(pluginRoot, "flavor-plugin.json"), "utf8")));
+      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile35(join44(pluginRoot, "flavor-plugin.json"), "utf8")));
       for (const contribution of manifest.contributes.skillRoots) {
-        const candidate = resolve35(pluginRoot, contribution.path);
-        const info = await lstat13(candidate);
+        const candidate = resolve36(pluginRoot, contribution.path);
+        const info = await lstat14(candidate);
         if (!info.isDirectory() || info.isSymbolicLink()) continue;
         const physical = await realpath13(candidate);
-        const relation = relative24(pluginRoot, physical);
-        if (relation === ".." || relation.startsWith(`..${sep25}`) || isAbsolute17(relation)) continue;
+        const relation = relative25(pluginRoot, physical);
+        if (relation === ".." || relation.startsWith(`..${sep26}`) || isAbsolute18(relation)) continue;
         roots.push(physical);
       }
     } catch {
@@ -29882,11 +30413,11 @@ async function createProjectMemoryManager(options) {
 }
 
 // src/mcp/config-manager.ts
-import { join as join43 } from "path";
+import { join as join45 } from "path";
 var ProjectMcpConfigManager = class {
   path;
   constructor(workspace) {
-    this.path = join43(workspace, ".flavor", "flavor.json");
+    this.path = join45(workspace, ".flavor", "flavor.json");
   }
   async list() {
     const document = await readRecoverableFile(this.path, (raw) => parseDocument2(this.path, raw));
@@ -29983,7 +30514,7 @@ function isRecord7(value) {
 }
 
 // src/desktop/model-config.ts
-import { join as join44 } from "path";
+import { join as join46 } from "path";
 var DEFAULT_DESKTOP_MODELS = [
   {
     id: "anthropic:deepseek-v4-pro",
@@ -30004,7 +30535,7 @@ var DEFAULT_DESKTOP_MODELS = [
 ];
 async function loadDesktopModels(workspace, home) {
   try {
-    const tokens2 = await createFileTokenStore(join44(home, ".flavor-code", "auth.json")).load();
+    const tokens2 = await createFileTokenStore(join46(home, ".flavor-code", "auth.json")).load();
     const pkceModels = [];
     const knownPkce = /* @__PURE__ */ new Set();
     for (const token of Object.values(tokens2)) {
@@ -30072,9 +30603,9 @@ function protocolLabel(type) {
 
 // src/desktop/d2c-product-preview.ts
 import { createReadStream as createReadStream2 } from "fs";
-import { realpath as realpath14, stat as stat14 } from "fs/promises";
+import { realpath as realpath14, stat as stat15 } from "fs/promises";
 import { createServer as createServer6 } from "http";
-import { extname as extname4, isAbsolute as isAbsolute18, relative as relative25, resolve as resolve36, sep as sep26 } from "path";
+import { extname as extname4, isAbsolute as isAbsolute19, relative as relative26, resolve as resolve37, sep as sep27 } from "path";
 var MIME_TYPES = {
   ".css": "text/css; charset=utf-8",
   ".gif": "image/gif",
@@ -30092,12 +30623,12 @@ function sendNotFound(response2) {
   response2.end("Not found");
 }
 function isInside(root, candidate) {
-  const delta = relative25(root, candidate);
-  return delta === "" || !delta.startsWith(`..${sep26}`) && delta !== ".." && !isAbsolute18(delta);
+  const delta = relative26(root, candidate);
+  return delta === "" || !delta.startsWith(`..${sep27}`) && delta !== ".." && !isAbsolute19(delta);
 }
 async function startD2cProductPreview(rootDirectory) {
-  const root = await realpath14(resolve36(rootDirectory));
-  const rootInfo = await stat14(root);
+  const root = await realpath14(resolve37(rootDirectory));
+  const rootInfo = await stat15(root);
   if (!rootInfo.isDirectory()) throw new Error("D2C product prototype directory is unavailable");
   const server = createServer6(async (request, response2) => {
     response2.setHeader("cache-control", "no-store");
@@ -30108,11 +30639,11 @@ async function startD2cProductPreview(rootDirectory) {
       let pathname = decodeURIComponent(url.pathname);
       if (pathname === "/") pathname = "/index.html";
       if (pathname.includes("\0")) return sendNotFound(response2);
-      const unresolved = resolve36(root, `.${pathname}`);
+      const unresolved = resolve37(root, `.${pathname}`);
       if (!isInside(root, unresolved)) return sendNotFound(response2);
       const target = await realpath14(unresolved).catch(() => void 0);
       if (target === void 0 || !isInside(root, target)) return sendNotFound(response2);
-      const info = await stat14(target);
+      const info = await stat15(target);
       if (!info.isFile()) return sendNotFound(response2);
       response2.writeHead(200, {
         "content-length": info.size,
@@ -30149,33 +30680,33 @@ function pngDataUrl(png) {
 }
 async function detectD2cFramework(workspace, task) {
   try {
-    const pkg = JSON.parse(await readFile35(join45(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
+    const pkg = JSON.parse(await readFile36(join47(d2cOutputDirectory(workspace, task), "package.json"), "utf8"));
     return pkg.dependencies?.react === void 0 ? "vue" : "react";
   } catch {
     return "vue";
   }
 }
 function integrationDirectory(workspace, task) {
-  return join45(workspace, ".flavor", "d2c", task, "integration");
+  return join47(workspace, ".flavor", "d2c", task, "integration");
 }
 var D2C_BACKEND_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".cfg", ".env", ".ini", ".js", ".json", ".lock", ".mjs", ".py", ".toml", ".txt", ".yaml", ".yml"]);
 var D2C_BACKEND_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".venv", "__pycache__", "data", "node_modules", "venv"]);
 async function d2cBackendSourceFingerprint(project) {
-  const runtimeManifest = join45(project, "server", "flavor-runtime.json");
-  const realBackend = (await stat15(runtimeManifest).catch(() => void 0))?.isFile() === true;
-  const root = realBackend ? join45(project, "server") : join45(project, "mock");
-  if ((await stat15(root).catch(() => void 0))?.isDirectory() !== true) return void 0;
+  const runtimeManifest = join47(project, "server", "flavor-runtime.json");
+  const realBackend = (await stat16(runtimeManifest).catch(() => void 0))?.isFile() === true;
+  const root = realBackend ? join47(project, "server") : join47(project, "mock");
+  if ((await stat16(root).catch(() => void 0))?.isDirectory() !== true) return void 0;
   const files = [];
   const visit = async (directory) => {
-    const entries = await readdir12(directory, { withFileTypes: true });
+    const entries = await readdir13(directory, { withFileTypes: true });
     for (const entry2 of entries) {
       if (entry2.isDirectory()) {
-        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join45(directory, entry2.name));
+        if (!D2C_BACKEND_IGNORED_DIRECTORIES.has(entry2.name)) await visit(join47(directory, entry2.name));
         continue;
       }
       if (!entry2.isFile()) continue;
       const extension2 = entry2.name.includes(".") ? `.${entry2.name.split(".").pop().toLowerCase()}` : "";
-      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join45(directory, entry2.name));
+      if (D2C_BACKEND_SOURCE_EXTENSIONS.has(extension2)) files.push(join47(directory, entry2.name));
     }
   };
   await visit(root);
@@ -30183,7 +30714,7 @@ async function d2cBackendSourceFingerprint(project) {
   for (const path of files.sort()) {
     hash.update(path.slice(root.length));
     hash.update("\0");
-    hash.update(await readFile35(path));
+    hash.update(await readFile36(path));
     hash.update("\0");
   }
   return hash.digest("hex");
@@ -30227,7 +30758,7 @@ var DesktopRuntimeController = class {
   /** Backend source digest observed when the managed process was started. */
   #d2cMockSourceFingerprints = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.#home = resolve37(options.home ?? homedir4());
+    this.#home = resolve38(options.home ?? homedir5());
     this.#createRuntime = options.createRuntime ?? (async (runtimeOptions) => createProductionRuntime(runtimeOptions));
     this.#createTerminalService = options.createTerminalService ?? ((workspace) => new TerminalService(workspace));
     this.#listSessions = options.listSessions ?? (async (workspace) => {
@@ -30302,7 +30833,7 @@ var DesktopRuntimeController = class {
     };
   }
   async openWorkspace(path) {
-    const workspace = resolve37(path);
+    const workspace = resolve38(path);
     if (workspace !== this.#workspace) {
       await this.#disposeRuntime();
       await this.#stopAllD2cPreviews();
@@ -30729,8 +31260,8 @@ var DesktopRuntimeController = class {
     if (workflow === void 0 || !reviewProgress(workflow).complete || workflow.stage === "visual-review") {
       throw new Error("Complete visual review before importing OpenAPI");
     }
-    const moduleManifest = join45(d2cOutputDirectory(workspace, task), "d2c.modules.json");
-    const moduleManifestInfo = await stat15(moduleManifest).catch(() => void 0);
+    const moduleManifest = join47(d2cOutputDirectory(workspace, task), "d2c.modules.json");
+    const moduleManifestInfo = await stat16(moduleManifest).catch(() => void 0);
     if (moduleManifestInfo === void 0 || !moduleManifestInfo.isFile()) {
       throw new Error("D2C implementation must write d2c.modules.json before API mapping; ask the agent to split the project into modules first");
     }
@@ -30742,8 +31273,8 @@ var DesktopRuntimeController = class {
     await mkdir27(dir, { recursive: true });
     const hash = createHash27("sha256").update(raw).digest("hex");
     await Promise.all([
-      writeFile17(join45(dir, "swagger.json"), raw),
-      writeFile17(join45(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
+      writeFile17(join47(dir, "swagger.json"), raw),
+      writeFile17(join47(dir, "openapi.normalized.json"), `${JSON.stringify(document, null, 2)}
 `)
     ]);
     const next = {
@@ -30767,9 +31298,9 @@ var DesktopRuntimeController = class {
     const workspace = this.#workspace;
     if (workspace === void 0) throw new Error("Open a project before importing OpenAPI");
     await this.#assertProductPrdLocked(workspace, task);
-    const info = await stat15(sourcePath);
+    const info = await stat16(sourcePath);
     if (!info.isFile() || info.size > 8 * 1024 * 1024) throw new Error("OpenAPI JSON must be a file no larger than 8 MiB");
-    return this.#storeD2cOpenApi(workspace, task, basename9(sourcePath), await readFile35(sourcePath, "utf8"), false);
+    return this.#storeD2cOpenApi(workspace, task, basename10(sourcePath), await readFile36(sourcePath, "utf8"), false);
   }
   async getD2cIntegration(task) {
     const workspace = this.#workspace;
@@ -30778,8 +31309,8 @@ var DesktopRuntimeController = class {
     let workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi === void 0 && workflow !== void 0 && reviewProgress(workflow).complete && await readD2cProductPlanView(workspace, task) !== void 0) {
       const modules = await readD2cModules(workspace, task);
-      const productOpenApiPath = join45(taskDir(workspace, task), "product", "openapi.json");
-      const authored = await readFile35(productOpenApiPath, "utf8").catch(() => void 0);
+      const productOpenApiPath = join47(taskDir(workspace, task), "product", "openapi.json");
+      const authored = await readFile36(productOpenApiPath, "utf8").catch(() => void 0);
       const generated = authored === void 0;
       const prepared = await this.#storeD2cOpenApi(
         workspace,
@@ -30791,7 +31322,7 @@ var DesktopRuntimeController = class {
       return prepared;
     }
     if (workflow?.openapi === void 0 || workflow.mappings === void 0) return void 0;
-    const document = JSON.parse(await readFile35(join45(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
+    const document = JSON.parse(await readFile36(join47(integrationDirectory(workspace, task), "openapi.normalized.json"), "utf8"));
     return { workflow, document, mappings: workflow.mappings };
   }
   async confirmD2cMapping(task, moduleId, operationKey) {
@@ -30858,7 +31389,7 @@ var DesktopRuntimeController = class {
     ].join("\n");
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery?.nodes.api.status === "running") {
-      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile35(join45(project, file)))));
+      const apiArtifacts = await Promise.all(generated.files.map(async (file) => artifactRef(file, await readFile36(join47(project, file)))));
       const completed = await updateDeliveryRun(
         workspace,
         task,
@@ -30885,8 +31416,8 @@ var DesktopRuntimeController = class {
     try {
       const fingerprint2 = await d2cBackendSourceFingerprint(project);
       if (fingerprint2 !== void 0) this.#d2cMockSourceFingerprints.set(task, fingerprint2);
-      const environmentPath = join45(project, ".env.local");
-      const existingEnvironment = await readFile35(environmentPath, "utf8").catch(() => "");
+      const environmentPath = join47(project, ".env.local");
+      const existingEnvironment = await readFile36(environmentPath, "utf8").catch(() => "");
       const environment = `${existingEnvironment.split(/\r?\n/).filter((line) => !/^\s*VITE_API_BASE_URL\s*=/.test(line)).join("\n").trim()}
 VITE_API_BASE_URL=${running.url}
 `.replace(/^\n/, "");
@@ -30966,8 +31497,8 @@ VITE_API_BASE_URL=${running.url}
     const readyPreview = this.#d2cPreviews.get(task);
     const readyMock = this.#d2cMocks.get(task);
     if (readyPreview === void 0 || readyMock === void 0) throw new Error("D2C preview or backend service is unavailable after synchronization");
-    const manifestPath = join45(taskDir(workspace, task), "design", "interaction-manifest.json");
-    const manifest = parseInteractionManifest(await readFile35(manifestPath, "utf8"));
+    const manifestPath = join47(taskDir(workspace, task), "design", "interaction-manifest.json");
+    const manifest = parseInteractionManifest(await readFile36(manifestPath, "utf8"));
     const baseline = await this.#verifyAcceptanceBaseline(workspace, task);
     const coverage = baseline === void 0 ? void 0 : verifyRequirementCoverage(baseline.approvedPrd.criteria, manifest);
     let executableManifest = manifest;
@@ -30978,7 +31509,7 @@ VITE_API_BASE_URL=${running.url}
       await mkdir27(planDir, { recursive: true });
       try {
         const observations = await this.#observeD2cPages(manifest, readyPreview.url);
-        const prd = await readFile35(join45(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
+        const prd = await readFile36(join47(taskDir(workspace, task), "product", "prd.md"), "utf8").catch(() => void 0);
         const apiContext = JSON.stringify({ openapi: workflow.openapi, mappings: workflow.mappings }, null, 2);
         const plan = await this.#d2cJudge.planInteractions({ task, seed: manifest, observations, ...prd === void 0 ? {} : { prd }, apiContext });
         executableManifest = mergeInteractionManifests(manifest, plan.manifest);
@@ -30989,9 +31520,9 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: executableManifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           pageAnalyses: plan.pageAnalyses
         };
-        await writeFile17(join45(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
+        await writeFile17(join47(planDir, "autonomous-interaction-plan.json"), `${JSON.stringify({ ...plan, manifest: executableManifest }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
-        await rm15(join45(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
+        await rm15(join47(planDir, "autonomous-interaction-diagnostic.json"), { force: true });
       } catch (cause) {
         const detail = message(cause);
         review = {
@@ -30999,8 +31530,8 @@ VITE_API_BASE_URL=${running.url}
           plannedScenarios: manifest.pages.reduce((total, page) => total + page.scenarios.length, 0),
           warning: `\u591A\u6A21\u6001\u81EA\u4E3B\u89C4\u5212\u5931\u8D25\uFF0C\u5DF2\u7EE7\u7EED\u6267\u884C\u5DF2\u786E\u8BA4\u7684\u8BBE\u8BA1\u5951\u7EA6\uFF1A${detail}`
         };
-        await rm15(join45(planDir, "autonomous-interaction-plan.json"), { force: true });
-        await writeFile17(join45(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
+        await rm15(join47(planDir, "autonomous-interaction-plan.json"), { force: true });
+        await writeFile17(join47(planDir, "autonomous-interaction-diagnostic.json"), `${JSON.stringify({
           schema: 1,
           stage: "planning",
           occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -31014,13 +31545,13 @@ VITE_API_BASE_URL=${running.url}
     let result = { ...rawResult, evidenceMode: review.mode };
     if (coverage !== void 0) {
       const evidence = createAcceptanceEvidence(coverage, result);
-      await writeFile17(join45(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
+      await writeFile17(join47(taskDir(workspace, task), "acceptance-evidence.json"), `${JSON.stringify({ ...evidence, baseline }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       if (!evidence.passed) result = { ...result, passed: false, failures: Math.max(1, result.failures) };
     }
     const dir = integrationDirectory(workspace, task);
     await mkdir27(dir, { recursive: true });
-    await writeFile17(join45(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
+    await writeFile17(join47(dir, "interaction-results.json"), `${JSON.stringify(result, null, 2)}
 `);
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyInteractionRun(current, result));
     return { workflow: next, result, review };
@@ -31033,7 +31564,7 @@ VITE_API_BASE_URL=${running.url}
     if (mock === void 0 || !mock.exited() || result.failures === 0) return result;
     const output = mock.output().trim();
     try {
-      const dir = join45(d2cOutputDirectory(workspace, task), "mock-server.log");
+      const dir = join47(d2cOutputDirectory(workspace, task), "mock-server.log");
       await writeFile17(dir, `${output}
 `);
     } catch {
@@ -31128,7 +31659,7 @@ VITE_API_BASE_URL=${running.url}
     if (current === void 0) throw new Error("D2C product plan is unavailable");
     if (current.plan.approvedPrd !== void 0) throw new Error("The approved PRD is immutable and cannot be edited");
     if (current.plan.phase !== "prd-review") throw new Error("PRD sections can only be edited during PRD review");
-    const path = join45(taskDir(workspace, task), "product", "prd.md");
+    const path = join47(taskDir(workspace, task), "product", "prd.md");
     const updated = await updatePrdSectionFile(path, { sectionId, body, expectedHash });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     await writeD2cProductPlan(workspace, {
@@ -31148,33 +31679,33 @@ VITE_API_BASE_URL=${running.url}
   async #assertProductPrdLocked(workspace, task) {
     const current = await readD2cProductPlanView(workspace, task);
     if (current?.plan.approvedPrd === void 0) return;
-    await assertApprovedPrd(join45(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
+    await assertApprovedPrd(join47(taskDir(workspace, task), "product", "prd.md"), current.plan.approvedPrd);
   }
   async #acceptancePaths(workspace, task) {
-    const product = join45(taskDir(workspace, task), "product");
-    const openapi = join45(product, "openapi.json");
+    const product = join47(taskDir(workspace, task), "product");
+    const openapi = join47(product, "openapi.json");
     return {
-      prd: join45(product, "prd.md"),
-      prototype: join45(product, "prototype", "index.html"),
-      interaction: join45(product, "prototype", "interaction-manifest.json"),
-      ...await stat15(openapi).catch(() => void 0) === void 0 ? {} : { openapi }
+      prd: join47(product, "prd.md"),
+      prototype: join47(product, "prototype", "index.html"),
+      interaction: join47(product, "prototype", "interaction-manifest.json"),
+      ...await stat16(openapi).catch(() => void 0) === void 0 ? {} : { openapi }
     };
   }
   async #verifyAcceptanceBaseline(workspace, task) {
     const product = await readD2cProductPlanView(workspace, task);
     if (product?.plan.approvedPrd === void 0) return void 0;
     await this.#assertProductPrdLocked(workspace, task);
-    const baseline = JSON.parse(await readFile35(join45(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
+    const baseline = JSON.parse(await readFile36(join47(taskDir(workspace, task), "acceptance-baseline.json"), "utf8"));
     await verifyAcceptanceBaseline(await this.#acceptancePaths(workspace, task), baseline);
-    const design = join45(taskDir(workspace, task), "design");
+    const design = join47(taskDir(workspace, task), "design");
     await Promise.all([
-      verifyAcceptanceArtifact(join45(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
-      verifyAcceptanceArtifact(join45(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
+      verifyAcceptanceArtifact(join47(design, "index.html"), baseline.artifacts.prototype, "runtime prototype"),
+      verifyAcceptanceArtifact(join47(design, "interaction-manifest.json"), baseline.artifacts.interaction, "runtime interaction contract")
     ]);
     const workflow = await readWorkflow(workspace, task);
     if (workflow?.openapi !== void 0) {
       await verifyAcceptanceArtifact(
-        join45(taskDir(workspace, task), "integration", "swagger.json"),
+        join47(taskDir(workspace, task), "integration", "swagger.json"),
         { hash: workflow.openapi.hash },
         "runtime OpenAPI contract"
       );
@@ -31195,14 +31726,14 @@ VITE_API_BASE_URL=${running.url}
       throw new Error("D2C PRD is empty and cannot be accepted");
     }
     if (stage === "design" && accepted) {
-      const manifest = join45(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
-      const normalizedManifest = parseInteractionManifest(await readFile35(manifest, "utf8"));
+      const manifest = join47(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json");
+      const normalizedManifest = parseInteractionManifest(await readFile36(manifest, "utf8"));
       if (current.plan.approvedPrd === void 0) throw new Error("Approve the PRD before confirming the design");
       verifyRequirementCoverage(current.plan.approvedPrd.criteria, normalizedManifest);
       await writeFile17(manifest, `${JSON.stringify(normalizedManifest, null, 2)}
 `, { encoding: "utf8", mode: 384 });
       const baseline = await captureAcceptanceBaseline(await this.#acceptancePaths(workspace, task), current.plan.approvedPrd);
-      await writeFile17(join45(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
+      await writeFile17(join47(taskDir(workspace, task), "acceptance-baseline.json"), `${JSON.stringify(baseline, null, 2)}
 `, { encoding: "utf8", mode: 384 });
     }
     const plan = await writeD2cProductPlan(
@@ -31236,8 +31767,8 @@ VITE_API_BASE_URL=${running.url}
     const imported = await this.importD2cDesign(task, d2cProductPrototypeDirectory(workspace, task));
     const delivery = await readDeliveryRun(workspace, task);
     if (delivery !== void 0) {
-      const prototype = await readFile35(join45(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
-      const interaction = await readFile35(join45(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
+      const prototype = await readFile36(join47(d2cProductPrototypeDirectory(workspace, task), "index.html"), "utf8");
+      const interaction = await readFile36(join47(d2cProductPrototypeDirectory(workspace, task), "interaction-manifest.json"), "utf8");
       const completed = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "design", [
         artifactRef("product/prototype/index.html", prototype),
         artifactRef("product/prototype/interaction-manifest.json", interaction)
@@ -31321,10 +31852,10 @@ VITE_API_BASE_URL=${running.url}
     const next = await updateWorkflow(workspace, task, workflow.revision, (current) => applyQualityJudgment(current, judgment));
     const qualityContent = `${JSON.stringify(judgment, null, 2)}
 `;
-    await writeFile17(join45(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
+    await writeFile17(join47(taskDir(workspace, task), "quality-judge.json"), qualityContent, { encoding: "utf8", mode: 384 });
     const delivery = await readDeliveryRun(workspace, task);
     if (next.stage === "completed" && delivery?.nodes.acceptance.status === "running") {
-      const interactionContent = await readFile35(join45(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
+      const interactionContent = await readFile36(join47(integrationDirectory(workspace, task), "interaction-results.json"), "utf8");
       const accepted = await updateDeliveryRun(workspace, task, delivery.revision, (run) => completeDeliveryNode(run, "acceptance", [
         artifactRef("integration/interaction-results.json", interactionContent),
         artifactRef("quality-judge.json", qualityContent)
@@ -31504,9 +32035,27 @@ function desktopWindowChrome(platform = process.platform) {
   };
 }
 
+// src/utils/login-shell-environment.ts
+import { delimiter as delimiter3 } from "path";
+async function loginShellEnvironment(environment, platform = process.platform, dependencies2 = {}) {
+  if (platform !== "darwin") return { ...environment };
+  const shell2 = environment.SHELL || "/bin/zsh";
+  const result = await (dependencies2.execute ?? execFileNoThrow)(
+    shell2,
+    ["-l", "-c", "command env"],
+    { timeout: 2e3, useCwd: false, env: environment }
+  );
+  if (result.code !== 0) return { ...environment };
+  const loginPath = result.stdout.split(/\r?\n/u).filter((line) => line.startsWith("PATH=")).at(-1)?.slice(5);
+  if (!loginPath) return { ...environment };
+  const currentPath = environment.PATH ?? "";
+  const entries = [...loginPath.split(delimiter3), ...currentPath.split(delimiter3)].filter((entry2, index, values) => entry2.length > 0 && values.indexOf(entry2) === index);
+  return { ...environment, PATH: entries.join(delimiter3) };
+}
+
 // src/desktop/git-manager.ts
-import { readFile as readFile36, rm as rm16 } from "fs/promises";
-import { isAbsolute as isAbsolute19, relative as relative26, resolve as resolve38 } from "path";
+import { readFile as readFile37, rm as rm16 } from "fs/promises";
+import { isAbsolute as isAbsolute20, relative as relative27, resolve as resolve39 } from "path";
 function failure(action, stderr, stdout) {
   return new Error(`${action}\u5931\u8D25\uFF1A${(stderr.trim() || stdout.trim() || "\u672A\u77E5 Git \u9519\u8BEF").split("\n")[0]}`);
 }
@@ -31537,7 +32086,7 @@ async function desktopGitDiff(workspace, path, staged = false) {
   if (file === void 0) throw new Error("\u8BE5\u6587\u4EF6\u5DF2\u4E0D\u5728\u53D8\u66F4\u5217\u8868\u4E2D");
   if (file.untracked) {
     const target = safeWorkspacePath(workspace, path);
-    const value = await readFile36(target, "utf8");
+    const value = await readFile37(target, "utf8");
     return value.length > 12e4 ? `${value.slice(0, 12e4)}
 \u2026[\u5185\u5BB9\u5DF2\u622A\u65AD]` : value;
   }
@@ -31599,13 +32148,13 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     return path.replaceAll("\\", "/");
   }));
   try {
-    const tree = JSON.parse(await readFile36(resolve38(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
+    const tree = JSON.parse(await readFile37(resolve39(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
     const leaf = tree.nodes?.find((node) => node.id === tree.leafId);
     const parent = leaf?.parentId == null ? void 0 : tree.nodes?.find((node) => node.id === leaf.parentId);
     if (leaf === void 0 || parent === void 0) return desktopGitReviewDiff(workspace, { scope: "last-turn", paths });
     const load = async (id) => {
       if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-      return JSON.parse(await readFile36(resolve38(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
+      return JSON.parse(await readFile37(resolve39(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
     };
     const [before, after] = await Promise.all([load(parent.checkpointId), load(leaf.checkpointId)]);
     const oldFiles = new Map(before.files.map((file) => [file.path, file.digest]));
@@ -31614,7 +32163,7 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     const object = async (digest) => {
       if (digest === void 0) return "";
       if (!/^[a-f0-9]{64}$/.test(digest)) throw new Error("Invalid checkpoint object");
-      const value = await readFile36(resolve38(workspace, ".flavor", "checkpoints", "objects", digest));
+      const value = await readFile37(resolve39(workspace, ".flavor", "checkpoints", "objects", digest));
       return value.includes(0) ? "[binary content]" : value.toString("utf8");
     };
     const chunks = await Promise.all(changed.map(async (path) => wholeFileDiff(path, await object(oldFiles.get(path)), await object(newFiles.get(path)))));
@@ -31638,11 +32187,11 @@ async function assertListed(workspace, path) {
   return file;
 }
 function safeWorkspacePath(workspace, path) {
-  if (isAbsolute19(path)) throw new Error("Git \u6587\u4EF6\u8DEF\u5F84\u5FC5\u987B\u662F\u9879\u76EE\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84");
-  const root = resolve38(workspace);
-  const target = resolve38(root, path);
-  const child = relative26(root, target);
-  if (child === "" || child.startsWith("..") || isAbsolute19(child)) throw new Error("\u62D2\u7EDD\u8BBF\u95EE\u9879\u76EE\u4E4B\u5916\u7684\u8DEF\u5F84");
+  if (isAbsolute20(path)) throw new Error("Git \u6587\u4EF6\u8DEF\u5F84\u5FC5\u987B\u662F\u9879\u76EE\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84");
+  const root = resolve39(workspace);
+  const target = resolve39(root, path);
+  const child = relative27(root, target);
+  if (child === "" || child.startsWith("..") || isAbsolute20(child)) throw new Error("\u62D2\u7EDD\u8BBF\u95EE\u9879\u76EE\u4E4B\u5916\u7684\u8DEF\u5F84");
   return target;
 }
 function safeGitTarget(value) {
@@ -31653,14 +32202,14 @@ function safeGitTarget(value) {
 
 // src/desktop/worktree-manager.ts
 import { randomUUID as randomUUID28 } from "crypto";
-import { mkdir as mkdir28, readFile as readFile37, readdir as readdir13, rm as rm17, stat as stat16, writeFile as writeFile18 } from "fs/promises";
-import { basename as basename10, isAbsolute as isAbsolute20, join as join46, relative as relative27, resolve as resolve39, sep as sep27 } from "path";
+import { mkdir as mkdir28, readFile as readFile38, readdir as readdir14, rm as rm17, stat as stat17, writeFile as writeFile18 } from "fs/promises";
+import { basename as basename11, isAbsolute as isAbsolute21, join as join48, relative as relative28, resolve as resolve40, sep as sep28 } from "path";
 var DesktopWorktreeManager = class {
   #repository;
   #storage;
   constructor(options) {
-    this.#repository = resolve39(options.repository);
-    this.#storage = resolve39(options.storage);
+    this.#repository = resolve40(options.repository);
+    this.#storage = resolve40(options.storage);
   }
   async create(label) {
     if (!await isGitRepository(this.#repository)) throw new Error("Task worktrees require a Git repository");
@@ -31693,15 +32242,15 @@ var DesktopWorktreeManager = class {
   async list() {
     let names;
     try {
-      names = await readdir13(this.#storage);
+      names = await readdir14(this.#storage);
     } catch (error) {
       if (error.code === "ENOENT") return [];
       throw error;
     }
     const values = await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => {
       try {
-        const stored = validateStored(JSON.parse(await readFile37(join46(this.#storage, name), "utf8")), this.#repository, this.#storage);
-        if ((await stat16(stored.path).catch(() => void 0))?.isDirectory() !== true) return void 0;
+        const stored = validateStored(JSON.parse(await readFile38(join48(this.#storage, name), "utf8")), this.#repository, this.#storage);
+        if ((await stat17(stored.path).catch(() => void 0))?.isDirectory() !== true) return void 0;
         const status = await git2(stored.path, ["status", "--porcelain"]);
         const merged = await git2(this.#repository, ["merge-base", "--is-ancestor", stored.branch, "HEAD"]);
         const { version: _version, ...item } = stored;
@@ -31734,45 +32283,45 @@ var DesktopWorktreeManager = class {
   }
   async #load(id) {
     const path = this.#metadataPath(id);
-    return validateStored(JSON.parse(await readFile37(path, "utf8")), this.#repository, this.#storage);
+    return validateStored(JSON.parse(await readFile38(path, "utf8")), this.#repository, this.#storage);
   }
   #metadataPath(id) {
     if (!/^worktree-[a-z0-9._-]{1,80}$/.test(id)) throw new Error("Invalid worktree id");
     return this.#safeStoragePath(`${id}.json`);
   }
   #safeStoragePath(name) {
-    const target = resolve39(this.#storage, name);
-    const delta = relative27(this.#storage, target);
-    if (delta === "" || delta === ".." || delta.startsWith(`..${sep27}`) || isAbsolute20(delta)) throw new Error("Worktree path escapes storage");
+    const target = resolve40(this.#storage, name);
+    const delta = relative28(this.#storage, target);
+    if (delta === "" || delta === ".." || delta.startsWith(`..${sep28}`) || isAbsolute21(delta)) throw new Error("Worktree path escapes storage");
     return target;
   }
 };
 function validateStored(value, repository, storage) {
   if (typeof value !== "object" || value === null) throw new Error("Invalid worktree metadata");
   const item = value;
-  if (item.version !== 1 || item.mode !== "worktree" || typeof item.id !== "string" || typeof item.path !== "string" || typeof item.branch !== "string" || typeof item.createdAt !== "string" || resolve39(item.repository ?? "") !== repository) {
+  if (item.version !== 1 || item.mode !== "worktree" || typeof item.id !== "string" || typeof item.path !== "string" || typeof item.branch !== "string" || typeof item.createdAt !== "string" || resolve40(item.repository ?? "") !== repository) {
     throw new Error("Invalid worktree metadata");
   }
-  const path = resolve39(item.path);
-  const delta = relative27(storage, path);
-  if (delta === "" || delta === ".." || delta.startsWith(`..${sep27}`) || isAbsolute20(delta) || basename10(path) !== item.id) {
+  const path = resolve40(item.path);
+  const delta = relative28(storage, path);
+  if (delta === "" || delta === ".." || delta.startsWith(`..${sep28}`) || isAbsolute21(delta) || basename11(path) !== item.id) {
     throw new Error("Worktree metadata escapes storage");
   }
   return { version: 1, id: item.id, mode: "worktree", repository, path, branch: item.branch, createdAt: item.createdAt };
 }
 
 // src/desktop/workbench-service.ts
-import { readFile as readFile38, readdir as readdir14, stat as stat17 } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { join as join47, resolve as resolve40 } from "path";
+import { readFile as readFile39, readdir as readdir15, stat as stat18 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join49, resolve as resolve41 } from "path";
 var MAX_TEXT = 128e3;
 var MAX_ITEMS = 200;
 var DesktopWorkbenchService = class {
   #workspace;
   #home;
-  constructor(workspace, home = homedir5()) {
-    this.#workspace = resolve40(workspace);
-    this.#home = resolve40(home);
+  constructor(workspace, home = homedir6()) {
+    this.#workspace = resolve41(workspace);
+    this.#home = resolve41(home);
   }
   async inspect(sessionId) {
     const [goals, instructions, permissionFiles, audit, context] = await Promise.all([
@@ -31797,11 +32346,11 @@ var DesktopWorkbenchService = class {
     return url.toString().replace(/\/$/, input.trim().endsWith("/") ? "/" : "");
   }
   async #goals() {
-    const root = join47(this.#workspace, ".flavor", "goals");
-    const names = await readdir14(root).catch((error) => error.code === "ENOENT" ? [] : Promise.reject(error));
+    const root = join49(this.#workspace, ".flavor", "goals");
+    const names = await readdir15(root).catch((error) => error.code === "ENOENT" ? [] : Promise.reject(error));
     const values = await Promise.all(names.filter((name) => /^goal-[A-Za-z0-9._-]+\.json$/.test(name)).slice(0, MAX_ITEMS).map(async (name) => {
       try {
-        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join47(root, name))));
+        return GoalStateSchema.parse(JSON.parse(await boundedRead2(join49(root, name))));
       } catch {
         return void 0;
       }
@@ -31811,7 +32360,7 @@ var DesktopWorkbenchService = class {
   async #instructions() {
     const names = ["FLAVOR.md", "AGENTS.md", "CLAUDE.md", "AGENTS.local.md", "CLAUDE.local.md"];
     const items = await Promise.all(names.map(async (name) => {
-      const path = join47(this.#workspace, name);
+      const path = join49(this.#workspace, name);
       try {
         return { name, path, content: redactErrorText(await boundedRead2(path)) };
       } catch (error) {
@@ -31823,10 +32372,10 @@ var DesktopWorkbenchService = class {
   }
   async #permissionFiles() {
     const candidates = [
-      ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve40(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
-      { tier: "user", path: join47(this.#home, ".flavor-code", "permissions.json"), content: "" },
-      { tier: "project", path: join47(this.#workspace, ".flavor", "permissions.json"), content: "" },
-      { tier: "local", path: join47(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
+      ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve41(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
+      { tier: "user", path: join49(this.#home, ".flavor-code", "permissions.json"), content: "" },
+      { tier: "project", path: join49(this.#workspace, ".flavor", "permissions.json"), content: "" },
+      { tier: "local", path: join49(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
     ];
     const values = await Promise.all(candidates.map(async (item) => {
       try {
@@ -31841,7 +32390,7 @@ var DesktopWorkbenchService = class {
   async #audit() {
     let raw;
     try {
-      raw = await boundedRead2(join47(this.#workspace, ".flavor", "audit.jsonl"));
+      raw = await boundedRead2(join49(this.#workspace, ".flavor", "audit.jsonl"));
     } catch (error) {
       if (error.code === "ENOENT") return [];
       throw error;
@@ -31856,7 +32405,7 @@ var DesktopWorkbenchService = class {
     }).reverse();
   }
   async #context(sessionId) {
-    const usage = await readJsonLines2(join47(this.#workspace, ".flavor", "usage.jsonl"));
+    const usage = await readJsonLines2(join49(this.#workspace, ".flavor", "usage.jsonl"));
     if (sessionId === void 0) return { visibility: [], usage };
     try {
       const document = await new SessionStore({ workspace: this.#workspace }).load(sessionId);
@@ -31867,10 +32416,10 @@ var DesktopWorkbenchService = class {
   }
 };
 async function boundedRead2(path) {
-  const info = await stat17(path);
+  const info = await stat18(path);
   if (!info.isFile()) throw new Error(`Expected a file: ${path}`);
   if (info.size > MAX_TEXT) throw new Error(`Workbench file exceeds ${MAX_TEXT} bytes: ${path}`);
-  return readFile38(path, "utf8");
+  return readFile39(path, "utf8");
 }
 async function readJsonLines2(path) {
   try {
@@ -31903,7 +32452,7 @@ var appMenu;
 var quitting = false;
 function logStartup(step, detail) {
   try {
-    const logPath = join48(dirname25(process.execPath), "flavor-code-startup.log");
+    const logPath = join50(dirname25(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);
@@ -31928,7 +32477,7 @@ var d2cEmbedded = createEmbeddedD2cAutomation(() => {
   };
 });
 var d2cJudgeClient = createD2cJudgeClient();
-var judgeStore = () => createD2cJudgeConfigStore(join48(app.getPath("userData"), "d2c-judge.json"));
+var judgeStore = () => createD2cJudgeConfigStore(join50(app.getPath("userData"), "d2c-judge.json"));
 function judgeImage(png) {
   const image = nativeImage.createFromBuffer(png);
   const size = image.getSize();
@@ -31953,8 +32502,8 @@ function sessionMetaKey(workspace, sessionId) {
   return `${workspace}\0${sessionId}`;
 }
 function worktreeManager(workspace) {
-  const key = createHash28("sha256").update(resolve41(workspace)).digest("hex").slice(0, 20);
-  return new DesktopWorktreeManager({ repository: workspace, storage: join48(app.getPath("userData"), "task-worktrees", key) });
+  const key = createHash28("sha256").update(resolve42(workspace)).digest("hex").slice(0, 20);
+  return new DesktopWorktreeManager({ repository: workspace, storage: join50(app.getPath("userData"), "task-worktrees", key) });
 }
 function activeWorkingDirectory() {
   if (activeWorkspace === void 0) throw new Error("\u8BF7\u5148\u6253\u5F00\u9879\u76EE");
@@ -32096,10 +32645,10 @@ function createDesktopController(workspace, owner2) {
       },
       collaboration: {
         instanceId: collaborationId,
-        alias: `desktop-${basename11(workspace ?? runtimeOptions.workspace ?? "flavor")}`.slice(0, 64),
+        alias: `desktop-${basename12(workspace ?? runtimeOptions.workspace ?? "flavor")}`.slice(0, 64),
         optional: true,
         startBroker: (address) => {
-          const entry2 = app.isPackaged ? join48(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join48(moduleDirectory, "pals-broker-entry.js");
+          const entry2 = app.isPackaged ? join50(process.resourcesPath, "app.asar.unpacked", "dist", "desktop", "pals-broker-entry.js") : join50(moduleDirectory, "pals-broker-entry.js");
           return spawnPalBrokerProcess({
             address,
             executable: process.execPath,
@@ -32121,11 +32670,11 @@ function createDesktopController(workspace, owner2) {
 var detachedController = createDesktopController();
 var controller = detachedController;
 function statePath() {
-  return join48(app.getPath("userData"), "desktop-state.json");
+  return join50(app.getPath("userData"), "desktop-state.json");
 }
 async function loadPersistedProjects() {
   try {
-    const raw = await readFile39(statePath(), "utf8");
+    const raw = await readFile40(statePath(), "utf8");
     if (raw.length > 1e5) return { projects: [] };
     const parsed = JSON.parse(raw);
     Object.assign(workbench, {
@@ -32166,10 +32715,10 @@ function validRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 async function assertDirectory(path) {
-  if (!(await stat18(path)).isDirectory()) throw new Error("The selected project is not a directory");
+  if (!(await stat19(path)).isDirectory()) throw new Error("The selected project is not a directory");
 }
 async function openWorkspace(path) {
-  const workspace = resolve41(path);
+  const workspace = resolve42(path);
   await assertDirectory(workspace);
   let project = managedProjects.get(workspace);
   if (project === void 0) {
@@ -32180,10 +32729,10 @@ async function openWorkspace(path) {
     activeWorkspace = workspace;
     controller = nextController;
     project.snapshot = await nextController.openWorkspace(workspace);
-    for (const saved of workbench.taskCheckouts.filter((item) => resolve41(item.workspace) === workspace)) {
+    for (const saved of workbench.taskCheckouts.filter((item) => resolve42(item.workspace) === workspace)) {
       try {
         await assertDirectory(saved.workingDirectory);
-        const task = { environment: "worktree", workingDirectory: resolve41(saved.workingDirectory), worktreeId: saved.worktreeId };
+        const task = { environment: "worktree", workingDirectory: resolve42(saved.workingDirectory), worktreeId: saved.worktreeId };
         task.controller = createDesktopController(workspace, task);
         task.snapshot = await task.controller.openWorkspace(task.workingDirectory);
         task.sessionId = saved.sessionId;
@@ -32297,7 +32846,7 @@ async function chooseAndOpenWorkspace() {
 var cachedAppIconDataUrl;
 function appIconDataUrl() {
   if (cachedAppIconDataUrl !== void 0) return cachedAppIconDataUrl;
-  const icon = nativeImage.createFromPath(join48(app.getAppPath(), "assets", "icon.png"));
+  const icon = nativeImage.createFromPath(join50(app.getAppPath(), "assets", "icon.png"));
   if (icon.isEmpty()) return void 0;
   cachedAppIconDataUrl = icon.toDataURL();
   return cachedAppIconDataUrl;
@@ -32313,7 +32862,7 @@ function installIpcHandlers() {
       } catch {
       }
     }
-    if (persisted.workspace !== void 0 && managedProjects.has(resolve41(persisted.workspace))) {
+    if (persisted.workspace !== void 0 && managedProjects.has(resolve42(persisted.workspace))) {
       try {
         return await openWorkspace(persisted.workspace);
       } catch {
@@ -32374,7 +32923,7 @@ function installIpcHandlers() {
   });
   ipcMain.handle(DESKTOP_CHANNELS.updateProject, async (_event, value) => {
     const input = UpdateProjectInputSchema.parse(value);
-    const workspace = resolve41(input.workspace);
+    const workspace = resolve42(input.workspace);
     if (!managedProjects.has(workspace)) throw new Error("\u9879\u76EE\u672A\u6253\u5F00");
     workbench.projectMeta[workspace] = { ...workbench.projectMeta[workspace], ...input.label === void 0 ? {} : { label: input.label || void 0 }, ...input.pinned === void 0 ? {} : { pinned: input.pinned } };
     await savePersistedProjects();
@@ -32382,7 +32931,7 @@ function installIpcHandlers() {
   });
   ipcMain.handle(DESKTOP_CHANNELS.closeProject, async (_event, value) => {
     const input = CloseProjectInputSchema.parse(value);
-    const workspace = resolve41(input.workspace);
+    const workspace = resolve42(input.workspace);
     const project = managedProjects.get(workspace);
     if (project === void 0) return decorateSnapshot(controller.snapshot());
     if ([...project.tasks].some((task) => task.snapshot.activeSession?.busy) && !input.force) throw new Error("\u9879\u76EE\u4E2D\u4ECD\u6709\u4EFB\u52A1\u8FD0\u884C\uFF1B\u786E\u8BA4\u540E\u518D\u5173\u95ED\u9879\u76EE");
@@ -32398,12 +32947,12 @@ function installIpcHandlers() {
     return decorateSnapshot(controller.snapshot());
   });
   ipcMain.handle(DESKTOP_CHANNELS.revealProject, async (_event, value) => {
-    const workspace = resolve41(ProjectPathInputSchema.parse(value).workspace);
+    const workspace = resolve42(ProjectPathInputSchema.parse(value).workspace);
     await assertDirectory(workspace);
     await shell.openPath(workspace);
   });
   ipcMain.handle(DESKTOP_CHANNELS.copyProjectPath, async (_event, value) => {
-    clipboard.writeText(resolve41(ProjectPathInputSchema.parse(value).workspace));
+    clipboard.writeText(resolve42(ProjectPathInputSchema.parse(value).workspace));
   });
   ipcMain.handle(DESKTOP_CHANNELS.dismissRecovery, async (_event, value) => {
     const { sessionId } = DeleteSessionInputSchema.parse(value);
@@ -32715,7 +33264,7 @@ function applicationMenu() {
   ]);
 }
 async function createWindow() {
-  const rendererPath = join48(app.getAppPath(), "dist", "desktop-renderer", "index.html");
+  const rendererPath = join50(app.getAppPath(), "dist", "desktop-renderer", "index.html");
   mainWindow = new BrowserWindow2({
     title: "Flavor Code",
     width: 1280,
@@ -32726,14 +33275,14 @@ async function createWindow() {
     show: false,
     ...desktopWindowChrome(),
     webPreferences: {
-      preload: join48(moduleDirectory, "preload.cjs"),
+      preload: join50(moduleDirectory, "preload.cjs"),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
       webSecurity: true
     }
   });
-  const iconPath = join48(app.getAppPath(), "assets", "icon.png");
+  const iconPath = join50(app.getAppPath(), "assets", "icon.png");
   const icon = nativeImage.createFromPath(iconPath);
   if (!icon.isEmpty()) {
     mainWindow.setIcon(icon);
@@ -32772,6 +33321,8 @@ async function createWindow() {
   });
 }
 app.whenReady().then(async () => {
+  const desktopEnvironment = await loginShellEnvironment(process.env);
+  if (desktopEnvironment.PATH !== void 0) process.env.PATH = desktopEnvironment.PATH;
   installIpcHandlers();
   appMenu = applicationMenu();
   Menu.setApplicationMenu(appMenu);