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

package/dist/desktop/main.js

@@ -2,8 +2,8 @@
 import { appendFileSync } from "fs";
 import { createHash as createHash28, randomUUID as randomUUID29 } from "crypto";
 import { readFile as readFile40, stat as stat19, writeFile as writeFile19 } from "fs/promises";
-import { basename as basename12, dirname as dirname25, join as join50, resolve as resolve42 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { basename as basename12, dirname as dirname23, join as join50, resolve as resolve43 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { app, BrowserWindow as BrowserWindow2, clipboard, dialog, ipcMain, Menu, nativeImage, Notification, shell } from "electron";
 
 // src/desktop/contracts.ts
@@ -293,13 +293,13 @@ var FlavorConfigSchema = z2.object({
     evaluationTimeoutMs: z2.number().int().min(100).max(3e4).default(2e3)
   }).prefault({}),
   maxIterations: z2.object({
-    main: z2.number().int().min(10).max(500).default(80),
-    subagent: z2.number().int().min(10).max(200).default(40),
+    main: z2.number().int().min(10).max(500).default(300),
+    subagent: z2.number().int().min(10).max(200).default(100),
     softLimitFactor: z2.number().min(0.5).max(1).default(0.8),
-    extendBy: z2.number().int().min(5).max(100).default(20)
+    extendBy: z2.number().int().min(5).max(100).default(50)
   }).prefault({}),
   loop: z2.object({
-    maxCycles: z2.number().int().positive().max(1e4).default(20),
+    maxCycles: z2.number().int().positive().max(1e4).default(100),
     maxTokens: z2.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(5e5),
     isolation: z2.literal("auto").default("auto")
   }).prefault({}),
@@ -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((resolve43) => setTimeout(resolve43, pollIntervalMs));
+      await new Promise((resolve44) => setTimeout(resolve44, 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((resolve43) => setTimeout(resolve43, 50));
+      await new Promise((resolve44) => setTimeout(resolve44, 50));
     }
     return last;
   };
   const settleAfterAction = async (previousUrl) => {
     const origin = new URL(previousUrl).origin;
-    await new Promise((resolve43) => setTimeout(resolve43, Math.min(180, Math.max(20, visualDelayMs * 0.25))));
+    await new Promise((resolve44) => setTimeout(resolve44, 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((resolve43) => setTimeout(resolve43, pollIntervalMs));
+      await new Promise((resolve44) => setTimeout(resolve44, 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((resolve43) => setTimeout(resolve43, 150));
+            await new Promise((resolve44) => setTimeout(resolve44, 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((resolve43) => setTimeout(resolve43, ms))) {
+function createD2cJudgeClient(fetcher = globalThis.fetch, retryDelay = (ms) => new Promise((resolve44) => setTimeout(resolve44, 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((resolve43, reject) => {
+  return new Promise((resolve44, 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(() => resolve43({ ...value.result, heatmapPng: Buffer.from(value.result.heatmapPng) }));
+      finish(() => resolve44({ ...value.result, heatmapPng: Buffer.from(value.result.heatmapPng) }));
     });
     worker.once("error", (error) => finish(() => reject(error)));
     worker.once("exit", (code) => {
@@ -3961,11 +3961,11 @@ function createD2cTools(workspace, options = {}) {
     name: "D2cImport",
     description: "Import a Pixso HTML design export for D2C (design-to-code) comparison. Copies the export directory into .flavor/d2c/<task>/design/. The task name must be lowercase letters, digits and dashes.",
     inputSchema: D2cImportInput,
-    paths: (input) => [input.exportDir],
+    paths: (input) => [resolve4(workspace, input.exportDir), resolve4(workspace, ".flavor", "d2c", input.task)],
     summarize: (input) => `${input.task} \u2190 ${input.exportDir}`,
     execute: async (input, signal) => {
       signal.throwIfAborted();
-      const manifest = await importDesign(workspace, input.task, input.exportDir);
+      const manifest = await importDesign(workspace, input.task, resolve4(workspace, input.exportDir));
       return {
         task: input.task,
         entryHtml: manifest.entryHtml,
@@ -3979,7 +3979,7 @@ function createD2cTools(workspace, options = {}) {
     name: "D2cCompare",
     description: "Compare an imported Pixso design against the rendered implementation and score visual fidelity. The implementation is a frontend project directory (Vue or React, Vite-based; dependencies are installed and the dev server is started and stopped automatically), a localhost URL of an already running server, or a workspace-relative .html file. Returns a similarity score plus structured offsets, color deviations, font mismatches and missing or extra elements, and stores the report with screenshots under .flavor/d2c/<task>/reports/. Requires the desktop app for rendering.",
     inputSchema: D2cCompareInput,
-    paths: (input) => [input.implementation],
+    paths: (input) => [resolve4(workspace, ".flavor", "d2c", input.task), .../^https?:\/\//iu.test(input.implementation) ? [] : [resolve4(workspace, input.implementation)]],
     summarize: (input) => input.task,
     execute: async (input, signal) => {
       signal.throwIfAborted();
@@ -4226,10 +4226,10 @@ ${summarizeReport(report2)}`).join("\n\n")
 
 // src/production.ts
 import { readFile as readFile28 } from "fs/promises";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { createHash as createHash21, randomUUID as randomUUID25 } from "crypto";
 import { homedir as homedir3, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
-import { basename as basename9, dirname as dirname24, join as join37, relative as relative24, resolve as resolve35, sep as sep24 } from "path";
+import { basename as basename9, dirname as dirname22, join as join37, relative as relative25, resolve as resolve36, sep as sep25 } 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((resolve43, reject) => {
+  return new Promise((resolve44, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
-      resolve43({ timedOut: true, value: void 0 });
+      resolve44({ timedOut: true, value: void 0 });
     }, ms);
     timer.unref?.();
     promise.then(
@@ -4455,7 +4455,7 @@ function withTimeout(promise, ms) {
         if (!settled) {
           settled = true;
           clearTimeout(timer);
-          resolve43({ timedOut: false, value });
+          resolve44({ timedOut: false, value });
         }
       },
       (error) => {
@@ -4470,13 +4470,13 @@ function withTimeout(promise, ms) {
 }
 function awaitWithSignal3(promise, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve44, reject) => {
     const onAbort = () => reject(signal.reason);
     signal.addEventListener("abort", onAbort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", onAbort);
-        resolve43(value);
+        resolve44(value);
       },
       (error) => {
         signal.removeEventListener("abort", onAbort);
@@ -4739,7 +4739,7 @@ var TaskPlanSchema = z11.object({
       }
       dependencies2.add(dependency);
     }
-    if (task.status === "completed") {
+    if (task.status === "completed" || task.status === "in_progress") {
       const incomplete = task.dependencies.find((dependency) => plan.tasks.find((candidate) => candidate.id === dependency)?.status !== "completed");
       if (incomplete !== void 0) {
         context.addIssue({
@@ -4768,7 +4768,7 @@ function updatePlanTask(plan, input) {
   if (!isValidTransition(previousStatus, update.status)) {
     throw new Error(`Invalid task transition for ${update.taskId}: ${previousStatus} -> ${update.status}`);
   }
-  if (update.status === "completed") {
+  if (update.status === "completed" || update.status === "in_progress") {
     const incomplete = current.tasks[index].dependencies.find((dependency) => current.tasks.find((task) => task.id === dependency)?.status !== "completed");
     if (incomplete !== void 0) throw new Error(`Task ${update.taskId} has an incomplete dependency: ${incomplete}`);
   }
@@ -4793,6 +4793,7 @@ function isValidTransition(from, to) {
   if (from === "in_progress") {
     return to === "completed" || to === "failed" || to === "blocked" || to === "cancelled";
   }
+  if (from === "blocked" || from === "failed") return to === "pending" || to === "in_progress" || to === "cancelled";
   return false;
 }
 function normalizeAbandonedPlan(plan) {
@@ -6163,8 +6164,8 @@ function withStructuredOutput(options) {
   if (retry.backoffMs.length < retry.maxRetries) {
     throw new Error("Structured output backoffMs must provide one delay per retry");
   }
-  for (const delay4 of retry.backoffMs.slice(0, retry.maxRetries)) {
-    if (!Number.isSafeInteger(delay4) || delay4 < 0) {
+  for (const delay3 of retry.backoffMs.slice(0, retry.maxRetries)) {
+    if (!Number.isSafeInteger(delay3) || delay3 < 0) {
       throw new Error("Structured output retry delays must be non-negative integers");
     }
   }
@@ -6525,10 +6526,10 @@ function sanitize(message2, secrets) {
 }
 function waitForRetry(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve44, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve43();
+      resolve44();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -6599,6 +6600,15 @@ var AgentLoop = class {
   get iterationLimitMode() {
     return this.#iterationLimitMode;
   }
+  get maxIterations() {
+    return this.#options.maxIterations;
+  }
+  get softLimitFactor() {
+    return this.#options.softLimitFactor;
+  }
+  get extendIterations() {
+    return this.#options.extendIterations;
+  }
   setModel(modelId) {
     this.#options.registry.get(modelId);
     this.#options.modelId = modelId;
@@ -7166,10 +7176,10 @@ function serializeToolInput(input) {
 }
 function waitForRetry2(delayMs, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve44, reject) => {
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve43();
+      resolve44();
     }, delayMs);
     const onAbort = () => {
       clearTimeout(timer);
@@ -7824,8 +7834,9 @@ var ToolRuntime = class {
     }
   }
   async execute(call, context) {
+    if (this.#disposed) return { ok: false, error: { code: "runtime_disposed", message: "ToolRuntime is disposed" } };
     const definition = this.#tools.get(call.name);
-    const journalId = definition === void 0 || this.#journal === void 0 ? void 0 : this.#journal.start(call.name, call.input, definition.retrySafe === true || definition.readOnly === true);
+    const journalId = definition === void 0 || this.#journal === void 0 ? void 0 : this.#journal.start(call.name, call.input, definition.retrySafe === true || definition.readOnly === true || getToolCategory(call.name) === "read");
     try {
       const result = await this.#execute(call, context);
       if (journalId !== void 0) this.#journal?.complete(journalId, result);
@@ -7852,6 +7863,10 @@ var ToolRuntime = class {
     if (tool === void 0) return { ok: false, error: { code: "unknown_tool", message: `Unknown tool: ${call.name}` } };
     const signal = context.signal ?? new AbortController().signal;
     const toolCallId = call.id ?? randomUUID7();
+    if (tool.agents !== void 0 && !tool.agents.includes(context.agent)) {
+      return this.#fail(toolCallId, tool.name, call.input, context.agent, "permission_denied", `Tool ${tool.name} is not available to ${context.agent} agents`);
+    }
+    if (signal.aborted) return this.#fail(toolCallId, tool.name, call.input, context.agent, "cancelled", message(signal.reason));
     const validation = this.normalize(call);
     if (!validation.ok) {
       return this.#fail(toolCallId, call.name, call.input, context.agent, validation.error.code, validation.error.message);
@@ -7959,17 +7974,37 @@ var ToolRuntime = class {
       } catch (error) {
         return this.#fail(toolCallId, tool.name, input, context.agent, "invalid_output", message(error));
       }
-      const declaredPresentation = tool.presentResult?.(rawOutput, input);
-      const presentation = declaredPresentation ?? getToolPresentation(rawOutput);
-      const rendered = tool.renderForModel?.(rawOutput, input);
+      const warnings = [];
+      let presentation = getToolPresentation(rawOutput);
+      try {
+        presentation = tool.presentResult?.(rawOutput, input) ?? presentation;
+      } catch (error) {
+        warnings.push(`Tool succeeded; result presentation failed: ${message(error)}`);
+      }
+      let rendered;
+      try {
+        rendered = tool.renderForModel?.(rawOutput, input);
+      } catch (error) {
+        warnings.push(`Tool succeeded; result rendering failed: ${message(error)}`);
+      }
       const output = rendered === void 0 ? await this.#limitOutput(tool.name, rawOutput) : rawOutput;
       const content = rendered === void 0 ? void 0 : await this.#limitText(tool.name, rendered);
-      const additionalContext = await this.#afterSuccess?.(tool.name, tool.paths(input), input, rawOutput, context);
-      await this.#hooks.emit({
-        version: 1,
-        type: "PostToolUse",
-        payload: { toolCallId, tool: tool.name, input, agent: context.agent, output }
-      });
+      let additionalContext = [];
+      try {
+        additionalContext = await this.#afterSuccess?.(tool.name, tool.paths(input), input, rawOutput, context) ?? [];
+      } catch (error) {
+        warnings.push(`Tool succeeded; context update failed: ${message(error)}`);
+      }
+      try {
+        await this.#hooks.emit({
+          version: 1,
+          type: "PostToolUse",
+          payload: { toolCallId, tool: tool.name, input, agent: context.agent, output }
+        });
+      } catch (error) {
+        warnings.push(`Tool succeeded; PostToolUse hook failed: ${message(error)}`);
+      }
+      additionalContext = [...additionalContext, ...warnings];
       return {
         ok: true,
         output,
@@ -8000,17 +8035,23 @@ var ToolRuntime = class {
     const preview = headTailPreview(serialized, previewChars);
     this.#turnOutputChars += preview.length;
     const directory = join7(this.#workspace, ".flavor", "tool-results");
-    await mkdir6(directory, { recursive: true });
     const filename2 = `${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID7()}-${safeFilename(tool)}.txt`;
     const savedTo = join7(directory, filename2);
-    await writeFile3(savedTo, serialized, "utf8");
+    let storage;
+    try {
+      await mkdir6(directory, { recursive: true });
+      await writeFile3(savedTo, serialized, "utf8");
+      storage = { savedTo };
+    } catch (error) {
+      storage = { storageError: `Tool succeeded, but the full output could not be saved: ${message(error)}` };
+    }
     return {
       truncated: true,
       reason,
       preview,
       originalChars: serialized.length,
       previewChars: preview.length,
-      savedTo
+      ...storage
     };
   }
   callPresentation(call) {
@@ -8211,6 +8252,8 @@ var LocalHarness = class {
         agent,
         ownerId,
         ...maxIterations === void 0 ? {} : { maxIterations },
+        ...this.#options.softLimitFactor === void 0 ? {} : { softLimitFactor: this.#options.softLimitFactor },
+        ...this.#options.extendIterations === void 0 ? {} : { extendIterations: this.#options.extendIterations },
         ...isMain && this.#options.hasActiveProgress !== void 0 ? { hasActiveProgress: this.#options.hasActiveProgress } : {},
         ...isMain && this.#options.hallucinationGuard !== void 0 ? { hallucinationGuard: this.#options.hallucinationGuard } : {},
         ...this.#options.modelJournal === void 0 ? {} : { modelJournal: this.#options.modelJournal }
@@ -8752,7 +8795,7 @@ function resolveWindowsCommand(command, cwd, env) {
     ...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}`)];
+    const candidates = extname2(base).length > 0 ? [base] : [...pathExt.map((extension2) => `${base}${extension2}`), base];
     for (const candidate of candidates) {
       if (isRegularFile(candidate)) return resolve9(candidate);
     }
@@ -8898,7 +8941,7 @@ function decoratePayload(payload, envelope) {
   return envelope === void 0 ? payload : { ...payload, ...envelope };
 }
 function runShellHandler(descriptor, event, signal) {
-  return new Promise((resolve43, reject) => {
+  return new Promise((resolve44, reject) => {
     const env = { ...process.env, ...descriptor.env };
     const invocation = prepareSpawnInvocation(descriptor.command, descriptor.args ?? [], { env });
     const child = spawn(invocation.command, invocation.args, {
@@ -8944,7 +8987,7 @@ function runShellHandler(descriptor, event, signal) {
         return;
       }
       try {
-        resolve43(HookDecisionSchema.parse(JSON.parse(stdout)));
+        resolve44(HookDecisionSchema.parse(JSON.parse(stdout)));
       } catch (error) {
         reject(error);
       }
@@ -8983,15 +9026,16 @@ function zodRecord(payload) {
 // src/utils/execFileNoThrow.ts
 import { execFile } from "child_process";
 function execFileNoThrow(file, args, options = {}) {
-  return new Promise((resolve43) => {
+  return new Promise((resolve44) => {
     const child = execFile(file, args, {
       timeout: options.timeout,
       cwd: options.useCwd === false ? void 0 : process.cwd(),
       env: options.env,
       encoding: "utf8",
-      windowsHide: true
+      windowsHide: true,
+      ...options.signal === void 0 ? {} : { signal: options.signal }
     }, (error, stdout, stderr) => {
-      resolve43({
+      resolve44({
         stdout,
         stderr,
         code: typeof error?.code === "number" ? error.code : error ? 1 : 0,
@@ -9163,14 +9207,14 @@ async function createIslandControlServer(options) {
       void dispatch(line, socket, options, token);
     });
   });
-  await new Promise((resolve43, reject) => {
+  await new Promise((resolve44, reject) => {
     const onError = (error) => {
       server.removeListener("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve43();
+      resolve44();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -9241,11 +9285,11 @@ function write(socket, payload) {
   }
 }
 function closeServer(server) {
-  return new Promise((resolve43) => {
+  return new Promise((resolve44) => {
     try {
-      server.close(() => resolve43());
+      server.close(() => resolve44());
     } catch {
-      resolve43();
+      resolve44();
     }
   });
 }
@@ -10430,7 +10474,7 @@ var USAGE = [
   "  clear     reset signals, done markers, and verified markers"
 ].join("\n");
 function runCommand(command, cwd, timeoutMs) {
-  return new Promise((resolve43) => {
+  return new Promise((resolve44) => {
     const isWindows = process.platform === "win32";
     const child = spawn2(isWindows ? "cmd.exe" : "/bin/sh", isWindows ? ["/d", "/s", "/c", command] : ["-c", command], {
       cwd,
@@ -10440,7 +10484,7 @@ function runCommand(command, cwd, timeoutMs) {
     let stderr = "";
     const timer = setTimeout(() => {
       child.kill();
-      resolve43({ ok: false, stdout, stderr: `${stderr}
+      resolve44({ ok: false, stdout, stderr: `${stderr}
 [killed: exceeded ${timeoutMs}ms]`, code: "timeout" });
     }, timeoutMs);
     child.stdout.on("data", (chunk) => {
@@ -10451,12 +10495,12 @@ function runCommand(command, cwd, timeoutMs) {
     });
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve43({ ok: false, stdout, stderr: `${stderr}
+      resolve44({ ok: false, stdout, stderr: `${stderr}
 ${error.message}`, code: "spawn" });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve43({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
+      resolve44({ ok: code === 0, stdout, stderr, code: code ?? "unknown" });
     });
   });
 }
@@ -10827,10 +10871,12 @@ ${result.stderr.slice(-4e3)}` : ""}`;
         name: "evolve_improve",
         description: "Implement a fix for one repeated tool failure. Default kind=plugin scaffolds the fix-<tool>/ plugin dir and writes PLAN.md with instructions for implementing, verifying, reloading, and testing it. kind=prompt_rule instead stores a concise guardrail rule (from `implementation`) that is injected into future system prompts and closes the suggestion. Use when the model proposes a concrete fix for a suggestion in the system prompt.",
         inputSchema,
-        paths: () => [],
-        execute: async (input) => {
+        paths: (input) => [join12(workspace, ".flavor", "evolve"), ...input.kind === "prompt_rule" ? [] : [join12(workspace, ".flavor", "plugins")]],
+        execute: async (input, signal) => {
+          signal.throwIfAborted();
           const { suggestionId, implementation, kind } = input;
           const suggestions = await openWithTrends(100);
+          signal.throwIfAborted();
           const suggestion = suggestions.find((item) => item.id === suggestionId);
           if (suggestion === void 0) throw new Error(`No open suggestion with id "${suggestionId}".`);
           if (kind === "prompt_rule") {
@@ -10869,9 +10915,7 @@ ${result.stderr.slice(-4e3)}` : ""}`;
 
 // src/init/project.ts
 import { lstat as lstat4, mkdir as mkdir9, readdir as readdir4, readFile as readFile9, realpath as realpath7, writeFile as writeFile8 } from "fs/promises";
-import { copyFileSync, mkdirSync as mkdirSync2, readdirSync } from "fs";
-import { basename as basename4, dirname as dirname9, isAbsolute as isAbsolute8, join as join13, relative as relative8, sep as sep8 } from "path";
-import { fileURLToPath } from "url";
+import { basename as basename4, isAbsolute as isAbsolute8, join as join13, relative as relative8, sep as sep8 } from "path";
 var GENERATED_START = "<!-- flavor-code:start -->";
 var GENERATED_END = "<!-- flavor-code:end -->";
 var MAX_MANIFEST_BYTES2 = 1e6;
@@ -11322,29 +11366,8 @@ async function createExampleFlavorConfig(cwd) {
   };
   await writeFile8(configPath, JSON.stringify(example, null, 2) + "\n");
 }
-var ASTGRAPH_SRC_DIR = join13(dirname9(fileURLToPath(import.meta.url)), "astgraph");
-async function copyAstgraphPlugin(cwd) {
-  const pluginDir = join13(cwd, ".flavor", "plugins", "astgraph");
-  try {
-    await lstat4(pluginDir);
-    return;
-  } catch (error) {
-    if (!isMissingPathError(error)) throw error;
-  }
-  copyDirectory(ASTGRAPH_SRC_DIR, pluginDir);
-}
-function copyDirectory(from, to) {
-  mkdirSync2(to, { recursive: true, mode: 448 });
-  for (const entry2 of readdirSync(from, { withFileTypes: true })) {
-    const source = join13(from, entry2.name);
-    const target = join13(to, entry2.name);
-    if (entry2.isDirectory()) copyDirectory(source, target);
-    else if (entry2.isFile()) copyFileSync(source, target);
-  }
-}
 async function initializeFlavor(cwd) {
   await ensureFlavorDirectories(cwd);
-  await copyAstgraphPlugin(cwd);
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
   const path = join13(cwd, "FLAVOR.md");
@@ -12439,7 +12462,7 @@ function formatPriorGaps(gaps) {
 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";
+import { dirname as dirname9, join as join16, relative as relative9, resolve as resolve12, sep as sep9 } from "path";
 var DEFAULT_MAX_BYTES = 1024 * 1024;
 var GoalStore = class {
   #workspace;
@@ -12452,7 +12475,7 @@ var GoalStore = class {
   }
   async save(input) {
     const state = GoalStateSchema.parse(input);
-    await assertNoSymlink(this.#workspace, dirname10(this.#root));
+    await assertNoSymlink(this.#workspace, dirname9(this.#root));
     await mkdir11(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink(this.#workspace, this.#root);
     const target = join16(this.#root, `${state.id}.json`);
@@ -12486,7 +12509,7 @@ async function assertNoSymlink(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname10(cursor);
+    cursor = dirname9(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -12573,7 +12596,7 @@ async function ensureWorktreeDirectoryIgnored(root) {
 // src/loop/store.ts
 import { constants as constants5 } from "fs";
 import { lstat as lstat6, mkdir as mkdir13, open as open6, readFile as readFile12, realpath as realpath8, rename as rename5, rm as rm7, stat as stat6 } from "fs/promises";
-import { dirname as dirname11, join as join18, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
+import { dirname as dirname10, join as join18, relative as relative10, resolve as resolve14, sep as sep10 } from "path";
 import { randomUUID as randomUUID12 } from "crypto";
 var LOOP_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var DEFAULT_MAX_BYTES2 = 5 * 1024 * 1024;
@@ -12655,7 +12678,7 @@ var LoopStore = class {
   }
   async #prepare(loopId) {
     validateId(loopId);
-    await assertNoSymlink2(this.#workspace, dirname11(this.#root));
+    await assertNoSymlink2(this.#workspace, dirname10(this.#root));
     await mkdir13(this.#root, { recursive: true, mode: 448 });
     await assertNoSymlink2(this.#workspace, this.#root);
     const directory = join18(this.#root, loopId);
@@ -12688,7 +12711,7 @@ async function assertNoSymlink2(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname11(cursor);
+    cursor = dirname10(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -12718,7 +12741,7 @@ import { readFile as readFile13 } from "fs/promises";
 import { join as join20 } from "path";
 
 // src/tools/shell.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { basename as basename5, delimiter as delimiter2, isAbsolute as isAbsolute9, join as join19, relative as relative11, resolve as resolve15, sep as sep11 } from "path";
 import { z as z23 } from "zod";
@@ -12761,7 +12784,7 @@ function createJobTools(registry) {
       inputSchema: IdInput,
       paths: () => [],
       execute: async (input, _signal, context) => {
-        registry.kill(input.id, owner(context));
+        await registry.kill(input.id, owner(context));
         return registry.read(input.id, owner(context));
       },
       presentResult: (output) => jobPresentation("kill", output)
@@ -12801,11 +12824,51 @@ function owner(context) {
   return context?.ownerId ?? context?.agent ?? "main";
 }
 
+// src/utils/process-tree.ts
+import { spawn as spawn3 } from "child_process";
+async function terminateProcessTree3(pid) {
+  if (pid === void 0) return;
+  if (process.platform === "win32") {
+    await new Promise((resolve44) => {
+      const child = spawn3("taskkill", ["/pid", String(pid), "/T", "/F"], { shell: false, windowsHide: true });
+      const finish = () => {
+        clearTimeout(timer);
+        resolve44();
+      };
+      const timer = setTimeout(finish, 5e3);
+      timer.unref();
+      child.once("error", finish);
+      child.once("close", finish);
+    });
+    try {
+      process.kill(pid);
+    } catch {
+    }
+  } else {
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    await new Promise((resolve44) => setTimeout(resolve44, 250));
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+}
+
 // src/tools/shell.ts
 var DEFAULT_MAX_OUTPUT_BYTES2 = 1048576;
 var DEFAULT_SHELL_TIMEOUT_MS = 10 * 6e4;
 var ELLIPSIS = "\u2026";
-var TERMINATION_GRACE_MS = 250;
 var TERMINATION_FAILURE_MS = 5e3;
 var STREAM_CLOSE_GRACE_MS = 500;
 var ShellInput = z23.object({
@@ -12824,12 +12887,6 @@ function normalizeShellCommand(input) {
   if ((executable === "cmd" || executable === "cmd.exe") && /^\/[ck]$/iu.test(args[0] ?? "")) {
     return { command, args: [args[0], ...args.slice(1).map(unquoteToken)] };
   }
-  if ((executable === "pwsh" || executable === "pwsh.exe" || executable === "powershell" || executable === "powershell.exe") && /^(?:-c|-command)$/iu.test(args[0] ?? "") && args.length > 1) {
-    return { command, args: [args[0], ...args.slice(1).map(unquoteToken)] };
-  }
-  if (/^(?:sh|bash|zsh|fish)$/iu.test(executable) && args[0] === "-c" && args[1] !== void 0) {
-    return { command, args: [args[0], unquoteToken(args[1]), ...args.slice(2)] };
-  }
   if (!/\s/u.test(command) || containsShellSyntax(command)) return { command, args };
   const tokens2 = tokenizeCommandLine(command);
   if (tokens2.length <= 1) return { command, args };
@@ -12947,7 +13004,8 @@ function shellInvocation(input, cwd, environment) {
         const payload = serializeCmdPayload(input.args.slice(commandFlag + 1));
         return {
           command: resolved,
-          args: [...input.args.slice(0, commandFlag + 1), `chcp 65001>nul & ${payload}`]
+          args: [...input.args.slice(0, commandFlag + 1), `chcp 65001>nul & ${payload}`],
+          windowsVerbatimArguments: true
         };
       }
     }
@@ -12963,7 +13021,8 @@ function shellInvocation(input, cwd, environment) {
   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}`]
+    args: ["/d", "/s", "/c", `chcp 65001>nul & ${script}`],
+    windowsVerbatimArguments: true
   };
   const encoded = Buffer.from(script, "utf16le").toString("base64");
   return {
@@ -12986,8 +13045,8 @@ function executionEnvironmentCommand(environment, command, args) {
 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 }`;
+  const invocation = `& ${psQuote(command)}${args.length > 0 ? ` ${args.map((arg) => /^-[A-Za-z][A-Za-z0-9-]*$/u.test(arg) ? arg : psQuote(arg)).join(" ")}` : ""}`;
+  return `$ErrorActionPreference='Stop'; try { ${invocation}; if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE } else { exit 0 } } catch { [Console]::Error.WriteLine($_.Exception.Message); if ($_.Exception -is [System.Management.Automation.CommandNotFoundException]) { exit 127 } else { exit 1 } }`;
 }
 function posixQuote(value) {
   return `'${value.replace(/'/gu, `'"'"'`)}'`;
@@ -13020,7 +13079,7 @@ ${result.stderr}`;
     return {
       kind: "command-not-found",
       message: `Executable "${command}" was not found by the selected runtime shell.`,
-      hint: "Use a command available on PATH, or pass an existing executable path without surrounding quotes."
+      hint: "Use a command available on PATH, or pass an existing executable path without surrounding quotes. For an unavailable PowerShell cmdlet, check Get-Command and its module in the selected shell; do not keep retrying the same command."
     };
   }
   if (code === "EACCES" || /(?:permission denied|access is denied|拒绝访问)/iu.test(detail)) {
@@ -13029,11 +13088,11 @@ ${result.stderr}`;
   if (/(?:no such file or directory|cannot find (?:the )?path|system cannot find|系统找不到指定的路径)/iu.test(detail)) {
     return { kind: "path-not-found", message: "The command referenced a path that does not exist." };
   }
-  if (/(?:syntax error|unexpected token|parsererror|语法错误)/iu.test(detail)) {
+  if (/(?:syntax\s*error|unexpected token|parsererror|unterminated (?:regexp|string)|语法错误)/iu.test(detail)) {
     return {
       kind: "shell-syntax",
-      message: "The selected runtime shell rejected the command syntax.",
-      hint: "Pass normal arguments through args; reserve shell syntax for pipes, redirects, and operators."
+      message: "The command or interpreter rejected the syntax.",
+      hint: 'Pass normal arguments through args. For JavaScript use command="node", args=["-e", "<complete script>"] without an extra shell or surrounding quotes. Legacy Windows PowerShell can strip quotes when forwarding native arguments.'
     };
   }
   return {
@@ -13055,7 +13114,7 @@ function createShellTool(workspace, options = {}) {
   }
   return {
     name: "Shell",
-    description: "Run a bounded command reliably inside the workspace. Pass a bare executable in command and one unquoted logical value per args entry; shell syntax is supported only when command contains pipes, redirects, or operators. stdout/stderr are returned verbatim and failures include a structured diagnostic. background=true returns a managed job id.",
+    description: 'Run a bounded command reliably inside the workspace. Pass a bare executable in command and one logical value per args entry, without adding surrounding shell quotes. For Node scripts use command="node", args=["-e", "<complete JavaScript>"]; do not wrap native commands in cmd /c or PowerShell -Command unless shell syntax is needed, since legacy PowerShell can strip embedded quotes. Use Grep for text searches and Read/Edit for file changes. stdout/stderr are returned verbatim and failures include a structured diagnostic. background=true returns a managed job id.',
     inputSchema: ShellInput,
     paths: (input) => [workingDirectory(root, input.cwd ?? void 0)],
     summarize: (input) => [input.command, ...input.args].join(" "),
@@ -13155,7 +13214,7 @@ async function executeShell(root, input, cancellation, maxBytes, environment = p
       return;
     }
     const invocation = shellInvocation(input, cwd, environment);
-    const child = spawn3(invocation.command, invocation.args, {
+    const child = spawn4(invocation.command, invocation.args, {
       cwd,
       shell: false,
       windowsHide: true,
@@ -13182,7 +13241,7 @@ async function executeShell(root, input, cancellation, maxBytes, environment = p
         void finishResolve(observedExitCode ?? child.exitCode, observedSignal ?? child.signalCode);
         return;
       }
-      termination = terminateTree(child.pid);
+      termination = terminateProcessTree3(child.pid);
       terminalTimer = setTimeout(() => finishReject(new Error(`Process did not close after ${reason} termination`)), TERMINATION_FAILURE_MS);
       terminalTimer.unref();
     };
@@ -13342,52 +13401,6 @@ function workingDirectory(root, cwd = ".") {
   if (delta === ".." || delta.startsWith(`..${sep11}`) || isAbsolute9(delta)) throw new Error("Working directory is outside the workspace");
   return candidate;
 }
-async function terminateTree(pid) {
-  if (pid === void 0) return;
-  if (process.platform === "win32") {
-    await waitForProcess(spawn3("taskkill", ["/pid", String(pid), "/T", "/F"], { shell: false, windowsHide: true }));
-    try {
-      process.kill(pid);
-    } catch {
-    }
-  } else {
-    try {
-      process.kill(-pid, "SIGTERM");
-    } catch {
-      try {
-        process.kill(pid, "SIGTERM");
-      } catch {
-      }
-    }
-    await delay2(TERMINATION_GRACE_MS);
-    try {
-      process.kill(-pid, "SIGKILL");
-    } catch {
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {
-      }
-    }
-  }
-}
-function waitForProcess(child) {
-  return new Promise((resolvePromise) => {
-    let settled = false;
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolvePromise();
-    };
-    const timer = setTimeout(finish, TERMINATION_FAILURE_MS);
-    timer.unref();
-    child.once("error", finish);
-    child.once("close", finish);
-  });
-}
-function delay2(milliseconds) {
-  return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
-}
 function decodeOutput(buffer) {
   const encoding = outputEncoding(buffer);
   return new TextDecoder(encoding).decode(buffer);
@@ -13639,7 +13652,7 @@ function isEnvTruthy(value) {
 
 // src/utils/log.ts
 import { appendFile as appendFile3, mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname12, join as join21, resolve as resolve16 } from "path";
+import { dirname as dirname11, join as join21, resolve as resolve16 } from "path";
 var pending = Promise.resolve();
 var usagePending = Promise.resolve();
 function usageLogPath() {
@@ -13658,7 +13671,7 @@ async function appendUsageLog(line) {
   usagePending = usagePending.catch(() => void 0).then(async () => {
     try {
       const path = usageLogPath();
-      await mkdir14(dirname12(path), { recursive: true, mode: 448 });
+      await mkdir14(dirname11(path), { recursive: true, mode: 448 });
       const flag = truncateOnNextAppend ? "w" : "a";
       truncateOnNextAppend = false;
       await appendFile3(path, `${line}
@@ -13686,7 +13699,7 @@ var AuditLogger = class {
   }
   async #write(line) {
     try {
-      await mkdir14(dirname12(this.#path), { recursive: true, mode: 448 });
+      await mkdir14(dirname11(this.#path), { recursive: true, mode: 448 });
       await appendFile3(this.#path, line, { encoding: "utf8", mode: 384, flag: "a" });
     } catch {
     }
@@ -14546,12 +14559,12 @@ import {
 
 // src/utils/version.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname13, join as join22 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname12, join as join22 } from "path";
+import { fileURLToPath } from "url";
 var cached;
 function packageVersion() {
   if (cached !== void 0) return cached;
-  let directory = dirname13(fileURLToPath2(import.meta.url));
+  let directory = dirname12(fileURLToPath(import.meta.url));
   for (; ; ) {
     try {
       const manifest = JSON.parse(readFileSync2(join22(directory, "package.json"), "utf8"));
@@ -14561,7 +14574,7 @@ function packageVersion() {
       }
     } catch {
     }
-    const parent = dirname13(directory);
+    const parent = dirname12(directory);
     if (parent === directory) break;
     directory = parent;
   }
@@ -14787,8 +14800,8 @@ var OAuthCallbackAuthProvider = class {
   async #startCallbackServer(expectedState, signal) {
     let serverResolve;
     let serverReject;
-    const codePromise = new Promise((resolve43, reject) => {
-      serverResolve = resolve43;
+    const codePromise = new Promise((resolve44, reject) => {
+      serverResolve = resolve44;
       serverReject = reject;
     });
     const server = createServer3((req, res) => {
@@ -14822,7 +14835,7 @@ var OAuthCallbackAuthProvider = class {
       );
       serverResolve(code);
     });
-    return new Promise((resolve43, reject) => {
+    return new Promise((resolve44, reject) => {
       server.once("error", (error) => {
         reject(new Error(`OAuth callback server failed: ${error.message}`));
       });
@@ -14839,7 +14852,7 @@ var OAuthCallbackAuthProvider = class {
         signal.addEventListener("abort", () => {
           serverReject(new Error("OAuth flow aborted"));
         }, { once: true });
-        resolve43({ redirectUri, promise: codePromise });
+        resolve44({ redirectUri, promise: codePromise });
       });
     });
   }
@@ -14921,7 +14934,7 @@ function escapeHtml(text) {
 }
 
 // src/auth/store.ts
-import { dirname as dirname14 } from "path";
+import { dirname as dirname13 } from "path";
 async function retainOnlyCredentials(store, keepCredentialId) {
   const tokens2 = await store.load();
   const retained = Object.fromEntries(Object.entries(tokens2).filter(([id]) => id === keepCredentialId));
@@ -14932,7 +14945,7 @@ function createFileTokenStore(filePath) {
   const store = {
     tokens: {},
     async load() {
-      const key = await loadOrCreateConfigKey(dirname14(filePath));
+      const key = await loadOrCreateConfigKey(dirname13(filePath));
       const result = await readRecoverableFile(filePath, (raw) => parseTokens(decryptDocument(raw, key)));
       const tokens2 = result?.value ?? {};
       baseline = { ...tokens2 };
@@ -14940,7 +14953,7 @@ function createFileTokenStore(filePath) {
       return tokens2;
     },
     async save(tokens2) {
-      const key = await loadOrCreateConfigKey(dirname14(filePath));
+      const key = await loadOrCreateConfigKey(dirname13(filePath));
       const removals = Object.keys(baseline).filter((providerId) => !(providerId in tokens2));
       const upserts = Object.fromEntries(Object.entries(tokens2).filter(
         ([providerId, token]) => !sameToken(baseline[providerId], token)
@@ -15769,10 +15782,14 @@ function createSkillResourceTool(registry) {
     name: "SkillResource",
     description: "Read a bounded resource explicitly referenced by a discovered skill; scripts are returned as data and never executed",
     inputSchema: SkillResourceInput,
+    readOnly: true,
     paths: () => [],
     execute: async (input, signal) => {
       signal.throwIfAborted();
-      const skill = (await registry.discover()).find((candidate) => candidate.name === input.skill);
+      const requested = input.skill.trim();
+      const alias = requested.includes(":") ? requested.slice(requested.lastIndexOf(":") + 1) : requested;
+      const discovered = await registry.discover();
+      const skill = discovered.find((candidate) => candidate.name === requested) ?? discovered.find((candidate) => candidate.name === alias);
       if (skill === void 0) throw new Error(`Unknown skill: ${input.skill}`);
       const capability = await registry.resolveResource(skill, input.reference);
       const content = await registry.readResource(capability);
@@ -15790,7 +15807,7 @@ function createSkillResourceTool(registry) {
 // src/session/store.ts
 import { constants as constants7 } from "fs";
 import { lstat as lstat8, mkdir as mkdir15, open as open7, readFile as readFile17, readdir as readdir6, realpath as realpath10, rename as rename6, rm as rm8, stat as stat7 } from "fs/promises";
-import { basename as basename6, dirname as dirname15, join as join24, relative as relative13, resolve as resolve20, sep as sep13 } from "path";
+import { basename as basename6, dirname as dirname14, 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";
 
@@ -16712,7 +16729,7 @@ var SessionStore = class {
     }
   }
   async #prepareDirectory() {
-    await assertNoSymlink3(this.#workspace, dirname15(this.#sessions));
+    await assertNoSymlink3(this.#workspace, dirname14(this.#sessions));
     await mkdir15(this.#sessions, { recursive: true, mode: 448 });
     await this.#assertSafeExistingDirectory();
   }
@@ -16940,7 +16957,7 @@ async function assertNoSymlink3(root, target) {
   const chain = [];
   while (cursor !== stop) {
     chain.push(cursor);
-    cursor = dirname15(cursor);
+    cursor = dirname14(cursor);
   }
   for (const path of chain.reverse()) {
     try {
@@ -16985,13 +17002,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 join26, resolve as resolve22 } from "path";
+import { dirname as dirname16, 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 join25, relative as relative14, resolve as resolve21, sep as sep14 } from "path";
+import { dirname as dirname15, 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;
@@ -17077,7 +17094,7 @@ var WorkspaceCheckpointStore = class {
     for (const file of checkpoint.files) {
       const target = contained(this.#workspace, file.path);
       const object = objects.get(file.digest);
-      await mkdir16(dirname16(target), { recursive: true });
+      await mkdir16(dirname15(target), { recursive: true });
       const temporary = `${target}.${process.pid}.${randomUUID14()}.tmp`;
       await writeFile10(temporary, object, { mode: file.mode });
       await rename7(temporary, target);
@@ -17149,7 +17166,7 @@ function contained(workspace, path) {
   return absolute;
 }
 async function atomicJson(path, value) {
-  await mkdir16(dirname16(path), { recursive: true });
+  await mkdir16(dirname15(path), { recursive: true });
   const temporary = `${path}.${process.pid}.${randomUUID14()}.tmp`;
   await writeFile10(temporary, `${JSON.stringify(value)}
 `, { encoding: "utf8", mode: 384 });
@@ -17264,7 +17281,7 @@ var SessionHistory = class _SessionHistory {
       leafId: this.#leafId,
       nodes: this.#nodes
     };
-    await mkdir17(dirname17(this.#path), { recursive: true });
+    await mkdir17(dirname16(this.#path), { recursive: true });
     const temporary = `${this.#path}.${process.pid}.${randomUUID15()}.tmp`;
     await writeFile11(temporary, `${JSON.stringify(document)}
 `, { encoding: "utf8", mode: 384 });
@@ -17563,14 +17580,14 @@ var ProjectSleepScheduler = class {
     const next = new Date(now);
     next.setDate(next.getDate() + 1);
     next.setHours(0, 0, 0, 0);
-    const delay4 = Math.max(1, next.getTime() - now.getTime());
+    const delay3 = Math.max(1, next.getTime() - now.getTime());
     const targetDate = localDateKey(now);
     this.#dailyTimer = setTimeout(() => {
       this.#dailyTimer = void 0;
       if (this.#disposed) return;
       this.#enqueue(targetDate);
       this.#scheduleNextMidnight();
-    }, delay4);
+    }, delay3);
     this.#dailyTimer.unref?.();
   }
   #enqueue(date) {
@@ -17865,7 +17882,7 @@ function computeSessionStats(documents) {
 // src/tools/files.ts
 import { constants as constants9 } from "fs";
 import { mkdir as mkdir19, open as open10, readFile as readFile20, realpath as realpath12, rename as rename10, rm as rm11, stat as stat8 } from "fs/promises";
-import { dirname as dirname18, isAbsolute as isAbsolute12, relative as relative16, resolve as resolve24, sep as sep16 } from "path";
+import { dirname as dirname17, isAbsolute as isAbsolute12, relative as relative16, resolve as resolve24, sep as sep16 } from "path";
 import { randomUUID as randomUUID17 } from "crypto";
 import { z as z29 } from "zod";
 
@@ -17983,8 +18000,12 @@ var ReadInput2 = z29.object({
   force: z29.union([z29.boolean(), z29.string().refine((value) => value === "true" || value === "false")]).nullable().optional()
 });
 var WriteInput = z29.object({ path: z29.string().min(1), content: z29.string() });
-var EditInput = z29.object({ path: z29.string().min(1), oldText: z29.string().min(1), newText: z29.string() });
-var ApplyPatchInput = z29.object({ patch: z29.string().min(1) });
+var EditInput = z29.object({
+  path: z29.string().min(1),
+  oldText: z29.string().min(1).describe("Copy exact current file text from Read, without displayed line numbers or diff prefixes. Include enough context for one unique match."),
+  newText: z29.string()
+});
+var ApplyPatchInput = z29.object({ patch: z29.string().min(1).describe("One-file unified diff with --- a/path, +++ b/path and @@ hunk headers. Use /dev/null as the old path to create a file.") });
 var FileObservationStore = class {
   #versions = /* @__PURE__ */ new Map();
   get(path) {
@@ -18027,9 +18048,9 @@ function createReadTool(workspace, options = {}) {
       const windowBytes = rangeRequested ? Math.max(maxBytes, Math.min(info.size, MAX_READ_BYTES)) : maxBytes;
       const contents = await readBounded2(path, windowBytes, signal, openFile2);
       if (isBinary(contents)) throw new Error("Cannot read binary file as text");
-      const textEnd = utf8SafeEnd(contents, windowBytes);
+      const textEnd = contents.length > windowBytes ? utf8SafeEnd(contents, windowBytes) : contents.length;
       const truncated = contents.length > windowBytes;
-      const text = contents.subarray(0, textEnd).toString("utf8").replaceAll("\r\n", "\n");
+      const text = decodeFileText(contents.subarray(0, textEnd)).replaceAll("\r\n", "\n");
       options.observations?.set(path, versionOfStat(info));
       const lines = text.split("\n");
       if (lines.at(-1) === "") lines.pop();
@@ -18105,7 +18126,7 @@ function createEditTool(workspace, options = {}) {
   const guard = createPathGuard(workspace);
   return {
     name: "Edit",
-    description: "Replace one unique exact text match",
+    description: "Replace one unique exact text match, accepting LF or CRLF input. Read the file before editing; after a mismatch, re-read with force=true and copy the current text instead of retrying the same oldText.",
     inputSchema: EditInput,
     paths: (input) => [guard.lexical(input.path)],
     execute: async (input, signal) => {
@@ -18115,14 +18136,14 @@ function createEditTool(workspace, options = {}) {
       const expected = await expectedMutationVersion(path, options.observations);
       const contents = await readText(path);
       const hasCRLF = contents.includes("\r\n");
-      const norm = (s) => hasCRLF ? s.replace(/\r\n/g, "\n") : s;
+      const norm = (s) => s.replace(/\r\n/g, "\n");
       const contentsLF = norm(contents);
       const oldTextLF = norm(input.oldText);
       const newTextLF = norm(input.newText);
       const first = contentsLF.indexOf(oldTextLF);
-      const second = first < 0 ? -1 : contentsLF.indexOf(oldTextLF, first + oldTextLF.length);
+      const second = first < 0 ? -1 : contentsLF.indexOf(oldTextLF, first + 1);
       if (first < 0 || second >= 0) {
-        const diagnosis = buildEditDiagnosis(contentsLF, oldTextLF, first, second);
+        const diagnosis = buildEditDiagnosis(contentsLF, oldTextLF, second);
         throw new Error(diagnosis);
       }
       const updatedLF = contentsLF.slice(0, first) + newTextLF + contentsLF.slice(first + oldTextLF.length);
@@ -18142,7 +18163,7 @@ function createApplyPatchTool(workspace, options = {}) {
   const guard = createPathGuard(workspace);
   return {
     name: "ApplyPatch",
-    description: "Apply a workspace-limited unified diff, relocating hunks only by unique exact context",
+    description: "Apply a single-file workspace-limited unified diff, relocating hunks only by unique exact context. Submit separate calls for multiple files.",
     inputSchema: ApplyPatchInput,
     paths: (input) => parsePatch(input.patch).map((file) => guard.lexical(file.path)),
     execute: async (input, signal) => {
@@ -18207,7 +18228,7 @@ function createPathGuard(workspace) {
           break;
         } catch (error) {
           if (!isMissing2(error)) throw error;
-          const parent = dirname18(ancestor);
+          const parent = dirname17(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
         }
@@ -18218,12 +18239,19 @@ function createPathGuard(workspace) {
 }
 async function atomicWrite(path, content, signal, expectedVersion) {
   abortIfNeeded(signal);
-  await mkdir19(dirname18(path), { recursive: true });
+  await mkdir19(dirname17(path), { recursive: true });
   const temporary = `${path}.${randomUUID17()}.tmp`;
+  let mode;
+  try {
+    mode = (await stat8(path)).mode & 511;
+  } catch (error) {
+    if (!isMissing2(error)) throw error;
+  }
   try {
     const handle = await open10(temporary, constants9.O_CREAT | constants9.O_EXCL | constants9.O_WRONLY, 384);
     try {
       await handle.writeFile(content, "utf8");
+      if (mode !== void 0) await handle.chmod(mode);
       await handle.sync();
     } finally {
       await handle.close();
@@ -18240,7 +18268,14 @@ async function atomicWrite(path, content, signal, expectedVersion) {
 async function readText(path) {
   const contents = await readFile20(path);
   if (isBinary(contents)) throw new Error("Cannot edit binary file as text");
-  return contents.toString("utf8");
+  return decodeFileText(contents);
+}
+function decodeFileText(contents) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(contents);
+  } catch {
+    throw new Error("File is not valid UTF-8 text. Convert its encoding before using Read/Edit/ApplyPatch to avoid corrupting its contents.");
+  }
 }
 var ABSENT_VERSION = "absent";
 async function expectedMutationVersion(path, observations) {
@@ -18450,11 +18485,12 @@ function patchPath(header) {
   const raw = header.split("	", 1)[0].trim();
   return raw.startsWith("a/") || raw.startsWith("b/") ? raw.slice(2) : raw;
 }
-function buildEditDiagnosis(contentsLF, oldTextLF, first, second) {
+function buildEditDiagnosis(contentsLF, oldTextLF, second) {
   let diagnosis = "oldText must match exactly once";
   if (second >= 0) {
-    const count = contentsLF.split(oldTextLF).length - 1;
-    diagnosis += ` \u2014 matched ${count} times in the file`;
+    let count = 0;
+    for (let index = contentsLF.indexOf(oldTextLF); index >= 0; index = contentsLF.indexOf(oldTextLF, index + 1)) count += 1;
+    diagnosis += ` \u2014 matched ${count} times in the file. No changes made. Include more surrounding text to select one occurrence.`;
     return diagnosis;
   }
   const oldLines = oldTextLF.split("\n");
@@ -18490,7 +18526,8 @@ ${snippet}
 First lines of file:
 ${fileSnippet}`;
   }
-  return diagnosis;
+  return `${diagnosis}
+No changes made. Use Read with force=true to retrieve current text, or Grep with fixedStrings=true to locate it. Copy oldText exactly without line-number prefixes; do not repeat the same failed edit.`;
 }
 function applyHunks(original, hunks) {
   const hasCRLF = original.includes("\r\n");
@@ -18576,9 +18613,9 @@ function matchesLines(source, start, expected) {
 }
 
 // src/tools/search.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { open as open11, opendir, stat as stat9 } from "fs/promises";
-import { dirname as dirname19, isAbsolute as isAbsolute13, relative as relative17, resolve as resolve25, sep as sep17 } from "path";
+import { isAbsolute as isAbsolute13, relative as relative17, resolve as resolve25, sep as sep17 } from "path";
 import { rgPath as bundledRgPath } from "@vscode/ripgrep";
 import createIgnore from "ignore";
 import { z as z30 } from "zod";
@@ -18669,8 +18706,9 @@ var GlobInput = z30.object({
   limit: z30.coerce.number().int().positive().max(1e5).nullable().optional()
 });
 var GrepInput = z30.object({
-  pattern: z30.string().min(1),
-  path: z30.string().min(1).describe('Workspace-relative search path. Use JSON null, not the string "null", for the workspace root.').nullable().optional(),
+  pattern: z30.string().min(1).describe("Regular expression without / delimiters, or literal text when fixedStrings=true."),
+  fixedStrings: BooleanInput.describe("Match literal text, useful for Markdown links and paths containing regex punctuation.").nullable().optional(),
+  path: z30.string().min(1).describe("Workspace-relative file or directory. A file restricts the search to that file. Use glob for multiple filenames and JSON null for the workspace root.").nullable().optional(),
   glob: z30.string().min(1).nullable().optional(),
   fileType: z30.enum(FILE_TYPES).nullable().optional(),
   includeIgnored: BooleanInput.describe("Include files excluded by .gitignore or .ignore. Git metadata remains excluded.").nullable().optional(),
@@ -18719,7 +18757,7 @@ function createGrepTool(workspace, options = {}) {
   const resources = searchResources(options);
   return {
     name: "Grep",
-    description: `Search workspace text with a regular expression. fileType must be one of: ${FILE_TYPES.join(", ")}.`,
+    description: `Search workspace text with a regular expression or fixedStrings=true for literal text. Zero matches is a successful search, not a path error. fileType must be one of: ${FILE_TYPES.join(", ")}.`,
     inputSchema: GrepInput,
     paths: (input) => [scope(root, searchPath(input.path))],
     summarize: (input) => {
@@ -18727,10 +18765,10 @@ function createGrepTool(workspace, options = {}) {
       const where = path ? ` in ${path}` : "";
       const kind = input.fileType ? ` [${input.fileType}]` : "";
       const ignored2 = input.includeIgnored === true ? " (including ignored files)" : "";
-      return `pattern: /${input.pattern}/${kind}${where}${ignored2}`;
+      return `pattern: ${input.fixedStrings === true ? JSON.stringify(input.pattern) : `/${input.pattern}/`}${kind}${where}${ignored2}`;
     },
     execute: async (input, signal) => {
-      const expression = new RegExp(input.pattern);
+      const expression = new RegExp(input.fixedStrings === true ? input.pattern.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&") : input.pattern);
       const limit = input.limit ?? options.defaultLimit ?? DEFAULT_RESULT_LIMIT;
       const context = input.context ?? 0;
       const start = await resolveGrepPath(root, searchPath(input.path));
@@ -18781,10 +18819,12 @@ async function rgGrep(root, start, input, context, signal, executable, argsPrefi
   }
   const args = ["--json", "--line-number", "--column", "--sort", "path", "--hidden", "--glob", "!.git", "--glob", "!.git/**", "--max-filesize", String(maxFileBytes), "--context", String(context)];
   if (input.includeIgnored === true) args.push("--no-ignore");
+  if (input.fixedStrings === true) args.push("--fixed-strings");
   if (input.glob !== void 0 && input.glob !== null) args.push("--glob", input.glob);
   else for (const extension2 of typeExtensions ?? []) args.push("--glob", `*${extension2}`);
   args.push("--regexp", input.pattern, "--", relative17(root, start) || ".");
   const matches = [];
+  const matcher = input.glob == null ? void 0 : globRegex(input.glob);
   const ignoreLayers = input.includeIgnored === true ? [] : await collectIgnoreLayers(root, start, signal, resources, ignoreBudget);
   const parser = delimitedParser(10, (record3) => {
     if (record3.length === 0) return true;
@@ -18797,6 +18837,7 @@ async function rgGrep(root, start, input, context, signal, executable, argsPrefi
     const lineWithEnding = tryDecodeUtf8(lineValue);
     if (decodedPath === void 0 || lineWithEnding === void 0) return true;
     const path = normalizePath(decodedPath).replace(/^\.\//, "");
+    if (matcher !== void 0 && !matcher.test(path)) return true;
     if (typeExtensions !== void 0 && !typeExtensions.some((extension2) => path.endsWith(extension2))) return true;
     if (ignored(path, false, ignoreLayers)) return true;
     const text = lineWithEnding.replace(/\r?\n$/, "");
@@ -18921,7 +18962,12 @@ async function nodeFiles(root, start, signal, accept, limit, resources, ignoreBu
     }
     ignores.length = ruleCount;
   }
-  await walk(start);
+  if ((await stat9(start)).isFile()) {
+    const path = normalizedRelative(root, start);
+    if (!isGitMetadataPath(root, start) && (includeIgnored || !ignored(path, false, ignores)) && accept(path)) output.push(path);
+  } else {
+    await walk(start);
+  }
   return output;
 }
 async function collectIgnoreLayers(root, start, signal, resources, ignoreBudget) {
@@ -18951,7 +18997,7 @@ async function collectIgnoreLayers(root, start, signal, resources, ignoreBudget)
       if (!ignored(path, true, layers)) await walk(absolute);
     }
   }
-  await walk(start);
+  if (!(await stat9(start)).isFile()) await walk(start);
   return layers;
 }
 async function loadIgnoreFiles(directory, base, rules, budget, signal) {
@@ -19071,8 +19117,12 @@ async function resolveGrepPath(root, path = ".") {
   const candidate = scope(root, path);
   try {
     const info = await stat9(candidate);
-    if (info.isFile()) return dirname19(candidate);
-  } catch {
+    if (!info.isFile() && !info.isDirectory()) throw new Error("Search path must be a file or directory");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Search path does not exist: ${path}. Use Glob to find the file; put filename patterns in glob, not path.`);
+    }
+    throw error;
   }
   return candidate;
 }
@@ -19142,7 +19192,7 @@ function delimitedParser(delimiter4, onRecord) {
 function runStreaming(executable, args, cwd, signal, maxBytes, parser) {
   return new Promise((resolvePromise, reject) => {
     abort(signal);
-    const child = spawn4(executable, args, { cwd, shell: false, windowsHide: true });
+    const child = spawn5(executable, args, { cwd, shell: false, windowsHide: true });
     let stdoutBytes = 0;
     let stderrBytes = 0;
     let stderr = Buffer.alloc(0);
@@ -19270,6 +19320,19 @@ import { isIP } from "net";
 import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { z as z31 } from "zod";
+
+// src/utils/abort.ts
+function waitWithSignal(operation, signal) {
+  if (signal === void 0) return operation;
+  return new Promise((resolve44, reject) => {
+    const abort2 = () => reject(signal.reason);
+    if (signal.aborted) abort2();
+    else signal.addEventListener("abort", abort2, { once: true });
+    operation.then(resolve44, reject).finally(() => signal.removeEventListener("abort", abort2));
+  });
+}
+
+// src/tools/web.ts
 var WebFetchInput = z31.object({
   url: z31.string().url().max(8192),
   timeoutMs: z31.coerce.number().int().positive().max(12e4).optional(),
@@ -19315,7 +19378,12 @@ function createWebSearchTool(provider = createDefaultWebSearchProvider()) {
     summarize: (input) => input.query,
     presentCall: (input) => ({ kind: "web", title: `Searching: ${input.query}` }),
     permissions: () => ({ paths: [] }),
-    execute: async (input, signal) => ({ query: input.query, results: [...await provider.search(input.query, input.maxResults ?? 8, signal)] }),
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
+      const maxResults = input.maxResults ?? 8;
+      const results = await waitWithSignal(provider.search(input.query, maxResults, signal), signal);
+      return { query: input.query, results: [...results].slice(0, maxResults) };
+    },
     renderForModel: (output) => output.results.length === 0 ? `No web results found for: ${output.query}` : output.results.map((item, index) => `${index + 1}. ${item.title}
 ${item.url}
 ${item.snippet}`).join("\n\n"),
@@ -19360,10 +19428,14 @@ var MultiSourceWebSearchProvider = class {
   }
 };
 async function fetchPublic(initialUrl, options) {
+  options.signal.throwIfAborted();
+  const deadline = AbortSignal.timeout(options.timeoutMs);
+  options = { ...options, signal: AbortSignal.any([options.signal, deadline]) };
   let current = new URL(initialUrl);
   for (let redirects = 0; redirects <= 5; redirects += 1) {
+    options.signal.throwIfAborted();
     validateUrl(current);
-    const addresses = await lookup(normalizedHostname(current.hostname), { all: true, verbatim: true });
+    const addresses = await waitWithSignal(lookup(normalizedHostname(current.hostname), { all: true, verbatim: true }), options.signal);
     if (addresses.length === 0) throw new Error("Host did not resolve");
     if (addresses.some((entry2) => isBlockedResolvedAddress(entry2.address, current.hostname))) {
       throw new Error("Blocked private or special network destination");
@@ -19375,7 +19447,13 @@ async function fetchPublic(initialUrl, options) {
       continue;
     }
     const contentType = response2.contentType;
-    const decoded = new TextDecoder(charset(contentType), { fatal: false }).decode(response2.body);
+    let decoder;
+    try {
+      decoder = new TextDecoder(charset(contentType), { fatal: false });
+    } catch {
+      decoder = new TextDecoder("utf-8");
+    }
+    const decoded = decoder.decode(response2.body);
     const content = !options.rawHtml && /text\/html|application\/xhtml\+xml/i.test(contentType) ? htmlToText(decoded) : decoded;
     return { url: current.href, status: response2.status, contentType, content, truncated: response2.truncated };
   }
@@ -19410,8 +19488,8 @@ async function requestAddress(url, address, options) {
       const status = response2.statusCode ?? 0;
       const location = response2.headers.location;
       if (location !== void 0 && [301, 302, 303, 307, 308].includes(status)) {
-        response2.resume();
         finish({ status, contentType: "", body: new Uint8Array(), truncated: false, redirect: location });
+        response2.destroy();
         return;
       }
       const chunks = [];
@@ -19427,7 +19505,11 @@ async function requestAddress(url, address, options) {
         const accepted = chunk.subarray(0, options.maxBytes - bytes);
         chunks.push(accepted);
         bytes += accepted.length;
-        if (accepted.length < chunk.length) truncated = true;
+        if (accepted.length < chunk.length) {
+          truncated = true;
+          finish({ status, contentType: String(response2.headers["content-type"] ?? "application/octet-stream"), body: Buffer.concat(chunks), truncated });
+          response2.destroy();
+        }
       });
       response2.once("end", () => finish({
         status,
@@ -19573,11 +19655,11 @@ function charset(contentType) {
 }
 
 // src/tools/lsp.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import { existsSync as existsSync5 } from "fs";
 import { access as access2, constants as constants10, readFile as readFile21 } from "fs/promises";
-import { 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 { basename as basename7, dirname as dirname18, extname as extname3, isAbsolute as isAbsolute14, relative as relative18, resolve as resolve26, sep as sep18 } from "path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL3 } from "url";
 import { z as z32 } from "zod";
 var LSP_REQUEST_TIMEOUT_MS = 15e3;
 var LspConnection = class {
@@ -19589,12 +19671,14 @@ var LspConnection = class {
   #nextId = 1;
   #disposed = false;
   #initError;
+  #shutdownPromise;
   constructor(command, args, cwd) {
     const invocation = prepareSpawnInvocation(command, args, { cwd });
-    this.#process = spawn5(invocation.command, invocation.args, {
+    this.#process = spawn6(invocation.command, invocation.args, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
+      detached: process.platform !== "win32",
       ...invocation.windowsVerbatimArguments === void 0 ? {} : { windowsVerbatimArguments: invocation.windowsVerbatimArguments }
     });
     this.#process.on("error", (err) => {
@@ -19603,9 +19687,15 @@ var LspConnection = class {
     });
     this.#process.once("exit", (code, signal) => {
       const reason = signal !== null ? `LSP server "${command}" exited with signal ${signal}` : `LSP server "${command}" exited with code ${code}`;
-      this.#rejectAll(new Error(reason));
+      this.#initError = new Error(reason);
+      this.#rejectAll(this.#initError);
     });
     this.#process.stdout.on("data", (chunk) => this.#buffer.feed(chunk, this.#onMessage));
+    this.#process.stderr.resume();
+    this.#process.stdin.on("error", (error) => {
+      this.#initError = error;
+      this.#rejectAll(error);
+    });
   }
   async initialize(rootUri) {
     if (this.#initError !== void 0) throw this.#initError;
@@ -19627,67 +19717,84 @@ var LspConnection = class {
     if (initResult === void 0) throw new Error("LSP initialize returned no capabilities");
     this.#notify("initialized", {});
   }
-  async findReferences(uri, line, character) {
+  async findReferences(uri, line, character, signal) {
+    signal?.throwIfAborted();
     await this.#syncDocument(uri);
     const result = await this.#request("textDocument/references", {
       textDocument: { uri },
       position: { line, character },
       context: { includeDeclaration: false }
-    });
+    }, signal);
     if (result === null || result === void 0) return [];
     if (!Array.isArray(result)) return [];
     return result.filter(isLocation);
   }
-  async hover(uri, line, character) {
+  async hover(uri, line, character, signal) {
+    signal?.throwIfAborted();
     await this.#syncDocument(uri);
     const result = await this.#request("textDocument/hover", {
       textDocument: { uri },
       position: { line, character }
-    });
+    }, signal);
     if (result === null || result === void 0) return null;
     if (typeof result === "object" && "contents" in result) {
       return result;
     }
     return null;
   }
-  async diagnostics(uri) {
+  async diagnostics(uri, signal) {
+    signal?.throwIfAborted();
     await this.#syncDocument(uri);
     const result = await this.#request("textDocument/diagnostic", {
       textDocument: { uri }
-    });
+    }, signal);
     if (result === null || result === void 0) return [];
     const items = result?.items ?? result;
     if (!Array.isArray(items)) return [];
     return items.filter(isDiagnostic);
   }
-  async shutdown() {
-    if (this.#disposed) return;
+  shutdown() {
+    if (this.#shutdownPromise !== void 0) return this.#shutdownPromise;
     this.#disposed = true;
-    try {
-      await this.#request("shutdown", null);
-    } catch {
-    }
-    this.#notify("exit", null);
-    this.#process.kill();
     this.#rejectAll(new Error("LSP connection disposed"));
+    this.#shutdownPromise = (async () => {
+      await terminateProcessTree3(this.#process.pid);
+      this.#process.stdin.destroy();
+      this.#process.stdout.destroy();
+      this.#process.stderr.destroy();
+    })();
+    return this.#shutdownPromise;
   }
   // -- JSON-RPC core -------------------------------------------------------
-  async #request(method, params) {
+  async #request(method, params, signal) {
     if (this.#disposed) throw new Error("LSP connection disposed");
+    if (this.#initError !== void 0) throw this.#initError;
+    signal?.throwIfAborted();
     const id = this.#nextId++;
     const request = { jsonrpc: "2.0", id, method, params };
-    const timeout = AbortSignal.timeout(LSP_REQUEST_TIMEOUT_MS);
-    const promise = new Promise((resolve43, reject) => {
-      this.#pending.set(id, { resolve: resolve43, reject });
-      timeout.addEventListener("abort", () => {
-        if (this.#pending.has(id)) {
-          this.#pending.delete(id);
-          reject(new Error(`LSP request "${method}" timed out after ${LSP_REQUEST_TIMEOUT_MS}ms`));
+    let timer;
+    let onAbort;
+    const promise = new Promise((resolve44, reject) => {
+      this.#pending.set(id, { resolve: resolve44, reject });
+      timer = setTimeout(() => reject(new Error(`LSP request "${method}" timed out after ${LSP_REQUEST_TIMEOUT_MS}ms`)), LSP_REQUEST_TIMEOUT_MS);
+      timer.unref();
+      onAbort = () => {
+        try {
+          this.#notify("$/cancelRequest", { id });
+        } catch {
         }
-      }, { once: true });
+        reject(signal?.reason);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
     });
-    this.#send(request);
-    return promise;
+    try {
+      this.#send(request);
+      return await promise;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+      if (onAbort !== void 0) signal?.removeEventListener("abort", onAbort);
+      this.#pending.delete(id);
+    }
   }
   #notify(method, params) {
     const notification = { jsonrpc: "2.0", method, params };
@@ -19707,6 +19814,7 @@ var LspConnection = class {
     } catch {
       return;
     }
+    if (typeof parsed !== "object" || parsed === null) return;
     if ("method" in parsed) {
       if ("id" in parsed) this.#handleServerRequest(parsed);
       return;
@@ -19742,7 +19850,7 @@ var LspConnection = class {
   async #syncDocumentNow(uri) {
     const url = new URL(uri);
     if (url.protocol !== "file:") return;
-    const filePath = fileURLToPath3(url);
+    const filePath = fileURLToPath2(url);
     const text = await readFile21(filePath, "utf8");
     const current = this.#documents.get(uri);
     if (current === void 0) {
@@ -19795,7 +19903,7 @@ var LspBuffer = class {
   }
 };
 var TYPESCRIPT_CLI = resolve26(
-  dirname20(fileURLToPath3(import.meta.resolve("typescript/package.json"))),
+  dirname18(fileURLToPath2(import.meta.resolve("typescript/package.json"))),
   "lib",
   "tsc.js"
 );
@@ -19830,6 +19938,8 @@ var KNOWN_SERVERS = [
   }
 ];
 var RealLspManager = class {
+  #disposed = false;
+  #disposal;
   #workspace;
   #connections = /* @__PURE__ */ new Map();
   #pendingStarts = /* @__PURE__ */ new Map();
@@ -19841,27 +19951,32 @@ var RealLspManager = class {
     this.#onStatus = options.onStatus;
   }
   dispose() {
-    for (const [, connection] of this.#connections) {
-      connection.shutdown().catch(() => {
-      });
-    }
+    if (this.#disposal !== void 0) return this.#disposal;
+    this.#disposed = true;
+    const shutdowns = [...this.#connections.values()].map((connection) => connection.shutdown());
+    shutdowns.push(...[...this.#pendingStarts.values()].map(async (start) => {
+      const connection = await start;
+      await connection.shutdown();
+    }));
     this.#connections.clear();
     this.#pendingStarts.clear();
+    this.#disposal = Promise.allSettled(shutdowns).then(() => void 0);
+    return this.#disposal;
   }
-  async findReferences(uri, line, character) {
-    const connection = await this.#getConnection(uri);
-    if (connection === void 0) return [];
-    return connection.findReferences(uri, line, character);
+  async findReferences(uri, line, character, signal) {
+    signal?.throwIfAborted();
+    const connection = await waitWithSignal(this.#getConnection(uri), signal);
+    return connection.findReferences(uri, line, character, signal);
   }
-  async hover(uri, line, character) {
-    const connection = await this.#getConnection(uri);
-    if (connection === void 0) return null;
-    return connection.hover(uri, line, character);
+  async hover(uri, line, character, signal) {
+    signal?.throwIfAborted();
+    const connection = await waitWithSignal(this.#getConnection(uri), signal);
+    return connection.hover(uri, line, character, signal);
   }
-  async diagnostics(uri) {
-    const connection = await this.#getConnection(uri);
-    if (connection === void 0) return [];
-    return connection.diagnostics(uri);
+  async diagnostics(uri, signal) {
+    signal?.throwIfAborted();
+    const connection = await waitWithSignal(this.#getConnection(uri), signal);
+    return connection.diagnostics(uri, signal);
   }
   #languageForUri(uri) {
     try {
@@ -19877,20 +19992,25 @@ var RealLspManager = class {
     return void 0;
   }
   async #getConnection(uri) {
+    if (this.#disposed) throw new Error("LSP manager is disposed");
     const language = this.#languageForUri(uri);
-    if (language === void 0) return void 0;
+    if (language === void 0) throw new Error(`No language server configured for ${uri}; use Read/Grep or the project compiler`);
     const existing = this.#connections.get(language);
     if (existing !== void 0) return existing;
     const pending2 = this.#pendingStarts.get(language);
     if (pending2 !== void 0) return pending2;
     const config = this.#serverConfigs.find((c) => c.language === language);
-    if (config === void 0) return void 0;
+    if (config === void 0) throw new Error(`No language server configured for ${language}`);
     const hasRoot = config.rootFiles.some((file) => existsSync5(resolve26(this.#workspace, file)));
-    if (!hasRoot) return void 0;
+    if (!hasRoot) throw new Error(`Cannot start ${language} language server: workspace needs ${config.rootFiles.join(" or ")}`);
     const startPromise = this.#startServer(config);
     this.#pendingStarts.set(language, startPromise);
     try {
       const connection = await startPromise;
+      if (this.#disposed) {
+        await connection.shutdown();
+        throw new Error("LSP manager is disposed");
+      }
       this.#connections.set(language, connection);
       return connection;
     } finally {
@@ -19908,6 +20028,7 @@ var RealLspManager = class {
       await connection.initialize(rootUri);
       this.#onStatus?.(`${config.language} Language Server ready (${config.command})`);
     } catch (error) {
+      await connection.shutdown();
       this.#onStatus?.(`${config.language} Language Server failed: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
@@ -19916,13 +20037,13 @@ var RealLspManager = class {
 };
 var LspFindRefsInput = z32.object({
   file: z32.string().min(1),
-  line: z32.coerce.number().int().nonnegative(),
-  character: z32.coerce.number().int().nonnegative()
+  line: z32.coerce.number().int().nonnegative().describe("Zero-based line number (first line is 0)."),
+  character: z32.coerce.number().int().nonnegative().describe("Zero-based UTF-16 character offset.")
 });
 var LspHoverInput = z32.object({
   file: z32.string().min(1),
-  line: z32.coerce.number().int().nonnegative(),
-  character: z32.coerce.number().int().nonnegative()
+  line: z32.coerce.number().int().nonnegative().describe("Zero-based line number (first line is 0)."),
+  character: z32.coerce.number().int().nonnegative().describe("Zero-based UTF-16 character offset.")
 });
 var LspDiagnosticsInput = z32.object({
   file: z32.string().min(1)
@@ -19948,10 +20069,11 @@ function createLspTools(workspace, options = {}) {
     inputSchema: LspFindRefsInput,
     paths: (input) => [guard(input.file)],
     summarize: (input) => `${basename7(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
-    execute: async (input, _signal) => {
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
       const path = guard(input.file);
       const uri = toUri(path);
-      const refs = await manager.findReferences(uri, input.line, input.character);
+      const refs = await waitWithSignal(manager.findReferences(uri, input.line, input.character, signal), signal);
       if (refs.length === 0) return `No references found at ${input.file}:${input.line}:${input.character}`;
       return refs.map((loc) => {
         const filePath = uriToPath(loc.uri);
@@ -19965,12 +20087,14 @@ function createLspTools(workspace, options = {}) {
     inputSchema: LspHoverInput,
     paths: (input) => [guard(input.file)],
     summarize: (input) => `${basename7(input.file)}:${input.line}:${input.character}${langTag(input.file)}`,
-    execute: async (input, _signal) => {
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
       const path = guard(input.file);
       const uri = toUri(path);
-      const info = await manager.hover(uri, input.line, input.character);
+      const info = await waitWithSignal(manager.hover(uri, input.line, input.character, signal), signal);
       if (info === null) return `No hover information at ${input.file}:${input.line}:${input.character}`;
-      const contents = typeof info.contents === "string" ? info.contents : info.contents.value;
+      const parts = Array.isArray(info.contents) ? info.contents : [info.contents];
+      const contents = parts.map((part) => typeof part === "string" ? part : part.value).join("\n\n");
       return contents;
     }
   };
@@ -19980,10 +20104,11 @@ function createLspTools(workspace, options = {}) {
     inputSchema: LspDiagnosticsInput,
     paths: (input) => [guard(input.file)],
     summarize: (input) => `${basename7(input.file)}${langTag(input.file)}`,
-    execute: async (input, _signal) => {
+    execute: async (input, signal) => {
+      signal.throwIfAborted();
       const path = guard(input.file);
       const uri = toUri(path);
-      const diags = await manager.diagnostics(uri);
+      const diags = await waitWithSignal(manager.diagnostics(uri, signal), signal);
       if (diags.length === 0) return `No diagnostics for ${input.file}`;
       return diags.map((d) => {
         const severity = severityLabel(d.severity);
@@ -20002,6 +20127,14 @@ function languageIdForPath(filePath) {
       return "typescript";
     case ".cts":
       return "typescript";
+    case ".py":
+    case ".pyi":
+    case ".pyx":
+      return "python";
+    case ".rs":
+      return "rust";
+    case ".go":
+      return "go";
     default:
       return "typescript";
   }
@@ -20013,7 +20146,7 @@ function isWithin7(root, candidate) {
 function uriToPath(uri) {
   try {
     const url = new URL(uri);
-    if (url.protocol === "file:") return decodeURIComponent(url.pathname);
+    if (url.protocol === "file:") return fileURLToPath2(url);
   } catch {
   }
   return uri;
@@ -20040,12 +20173,14 @@ function severityLabel(severity) {
 }
 
 // src/git/service.ts
-async function git2(workspace, args, timeoutMs = 3e4) {
-  const result = await execFileNoThrow("git", ["-C", workspace, ...args], { timeout: timeoutMs, useCwd: false });
+async function git2(workspace, args, timeoutMs = 3e4, signal) {
+  signal?.throwIfAborted();
+  const result = await execFileNoThrow("git", ["-C", workspace, ...args], { timeout: timeoutMs, useCwd: false, ...signal === void 0 ? {} : { signal } });
+  signal?.throwIfAborted();
   return { ok: result.code === 0, stdout: result.stdout, stderr: result.stderr, code: result.code };
 }
-async function isGitRepository(workspace) {
-  const result = await git2(workspace, ["rev-parse", "--is-inside-work-tree"], 2e3);
+async function isGitRepository(workspace, signal) {
+  const result = await git2(workspace, ["rev-parse", "--is-inside-work-tree"], 2e3, signal);
   return result.ok && result.stdout.trim() === "true";
 }
 function gitFailure(result, action) {
@@ -20123,16 +20258,21 @@ async function commit(workspace, commitMessage) {
   const head = await git2(workspace, ["log", "-1", "--pretty=%h %s"]);
   return head.stdout.trim() || "committed";
 }
-async function fileHistory(workspace, path, limit) {
+async function fileHistory(workspace, path, limit, signal) {
   const args = [
+    "--literal-pathspecs",
     "log",
     `--max-count=${limit}`,
     "--date=short",
     "--pretty=format:%h%x1f%ad%x1f%an%x1f%s",
     ...path === void 0 ? [] : ["--follow", "--", path]
   ];
-  const result = await git2(workspace, args, 15e3);
-  if (!result.ok) throw gitFailure(result, "log");
+  const result = await git2(workspace, args, 15e3, signal);
+  if (!result.ok) {
+    const head = await git2(workspace, ["rev-parse", "--verify", "HEAD"], 2e3, signal);
+    if (!head.ok && await isGitRepository(workspace, signal)) return [];
+    throw gitFailure(result, "log");
+  }
   return result.stdout.split("\n").filter((line) => line.trim().length > 0).map((line) => {
     const [hash = "", date = "", author = "", ...subject] = line.split("");
     return { hash, date, author, subject: subject.join("") };
@@ -20471,24 +20611,33 @@ function mapNode(value) {
 
 // src/git/tools.ts
 import { z as z34 } from "zod";
+import { isAbsolute as isAbsolute15, relative as relative19, resolve as resolve28, sep as sep19 } from "path";
 var GitHistoryInput = z34.object({
-  path: z34.string().describe("File to inspect; omit for the whole repository history").optional(),
-  limit: z34.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
+  path: z34.string().min(1).describe("Workspace-relative or absolute file path; omit for the whole repository history").optional(),
+  limit: z34.coerce.number().int().min(1).max(50).describe("Maximum number of commits to return (default 20)").optional()
 });
 function createGitHistoryTool(workspace) {
+  const root = resolve28(workspace);
+  const file = (path) => {
+    const absolute = resolve28(root, path);
+    const delta = relative19(root, absolute);
+    if (delta === ".." || delta.startsWith(`..${sep19}`) || isAbsolute15(delta)) throw new Error("GitHistory path is outside the workspace");
+    return absolute;
+  };
   return {
     name: "GitHistory",
     description: "Show git commit history for the repository or for one file (follows renames). Use to understand when and why code changed.",
     inputSchema: GitHistoryInput,
     readOnly: true,
-    paths: (input) => input.path === void 0 ? [] : [input.path],
+    paths: (input) => input.path === void 0 ? [root] : [file(input.path)],
     summarize: (input) => input.path ?? "repository",
     renderForModel: (output) => output,
     async execute(input, signal) {
       signal.throwIfAborted();
-      if (!await isGitRepository(workspace)) throw new Error("Not a git repository");
+      const path = input.path === void 0 ? void 0 : relative19(root, file(input.path));
+      if (!await isGitRepository(root, signal)) throw new Error("Not a git repository");
       const limit = input.limit ?? 20;
-      const entries = await fileHistory(workspace, input.path, limit);
+      const entries = await fileHistory(root, path, limit, signal);
       if (entries.length === 0) {
         return input.path === void 0 ? "No commits found." : `No commits found for ${input.path} (the file may be untracked).`;
       }
@@ -20551,7 +20700,8 @@ var QuestionBridge = class {
   }
   async #askRelayed(questions, signal) {
     try {
-      const answers = await this.#relay(questions, signal);
+      const answers = await waitWithSignal(this.#relay(questions, signal), signal);
+      signal.throwIfAborted();
       if (answers !== void 0) {
         this.#active = false;
         return answers;
@@ -20563,10 +20713,15 @@ var QuestionBridge = class {
     }
   }
   #askLocally(questions, signal) {
-    return new Promise((resolve43, reject) => {
+    if (signal.aborted) {
+      this.#active = false;
+      return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve44, reject) => {
       const onAbort = () => {
         this.#pending = void 0;
         this.#active = false;
+        this.#onChange?.();
         reject(signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason)));
       };
       signal.addEventListener("abort", onAbort, { once: true });
@@ -20577,7 +20732,7 @@ var QuestionBridge = class {
           this.#pending = void 0;
           this.#active = false;
           this.#onChange?.();
-          resolve43(answers);
+          resolve44(answers);
         },
         reject: (error) => {
           signal.removeEventListener("abort", onAbort);
@@ -20670,7 +20825,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 join30, resolve as resolve28 } from "path";
+import { dirname as dirname19, join as join30, resolve as resolve29 } from "path";
 import { z as z37 } from "zod";
 var MANAGED_TOOL_VERSION = 1;
 var MAX_RECORD_BYTES = 256 * 1024;
@@ -20712,9 +20867,9 @@ var ManagedToolStore = class {
   #entries = /* @__PURE__ */ new Map();
   #diagnostics = [];
   constructor(options) {
-    this.#workspace = resolve28(options.workspace);
+    this.#workspace = resolve29(options.workspace);
     this.#projectRoot = join30(this.#workspace, ".flavor", "tools");
-    this.#globalRoot = join30(resolve28(options.home), ".flavor-code", "tools");
+    this.#globalRoot = join30(resolve29(options.home), ".flavor-code", "tools");
     this.#now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   }
   get diagnostics() {
@@ -20954,7 +21109,7 @@ ${sourceUrl}`
   }
 }
 async function writeExclusive(path, content) {
-  await mkdir20(dirname21(path), { recursive: true });
+  await mkdir20(dirname19(path), { recursive: true });
   const temporary = `${path}.${randomUUID18()}.tmp`;
   try {
     await writeFile12(temporary, content, { encoding: "utf8", flag: "wx", mode: 384 });
@@ -22268,9 +22423,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((resolve43) => {
+    return new Promise((resolve44) => {
       const check2 = () => {
-        if (!this.#activePlanning.has(key)) resolve43();
+        if (!this.#activePlanning.has(key)) resolve44();
         else this.#planningIdleWaiters.add(check2);
       };
       this.#planningIdleWaiters.add(check2);
@@ -22381,7 +22536,7 @@ function requiredPals(service) {
 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 { isAbsolute as isAbsolute16, join as join31, relative as relative20, resolve as resolve30, sep as sep20 } from "path";
 import { rgPath as bundledRgPath2 } from "@vscode/ripgrep";
 
 // src/utils/semver.ts
@@ -22398,8 +22553,8 @@ 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);
+  const timeout = new Promise((resolve44) => {
+    timer = setTimeout(() => resolve44(void 0), timeoutMs);
     timer.unref?.();
   });
   try {
@@ -22419,8 +22574,8 @@ async function fetchLatestVersion(options = {}) {
 
 // src/doctor.ts
 async function runDoctor(options = {}, dependencies2 = {}) {
-  const workspace = resolve29(options.workspace ?? process.cwd());
-  const home = resolve29(options.home ?? homedir());
+  const workspace = resolve30(options.workspace ?? process.cwd());
+  const home = resolve30(options.home ?? homedir());
   const environment = options.environment ?? process.env;
   const platform = options.platform ?? process.platform;
   const arch = options.arch ?? process.arch;
@@ -22568,14 +22723,14 @@ async function pluginCheck(directories) {
     }
     for (const entry2 of entries) {
       if (!entry2.isDirectory() || entry2.name.startsWith(".")) continue;
-      const root = resolve29(directory, entry2.name);
+      const root = resolve30(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 main = resolve30(root, manifest.main);
+        const delta = relative20(root, main);
+        if (delta === ".." || delta.startsWith(`..${sep20}`) || isAbsolute16(delta)) throw new Error("plugin entry escapes its root");
         const mainInfo = await lstat12(main);
         if (!mainInfo.isFile() || mainInfo.isSymbolicLink()) throw new Error("plugin entry must be a regular file");
         valid += 1;
@@ -22639,7 +22794,7 @@ var LANG_LABELS = /* @__PURE__ */ new Map([
 ]);
 
 // src/utils/crash-guard.ts
-import { mkdirSync as mkdirSync3, writeFileSync } from "fs";
+import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
 import { join as join32 } from "path";
 var installed = false;
 var crashing = false;
@@ -22679,7 +22834,7 @@ function installCrashGuard(options = {}) {
   const writeCrashLog = (kind, detail) => {
     try {
       const dir = crashLogDir();
-      mkdirSync3(dir, { recursive: true });
+      mkdirSync2(dir, { recursive: true });
       const path = join32(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
       writeFileSync(path, [
         `kind: ${kind}`,
@@ -23452,7 +23607,7 @@ ${total}`;
 // src/memory/store.ts
 import { createHash as createHash17 } from "crypto";
 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";
+import { resolve as resolve31, join as join33, relative as relative21, sep as sep21 } from "path";
 
 // src/memory/similarity.ts
 function normalizeForSimilarity(value) {
@@ -23554,7 +23709,7 @@ 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 = resolve30(options.workspace);
+    this.workspace = resolve31(options.workspace);
     this.#memoryRoot = join33(this.workspace, ".flavor", "memory");
     this.path = join33(this.#memoryRoot, "MEMORY.md");
     this.#behaviorPath = join33(this.#memoryRoot, "behavior.json");
@@ -23780,9 +23935,9 @@ var MemoryStore = class {
   }
   #resolveContentPath(contentPath) {
     if (!/^tasks\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\.md$/.test(contentPath)) throw new Error("Invalid memory content path");
-    const path = 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");
+    const path = resolve31(this.#memoryRoot, ...contentPath.split("/"));
+    const rel = relative21(this.#memoryRoot, path);
+    if (rel === ".." || rel.startsWith(`..${sep21}`)) throw new Error("Memory content path escapes the memory directory");
     return path;
   }
   async #updateIndex(update) {
@@ -24239,14 +24394,14 @@ var MemoryReviewBridge = class {
 };
 
 // src/execution/docker.ts
-import { spawn as spawn6 } from "child_process";
-import { relative as relative21, resolve as resolve31, sep as sep21, win32 } from "path";
+import { spawn as spawn7 } from "child_process";
+import { relative as relative22, resolve as resolve32, sep as sep22, 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) : relative21(resolve31(workspace), resolve31(cwd));
-  if (delta === ".." || delta.startsWith(`..${windows ? "\\" : sep21}`)) throw new Error("Docker cwd escapes workspace");
+  const delta = windows ? win32.relative(workspace, cwd) : relative22(resolve32(workspace), resolve32(cwd));
+  if (delta === ".." || delta.startsWith(`..${windows ? "\\" : sep22}`)) throw new Error("Docker cwd escapes workspace");
   const containerCwd = delta.length === 0 ? "/workspace" : `/workspace/${delta.replaceAll("\\", "/")}`;
   const args = [
     "run",
@@ -24298,7 +24453,7 @@ function runDockerInvocation(invocation, signal, timeoutMs, maxOutputBytes = DEF
       resolvePromise({ exitCode: null, signal: null, stdout: "", stderr: "", terminationReason: "cancelled" });
       return;
     }
-    const child = spawn6(invocation.command, invocation.args, { windowsHide: true, shell: false });
+    const child = spawn7(invocation.command, invocation.args, { windowsHide: true, shell: false });
     const stdout = new BoundedUtf8Output(maxOutputBytes);
     const stderr = new BoundedUtf8Output(maxOutputBytes);
     let reason = null;
@@ -24416,7 +24571,7 @@ function createExecutionEnvironment(workspace, config) {
 
 // src/ide/client.ts
 import { readFile as readFile25, readdir as readdir11, stat as stat12 } from "fs/promises";
-import { basename as basename8, join as join34, relative as relative22, resolve as resolve32, sep as sep22 } from "path";
+import { basename as basename8, join as join34, relative as relative23, resolve as resolve33, sep as sep23 } from "path";
 var FlavorIdeClient = class {
   #workspace;
   #home;
@@ -24427,8 +24582,8 @@ var FlavorIdeClient = class {
   #sessionId;
   #eventTail = Promise.resolve();
   constructor(options) {
-    this.#workspace = resolve32(options.workspace);
-    this.#home = resolve32(options.home);
+    this.#workspace = resolve33(options.workspace);
+    this.#home = resolve33(options.home);
     this.#environment = options.environment ?? process.env;
     this.#fetch = options.fetch ?? fetch;
   }
@@ -24626,16 +24781,16 @@ function parsePort(value) {
   return Number.isInteger(port2) && port2 > 0 && port2 <= 65535 ? port2 : void 0;
 }
 function isWithin8(parent, child) {
-  const base = normalize(resolve32(parent));
-  const target = normalize(resolve32(child));
-  return target === base || target.startsWith(`${base}${sep22}`);
+  const base = normalize(resolve33(parent));
+  const target = normalize(resolve33(child));
+  return target === base || target.startsWith(`${base}${sep23}`);
 }
 function normalize(path) {
   const normalized = path.normalize("NFC");
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function relativeDisplay(workspace, filePath) {
-  const path = relative22(workspace, filePath).replaceAll("\\", "/");
+  const path = relative23(workspace, filePath).replaceAll("\\", "/");
   return path && !path.startsWith("../") ? path : basename8(filePath);
 }
 
@@ -24654,11 +24809,12 @@ var JobRegistry = class {
   }
   create(input) {
     this.#pruneCompleted();
+    if (this.#jobs.size >= this.#maxJobs) throw new Error(`Background job limit (${this.#maxJobs}) reached; wait for or cancel an existing job first`);
     const id = `job-${randomUUID19().slice(0, 12)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let settle;
-    const done = new Promise((resolve43) => {
-      settle = resolve43;
+    const done = new Promise((resolve44) => {
+      settle = resolve44;
     });
     const record3 = {
       id,
@@ -24692,7 +24848,7 @@ var JobRegistry = class {
       },
       complete: (result = {}) => this.#finish(
         record3,
-        result.exitCode !== void 0 && result.exitCode !== null && result.exitCode !== 0 ? "failed" : "completed",
+        result.error !== void 0 || result.exitCode !== void 0 && result.exitCode !== null && result.exitCode !== 0 ? "failed" : "completed",
         result
       ),
       fail: (error) => this.#finish(record3, "failed", { error: error instanceof Error ? error.message : String(error) }),
@@ -24708,21 +24864,24 @@ var JobRegistry = class {
     return { ...snapshot2(job), output: job.output.slice(effective - job.outputStart), cursor: job.outputStart + job.output.length };
   }
   async wait(id, owner2, signal) {
+    signal?.throwIfAborted();
     const job = this.#owned(id, owner2);
     if (job.state !== "running") return snapshot2(job);
-    if (signal === void 0) return job.done;
-    return Promise.race([job.done, new Promise((_resolve, reject) => {
-      if (signal.aborted) {
-        reject(signal.reason);
-        return;
-      }
-      signal.addEventListener("abort", () => reject(signal.reason), { once: true });
-    })]);
+    return waitWithSignal(job.done, signal);
   }
   kill(id, owner2) {
     const job = this.#owned(id, owner2);
     if (job.state !== "running") return;
-    void job.cancel?.();
+    try {
+      const cancellation = job.cancel?.();
+      if (cancellation !== void 0) return cancellation.then(
+        () => this.#finish(job, "cancelled", {}),
+        (error) => this.#finish(job, "failed", { error: `Cancellation failed: ${error instanceof Error ? error.message : String(error)}` })
+      );
+    } catch (error) {
+      this.#finish(job, "failed", { error: `Cancellation failed: ${error instanceof Error ? error.message : String(error)}` });
+      return;
+    }
     this.#finish(job, "cancelled", {});
   }
   subscribe(listener) {
@@ -24782,7 +24941,7 @@ function snapshot2(job) {
 // src/terminal/service.ts
 import { randomUUID as randomUUID20 } from "crypto";
 import { createRequire as nodeCreateRequire2 } from "module";
-import { isAbsolute as isAbsolute16, relative as relative23, resolve as resolve33, sep as sep23 } from "path";
+import { isAbsolute as isAbsolute17, relative as relative24, resolve as resolve34, sep as sep24 } from "path";
 var TerminalService = class {
   #root;
   #factory;
@@ -24790,10 +24949,11 @@ var TerminalService = class {
   #maxOutputChars;
   #sessions = /* @__PURE__ */ new Map();
   constructor(workspace, options = {}) {
-    this.#root = resolve33(workspace);
+    this.#root = resolve34(workspace);
     this.#factory = options.factory ?? defaultFactory;
     this.#jobs = options.jobs;
     this.#maxOutputChars = options.maxOutputChars ?? 2e5;
+    if (!Number.isSafeInteger(this.#maxOutputChars) || this.#maxOutputChars <= 0) throw new Error("maxOutputChars must be a positive integer");
   }
   open(input) {
     const cwd = workspacePath(this.#root, input.cwd ?? ".");
@@ -24820,7 +24980,13 @@ var TerminalService = class {
       truncated: false,
       disposables: []
     };
-    const job = this.#jobs?.create({ kind: "terminal", owner: input.owner, label: shell2, cancel: () => this.close(id, input.owner) });
+    let job;
+    try {
+      job = this.#jobs?.create({ kind: "terminal", owner: input.owner, label: shell2, cancel: () => this.close(id, input.owner) });
+    } catch (error) {
+      pty.kill();
+      throw error;
+    }
     if (job !== void 0) {
       jobId = job.id;
       record3.jobId = job.id;
@@ -24846,10 +25012,10 @@ var TerminalService = class {
     return { ...snapshot3(record3), ...jobId === void 0 ? {} : { jobId } };
   }
   write(id, owner2, data2) {
-    this.#owned(id, owner2).pty.write(data2);
+    this.#running(id, owner2).pty.write(data2);
   }
   resize(id, owner2, columns, rows) {
-    this.#owned(id, owner2).pty.resize(columns, rows);
+    this.#running(id, owner2).pty.resize(columns, rows);
   }
   read(id, owner2, cursor = 0) {
     const record3 = this.#owned(id, owner2);
@@ -24880,6 +25046,11 @@ var TerminalService = class {
     if (record3.owner !== owner2) throw new Error("Terminal owner mismatch");
     return record3;
   }
+  #running(id, owner2) {
+    const record3 = this.#owned(id, owner2);
+    if (record3.state !== "running") throw new Error(`Terminal ${id} is ${record3.state}; use TerminalOpen to start a new session`);
+    return record3;
+  }
 };
 function snapshot3(record3) {
   return {
@@ -24908,15 +25079,15 @@ function cleanEnvironment(environment) {
   return Object.fromEntries(Object.entries(environment).filter((entry2) => entry2[1] !== void 0));
 }
 function workspacePath(root, input) {
-  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");
+  const path = resolve34(root, input);
+  const delta = relative24(root, path);
+  if (delta === ".." || delta.startsWith(`..${sep24}`) || isAbsolute17(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 resolve34 } from "path";
+import { resolve as resolve35 } 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")]);
@@ -24930,8 +25101,8 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       name: "TerminalOpen",
       description: "Open a persistent interactive pseudo-terminal in the workspace",
       inputSchema: OpenInput,
-      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 ?? ".") }),
+      paths: (input) => [resolve35(workspace, input.cwd ?? ".")],
+      permissions: (input) => ({ paths: [resolve35(workspace, input.cwd ?? ".")], command: input.shell ?? "system-shell", args: input.args ?? [], cwd: resolve35(workspace, input.cwd ?? ".") }),
       execute: async (input, _signal, context) => terminals.open({
         owner: owner(context),
         ...input.cwd === void 0 ? {} : { cwd: input.cwd },
@@ -24960,7 +25131,7 @@ function createTerminalTools(terminals, workspace = process.cwd()) {
       inputSchema: ReadInput3,
       paths: () => [],
       execute: async (input, _signal, context) => terminals.read(input.id, owner(context), input.cursor ?? 0),
-      renderForModel: (output) => output.output,
+      renderForModel: (output) => JSON.stringify(output),
       presentResult: (output) => {
         const result = output;
         return {
@@ -25028,13 +25199,13 @@ import { createHash as createHash20 } from "crypto";
 import { Socket as Socket2 } from "net";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join36 } from "path";
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 
 // src/pals/broker.ts
 import { createHash as createHash19, randomUUID as randomUUID23, timingSafeEqual } from "crypto";
 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";
+import { dirname as dirname21 } from "path";
 
 // src/pals/auth.ts
 import { randomBytes as randomBytes3, randomUUID as randomUUID21 } from "crypto";
@@ -25085,7 +25256,7 @@ function validatePalAuthToken(token) {
 // src/pals/lifecycle.ts
 import { randomUUID as randomUUID22 } from "crypto";
 import { mkdir as mkdir22, open as open13, readFile as readFile27, rename as rename11, stat as stat13, unlink as unlink5 } from "fs/promises";
-import { dirname as dirname22 } from "path";
+import { dirname as dirname20 } from "path";
 function defaultProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return true;
   try {
@@ -25106,7 +25277,7 @@ function parseMetadata(value) {
 }
 async function acquirePalFileLock(options) {
   if (await options.endpointLive()) return void 0;
-  await mkdir22(dirname22(options.path), { recursive: true, mode: 448 });
+  await mkdir22(dirname20(options.path), { recursive: true, mode: 448 });
   const pid = options.pid ?? process.pid;
   const now = options.now ?? Date.now;
   const nonce = randomUUID22();
@@ -25161,16 +25332,16 @@ async function acquirePalFileLock(options) {
 
 // src/pals/broker-cli.ts
 var startupAttempts = /* @__PURE__ */ new Map();
-function delay3(milliseconds) {
-  return new Promise((resolve43) => setTimeout(resolve43, milliseconds));
+function delay2(milliseconds) {
+  return new Promise((resolve44) => setTimeout(resolve44, milliseconds));
 }
 function canConnect(address) {
-  return new Promise((resolve43) => {
+  return new Promise((resolve44) => {
     const socket = new Socket2();
     const finish = (connected) => {
       socket.removeAllListeners();
       socket.destroy();
-      resolve43(connected);
+      resolve44(connected);
     };
     socket.once("connect", () => finish(true));
     socket.once("error", () => finish(false));
@@ -25193,7 +25364,7 @@ async function spawnPalBrokerProcess(options) {
   const lock = await acquirePalFileLock({ path: lockPath, endpointLive: () => canConnect(address) });
   if (lock === void 0) return;
   try {
-    const child = spawn7(options.executable, [...options.args], {
+    const child = spawn8(options.executable, [...options.args], {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
@@ -25201,7 +25372,7 @@ async function spawnPalBrokerProcess(options) {
     });
     child.unref();
     const deadline = Date.now() + 5e3;
-    while (Date.now() < deadline && !await canConnect(address)) await delay3(25);
+    while (Date.now() < deadline && !await canConnect(address)) await delay2(25);
     if (!await canConnect(address)) throw new Error(`Pals broker process did not become ready at '${address}'`);
   } finally {
     await lock.release();
@@ -25222,7 +25393,7 @@ async function ensureOnce(options) {
   const deadline = Date.now() + timeoutMs;
   do {
     if (await canConnect(options.address)) return;
-    await delay3(retryDelayMs);
+    await delay2(retryDelayMs);
   } while (Date.now() < deadline);
   throw new Error(`Timed out waiting for pals broker at '${options.address}'`);
 }
@@ -25361,8 +25532,8 @@ var PalClient = class {
       let disconnectTimer;
       await Promise.race([
         this.request({ version: 1, type: "disconnect", requestId: randomUUID24() }).catch(() => void 0),
-        new Promise((resolve43) => {
-          disconnectTimer = setTimeout(resolve43, Math.min(this.requestTimeoutMs, 250));
+        new Promise((resolve44) => {
+          disconnectTimer = setTimeout(resolve44, Math.min(this.requestTimeoutMs, 250));
         })
       ]);
       if (disconnectTimer !== void 0) clearTimeout(disconnectTimer);
@@ -25408,7 +25579,7 @@ var PalClient = class {
     return presence;
   }
   openSocket() {
-    return new Promise((resolve43, reject) => {
+    return new Promise((resolve44, reject) => {
       let settled = false;
       const rejectConnection = (error) => {
         if (settled) return;
@@ -25431,7 +25602,7 @@ var PalClient = class {
         settled = true;
         if (this.connectingReject === rejectConnection) this.connectingReject = void 0;
         socket.off("error", onInitialError);
-        resolve43();
+        resolve44();
       };
       const onInitialError = (error) => {
         socket.off("connect", onConnect);
@@ -25462,12 +25633,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((resolve43, reject) => {
+    return new Promise((resolve44, 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: resolve43, reject, timer });
+      this.pending.set(request.requestId, { resolve: resolve44, reject, timer });
       let frame;
       try {
         frame = encodeControlFrame(BrokerRequestSchema.parse(request));
@@ -25571,12 +25742,12 @@ var PalClient = class {
   }
   scheduleReconnect() {
     if (this.reconnectTimer !== void 0 || this.closed) return;
-    const delay4 = this.reconnectDelayMs;
+    const delay3 = this.reconnectDelayMs;
     this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, this.reconnectMaxDelayMs);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = void 0;
       void this.start().catch(() => this.scheduleReconnect());
-    }, delay4);
+    }, delay3);
     this.reconnectTimer.unref?.();
   }
 };
@@ -25678,6 +25849,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const recipientId = await assertSendTarget(client, input.target, input.coWorkId);
+        signal.throwIfAborted();
         return client.sendChat(recipientId, shareGuard.protect(input.message));
       }
     },
@@ -25701,6 +25873,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         assertRequiredParticipant(await client.coWorkStatus(input.plan.coWorkId), options.selfId);
+        signal.throwIfAborted();
         const plan = CoWorkPlanSchema.parse({
           ...input.plan,
           goal: shareGuard.protect(input.plan.goal),
@@ -25717,11 +25890,13 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         let state = await assertCurrentToken(client, input);
+        signal.throwIfAborted();
         assertRequiredParticipant(state, options.selfId);
         if (!state.planAcceptedParticipantIds.includes(options.selfId)) {
           state = await client.coWorkAction({ type: "cowork-plan-accept", ...input });
         }
         if (state.readyParticipantIds.includes(options.selfId) || state.phase === "running") return state;
+        signal.throwIfAborted();
         return client.coWorkAction({ type: "cowork-ready", ...input });
       }
     },
@@ -25735,6 +25910,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const recipientId = await assertSendTarget(client, input.target, input.coWorkId);
+        signal.throwIfAborted();
         return client.sendChat(recipientId, `[co-work ${input.coWorkId} progress] ${shareGuard.protect(input.detail)}`);
       }
     },
@@ -25748,6 +25924,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const state = await assertCurrentToken(client, input);
+        signal.throwIfAborted();
         assertRequiredParticipant(state, options.selfId);
         if (state.phase !== "running" || !state.acceptedParticipantIds.includes(options.selfId) || !state.readyParticipantIds.includes(options.selfId)) {
           throw new Error("A required participant must be accepted, ready, and running before reporting completion");
@@ -25765,6 +25942,7 @@ function createPalsTools(client, options) {
       execute: async (input, signal) => {
         signal.throwIfAborted();
         const state = await assertCurrentToken(client, input);
+        signal.throwIfAborted();
         assertRequiredParticipant(state, options.selfId);
         if (state.integrationOwnerId !== options.selfId) throw new Error("Only the broker-designated integration owner can finalize integration");
         if (state.phase !== "verifying") throw new Error("Co-work is not ready for integration verification");
@@ -25871,8 +26049,8 @@ var ApprovalBridge = class {
   }
 };
 async function createProductionRuntime(options) {
-  const workspace = resolve35(options.workspace ?? process.cwd());
-  const home = resolve35(options.home ?? homedir3());
+  const workspace = resolve36(options.workspace ?? process.cwd());
+  const home = resolve36(options.home ?? homedir3());
   const environment = options.environment ?? process.env;
   const ide = new FlavorIdeClient({ workspace, home, environment });
   const ideReady = ide.initialize();
@@ -26046,6 +26224,7 @@ async function createProductionRuntime(options) {
   const executionEnvironment = createExecutionEnvironment(workspace, config.execution);
   const jobs = new JobRegistry();
   const terminals = new TerminalService(workspace, { jobs });
+  const lspManager = new RealLspManager({ workspace, onStatus: (message2) => emitOutput({ type: "notice", message: message2 }) });
   const observations = new FileObservationStore();
   const workspaceInstructions = new WorkspaceInstructions(workspace);
   const fileMutationOptions = {
@@ -26069,9 +26248,7 @@ async function createProductionRuntime(options) {
     createWebSearchTool(),
     ...createJobTools(jobs),
     ...createTerminalTools(terminals, workspace),
-    ...createLspTools(workspace, {
-      onStatus: (message2) => emitOutput({ type: "notice", message: message2 })
-    }),
+    ...createLspTools(workspace, { manager: lspManager }),
     ...options.approvalPolicy === "deny" ? [] : [createAskUserQuestionTool(askUserQuestionHandler)],
     createTaskOutputTool(),
     createTodoWriteTool()
@@ -26608,6 +26785,8 @@ async function createProductionRuntime(options) {
       permissionPolicy,
       maxIterationsMain: config.maxIterations.main,
       maxIterationsSubagent: config.maxIterations.subagent,
+      softLimitFactor: config.maxIterations.softLimitFactor,
+      extendIterations: config.maxIterations.extendBy,
       hasActiveProgress,
       afterToolSuccess: async (_tool, paths, _input, _output, context) => workspaceInstructions.discover(paths, context.ownerId ?? context.agent),
       toolJournal: {
@@ -26999,6 +27178,8 @@ async function createProductionRuntime(options) {
         permissionPolicy,
         maxIterationsMain: config.maxIterations.main,
         maxIterationsSubagent: config.maxIterations.subagent,
+        softLimitFactor: config.maxIterations.softLimitFactor,
+        extendIterations: config.maxIterations.extendBy,
         loopMode: true,
         afterToolSuccess: async (_tool, paths, _input, _output, context) => loopInstructions.discover(paths, context.ownerId ?? context.agent),
         toolJournal: {
@@ -27288,9 +27469,9 @@ async function createProductionRuntime(options) {
       explain: (query, focus, signal, onText) => runExplain({
         graph: new DesktopAstGraphService(workspace),
         readFile: async (path) => {
-          const root = resolve35(workspace);
-          const abs = resolve35(root, path);
-          if (abs !== root && !abs.startsWith(root + sep24)) throw new Error(`path outside workspace: ${path}`);
+          const root = resolve36(workspace);
+          const abs = resolve36(root, path);
+          if (abs !== root && !abs.startsWith(root + sep25)) throw new Error(`path outside workspace: ${path}`);
           return readFile28(abs, "utf8");
         },
         history: async (path, limit) => fileHistory(workspace, path, limit),
@@ -27642,6 +27823,7 @@ ${renderMemoryDocument(entries)}`;
         if (executionEnvironment !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "execution-environment", executionEnvironment.dispose());
         if (islandControlServer !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "island-control", islandControlServer.close());
         terminals.dispose();
+        await boundedStep(stepTimeoutMs, diagnostics, "language-servers", lspManager.dispose());
         await boundedStep(stepTimeoutMs, diagnostics, "jobs", jobs.dispose());
         auditLogger.close();
         evolveService.dispose();
@@ -27682,6 +27864,7 @@ ${renderMemoryDocument(entries)}`;
       if (sleepScheduler !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "sleep-scheduler", sleepScheduler.dispose());
       if (executionEnvironment !== void 0) await boundedStep(stepTimeoutMs, diagnostics, "execution-environment", executionEnvironment.dispose());
       terminals.dispose();
+      await boundedStep(stepTimeoutMs, diagnostics, "language-servers", lspManager.dispose());
       await boundedStep(stepTimeoutMs, diagnostics, "jobs", jobs.dispose());
       unsubscribeCollaboration?.();
       pendingCollaborationEvents.length = 0;
@@ -27835,9 +28018,9 @@ 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 = resolve35(workspace, name);
-    const relativePath = relative24(resolve35(workspace), path);
-    if (relativePath === ".." || relativePath.startsWith(`..${sep24}`)) continue;
+    const path = resolve36(workspace, name);
+    const relativePath = relative25(resolve36(workspace), path);
+    if (relativePath === ".." || relativePath.startsWith(`..${sep25}`)) continue;
     hash.update(name);
     if (remaining <= 0) continue;
     try {
@@ -27969,7 +28152,7 @@ function requestMemoryRestart(workspace, sessionId, emitOutput) {
       previous = parseMemoryRestartMarker(readFileSync3(markerPath, "utf8"));
     } catch {
     }
-    mkdirSync4(dirname24(markerPath), { recursive: true });
+    mkdirSync3(dirname22(markerPath), { recursive: true });
     writeFileSync2(markerPath, `${JSON.stringify(nextMemoryRestartMarker(previous, sessionId, /* @__PURE__ */ new Date()))}
 `, "utf8");
   } catch {
@@ -28504,7 +28687,7 @@ function createMemoryTaskId() {
 import { createHash as createHash27 } from "crypto";
 import { mkdir as mkdir27, readFile as readFile36, readdir as readdir13, rm as rm15, stat as stat16, writeFile as writeFile17 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename10, join as join47, resolve as resolve38 } from "path";
+import { basename as basename10, join as join47, resolve as resolve39 } from "path";
 
 // src/d2c/workflow.ts
 import { createHash as createHash22 } from "crypto";
@@ -29032,7 +29215,7 @@ function confirmApiMapping(mapping, operationKey, operations) {
 
 // src/d2c/modules.ts
 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 { isAbsolute as isAbsolute18, join as join39, normalize as normalize2, posix, sep as sep26, win32 as win322 } from "path";
 import { z as z43 } from "zod";
 var ModuleSchema = z43.object({
   id: z43.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/),
@@ -29044,10 +29227,10 @@ 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 (isAbsolute17(path) || posix.isAbsolute(path) || win322.isAbsolute(path) || path.includes("\0")) return false;
+  if (isAbsolute18(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(`..${sep25}`) && !portableSegments.includes("..");
+  return value !== ".." && !value.startsWith(`..${sep26}`) && !portableSegments.includes("..");
 }
 function d2cOutputDirectory(workspace, task) {
   if (!D2C_TASK_PATTERN.test(task)) throw new Error(`Invalid D2C task: ${task}`);
@@ -29270,7 +29453,7 @@ http.interceptors.response.use((response) => response, (error) => Promise.reject
 }
 
 // src/d2c/mock-runner.ts
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn9 } from "child_process";
 import { access as access4, readFile as readFile31 } from "fs/promises";
 import { createServer as createServer5 } from "net";
 import { join as join41 } from "path";
@@ -29293,7 +29476,7 @@ async function port() {
     });
   });
 }
-function waitForProcess2(child, timeoutMs, label) {
+function waitForProcess(child, timeoutMs, label) {
   return new Promise((resolvePromise, rejectPromise) => {
     const timer = setTimeout(() => {
       void terminateProcessTree(child, true);
@@ -29323,7 +29506,7 @@ async function install(projectDir, signal) {
         if (key.toLowerCase() === "npm_config_allow_scripts") delete env[key];
       }
     }
-    const child = spawn8(command, args, { cwd: projectDir, env, shell: false, windowsHide: true });
+    const child = spawn9(command, args, { cwd: projectDir, env, shell: false, windowsHide: true });
     let output = "";
     const append = (chunk) => {
       output = (output + chunk.toString("utf8")).slice(-8e3);
@@ -29335,7 +29518,7 @@ async function install(projectDir, signal) {
     };
     signal?.addEventListener("abort", abort2, { once: true });
     try {
-      await waitForProcess2(child, 18e4, "D2C mock dependency install");
+      await waitForProcess(child, 18e4, "D2C mock dependency install");
       return output;
     } catch (error) {
       throw new Error(`${error instanceof Error ? error.message : String(error)}${output.trim() ? `
@@ -29355,7 +29538,7 @@ ${output.trim()}` : ""}`);
 async function installPython(serverDir, signal) {
   signal?.throwIfAborted();
   const executable = process.env.FLAVOR_PYTHON?.trim() || (process.platform === "win32" ? "python" : "python3");
-  const child = spawn8(executable, ["-m", "pip", "install", "-r", "requirements.txt"], {
+  const child = spawn9(executable, ["-m", "pip", "install", "-r", "requirements.txt"], {
     cwd: serverDir,
     env: process.env,
     shell: false,
@@ -29372,7 +29555,7 @@ async function installPython(serverDir, signal) {
   };
   signal?.addEventListener("abort", abort2, { once: true });
   try {
-    await waitForProcess2(child, 18e4, "E2E backend dependency install");
+    await waitForProcess(child, 18e4, "E2E backend dependency install");
   } catch (error) {
     throw new Error(`${error instanceof Error ? error.message : String(error)}${output.trim() ? `
 ${output.trim()}` : ""}`);
@@ -29386,7 +29569,7 @@ async function runPythonBackend(projectDir, options) {
   const selectedPort = await port();
   const url = `http://127.0.0.1:${selectedPort}`;
   const executable = process.env.FLAVOR_PYTHON?.trim() || (process.platform === "win32" ? "python" : "python3");
-  const child = spawn8(executable, ["-m", "uvicorn", "main:app", "--host", "127.0.0.1", "--port", String(selectedPort)], {
+  const child = spawn9(executable, ["-m", "uvicorn", "main:app", "--host", "127.0.0.1", "--port", String(selectedPort)], {
     cwd: serverDir,
     windowsHide: true,
     shell: false,
@@ -29446,7 +29629,7 @@ async function runD2cMockServer(projectDir, options = {}) {
   if (options.installDependencies !== false) await install(projectDir, options.signal);
   const selectedPort = await port();
   const url = `http://127.0.0.1:${selectedPort}`;
-  const child = spawn8(process.execPath, [serverPath], {
+  const child = spawn9(process.execPath, [serverPath], {
     cwd: projectDir,
     windowsHide: true,
     env: { ...process.env, D2C_MOCK_PORT: String(selectedPort), ELECTRON_RUN_AS_NODE: "1" }
@@ -30189,14 +30372,14 @@ async function updateDeliveryRun(workspace, task, expectedRevision, mutation) {
 // src/skills/manager.ts
 import { lstat as lstat14, mkdir as mkdir26, readFile as readFile35, readdir as readdir12, realpath as realpath13, rm as rm14, writeFile as writeFile16 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { isAbsolute as isAbsolute18, join as join44, relative as relative25, resolve as resolve36, sep as sep26 } from "path";
+import { isAbsolute as isAbsolute19, join as join44, relative as relative26, resolve as resolve37, sep as sep27 } from "path";
 import { stringify } from "yaml";
 var SkillManager = class {
   #workspace;
   #home;
   constructor(options) {
-    this.#workspace = resolve36(options.workspace);
-    this.#home = resolve36(options.home ?? homedir4());
+    this.#workspace = resolve37(options.workspace);
+    this.#home = resolve37(options.home ?? homedir4());
   }
   async list() {
     const { registry, disabled } = await this.#registry();
@@ -30340,12 +30523,12 @@ async function discoverPluginSkillRoots(directory) {
     try {
       const manifest = PluginManifestSchema.parse(JSON.parse(await readFile35(join44(pluginRoot, "flavor-plugin.json"), "utf8")));
       for (const contribution of manifest.contributes.skillRoots) {
-        const candidate = resolve36(pluginRoot, contribution.path);
+        const candidate = resolve37(pluginRoot, contribution.path);
         const info = await lstat14(candidate);
         if (!info.isDirectory() || info.isSymbolicLink()) continue;
         const physical = await realpath13(candidate);
-        const relation = relative25(pluginRoot, physical);
-        if (relation === ".." || relation.startsWith(`..${sep26}`) || isAbsolute18(relation)) continue;
+        const relation = relative26(pluginRoot, physical);
+        if (relation === ".." || relation.startsWith(`..${sep27}`) || isAbsolute19(relation)) continue;
         roots.push(physical);
       }
     } catch {
@@ -30605,7 +30788,7 @@ function protocolLabel(type) {
 import { createReadStream as createReadStream2 } from "fs";
 import { realpath as realpath14, stat as stat15 } from "fs/promises";
 import { createServer as createServer6 } from "http";
-import { extname as extname4, isAbsolute as isAbsolute19, relative as relative26, resolve as resolve37, sep as sep27 } from "path";
+import { extname as extname4, isAbsolute as isAbsolute20, relative as relative27, resolve as resolve38, sep as sep28 } from "path";
 var MIME_TYPES = {
   ".css": "text/css; charset=utf-8",
   ".gif": "image/gif",
@@ -30623,11 +30806,11 @@ function sendNotFound(response2) {
   response2.end("Not found");
 }
 function isInside(root, candidate) {
-  const delta = relative26(root, candidate);
-  return delta === "" || !delta.startsWith(`..${sep27}`) && delta !== ".." && !isAbsolute19(delta);
+  const delta = relative27(root, candidate);
+  return delta === "" || !delta.startsWith(`..${sep28}`) && delta !== ".." && !isAbsolute20(delta);
 }
 async function startD2cProductPreview(rootDirectory) {
-  const root = await realpath14(resolve37(rootDirectory));
+  const root = await realpath14(resolve38(rootDirectory));
   const rootInfo = await stat15(root);
   if (!rootInfo.isDirectory()) throw new Error("D2C product prototype directory is unavailable");
   const server = createServer6(async (request, response2) => {
@@ -30639,7 +30822,7 @@ async function startD2cProductPreview(rootDirectory) {
       let pathname = decodeURIComponent(url.pathname);
       if (pathname === "/") pathname = "/index.html";
       if (pathname.includes("\0")) return sendNotFound(response2);
-      const unresolved = resolve37(root, `.${pathname}`);
+      const unresolved = resolve38(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);
@@ -30758,7 +30941,7 @@ var DesktopRuntimeController = class {
   /** Backend source digest observed when the managed process was started. */
   #d2cMockSourceFingerprints = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.#home = resolve38(options.home ?? homedir5());
+    this.#home = resolve39(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) => {
@@ -30833,7 +31016,7 @@ var DesktopRuntimeController = class {
     };
   }
   async openWorkspace(path) {
-    const workspace = resolve38(path);
+    const workspace = resolve39(path);
     if (workspace !== this.#workspace) {
       await this.#disposeRuntime();
       await this.#stopAllD2cPreviews();
@@ -32055,7 +32238,7 @@ async function loginShellEnvironment(environment, platform = process.platform, d
 
 // src/desktop/git-manager.ts
 import { readFile as readFile37, rm as rm16 } from "fs/promises";
-import { isAbsolute as isAbsolute20, relative as relative27, resolve as resolve39 } from "path";
+import { isAbsolute as isAbsolute21, relative as relative28, resolve as resolve40 } from "path";
 function failure(action, stderr, stdout) {
   return new Error(`${action}\u5931\u8D25\uFF1A${(stderr.trim() || stdout.trim() || "\u672A\u77E5 Git \u9519\u8BEF").split("\n")[0]}`);
 }
@@ -32148,13 +32331,13 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     return path.replaceAll("\\", "/");
   }));
   try {
-    const tree = JSON.parse(await readFile37(resolve39(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
+    const tree = JSON.parse(await readFile37(resolve40(workspace, ".flavor", "session-trees", sessionId, "tree.json"), "utf8"));
     const leaf = tree.nodes?.find((node) => node.id === tree.leafId);
     const parent = leaf?.parentId == null ? void 0 : tree.nodes?.find((node) => node.id === leaf.parentId);
     if (leaf === void 0 || parent === void 0) return desktopGitReviewDiff(workspace, { scope: "last-turn", paths });
     const load = async (id) => {
       if (!/^checkpoint-[A-Za-z0-9-]+$/.test(id)) throw new Error("Invalid checkpoint id");
-      return JSON.parse(await readFile37(resolve39(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
+      return JSON.parse(await readFile37(resolve40(workspace, ".flavor", "checkpoints", "manifests", `${id}.json`), "utf8"));
     };
     const [before, after] = await Promise.all([load(parent.checkpointId), load(leaf.checkpointId)]);
     const oldFiles = new Map(before.files.map((file) => [file.path, file.digest]));
@@ -32163,7 +32346,7 @@ async function desktopLastTurnDiff(workspace, sessionId, paths = []) {
     const object = async (digest) => {
       if (digest === void 0) return "";
       if (!/^[a-f0-9]{64}$/.test(digest)) throw new Error("Invalid checkpoint object");
-      const value = await readFile37(resolve39(workspace, ".flavor", "checkpoints", "objects", digest));
+      const value = await readFile37(resolve40(workspace, ".flavor", "checkpoints", "objects", digest));
       return value.includes(0) ? "[binary content]" : value.toString("utf8");
     };
     const chunks = await Promise.all(changed.map(async (path) => wholeFileDiff(path, await object(oldFiles.get(path)), await object(newFiles.get(path)))));
@@ -32187,11 +32370,11 @@ async function assertListed(workspace, path) {
   return file;
 }
 function safeWorkspacePath(workspace, path) {
-  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");
+  if (isAbsolute21(path)) throw new Error("Git \u6587\u4EF6\u8DEF\u5F84\u5FC5\u987B\u662F\u9879\u76EE\u5185\u7684\u76F8\u5BF9\u8DEF\u5F84");
+  const root = resolve40(workspace);
+  const target = resolve40(root, path);
+  const child = relative28(root, target);
+  if (child === "" || child.startsWith("..") || isAbsolute21(child)) throw new Error("\u62D2\u7EDD\u8BBF\u95EE\u9879\u76EE\u4E4B\u5916\u7684\u8DEF\u5F84");
   return target;
 }
 function safeGitTarget(value) {
@@ -32203,13 +32386,13 @@ function safeGitTarget(value) {
 // src/desktop/worktree-manager.ts
 import { randomUUID as randomUUID28 } from "crypto";
 import { mkdir as mkdir28, readFile as readFile38, readdir as readdir14, rm as rm17, stat as stat17, writeFile as writeFile18 } from "fs/promises";
-import { basename as basename11, isAbsolute as isAbsolute21, join as join48, relative as relative28, resolve as resolve40, sep as sep28 } from "path";
+import { basename as basename11, isAbsolute as isAbsolute22, join as join48, relative as relative29, resolve as resolve41, sep as sep29 } from "path";
 var DesktopWorktreeManager = class {
   #repository;
   #storage;
   constructor(options) {
-    this.#repository = resolve40(options.repository);
-    this.#storage = resolve40(options.storage);
+    this.#repository = resolve41(options.repository);
+    this.#storage = resolve41(options.storage);
   }
   async create(label) {
     if (!await isGitRepository(this.#repository)) throw new Error("Task worktrees require a Git repository");
@@ -32290,21 +32473,21 @@ var DesktopWorktreeManager = class {
     return this.#safeStoragePath(`${id}.json`);
   }
   #safeStoragePath(name) {
-    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");
+    const target = resolve41(this.#storage, name);
+    const delta = relative29(this.#storage, target);
+    if (delta === "" || delta === ".." || delta.startsWith(`..${sep29}`) || isAbsolute22(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" || resolve40(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" || resolve41(item.repository ?? "") !== repository) {
     throw new Error("Invalid worktree metadata");
   }
-  const path = resolve40(item.path);
-  const delta = relative28(storage, path);
-  if (delta === "" || delta === ".." || delta.startsWith(`..${sep28}`) || isAbsolute21(delta) || basename11(path) !== item.id) {
+  const path = resolve41(item.path);
+  const delta = relative29(storage, path);
+  if (delta === "" || delta === ".." || delta.startsWith(`..${sep29}`) || isAbsolute22(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 };
@@ -32313,15 +32496,15 @@ function validateStored(value, repository, storage) {
 // src/desktop/workbench-service.ts
 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";
+import { join as join49, resolve as resolve42 } from "path";
 var MAX_TEXT = 128e3;
 var MAX_ITEMS = 200;
 var DesktopWorkbenchService = class {
   #workspace;
   #home;
   constructor(workspace, home = homedir6()) {
-    this.#workspace = resolve41(workspace);
-    this.#home = resolve41(home);
+    this.#workspace = resolve42(workspace);
+    this.#home = resolve42(home);
   }
   async inspect(sessionId) {
     const [goals, instructions, permissionFiles, audit, context] = await Promise.all([
@@ -32372,7 +32555,7 @@ var DesktopWorkbenchService = class {
   }
   async #permissionFiles() {
     const candidates = [
-      ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve41(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
+      ...process.env.FLAVOR_MANAGED_PERMISSIONS ? [{ tier: "managed", path: resolve42(process.env.FLAVOR_MANAGED_PERMISSIONS), content: "" }] : [],
       { tier: "user", path: join49(this.#home, ".flavor-code", "permissions.json"), content: "" },
       { tier: "project", path: join49(this.#workspace, ".flavor", "permissions.json"), content: "" },
       { tier: "local", path: join49(this.#workspace, ".flavor", "permissions.local.json"), content: "" }
@@ -32445,14 +32628,14 @@ function redact2(value, key = "") {
 
 // src/desktop/main.ts
 installCrashGuard();
-var moduleDirectory = dirname25(fileURLToPath4(import.meta.url));
+var moduleDirectory = dirname23(fileURLToPath3(import.meta.url));
 var developmentUrl = process.env.FLAVOR_DESKTOP_DEV_URL;
 var mainWindow;
 var appMenu;
 var quitting = false;
 function logStartup(step, detail) {
   try {
-    const logPath = join50(dirname25(process.execPath), "flavor-code-startup.log");
+    const logPath = join50(dirname23(process.execPath), "flavor-code-startup.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     appendFileSync(logPath, `[${ts}] ${step}${detail ? ` | ${detail}` : ""}
 `);
@@ -32502,7 +32685,7 @@ function sessionMetaKey(workspace, sessionId) {
   return `${workspace}\0${sessionId}`;
 }
 function worktreeManager(workspace) {
-  const key = createHash28("sha256").update(resolve42(workspace)).digest("hex").slice(0, 20);
+  const key = createHash28("sha256").update(resolve43(workspace)).digest("hex").slice(0, 20);
   return new DesktopWorktreeManager({ repository: workspace, storage: join50(app.getPath("userData"), "task-worktrees", key) });
 }
 function activeWorkingDirectory() {
@@ -32718,7 +32901,7 @@ async function assertDirectory(path) {
   if (!(await stat19(path)).isDirectory()) throw new Error("The selected project is not a directory");
 }
 async function openWorkspace(path) {
-  const workspace = resolve42(path);
+  const workspace = resolve43(path);
   await assertDirectory(workspace);
   let project = managedProjects.get(workspace);
   if (project === void 0) {
@@ -32729,10 +32912,10 @@ async function openWorkspace(path) {
     activeWorkspace = workspace;
     controller = nextController;
     project.snapshot = await nextController.openWorkspace(workspace);
-    for (const saved of workbench.taskCheckouts.filter((item) => resolve42(item.workspace) === workspace)) {
+    for (const saved of workbench.taskCheckouts.filter((item) => resolve43(item.workspace) === workspace)) {
       try {
         await assertDirectory(saved.workingDirectory);
-        const task = { environment: "worktree", workingDirectory: resolve42(saved.workingDirectory), worktreeId: saved.worktreeId };
+        const task = { environment: "worktree", workingDirectory: resolve43(saved.workingDirectory), worktreeId: saved.worktreeId };
         task.controller = createDesktopController(workspace, task);
         task.snapshot = await task.controller.openWorkspace(task.workingDirectory);
         task.sessionId = saved.sessionId;
@@ -32862,7 +33045,7 @@ function installIpcHandlers() {
       } catch {
       }
     }
-    if (persisted.workspace !== void 0 && managedProjects.has(resolve42(persisted.workspace))) {
+    if (persisted.workspace !== void 0 && managedProjects.has(resolve43(persisted.workspace))) {
       try {
         return await openWorkspace(persisted.workspace);
       } catch {
@@ -32923,7 +33106,7 @@ function installIpcHandlers() {
   });
   ipcMain.handle(DESKTOP_CHANNELS.updateProject, async (_event, value) => {
     const input = UpdateProjectInputSchema.parse(value);
-    const workspace = resolve42(input.workspace);
+    const workspace = resolve43(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();
@@ -32931,7 +33114,7 @@ function installIpcHandlers() {
   });
   ipcMain.handle(DESKTOP_CHANNELS.closeProject, async (_event, value) => {
     const input = CloseProjectInputSchema.parse(value);
-    const workspace = resolve42(input.workspace);
+    const workspace = resolve43(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");
@@ -32947,12 +33130,12 @@ function installIpcHandlers() {
     return decorateSnapshot(controller.snapshot());
   });
   ipcMain.handle(DESKTOP_CHANNELS.revealProject, async (_event, value) => {
-    const workspace = resolve42(ProjectPathInputSchema.parse(value).workspace);
+    const workspace = resolve43(ProjectPathInputSchema.parse(value).workspace);
     await assertDirectory(workspace);
     await shell.openPath(workspace);
   });
   ipcMain.handle(DESKTOP_CHANNELS.copyProjectPath, async (_event, value) => {
-    clipboard.writeText(resolve42(ProjectPathInputSchema.parse(value).workspace));
+    clipboard.writeText(resolve43(ProjectPathInputSchema.parse(value).workspace));
   });
   ipcMain.handle(DESKTOP_CHANNELS.dismissRecovery, async (_event, value) => {
     const { sessionId } = DeleteSessionInputSchema.parse(value);