@kenkaiiii/gg-boss 4.8.7 → 4.9.0

package/dist/{chunk-OKATJ2SW.js → chunk-QDOB5CCW.js}

@@ -3225,8 +3225,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path43) {
-      let input = path43;
+    function removeDotSegments(path45) {
+      let input = path45;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3426,8 +3426,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path43, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path43 && path43 !== "/" ? path43 : void 0;
+        const [path45, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path45 && path45 !== "/" ? path45 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6835,12 +6835,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs37, exportName) {
+    function addFormats(ajv, list, fs38, exportName) {
       var _a6;
       var _b;
       (_a6 = (_b = ajv.opts.code).formats) !== null && _a6 !== void 0 ? _a6 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs37[f]);
+        ajv.addFormat(f, fs38[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6855,8 +6855,8 @@ var require_windows = __commonJS({
     init_esm_shims();
     module.exports = isexe;
     isexe.sync = sync;
-    var fs37 = __require("fs");
-    function checkPathExt(path43, options) {
+    var fs38 = __require("fs");
+    function checkPathExt(path45, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -6867,25 +6867,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path43.substr(-p.length).toLowerCase() === p) {
+        if (p && path45.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path43, options) {
+    function checkStat(stat, path45, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path43, options);
+      return checkPathExt(path45, options);
     }
-    function isexe(path43, options, cb) {
-      fs37.stat(path43, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path43, options));
+    function isexe(path45, options, cb) {
+      fs38.stat(path45, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path45, options));
       });
     }
-    function sync(path43, options) {
-      return checkStat(fs37.statSync(path43), path43, options);
+    function sync(path45, options) {
+      return checkStat(fs38.statSync(path45), path45, options);
     }
   }
 });
@@ -6897,14 +6897,14 @@ var require_mode = __commonJS({
     init_esm_shims();
     module.exports = isexe;
     isexe.sync = sync;
-    var fs37 = __require("fs");
-    function isexe(path43, options, cb) {
-      fs37.stat(path43, function(er, stat) {
+    var fs38 = __require("fs");
+    function isexe(path45, options, cb) {
+      fs38.stat(path45, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path43, options) {
-      return checkStat(fs37.statSync(path43), options);
+    function sync(path45, options) {
+      return checkStat(fs38.statSync(path45), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -6930,7 +6930,7 @@ var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs37 = __require("fs");
+    var fs38 = __require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -6939,7 +6939,7 @@ var require_isexe = __commonJS({
     }
     module.exports = isexe;
     isexe.sync = sync;
-    function isexe(path43, options, cb) {
+    function isexe(path45, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -6949,7 +6949,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve2, reject) {
-          isexe(path43, options || {}, function(er, is) {
+          isexe(path45, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -6958,7 +6958,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path43, options || {}, function(er, is) {
+      core(path45, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -6968,9 +6968,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path43, options) {
+    function sync(path45, options) {
       try {
-        return core.sync(path43, options || {});
+        return core.sync(path45, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -6988,7 +6988,7 @@ var require_which = __commonJS({
     "use strict";
     init_esm_shims();
     var isWindows3 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path43 = __require("path");
+    var path45 = __require("path");
     var COLON = isWindows3 ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -7026,7 +7026,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path43.join(pathPart, cmd);
+        const pCmd = path45.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve2(subStep(p, i, 0));
       });
@@ -7053,7 +7053,7 @@ var require_which = __commonJS({
       for (let i = 0; i < pathEnv.length; i++) {
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path43.join(pathPart, cmd);
+        const pCmd = path45.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -7103,7 +7103,7 @@ var require_resolveCommand = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path43 = __require("path");
+    var path45 = __require("path");
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -7121,7 +7121,7 @@ var require_resolveCommand = __commonJS({
       try {
         resolved = which.sync(parsed.command, {
           path: env2[getPathKey({ env: env2 })],
-          pathExt: withoutPathExt ? path43.delimiter : void 0
+          pathExt: withoutPathExt ? path45.delimiter : void 0
         });
       } catch (e) {
       } finally {
@@ -7130,7 +7130,7 @@ var require_resolveCommand = __commonJS({
         }
       }
       if (resolved) {
-        resolved = path43.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+        resolved = path45.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
       }
       return resolved;
     }
@@ -7187,8 +7187,8 @@ var require_shebang_command = __commonJS({
       if (!match) {
         return null;
       }
-      const [path43, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path43.split("/").pop();
+      const [path45, argument] = match[0].replace(/#! ?/, "").split(" ");
+      const binary = path45.split("/").pop();
       if (binary === "env") {
         return argument;
       }
@@ -7202,16 +7202,16 @@ var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var fs37 = __require("fs");
+    var fs38 = __require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd2;
       try {
-        fd2 = fs37.openSync(command, "r");
-        fs37.readSync(fd2, buffer, 0, size, 0);
-        fs37.closeSync(fd2);
+        fd2 = fs38.openSync(command, "r");
+        fs38.readSync(fd2, buffer, 0, size, 0);
+        fs38.closeSync(fd2);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -7225,7 +7225,7 @@ var require_parse = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var path43 = __require("path");
+    var path45 = __require("path");
     var resolveCommand = require_resolveCommand();
     var escape4 = require_escape();
     var readShebang = require_readShebang();
@@ -7250,7 +7250,7 @@ var require_parse = __commonJS({
       const needsShell = !isExecutableRegExp.test(commandFile);
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path43.normalize(parsed.command);
+        parsed.command = path45.normalize(parsed.command);
         parsed.command = escape4.command(parsed.command);
         parsed.args = parsed.args.map((arg) => escape4.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
@@ -7342,7 +7342,7 @@ var require_cross_spawn = __commonJS({
     var cp = __require("child_process");
     var parse3 = require_parse();
     var enoent = require_enoent();
-    function spawn8(command, args, options) {
+    function spawn9(command, args, options) {
       const parsed = parse3(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -7354,8 +7354,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module.exports = spawn8;
-    module.exports.spawn = spawn8;
+    module.exports = spawn9;
+    module.exports.spawn = spawn9;
     module.exports.sync = spawnSync2;
     module.exports._parse = parse3;
     module.exports._enoent = enoent;
@@ -17765,10 +17765,10 @@ var require_react_reconciler_development = __commonJS({
           fiber = fiber.next, id2--;
         return fiber;
       }
-      function copyWithSetImpl(obj, path43, index, value) {
-        if (index >= path43.length) return value;
-        var key = path43[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
-        updated[key] = copyWithSetImpl(obj[key], path43, index + 1, value);
+      function copyWithSetImpl(obj, path45, index, value) {
+        if (index >= path45.length) return value;
+        var key = path45[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+        updated[key] = copyWithSetImpl(obj[key], path45, index + 1, value);
         return updated;
       }
       function copyWithRename(obj, oldPath, newPath) {
@@ -17795,11 +17795,11 @@ var require_react_reconciler_development = __commonJS({
         );
         return updated;
       }
-      function copyWithDeleteImpl(obj, path43, index) {
-        var key = path43[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
-        if (index + 1 === path43.length)
+      function copyWithDeleteImpl(obj, path45, index) {
+        var key = path45[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+        if (index + 1 === path45.length)
           return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
-        updated[key] = copyWithDeleteImpl(obj[key], path43, index + 1);
+        updated[key] = copyWithDeleteImpl(obj[key], path45, index + 1);
         return updated;
       }
       function shouldSuspendImpl() {
@@ -31076,29 +31076,29 @@ var require_react_reconciler_development = __commonJS({
       var didWarnAboutNestedUpdates = false;
       var didWarnAboutFindNodeInStrictMode = {};
       var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, scheduleRetry = null, setErrorHandler = null, setSuspenseHandler = null;
-      overrideHookState = function(fiber, id2, path43, value) {
+      overrideHookState = function(fiber, id2, path45, value) {
         id2 = findHook(fiber, id2);
-        null !== id2 && (path43 = copyWithSetImpl(id2.memoizedState, path43, 0, value), id2.memoizedState = path43, id2.baseState = path43, fiber.memoizedProps = assign({}, fiber.memoizedProps), path43 = enqueueConcurrentRenderForLane(fiber, 2), null !== path43 && scheduleUpdateOnFiber(path43, fiber, 2));
+        null !== id2 && (path45 = copyWithSetImpl(id2.memoizedState, path45, 0, value), id2.memoizedState = path45, id2.baseState = path45, fiber.memoizedProps = assign({}, fiber.memoizedProps), path45 = enqueueConcurrentRenderForLane(fiber, 2), null !== path45 && scheduleUpdateOnFiber(path45, fiber, 2));
       };
-      overrideHookStateDeletePath = function(fiber, id2, path43) {
+      overrideHookStateDeletePath = function(fiber, id2, path45) {
         id2 = findHook(fiber, id2);
-        null !== id2 && (path43 = copyWithDeleteImpl(id2.memoizedState, path43, 0), id2.memoizedState = path43, id2.baseState = path43, fiber.memoizedProps = assign({}, fiber.memoizedProps), path43 = enqueueConcurrentRenderForLane(fiber, 2), null !== path43 && scheduleUpdateOnFiber(path43, fiber, 2));
+        null !== id2 && (path45 = copyWithDeleteImpl(id2.memoizedState, path45, 0), id2.memoizedState = path45, id2.baseState = path45, fiber.memoizedProps = assign({}, fiber.memoizedProps), path45 = enqueueConcurrentRenderForLane(fiber, 2), null !== path45 && scheduleUpdateOnFiber(path45, fiber, 2));
       };
       overrideHookStateRenamePath = function(fiber, id2, oldPath, newPath) {
         id2 = findHook(fiber, id2);
         null !== id2 && (oldPath = copyWithRename(id2.memoizedState, oldPath, newPath), id2.memoizedState = oldPath, id2.baseState = oldPath, fiber.memoizedProps = assign({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2));
       };
-      overrideProps = function(fiber, path43, value) {
-        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path43, 0, value);
+      overrideProps = function(fiber, path45, value) {
+        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path45, 0, value);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path43 = enqueueConcurrentRenderForLane(fiber, 2);
-        null !== path43 && scheduleUpdateOnFiber(path43, fiber, 2);
+        path45 = enqueueConcurrentRenderForLane(fiber, 2);
+        null !== path45 && scheduleUpdateOnFiber(path45, fiber, 2);
       };
-      overridePropsDeletePath = function(fiber, path43) {
-        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path43, 0);
+      overridePropsDeletePath = function(fiber, path45) {
+        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path45, 0);
         fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
-        path43 = enqueueConcurrentRenderForLane(fiber, 2);
-        null !== path43 && scheduleUpdateOnFiber(path43, fiber, 2);
+        path45 = enqueueConcurrentRenderForLane(fiber, 2);
+        null !== path45 && scheduleUpdateOnFiber(path45, fiber, 2);
       };
       overridePropsRenamePath = function(fiber, oldPath, newPath) {
         fiber.pendingProps = copyWithRename(
@@ -34333,15 +34333,15 @@ function redactSensitive(body) {
   }
   return null;
 }
-async function checkCredentialsFileSafety(path43, onWarn = (m) => console.warn(`anthropic-sdk: ${m}`)) {
+async function checkCredentialsFileSafety(path45, onWarn = (m) => console.warn(`anthropic-sdk: ${m}`)) {
   if (typeof process === "undefined" || process.platform === "win32")
     return;
-  const fs37 = await import("fs");
-  let resolved = path43;
+  const fs38 = await import("fs");
+  let resolved = path45;
   let st;
   try {
-    resolved = await fs37.promises.realpath(path43);
-    st = await fs37.promises.stat(resolved);
+    resolved = await fs38.promises.realpath(path45);
+    st = await fs38.promises.stat(resolved);
   } catch {
     return;
   }
@@ -34357,27 +34357,27 @@ async function checkCredentialsFileSafety(path43, onWarn = (m) => console.warn(`
   }
 }
 async function writeCredentialsFileAtomic(targetPath, data) {
-  const fs37 = await import("fs");
-  const path43 = await import("path");
-  const dir = path43.dirname(targetPath);
-  await fs37.promises.mkdir(dir, { recursive: true, mode: 448 });
+  const fs38 = await import("fs");
+  const path45 = await import("path");
+  const dir = path45.dirname(targetPath);
+  await fs38.promises.mkdir(dir, { recursive: true, mode: 448 });
   const tmpPath = `${targetPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    const fh = await fs37.promises.open(tmpPath, "w", 384);
+    const fh = await fs38.promises.open(tmpPath, "w", 384);
     try {
       await fh.writeFile(JSON.stringify(data, null, 2));
       await fh.sync();
     } finally {
       await fh.close();
     }
-    await fs37.promises.rename(tmpPath, targetPath);
+    await fs38.promises.rename(tmpPath, targetPath);
   } catch (err) {
-    await fs37.promises.unlink(tmpPath).catch(() => {
+    await fs38.promises.unlink(tmpPath).catch(() => {
     });
     throw err;
   }
   try {
-    const dirFh = await fs37.promises.open(dir, "r");
+    const dirFh = await fs38.promises.open(dir, "r");
     try {
       await dirFh.sync();
     } finally {
@@ -34679,12 +34679,12 @@ var loadConfigWithSource = async (profile) => {
     return null;
   }
   validateProfileName(profileName);
-  const fs37 = await import("fs");
-  const path43 = await import("path");
-  const configPath = path43.join(rootConfigPath, "configs", `${profileName}.json`);
+  const fs38 = await import("fs");
+  const path45 = await import("path");
+  const configPath = path45.join(rootConfigPath, "configs", `${profileName}.json`);
   let configRaw;
   try {
-    configRaw = await fs37.promises.readFile(configPath, "utf-8");
+    configRaw = await fs38.promises.readFile(configPath, "utf-8");
   } catch (err) {
     if (err?.code !== "ENOENT") {
       throw new Error(`failed to read config file ${configPath}: ${err}`);
@@ -34765,14 +34765,14 @@ var getCredentialsPath = async (config2, profile) => {
     return null;
   }
   validateProfileName(profileName);
-  const path43 = await import("path");
-  return path43.join(rootConfigPath, "credentials", `${profileName}.json`);
+  const path45 = await import("path");
+  return path45.join(rootConfigPath, "credentials", `${profileName}.json`);
 };
 var getRootConfigPath = async () => {
   if (!supportsLocalConfigFiles()) {
     return null;
   }
-  const path43 = await import("path");
+  const path45 = await import("path");
   const configDir = readEnv("ANTHROPIC_CONFIG_DIR");
   if (configDir) {
     return configDir;
@@ -34781,21 +34781,21 @@ var getRootConfigPath = async () => {
   if (os12 === "Windows") {
     const appData = readEnv("APPDATA");
     if (appData) {
-      return path43.join(appData, "Anthropic");
+      return path45.join(appData, "Anthropic");
     }
     const userProfile = readEnv("USERPROFILE");
     if (userProfile) {
-      return path43.join(userProfile, "AppData", "Roaming", "Anthropic");
+      return path45.join(userProfile, "AppData", "Roaming", "Anthropic");
     }
     return null;
   }
   const xdgConfigHome = readEnv("XDG_CONFIG_HOME");
   if (xdgConfigHome) {
-    return path43.join(xdgConfigHome, "anthropic");
+    return path45.join(xdgConfigHome, "anthropic");
   }
   const home = readEnv("HOME");
   if (home) {
-    return path43.join(home, ".config", "anthropic");
+    return path45.join(home, ".config", "anthropic");
   }
   return null;
 };
@@ -34812,11 +34812,11 @@ var getActiveProfileName = async () => {
   if (profileName) {
     return profileName;
   }
-  const fs37 = await import("fs");
-  const path43 = await import("path");
-  const filePath = path43.join(rootConfigPath, "active_config");
+  const fs38 = await import("fs");
+  const path45 = await import("path");
+  const filePath = path45.join(rootConfigPath, "active_config");
   try {
-    return (await fs37.promises.readFile(filePath, "utf-8")).trim() || "default";
+    return (await fs38.promises.readFile(filePath, "utf-8")).trim() || "default";
   } catch (err) {
     if (err?.code !== "ENOENT") {
       throw new Error(`failed to read ${filePath}: ${err}`);
@@ -34827,21 +34827,21 @@ var getActiveProfileName = async () => {
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.94.0_zod@4.4.3/node_modules/@anthropic-ai/sdk/lib/credentials/identity-token.mjs
 init_esm_shims();
-function identityTokenFromFile(path43) {
-  if (!path43) {
+function identityTokenFromFile(path45) {
+  if (!path45) {
     throw new AnthropicError("Identity token file path is empty");
   }
   return async () => {
-    const fs37 = await import("fs");
+    const fs38 = await import("fs");
     let content;
     try {
-      content = await fs37.promises.readFile(path43, "utf-8");
+      content = await fs38.promises.readFile(path45, "utf-8");
     } catch (err) {
-      throw new AnthropicError(`Failed to read identity token file at ${path43}: ${err}`);
+      throw new AnthropicError(`Failed to read identity token file at ${path45}: ${err}`);
     }
     const token = content.trim();
     if (!token) {
-      throw new AnthropicError(`Identity token file at ${path43} is empty`);
+      throw new AnthropicError(`Identity token file at ${path45} is empty`);
     }
     return token;
   };
@@ -34916,11 +34916,11 @@ function oidcFederationProvider(config2) {
 init_esm_shims();
 function userOAuthProvider(config2) {
   return async (opts) => {
-    const fs37 = await import("fs");
+    const fs38 = await import("fs");
     await checkCredentialsFileSafety(config2.credentialsPath, config2.onSafetyWarning);
     let raw;
     try {
-      raw = await fs37.promises.readFile(config2.credentialsPath, "utf-8");
+      raw = await fs38.promises.readFile(config2.credentialsPath, "utf-8");
     } catch (err) {
       throw new WorkloadIdentityError(`Credentials file not found at ${config2.credentialsPath}: ${err}`);
     }
@@ -35084,11 +35084,11 @@ function resolveIdentityTokenProvider(auth2) {
 }
 function cachedExchangeProvider(exchange, credentialsPath, onCacheWriteError, onSafetyWarning) {
   return async (opts) => {
-    const fs37 = await import("fs");
+    const fs38 = await import("fs");
     await checkCredentialsFileSafety(credentialsPath, onSafetyWarning);
     let existing;
     try {
-      const raw = await fs37.promises.readFile(credentialsPath, "utf-8");
+      const raw = await fs38.promises.readFile(credentialsPath, "utf-8");
       existing = JSON.parse(raw);
       const token = existing?.["access_token"];
       if (token && !opts?.forceRefresh) {
@@ -35927,12 +35927,12 @@ function encodeURIPath(str2) {
   return str2.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
 }
 var EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-var createPathTagFunction = (pathEncoder = encodeURIPath) => function path43(statics, ...params) {
+var createPathTagFunction = (pathEncoder = encodeURIPath) => function path45(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path44 = statics.reduce((previousValue, currentValue, index) => {
+  const path46 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -35949,7 +35949,7 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path43(sta
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path44.split(/[?#]/, 1)[0];
+  const pathOnly = path46.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match;
   while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -35970,10 +35970,10 @@ var createPathTagFunction = (pathEncoder = encodeURIPath) => function path43(sta
     }, "");
     throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path44}
+${path46}
 ${underline}`);
   }
-  return path44;
+  return path46;
 };
 var path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
 
@@ -40734,9 +40734,9 @@ var BaseAnthropic = class {
   makeStatusError(status, error51, message, headers) {
     return APIError.generate(status, error51, message, headers);
   }
-  buildURL(path43, query, defaultBaseURL) {
+  buildURL(path45, query, defaultBaseURL) {
     const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url2 = isAbsoluteURL(path43) ? new URL(path43) : new URL(baseURL + (baseURL.endsWith("/") && path43.startsWith("/") ? path43.slice(1) : path43));
+    const url2 = isAbsoluteURL(path45) ? new URL(path45) : new URL(baseURL + (baseURL.endsWith("/") && path45.startsWith("/") ? path45.slice(1) : path45));
     const defaultQuery = this.defaultQuery();
     const pathQuery = Object.fromEntries(url2.searchParams);
     if (!isEmptyObj(defaultQuery) || !isEmptyObj(pathQuery)) {
@@ -40780,24 +40780,24 @@ var BaseAnthropic = class {
       request.headers = headers;
     }
   }
-  get(path43, opts) {
-    return this.methodRequest("get", path43, opts);
+  get(path45, opts) {
+    return this.methodRequest("get", path45, opts);
   }
-  post(path43, opts) {
-    return this.methodRequest("post", path43, opts);
+  post(path45, opts) {
+    return this.methodRequest("post", path45, opts);
   }
-  patch(path43, opts) {
-    return this.methodRequest("patch", path43, opts);
+  patch(path45, opts) {
+    return this.methodRequest("patch", path45, opts);
   }
-  put(path43, opts) {
-    return this.methodRequest("put", path43, opts);
+  put(path45, opts) {
+    return this.methodRequest("put", path45, opts);
   }
-  delete(path43, opts) {
-    return this.methodRequest("delete", path43, opts);
+  delete(path45, opts) {
+    return this.methodRequest("delete", path45, opts);
   }
-  methodRequest(method, path43, opts) {
+  methodRequest(method, path45, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path43, ...opts2 };
+      return { method, path: path45, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -40902,8 +40902,8 @@ var BaseAnthropic = class {
     }));
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
-  getAPIList(path43, Page3, opts) {
-    return this.requestAPIList(Page3, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path43, ...opts2 })) : { method: "get", path: path43, ...opts });
+  getAPIList(path45, Page3, opts) {
+    return this.requestAPIList(Page3, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path45, ...opts2 })) : { method: "get", path: path45, ...opts });
   }
   requestAPIList(Page3, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -40997,14 +40997,14 @@ var BaseAnthropic = class {
   }
   async buildRequest(inputOptions, { retryCount = 0 } = {}) {
     const options = { ...inputOptions };
-    const { method, path: path43, query, defaultBaseURL } = options;
+    const { method, path: path45, query, defaultBaseURL } = options;
     if (this._authState.resolution) {
       await this._authState.resolution;
     }
     if (!this._baseURLIsExplicit && this._authState.baseURL && this.baseURL !== this._authState.baseURL) {
       this.baseURL = this._authState.baseURL;
     }
-    const url2 = this.buildURL(path43, query, defaultBaseURL);
+    const url2 = this.buildURL(path45, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -41891,10 +41891,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path43) {
-  if (!path43)
+function getElementAtPath(obj, path45) {
+  if (!path45)
     return obj;
-  return path43.reduce((acc, key) => acc?.[key], obj);
+  return path45.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -42303,11 +42303,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path43, issues) {
+function prefixIssues(path45, issues) {
   return issues.map((iss) => {
     var _a6;
     (_a6 = iss).path ?? (_a6.path = []);
-    iss.path.unshift(path43);
+    iss.path.unshift(path45);
     return iss;
   });
 }
@@ -42454,16 +42454,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path43 = []) => {
+  const processError = (error52, path45 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path43, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path45, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path45, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path45, ...issue2.path]);
       } else {
-        const fullpath = [...path43, ...issue2.path];
+        const fullpath = [...path45, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -42490,17 +42490,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path43 = []) => {
+  const processError = (error52, path45 = []) => {
     var _a6, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path43, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path45, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path45, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path43, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path45, ...issue2.path]);
       } else {
-        const fullpath = [...path43, ...issue2.path];
+        const fullpath = [...path45, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -42532,8 +42532,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path43 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path43) {
+  const path45 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path45) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -55306,13 +55306,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path43 = ref.slice(1).split("/").filter(Boolean);
-  if (path43.length === 0) {
+  const path45 = ref.slice(1).split("/").filter(Boolean);
+  if (path45.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path43[0] === defsKey) {
-    const key = path43[1];
+  if (path45[0] === defsKey) {
+    const key = path45[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -57541,12 +57541,12 @@ function encodeURIPath2(str2) {
   return str2.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
 }
 var EMPTY2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-var createPathTagFunction2 = (pathEncoder = encodeURIPath2) => function path43(statics, ...params) {
+var createPathTagFunction2 = (pathEncoder = encodeURIPath2) => function path45(statics, ...params) {
   if (statics.length === 1)
     return statics[0];
   let postPath = false;
   const invalidSegments = [];
-  const path44 = statics.reduce((previousValue, currentValue, index) => {
+  const path46 = statics.reduce((previousValue, currentValue, index) => {
     if (/[?#]/.test(currentValue)) {
       postPath = true;
     }
@@ -57563,7 +57563,7 @@ var createPathTagFunction2 = (pathEncoder = encodeURIPath2) => function path43(s
     }
     return previousValue + currentValue + (index === params.length ? "" : encoded);
   }, "");
-  const pathOnly = path44.split(/[?#]/, 1)[0];
+  const pathOnly = path46.split(/[?#]/, 1)[0];
   const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
   let match;
   while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -57584,10 +57584,10 @@ var createPathTagFunction2 = (pathEncoder = encodeURIPath2) => function path43(s
     }, "");
     throw new OpenAIError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path44}
+${path46}
 ${underline}`);
   }
-  return path44;
+  return path46;
 };
 var path2 = /* @__PURE__ */ createPathTagFunction2(encodeURIPath2);
 
@@ -62713,9 +62713,9 @@ var OpenAI = class {
     this.apiKey = token;
     return true;
   }
-  buildURL(path43, query, defaultBaseURL) {
+  buildURL(path45, query, defaultBaseURL) {
     const baseURL = !__classPrivateFieldGet2(this, _OpenAI_instances, "m", _OpenAI_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-    const url2 = isAbsoluteURL2(path43) ? new URL(path43) : new URL(baseURL + (baseURL.endsWith("/") && path43.startsWith("/") ? path43.slice(1) : path43));
+    const url2 = isAbsoluteURL2(path45) ? new URL(path45) : new URL(baseURL + (baseURL.endsWith("/") && path45.startsWith("/") ? path45.slice(1) : path45));
     const defaultQuery = this.defaultQuery();
     const pathQuery = Object.fromEntries(url2.searchParams);
     if (!isEmptyObj2(defaultQuery) || !isEmptyObj2(pathQuery)) {
@@ -62740,24 +62740,24 @@ var OpenAI = class {
    */
   async prepareRequest(request, { url: url2, options }) {
   }
-  get(path43, opts) {
-    return this.methodRequest("get", path43, opts);
+  get(path45, opts) {
+    return this.methodRequest("get", path45, opts);
   }
-  post(path43, opts) {
-    return this.methodRequest("post", path43, opts);
+  post(path45, opts) {
+    return this.methodRequest("post", path45, opts);
   }
-  patch(path43, opts) {
-    return this.methodRequest("patch", path43, opts);
+  patch(path45, opts) {
+    return this.methodRequest("patch", path45, opts);
   }
-  put(path43, opts) {
-    return this.methodRequest("put", path43, opts);
+  put(path45, opts) {
+    return this.methodRequest("put", path45, opts);
   }
-  delete(path43, opts) {
-    return this.methodRequest("delete", path43, opts);
+  delete(path45, opts) {
+    return this.methodRequest("delete", path45, opts);
   }
-  methodRequest(method, path43, opts) {
+  methodRequest(method, path45, opts) {
     return this.request(Promise.resolve(opts).then((opts2) => {
-      return { method, path: path43, ...opts2 };
+      return { method, path: path45, ...opts2 };
     }));
   }
   request(options, remainingRetries = null) {
@@ -62875,8 +62875,8 @@ var OpenAI = class {
     }));
     return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
   }
-  getAPIList(path43, Page3, opts) {
-    return this.requestAPIList(Page3, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path43, ...opts2 })) : { method: "get", path: path43, ...opts });
+  getAPIList(path45, Page3, opts) {
+    return this.requestAPIList(Page3, opts && "then" in opts ? opts.then((opts2) => ({ method: "get", path: path45, ...opts2 })) : { method: "get", path: path45, ...opts });
   }
   requestAPIList(Page3, options) {
     const request = this.makeRequest(options, null, void 0);
@@ -62967,8 +62967,8 @@ var OpenAI = class {
   }
   async buildRequest(inputOptions, { retryCount = 0 } = {}) {
     const options = { ...inputOptions };
-    const { method, path: path43, query, defaultBaseURL } = options;
-    const url2 = this.buildURL(path43, query, defaultBaseURL);
+    const { method, path: path45, query, defaultBaseURL } = options;
+    const url2 = this.buildURL(path45, query, defaultBaseURL);
     if ("timeout" in options)
       validatePositiveInteger2("timeout", options.timeout);
     options.timeout = options.timeout ?? this.timeout;
@@ -64703,11 +64703,11 @@ async function* runStream2(options) {
     }
   }
   if (getEnvironment()?.GGAI_DUMP_REQUEST) {
-    const fs37 = await import("fs");
+    const fs38 = await import("fs");
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const dumpPath = `/tmp/ggai-request-${ts}.json`;
-    fs37.writeFileSync(dumpPath, JSON.stringify(params, null, 2));
-    fs37.appendFileSync(
+    fs38.writeFileSync(dumpPath, JSON.stringify(params, null, 2));
+    fs38.appendFileSync(
       "/tmp/ggai-requests.log",
       `[${ts}] ${dumpPath} messages=${params.messages.length}
 `
@@ -69290,25 +69290,715 @@ var ProcessManager = class {
   }
 };
 
+// ../ggcoder/dist/core/lsp/manager.js
+init_esm_shims();
+import path8 from "path";
+
+// ../ggcoder/dist/core/logger.js
+init_esm_shims();
+
+// ../ggcoder/dist/core/lsp/client.js
+init_esm_shims();
+import { spawn as spawn3 } from "child_process";
+import { pathToFileURL } from "url";
+
+// ../ggcoder/dist/core/lsp/jsonrpc.js
+init_esm_shims();
+var JsonRpcRequestError = class extends Error {
+  code;
+  constructor(method, code, message) {
+    super(`${method}: ${message} (code ${code})`);
+    this.name = "JsonRpcRequestError";
+    this.code = code;
+  }
+};
+var HEADER_SEPARATOR = "\r\n\r\n";
+var JsonRpcConnection = class {
+  output;
+  buffer = Buffer.alloc(0);
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  disposed = false;
+  constructor(input, output) {
+    this.output = output;
+    input.on("data", (chunk) => this.onData(chunk));
+    output.on("error", () => {
+    });
+  }
+  onNotification(method, handler) {
+    const handlers = this.notificationHandlers.get(method) ?? [];
+    handlers.push(handler);
+    this.notificationHandlers.set(method, handlers);
+  }
+  request(method, params, timeoutMs) {
+    if (this.disposed) {
+      return Promise.reject(new JsonRpcRequestError(method, -32099, "connection disposed"));
+    }
+    const id2 = this.nextId++;
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id2);
+        reject(new JsonRpcRequestError(method, -32803, `timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      timer.unref();
+      this.pending.set(id2, (msg) => {
+        clearTimeout(timer);
+        if (msg.error) {
+          reject(new JsonRpcRequestError(method, msg.error.code, msg.error.message));
+        } else {
+          resolve2(msg.result);
+        }
+      });
+      this.send({ jsonrpc: "2.0", id: id2, method, params });
+    });
+  }
+  notify(method, params) {
+    this.send({ jsonrpc: "2.0", method, params });
+  }
+  /** Reject all in-flight requests and stop accepting new work. */
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    for (const [id2, settle] of this.pending) {
+      this.pending.delete(id2);
+      settle({ error: { code: -32099, message: "connection disposed" } });
+    }
+  }
+  send(msg) {
+    if (this.disposed)
+      return;
+    const body = JSON.stringify(msg);
+    try {
+      this.output.write(`Content-Length: ${Buffer.byteLength(body)}\r
+\r
+${body}`);
+    } catch {
+    }
+  }
+  onData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    for (; ; ) {
+      const headerEnd = this.buffer.indexOf(HEADER_SEPARATOR);
+      if (headerEnd === -1)
+        return;
+      const header = this.buffer.subarray(0, headerEnd).toString();
+      const match = /Content-Length: (\d+)/i.exec(header);
+      if (!match) {
+        this.buffer = this.buffer.subarray(headerEnd + HEADER_SEPARATOR.length);
+        continue;
+      }
+      const length = Number(match[1]);
+      const bodyStart = headerEnd + HEADER_SEPARATOR.length;
+      if (this.buffer.length < bodyStart + length)
+        return;
+      const body = this.buffer.subarray(bodyStart, bodyStart + length).toString();
+      this.buffer = this.buffer.subarray(bodyStart + length);
+      let msg;
+      try {
+        msg = JSON.parse(body);
+      } catch {
+        continue;
+      }
+      this.onMessage(msg);
+    }
+  }
+  onMessage(msg) {
+    if (msg.id !== void 0 && msg.method === void 0) {
+      const settle = typeof msg.id === "number" ? this.pending.get(msg.id) : void 0;
+      if (settle && typeof msg.id === "number") {
+        this.pending.delete(msg.id);
+        settle(msg);
+      }
+      return;
+    }
+    if (msg.id !== void 0 && msg.method !== void 0) {
+      let result = null;
+      if (msg.method === "workspace/configuration") {
+        const items = msg.params?.items ?? [];
+        result = items.map(() => null);
+      }
+      this.send({ jsonrpc: "2.0", id: msg.id, result });
+      return;
+    }
+    if (msg.method !== void 0) {
+      const handlers = this.notificationHandlers.get(msg.method);
+      if (handlers) {
+        for (const handler of handlers)
+          handler(msg.params);
+      }
+    }
+  }
+};
+
+// ../ggcoder/dist/core/lsp/client.js
+var SERVER_CANCELLED = -32802;
+var METHOD_NOT_FOUND = -32601;
+var PULL_POLL_INTERVAL_MS = 300;
+var SHUTDOWN_TIMEOUT_MS = 2e3;
+var KILL_GRACE_MS = 1500;
+function sleep4(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms).unref();
+  });
+}
+var LspClient = class {
+  spec;
+  rootPath;
+  proc;
+  conn;
+  versions = /* @__PURE__ */ new Map();
+  published = /* @__PURE__ */ new Map();
+  waiters = [];
+  hasPullDiagnostics = false;
+  alive = true;
+  initializationOptions;
+  constructor(spec, rootPath, command) {
+    this.spec = spec;
+    this.rootPath = rootPath;
+    this.initializationOptions = command.initializationOptions ?? {};
+    this.proc = spawn3(command.command, command.args, {
+      cwd: rootPath,
+      stdio: ["pipe", "pipe", "ignore"],
+      env: getSafeToolEnv()
+    });
+    this.proc.on("error", () => this.markDead());
+    this.proc.on("exit", () => this.markDead());
+    const { stdout, stdin } = this.proc;
+    if (!stdout || !stdin) {
+      this.proc.kill("SIGKILL");
+      throw new Error(`failed to open stdio pipes for ${spec.id} language server`);
+    }
+    this.conn = new JsonRpcConnection(stdout, stdin);
+    this.conn.onNotification("textDocument/publishDiagnostics", (params) => {
+      const publish = params;
+      this.published.set(publish.uri, publish.diagnostics);
+      this.waiters = this.waiters.filter((waiter) => {
+        if (waiter.uri !== publish.uri)
+          return true;
+        waiter.resolve(publish.diagnostics);
+        return false;
+      });
+    });
+  }
+  get isAlive() {
+    return this.alive;
+  }
+  async initialize(timeoutMs) {
+    const rootUri = pathToFileURL(this.rootPath).href;
+    const result = await this.conn.request("initialize", {
+      processId: process.pid,
+      rootUri,
+      workspaceFolders: [{ uri: rootUri, name: "ggcoder" }],
+      initializationOptions: this.initializationOptions,
+      capabilities: {
+        textDocument: {
+          synchronization: { didSave: true },
+          publishDiagnostics: { relatedInformation: false },
+          diagnostic: { dynamicRegistration: false, relatedDocumentSupport: false }
+        },
+        workspace: { configuration: true, workspaceFolders: true }
+      }
+    }, timeoutMs);
+    this.hasPullDiagnostics = Boolean(result?.capabilities?.diagnosticProvider);
+    this.conn.notify("initialized", {});
+  }
+  /**
+   * Sync `content` into the server's overlay for `filePath` — didOpen the
+   * first time, didChange (full text) + didSave afterwards. Clears the
+   * push-diagnostics cache for the uri so a subsequent collect waits for a
+   * report computed against THIS content rather than a stale one.
+   */
+  syncDocument(filePath, content) {
+    const uri = pathToFileURL(filePath).href;
+    this.published.delete(uri);
+    const previousVersion = this.versions.get(uri);
+    if (previousVersion === void 0) {
+      this.versions.set(uri, 1);
+      this.conn.notify("textDocument/didOpen", {
+        textDocument: {
+          uri,
+          languageId: this.spec.languageIdFor(extensionOf(filePath)),
+          version: 1,
+          text: content
+        }
+      });
+    } else {
+      const version2 = previousVersion + 1;
+      this.versions.set(uri, version2);
+      this.conn.notify("textDocument/didChange", {
+        textDocument: { uri, version: version2 },
+        contentChanges: [{ text: content }]
+      });
+      this.conn.notify("textDocument/didSave", { textDocument: { uri }, text: content });
+    }
+    return uri;
+  }
+  /**
+   * Current diagnostics for `uri`, racing the push channel (next
+   * publishDiagnostics after the last sync) against a pull-diagnostics poll
+   * loop when the server supports LSP 3.17 pull. Returns null on timeout.
+   */
+  async collectDiagnostics(uri, timeoutMs) {
+    const push = this.waitForPublish(uri, timeoutMs);
+    if (!this.hasPullDiagnostics)
+      return push;
+    let stopped = false;
+    const pull = (async () => {
+      const deadline = Date.now() + timeoutMs;
+      while (!stopped && this.alive && Date.now() < deadline) {
+        const items = await this.pullDiagnostics(uri, Math.max(1, deadline - Date.now()));
+        if (items === "unsupported")
+          return push;
+        if (items !== "retry")
+          return items;
+        await sleep4(PULL_POLL_INTERVAL_MS);
+      }
+      return push;
+    })();
+    try {
+      return await Promise.race([push, pull]);
+    } finally {
+      stopped = true;
+    }
+  }
+  /**
+   * Graceful shutdown/exit handshake with SIGKILL fallback. Synchronous so it
+   * is safe inside `process.on("exit")` handlers: the shutdown request and
+   * exit notification are written immediately; the SIGKILL timer covers
+   * servers that ignore them (and stdin EOF reaps them when we die first).
+   */
+  shutdown() {
+    if (!this.alive)
+      return;
+    void this.conn.request("shutdown", null, SHUTDOWN_TIMEOUT_MS).catch(() => {
+    });
+    this.conn.notify("exit");
+    const killTimer = setTimeout(() => {
+      if (this.alive)
+        this.proc.kill("SIGKILL");
+    }, KILL_GRACE_MS);
+    killTimer.unref();
+  }
+  markDead() {
+    this.alive = false;
+    this.conn.dispose();
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const waiter of waiters)
+      waiter.resolve([]);
+  }
+  waitForPublish(uri, timeoutMs) {
+    const cached4 = this.published.get(uri);
+    if (cached4 !== void 0)
+      return Promise.resolve(cached4);
+    if (!this.alive)
+      return Promise.resolve(null);
+    return new Promise((resolve2) => {
+      const waiter = {
+        uri,
+        resolve: (diagnostics) => {
+          clearTimeout(timer);
+          resolve2(diagnostics);
+        }
+      };
+      const timer = setTimeout(() => {
+        this.waiters = this.waiters.filter((w) => w !== waiter);
+        resolve2(null);
+      }, timeoutMs);
+      timer.unref();
+      this.waiters.push(waiter);
+    });
+  }
+  async pullDiagnostics(uri, timeoutMs) {
+    try {
+      const report = await this.conn.request("textDocument/diagnostic", { textDocument: { uri } }, timeoutMs);
+      if (report?.kind === "full")
+        return report.items ?? [];
+      if (report?.kind === "unchanged")
+        return this.published.get(uri) ?? [];
+      return "unsupported";
+    } catch (error51) {
+      if (error51 instanceof JsonRpcRequestError) {
+        if (error51.code === SERVER_CANCELLED)
+          return "retry";
+        if (error51.code === METHOD_NOT_FOUND)
+          return "unsupported";
+      }
+      return "unsupported";
+    }
+  }
+};
+function extensionOf(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  return dot === -1 ? "" : filePath.slice(dot).toLowerCase();
+}
+
+// ../ggcoder/dist/core/lsp/format.js
+init_esm_shims();
+var SEVERITY_ERROR = 1;
+var MAX_DIAGNOSTICS = 5;
+function formatDiagnostics(relPath, diagnostics) {
+  const errors = diagnostics.filter((d) => (d.severity ?? SEVERITY_ERROR) === SEVERITY_ERROR);
+  if (errors.length === 0)
+    return "";
+  const lines = errors.slice(0, MAX_DIAGNOSTICS).map((d) => {
+    const line = d.range.start.line + 1;
+    const character = d.range.start.character + 1;
+    const message = d.message.split("\n")[0];
+    const source2 = d.source ? ` (${d.source})` : "";
+    return `L${line}:${character} ${message}${source2}`;
+  });
+  const overflow = errors.length > MAX_DIAGNOSTICS ? `
+\u2026and ${errors.length - MAX_DIAGNOSTICS} more error${errors.length - MAX_DIAGNOSTICS === 1 ? "" : "s"}` : "";
+  return `
+
+Diagnostics in ${relPath} (informational \u2014 may resolve after related edits):
+` + lines.join("\n") + overflow;
+}
+
+// ../ggcoder/dist/core/lsp/servers.js
+init_esm_shims();
+import fs7 from "fs";
+import path7 from "path";
+import { fileURLToPath } from "url";
+var WINDOWS_SUFFIXES = [".cmd", ".exe", ".bat"];
+function isExecutableFile(candidate) {
+  try {
+    const stat = fs7.statSync(candidate);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+function candidateNames(name) {
+  if (process.platform !== "win32")
+    return [name];
+  return [name, ...WINDOWS_SUFFIXES.map((suffix) => `${name}${suffix}`)];
+}
+var MODULE_DIR = path7.dirname(fileURLToPath(import.meta.url));
+function binDirsUpFrom(start) {
+  const dirs = [];
+  let dir = start;
+  for (; ; ) {
+    dirs.push(path7.join(dir, "node_modules", ".bin"));
+    const parent = path7.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return dirs;
+}
+function findExecutable(name, projectRoot) {
+  const names = candidateNames(name);
+  const binDirs = [...binDirsUpFrom(projectRoot), ...binDirsUpFrom(MODULE_DIR)];
+  for (const binDir of binDirs) {
+    for (const candidate of names) {
+      const binPath = path7.join(binDir, candidate);
+      if (isExecutableFile(binPath))
+        return binPath;
+    }
+  }
+  const pathEnv = process.env.PATH ?? "";
+  for (const pathDir of pathEnv.split(path7.delimiter)) {
+    if (!pathDir)
+      continue;
+    for (const candidate of names) {
+      const binPath = path7.join(pathDir, candidate);
+      if (isExecutableFile(binPath))
+        return binPath;
+    }
+  }
+  return null;
+}
+function findInNodeModulesUp(relPath, start) {
+  let dir = start;
+  for (; ; ) {
+    const candidate = path7.join(dir, "node_modules", relPath);
+    if (fs7.existsSync(candidate))
+      return candidate;
+    const parent = path7.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function findPackageBinScript(pkgName, binName, start) {
+  const pkgJsonPath = findInNodeModulesUp(path7.join(pkgName, "package.json"), start);
+  if (!pkgJsonPath)
+    return null;
+  try {
+    const pkg = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf8"));
+    const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[binName];
+    if (!bin)
+      return null;
+    const script = path7.join(path7.dirname(pkgJsonPath), bin);
+    return fs7.existsSync(script) ? script : null;
+  } catch {
+    return null;
+  }
+}
+function resolveNodeServer(pkgName, binName, projectRoot, args) {
+  const script = findPackageBinScript(pkgName, binName, projectRoot) ?? findPackageBinScript(pkgName, binName, MODULE_DIR);
+  if (script)
+    return { command: process.execPath, args: [script, ...args] };
+  const bin = findExecutable(binName, projectRoot);
+  return bin ? { command: bin, args } : null;
+}
+var TSSERVER_REL_PATH = path7.join("typescript", "lib", "tsserver.js");
+function projectTsserverPath(projectRoot) {
+  return findInNodeModulesUp(TSSERVER_REL_PATH, projectRoot);
+}
+function bundledTsserverPath() {
+  return findInNodeModulesUp(TSSERVER_REL_PATH, MODULE_DIR);
+}
+var TS_LANGUAGE_IDS = {
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "typescriptreact",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascriptreact"
+};
+var LSP_SERVER_CATALOG = [
+  {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
+    rootMarkers: [
+      "tsconfig.json",
+      "jsconfig.json",
+      "pnpm-lock.yaml",
+      "package-lock.json",
+      "yarn.lock",
+      "bun.lockb"
+    ],
+    languageIdFor: (extension) => TS_LANGUAGE_IDS[extension] ?? "typescript",
+    resolveCommand(projectRoot) {
+      const command = resolveNodeServer("typescript-language-server", "typescript-language-server", projectRoot, ["--stdio"]);
+      if (!command)
+        return null;
+      if (projectTsserverPath(projectRoot))
+        return command;
+      const tsserver = bundledTsserverPath();
+      if (!tsserver)
+        return null;
+      return { ...command, initializationOptions: { tsserver: { path: tsserver } } };
+    }
+  },
+  {
+    id: "python",
+    extensions: [".py"],
+    rootMarkers: [
+      "pyrightconfig.json",
+      "pyproject.toml",
+      "setup.py",
+      "setup.cfg",
+      "requirements.txt",
+      "Pipfile"
+    ],
+    languageIdFor: () => "python",
+    resolveCommand(projectRoot) {
+      return resolveNodeServer("pyright", "pyright-langserver", projectRoot, ["--stdio"]);
+    }
+  },
+  {
+    id: "go",
+    extensions: [".go"],
+    rootMarkers: ["go.mod"],
+    languageIdFor: () => "go",
+    resolveCommand(projectRoot) {
+      const bin = findExecutable("gopls", projectRoot);
+      return bin ? { command: bin, args: ["serve"] } : null;
+    }
+  },
+  {
+    id: "rust",
+    extensions: [".rs"],
+    rootMarkers: ["Cargo.toml"],
+    languageIdFor: () => "rust",
+    resolveCommand(projectRoot) {
+      const bin = findExecutable("rust-analyzer", projectRoot);
+      return bin ? { command: bin, args: [] } : null;
+    }
+  },
+  {
+    id: "clangd",
+    extensions: [".c", ".h", ".cc", ".cpp", ".cxx", ".hpp", ".hh"],
+    rootMarkers: ["compile_commands.json", ".clangd", "CMakeLists.txt"],
+    languageIdFor: (extension) => extension === ".c" || extension === ".h" ? "c" : "cpp",
+    resolveCommand(projectRoot) {
+      const bin = findExecutable("clangd", projectRoot);
+      return bin ? { command: bin, args: ["--log=error"] } : null;
+    }
+  }
+];
+function serverForFile(filePath, catalog = LSP_SERVER_CATALOG) {
+  const extension = path7.extname(filePath).toLowerCase();
+  if (!extension)
+    return null;
+  return catalog.find((spec) => spec.extensions.includes(extension)) ?? null;
+}
+function findProjectRoot(filePath, markers, ceiling) {
+  const fileDir = path7.dirname(path7.resolve(filePath));
+  const cap = path7.resolve(ceiling);
+  const underCeiling = fileDir === cap || fileDir.startsWith(cap + path7.sep);
+  let dir = fileDir;
+  for (; ; ) {
+    for (const marker of markers) {
+      try {
+        fs7.statSync(path7.join(dir, marker));
+        return dir;
+      } catch {
+      }
+    }
+    if (underCeiling && dir === cap)
+      break;
+    const parent = path7.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return fileDir;
+}
+
+// ../ggcoder/dist/core/lsp/manager.js
+var DEFAULT_WARM_BUDGET_MS = 3e3;
+var DEFAULT_FIRST_BUDGET_MS = 8e3;
+var INIT_TIMEOUT_MS = 1e4;
+var LspManager = class {
+  cwd;
+  catalog;
+  warmBudgetMs;
+  firstBudgetMs;
+  /** (serverId\0root) → in-flight or settled client; null = broken for session. */
+  clients = /* @__PURE__ */ new Map();
+  /** Keys that have completed at least one diagnostics pass (warm). */
+  warmKeys = /* @__PURE__ */ new Set();
+  shutDown = false;
+  constructor(cwd2, options) {
+    this.cwd = cwd2;
+    this.catalog = options?.catalog ?? LSP_SERVER_CATALOG;
+    this.warmBudgetMs = options?.warmBudgetMs ?? DEFAULT_WARM_BUDGET_MS;
+    this.firstBudgetMs = options?.firstBudgetMs ?? DEFAULT_FIRST_BUDGET_MS;
+  }
+  /**
+   * Diagnostics for `filePath` after its content became `content` on disk.
+   * Returns a formatted informational block, or "" when the file is clean,
+   * unsupported, or anything at all goes wrong (silent graceful degradation).
+   */
+  async diagnosticsAfterWrite(filePath, content) {
+    if (this.shutDown)
+      return "";
+    try {
+      const spec = serverForFile(filePath, this.catalog);
+      if (!spec)
+        return "";
+      const root = findProjectRoot(filePath, spec.rootMarkers, this.cwd);
+      const key = `${spec.id}\0${root}`;
+      const budgetMs = this.warmKeys.has(key) ? this.warmBudgetMs : this.firstBudgetMs;
+      const work = this.collect(key, spec, root, filePath, content, budgetMs);
+      return await withBudget(work, budgetMs);
+    } catch (error51) {
+      log("WARN", "lsp", `diagnostics failed for ${filePath}`, {
+        error: error51 instanceof Error ? error51.message : String(error51)
+      });
+      return "";
+    }
+  }
+  /** Shut down every pooled server. Safe in process exit handlers. */
+  shutdownAll() {
+    this.shutDown = true;
+    for (const pending of this.clients.values()) {
+      void pending.then((client) => client?.shutdown()).catch(() => {
+      });
+    }
+    this.clients.clear();
+    this.warmKeys.clear();
+  }
+  async collect(key, spec, root, filePath, content, budgetMs) {
+    const client = await this.ensureClient(key, spec, root);
+    if (!client)
+      return "";
+    if (!client.isAlive) {
+      this.clients.set(key, Promise.resolve(null));
+      log("WARN", "lsp", `${spec.id} server died`, { root });
+      return "";
+    }
+    const uri = client.syncDocument(path8.resolve(this.cwd, filePath), content);
+    const diagnostics = await client.collectDiagnostics(uri, budgetMs);
+    this.warmKeys.add(key);
+    if (diagnostics === null)
+      return "";
+    const relPath = path8.relative(this.cwd, path8.resolve(this.cwd, filePath));
+    return formatDiagnostics(relPath, diagnostics);
+  }
+  ensureClient(key, spec, root) {
+    const existing = this.clients.get(key);
+    if (existing)
+      return existing;
+    const pending = (async () => {
+      const command = spec.resolveCommand(root);
+      if (!command) {
+        log("INFO", "lsp", `${spec.id} language server not available`, { root });
+        return null;
+      }
+      try {
+        const startedAt = Date.now();
+        const client = new LspClient(spec, root, command);
+        await client.initialize(INIT_TIMEOUT_MS);
+        log("INFO", "lsp", `${spec.id} server initialized`, {
+          root,
+          ms: String(Date.now() - startedAt)
+        });
+        return client;
+      } catch (error51) {
+        log("WARN", "lsp", `${spec.id} server failed to start`, {
+          root,
+          error: error51 instanceof Error ? error51.message : String(error51)
+        });
+        return null;
+      }
+    })();
+    this.clients.set(key, pending);
+    return pending;
+  }
+};
+function withBudget(work, budgetMs) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => resolve2(""), budgetMs);
+    timer.unref();
+    work.then((result) => {
+      clearTimeout(timer);
+      resolve2(result);
+    }).catch(() => {
+      clearTimeout(timer);
+      resolve2("");
+    });
+  });
+}
+
 // ../ggcoder/dist/tools/read.js
 init_esm_shims();
-import fs11 from "fs/promises";
-import path10 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 
 // ../ggcoder/dist/tools/path-utils.js
 init_esm_shims();
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path9 from "path";
 import os4 from "os";
 function resolvePath(cwd2, filePath) {
   if (filePath.startsWith("~")) {
-    filePath = path7.join(os4.homedir(), filePath.slice(1));
+    filePath = path9.join(os4.homedir(), filePath.slice(1));
   }
-  return path7.resolve(cwd2, filePath);
+  return path9.resolve(cwd2, filePath);
 }
 async function rejectSymlink(resolved) {
   try {
-    const stat = await fs7.lstat(resolved);
+    const stat = await fs8.lstat(resolved);
     if (stat.isSymbolicLink()) {
       throw new Error(`Refusing to follow symlink: ${resolved}`);
     }
@@ -69369,34 +70059,34 @@ function truncateTail(content, maxLines = MAX_LINES, maxBytes = MAX_BYTES2) {
 
 // ../ggcoder/dist/tools/overflow.js
 init_esm_shims();
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 import os5 from "os";
-import path8 from "path";
+import path10 from "path";
 async function writeOverflow(content, prefix) {
-  const filePath = path8.join(os5.tmpdir(), `gg-${prefix}-${Date.now()}.txt`);
-  await fs8.writeFile(filePath, content, { encoding: "utf-8", mode: 384 });
+  const filePath = path10.join(os5.tmpdir(), `gg-${prefix}-${Date.now()}.txt`);
+  await fs9.writeFile(filePath, content, { encoding: "utf-8", mode: 384 });
   return filePath;
 }
 
 // ../ggcoder/dist/tools/operations.js
 init_esm_shims();
-import fs9 from "fs/promises";
-import { spawn as spawn3 } from "child_process";
+import fs10 from "fs/promises";
+import { spawn as spawn4 } from "child_process";
 import { createReadStream } from "fs";
 var localOperations = {
-  readFile: (path43) => fs9.readFile(path43, "utf-8"),
-  writeFile: async (path43, content) => {
+  readFile: (path45) => fs10.readFile(path45, "utf-8"),
+  writeFile: async (path45, content) => {
     const { dirname: dirname3 } = await import("path");
-    await fs9.mkdir(dirname3(path43), { recursive: true });
-    await fs9.writeFile(path43, content, "utf-8");
+    await fs10.mkdir(dirname3(path45), { recursive: true });
+    await fs10.writeFile(path45, content, "utf-8");
   },
-  stat: (path43) => fs9.stat(path43),
-  lstat: (path43) => fs9.lstat(path43),
-  readdir: (path43, options) => fs9.readdir(path43, options),
-  mkdir: (path43) => fs9.mkdir(path43, { recursive: true }).then(() => {
+  stat: (path45) => fs10.stat(path45),
+  lstat: (path45) => fs10.lstat(path45),
+  readdir: (path45, options) => fs10.readdir(path45, options),
+  mkdir: (path45) => fs10.mkdir(path45, { recursive: true }).then(() => {
   }),
-  createReadStream: (path43, encoding) => createReadStream(path43, { encoding }),
-  spawn: (command, args, options) => spawn3(command, args, {
+  createReadStream: (path45, encoding) => createReadStream(path45, { encoding }),
+  spawn: (command, args, options) => spawn4(command, args, {
     cwd: options.cwd,
     env: options.env,
     detached: options.detached,
@@ -69439,9 +70129,9 @@ async function assertFresh(tracker, resolvedPath, ops) {
 
 // ../ggcoder/dist/utils/image.js
 init_esm_shims();
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 import os6 from "os";
-import path9 from "path";
+import path11 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -69489,7 +70179,7 @@ async function compressVideoToFit(inputPath, targetBytes = COMPRESS_TARGET_BYTES
   }
   const totalKbps = Math.floor(targetBytes * 8 / durationSec / 1e3 * 0.9);
   const videoKbps = Math.max(COMPRESS_MIN_VIDEO_KBPS, totalKbps - COMPRESS_AUDIO_KBPS);
-  const outPath = path9.join(os6.tmpdir(), `ggcoder-compressed-${Date.now()}.mp4`);
+  const outPath = path11.join(os6.tmpdir(), `ggcoder-compressed-${Date.now()}.mp4`);
   try {
     await execFileAsync("ffmpeg", [
       "-y",
@@ -69517,7 +70207,7 @@ async function compressVideoToFit(inputPath, targetBytes = COMPRESS_TARGET_BYTES
       outPath
     ], { signal, maxBuffer: 16 * 1024 * 1024 });
   } catch (err) {
-    await fs10.unlink(outPath).catch(() => {
+    await fs11.unlink(outPath).catch(() => {
     });
     return {
       ok: false,
@@ -69527,15 +70217,15 @@ async function compressVideoToFit(inputPath, targetBytes = COMPRESS_TARGET_BYTES
   let compressedBytes;
   let originalBytes;
   try {
-    compressedBytes = (await fs10.stat(outPath)).size;
-    originalBytes = (await fs10.stat(inputPath)).size;
+    compressedBytes = (await fs11.stat(outPath)).size;
+    originalBytes = (await fs11.stat(inputPath)).size;
   } catch {
-    await fs10.unlink(outPath).catch(() => {
+    await fs11.unlink(outPath).catch(() => {
     });
     return { ok: false, reason: "compression produced no usable output" };
   }
   if (compressedBytes > targetBytes) {
-    await fs10.unlink(outPath).catch(() => {
+    await fs11.unlink(outPath).catch(() => {
     });
     return {
       ok: false,
@@ -69561,7 +70251,7 @@ var VIDEO_MEDIA_TYPES = {
 };
 var MEDIA_TYPES = IMAGE_MEDIA_TYPES;
 function isAttachablePath(filePath) {
-  const ext = path9.extname(filePath).toLowerCase();
+  const ext = path11.extname(filePath).toLowerCase();
   return ATTACHABLE_EXTENSIONS.has(ext);
 }
 function resolvePath2(filePath, cwd2) {
@@ -69574,9 +70264,9 @@ function resolvePath2(filePath, cwd2) {
   }
   resolved = resolved.replace(/\\(.)/g, "$1");
   if (resolved.startsWith("~/")) {
-    resolved = path9.join(process.env.HOME ?? "/", resolved.slice(2));
-  } else if (!path9.isAbsolute(resolved)) {
-    resolved = path9.join(cwd2, resolved);
+    resolved = path11.join(process.env.HOME ?? "/", resolved.slice(2));
+  } else if (!path11.isAbsolute(resolved)) {
+    resolved = path11.join(cwd2, resolved);
   }
   return resolved;
 }
@@ -69611,7 +70301,7 @@ async function extractImagePaths(text, cwd2) {
 var extractMediaPaths = extractImagePaths;
 async function fileExists(filePath) {
   try {
-    const stat = await fs10.stat(filePath);
+    const stat = await fs11.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -69689,13 +70379,13 @@ async function downscaleForPreview(buffer) {
   }
 }
 async function readImageFile(filePath) {
-  const ext = path9.extname(filePath).toLowerCase();
-  const fileName = path9.basename(filePath);
+  const ext = path11.extname(filePath).toLowerCase();
+  const fileName = path11.basename(filePath);
   if (VIDEO_EXTENSIONS.has(ext)) {
     try {
       const mediaType = VIDEO_MEDIA_TYPES[ext] ?? "video/mp4";
-      const stat = await fs10.stat(filePath);
-      const data = stat.size <= MAX_VIDEO_BYTES ? (await fs10.readFile(filePath)).toString("base64") : "";
+      const stat = await fs11.stat(filePath);
+      const data = stat.size <= MAX_VIDEO_BYTES ? (await fs11.readFile(filePath)).toString("base64") : "";
       return { kind: "video", fileName, filePath, mediaType, data };
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
@@ -69710,7 +70400,7 @@ async function readImageFile(filePath) {
   }
   if (TEXT_EXTENSIONS.has(ext)) {
     try {
-      const content = await fs10.readFile(filePath, "utf-8");
+      const content = await fs11.readFile(filePath, "utf-8");
       return { kind: "text", fileName, filePath, mediaType: "text/plain", data: content };
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
@@ -69725,7 +70415,7 @@ async function readImageFile(filePath) {
   }
   try {
     const mediaType = MEDIA_TYPES[ext] ?? "image/png";
-    const rawBuffer = await fs10.readFile(filePath);
+    const rawBuffer = await fs11.readFile(filePath);
     const { buffer, mediaType: finalMediaType } = await shrinkToFit(rawBuffer, mediaType);
     return {
       kind: "image",
@@ -69773,8 +70463,8 @@ function getClipboardImage() {
           return;
         }
         try {
-          const rawBuffer = await fs10.readFile(tmpPath);
-          await fs10.unlink(tmpPath).catch(() => {
+          const rawBuffer = await fs11.readFile(tmpPath);
+          await fs11.unlink(tmpPath).catch(() => {
           });
           const { buffer: finalBuffer, mediaType: finalMediaType } = await shrinkToFit(rawBuffer, mediaType);
           resolve2({
@@ -69855,10 +70545,10 @@ function createReadTool(cwd2, readFiles, ops = localOperations, onFileRead, vide
     async execute({ file_path, offset, limit: limit2 }, context) {
       const resolved = resolvePath(cwd2, file_path);
       await rejectSymlink(resolved);
-      const ext = path10.extname(resolved).toLowerCase();
+      const ext = path12.extname(resolved).toLowerCase();
       if (IMAGE_EXTENSIONS.has(ext)) {
         try {
-          const rawBuffer = await fs11.readFile(resolved);
+          const rawBuffer = await fs12.readFile(resolved);
           const mediaType = IMAGE_MEDIA_TYPES[ext] ?? "image/png";
           const { buffer, mediaType: finalMediaType } = await shrinkToFit(rawBuffer, mediaType);
           const resizedNote = buffer.length < rawBuffer.length ? ` (resized from ${rawBuffer.length} to ${buffer.length} bytes)` : "";
@@ -69908,7 +70598,7 @@ function createReadTool(cwd2, readFiles, ops = localOperations, onFileRead, vide
             videoPath = result2.path;
             note = ` (auto-compressed from ${(result2.originalBytes / (1024 * 1024)).toFixed(0)} MB to ${(result2.compressedBytes / (1024 * 1024)).toFixed(0)} MB for analysis)`;
           }
-          const rawBuffer = await fs11.readFile(videoPath);
+          const rawBuffer = await fs12.readFile(videoPath);
           const mediaType = VIDEO_MEDIA_TYPES[ext] ?? "video/mp4";
           return {
             content: [
@@ -69926,7 +70616,7 @@ function createReadTool(cwd2, readFiles, ops = localOperations, onFileRead, vide
           return `Could not read video ${resolved}: ${reason}`;
         } finally {
           if (compressedPath)
-            await fs11.unlink(compressedPath).catch(() => {
+            await fs12.unlink(compressedPath).catch(() => {
             });
         }
       }
@@ -69981,8 +70671,8 @@ init_esm_shims();
 
 // ../ggcoder/dist/tools/write.js
 init_esm_shims();
-import fs12 from "fs/promises";
-import path11 from "path";
+import fs13 from "fs/promises";
+import path13 from "path";
 
 // ../ggcoder/dist/core/runtime-mode.js
 init_esm_shims();
@@ -70004,7 +70694,7 @@ var WriteParams = external_exports.object({
   file_path: external_exports.string().describe("The file path to write to"),
   content: external_exports.string().describe("The content to write")
 });
-function createWriteTool(cwd2, readFiles, ops = localOperations, planModeRefOrOnFileMutated, onFileMutated, onPreFileMutation) {
+function createWriteTool(cwd2, readFiles, ops = localOperations, planModeRefOrOnFileMutated, onFileMutated, onPreFileMutation, getDiagnostics) {
   const planModeRef = isPlanModeRef(planModeRefOrOnFileMutated) ? planModeRefOrOnFileMutated : void 0;
   const mutationCallback = isMutationCallback(planModeRefOrOnFileMutated) ? planModeRefOrOnFileMutated : onFileMutated;
   return {
@@ -70016,12 +70706,12 @@ function createWriteTool(cwd2, readFiles, ops = localOperations, planModeRefOrOn
       const resolved = resolvePath(cwd2, file_path);
       await rejectSymlink(resolved);
       if (isPlanModeActive(planModeRef)) {
-        const plansDir = path11.join(cwd2, ".gg", "plans");
-        const relative = path11.relative(plansDir, resolved);
-        if (relative.startsWith("..") || path11.isAbsolute(relative)) {
+        const plansDir = path13.join(cwd2, ".gg", "plans");
+        const relative = path13.relative(plansDir, resolved);
+        if (relative.startsWith("..") || path13.isAbsolute(relative)) {
           return `Error: write is restricted in plan mode. You can only write to .gg/plans/. Got: ${file_path}`;
         }
-        await fs12.mkdir(plansDir, { recursive: true });
+        await fs13.mkdir(plansDir, { recursive: true });
       }
       if (readFiles) {
         const exists = await ops.stat(resolved).then(() => true, () => false);
@@ -70033,15 +70723,22 @@ function createWriteTool(cwd2, readFiles, ops = localOperations, planModeRefOrOn
       await ops.writeFile(resolved, content);
       await recordWrite(readFiles, resolved, content, ops);
       await mutationCallback?.(resolved);
+      let diagnosticsNote = "";
+      if (getDiagnostics) {
+        try {
+          diagnosticsNote = await getDiagnostics(resolved, content);
+        } catch {
+        }
+      }
       const lines = content.split("\n").length;
-      return `Wrote ${lines} lines to ${resolved}`;
+      return `Wrote ${lines} lines to ${resolved}` + diagnosticsNote;
     }
   };
 }
 
 // ../ggcoder/dist/tools/edit.js
 init_esm_shims();
-import path12 from "path";
+import path14 from "path";
 
 // ../ggcoder/dist/tools/edit-diff.js
 init_esm_shims();
@@ -70150,16 +70847,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path43, added, removed, oldPosInc, options) {
-    const last = path43.lastComponent;
+  addToPath(path45, added, removed, oldPosInc, options) {
+    const last = path45.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path43.oldPos + oldPosInc,
+        oldPos: path45.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path43.oldPos + oldPosInc,
+        oldPos: path45.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -70907,7 +71604,7 @@ function tryMatch(working, old, next, replaceAll) {
     newWorking: working.slice(0, match.index) + next + working.slice(match.index + match.matchLength)
   };
 }
-function createEditTool(cwd2, readFiles, ops = localOperations, planModeRefOrOnFileMutated, onFileMutated, onPreFileMutation) {
+function createEditTool(cwd2, readFiles, ops = localOperations, planModeRefOrOnFileMutated, onFileMutated, onPreFileMutation, getDiagnostics) {
   const planModeRef = isPlanModeRef2(planModeRefOrOnFileMutated) ? planModeRefOrOnFileMutated : void 0;
   const mutationCallback = isMutationCallback2(planModeRefOrOnFileMutated) ? planModeRefOrOnFileMutated : onFileMutated;
   return {
@@ -70926,7 +71623,7 @@ function createEditTool(cwd2, readFiles, ops = localOperations, planModeRefOrOnF
       const hasCRLF = original.includes("\r\n");
       const originalNormalized = hasCRLF ? original.replace(/\r\n/g, "\n") : original;
       let working = originalNormalized;
-      const fileName = path12.basename(resolved);
+      const fileName = path14.basename(resolved);
       const outcomes = new Array(edits.length);
       for (let i = 0; i < edits.length; i++) {
         const { old_text, new_text, replace_all } = edits[i];
@@ -71028,15 +71725,22 @@ ${f.closestSnippet}`;
 ` : "";
         throw new Error(header + formatFailures());
       }
-      const relPath = path12.relative(cwd2, resolved);
+      const relPath = path14.relative(cwd2, resolved);
       const diff3 = generateDiff(originalNormalized, working, relPath);
       const changed = working !== originalNormalized;
+      let diagnosticsNote = "";
       if (changed) {
         const finalContent = hasCRLF ? working.replace(/\n/g, "\r\n") : working;
         await onPreFileMutation?.(resolved);
         await ops.writeFile(resolved, finalContent);
         await recordWrite(readFiles, resolved, finalContent, ops);
         await mutationCallback?.(resolved);
+        if (getDiagnostics) {
+          try {
+            diagnosticsNote = await getDiagnostics(resolved, finalContent);
+          } catch {
+          }
+        }
       }
       if (failures.length === 0) {
         if (!changed) {
@@ -71044,13 +71748,13 @@ ${f.closestSnippet}`;
           return { content: summary2, details: { diff: diff3 } };
         }
         const summary = edits.length > 1 ? `Successfully applied ${edits.length} edits to ${relPath}.` : `Successfully replaced text in ${relPath}.`;
-        return { content: summary, details: { diff: diff3 } };
+        return { content: summary + diagnosticsNote, details: { diff: diff3 } };
       }
       const noun = failures.length === 1 ? "edit" : "edits";
       const content = `Applied ${successCount} of ${edits.length} edits to ${relPath}.
 ${failures.length} ${noun} skipped \u2014 re-issue ONLY these (the rest are already done, do not redo them):
 
-` + formatFailures();
+` + formatFailures() + diagnosticsNote;
       return { content, details: { diff: diff3 } };
     }
   };
@@ -71293,8 +71997,8 @@ Failed to spawn: ${err.message}`);
 
 // ../ggcoder/dist/tools/find.js
 init_esm_shims();
-import fs13 from "fs/promises";
-import path13 from "path";
+import fs14 from "fs/promises";
+import path15 from "path";
 var FindParams = external_exports.object({
   pattern: external_exports.string().describe("Glob pattern to match files (e.g. '**/*.ts', 'src/**/*.tsx')"),
   path: external_exports.string().optional().describe("Directory to search in (defaults to cwd)")
@@ -71340,7 +72044,7 @@ ${filtered.length} file(s) found`;
 }
 async function loadGitignore(dir) {
   try {
-    const content = await fs13.readFile(path13.join(dir, ".gitignore"), "utf-8");
+    const content = await fs14.readFile(path15.join(dir, ".gitignore"), "utf-8");
     return content.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
@@ -71350,7 +72054,7 @@ async function loadGitignore(dir) {
 // ../ggcoder/dist/tools/grep.js
 init_esm_shims();
 import readline from "readline";
-import path14 from "path";
+import path16 from "path";
 var GrepParams = external_exports.object({
   pattern: external_exports.string().describe("Search pattern (regex supported)"),
   path: external_exports.string().optional().describe("File or directory to search (defaults to cwd)"),
@@ -71406,10 +72110,10 @@ function createGrepTool(cwd2, ops = localOperations) {
         }
         scannedCandidates += 1;
         const entry = typeof item === "string" ? item : item.path;
-        const ext = path14.extname(entry).toLowerCase();
+        const ext = path16.extname(entry).toLowerCase();
         if (BINARY_EXTENSIONS.has(ext))
           continue;
-        const filePath = path14.join(dir, entry);
+        const filePath = path16.join(dir, entry);
         const fileResults = await searchFile(filePath, regex2, cwd2, maxResults - results.length, ops);
         results.push(...fileResults);
       }
@@ -71419,7 +72123,7 @@ function createGrepTool(cwd2, ops = localOperations) {
 }
 async function searchFile(filePath, regex2, cwd2, maxResults, ops) {
   const results = [];
-  const relPath = path14.relative(cwd2, filePath);
+  const relPath = path16.relative(cwd2, filePath);
   try {
     const fileStat = await ops.stat(filePath);
     if (fileStat.size > MAX_FILE_SIZE)
@@ -71481,7 +72185,7 @@ ${results.length} match(es) found`;
 
 // ../ggcoder/dist/tools/ls.js
 init_esm_shims();
-import path15 from "path";
+import path17 from "path";
 var LsParams = external_exports.object({
   path: external_exports.string().optional().describe("Directory path (defaults to cwd)"),
   all: external_exports.boolean().optional().describe("Show hidden files (default: false)")
@@ -71503,7 +72207,7 @@ function createLsTool(cwd2, ops = localOperations) {
       }
       for (const file2 of files) {
         try {
-          const stat = await ops.stat(path15.join(resolved, file2.name));
+          const stat = await ops.stat(path17.join(resolved, file2.name));
           const size = formatSize(stat.size);
           const type2 = file2.isSymbolicLink() ? "l" : "f";
           lines.push(`${type2}  ${size.padStart(8)}  ${file2.name}`);
@@ -71529,13 +72233,8 @@ function formatSize(bytes) {
 
 // ../ggcoder/dist/tools/subagent.js
 init_esm_shims();
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { createInterface } from "readline";
-
-// ../ggcoder/dist/core/logger.js
-init_esm_shims();
-
-// ../ggcoder/dist/tools/subagent.js
 var SUB_AGENT_MAX_TURNS = 10;
 var SUB_AGENT_MAX_OUTPUT_CHARS = 1e5;
 var SUB_AGENT_MAX_OUTPUT_LINES = 500;
@@ -71594,7 +72293,7 @@ ${agentList}` : "\n\nNo named agents configured.";
       }
       cliArgs.push(args.task);
       const binPath = process.argv[1];
-      const child = spawn4(process.execPath, [binPath, ...cliArgs], {
+      const child = spawn5(process.execPath, [binPath, ...cliArgs], {
         cwd: cwd2,
         stdio: ["ignore", "pipe", "pipe"],
         env: { ...process.env }
@@ -72987,9 +73686,9 @@ function createWebSearchTool() {
 
 // ../ggcoder/dist/tools/source-path.js
 init_esm_shims();
-import { spawn as spawn5 } from "child_process";
-import path16 from "path";
-import { fileURLToPath } from "url";
+import { spawn as spawn6 } from "child_process";
+import path18 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var SOURCE_PATH_TIMEOUT_MS = 12e4;
 var MAX_STDERR_CHARS = 1e4;
 var OPENSRC_BIN_ENV = "GG_CODER_OPENSRC_BIN";
@@ -73010,7 +73709,7 @@ function createSourcePathTool(cwd2) {
         cliArgs.push("--verbose");
       log("INFO", "source_path", "opensrc path start", { package: args.package, cwd: cwd2 });
       return new Promise((resolve2) => {
-        const child = spawn5(process.execPath, [opensrcBin, ...cliArgs], {
+        const child = spawn6(process.execPath, [opensrcBin, ...cliArgs], {
           cwd: cwd2,
           stdio: ["ignore", "pipe", "pipe"],
           env: getOpenSrcEnv()
@@ -73088,8 +73787,8 @@ function getBundledOpenSrcBinPath() {
   const override = process.env[OPENSRC_BIN_ENV]?.trim();
   if (override)
     return override;
-  const currentDir = path16.dirname(fileURLToPath(import.meta.url));
-  return path16.resolve(currentDir, "../../node_modules/opensrc/bin/opensrc.js");
+  const currentDir = path18.dirname(fileURLToPath2(import.meta.url));
+  return path18.resolve(currentDir, "../../node_modules/opensrc/bin/opensrc.js");
 }
 function getOpenSrcEnv() {
   return {
@@ -73337,7 +74036,7 @@ ${list}`;
 
 // ../ggcoder/dist/tools/screenshot.js
 init_esm_shims();
-import path17 from "path";
+import path19 from "path";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 var INSTALL_HINT = "Browser engine not installed. Add the optional dependency and download Chromium:\n  pnpm add -w playwright && npx playwright install chromium\nThen retry the screenshot.";
 var ActionInput = external_exports.object({
@@ -73375,7 +74074,7 @@ function isBrowserBinaryMissing(err) {
 }
 function defaultOutPath(cwd2) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return path17.join(cwd2, ".gg", "screenshots", `${stamp}.png`);
+  return path19.join(cwd2, ".gg", "screenshots", `${stamp}.png`);
 }
 async function runActions(page, actions) {
   for (const action of actions ?? []) {
@@ -73426,7 +74125,7 @@ function createScreenshotTool(cwd2) {
         await runActions(page, args.actions);
         const raw = await page.screenshot({ fullPage: args.full_page ?? false });
         context.signal.removeEventListener("abort", onAbort);
-        await mkdir2(path17.dirname(outPath), { recursive: true });
+        await mkdir2(path19.dirname(outPath), { recursive: true });
         await writeFile2(outPath, raw);
         const { buffer, mediaType } = await shrinkToFit(raw, "image/png");
         const previewBuffer = await downscaleForPreview(buffer);
@@ -73478,8 +74177,8 @@ function createEnterPlanTool(onEnterPlan) {
 
 // ../ggcoder/dist/tools/exit-plan.js
 init_esm_shims();
-import fs14 from "fs/promises";
-import path18 from "path";
+import fs15 from "fs/promises";
+import path20 from "path";
 var ExitPlanParams = external_exports.object({
   plan_path: external_exports.string().describe("Path to the plan markdown file; must be under .gg/plans/")
 });
@@ -73491,13 +74190,13 @@ function createExitPlanTool(cwd2, onExitPlan) {
     executionMode: "sequential",
     async execute({ plan_path }) {
       const resolved = resolvePath(cwd2, plan_path);
-      const plansDir = path18.join(cwd2, ".gg", "plans");
-      const relative = path18.relative(plansDir, resolved);
-      if (relative.startsWith("..") || path18.isAbsolute(relative)) {
+      const plansDir = path20.join(cwd2, ".gg", "plans");
+      const relative = path20.relative(plansDir, resolved);
+      if (relative.startsWith("..") || path20.isAbsolute(relative)) {
         return `Error: plan_path must be under .gg/plans/. Got: ${plan_path}`;
       }
       try {
-        const content = await fs14.readFile(resolved, "utf-8");
+        const content = await fs15.readFile(resolved, "utf-8");
         if (!content.trim()) {
           return "Error: Plan file is empty. Write your plan before calling exit_plan.";
         }
@@ -73515,11 +74214,14 @@ function createTools(cwd2, opts) {
   const processManager = new ProcessManager();
   const ops = opts?.operations ?? localOperations;
   const planModeRef = opts?.planModeRef;
+  const lspEnabled = (opts?.lspDiagnostics ?? true) && ops === localOperations;
+  const lspManager = lspEnabled ? new LspManager(cwd2) : void 0;
+  const getDiagnostics = lspManager ? (filePath, content) => lspManager.diagnosticsAfterWrite(filePath, content) : void 0;
   const videoByteLimit = opts?.model ? getVideoByteLimit(opts.model) : void 0;
   const tools = [
     createReadTool(cwd2, readFiles, ops, opts?.onFileRead, videoByteLimit),
-    createWriteTool(cwd2, readFiles, ops, planModeRef, opts?.onFileMutated, opts?.onPreFileMutation),
-    createEditTool(cwd2, readFiles, ops, planModeRef, opts?.onFileMutated, opts?.onPreFileMutation),
+    createWriteTool(cwd2, readFiles, ops, planModeRef, opts?.onFileMutated, opts?.onPreFileMutation, getDiagnostics),
+    createEditTool(cwd2, readFiles, ops, planModeRef, opts?.onFileMutated, opts?.onPreFileMutation, getDiagnostics),
     createBashTool(cwd2, processManager, ops, planModeRef),
     createFindTool(cwd2),
     createGrepTool(cwd2, ops),
@@ -73548,24 +74250,24 @@ function createTools(cwd2, opts) {
     tools.push(createExitPlanTool(cwd2, opts.onExitPlan));
   }
   const rebuildReadTool = (model) => createReadTool(cwd2, readFiles, ops, opts?.onFileRead, getVideoByteLimit(model));
-  return { tools, processManager, rebuildReadTool };
+  return { tools, processManager, rebuildReadTool, lspManager };
 }
 
 // ../ggcoder/dist/system-prompt.js
 init_esm_shims();
-import fs19 from "fs/promises";
-import path24 from "path";
+import fs20 from "fs/promises";
+import path26 from "path";
 
 // ../ggcoder/dist/core/skills.js
 init_esm_shims();
-import fs15 from "fs/promises";
-import path19 from "path";
+import fs16 from "fs/promises";
+import path21 from "path";
 async function discoverSkills(options) {
   const skills = [];
   const globalSkills = await loadSkillsFromDir(options.globalSkillsDir, "global");
   skills.push(...globalSkills);
   if (options.projectDir) {
-    const projectSkillsDir = path19.join(options.projectDir, ".gg", "skills");
+    const projectSkillsDir = path21.join(options.projectDir, ".gg", "skills");
     const projectSkills = await loadSkillsFromDir(projectSkillsDir, "project");
     skills.push(...projectSkills);
   }
@@ -73575,27 +74277,27 @@ async function loadSkillsFromDir(dir, source2) {
   const skills = [];
   let dirents;
   try {
-    dirents = await fs15.readdir(dir, { withFileTypes: true });
+    dirents = await fs16.readdir(dir, { withFileTypes: true });
   } catch {
     return skills;
   }
   for (const entry of dirents) {
-    const entryPath = path19.join(dir, entry.name);
+    const entryPath = path21.join(dir, entry.name);
     if (entry.isFile() && entry.name.endsWith(".md")) {
       try {
-        const content = await fs15.readFile(entryPath, "utf-8");
+        const content = await fs16.readFile(entryPath, "utf-8");
         const skill = parseSkillFile(content, source2);
         if (!skill.name)
-          skill.name = path19.basename(entry.name, ".md");
+          skill.name = path21.basename(entry.name, ".md");
         skills.push(skill);
       } catch {
       }
       continue;
     }
     if (entry.isDirectory()) {
-      const skillFile = path19.join(entryPath, "SKILL.md");
+      const skillFile = path21.join(entryPath, "SKILL.md");
       try {
-        const content = await fs15.readFile(skillFile, "utf-8");
+        const content = await fs16.readFile(skillFile, "utf-8");
         const skill = parseSkillFile(content, source2);
         if (!skill.name)
           skill.name = entry.name;
@@ -73695,13 +74397,13 @@ var DEFAULT_TOOL_NAMES = [
 
 // ../ggcoder/dist/core/style-packs/index.js
 init_esm_shims();
-import fs17 from "fs";
-import path21 from "path";
+import fs18 from "fs";
+import path24 from "path";
 
 // ../ggcoder/dist/core/language-detector.js
 init_esm_shims();
-import fs16 from "fs";
-import path20 from "path";
+import fs17 from "fs";
+import path23 from "path";
 var MARKERS = {
   typescript: { manifests: ["tsconfig.json"], extensions: [".ts", ".tsx", ".mts", ".cts"] },
   // JS is only flagged when there's a package.json AND no tsconfig — pure JS projects.
@@ -73989,11 +74691,11 @@ var PACKS = {
 
 // ../ggcoder/dist/core/style-packs/index.js
 function loadPack(id2, cwd2) {
-  const overridePath = path21.join(cwd2, ".gg", "styles", `${id2}.md`);
+  const overridePath = path24.join(cwd2, ".gg", "styles", `${id2}.md`);
   try {
-    const stat = fs17.statSync(overridePath);
+    const stat = fs18.statSync(overridePath);
     if (stat.isFile()) {
-      return fs17.readFileSync(overridePath, "utf-8").trim();
+      return fs18.readFileSync(overridePath, "utf-8").trim();
     }
   } catch {
   }
@@ -74032,8 +74734,8 @@ Universal rules for agent-written code:
 
 // ../ggcoder/dist/core/verify-commands.js
 init_esm_shims();
-import fs18 from "fs";
-import path23 from "path";
+import fs19 from "fs";
+import path25 from "path";
 function detectVerifyCommands(cwd2, active) {
   const cmds = [];
   if (active.has("typescript") || active.has("javascript")) {
@@ -74060,12 +74762,12 @@ function detectVerifyCommands(cwd2, active) {
       const testScript = pick2("test", "test:unit");
       if (testScript)
         cmds.push({ label: "test", command: `${runner} ${testScript}`, language: lang });
-    } else if (active.has("typescript") && fileExists2(path23.join(cwd2, "tsconfig.json"))) {
+    } else if (active.has("typescript") && fileExists2(path25.join(cwd2, "tsconfig.json"))) {
       cmds.push({ label: "typecheck", command: "tsc --noEmit", language: "typescript" });
     }
   }
   if (active.has("python")) {
-    const pyproject = readFileSafe(path23.join(cwd2, "pyproject.toml"));
+    const pyproject = readFileSafe(path25.join(cwd2, "pyproject.toml"));
     if (pyproject) {
       if (/\[tool\.ruff/.test(pyproject)) {
         cmds.push({ label: "lint", command: "ruff check .", language: "python" });
@@ -74097,10 +74799,10 @@ function detectVerifyCommands(cwd2, active) {
   }
   if (active.has("java") || active.has("kotlin")) {
     const lang = active.has("kotlin") ? "kotlin" : "java";
-    if (fileExists2(path23.join(cwd2, "gradlew"))) {
+    if (fileExists2(path25.join(cwd2, "gradlew"))) {
       cmds.push({ label: "build", command: "./gradlew build", language: lang });
       cmds.push({ label: "test", command: "./gradlew test", language: lang });
-    } else if (fileExists2(path23.join(cwd2, "pom.xml"))) {
+    } else if (fileExists2(path25.join(cwd2, "pom.xml"))) {
       cmds.push({ label: "verify", command: "mvn verify", language: lang });
     }
   }
@@ -74114,7 +74816,7 @@ function detectVerifyCommands(cwd2, active) {
     cmds.push({ label: "test", command: "dotnet test", language: "csharp" });
   }
   if (active.has("ruby")) {
-    if (fileExists2(path23.join(cwd2, "Gemfile"))) {
+    if (fileExists2(path25.join(cwd2, "Gemfile"))) {
       cmds.push({ label: "lint", command: "bundle exec rubocop", language: "ruby" });
       cmds.push({ label: "test", command: "bundle exec rspec", language: "ruby" });
     }
@@ -74124,7 +74826,7 @@ function detectVerifyCommands(cwd2, active) {
     cmds.push({ label: "test", command: "mix test", language: "elixir" });
   }
   if (active.has("php")) {
-    if (fileExists2(path23.join(cwd2, "composer.json"))) {
+    if (fileExists2(path25.join(cwd2, "composer.json"))) {
       cmds.push({ label: "test", command: "composer test", language: "php" });
     }
   }
@@ -74143,20 +74845,20 @@ function detectVerifyCommands(cwd2, active) {
 }
 function fileExists2(p) {
   try {
-    return fs18.statSync(p).isFile();
+    return fs19.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function readFileSafe(p) {
   try {
-    return fs18.readFileSync(p, "utf-8");
+    return fs19.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
 }
 function readPackageJsonScripts(cwd2) {
-  const raw = readFileSafe(path23.join(cwd2, "package.json"));
+  const raw = readFileSafe(path25.join(cwd2, "package.json"));
   if (!raw)
     return null;
   try {
@@ -74167,11 +74869,11 @@ function readPackageJsonScripts(cwd2) {
   }
 }
 function detectNodeRunner(cwd2) {
-  if (fileExists2(path23.join(cwd2, "pnpm-lock.yaml")))
+  if (fileExists2(path25.join(cwd2, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fileExists2(path23.join(cwd2, "yarn.lock")))
+  if (fileExists2(path25.join(cwd2, "yarn.lock")))
     return "yarn";
-  if (fileExists2(path23.join(cwd2, "bun.lockb")))
+  if (fileExists2(path25.join(cwd2, "bun.lockb")))
     return "bun";
   return "npm run";
 }
@@ -74278,7 +74980,7 @@ Explore with read/search/docs tools and read-only bash (e.g. \`git log\`, \`git
 async function renderApprovedPlanSection(approvedPlanPath) {
   if (!approvedPlanPath)
     return null;
-  const planContent = await fs19.readFile(approvedPlanPath, "utf-8").catch(() => null);
+  const planContent = await fs20.readFile(approvedPlanPath, "utf-8").catch(() => null);
   if (planContent === null)
     return null;
   if (!planContent.trim())
@@ -74331,17 +75033,17 @@ async function collectProjectContext(cwd2) {
   while (!visited.has(dir)) {
     visited.add(dir);
     for (const name of CONTEXT_FILES) {
-      const filePath = path24.join(dir, name);
+      const filePath = path26.join(dir, name);
       try {
-        const content = await fs19.readFile(filePath, "utf-8");
-        const relPath = path24.relative(cwd2, filePath) || name;
+        const content = await fs20.readFile(filePath, "utf-8");
+        const relPath = path26.relative(cwd2, filePath) || name;
         contextParts.push(`### ${relPath}
 
 ${content.trim()}`);
       } catch {
       }
     }
-    const parent = path24.dirname(dir);
+    const parent = path26.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -74407,11 +75109,11 @@ async function buildSystemPrompt(cwd2, skills, planMode, approvedPlanPath, toolN
 
 // ../ggcoder/dist/session.js
 init_esm_shims();
-import fs20 from "fs/promises";
-import path25 from "path";
+import fs21 from "fs/promises";
+import path27 from "path";
 import os7 from "os";
 import crypto4 from "crypto";
-var SESSION_DIR = path25.join(os7.homedir(), ".gg", "sessions");
+var SESSION_DIR = path27.join(os7.homedir(), ".gg", "sessions");
 
 // ../ggcoder/dist/core/index.js
 init_esm_shims();
@@ -74524,20 +75226,20 @@ init_esm_shims();
 
 // ../ggcoder/dist/core/settings-manager.js
 init_esm_shims();
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 
 // ../ggcoder/dist/config.js
 init_esm_shims();
-import path26 from "path";
-import fs21 from "fs/promises";
+import path28 from "path";
+import fs22 from "fs/promises";
 import fsSync from "fs";
 async function ensureAppDirs() {
   const paths = getAppPaths();
-  await fs21.mkdir(paths.agentDir, { recursive: true, mode: 448 });
-  await fs21.mkdir(paths.sessionsDir, { recursive: true, mode: 448 });
-  await fs21.mkdir(paths.skillsDir, { recursive: true, mode: 448 });
-  await fs21.mkdir(paths.extensionsDir, { recursive: true, mode: 448 });
-  await fs21.mkdir(paths.agentsDir, { recursive: true, mode: 448 });
+  await fs22.mkdir(paths.agentDir, { recursive: true, mode: 448 });
+  await fs22.mkdir(paths.sessionsDir, { recursive: true, mode: 448 });
+  await fs22.mkdir(paths.skillsDir, { recursive: true, mode: 448 });
+  await fs22.mkdir(paths.extensionsDir, { recursive: true, mode: 448 });
+  await fs22.mkdir(paths.agentsDir, { recursive: true, mode: 448 });
   await seedDefaultAgents(paths.agentsDir);
   await seedDefaultSkills(paths.skillsDir);
   return paths;
@@ -74594,11 +75296,11 @@ Rules:
 `
   };
   for (const [filename, content] of Object.entries(defaults2)) {
-    const filePath = path26.join(agentsDir, filename);
+    const filePath = path28.join(agentsDir, filename);
     try {
-      await fs21.access(filePath);
+      await fs22.access(filePath);
     } catch {
-      await fs21.writeFile(filePath, content, "utf-8");
+      await fs22.writeFile(filePath, content, "utf-8");
     }
   }
 }
@@ -74607,11 +75309,11 @@ async function seedDefaultSkills(skillsDir) {
     "find-skills.md": FIND_SKILLS_MD
   };
   for (const [filename, content] of Object.entries(defaults2)) {
-    const filePath = path26.join(skillsDir, filename);
+    const filePath = path28.join(skillsDir, filename);
     try {
-      await fs21.access(filePath);
+      await fs22.access(filePath);
     } catch {
-      await fs21.writeFile(filePath, content, "utf-8");
+      await fs22.writeFile(filePath, content, "utf-8");
     }
   }
 }
@@ -74730,6 +75432,8 @@ var SettingsSchema = external_exports.object({
   ]).default("auto"),
   showTokenUsage: external_exports.boolean().default(true),
   idealReviewEnabled: external_exports.boolean().default(true),
+  /** Append LSP diagnostics to edit/write tool results. */
+  lspDiagnostics: external_exports.boolean().default(true),
   enabledTools: external_exports.array(external_exports.string()).optional(),
   /** Delete session transcripts older than this many days at startup. 0 disables pruning. */
   sessionRetentionDays: external_exports.number().int().min(0).default(30)
@@ -74743,6 +75447,7 @@ var DEFAULT_SETTINGS = {
   theme: "auto",
   showTokenUsage: true,
   idealReviewEnabled: true,
+  lspDiagnostics: true,
   sessionRetentionDays: 30
 };
 var SettingsManager = class {
@@ -74754,7 +75459,7 @@ var SettingsManager = class {
   }
   async load() {
     try {
-      const content = await fs22.readFile(this.filePath, "utf-8");
+      const content = await fs23.readFile(this.filePath, "utf-8");
       const raw = JSON.parse(content);
       this.settings = SettingsSchema.parse({ ...DEFAULT_SETTINGS, ...raw });
     } catch {
@@ -74765,7 +75470,7 @@ var SettingsManager = class {
   }
   async save() {
     const content = JSON.stringify(this.settings, null, 2);
-    await fs22.writeFile(this.filePath, content, "utf-8");
+    await fs23.writeFile(this.filePath, content, "utf-8");
   }
   get(key) {
     return this.settings[key];
@@ -74781,10 +75486,10 @@ var SettingsManager = class {
 
 // ../ggcoder/dist/core/session-manager.js
 init_esm_shims();
-import fs23 from "fs/promises";
+import fs24 from "fs/promises";
 import { createReadStream as createReadStream2 } from "fs";
 import { createInterface as createInterface2 } from "readline";
-import path27 from "path";
+import path29 from "path";
 import crypto6 from "crypto";
 var DISPLAY_ITEM_CUSTOM_KIND = "display_item";
 function isCompletedItemLike(value) {
@@ -74819,15 +75524,15 @@ var SessionManager = class _SessionManager {
     this.onPersistError?.(err);
   }
   dirForCwd(cwd2) {
-    return path27.join(this.sessionsDir, encodeCwd(cwd2));
+    return path29.join(this.sessionsDir, encodeCwd(cwd2));
   }
   async create(cwd2, provider, model) {
     const id2 = crypto6.randomUUID();
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const dir = this.dirForCwd(cwd2);
-    await fs23.mkdir(dir, { recursive: true });
+    await fs24.mkdir(dir, { recursive: true });
     const fileName = `${timestamp.replace(/[:.]/g, "-")}_${id2.slice(0, 8)}.jsonl`;
-    const filePath = path27.join(dir, fileName);
+    const filePath = path29.join(dir, fileName);
     const header = {
       type: "session",
       version: 2,
@@ -74838,7 +75543,7 @@ var SessionManager = class _SessionManager {
       model,
       leafId: null
     };
-    await fs23.appendFile(filePath, JSON.stringify(header) + "\n", "utf-8");
+    await fs24.appendFile(filePath, JSON.stringify(header) + "\n", "utf-8");
     return { id: id2, path: filePath, header };
   }
   async load(sessionPath) {
@@ -74891,7 +75596,7 @@ var SessionManager = class _SessionManager {
     const dir = this.dirForCwd(cwd2);
     let files;
     try {
-      files = await fs23.readdir(dir);
+      files = await fs24.readdir(dir);
     } catch {
       return [];
     }
@@ -74899,7 +75604,7 @@ var SessionManager = class _SessionManager {
     for (const file2 of files) {
       if (!file2.endsWith(".jsonl"))
         continue;
-      const filePath = path27.join(dir, file2);
+      const filePath = path29.join(dir, file2);
       try {
         const rl = createInterface2({
           input: createReadStream2(filePath, { encoding: "utf-8" }),
@@ -74958,21 +75663,21 @@ var SessionManager = class _SessionManager {
     if (options.maxAgeDays <= 0)
       return result;
     const cutoffMs = Date.now() - options.maxAgeDays * 864e5;
-    const keep = new Set((options.keepPaths ?? []).map((p) => path27.resolve(p)));
+    const keep = new Set((options.keepPaths ?? []).map((p) => path29.resolve(p)));
     let cwdDirs;
     try {
-      cwdDirs = await fs23.readdir(this.sessionsDir);
+      cwdDirs = await fs24.readdir(this.sessionsDir);
     } catch {
       return result;
     }
     for (const dirName of cwdDirs) {
-      const dir = path27.join(this.sessionsDir, dirName);
+      const dir = path29.join(this.sessionsDir, dirName);
       let files;
       try {
-        const stat = await fs23.stat(dir);
+        const stat = await fs24.stat(dir);
         if (!stat.isDirectory())
           continue;
-        files = await fs23.readdir(dir);
+        files = await fs24.readdir(dir);
       } catch {
         continue;
       }
@@ -74980,14 +75685,14 @@ var SessionManager = class _SessionManager {
       for (const file2 of files) {
         if (!file2.endsWith(".jsonl"))
           continue;
-        const filePath = path27.join(dir, file2);
-        if (keep.has(path27.resolve(filePath)))
+        const filePath = path29.join(dir, file2);
+        if (keep.has(path29.resolve(filePath)))
           continue;
         try {
-          const stat = await fs23.stat(filePath);
+          const stat = await fs24.stat(filePath);
           if (stat.mtimeMs >= cutoffMs)
             continue;
-          await fs23.unlink(filePath);
+          await fs24.unlink(filePath);
           result.deletedFiles += 1;
           result.freedBytes += stat.size;
           remaining -= 1;
@@ -74995,7 +75700,7 @@ var SessionManager = class _SessionManager {
         }
       }
       if (remaining === 0) {
-        await fs23.rmdir(dir).catch(() => {
+        await fs24.rmdir(dir).catch(() => {
         });
       }
     }
@@ -75003,7 +75708,7 @@ var SessionManager = class _SessionManager {
   }
   async appendEntry(sessionPath, entry) {
     try {
-      await fs23.appendFile(sessionPath, JSON.stringify(entry) + "\n", "utf-8");
+      await fs24.appendFile(sessionPath, JSON.stringify(entry) + "\n", "utf-8");
     } catch (error51) {
       this.handlePersistError(error51, "appendEntry");
     }
@@ -75016,7 +75721,7 @@ var SessionManager = class _SessionManager {
     }
   }
   async updateLeafUnsafe(sessionPath, leafId) {
-    const fd2 = await fs23.open(sessionPath, "r+");
+    const fd2 = await fs24.open(sessionPath, "r+");
     try {
       const buf = Buffer.alloc(4096);
       const { bytesRead } = await fd2.read(buf, 0, 4096, 0);
@@ -75034,9 +75739,9 @@ var SessionManager = class _SessionManager {
         await fd2.write(newHeaderLine, 0, "utf-8");
       } else {
         await fd2.close();
-        const content = await fs23.readFile(sessionPath, "utf-8");
+        const content = await fs24.readFile(sessionPath, "utf-8");
         const firstNewline = content.indexOf("\n");
-        await fs23.writeFile(sessionPath, newHeaderLine + content.slice(firstNewline), "utf-8");
+        await fs24.writeFile(sessionPath, newHeaderLine + content.slice(firstNewline), "utf-8");
         return;
       }
     } finally {
@@ -75980,25 +76685,25 @@ function getPromptCommand(name) {
 
 // ../ggcoder/dist/core/custom-commands.js
 init_esm_shims();
-import fs24 from "fs/promises";
-import path28 from "path";
+import fs25 from "fs/promises";
+import path30 from "path";
 async function loadCustomCommands(cwd2) {
-  const commandsDir = path28.join(cwd2, ".gg", "commands");
+  const commandsDir = path30.join(cwd2, ".gg", "commands");
   const commands = [];
   let files;
   try {
-    files = await fs24.readdir(commandsDir);
+    files = await fs25.readdir(commandsDir);
   } catch {
     return commands;
   }
   for (const file2 of files) {
     if (!file2.endsWith(".md"))
       continue;
-    const filePath = path28.join(commandsDir, file2);
+    const filePath = path30.join(commandsDir, file2);
     try {
-      const raw = await fs24.readFile(filePath, "utf-8");
+      const raw = await fs25.readFile(filePath, "utf-8");
       const parsed = parseSkillFile(raw, "project");
-      const name = parsed.name || path28.basename(file2, ".md");
+      const name = parsed.name || path30.basename(file2, ".md");
       commands.push({
         name,
         description: parsed.description || `Custom command from .gg/commands/${file2}`,
@@ -76019,21 +76724,21 @@ init_esm_shims();
 
 // ../ggcoder/dist/core/extensions/loader.js
 init_esm_shims();
-import fs25 from "fs/promises";
-import path29 from "path";
+import fs26 from "fs/promises";
+import path31 from "path";
 var ExtensionLoader = class {
   loaded = [];
   async loadAll(extensionsDir, context) {
     let files;
     try {
-      files = await fs25.readdir(extensionsDir);
+      files = await fs26.readdir(extensionsDir);
     } catch {
       return;
     }
     for (const file2 of files) {
       if (!file2.endsWith(".js"))
         continue;
-      const filePath = path29.join(extensionsDir, file2);
+      const filePath = path31.join(extensionsDir, file2);
       try {
         const mod = await import(filePath);
         const factory = typeof mod.default === "function" ? mod.default : mod.createExtension;
@@ -82438,8 +83143,8 @@ init_esm_shims();
 
 // ../ggcoder/dist/core/mcp/store.js
 init_esm_shims();
-import path30 from "path";
-import fs26 from "fs/promises";
+import path33 from "path";
+import fs27 from "fs/promises";
 var StoredServerEntrySchema = external_exports.object({
   type: external_exports.enum(["stdio", "http", "streamable-http", "sse"]).optional(),
   url: external_exports.string().optional(),
@@ -82457,12 +83162,12 @@ function globalMcpPath() {
   return getAppPaths().mcpFile;
 }
 function projectMcpPath(cwd2) {
-  return path30.join(cwd2, ".gg", "mcp.json");
+  return path33.join(cwd2, ".gg", "mcp.json");
 }
 async function readMcpFile(filePath) {
   let content;
   try {
-    content = await fs26.readFile(filePath, "utf-8");
+    content = await fs27.readFile(filePath, "utf-8");
   } catch {
     return { mcpServers: {} };
   }
@@ -82565,12 +83270,12 @@ init_esm_shims();
 
 // ../ggcoder/dist/core/agents.js
 init_esm_shims();
-import fs27 from "fs/promises";
-import path31 from "path";
+import fs28 from "fs/promises";
+import path34 from "path";
 async function discoverAgents(options) {
   const agents = [];
   if (options.projectDir) {
-    const projectAgentsDir = path31.join(options.projectDir, ".gg", "agents");
+    const projectAgentsDir = path34.join(options.projectDir, ".gg", "agents");
     const projectAgents = await loadAgentsFromDir(projectAgentsDir, "project");
     agents.push(...projectAgents);
   }
@@ -82588,19 +83293,19 @@ async function loadAgentsFromDir(dir, source2) {
   const agents = [];
   let files;
   try {
-    files = await fs27.readdir(dir);
+    files = await fs28.readdir(dir);
   } catch {
     return agents;
   }
   for (const file2 of files) {
     if (!file2.endsWith(".md"))
       continue;
-    const filePath = path31.join(dir, file2);
+    const filePath = path34.join(dir, file2);
     try {
-      const content = await fs27.readFile(filePath, "utf-8");
+      const content = await fs28.readFile(filePath, "utf-8");
       const agent = parseAgentFile(content, source2);
       if (!agent.name) {
-        agent.name = path31.basename(file2, ".md");
+        agent.name = path34.basename(file2, ".md");
       }
       agents.push(agent);
     } catch {
@@ -82733,8 +83438,8 @@ var BUNDLED_AGENTS = [
 
 // ../ggcoder/dist/core/agent-session.js
 import crypto8 from "crypto";
-import fs28 from "fs/promises";
-import path33 from "path";
+import fs29 from "fs/promises";
+import path35 from "path";
 var AgentSession = class {
   eventBus = new EventBus();
   slashCommands = new SlashCommandRegistry();
@@ -82747,6 +83452,7 @@ var AgentSession = class {
   skills = [];
   cacheKeyLogged = false;
   processManager;
+  lspManager;
   mcpManager;
   provider;
   model;
@@ -82779,10 +83485,10 @@ var AgentSession = class {
     this.authStorage = new AuthStorage(paths.authFile);
     await this.authStorage.load();
     this.sessionManager = new SessionManager(paths.sessionsDir);
-    const localGGDir = path33.join(this.cwd, ".gg");
-    await fs28.mkdir(path33.join(localGGDir, "skills"), { recursive: true });
-    await fs28.mkdir(path33.join(localGGDir, "commands"), { recursive: true });
-    await fs28.mkdir(path33.join(localGGDir, "agents"), { recursive: true });
+    const localGGDir = path35.join(this.cwd, ".gg");
+    await fs29.mkdir(path35.join(localGGDir, "skills"), { recursive: true });
+    await fs29.mkdir(path35.join(localGGDir, "commands"), { recursive: true });
+    await fs29.mkdir(path35.join(localGGDir, "agents"), { recursive: true });
     this.skills = await discoverSkills({
       globalSkillsDir: paths.skillsDir,
       projectDir: this.cwd
@@ -82791,17 +83497,19 @@ var AgentSession = class {
       globalAgentsDir: paths.agentsDir,
       projectDir: this.cwd
     });
-    const { tools, processManager } = createTools(this.cwd, {
+    const { tools, processManager, lspManager } = createTools(this.cwd, {
       agents,
       skills: this.skills,
       provider: this.provider,
       model: this.model,
+      lspDiagnostics: this.settingsManager.get("lspDiagnostics"),
       // Lazy — sessionId isn't assigned yet when createTools() runs, so we
       // must defer reading the cache key until the sub-agent actually fires.
       getCacheKey: () => this.getPromptCacheKey()
     });
     this.tools = tools;
     this.processManager = processManager;
+    this.lspManager = lspManager;
     this.mcpManager = new MCPClientManager();
     try {
       let apiKey;
@@ -83134,6 +83842,7 @@ ${parsed.args}` : promptText;
   }
   async dispose() {
     this.processManager?.shutdownAll();
+    this.lspManager?.shutdownAll();
     await this.mcpManager?.dispose();
     await this.extensionLoader.deactivateAll();
     this.eventBus.removeAllListeners();
@@ -84008,7 +84717,7 @@ import process14 from "process";
 init_esm_shims();
 var import_react15 = __toESM(require_react(), 1);
 import process13 from "process";
-import fs31 from "fs";
+import fs32 from "fs";
 
 // ../../node_modules/.pnpm/es-toolkit@1.46.1/node_modules/es-toolkit/dist/compat/index.mjs
 init_esm_shims();
@@ -86201,7 +86910,7 @@ function wrapAnsi2(string4, columns, options) {
 init_esm_shims();
 import process5 from "process";
 import { execFileSync as execFileSync2 } from "child_process";
-import fs29 from "fs";
+import fs30 from "fs";
 import tty from "tty";
 var defaultColumns = 80;
 var defaultRows = 24;
@@ -86231,7 +86940,7 @@ var isForegroundProcess = () => {
     return true;
   }
   try {
-    const statContents = fs29.readFileSync("/proc/self/stat", "utf8");
+    const statContents = fs30.readFileSync("/proc/self/stat", "utf8");
     const closingParenthesisIndex = statContents.lastIndexOf(") ");
     if (closingParenthesisIndex === -1) {
       return false;
@@ -86275,8 +86984,8 @@ function terminalSize() {
 }
 var devTty = () => {
   try {
-    const flags = process5.platform === "darwin" ? fs29.constants.O_EVTONLY | fs29.constants.O_NONBLOCK : fs29.constants.O_NONBLOCK;
-    const { columns, rows } = tty.WriteStream(fs29.openSync("/dev/tty", flags));
+    const flags = process5.platform === "darwin" ? fs30.constants.O_EVTONLY | fs30.constants.O_NONBLOCK : fs30.constants.O_NONBLOCK;
+    const { columns, rows } = tty.WriteStream(fs30.openSync("/dev/tty", flags));
     return { columns, rows };
   } catch {
   }
@@ -88216,8 +88925,8 @@ var cleanupYogaNode = (node) => {
 var currentUpdatePriority = import_constants3.NoEventPriority;
 var currentRootNode;
 async function loadPackageJson() {
-  const fs37 = await import("fs");
-  const content = fs37.readFileSync(new URL("../package.json", import.meta.url), "utf8");
+  const fs38 = await import("fs");
+  const content = fs38.readFileSync(new URL("../package.json", import.meta.url), "utf8");
   return JSON.parse(content);
 }
 var packageJson = isDev() ? await loadPackageJson() : { name: void 0, version: void 0 };
@@ -89779,7 +90488,7 @@ var import_react13 = __toESM(require_react(), 1);
 init_esm_shims();
 var import_react12 = __toESM(require_react(), 1);
 var import_stack_utils = __toESM(require_stack_utils(), 1);
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import { cwd } from "process";
 
 // ../../node_modules/.pnpm/code-excerpt@4.0.0/node_modules/code-excerpt/dist/index.js
@@ -89907,8 +90616,8 @@ function Text({ color: color2, backgroundColor, dimColor = false, bold = false,
 }
 
 // ../../node_modules/.pnpm/@kenkaiiii+ink@6.8.0-gg.2_@types+react@19.2.14_react@19.2.5/node_modules/@kenkaiiii/ink/build/components/ErrorOverview.js
-var cleanupPath = (path43) => {
-  return path43?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path45) => {
+  return path45?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new import_stack_utils.default({
   cwd: cwd(),
@@ -89920,8 +90629,8 @@ function ErrorOverview({ error: error51 }) {
   const filePath = cleanupPath(origin?.file);
   let excerpt;
   let lineWidth = 0;
-  if (filePath && origin?.line && fs30.existsSync(filePath)) {
-    const sourceCode = fs30.readFileSync(filePath, "utf8");
+  if (filePath && origin?.line && fs31.existsSync(filePath)) {
+    const sourceCode = fs31.readFileSync(filePath, "utf8");
     excerpt = dist_default3(sourceCode, origin.line);
     if (excerpt) {
       for (const { line } of excerpt) {
@@ -90740,7 +91449,7 @@ var Ink = class {
       }
       if (process13.env["GG_INK_DEBUG"] === "1" && (delta !== 0 || this.framePadDebt > 0)) {
         try {
-          fs31.appendFileSync("/tmp/gg-ink-debug.log", JSON.stringify({
+          fs32.appendFileSync("/tmp/gg-ink-debug.log", JSON.stringify({
             t: Date.now() % 1e5,
             delta,
             ins: insertLineCount,
@@ -92576,9 +93285,9 @@ var taskBarStore = createStore({
 // ../ggcoder/dist/utils/sound.js
 init_esm_shims();
 import { execFile as execFile2 } from "child_process";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { resolve, dirname } from "path";
-var __dirname2 = dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname(fileURLToPath3(import.meta.url));
 var notificationPath = resolve(__dirname2, "../../assets/end-notification.mp3");
 
 // ../ggcoder/dist/ui/hooks/useAgentLoop.js
@@ -93196,8 +93905,8 @@ function shortenValue(value, maxLength = MAX_DETAIL_LENGTH) {
   const tailLength = maxLength - 1 - headLength;
   return `${normalized.slice(0, headLength)}\u2026${normalized.slice(-tailLength)}`;
 }
-function basename2(path43) {
-  const trimmed = path43.replace(/\/+$/u, "");
+function basename2(path45) {
+  const trimmed = path45.replace(/\/+$/u, "");
   return trimmed.split("/").filter(Boolean).at(-1) ?? trimmed;
 }
 function uniqueValues(values) {
@@ -108180,8 +108889,8 @@ function collapseSubmittedUserText(text) {
 }
 
 // ../ggcoder/dist/ui/terminal-history.js
-import path34 from "path";
-import { pathToFileURL } from "url";
+import path36 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
 
 // ../ggcoder/dist/ui/utils/terminal-graphics.js
 init_esm_shims();
@@ -110469,9 +111178,9 @@ init_esm_shims();
 import { execFile as execFile3 } from "child_process";
 import { readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname2, join as join3 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function resolveCliVersion() {
-  let dir = dirname2(fileURLToPath3(import.meta.url));
+  let dir = dirname2(fileURLToPath4(import.meta.url));
   for (let i = 0; i < 6; i++) {
     try {
       const manifest = JSON.parse(readFileSync5(join3(dir, "package.json"), "utf8"));
@@ -110537,11 +111246,11 @@ import { execFile as execFile4 } from "child_process";
 
 // ../ggcoder/dist/core/auto-update.js
 init_esm_shims();
-import path35 from "path";
+import path37 from "path";
 import os10 from "os";
 var updater = createAutoUpdater({
   packageName: "@kenkaiiii/ggcoder",
-  stateFilePath: () => path35.join(os10.homedir(), ".gg", "update-state.json")
+  stateFilePath: () => path37.join(os10.homedir(), ".gg", "update-state.json")
 });
 var checkAndAutoUpdate = updater.checkAndAutoUpdate;
 var getPendingUpdate = updater.getPendingUpdate;
@@ -110553,10 +111262,10 @@ init_esm_shims();
 
 // ../ggcoder/dist/core/setup-history.js
 init_esm_shims();
-import fs32 from "fs";
-import path36 from "path";
+import fs33 from "fs";
+import path38 from "path";
 import os11 from "os";
-var HISTORY_PATH = path36.join(os11.homedir(), ".gg", "setup-history.json");
+var HISTORY_PATH = path38.join(os11.homedir(), ".gg", "setup-history.json");
 
 // ../ggcoder/dist/ui/components/RewindOverlay.js
 init_esm_shims();
@@ -110806,7 +111515,7 @@ function MessageResponse({ children, height, accentColor }) {
 
 // ../ggcoder/dist/ui/utils/highlight.js
 init_esm_shims();
-import path37 from "path";
+import path39 from "path";
 var EXT_TO_LANG = {
   ts: "typescript",
   tsx: "typescript",
@@ -110834,7 +111543,7 @@ var EXT_TO_LANG = {
   dockerfile: "dockerfile"
 };
 function langFromPath(filePath) {
-  const ext = path37.extname(filePath).replace(/^\./, "").toLowerCase();
+  const ext = path39.extname(filePath).replace(/^\./, "").toLowerCase();
   return EXT_TO_LANG[ext];
 }
 var hlModule;
@@ -112944,17 +113653,17 @@ var EventQueue = class {
 
 // src/settings.ts
 init_esm_shims();
-import fs33 from "fs/promises";
-import path38 from "path";
+import fs34 from "fs/promises";
+import path40 from "path";
 function settingsPath() {
-  return path38.join(getAppPaths().agentDir, "boss", "settings.json");
+  return path40.join(getAppPaths().agentDir, "boss", "settings.json");
 }
 async function ensureDir() {
-  await fs33.mkdir(path38.dirname(settingsPath()), { recursive: true, mode: 448 });
+  await fs34.mkdir(path40.dirname(settingsPath()), { recursive: true, mode: 448 });
 }
 async function loadSettings() {
   try {
-    const content = await fs33.readFile(settingsPath(), "utf-8");
+    const content = await fs34.readFile(settingsPath(), "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed || typeof parsed !== "object") return {};
     return parsed;
@@ -112969,8 +113678,8 @@ async function saveSettings(patch) {
     const merged = { ...current, ...patch };
     await ensureDir();
     const tmp = `${settingsPath()}.${process.pid}.tmp`;
-    await fs33.writeFile(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
-    await fs33.rename(tmp, settingsPath());
+    await fs34.writeFile(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+    await fs34.rename(tmp, settingsPath());
   });
   writeChain = next.catch(() => void 0);
   await next;
@@ -113362,18 +114071,18 @@ init_esm_shims();
 // src/tasks-store.ts
 init_esm_shims();
 var import_react98 = __toESM(require_react(), 1);
-import fs34 from "fs/promises";
-import path39 from "path";
+import fs35 from "fs/promises";
+import path41 from "path";
 import crypto10 from "crypto";
 function getPlanPath() {
-  return path39.join(getAppPaths().agentDir, "boss", "plan.json");
+  return path41.join(getAppPaths().agentDir, "boss", "plan.json");
 }
 async function ensureDir2() {
-  await fs34.mkdir(path39.dirname(getPlanPath()), { recursive: true, mode: 448 });
+  await fs35.mkdir(path41.dirname(getPlanPath()), { recursive: true, mode: 448 });
 }
 async function loadPlan() {
   try {
-    const content = await fs34.readFile(getPlanPath(), "utf-8");
+    const content = await fs35.readFile(getPlanPath(), "utf-8");
     const parsed = JSON.parse(content);
     return Array.isArray(parsed.tasks) ? parsed.tasks : [];
   } catch {
@@ -113387,8 +114096,8 @@ async function persist(tasks) {
     await ensureDir2();
     const finalPath = getPlanPath();
     const tmpPath = `${finalPath}.${process.pid}.tmp`;
-    await fs34.writeFile(tmpPath, snapshot, "utf-8");
-    await fs34.rename(tmpPath, finalPath);
+    await fs35.writeFile(tmpPath, snapshot, "utf-8");
+    await fs35.rename(tmpPath, finalPath);
   });
   persistChain = next.catch(() => void 0);
   await next;
@@ -113656,13 +114365,13 @@ function createTaskTools(deps) {
 
 // src/audio.ts
 init_esm_shims();
-import { spawn as spawn7, execFileSync as execFileSync4 } from "child_process";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import path40 from "path";
-import fs35 from "fs";
+import { spawn as spawn8, execFileSync as execFileSync4 } from "child_process";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import path43 from "path";
+import fs36 from "fs";
 function readMp3DurationMs(file2) {
   try {
-    const buf = fs35.readFileSync(file2);
+    const buf = fs36.readFileSync(file2);
     let i = 0;
     if (buf.length >= 10 && buf[0] === 73 && buf[1] === 68 && buf[2] === 51) {
       const tagSize = (buf[6] & 127) << 21 | (buf[7] & 127) << 14 | (buf[8] & 127) << 7 | buf[9] & 127;
@@ -113719,10 +114428,10 @@ function getSplashAudioDurationMs() {
   return ms && ms > 0 ? ms : 1500;
 }
 function assetPath(name) {
-  const here = path40.dirname(fileURLToPath4(import.meta.url));
-  const dist = path40.join(here, name);
-  if (fs35.existsSync(dist)) return dist;
-  return path40.join(here, "..", "assets", name);
+  const here = path43.dirname(fileURLToPath5(import.meta.url));
+  const dist = path43.join(here, name);
+  if (fs36.existsSync(dist)) return dist;
+  return path43.join(here, "..", "assets", name);
 }
 function splashAssetPath() {
   return assetPath("splash.mp3");
@@ -113731,7 +114440,7 @@ function trySpawn(cmd, args) {
   return new Promise((resolve2) => {
     let resolved = false;
     try {
-      const child = spawn7(cmd, args, {
+      const child = spawn8(cmd, args, {
         detached: true,
         stdio: "ignore"
       });
@@ -113762,15 +114471,15 @@ function trySpawn(cmd, args) {
 }
 function isWsl() {
   if (process.platform !== "linux") return false;
-  return !!process.env.WSL_DISTRO_NAME || fs35.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop");
+  return !!process.env.WSL_DISTRO_NAME || fs36.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
 async function tryPlayOnWindowsHost(file2) {
   try {
-    const here = path40.dirname(fileURLToPath4(import.meta.url));
-    const devAssets = path40.resolve(here, "..", "assets");
-    const resolved = path40.resolve(file2);
-    const inDist = resolved === here || resolved.startsWith(here + path40.sep);
-    const inAssets = resolved === devAssets || resolved.startsWith(devAssets + path40.sep);
+    const here = path43.dirname(fileURLToPath5(import.meta.url));
+    const devAssets = path43.resolve(here, "..", "assets");
+    const resolved = path43.resolve(file2);
+    const inDist = resolved === here || resolved.startsWith(here + path43.sep);
+    const inAssets = resolved === devAssets || resolved.startsWith(devAssets + path43.sep);
     if (!inDist && !inAssets) {
       return false;
     }
@@ -113790,7 +114499,7 @@ async function tryPlayOnWindowsHost(file2) {
     return new Promise((resolve2) => {
       let resolved2 = false;
       try {
-        const child = spawn7(
+        const child = spawn8(
           "powershell.exe",
           ["-NoProfile", "-WindowStyle", "Hidden", "-Command", script],
           {
@@ -113834,7 +114543,7 @@ async function tryPlayOnWindowsHost(file2) {
   }
 }
 async function playFile(file2) {
-  if (!fs35.existsSync(file2)) return;
+  if (!fs36.existsSync(file2)) return;
   const platform2 = process.platform;
   if (platform2 === "darwin") {
     await trySpawn("afplay", [file2]);
@@ -113932,37 +114641,37 @@ function truncateOversizedToolResults2(messages, opts = {}) {
 
 // src/sessions.ts
 init_esm_shims();
-import fs36 from "fs/promises";
-import path41 from "path";
+import fs37 from "fs/promises";
+import path44 from "path";
 import crypto11 from "crypto";
 var BOSS_SUBDIR = "boss";
 var SESSIONS_SUBDIR = "sessions";
 function getBossDir() {
-  return path41.join(getAppPaths().agentDir, BOSS_SUBDIR);
+  return path44.join(getAppPaths().agentDir, BOSS_SUBDIR);
 }
 function getSessionsDir() {
-  return path41.join(getBossDir(), SESSIONS_SUBDIR);
+  return path44.join(getBossDir(), SESSIONS_SUBDIR);
 }
 async function ensureSessionsDir() {
   const dir = getSessionsDir();
-  await fs36.mkdir(dir, { recursive: true, mode: 448 });
+  await fs37.mkdir(dir, { recursive: true, mode: 448 });
   return dir;
 }
 async function createSession2() {
   await ensureSessionsDir();
   const id2 = `${Date.now()}-${crypto11.randomBytes(4).toString("hex")}`;
-  const filePath = path41.join(getSessionsDir(), `${id2}.jsonl`);
-  await fs36.writeFile(filePath, "", "utf-8");
+  const filePath = path44.join(getSessionsDir(), `${id2}.jsonl`);
+  await fs37.writeFile(filePath, "", "utf-8");
   return { id: id2, filePath };
 }
 async function appendMessages(filePath, msgs) {
   if (msgs.length === 0) return;
   const lines = msgs.map((m) => JSON.stringify(m)).join("\n") + "\n";
-  await fs36.appendFile(filePath, lines, "utf-8");
+  await fs37.appendFile(filePath, lines, "utf-8");
 }
 async function loadSession2(filePath) {
   try {
-    const content = await fs36.readFile(filePath, "utf-8");
+    const content = await fs37.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.length > 0);
     const messages = [];
     for (const line of lines) {
@@ -113978,8 +114687,8 @@ async function loadSession2(filePath) {
 }
 async function inspectSession(filePath, id2) {
   try {
-    const stat = await fs36.stat(filePath);
-    const content = await fs36.readFile(filePath, "utf-8");
+    const stat = await fs37.stat(filePath);
+    const content = await fs37.readFile(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.length > 0);
     let firstUserMessage;
     for (const line of lines) {
@@ -114012,7 +114721,7 @@ async function listSessions2() {
   await ensureSessionsDir();
   let entries;
   try {
-    entries = await fs36.readdir(getSessionsDir());
+    entries = await fs37.readdir(getSessionsDir());
   } catch {
     return [];
   }
@@ -114020,7 +114729,7 @@ async function listSessions2() {
   for (const name of entries) {
     if (!name.endsWith(".jsonl")) continue;
     const id2 = name.replace(/\.jsonl$/, "");
-    const info = await inspectSession(path41.join(getSessionsDir(), name), id2);
+    const info = await inspectSession(path44.join(getSessionsDir(), name), id2);
     if (info) infos.push(info);
   }
   infos.sort((a, b) => b.lastModified - a.lastModified);
@@ -114031,7 +114740,7 @@ async function getMostRecent() {
   return all[0] ?? null;
 }
 async function getSessionById(id2) {
-  const filePath = path41.join(getSessionsDir(), `${id2}.jsonl`);
+  const filePath = path44.join(getSessionsDir(), `${id2}.jsonl`);
   return inspectSession(filePath, id2);
 }
 
@@ -114985,4 +115694,4 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-OKATJ2SW.js.map
+//# sourceMappingURL=chunk-QDOB5CCW.js.map