fss-link 1.5.4 → 1.5.6

package/bundle/fss-link.js

@@ -397,14 +397,14 @@ async function authWithUserCode(client) {
   console.log("");
   console.log(authUrl);
   console.log("");
-  const code = await new Promise((resolve20) => {
+  const code = await new Promise((resolve19) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
     rl.question("Enter the authorization code: ", (code2) => {
       rl.close();
-      resolve20(code2.trim());
+      resolve19(code2.trim());
     });
   });
   if (!code) {
@@ -434,7 +434,7 @@ async function authWithWeb(client) {
     scope: OAUTH_SCOPE,
     state
   });
-  const loginCompletePromise = new Promise((resolve20, reject) => {
+  const loginCompletePromise = new Promise((resolve19, reject) => {
     const server = http.createServer(async (req, res) => {
       try {
         if (req.url.indexOf("/oauth2callback") === -1) {
@@ -463,7 +463,7 @@ async function authWithWeb(client) {
           }
           res.writeHead(HTTP_REDIRECT, { Location: SIGN_IN_SUCCESS_URL });
           res.end();
-          resolve20();
+          resolve19();
         } else {
           reject(new Error("No code found in request"));
         }
@@ -481,7 +481,7 @@ async function authWithWeb(client) {
   };
 }
 function getAvailablePort() {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve19, reject) => {
     let port = 0;
     try {
       const portStr = process.env["OAUTH_CALLBACK_PORT"];
@@ -490,7 +490,7 @@ function getAvailablePort() {
         if (isNaN(port) || port <= 0 || port > 65535) {
           return reject(new Error(`Invalid value for OAUTH_CALLBACK_PORT: "${portStr}"`));
         }
-        return resolve20(port);
+        return resolve19(port);
       }
       const server = net.createServer();
       server.listen(0, () => {
@@ -502,7 +502,7 @@ function getAvailablePort() {
         server.unref();
       });
       server.on("error", (e2) => reject(e2));
-      server.on("close", () => resolve20(port));
+      server.on("close", () => resolve19(port));
     } catch (e2) {
       reject(e2);
     }
@@ -3981,7 +3981,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve20.call(this, root, ref);
+      let _sch = resolve19.call(this, root, ref);
       if (_sch === void 0) {
         const schema2 = (_a4 = root.localRefs) === null || _a4 === void 0 ? void 0 : _a4[ref];
         const { schemaId } = this.opts;
@@ -4008,7 +4008,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve20(root, ref) {
+    function resolve19(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -4583,7 +4583,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve20(baseURI, relativeURI, options2) {
+    function resolve19(baseURI, relativeURI, options2) {
       const schemelessOptions = options2 ? Object.assign({ scheme: "null" }, options2) : { scheme: "null" };
       const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -4810,7 +4810,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize8,
-      resolve: resolve20,
+      resolve: resolve19,
       resolveComponent,
       equal,
       serialize: serialize2,
@@ -8855,7 +8855,7 @@ function defaultShouldRetry(error) {
   return false;
 }
 function delay(ms) {
-  return new Promise((resolve20) => setTimeout(resolve20, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 async function retryWithBackoff(fn, options2) {
   const { maxAttempts, initialDelayMs, maxDelayMs, onPersistent429, authType, shouldRetry } = {
@@ -10539,7 +10539,7 @@ var init_qwen_logger = __esm({
         this.events.clear();
         const rumPayload = await this.createRumPayload();
         rumPayload.events = eventsToSend;
-        const flushFn = () => new Promise((resolve20, reject) => {
+        const flushFn = () => new Promise((resolve19, reject) => {
           const body = safeJsonStringify(rumPayload);
           const options2 = {
             hostname: USAGE_STATS_HOSTNAME,
@@ -10562,7 +10562,7 @@ var init_qwen_logger = __esm({
               return reject(err);
             }
             res.on("data", (buf) => bufs.push(buf));
-            res.on("end", () => resolve20(Buffer2.concat(bufs)));
+            res.on("end", () => resolve19(Buffer2.concat(bufs)));
           });
           req.on("error", reject);
           req.end(body);
@@ -10891,8 +10891,8 @@ var init_file_exporters = __esm({
         return JSON.stringify(data, null, 2) + "\n";
       }
       shutdown() {
-        return new Promise((resolve20) => {
-          this.writeStream.end(resolve20);
+        return new Promise((resolve19) => {
+          this.writeStream.end(resolve19);
         });
       }
     };
@@ -11961,7 +11961,7 @@ var init_values = __esm({
 var sleep;
 var init_sleep = __esm({
   "node_modules/openai/internal/utils/sleep.mjs"() {
-    sleep = (ms) => new Promise((resolve20) => setTimeout(resolve20, ms));
+    sleep = (ms) => new Promise((resolve19) => setTimeout(resolve19, ms));
   }
 });
 
@@ -13116,8 +13116,8 @@ var init_api_promise = __esm({
     init_parse();
     APIPromise = class _APIPromise extends Promise {
       constructor(client, responsePromise, parseResponse2 = defaultParseResponse) {
-        super((resolve20) => {
-          resolve20(null);
+        super((resolve19) => {
+          resolve19(null);
         });
         this.responsePromise = responsePromise;
         this.parseResponse = parseResponse2;
@@ -13587,12 +13587,12 @@ var init_EventStream = __esm({
         _EventStream_errored.set(this, false);
         _EventStream_aborted.set(this, false);
         _EventStream_catchingPromiseCreated.set(this, false);
-        __classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve20, reject) => {
-          __classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve20, "f");
+        __classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve19, reject) => {
+          __classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve19, "f");
           __classPrivateFieldSet(this, _EventStream_rejectConnectedPromise, reject, "f");
         }), "f");
-        __classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve20, reject) => {
-          __classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve20, "f");
+        __classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve19, reject) => {
+          __classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve19, "f");
           __classPrivateFieldSet(this, _EventStream_rejectEndPromise, reject, "f");
         }), "f");
         __classPrivateFieldGet(this, _EventStream_connectedPromise, "f").catch(() => {
@@ -13676,11 +13676,11 @@ var init_EventStream = __esm({
        *   const message = await stream.emitted('message') // rejects if the stream errors
        */
       emitted(event) {
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve19, reject) => {
           __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
           if (event !== "error")
             this.once("error", reject);
-          this.once(event, resolve20);
+          this.once(event, resolve19);
         });
       }
       async done() {
@@ -14826,7 +14826,7 @@ var init_ChatCompletionStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve20, reject) => readQueue.push({ resolve: resolve20, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve19, reject) => readQueue.push({ resolve: resolve19, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -15634,7 +15634,7 @@ var init_AssistantStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve20, reject) => readQueue.push({ resolve: resolve20, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve19, reject) => readQueue.push({ resolve: resolve19, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
             }
             const chunk = pushQueue.shift();
             return { value: chunk, done: false };
@@ -17598,7 +17598,7 @@ var init_ResponseStream = __esm({
               if (done) {
                 return { value: void 0, done: true };
               }
-              return new Promise((resolve20, reject) => readQueue.push({ resolve: resolve20, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
+              return new Promise((resolve19, reject) => readQueue.push({ resolve: resolve19, reject })).then((event2) => event2 ? { value: event2, done: false } : { value: void 0, done: true });
             }
             const event = pushQueue.shift();
             return { value: event, done: false };
@@ -20707,11 +20707,20 @@ Streaming setup timeout troubleshooting:
               const functionCalls = [];
               const functionResponses = [];
               const textParts = [];
+              const imageParts = [];
               for (const part of content.parts || []) {
                 if (typeof part === "string") {
                   textParts.push(part);
                 } else if ("text" in part && part.text) {
                   textParts.push(part.text);
+                } else if ("inlineData" in part && part.inlineData) {
+                  imageParts.push({
+                    type: "image_url",
+                    image_url: {
+                      url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
+                      detail: "auto"
+                    }
+                  });
                 } else if ("functionCall" in part && part.functionCall) {
                   functionCalls.push(part.functionCall);
                 } else if ("functionResponse" in part && part.functionResponse) {
@@ -20726,6 +20735,14 @@ Streaming setup timeout troubleshooting:
                     content: typeof funcResponse.response === "string" ? funcResponse.response : JSON.stringify(funcResponse.response)
                   });
                 }
+                if (imageParts.length > 0) {
+                  const contentParts = [];
+                  const text = textParts.join("");
+                  if (text)
+                    contentParts.push({ type: "text", text });
+                  contentParts.push(...imageParts);
+                  messages.push({ role: "user", content: contentParts });
+                }
               } else if (content.role === "model" && functionCalls.length > 0) {
                 const toolCalls = functionCalls.map((fc, index) => ({
                   id: fc.id || `call_${index}`,
@@ -20743,7 +20760,13 @@ Streaming setup timeout troubleshooting:
               } else {
                 const role = content.role === "model" ? "assistant" : "user";
                 const text = textParts.join("");
-                if (text) {
+                if (role === "user" && imageParts.length > 0) {
+                  const contentParts = [];
+                  if (text)
+                    contentParts.push({ type: "text", text });
+                  contentParts.push(...imageParts);
+                  messages.push({ role, content: contentParts });
+                } else if (text) {
                   messages.push({ role, content: text });
                 }
               }
@@ -21652,7 +21675,7 @@ var init_sharedTokenManager = __esm({
               } catch (statError) {
                 console.warn(`Failed to stat lock file ${lockPath}: ${statError instanceof Error ? statError.message : String(statError)}`);
               }
-              await new Promise((resolve20) => setTimeout(resolve20, attemptInterval));
+              await new Promise((resolve19) => setTimeout(resolve19, attemptInterval));
             } else {
               throw new TokenManagerError(TokenError.FILE_ACCESS_ERROR, `Failed to create lock file: ${error instanceof Error ? error.message : String(error)}`, error);
             }
@@ -21928,19 +21951,19 @@ Server requested to slow down, increasing poll interval to ${pollInterval}ms'`);
           }
           qwenOAuth2Events.emit(QwenOAuth2Event.AuthProgress, "polling", `Polling... (attempt ${attempt + 1}/${maxAttempts})`);
           process.stdout.write(".");
-          await new Promise((resolve20) => {
+          await new Promise((resolve19) => {
             const checkInterval = 100;
             let elapsedTime = 0;
             const intervalId = setInterval(() => {
               elapsedTime += checkInterval;
               if (isCancelled) {
                 clearInterval(intervalId);
-                resolve20();
+                resolve19();
                 return;
               }
               if (elapsedTime >= pollInterval) {
                 clearInterval(intervalId);
-                resolve20();
+                resolve19();
                 return;
               }
             }, checkInterval);
@@ -21975,7 +21998,7 @@ Server requested to slow down, increasing poll interval to ${pollInterval}ms'`);
         if (isCancelled) {
           return { success: false, reason: "cancelled" };
         }
-        await new Promise((resolve20) => setTimeout(resolve20, pollInterval));
+        await new Promise((resolve19) => setTimeout(resolve19, pollInterval));
       }
     }
     const timeoutMessage = "Authorization timeout, please restart the process.";
@@ -22495,7 +22518,7 @@ async function createContentGeneratorConfig(config, authType) {
 async function createContentGenerator(config, gcConfig, sessionId2) {
   if (DEBUG_CONTENT)
     console.log(`\u{1F41B} DEBUG createContentGenerator: authType=${config.authType}, apiKey=${config.apiKey}, baseUrl=${config.baseUrl}`);
-  const version = "1.5.4";
+  const version = "1.5.6";
   const userAgent = `FSS-Link/${version} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent
@@ -23448,7 +23471,7 @@ var init_oauth_provider = __esm({
        * @returns Promise that resolves with the authorization code
        */
       static async startCallbackServer(expectedState) {
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve19, reject) => {
           const server = http2.createServer(async (req, res) => {
             try {
               const url2 = new URL3(req.url, `http://localhost:${this.REDIRECT_PORT}`);
@@ -23499,7 +23522,7 @@ var init_oauth_provider = __esm({
             </html>
           `);
               server.close();
-              resolve20({ code, state });
+              resolve19({ code, state });
             } catch (error) {
               server.close();
               reject(error);
@@ -24729,7 +24752,7 @@ var init_tool_registry = __esm({
         let error = null;
         let code = null;
         let signal = null;
-        await new Promise((resolve20) => {
+        await new Promise((resolve19) => {
           const onStdout = (data) => {
             stdout += data?.toString();
           };
@@ -24743,7 +24766,7 @@ var init_tool_registry = __esm({
             code = _code;
             signal = _signal2;
             cleanup();
-            resolve20();
+            resolve19();
           };
           const cleanup = () => {
             child.stdout.removeListener("data", onStdout);
@@ -24945,7 +24968,7 @@ Signal: Signal number or \`(none)\` if no signal was received.
             stderrByteLength += data.length;
             stderr += stderrDecoder.write(data);
           });
-          await new Promise((resolve20, reject) => {
+          await new Promise((resolve19, reject) => {
             proc2.on("error", reject);
             proc2.on("close", (code) => {
               stdout += stdoutDecoder.end();
@@ -24958,7 +24981,7 @@ Signal: Signal number or \`(none)\` if no signal was received.
                 console.error(stderr);
                 return reject(new Error(`Tool discovery command failed with exit code ${code}`));
               }
-              resolve20();
+              resolve19();
             });
           });
           const functions = [];
@@ -25245,32 +25268,22 @@ async function processSingleFileContent(filePath, rootDirectory, fileSystemServi
       }
       case "image": {
         const sizeStr = formatFileSize(fileSizeInBytes);
-        const mimeType = mime.lookup(filePath) || "image/*";
+        const mimeType = mime.lookup(filePath) || "image/jpeg";
+        const imageBuffer = await fs9.promises.readFile(filePath);
+        const base64Data = imageBuffer.toString("base64");
         return {
-          llmContent: `Cannot read image file with this tool: ${relativePathForDisplay}
-
-File details:
-- Type: ${mimeType}
-- Size: ${sizeStr}
-- Path: ${filePath}
-
-Images cannot be read with the read_file tool to prevent context overflow.
-Use a vision-capable model or bash tools (e.g., base64, file, identify) if available.`,
-          returnDisplay: `Skipped image file (${sizeStr}): ${relativePathForDisplay}`
+          llmContent: { inlineData: { mimeType, data: base64Data } },
+          returnDisplay: `Read image file (${sizeStr}): ${relativePathForDisplay}`
         };
       }
       case "pdf": {
         const sizeStr = formatFileSize(fileSizeInBytes);
+        const mimeType = "application/pdf";
+        const pdfBuffer = await fs9.promises.readFile(filePath);
+        const base64Data = pdfBuffer.toString("base64");
         return {
-          llmContent: `Cannot read PDF file with this tool: ${relativePathForDisplay}
-
-File details:
-- Type: PDF Document
-- Size: ${sizeStr}
-- Path: ${filePath}
-
-PDFs cannot be read with the read_file tool. Use the PDF parser tool for proper content extraction.`,
-          returnDisplay: `Skipped PDF file (${sizeStr}): ${relativePathForDisplay}`
+          llmContent: { inlineData: { mimeType, data: base64Data } },
+          returnDisplay: `Read pdf file (${sizeStr}): ${relativePathForDisplay}`
         };
       }
       case "audio":
@@ -25349,7 +25362,7 @@ function getFileTypeIcon(filePath, fileType) {
   return "\u{1F4C4}";
 }
 async function countLinesEfficiently(filePath, maxLines = 1e4) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve19) => {
     let lineCount = 0;
     const stream2 = fs9.createReadStream(filePath, { encoding: "utf-8" });
     let remainder = "";
@@ -25360,16 +25373,16 @@ async function countLinesEfficiently(filePath, maxLines = 1e4) {
       lineCount += lines.length;
       if (lineCount > maxLines) {
         stream2.destroy();
-        resolve20(void 0);
+        resolve19(void 0);
       }
     });
     stream2.on("end", () => {
       if (remainder)
         lineCount++;
-      resolve20(lineCount);
+      resolve19(lineCount);
     });
     stream2.on("error", () => {
-      resolve20(void 0);
+      resolve19(void 0);
     });
   });
 }
@@ -25925,31 +25938,6 @@ Output budget: ${budgetUsagePercent}% of ${(MAX_LS_OUTPUT_SIZE / 1024).toFixed(0
         });
         this.config = config;
       }
-      /**
-       * Check if execution needs user confirmation (e.g., for workspace boundary violations)
-       * @param abortSignal Signal to handle request cancellation
-       * @returns Confirmation details if needed, false otherwise
-       */
-      async shouldConfirmExecute(abortSignal) {
-        const workspaceContext = this.config.getWorkspaceContext();
-        const params = this.pendingToolCall?.params;
-        if (params?.path) {
-          const targetPath = path13.resolve(params.path);
-          if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
-            const details = {
-              attemptedPath: targetPath,
-              toolName: "list_directory",
-              operation: "list directory"
-            };
-            return createWorkspaceConfirmation(details, workspaceContext, async (outcome) => {
-              if (outcome === ToolConfirmationOutcome.ProceedAlways) {
-                workspaceContext.addDirectory(targetPath);
-              }
-            });
-          }
-        }
-        return false;
-      }
       /**
        * Validates the parameters for the tool
        * @param params Parameters to validate
@@ -29875,10 +29863,10 @@ var init_esm4 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve19, reject) => {
           this.on(DESTROYED, () => reject(new Error("stream destroyed")));
           this.on("error", (er) => reject(er));
-          this.on("end", () => resolve20());
+          this.on("end", () => resolve19());
         });
       }
       /**
@@ -29902,7 +29890,7 @@ var init_esm4 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve20;
+          let resolve19;
           let reject;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -29916,19 +29904,19 @@ var init_esm4 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve20({ value, done: !!this[EOF] });
+            resolve19({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve20({ done: true, value: void 0 });
+            resolve19({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject = rej;
-            resolve20 = res2;
+            resolve19 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -30908,9 +30896,9 @@ var init_esm5 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve20 = () => {
+          let resolve19 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve20 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve19 = res);
           try {
             for (const e2 of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -30923,7 +30911,7 @@ var init_esm5 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve20();
+          resolve19();
         }
         return children.slice(0, children.provisional);
       }
@@ -31153,8 +31141,8 @@ var init_esm5 = __esm({
        *
        * @internal
        */
-      constructor(cwd3 = process.cwd(), pathImpl, sep6, { nocase, childrenCacheSize = 16 * 1024, fs: fs73 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs73);
+      constructor(cwd3 = process.cwd(), pathImpl, sep6, { nocase, childrenCacheSize = 16 * 1024, fs: fs76 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs76);
         if (cwd3 instanceof URL || cwd3.startsWith("file://")) {
           cwd3 = fileURLToPath(cwd3);
         }
@@ -31712,8 +31700,8 @@ var init_esm5 = __esm({
       /**
        * @internal
        */
-      newRoot(fs73) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs73 });
+      newRoot(fs76) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs76 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -31741,8 +31729,8 @@ var init_esm5 = __esm({
       /**
        * @internal
        */
-      newRoot(fs73) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs73 });
+      newRoot(fs76) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs76 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -33401,7 +33389,7 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
        * @returns {Promise<boolean>} True if the command is available, false otherwise.
        */
       isCommandAvailable(command) {
-        return new Promise((resolve20) => {
+        return new Promise((resolve19) => {
           const checkCommand = process.platform === "win32" ? "where" : "command";
           const checkArgs = process.platform === "win32" ? [command] : ["-v", command];
           try {
@@ -33409,10 +33397,10 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
               stdio: "ignore",
               shell: process.platform === "win32"
             });
-            child.on("close", (code) => resolve20(code === 0));
-            child.on("error", () => resolve20(false));
+            child.on("close", (code) => resolve19(code === 0));
+            child.on("error", () => resolve19(false));
           } catch {
-            resolve20(false);
+            resolve19(false);
           }
         });
       }
@@ -33550,7 +33538,7 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
               gitArgs.push("--", include);
             }
             try {
-              const output = await new Promise((resolve20, reject) => {
+              const output = await new Promise((resolve19, reject) => {
                 const child = spawn2("git", gitArgs, {
                   cwd: absolutePath,
                   windowsHide: true
@@ -33572,9 +33560,9 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
                   const stdoutData = Buffer.concat(stdoutChunks).toString("utf8");
                   const stderrData = Buffer.concat(stderrChunks).toString("utf8");
                   if (code === 0)
-                    resolve20(stdoutData);
+                    resolve19(stdoutData);
                   else if (code === 1)
-                    resolve20("");
+                    resolve19("");
                   else
                     reject(new Error(`git grep exited with code ${code}: ${stderrData}`));
                 });
@@ -33610,7 +33598,7 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
             grepArgs.push(pattern);
             grepArgs.push(".");
             try {
-              const output = await new Promise((resolve20, reject) => {
+              const output = await new Promise((resolve19, reject) => {
                 const child = spawn2("grep", grepArgs, {
                   cwd: absolutePath,
                   windowsHide: true
@@ -33639,14 +33627,14 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
                   const stderrData = Buffer.concat(stderrChunks).toString("utf8").trim();
                   cleanup();
                   if (code === 0)
-                    resolve20(stdoutData);
+                    resolve19(stdoutData);
                   else if (code === 1)
-                    resolve20("");
+                    resolve19("");
                   else {
                     if (stderrData)
                       reject(new Error(`System grep exited with code ${code}: ${stderrData}`));
                     else
-                      resolve20("");
+                      resolve19("");
                   }
                 };
                 const cleanup = () => {
@@ -33792,7 +33780,7 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
               gitArgs.splice(4, 0, `-B${contextBefore}`);
             if (contextAfter > 0)
               gitArgs.splice(4, 0, `-A${contextAfter}`);
-            const output = await new Promise((resolve20, reject) => {
+            const output = await new Promise((resolve19, reject) => {
               const child = spawn2("git", gitArgs, { cwd: fileDir, windowsHide: true });
               const stdoutChunks = [];
               const stderrChunks = [];
@@ -33811,9 +33799,9 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
                 const stdoutData = Buffer.concat(stdoutChunks).toString("utf8");
                 const stderrData = Buffer.concat(stderrChunks).toString("utf8");
                 if (code === 0)
-                  resolve20(stdoutData);
+                  resolve19(stdoutData);
                 else if (code === 1)
-                  resolve20("");
+                  resolve19("");
                 else
                   reject(new Error(`git grep exited with code ${code}: ${stderrData}`));
               });
@@ -33834,7 +33822,7 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
               grepArgs.push(`-A${contextAfter}`);
             grepArgs.push(pattern);
             grepArgs.push(filePath);
-            const output = await new Promise((resolve20, reject) => {
+            const output = await new Promise((resolve19, reject) => {
               const child = spawn2("grep", grepArgs, { windowsHide: true });
               const stdoutChunks = [];
               const stderrChunks = [];
@@ -33853,9 +33841,9 @@ NOTE: Search stopped after processing ${processedMB} MB of content (approaching
                 const stdoutData = Buffer.concat(stdoutChunks).toString("utf8");
                 const stderrData = Buffer.concat(stderrChunks).toString("utf8");
                 if (code === 0)
-                  resolve20(stdoutData);
+                  resolve19(stdoutData);
                 else if (code === 1)
-                  resolve20("");
+                  resolve19("");
                 else
                   reject(new Error(`grep exited with code ${code}: ${stderrData}`));
               });
@@ -39851,8 +39839,8 @@ var init_ide_client = __esm({
        * - Closes the file
        */
       async openDiff(filePath, newContent) {
-        return new Promise((resolve20, reject) => {
-          this.diffResponses.set(filePath, resolve20);
+        return new Promise((resolve19, reject) => {
+          this.diffResponses.set(filePath, resolve19);
           this.client?.callTool({
             name: `openDiff`,
             arguments: {
@@ -40469,32 +40457,6 @@ Expectation for required parameters:
         });
         this.config = config;
       }
-      /**
-       * Check if execution needs user confirmation (e.g., for workspace boundary violations)
-       * @param abortSignal Signal to handle request cancellation
-       * @returns Confirmation details if needed, false otherwise
-       */
-      async shouldConfirmExecute(abortSignal) {
-        const workspaceContext = this.config.getWorkspaceContext();
-        const params = this.pendingToolCall?.params;
-        if (params?.file_path) {
-          const targetPath = path21.resolve(params.file_path);
-          if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
-            const details = {
-              attemptedPath: targetPath,
-              toolName: "replace",
-              operation: "edit file"
-            };
-            return createWorkspaceConfirmation(details, workspaceContext, async (outcome) => {
-              if (outcome === ToolConfirmationOutcome.ProceedAlways) {
-                const parentDir = path21.dirname(targetPath);
-                workspaceContext.addDirectory(parentDir);
-              }
-            });
-          }
-        }
-        return false;
-      }
       /**
        * Validates the parameters for the Edit tool
        * @param params Parameters to validate
@@ -46249,40 +46211,40 @@ var require_lib = __commonJS({
       return matches;
     };
     exports.analyse = analyse;
-    var detectFile = (filepath, opts = {}) => new Promise((resolve20, reject) => {
+    var detectFile = (filepath, opts = {}) => new Promise((resolve19, reject) => {
       let fd;
-      const fs73 = (0, node_1.default)();
+      const fs76 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs73.closeSync(fd);
+          fs76.closeSync(fd);
         }
         if (err) {
           reject(err);
         } else {
-          resolve20((0, exports.detect)(buffer));
+          resolve19((0, exports.detect)(buffer));
         }
       };
       if (opts && opts.sampleSize) {
-        fd = fs73.openSync(filepath, "r");
+        fd = fs76.openSync(filepath, "r");
         const sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs73.read(fd, sample, 0, opts.sampleSize, opts.offset, (err) => {
+        fs76.read(fd, sample, 0, opts.sampleSize, opts.offset, (err) => {
           handler(err, sample);
         });
         return;
       }
-      fs73.readFile(filepath, handler);
+      fs76.readFile(filepath, handler);
     });
     exports.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs73 = (0, node_1.default)();
+      const fs76 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs73.openSync(filepath, "r");
+        const fd = fs76.openSync(filepath, "r");
         const sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs73.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
-        fs73.closeSync(fd);
+        fs76.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        fs76.closeSync(fd);
         return (0, exports.detect)(sample);
       }
-      return (0, exports.detect)(fs73.readFileSync(filepath));
+      return (0, exports.detect)(fs76.readFileSync(filepath));
     };
     exports.detectFileSync = detectFileSync;
     exports.default = {
@@ -49895,7 +49857,7 @@ var init_shellExecutionService = __esm({
               PAGER: "cat"
             }
           });
-          const result = new Promise((resolve20) => {
+          const result = new Promise((resolve19) => {
             let stdoutDecoder = null;
             let stderrDecoder = null;
             let stdout = "";
@@ -49948,7 +49910,7 @@ var init_shellExecutionService = __esm({
               const { finalBuffer } = cleanup();
               const separator = stdout.endsWith("\n") ? "" : "\n";
               const combinedOutput = stdout + (stderr ? (stdout ? separator : "") + stderr : "");
-              resolve20({
+              resolve19({
                 rawOutput: finalBuffer,
                 output: combinedOutput.trim(),
                 exitCode: code,
@@ -50044,7 +50006,7 @@ var init_shellExecutionService = __esm({
             },
             handleFlowControl: true
           });
-          const result = new Promise((resolve20) => {
+          const result = new Promise((resolve19) => {
             const headlessTerminal = new Terminal({
               allowProposedApi: true,
               cols,
@@ -50060,7 +50022,7 @@ var init_shellExecutionService = __esm({
             const MAX_SNIFF_SIZE = 4096;
             let sniffedBytes = 0;
             const handleOutput = (data) => {
-              processingChain = processingChain.then(() => new Promise((resolve21) => {
+              processingChain = processingChain.then(() => new Promise((resolve20) => {
                 if (!decoder) {
                   const encoding = getCachedEncodingForBuffer(data);
                   try {
@@ -50084,7 +50046,7 @@ var init_shellExecutionService = __esm({
                     const newStrippedOutput = getFullText(headlessTerminal);
                     output = newStrippedOutput;
                     onOutputEvent({ type: "data", chunk: newStrippedOutput });
-                    resolve21();
+                    resolve20();
                   });
                 } else {
                   const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
@@ -50092,7 +50054,7 @@ var init_shellExecutionService = __esm({
                     type: "binary_progress",
                     bytesReceived: totalBytes
                   });
-                  resolve21();
+                  resolve20();
                 }
               }));
             };
@@ -50105,7 +50067,7 @@ var init_shellExecutionService = __esm({
               abortSignal.removeEventListener("abort", abortHandler);
               processingChain.then(() => {
                 const finalBuffer = Buffer.concat(outputChunks);
-                resolve20({
+                resolve19({
                   rawOutput: finalBuffer,
                   output,
                   exitCode,
@@ -51148,31 +51110,12 @@ Size change: ${sizeDelta > 0 ? "+" : ""}${sizeDelta} characters (${oldSize} \u21
         });
         this.config = config;
       }
-      /**
-       * Check if execution needs user confirmation (e.g., for workspace boundary violations)
-       * @param abortSignal Signal to handle request cancellation
-       * @returns Confirmation details if needed, false otherwise
-       */
-      async shouldConfirmExecute(abortSignal) {
-        const workspaceContext = this.config.getWorkspaceContext();
-        const params = this.pendingToolCall?.params;
-        if (params?.file_path) {
-          const targetPath = path23.resolve(params.file_path);
-          if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
-            const details = {
-              attemptedPath: targetPath,
-              toolName: "write_file",
-              operation: "write file"
-            };
-            return createWorkspaceConfirmation(details, workspaceContext, async (outcome) => {
-              if (outcome === ToolConfirmationOutcome.ProceedAlways) {
-                const parentDir = path23.dirname(targetPath);
-                workspaceContext.addDirectory(parentDir);
-              }
-            });
-          }
+      validateToolParams(params) {
+        const raw = params;
+        if (raw["content"] !== void 0 && typeof raw["content"] !== "string") {
+          raw["content"] = typeof raw["content"] === "object" ? JSON.stringify(raw["content"], null, 2) : String(raw["content"]);
         }
-        return false;
+        return super.validateToolParams(params);
       }
       validateToolParamValues(params) {
         const filePath = params.file_path;
@@ -58064,19 +58007,19 @@ function pLimit(concurrency) {
       queue.dequeue()();
     }
   };
-  const run = async (function_, resolve20, arguments_) => {
+  const run = async (function_, resolve19, arguments_) => {
     activeCount++;
     const result = (async () => function_(...arguments_))();
-    resolve20(result);
+    resolve19(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (function_, resolve20, arguments_) => {
+  const enqueue = (function_, resolve19, arguments_) => {
     queue.enqueue(
-      AsyncResource.bind(run.bind(void 0, function_, resolve20, arguments_))
+      AsyncResource.bind(run.bind(void 0, function_, resolve19, arguments_))
     );
     (async () => {
       await Promise.resolve();
@@ -58085,8 +58028,8 @@ function pLimit(concurrency) {
       }
     })();
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve20) => {
-    enqueue(function_, resolve20, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve19) => {
+    enqueue(function_, resolve19, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -60570,7 +60513,7 @@ var init_webScraperService = __esm({
             }
             if (attempt < maxRetries) {
               const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
-              await new Promise((resolve20) => setTimeout(resolve20, backoffMs));
+              await new Promise((resolve19) => setTimeout(resolve19, backoffMs));
             }
           }
         }
@@ -60720,7 +60663,7 @@ ${content.content}`;
         const timeSinceLastRequest = now - lastRequest;
         if (timeSinceLastRequest < minDelay) {
           const waitTime = minDelay - timeSinceLastRequest;
-          await new Promise((resolve20) => setTimeout(resolve20, waitTime));
+          await new Promise((resolve19) => setTimeout(resolve19, waitTime));
         }
         this.rateLimiter.set(domain, Date.now());
       }
@@ -61300,7 +61243,7 @@ var init_tts_tool = __esm({
           if (process.env["FSS_DEBUG"] === "true") {
             console.log(`[TTS DEBUG] Request body: ${JSON.stringify(requestBody, null, 2)}`);
           }
-          const response = await fetch("http://192.168.1.5:11450/api/v1/synthesize", {
+          const response = await fetch("http://tts.internal.bobai.com.au:11450/api/v1/synthesize", {
             method: "POST",
             headers: {
               "Content-Type": "application/json"
@@ -67920,7 +67863,7 @@ var init_memory_tracker = __esm({
       async forceGC() {
         if (global.gc) {
           global.gc();
-          await new Promise((resolve20) => setTimeout(resolve20, 10));
+          await new Promise((resolve19) => setTimeout(resolve19, 10));
         }
       }
       /**
@@ -68496,7 +68439,7 @@ var init_excel_parser = __esm({
         }
       }
       async parseCsvFile(filePath, delimiter2 = ",") {
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve19, reject) => {
           const data = [];
           const fileStream = fs27.createReadStream(filePath);
           fileStream.pipe(parse3({
@@ -68517,7 +68460,7 @@ var init_excel_parser = __esm({
               rowCount: data.length,
               columnCount: data[0]?.length || 0
             };
-            resolve20({
+            resolve19({
               sheets: { "Sheet1": sheetData }
             });
           }).on("error", reject);
@@ -68856,7 +68799,7 @@ Perfect for:
       }
       async validateFile(filePath) {
         const config = DEFAULT_PARSER_CONFIGS["excel"];
-        const stats = await import("fs/promises").then((fs73) => fs73.stat(filePath));
+        const stats = await import("fs/promises").then((fs76) => fs76.stat(filePath));
         if (!stats.isFile()) {
           throw new Error(`Path is not a file: ${filePath}`);
         }
@@ -68878,8 +68821,8 @@ Perfect for:
         }
         const backupPath = `${filePath}.backup.${Date.now()}`;
         try {
-          const fs73 = await import("fs/promises");
-          await fs73.copyFile(filePath, backupPath);
+          const fs76 = await import("fs/promises");
+          await fs76.copyFile(filePath, backupPath);
           return backupPath;
         } catch (error) {
           console.warn(`Failed to create backup: ${error}`);
@@ -68887,8 +68830,8 @@ Perfect for:
         }
       }
       async getFileSize(filePath) {
-        const fs73 = await import("fs/promises");
-        const stats = await fs73.stat(filePath);
+        const fs76 = await import("fs/promises");
+        const stats = await fs76.stat(filePath);
         return stats.size;
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -69145,7 +69088,7 @@ var init_word_parser = __esm({
         return result;
       }
       async extractDocxContent(filePath) {
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve19, reject) => {
           const content = {};
           yauzl.open(filePath, { lazyEntries: true }, (err, zipfile) => {
             if (err || !zipfile) {
@@ -69176,7 +69119,7 @@ var init_word_parser = __esm({
               }
             });
             zipfile.on("end", () => {
-              resolve20(content);
+              resolve19(content);
             });
             zipfile.on("error", (err2) => {
               reject(err2);
@@ -69308,8 +69251,8 @@ var init_word_parser = __esm({
           throw new Error(`Failed to parse document: ${result.errors?.join("; ")}`);
         }
         const convertedContent = await this.convertToFormat(result.content || "", format, result.metadata);
-        const fs73 = await import("fs/promises");
-        await fs73.writeFile(outputPath, convertedContent, "utf8");
+        const fs76 = await import("fs/promises");
+        await fs76.writeFile(outputPath, convertedContent, "utf8");
       }
       /**
        * Read and convert document to markdown file
@@ -69534,7 +69477,7 @@ Perfect for:
       }
       async validateFile(filePath) {
         const config = DEFAULT_PARSER_CONFIGS["word"];
-        const stats = await import("fs/promises").then((fs73) => fs73.stat(filePath));
+        const stats = await import("fs/promises").then((fs76) => fs76.stat(filePath));
         if (!stats.isFile()) {
           throw new Error(`Path is not a file: ${filePath}`);
         }
@@ -69556,8 +69499,8 @@ Perfect for:
         }
         const backupPath = `${filePath}.backup.${Date.now()}`;
         try {
-          const fs73 = await import("fs/promises");
-          await fs73.copyFile(filePath, backupPath);
+          const fs76 = await import("fs/promises");
+          await fs76.copyFile(filePath, backupPath);
           return backupPath;
         } catch (error) {
           console.warn(`Failed to create backup: ${error}`);
@@ -69565,8 +69508,8 @@ Perfect for:
         }
       }
       async getFileSize(filePath) {
-        const fs73 = await import("fs/promises");
-        const stats = await fs73.stat(filePath);
+        const fs76 = await import("fs/promises");
+        const stats = await fs76.stat(filePath);
         return stats.size;
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -69693,7 +69636,7 @@ Perfect for:
           this.validateFormat(this.params.file_path);
           const backupPath = await this.createBackup(this.params.file_path);
           const pdfParse = await import("pdf-parse");
-          const fs73 = await import("fs/promises");
+          const fs76 = await import("fs/promises");
           const parseOptions = {};
           if (this.params.options?.password) {
             parseOptions.password = this.params.options.password;
@@ -69701,7 +69644,7 @@ Perfect for:
           if (this.params.options?.max_pages) {
             parseOptions.max = this.params.options.max_pages;
           }
-          const pdfBuffer = await fs73.readFile(this.params.file_path);
+          const pdfBuffer = await fs76.readFile(this.params.file_path);
           const pdfData = await pdfParse.default(pdfBuffer, parseOptions);
           const metadata = {
             pageCount: pdfData.numpages,
@@ -69756,7 +69699,7 @@ Perfect for:
       }
       async validateFile(filePath) {
         const config = DEFAULT_PARSER_CONFIGS["pdf"];
-        const stats = await import("fs/promises").then((fs73) => fs73.stat(filePath));
+        const stats = await import("fs/promises").then((fs76) => fs76.stat(filePath));
         if (!stats.isFile()) {
           throw new Error(`Path is not a file: ${filePath}`);
         }
@@ -69778,8 +69721,8 @@ Perfect for:
         }
         const backupPath = `${filePath}.backup.${Date.now()}`;
         try {
-          const fs73 = await import("fs/promises");
-          await fs73.copyFile(filePath, backupPath);
+          const fs76 = await import("fs/promises");
+          await fs76.copyFile(filePath, backupPath);
           return backupPath;
         } catch (error) {
           console.warn(`Failed to create backup: ${error}`);
@@ -69787,8 +69730,8 @@ Perfect for:
         }
       }
       async getFileSize(filePath) {
-        const fs73 = await import("fs/promises");
-        const stats = await fs73.stat(filePath);
+        const fs76 = await import("fs/promises");
+        const stats = await fs76.stat(filePath);
         return stats.size;
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -71358,8 +71301,8 @@ var init_geminiChat = __esm({
       async sendMessageStream(params, prompt_id) {
         await this.sendPromise;
         let streamDoneResolver;
-        const streamDonePromise = new Promise((resolve20) => {
-          streamDoneResolver = resolve20;
+        const streamDonePromise = new Promise((resolve19) => {
+          streamDoneResolver = resolve19;
         });
         this.sendPromise = streamDonePromise;
         const userContent = createUserContent(params.message);
@@ -73213,12 +73156,12 @@ var init_gitService = __esm({
         this.setupShadowGitRepository();
       }
       verifyGitAvailability() {
-        return new Promise((resolve20) => {
+        return new Promise((resolve19) => {
           exec2("git --version", (error) => {
             if (error) {
-              resolve20(false);
+              resolve19(false);
             } else {
-              resolve20(true);
+              resolve19(true);
             }
           });
         });
@@ -74662,14 +74605,14 @@ async function openDiff(oldPath, newPath, editor, onEditorClose) {
       case "windsurf":
       case "cursor":
       case "zed":
-        return new Promise((resolve20, reject) => {
+        return new Promise((resolve19, reject) => {
           const childProcess2 = spawn3(diffCommand.command, diffCommand.args, {
             stdio: "inherit",
             shell: true
           });
           childProcess2.on("close", (code) => {
             if (code === 0) {
-              resolve20();
+              resolve19();
             } else {
               reject(new Error(`${editor} exited with code ${code}`));
             }
@@ -75027,7 +74970,7 @@ var init_coreToolScheduler = __esm({
       }
       schedule(request2, signal) {
         if (this.isRunning() || this.isScheduling) {
-          return new Promise((resolve20, reject) => {
+          return new Promise((resolve19, reject) => {
             const abortHandler = () => {
               const index = this.requestQueue.findIndex((item) => item.request === request2);
               if (index > -1) {
@@ -75041,7 +74984,7 @@ var init_coreToolScheduler = __esm({
               signal,
               resolve: () => {
                 signal.removeEventListener("abort", abortHandler);
-                resolve20();
+                resolve19();
               },
               reject: (reason) => {
                 signal.removeEventListener("abort", abortHandler);
@@ -80145,7 +80088,7 @@ var init_result_cache = __esm({
 
 // node_modules/fdir/dist/index.mjs
 import { createRequire } from "module";
-import { basename as basename14, dirname as dirname9, normalize as normalize4, relative as relative5, resolve as resolve14, sep as sep4 } from "path";
+import { basename as basename14, dirname as dirname9, normalize as normalize4, relative as relative5, resolve as resolve13, sep as sep4 } from "path";
 import * as nativeFs from "fs";
 function cleanPath(path84) {
   let normalized2 = normalize4(path84);
@@ -80161,7 +80104,7 @@ function isRootDirectory(path84) {
 function normalizePath(path84, options2) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options2;
   const pathNeedsCleaning = process.platform === "win32" && path84.includes("/") || path84.startsWith(".");
-  if (resolvePaths) path84 = resolve14(path84);
+  if (resolvePaths) path84 = resolve13(path84);
   if (normalizePath$1 || pathNeedsCleaning) path84 = cleanPath(path84);
   if (path84 === ".") return "";
   const needsSeperator = path84[path84.length - 1] !== pathSeparator;
@@ -80312,11 +80255,11 @@ var init_dist = __esm({
     empty = () => {
     };
     resolveSymlinksAsync = function(path84, state, callback$1) {
-      const { queue, fs: fs73, options: { suppressErrors } } = state;
+      const { queue, fs: fs76, options: { suppressErrors } } = state;
       queue.enqueue();
-      fs73.realpath(path84, (error, resolvedPath) => {
+      fs76.realpath(path84, (error, resolvedPath) => {
         if (error) return queue.dequeue(suppressErrors ? null : error, state);
-        fs73.stat(resolvedPath, (error$1, stat7) => {
+        fs76.stat(resolvedPath, (error$1, stat7) => {
           if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
           if (stat7.isDirectory() && isRecursive(path84, resolvedPath, state)) return queue.dequeue(null, state);
           callback$1(stat7, resolvedPath);
@@ -80325,11 +80268,11 @@ var init_dist = __esm({
       });
     };
     resolveSymlinks = function(path84, state, callback$1) {
-      const { queue, fs: fs73, options: { suppressErrors } } = state;
+      const { queue, fs: fs76, options: { suppressErrors } } = state;
       queue.enqueue();
       try {
-        const resolvedPath = fs73.realpathSync(path84);
-        const stat7 = fs73.statSync(resolvedPath);
+        const resolvedPath = fs76.realpathSync(path84);
+        const stat7 = fs76.statSync(resolvedPath);
         if (stat7.isDirectory() && isRecursive(path84, resolvedPath, state)) return;
         callback$1(stat7, resolvedPath);
       } catch (e2) {
@@ -80368,22 +80311,22 @@ var init_dist = __esm({
     walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
       state.queue.enqueue();
       if (currentDepth < 0) return state.queue.dequeue(null, state);
-      const { fs: fs73 } = state;
+      const { fs: fs76 } = state;
       state.visited.push(crawlPath);
       state.counts.directories++;
-      fs73.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+      fs76.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
         callback$1(entries, directoryPath, currentDepth);
         state.queue.dequeue(state.options.suppressErrors ? null : error, state);
       });
     };
     walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-      const { fs: fs73 } = state;
+      const { fs: fs76 } = state;
       if (currentDepth < 0) return;
       state.visited.push(crawlPath);
       state.counts.directories++;
       let entries = [];
       try {
-        entries = fs73.readdirSync(crawlPath || ".", readdirOpts);
+        entries = fs76.readdirSync(crawlPath || ".", readdirOpts);
       } catch (e2) {
         if (!state.options.suppressErrors) throw e2;
       }
@@ -80997,7 +80940,7 @@ function basicMatch(query) {
   return getResultFromScoreMap(scoreMap, this.opts.limit);
 }
 function asyncMatcher(token2, len, iter2, onFinish) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve19, reject) => {
     const INCREMENT = 1e3;
     let i = 0, end = Math.min(INCREMENT, len);
     const step = () => {
@@ -81010,7 +80953,7 @@ function asyncMatcher(token2, len, iter2, onFinish) {
         end = Math.min(end + INCREMENT, len);
         isNode ? setImmediate(step) : setTimeout(step);
       } else {
-        resolve20(onFinish());
+        resolve19(onFinish());
       }
     };
     step();
@@ -81709,7 +81652,7 @@ async function filter3(allPaths, pattern, signal) {
   const results = [];
   for (const [i, p] of allPaths.entries()) {
     if (i % 1e3 === 0) {
-      await new Promise((resolve20) => setImmediate(resolve20));
+      await new Promise((resolve19) => setImmediate(resolve19));
       if (signal?.aborted) {
         throw new AbortError();
       }
@@ -81792,7 +81735,7 @@ var init_fileSearch = __esm({
         const results = [];
         for (const [i, candidate] of filteredCandidates.entries()) {
           if (i % 1e3 === 0) {
-            await new Promise((resolve20) => setImmediate(resolve20));
+            await new Promise((resolve19) => setImmediate(resolve19));
             if (options2.signal?.aborted) {
               throw new AbortError();
             }
@@ -84109,8 +84052,8 @@ var init_databasePool = __esm({
           this.connections.push(connection);
           return connection;
         }
-        return new Promise((resolve20) => {
-          this.pendingRequests.push(resolve20);
+        return new Promise((resolve19) => {
+          this.pendingRequests.push(resolve19);
         });
       }
       /**
@@ -84332,6 +84275,55 @@ var init_databaseMigrations = __esm({
             db.exec("DROP TABLE IF EXISTS model_configs");
           }
         });
+        this.migrations.push({
+          version: 2,
+          name: "lock_metrics_tracking",
+          up: (db) => {
+            console.log("Creating lock_metrics table...");
+            db.exec(`
+          CREATE TABLE IF NOT EXISTS lock_metrics (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            operation TEXT NOT NULL,
+            lock_acquired_at DATETIME NOT NULL,
+            lock_released_at DATETIME,
+            wait_time_ms INTEGER DEFAULT 0,
+            hold_time_ms INTEGER,
+            timeout_occurred BOOLEAN DEFAULT 0,
+            conflict_detected BOOLEAN DEFAULT 0,
+            error_message TEXT,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+          )
+        `);
+            db.exec(`
+          CREATE INDEX IF NOT EXISTS idx_lock_metrics_recent
+          ON lock_metrics(created_at DESC)
+        `);
+            db.exec(`
+          CREATE INDEX IF NOT EXISTS idx_lock_metrics_timeouts
+          ON lock_metrics(timeout_occurred, created_at DESC)
+          WHERE timeout_occurred = 1
+        `);
+            db.exec(`
+          CREATE INDEX IF NOT EXISTS idx_lock_metrics_conflicts
+          ON lock_metrics(conflict_detected, created_at DESC)
+          WHERE conflict_detected = 1
+        `);
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            db.exec(`
+          INSERT OR REPLACE INTO schema_info (key, value, updated_at)
+          VALUES
+            ('lock_metrics_enabled', '1', '${now}')
+        `);
+            console.log("lock_metrics table created successfully");
+          },
+          down: (db) => {
+            db.exec("DROP INDEX IF EXISTS idx_lock_metrics_conflicts");
+            db.exec("DROP INDEX IF EXISTS idx_lock_metrics_timeouts");
+            db.exec("DROP INDEX IF EXISTS idx_lock_metrics_recent");
+            db.exec("DROP TABLE IF EXISTS lock_metrics");
+            db.exec(`DELETE FROM schema_info WHERE key = 'lock_metrics_enabled'`);
+          }
+        });
       }
       /**
        * Get current schema version from database
@@ -84842,17 +84834,17 @@ var init_async_mutex = __esm({
        * @returns Promise that resolves to a release function
        */
       async acquire() {
-        return new Promise((resolve20) => {
+        return new Promise((resolve19) => {
           if (!this.locked) {
             this.locked = true;
             this.debugLog("\u{1F512} Mutex acquired immediately");
-            resolve20(() => this.release());
+            resolve19(() => this.release());
           } else {
             this.debugLog(`\u23F3 Mutex busy, joining queue (position: ${this.waitQueue.length + 1})`);
             this.waitQueue.push(() => {
               this.locked = true;
               this.debugLog("\u{1F512} Mutex acquired from queue");
-              resolve20(() => this.release());
+              resolve19(() => this.release());
             });
           }
         });
@@ -85010,7 +85002,7 @@ var init_database_queue = __esm({
        */
       async waitForIdle() {
         while (this.mutex.isLocked() || this.mutex.getQueueLength() > 0) {
-          await new Promise((resolve20) => setTimeout(resolve20, 10));
+          await new Promise((resolve19) => setTimeout(resolve19, 10));
         }
         this.debugLog("\u{1F3C1} [DB-QUEUE] All operations completed - queue is idle");
       }
@@ -85074,9 +85066,344 @@ var init_database_queue = __esm({
   }
 });
 
+// packages/cli/src/config/database-lock.ts
+import lockfile from "proper-lockfile";
+import * as fs52 from "fs";
+var DatabaseLockManager;
+var init_database_lock = __esm({
+  "packages/cli/src/config/database-lock.ts"() {
+    DatabaseLockManager = class {
+      lockPath;
+      dbPath;
+      options;
+      db = null;
+      currentMetrics = null;
+      constructor(dbPath, customTimeout) {
+        this.dbPath = dbPath;
+        this.lockPath = `${dbPath}.lock`;
+        const envTimeout = process.env["FSS_LOCK_TIMEOUT"];
+        const timeout = customTimeout || (envTimeout ? parseInt(envTimeout, 10) : 5e3);
+        this.options = {
+          stale: 1e4,
+          // 10 seconds - if process hasn't updated lock, consider stale
+          retries: 10,
+          // Try 10 times
+          retryInterval: 100,
+          // Start with 100ms
+          timeout
+          // Configurable via FSS_LOCK_TIMEOUT env var (default 5000ms)
+        };
+      }
+      /**
+       * Set database instance for metrics tracking
+       */
+      setDatabase(db) {
+        this.db = db;
+      }
+      /**
+       * Acquire exclusive lock for database write operation
+       *
+       * Returns an unlock function that must be called to release the lock.
+       * Uses exponential backoff for retries if lock is held by another process.
+       *
+       * @throws Error if lock cannot be acquired within timeout
+       * @returns Unlock function
+       */
+      async acquireLock(operationName = "database_save") {
+        const startTime = Date.now();
+        let attempt = 0;
+        let conflictDetected = false;
+        this.currentMetrics = {
+          operation: operationName,
+          lockAcquiredAt: /* @__PURE__ */ new Date(),
+          waitTimeMs: 0,
+          timeoutOccurred: false,
+          conflictDetected: false
+        };
+        while (Date.now() - startTime < this.options.timeout) {
+          try {
+            await lockfile.lock(this.dbPath, {
+              stale: this.options.stale,
+              retries: {
+                retries: 0,
+                // We handle retries manually for better control
+                minTimeout: this.options.retryInterval
+              },
+              lockfilePath: this.lockPath
+            });
+            const waitTime = Date.now() - startTime;
+            this.currentMetrics.waitTimeMs = waitTime;
+            this.currentMetrics.conflictDetected = conflictDetected;
+            if (process.env["FSS_DEBUG"] === "true") {
+              console.log(`[DB-LOCK] Lock acquired (attempt ${attempt + 1}, waited ${waitTime}ms)`);
+            }
+            return async () => {
+              const unlockStartTime = Date.now();
+              try {
+                await lockfile.unlock(this.dbPath, {
+                  lockfilePath: this.lockPath
+                });
+                if (this.currentMetrics) {
+                  this.currentMetrics.lockReleasedAt = /* @__PURE__ */ new Date();
+                  this.currentMetrics.holdTimeMs = Date.now() - unlockStartTime;
+                  await this.recordMetrics(this.currentMetrics);
+                }
+                if (process.env["FSS_DEBUG"] === "true") {
+                  console.log("[DB-LOCK] Lock released");
+                }
+              } catch (err) {
+                const errorMsg = `Failed to unlock: ${err instanceof Error ? err.message : String(err)}`;
+                console.warn("[DB-LOCK]", errorMsg);
+                if (this.currentMetrics) {
+                  this.currentMetrics.errorMessage = errorMsg;
+                  await this.recordMetrics(this.currentMetrics);
+                }
+              }
+            };
+          } catch (err) {
+            if (err.code === "ELOCKED") {
+              conflictDetected = true;
+              attempt++;
+              const backoff = Math.min(
+                this.options.retryInterval * Math.pow(2, attempt),
+                1e3
+                // Max 1 second between retries
+              );
+              if (process.env["FSS_DEBUG"] === "true") {
+                console.log(`[DB-LOCK] Lock held by another process, retrying in ${backoff}ms (attempt ${attempt}/${this.options.retries})...`);
+              }
+              await this.sleep(backoff);
+              continue;
+            }
+            const errorMsg = this.getUserFriendlyErrorMessage(err);
+            if (this.currentMetrics) {
+              this.currentMetrics.timeoutOccurred = true;
+              this.currentMetrics.errorMessage = errorMsg;
+              await this.recordMetrics(this.currentMetrics);
+            }
+            throw new Error(errorMsg);
+          }
+        }
+        const timeoutMsg = this.getTimeoutErrorMessage();
+        if (this.currentMetrics) {
+          this.currentMetrics.timeoutOccurred = true;
+          this.currentMetrics.conflictDetected = conflictDetected;
+          this.currentMetrics.waitTimeMs = Date.now() - startTime;
+          this.currentMetrics.errorMessage = timeoutMsg;
+          await this.recordMetrics(this.currentMetrics);
+        }
+        throw new Error(timeoutMsg);
+      }
+      /**
+       * Check if database is currently locked by another process
+       *
+       * @returns true if locked, false if available or stale
+       */
+      async isLocked() {
+        try {
+          return await lockfile.check(this.dbPath, {
+            lockfilePath: this.lockPath,
+            stale: this.options.stale
+          });
+        } catch (err) {
+          return false;
+        }
+      }
+      /**
+       * Force remove stale lock file
+       *
+       * Use with caution! Only call this if you're certain the lock is stale
+       * (e.g., from a crashed process).
+       */
+      async forceUnlock() {
+        try {
+          if (fs52.existsSync(this.lockPath)) {
+            const stat7 = fs52.statSync(this.lockPath);
+            const age = Date.now() - stat7.mtimeMs;
+            if (age > this.options.stale) {
+              console.warn(`[DB-LOCK] Removing stale lock (${age}ms old)`);
+              fs52.unlinkSync(this.lockPath);
+            } else {
+              console.warn(`[DB-LOCK] Lock is not stale (${age}ms old), not removing`);
+            }
+          }
+        } catch (err) {
+          console.warn("[DB-LOCK] Failed to force unlock:", err);
+        }
+      }
+      /**
+       * Get lock file path (for debugging)
+       */
+      getLockPath() {
+        return this.lockPath;
+      }
+      /**
+       * Sleep for specified milliseconds
+       */
+      sleep(ms) {
+        return new Promise((resolve19) => setTimeout(resolve19, ms));
+      }
+      /**
+       * Record lock metrics to database
+       */
+      async recordMetrics(metrics2) {
+        if (!this.db) {
+          return;
+        }
+        try {
+          const stmt = this.db.prepare(`
+        INSERT INTO lock_metrics (
+          operation,
+          lock_acquired_at,
+          lock_released_at,
+          wait_time_ms,
+          hold_time_ms,
+          timeout_occurred,
+          conflict_detected,
+          error_message
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+          stmt.run([
+            metrics2.operation,
+            metrics2.lockAcquiredAt.toISOString(),
+            metrics2.lockReleasedAt?.toISOString() || null,
+            metrics2.waitTimeMs,
+            metrics2.holdTimeMs || null,
+            metrics2.timeoutOccurred ? 1 : 0,
+            metrics2.conflictDetected ? 1 : 0,
+            metrics2.errorMessage || null
+          ]);
+          stmt.free();
+        } catch (err) {
+          if (process.env["FSS_DEBUG"] === "true") {
+            console.warn("[DB-LOCK] Failed to record metrics:", err);
+          }
+        }
+      }
+      /**
+       * Get user-friendly error message for lock errors
+       */
+      getUserFriendlyErrorMessage(err) {
+        if (err.code === "EACCES" || err.code === "EPERM") {
+          return "Cannot save database: Permission denied. Please check file permissions for your FSS Link database.";
+        }
+        if (err.code === "ENOENT") {
+          return "Cannot save database: Database directory not found. The database folder may have been deleted.";
+        }
+        if (err.code === "ENOSPC") {
+          return "Cannot save database: No space left on disk. Please free up disk space and try again.";
+        }
+        if (err.code === "EROFS") {
+          return "Cannot save database: File system is read-only. The disk may be mounted as read-only.";
+        }
+        return `Cannot save database: ${err.message || "Unknown error"}. Please check your system and try again.`;
+      }
+      /**
+       * Get user-friendly timeout error message
+       */
+      getTimeoutErrorMessage() {
+        const timeoutSeconds = Math.round(this.options.timeout / 1e3);
+        return `Cannot save database: Another FSS Link instance is currently saving data. Waited ${timeoutSeconds} seconds but the lock is still held. Please wait for the other instance to complete, or use 'fss-link db:force-unlock' if you're certain no other instance is running.`;
+      }
+      /**
+       * Get recent lock metrics for diagnostics
+       */
+      async getMetrics(limit2 = 10) {
+        if (!this.db) {
+          return [];
+        }
+        try {
+          const stmt = this.db.prepare(`
+        SELECT
+          id,
+          operation,
+          lock_acquired_at,
+          lock_released_at,
+          wait_time_ms,
+          hold_time_ms,
+          timeout_occurred,
+          conflict_detected,
+          error_message,
+          created_at
+        FROM lock_metrics
+        ORDER BY created_at DESC
+        LIMIT ?
+      `);
+          stmt.bind([limit2]);
+          const results = [];
+          while (stmt.step()) {
+            const row = stmt.getAsObject();
+            results.push({
+              id: row["id"],
+              operation: row["operation"],
+              lockAcquiredAt: row["lock_acquired_at"],
+              lockReleasedAt: row["lock_released_at"],
+              waitTimeMs: row["wait_time_ms"],
+              holdTimeMs: row["hold_time_ms"],
+              timeoutOccurred: Boolean(row["timeout_occurred"]),
+              conflictDetected: Boolean(row["conflict_detected"]),
+              errorMessage: row["error_message"],
+              createdAt: row["created_at"]
+            });
+          }
+          stmt.free();
+          return results;
+        } catch (err) {
+          console.warn("[DB-LOCK] Failed to get metrics:", err);
+          return [];
+        }
+      }
+      /**
+       * Get lock statistics summary
+       */
+      async getStatistics() {
+        if (!this.db) {
+          return {
+            totalOperations: 0,
+            totalTimeouts: 0,
+            totalConflicts: 0,
+            averageWaitTime: 0,
+            averageHoldTime: 0
+          };
+        }
+        try {
+          const stmt = this.db.prepare(`
+        SELECT
+          COUNT(*) as total_operations,
+          SUM(CASE WHEN timeout_occurred = 1 THEN 1 ELSE 0 END) as total_timeouts,
+          SUM(CASE WHEN conflict_detected = 1 THEN 1 ELSE 0 END) as total_conflicts,
+          AVG(wait_time_ms) as avg_wait_time,
+          AVG(hold_time_ms) as avg_hold_time
+        FROM lock_metrics
+      `);
+          stmt.step();
+          const row = stmt.getAsObject();
+          stmt.free();
+          return {
+            totalOperations: row["total_operations"] || 0,
+            totalTimeouts: row["total_timeouts"] || 0,
+            totalConflicts: row["total_conflicts"] || 0,
+            averageWaitTime: row["avg_wait_time"] || 0,
+            averageHoldTime: row["avg_hold_time"] || 0
+          };
+        } catch (err) {
+          console.warn("[DB-LOCK] Failed to get statistics:", err);
+          return {
+            totalOperations: 0,
+            totalTimeouts: 0,
+            totalConflicts: 0,
+            averageWaitTime: 0,
+            averageHoldTime: 0
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/cli/src/config/core-database.ts
 import * as path58 from "path";
-import * as fs52 from "fs";
+import * as fs53 from "fs";
 function getCoreDatabase() {
   if (!coreDatabase) {
     const dbPath = path58.join(USER_SETTINGS_DIR, "fss-link.db");
@@ -85092,12 +85419,14 @@ var init_core_database = __esm({
     init_databaseMigrations();
     init_queryOptimizer();
     init_database_queue();
+    init_database_lock();
     CoreDatabase = class {
       constructor(dbPath) {
         this.dbPath = dbPath;
         this.migrationManager = new MigrationManager();
         this.queryOptimizer = new QueryOptimizer();
         this.pool = getDatabasePool(dbPath);
+        this.lockManager = new DatabaseLockManager(dbPath);
       }
       db = null;
       isInitialized = false;
@@ -85105,6 +85434,7 @@ var init_core_database = __esm({
       migrationManager;
       queryOptimizer;
       pool;
+      lockManager;
       /**
        * Get the database instance (for delegation to other managers)
        */
@@ -85128,10 +85458,18 @@ var init_core_database = __esm({
        */
       async initialize() {
         try {
+          const isLocked = await this.lockManager.isLocked();
+          if (isLocked) {
+            console.warn("[DB-INIT] Database is locked by another process");
+            console.warn("[DB-INIT] This might indicate:");
+            console.warn("[DB-INIT]   1. Another FSS Link instance is currently saving");
+            console.warn("[DB-INIT]   2. Previous instance crashed during save operation");
+            console.warn("[DB-INIT] Waiting for lock to be released or expire (10s)...");
+          }
           await this.pool.initialize();
-          if (fs52.existsSync(this.dbPath)) {
+          if (fs53.existsSync(this.dbPath)) {
             try {
-              const buffer = fs52.readFileSync(this.dbPath).slice(0, 100);
+              const buffer = fs53.readFileSync(this.dbPath).slice(0, 100);
               if (!buffer.toString("ascii", 0, 16).includes("SQLite format 3")) {
                 console.warn("Database file appears corrupted, attempting recovery...");
                 await this.recoverFromCorruption();
@@ -85144,6 +85482,7 @@ var init_core_database = __esm({
           this.db = await this.createPrimaryConnection();
           await this.initializeSchema(this.db);
           await this.ensureDefaultConfigurations(this.db);
+          this.lockManager.setDatabase(this.db);
           this.isInitialized = true;
           this.setupAutoSave();
         } catch (error) {
@@ -85153,6 +85492,7 @@ var init_core_database = __esm({
             this.db = await this.createPrimaryConnection();
             await this.initializeSchema(this.db);
             await this.ensureDefaultConfigurations(this.db);
+            this.lockManager.setDatabase(this.db);
             this.isInitialized = true;
             this.setupAutoSave();
             console.log("Database recovery successful");
@@ -85175,8 +85515,8 @@ var init_core_database = __esm({
        */
       async createPrimaryConnection() {
         const dbDir = path58.dirname(this.dbPath);
-        if (!fs52.existsSync(dbDir)) {
-          fs52.mkdirSync(dbDir, { recursive: true });
+        if (!fs53.existsSync(dbDir)) {
+          fs53.mkdirSync(dbDir, { recursive: true });
         }
         const connection = await this.pool.getConnection();
         return connection;
@@ -85239,10 +85579,15 @@ var init_core_database = __esm({
         }, "forceSave");
       }
       /**
-       * Perform database save operation
+       * Perform database save operation with file locking
+       *
+       * Acquires an exclusive lock before writing to disk to prevent concurrent
+       * writes from multiple FSS Link instances. The lock is automatically released
+       * after the write completes (or fails).
        */
       async performSave() {
         if (!this.db) return;
+        const unlock = await this.lockManager.acquireLock();
         try {
           console.log("[DB-SAVE] About to export - DB instance:", this.db.constructor.name);
           console.log("[DB-SAVE] DB has", this.db.exec("SELECT COUNT(*) FROM user_preferences")[0]?.values[0][0] || 0, "preferences in memory");
@@ -85255,22 +85600,38 @@ var init_core_database = __esm({
           console.log("[DB-SAVE] Exporting database from memory...");
           const data = this.db.export();
           console.log("[DB-SAVE] Exported", data.length, "bytes");
-          if (fs52.existsSync(this.dbPath)) {
+          if (fs53.existsSync(this.dbPath)) {
             const backupPath2 = `${this.dbPath}.backup`;
             console.log("[DB-SAVE] Creating backup:", backupPath2);
-            fs52.copyFileSync(this.dbPath, backupPath2);
+            fs53.copyFileSync(this.dbPath, backupPath2);
           }
           console.log("[DB-SAVE] Writing to:", this.dbPath);
-          fs52.writeFileSync(this.dbPath, Buffer.from(data));
+          fs53.writeFileSync(this.dbPath, Buffer.from(data));
           console.log("[DB-SAVE] Write completed successfully");
+          const written = fs53.readFileSync(this.dbPath);
+          if (written.length !== data.length) {
+            throw new Error("Write verification failed: size mismatch");
+          }
           const backupPath = `${this.dbPath}.backup`;
-          if (fs52.existsSync(backupPath)) {
+          if (fs53.existsSync(backupPath)) {
             console.log("[DB-SAVE] Removing backup");
-            fs52.unlinkSync(backupPath);
+            fs53.unlinkSync(backupPath);
           }
         } catch (error) {
           console.error("[DB-SAVE] ERROR: Database save failed:", error);
+          const backupPath = `${this.dbPath}.backup`;
+          if (fs53.existsSync(backupPath)) {
+            console.log("[DB-SAVE] Restoring from backup...");
+            try {
+              fs53.copyFileSync(backupPath, this.dbPath);
+              console.log("[DB-SAVE] Backup restored successfully");
+            } catch (restoreError) {
+              console.error("[DB-SAVE] Failed to restore backup:", restoreError);
+            }
+          }
           throw error;
+        } finally {
+          await unlock();
         }
       }
       /**
@@ -85280,13 +85641,13 @@ var init_core_database = __esm({
         console.log("Attempting database corruption recovery...");
         const backupPath = `${this.dbPath}.backup`;
         const corruptedPath = `${this.dbPath}.corrupted.${Date.now()}`;
-        if (fs52.existsSync(this.dbPath)) {
-          fs52.renameSync(this.dbPath, corruptedPath);
+        if (fs53.existsSync(this.dbPath)) {
+          fs53.renameSync(this.dbPath, corruptedPath);
           console.log(`Moved corrupted database to: ${corruptedPath}`);
         }
-        if (fs52.existsSync(backupPath)) {
+        if (fs53.existsSync(backupPath)) {
           try {
-            fs52.copyFileSync(backupPath, this.dbPath);
+            fs53.copyFileSync(backupPath, this.dbPath);
             console.log("Restored database from backup file");
             return;
           } catch (backupError) {
@@ -85304,6 +85665,7 @@ var init_core_database = __esm({
           throw new Error("Database not available for default configuration setup");
         }
         const stmt = database.prepare("SELECT COUNT(*) as count FROM model_configs");
+        stmt.step();
         const result = stmt.getAsObject();
         stmt.free();
         if (result.count > 0) {
@@ -85417,6 +85779,12 @@ var init_core_database = __esm({
       getMigrationManager() {
         return this.migrationManager;
       }
+      /**
+       * Get lock manager instance
+       */
+      getLockManager() {
+        return this.lockManager;
+      }
     };
     coreDatabase = null;
   }
@@ -87189,7 +87557,7 @@ var init_unified_database = __esm({
 
 // packages/cli/src/config/database.ts
 import * as path59 from "path";
-import * as fs53 from "fs";
+import * as fs54 from "fs";
 import * as crypto13 from "crypto";
 function debugLog(message) {
   if (process.env["FSS_DEBUG"] === "true") {
@@ -87206,8 +87574,8 @@ async function getFSSLinkDatabase() {
   }
   if (initializationLock) {
     debugLog("Database initialization locked, queuing request...");
-    return new Promise((resolve20, reject) => {
-      waitingQueue.push({ resolve: resolve20, reject });
+    return new Promise((resolve19, reject) => {
+      waitingQueue.push({ resolve: resolve19, reject });
     });
   }
   initializationLock = true;
@@ -87221,7 +87589,7 @@ async function getFSSLinkDatabase() {
       databaseInstance = instance;
       const queue = [...waitingQueue];
       waitingQueue = [];
-      queue.forEach(({ resolve: resolve20 }) => resolve20(instance));
+      queue.forEach(({ resolve: resolve19 }) => resolve19(instance));
       return instance;
     } catch (error) {
       const queue = [...waitingQueue];
@@ -87247,14 +87615,14 @@ var init_database = __esm({
       constructor() {
         this.unifiedDb = getUnifiedDatabase();
         const keyPath = path59.join(USER_SETTINGS_DIR, "db.key");
-        if (fs53.existsSync(keyPath)) {
-          this.encryptionKey = fs53.readFileSync(keyPath);
+        if (fs54.existsSync(keyPath)) {
+          this.encryptionKey = fs54.readFileSync(keyPath);
         } else {
           this.encryptionKey = crypto13.randomBytes(32);
-          if (!fs53.existsSync(USER_SETTINGS_DIR)) {
-            fs53.mkdirSync(USER_SETTINGS_DIR, { recursive: true });
+          if (!fs54.existsSync(USER_SETTINGS_DIR)) {
+            fs54.mkdirSync(USER_SETTINGS_DIR, { recursive: true });
           }
-          fs53.writeFileSync(keyPath, this.encryptionKey);
+          fs54.writeFileSync(keyPath, this.encryptionKey);
         }
       }
       /**
@@ -87558,14 +87926,14 @@ var init_database = __esm({
        */
       static getEncryptionKey() {
         const keyPath = path59.join(USER_SETTINGS_DIR, "db.key");
-        if (fs53.existsSync(keyPath)) {
-          return fs53.readFileSync(keyPath);
+        if (fs54.existsSync(keyPath)) {
+          return fs54.readFileSync(keyPath);
         } else {
           const key = crypto13.randomBytes(32);
-          if (!fs53.existsSync(USER_SETTINGS_DIR)) {
-            fs53.mkdirSync(USER_SETTINGS_DIR, { recursive: true });
+          if (!fs54.existsSync(USER_SETTINGS_DIR)) {
+            fs54.mkdirSync(USER_SETTINGS_DIR, { recursive: true });
           }
-          fs53.writeFileSync(keyPath, key);
+          fs54.writeFileSync(keyPath, key);
           return key;
         }
       }
@@ -91057,13 +91425,13 @@ var isAtCommand = (query) => (
 );
 var isSlashCommand = (query) => query.startsWith("/");
 var copyToClipboard = async (text) => {
-  const run = (cmd, args) => new Promise((resolve20, reject) => {
+  const run = (cmd, args) => new Promise((resolve19, reject) => {
     const child = spawn4(cmd, args);
     let stderr = "";
     child.stderr.on("data", (chunk) => stderr += chunk.toString());
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) return resolve20();
+      if (code === 0) return resolve19();
       const errorMsg = stderr.trim();
       reject(
         new Error(
@@ -91621,7 +91989,7 @@ var useShellCommandProcessor = (addItemToHistory, setPendingHistoryItem, onExec,
         }
         commandToExecute = `{ ${command} }; __code=$?; pwd > "${pwdFilePath}"; exit $__code`;
       }
-      const executeCommand = async (resolve20) => {
+      const executeCommand = async (resolve19) => {
         let lastUpdateTime = Date.now();
         let cumulativeStdout = "";
         let isBinaryStream = false;
@@ -91764,7 +92132,7 @@ ${finalOutput}`;
             if (pwdFilePath && fs47.existsSync(pwdFilePath)) {
               fs47.unlinkSync(pwdFilePath);
             }
-            resolve20();
+            resolve19();
           });
         } catch (err) {
           setPendingHistoryItem(null);
@@ -91779,11 +92147,11 @@ ${finalOutput}`;
           if (pwdFilePath && fs47.existsSync(pwdFilePath)) {
             fs47.unlinkSync(pwdFilePath);
           }
-          resolve20();
+          resolve19();
         }
       };
-      const execPromise = new Promise((resolve20) => {
-        executeCommand(resolve20);
+      const execPromise = new Promise((resolve19) => {
+        executeCommand(resolve19);
       });
       onExec(execPromise);
       return true;
@@ -96485,7 +96853,7 @@ var FolderTrustDialog = ({
 // packages/cli/src/config/trustedFolders.ts
 init_dist2();
 var import_strip_json_comments2 = __toESM(require_strip_json_comments(), 1);
-import * as fs54 from "fs";
+import * as fs55 from "fs";
 import * as path60 from "path";
 import { homedir as homedir13 } from "os";
 var TRUSTED_FOLDERS_FILENAME = "trustedFolders.json";
@@ -96516,8 +96884,8 @@ function loadTrustedFolders() {
   const userConfig = {};
   const userPath = USER_TRUSTED_FOLDERS_PATH;
   try {
-    if (fs54.existsSync(userPath)) {
-      const content = fs54.readFileSync(userPath, "utf-8");
+    if (fs55.existsSync(userPath)) {
+      const content = fs55.readFileSync(userPath, "utf-8");
       const parsed = JSON.parse((0, import_strip_json_comments2.default)(content));
       if (parsed) {
         Object.assign(userConfig, parsed);
@@ -96537,10 +96905,10 @@ function loadTrustedFolders() {
 function saveTrustedFolders(trustedFoldersFile) {
   try {
     const dirPath = path60.dirname(trustedFoldersFile.path);
-    if (!fs54.existsSync(dirPath)) {
-      fs54.mkdirSync(dirPath, { recursive: true });
+    if (!fs55.existsSync(dirPath)) {
+      fs55.mkdirSync(dirPath, { recursive: true });
     }
-    fs54.writeFileSync(
+    fs55.writeFileSync(
       trustedFoldersFile.path,
       JSON.stringify(trustedFoldersFile.config, null, 2),
       "utf-8"
@@ -96789,7 +97157,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "1.5.4";
+  return "1.5.6";
 }
 
 // packages/cli/src/ui/commands/aboutCommand.ts
@@ -96841,7 +97209,7 @@ import open4 from "open";
 import process11 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "ff600884";
+var GIT_COMMIT_INFO = "5a5d9179";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 init_dist2();
@@ -97680,7 +98048,7 @@ var ideCommand = (config) => {
           if (ideClient.getConnectionStatus().status === IDEConnectionStatus.Connected) {
             break;
           }
-          await new Promise((resolve20) => setTimeout(resolve20, 500));
+          await new Promise((resolve19) => setTimeout(resolve19, 500));
         }
         const { messageType, content } = getIdeStatusMessage(ideClient);
         if (messageType === "error") {
@@ -97752,7 +98120,7 @@ var ideCommand = (config) => {
 };
 
 // packages/cli/src/ui/commands/initCommand.ts
-import * as fs55 from "fs";
+import * as fs56 from "fs";
 import * as path65 from "path";
 init_dist2();
 var initCommand = {
@@ -97771,9 +98139,9 @@ var initCommand = {
     const contextFileName = getCurrentGeminiMdFilename();
     const contextFilePath = path65.join(targetDir, contextFileName);
     try {
-      if (fs55.existsSync(contextFilePath)) {
+      if (fs56.existsSync(contextFilePath)) {
         try {
-          const existing = fs55.readFileSync(contextFilePath, "utf8");
+          const existing = fs56.readFileSync(contextFilePath, "utf8");
           if (existing && existing.trim().length > 0) {
             return {
               type: "message",
@@ -97785,7 +98153,7 @@ var initCommand = {
         }
       }
       try {
-        fs55.writeFileSync(contextFilePath, "", "utf8");
+        fs56.writeFileSync(contextFilePath, "", "utf8");
         context.ui.addItem(
           {
             type: "info",
@@ -98264,7 +98632,7 @@ var mcpCommand = {
 init_dist2();
 import path66 from "node:path";
 import os22 from "os";
-import fs56 from "fs/promises";
+import fs57 from "fs/promises";
 var memoryCommand = {
   name: "memory",
   description: "Commands for interacting with memory.",
@@ -98298,7 +98666,7 @@ ${memoryContent}
           action: async (context) => {
             try {
               const projectMemoryPath = path66.join(process.cwd(), "LINK.md");
-              const memoryContent = await fs56.readFile(
+              const memoryContent = await fs57.readFile(
                 projectMemoryPath,
                 "utf-8"
               );
@@ -98336,7 +98704,7 @@ ${memoryContent}
                 FSS_LINK_DIR,
                 "LINK.md"
               );
-              const globalMemoryContent = await fs56.readFile(
+              const globalMemoryContent = await fs57.readFile(
                 globalMemoryPath,
                 "utf-8"
               );
@@ -98575,7 +98943,7 @@ var quitCommand = {
 };
 
 // packages/cli/src/ui/commands/restoreCommand.ts
-import * as fs57 from "fs/promises";
+import * as fs58 from "fs/promises";
 import path67 from "path";
 async function restoreAction(context, args) {
   const { services, ui } = context;
@@ -98590,8 +98958,8 @@ async function restoreAction(context, args) {
     };
   }
   try {
-    await fs57.mkdir(checkpointDir, { recursive: true });
-    const files = await fs57.readdir(checkpointDir);
+    await fs58.mkdir(checkpointDir, { recursive: true });
+    const files = await fs58.readdir(checkpointDir);
     const jsonFiles = files.filter((file) => file.endsWith(".json"));
     if (!args) {
       if (jsonFiles.length === 0) {
@@ -98627,7 +98995,7 @@ ${fileList}`
       };
     }
     const filePath = path67.join(checkpointDir, selectedFile);
-    const data = await fs57.readFile(filePath, "utf-8");
+    const data = await fs58.readFile(filePath, "utf-8");
     const toolCallData = JSON.parse(data);
     if (toolCallData.history) {
       if (!loadHistory) {
@@ -98673,7 +99041,7 @@ async function completion(context, _partialArg) {
     return [];
   }
   try {
-    const files = await fs57.readdir(checkpointDir);
+    const files = await fs58.readdir(checkpointDir);
     return files.filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", ""));
   } catch (_err) {
     return [];
@@ -98839,7 +99207,7 @@ var vimCommand = {
 
 // packages/cli/src/ui/commands/setupGithubCommand.ts
 import path68 from "node:path";
-import * as fs58 from "node:fs";
+import * as fs59 from "node:fs";
 import { Writable } from "node:stream";
 import { ProxyAgent as ProxyAgent4 } from "undici";
 
@@ -98940,20 +99308,20 @@ async function updateGitignore(gitRepoRoot) {
     let existingContent = "";
     let fileExists = true;
     try {
-      existingContent = await fs58.promises.readFile(gitignorePath, "utf8");
+      existingContent = await fs59.promises.readFile(gitignorePath, "utf8");
     } catch (_error) {
       fileExists = false;
     }
     if (!fileExists) {
       const contentToWrite = gitignoreEntries.join("\n") + "\n";
-      await fs58.promises.writeFile(gitignorePath, contentToWrite);
+      await fs59.promises.writeFile(gitignorePath, contentToWrite);
     } else {
       const missingEntries = gitignoreEntries.filter(
         (entry) => !existingContent.split(/\r?\n/).some((line) => line.split("#")[0].trim() === entry)
       );
       if (missingEntries.length > 0) {
         const contentToAdd = "\n" + missingEntries.join("\n") + "\n";
-        await fs58.promises.appendFile(gitignorePath, contentToAdd);
+        await fs59.promises.appendFile(gitignorePath, contentToAdd);
       }
     }
   } catch (error) {
@@ -98985,7 +99353,7 @@ var setupGithubCommand = {
     const readmeUrl = `https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`;
     const githubWorkflowsDir = path68.join(gitRepoRoot, ".github", "workflows");
     try {
-      await fs58.promises.mkdir(githubWorkflowsDir, { recursive: true });
+      await fs59.promises.mkdir(githubWorkflowsDir, { recursive: true });
     } catch (_error) {
       console.debug(
         `Failed to create ${githubWorkflowsDir} directory:`,
@@ -99023,7 +99391,7 @@ var setupGithubCommand = {
             githubWorkflowsDir,
             path68.basename(workflow)
           );
-          const fileStream = fs58.createWriteStream(destination, {
+          const fileStream = fs59.createWriteStream(destination, {
             mode: 420,
             // -rw-r--r--, user(rw), group(r), other(r)
             flags: "w",
@@ -99057,7 +99425,7 @@ var setupGithubCommand = {
 };
 
 // packages/cli/src/ui/utils/terminalSetup.ts
-import { promises as fs59 } from "fs";
+import { promises as fs60 } from "fs";
 import * as os23 from "os";
 import * as path69 from "path";
 import { exec as exec4 } from "child_process";
@@ -99071,10 +99439,10 @@ async function detectAndEnableKittyProtocol() {
   if (detectionComplete) {
     return protocolSupported;
   }
-  return new Promise((resolve20) => {
+  return new Promise((resolve19) => {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {
       detectionComplete = true;
-      resolve20(false);
+      resolve19(false);
       return;
     }
     const originalRawMode = process.stdin.isRaw;
@@ -99104,7 +99472,7 @@ async function detectAndEnableKittyProtocol() {
             process.on("SIGTERM", disableProtocol);
           }
           detectionComplete = true;
-          resolve20(protocolSupported);
+          resolve19(protocolSupported);
         }
       }
     };
@@ -99118,7 +99486,7 @@ async function detectAndEnableKittyProtocol() {
           process.stdin.setRawMode(false);
         }
         detectionComplete = true;
-        resolve20(false);
+        resolve19(false);
       }
     }, 50);
   });
@@ -99172,7 +99540,7 @@ async function backupFile(filePath) {
   try {
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const backupPath = `${filePath}.backup.${timestamp2}`;
-    await fs59.copyFile(filePath, backupPath);
+    await fs60.copyFile(filePath, backupPath);
   } catch (error) {
     console.warn(`Failed to create backup of ${filePath}:`, error);
   }
@@ -99206,10 +99574,10 @@ async function configureVSCodeStyle(terminalName, appName) {
   }
   const keybindingsFile = path69.join(configDir, "keybindings.json");
   try {
-    await fs59.mkdir(configDir, { recursive: true });
+    await fs60.mkdir(configDir, { recursive: true });
     let keybindings = [];
     try {
-      const content = await fs59.readFile(keybindingsFile, "utf8");
+      const content = await fs60.readFile(keybindingsFile, "utf8");
       await backupFile(keybindingsFile);
       try {
         const cleanContent = stripJsonComments3(content);
@@ -99279,7 +99647,7 @@ Please check and modify manually if needed: ${keybindingsFile}`
     if (!hasOurShiftEnter || !hasOurCtrlEnter) {
       if (!hasOurShiftEnter) keybindings.unshift(shiftEnterBinding);
       if (!hasOurCtrlEnter) keybindings.unshift(ctrlEnterBinding);
-      await fs59.writeFile(keybindingsFile, JSON.stringify(keybindings, null, 4));
+      await fs60.writeFile(keybindingsFile, JSON.stringify(keybindings, null, 4));
       return {
         success: true,
         message: `Added Shift+Enter and Ctrl+Enter keybindings to ${terminalName}.
@@ -99510,11 +99878,11 @@ function cleanTextForSpeech2(text) {
 async function executeSpeech(text, voice, progress) {
   try {
     progress?.setPhase("cleaning");
-    await new Promise((resolve20) => setTimeout(resolve20, 300));
+    await new Promise((resolve19) => setTimeout(resolve19, 300));
     const cleanedText = cleanTextForSpeech2(text);
     progress?.setPhase("sending");
-    await new Promise((resolve20) => setTimeout(resolve20, 200));
-    const response = await fetch("http://192.168.1.5:11450/api/v1/synthesize", {
+    await new Promise((resolve19) => setTimeout(resolve19, 200));
+    const response = await fetch("http://tts.internal.bobai.com.au:11450/api/v1/synthesize", {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -99533,10 +99901,10 @@ async function executeSpeech(text, voice, progress) {
     }
     progress?.setPhase("processing");
     await response.json();
-    await new Promise((resolve20) => setTimeout(resolve20, 400));
+    await new Promise((resolve19) => setTimeout(resolve19, 400));
     progress?.setPhase("speaking");
     const estimatedDuration = Math.max(1e3, Math.min(text.length * 50, 5e3));
-    await new Promise((resolve20) => setTimeout(resolve20, estimatedDuration));
+    await new Promise((resolve19) => setTimeout(resolve19, estimatedDuration));
     progress?.setPhase("completed");
   } catch (error) {
     progress?.setError(error instanceof Error ? error.message : "Unknown error");
@@ -99689,7 +100057,7 @@ var ttsCommand = {
         let serverAvailable = false;
         let serverInfo = "";
         try {
-          const response = await fetch("http://192.168.1.5:11450/health", {
+          const response = await fetch("http://tts.internal.bobai.com.au:11450/health", {
             method: "GET"
           });
           serverAvailable = response.ok;
@@ -99725,7 +100093,7 @@ var ttsCommand = {
 `;
         status += `Server Status:
 `;
-        status += `  \u{1F310} Endpoint: http://192.168.1.5:11450
+        status += `  \u{1F310} Endpoint: http://tts.internal.bobai.com.au:11450
 `;
         status += `  \u{1F4E1} Connection: ${serverAvailable ? "\u2705 Connected" : "\u274C Failed"}
 `;
@@ -99921,7 +100289,7 @@ var BuiltinCommandLoader = class {
 init_esm6();
 init_zod();
 init_dist2();
-import { promises as fs60 } from "fs";
+import { promises as fs61 } from "fs";
 import path70 from "path";
 import toml from "@iarna/toml";
 
@@ -100192,7 +100560,7 @@ var FileCommandLoader = class {
   async parseAndAdaptFile(filePath, baseDir, extensionName) {
     let fileContent;
     try {
-      fileContent = await fs60.readFile(filePath, "utf-8");
+      fileContent = await fs61.readFile(filePath, "utf-8");
     } catch (error) {
       console.error(
         `[FileCommandLoader] Failed to read file ${filePath}:`,
@@ -100792,12 +101160,12 @@ var useSlashCommandProcessor = (config, settings, addItem, clearItems, loadHisto
                     content: result.content
                   };
                 case "confirm_shell_commands": {
-                  const { outcome, approvedCommands } = await new Promise((resolve20) => {
+                  const { outcome, approvedCommands } = await new Promise((resolve19) => {
                     setShellConfirmationRequest({
                       commands: result.commandsToConfirm,
                       onConfirm: (resolvedOutcome, resolvedApprovedCommands) => {
                         setShellConfirmationRequest(null);
-                        resolve20({
+                        resolve19({
                           outcome: resolvedOutcome,
                           approvedCommands: resolvedApprovedCommands
                         });
@@ -100819,12 +101187,12 @@ var useSlashCommandProcessor = (config, settings, addItem, clearItems, loadHisto
                   );
                 }
                 case "confirm_action": {
-                  const { confirmed } = await new Promise((resolve20) => {
+                  const { confirmed } = await new Promise((resolve19) => {
                     setConfirmationRequest({
                       prompt: result.prompt,
                       onConfirm: (resolvedConfirmed) => {
                         setConfirmationRequest(null);
-                        resolve20({ confirmed: resolvedConfirmed });
+                        resolve19({ confirmed: resolvedConfirmed });
                       }
                     });
                   });
@@ -101493,7 +101861,7 @@ function useInputHistory({
 init_strip_ansi();
 import { stripVTControlCharacters } from "util";
 import { spawnSync } from "child_process";
-import fs61 from "fs";
+import fs62 from "fs";
 import os24 from "os";
 import pathMod from "path";
 import { useState as useState21, useCallback as useCallback15, useEffect as useEffect20, useMemo as useMemo5, useReducer as useReducer2 } from "react";
@@ -103361,9 +103729,9 @@ function useTextBuffer({
   const openInExternalEditor = useCallback15(
     async (opts = {}) => {
       const editor = opts.editor ?? process.env["VISUAL"] ?? process.env["EDITOR"] ?? (process.platform === "win32" ? "notepad" : "vi");
-      const tmpDir = fs61.mkdtempSync(pathMod.join(os24.tmpdir(), "gemini-edit-"));
+      const tmpDir = fs62.mkdtempSync(pathMod.join(os24.tmpdir(), "gemini-edit-"));
       const filePath = pathMod.join(tmpDir, "buffer.txt");
-      fs61.writeFileSync(filePath, text, "utf8");
+      fs62.writeFileSync(filePath, text, "utf8");
       dispatch({ type: "create_undo_snapshot" });
       const wasRaw = stdin?.isRaw ?? false;
       try {
@@ -103374,7 +103742,7 @@ function useTextBuffer({
         if (error) throw error;
         if (typeof status === "number" && status !== 0)
           throw new Error(`External editor exited with status ${status}`);
-        let newText = fs61.readFileSync(filePath, "utf8");
+        let newText = fs62.readFileSync(filePath, "utf8");
         newText = newText.replace(/\r\n?/g, "\n");
         dispatch({ type: "set_text", payload: newText, pushToUndo: false });
       } catch (err) {
@@ -103382,11 +103750,11 @@ function useTextBuffer({
       } finally {
         if (wasRaw) setRawMode?.(true);
         try {
-          fs61.unlinkSync(filePath);
+          fs62.unlinkSync(filePath);
         } catch {
         }
         try {
-          fs61.rmdirSync(tmpDir);
+          fs62.rmdirSync(tmpDir);
         } catch {
         }
       }
@@ -103525,7 +103893,7 @@ import chalk from "chalk";
 // packages/cli/src/ui/hooks/useShellHistory.ts
 init_dist2();
 import { useState as useState22, useEffect as useEffect21, useCallback as useCallback16 } from "react";
-import * as fs62 from "fs/promises";
+import * as fs63 from "fs/promises";
 import * as path71 from "path";
 var HISTORY_FILE = "shell_history";
 var MAX_HISTORY_LENGTH2 = 100;
@@ -103535,7 +103903,7 @@ async function getHistoryFilePath(projectRoot) {
 }
 async function readHistoryFile(filePath) {
   try {
-    const text = await fs62.readFile(filePath, "utf-8");
+    const text = await fs63.readFile(filePath, "utf-8");
     const result = [];
     let cur = "";
     for (const raw of text.split(/\r?\n/)) {
@@ -103559,8 +103927,8 @@ async function readHistoryFile(filePath) {
 }
 async function writeHistoryFile(filePath, history) {
   try {
-    await fs62.mkdir(path71.dirname(filePath), { recursive: true });
-    await fs62.writeFile(filePath, history.join("\n"));
+    await fs63.mkdir(path71.dirname(filePath), { recursive: true });
+    await fs63.writeFile(filePath, history.join("\n"));
   } catch (error) {
     console.error("Error writing shell history:", error);
   }
@@ -104389,7 +104757,7 @@ var keyMatchers = createKeyMatchers(defaultKeyBindings);
 // packages/cli/src/ui/utils/clipboardUtils.ts
 import { exec as exec5 } from "child_process";
 import { promisify as promisify5 } from "util";
-import * as fs63 from "fs/promises";
+import * as fs64 from "fs/promises";
 import * as path72 from "path";
 var execAsync4 = promisify5(exec5);
 async function clipboardHasImage() {
@@ -104413,7 +104781,7 @@ async function saveClipboardImage(targetDir) {
   try {
     const baseDir = targetDir || process.cwd();
     const tempDir = path72.join(baseDir, ".gemini-clipboard");
-    await fs63.mkdir(tempDir, { recursive: true });
+    await fs64.mkdir(tempDir, { recursive: true });
     const timestamp2 = (/* @__PURE__ */ new Date()).getTime();
     const formats = [
       { class: "PNGf", extension: "png" },
@@ -104443,7 +104811,7 @@ async function saveClipboardImage(targetDir) {
       const { stdout } = await execAsync4(`osascript -e '${script}'`);
       if (stdout.trim() === "success") {
         try {
-          const stats = await fs63.stat(tempFilePath);
+          const stats = await fs64.stat(tempFilePath);
           if (stats.size > 0) {
             return tempFilePath;
           }
@@ -104451,7 +104819,7 @@ async function saveClipboardImage(targetDir) {
         }
       }
       try {
-        await fs63.unlink(tempFilePath);
+        await fs64.unlink(tempFilePath);
       } catch {
       }
     }
@@ -104465,14 +104833,14 @@ async function cleanupOldClipboardImages(targetDir) {
   try {
     const baseDir = targetDir || process.cwd();
     const tempDir = path72.join(baseDir, ".gemini-clipboard");
-    const files = await fs63.readdir(tempDir);
+    const files = await fs64.readdir(tempDir);
     const oneHourAgo = Date.now() - 60 * 60 * 1e3;
     for (const file of files) {
       if (file.startsWith("clipboard-") && (file.endsWith(".png") || file.endsWith(".jpg") || file.endsWith(".tiff") || file.endsWith(".gif"))) {
         const filePath = path72.join(tempDir, file);
-        const stats = await fs63.stat(filePath);
+        const stats = await fs64.stat(filePath);
         if (stats.mtimeMs < oneHourAgo) {
-          await fs63.unlink(filePath);
+          await fs64.unlink(filePath);
         }
       }
     }
@@ -122108,7 +122476,7 @@ function ProviderEndpointSelectionDialog({
           const modelManager = getModelManager();
           modelManager.switchToModel(selected.modelId).then(async (success) => {
             if (success) {
-              await new Promise((resolve20) => setTimeout(resolve20, 300));
+              await new Promise((resolve19) => setTimeout(resolve19, 300));
               onCancel();
             } else {
               setError("Failed to switch model - model not found");
@@ -123315,7 +123683,7 @@ var ShellConfirmationDialog = ({ request: request2 }) => {
 };
 
 // packages/cli/src/config/config.ts
-import * as fs65 from "fs";
+import * as fs68 from "fs";
 import * as path77 from "path";
 import { homedir as homedir18 } from "node:os";
 import yargs from "yargs/yargs";
@@ -123538,7 +123906,7 @@ init_dist2();
 import { Client as Client3 } from "@modelcontextprotocol/sdk/client/index.js";
 
 // packages/cli/src/config/extension.ts
-import * as fs64 from "fs";
+import * as fs65 from "fs";
 import * as path75 from "path";
 import * as os25 from "os";
 var EXTENSIONS_DIRECTORY_NAME = path75.join(".fss-link", "extensions");
@@ -123559,11 +123927,11 @@ function loadExtensions(workspaceDir) {
 }
 function loadExtensionsFromDir(dir) {
   const extensionsDir = path75.join(dir, EXTENSIONS_DIRECTORY_NAME);
-  if (!fs64.existsSync(extensionsDir)) {
+  if (!fs65.existsSync(extensionsDir)) {
     return [];
   }
   const extensions = [];
-  for (const subdir of fs64.readdirSync(extensionsDir)) {
+  for (const subdir of fs65.readdirSync(extensionsDir)) {
     const extensionDir = path75.join(extensionsDir, subdir);
     const extension = loadExtension(extensionDir);
     if (extension != null) {
@@ -123573,19 +123941,19 @@ function loadExtensionsFromDir(dir) {
   return extensions;
 }
 function loadExtension(extensionDir) {
-  if (!fs64.statSync(extensionDir).isDirectory()) {
+  if (!fs65.statSync(extensionDir).isDirectory()) {
     console.error(
       `Warning: unexpected file ${extensionDir} in extensions directory.`
     );
     return null;
   }
   let configFilePath = path75.join(extensionDir, EXTENSIONS_CONFIG_FILENAME);
-  if (!fs64.existsSync(configFilePath)) {
+  if (!fs65.existsSync(configFilePath)) {
     const oldConfigFilePath = path75.join(
       extensionDir,
       EXTENSIONS_CONFIG_FILENAME_OLD
     );
-    if (!fs64.existsSync(oldConfigFilePath)) {
+    if (!fs65.existsSync(oldConfigFilePath)) {
       console.error(
         `Warning: extension directory ${extensionDir} does not contain a config file ${configFilePath}.`
       );
@@ -123594,7 +123962,7 @@ function loadExtension(extensionDir) {
     configFilePath = oldConfigFilePath;
   }
   try {
-    const configContent = fs64.readFileSync(configFilePath, "utf-8");
+    const configContent = fs65.readFileSync(configFilePath, "utf-8");
     const config = JSON.parse(configContent);
     if (!config.name || !config.version) {
       console.error(
@@ -123602,7 +123970,7 @@ function loadExtension(extensionDir) {
       );
       return null;
     }
-    const contextFiles = getContextFileNames(config).map((contextFileName) => path75.join(extensionDir, contextFileName)).filter((contextFilePath) => fs64.existsSync(contextFilePath));
+    const contextFiles = getContextFileNames(config).map((contextFileName) => path75.join(extensionDir, contextFileName)).filter((contextFilePath) => fs65.existsSync(contextFilePath));
     return {
       path: extensionDir,
       config,
@@ -123770,6 +124138,171 @@ var mcpCommand2 = {
   }
 };
 
+// packages/cli/src/commands/db/lock-status.ts
+init_core_database();
+import * as fs66 from "fs";
+var lockStatusCommand = {
+  command: "lock-status",
+  describe: "Show database lock status and metrics",
+  handler: async () => {
+    try {
+      const coreDb = getCoreDatabase();
+      await coreDb.ensureInitialized();
+      await coreDb.forceSave();
+      const lockManager = coreDb.getLockManager();
+      const lockPath = lockManager.getLockPath();
+      console.log("\u{1F4CA} FSS Link Database Lock Status\n");
+      console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+      const isLocked = await lockManager.isLocked();
+      if (isLocked) {
+        console.log("\u{1F512} Status: LOCKED");
+        console.log(`   Another FSS Link instance is currently saving data.
+`);
+        if (fs66.existsSync(lockPath)) {
+          const stat7 = fs66.statSync(lockPath);
+          const age = Date.now() - stat7.mtimeMs;
+          const ageSeconds = Math.round(age / 1e3);
+          console.log(`   Lock file: ${lockPath}`);
+          console.log(`   Lock age: ${ageSeconds} seconds`);
+          if (age > 1e4) {
+            console.log(`   \u26A0\uFE0F  WARNING: Lock is stale (older than 10 seconds)`);
+            console.log(`   This may indicate a crashed process.`);
+            console.log(`   Use 'fss-link db:force-unlock' to remove it.
+`);
+          } else {
+            console.log();
+          }
+        }
+      } else {
+        console.log("\u2705 Status: UNLOCKED");
+        console.log(`   Database is available for writing.
+`);
+      }
+      const stats = await lockManager.getStatistics();
+      if (stats.totalOperations > 0) {
+        console.log("\u{1F4C8} Lock Statistics:\n");
+        console.log(`   Total operations:   ${stats.totalOperations}`);
+        console.log(`   Total conflicts:    ${stats.totalConflicts}`);
+        console.log(`   Total timeouts:     ${stats.totalTimeouts}`);
+        console.log(`   Avg wait time:      ${Math.round(stats.averageWaitTime)}ms`);
+        console.log(`   Avg hold time:      ${Math.round(stats.averageHoldTime)}ms
+`);
+      } else {
+        console.log("\u{1F4C8} Lock Statistics:\n");
+        console.log(`   No lock operations recorded yet.
+`);
+      }
+      const recentMetrics = await lockManager.getMetrics(5);
+      if (recentMetrics.length > 0) {
+        console.log("\u{1F4CB} Recent Operations (last 5):\n");
+        for (const metric of recentMetrics) {
+          const date = new Date(metric.createdAt);
+          const timeStr = date.toLocaleTimeString();
+          const status = metric.timeoutOccurred ? "\u274C TIMEOUT" : metric.conflictDetected ? "\u26A0\uFE0F  CONFLICT" : "\u2705 SUCCESS";
+          console.log(`   ${timeStr} - ${status}`);
+          console.log(`   Operation: ${metric.operation}`);
+          console.log(`   Wait: ${metric.waitTimeMs}ms, Hold: ${metric.holdTimeMs || "N/A"}ms`);
+          if (metric.errorMessage) {
+            console.log(`   Error: ${metric.errorMessage}`);
+          }
+          console.log();
+        }
+      }
+      console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    } catch (error) {
+      console.error("Error getting lock status:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// packages/cli/src/commands/db/force-unlock.ts
+init_core_database();
+import * as fs67 from "fs";
+import * as readline4 from "readline";
+async function confirm(question) {
+  const rl = readline4.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve19) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve19(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+var forceUnlockCommand = {
+  command: "force-unlock",
+  describe: "Force remove database lock file (use with caution)",
+  builder: (yargs2) => yargs2.option("yes", {
+    alias: "y",
+    type: "boolean",
+    description: "Skip confirmation prompt",
+    default: false
+  }),
+  handler: async (argv) => {
+    try {
+      const coreDb = getCoreDatabase();
+      await coreDb.ensureInitialized();
+      await coreDb.forceSave();
+      const lockManager = coreDb.getLockManager();
+      const lockPath = lockManager.getLockPath();
+      console.log("\u26A0\uFE0F  Force Unlock Database\n");
+      if (!fs67.existsSync(lockPath)) {
+        console.log("\u2705 No lock file found - database is not locked.\n");
+        return;
+      }
+      const stat7 = fs67.statSync(lockPath);
+      const age = Date.now() - stat7.mtimeMs;
+      const ageSeconds = Math.round(age / 1e3);
+      console.log(`Lock file: ${lockPath}`);
+      console.log(`Lock age: ${ageSeconds} seconds
+`);
+      if (age < 1e4) {
+        console.log("\u26A0\uFE0F  WARNING: Lock is NOT stale (less than 10 seconds old)");
+        console.log("   This lock may belong to an active FSS Link instance.\n");
+        console.log("   Force removing it could cause database corruption if another");
+        console.log("   instance is currently saving data.\n");
+      } else {
+        console.log("\u2139\uFE0F  Lock appears to be stale (older than 10 seconds)");
+        console.log("   This is likely from a crashed process.\n");
+      }
+      if (!argv.yes) {
+        console.log("This will forcefully remove the lock file.");
+        console.log("Only do this if you are certain no other FSS Link instance is running.\n");
+        const confirmed = await confirm("Are you sure you want to continue? (y/N): ");
+        if (!confirmed) {
+          console.log("\n\u274C Cancelled - lock file not removed.\n");
+          return;
+        }
+      }
+      await lockManager.forceUnlock();
+      if (fs67.existsSync(lockPath)) {
+        console.log("\n\u26A0\uFE0F  Lock file still exists after force unlock.");
+        console.log("   It may have been recently updated by another instance.\n");
+        console.log(`   Lock age is now: ${Math.round((Date.now() - fs67.statSync(lockPath).mtimeMs) / 1e3)} seconds
+`);
+      } else {
+        console.log("\n\u2705 Lock file removed successfully.\n");
+        console.log("   Database is now unlocked and ready for use.\n");
+      }
+    } catch (error) {
+      console.error("Error forcing unlock:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// packages/cli/src/commands/db.ts
+var dbCommand = {
+  command: "db",
+  describe: "Database management and diagnostics",
+  builder: (yargs2) => yargs2.command(lockStatusCommand).command(forceUnlockCommand).demandCommand(1, "You need at least one command before continuing.").version(false),
+  handler: () => {
+  }
+};
+
 // packages/cli/src/config/config.ts
 init_dist2();
 
@@ -124027,7 +124560,7 @@ async function parseArguments() {
       }
       return true;
     })
-  ).command(mcpCommand2).version(await getCliVersion()).alias("v", "version").help().alias("h", "help").strict().demandCommand(0, 0);
+  ).command(mcpCommand2).command(dbCommand).version(await getCliVersion()).alias("v", "version").help().alias("h", "help").strict().demandCommand(0, 0);
   yargsInstance.wrap(yargsInstance.terminalWidth());
   const result = await yargsInstance.parse();
   if (result._.length > 0 && result._[0] === "mcp") {
@@ -124036,8 +124569,8 @@ async function parseArguments() {
   return result;
 }
 async function loadHierarchicalGeminiMemory(currentWorkingDirectory, includeDirectoriesToReadGemini = [], debugMode, fileService, settings, extensionContextFilePaths = [], memoryImportFormat = "tree", fileFilteringOptions) {
-  const realCwd = fs65.realpathSync(path77.resolve(currentWorkingDirectory));
-  const realHome = fs65.realpathSync(path77.resolve(homedir18()));
+  const realCwd = fs68.realpathSync(path77.resolve(currentWorkingDirectory));
+  const realHome = fs68.realpathSync(path77.resolve(homedir18()));
   const isHomeDirectory = realCwd === realHome;
   const effectiveCwd = isHomeDirectory ? "" : currentWorkingDirectory;
   if (debugMode) {
@@ -126576,7 +127109,7 @@ function IdeIntegrationNudge({
 // packages/cli/src/ui/hooks/useGitBranchName.ts
 import { useState as useState42, useEffect as useEffect38, useCallback as useCallback24 } from "react";
 import { exec as exec6 } from "node:child_process";
-import fs66 from "node:fs";
+import fs69 from "node:fs";
 import fsPromises3 from "node:fs/promises";
 import path78 from "path";
 function useGitBranchName(cwd3) {
@@ -126616,8 +127149,8 @@ function useGitBranchName(cwd3) {
     let watcher;
     const setupWatcher = async () => {
       try {
-        await fsPromises3.access(gitLogsHeadPath, fs66.constants.F_OK);
-        watcher = fs66.watch(gitLogsHeadPath, (eventType) => {
+        await fsPromises3.access(gitLogsHeadPath, fs69.constants.F_OK);
+        watcher = fs69.watch(gitLogsHeadPath, (eventType) => {
           if (eventType === "change" || eventType === "rename") {
             fetchBranchName();
           }
@@ -127261,7 +127794,7 @@ function useKittyKeyboardProtocol() {
 }
 
 // packages/cli/src/ui/App.tsx
-import * as fs68 from "fs";
+import * as fs71 from "fs";
 
 // packages/cli/src/ui/components/UpdateNotification.tsx
 import { Box as Box52, Text as Text57 } from "ink";
@@ -128347,7 +128880,7 @@ function SettingsDialog({
 
 // packages/cli/src/utils/installationInfo.ts
 init_dist2();
-import * as fs67 from "fs";
+import * as fs70 from "fs";
 import * as path79 from "path";
 import * as childProcess from "child_process";
 function getInstallationInfo(projectRoot, isAutoUpdateDisabled) {
@@ -128356,7 +128889,7 @@ function getInstallationInfo(projectRoot, isAutoUpdateDisabled) {
     return { packageManager: "unknown" /* UNKNOWN */, isGlobal: false };
   }
   try {
-    const realPath = fs67.realpathSync(cliPath).replace(/\\/g, "/");
+    const realPath = fs70.realpathSync(cliPath).replace(/\\/g, "/");
     const normalizedProjectRoot = projectRoot?.replace(/\\/g, "/");
     const isGit = isGitRepository(process.cwd());
     if (isGit && normalizedProjectRoot && realPath.startsWith(normalizedProjectRoot) && !realPath.includes("/node_modules/")) {
@@ -128367,8 +128900,8 @@ function getInstallationInfo(projectRoot, isAutoUpdateDisabled) {
         updateMessage: 'Running from a local git clone. Please update with "git pull".'
       };
     }
-    if (realPath.includes("/node_modules/") && fs67.existsSync(cliPath) && fs67.lstatSync(cliPath).isSymbolicLink()) {
-      const symlinkTarget = fs67.readlinkSync(cliPath);
+    if (realPath.includes("/node_modules/") && fs70.existsSync(cliPath) && fs70.lstatSync(cliPath).isSymbolicLink()) {
+      const symlinkTarget = fs70.readlinkSync(cliPath);
       const absoluteTarget = path79.isAbsolute(symlinkTarget) ? symlinkTarget : path79.resolve(path79.dirname(cliPath), symlinkTarget);
       if (isGitRepository(absoluteTarget)) {
         return {
@@ -128441,11 +128974,11 @@ function getInstallationInfo(projectRoot, isAutoUpdateDisabled) {
     }
     if (normalizedProjectRoot && realPath.startsWith(`${normalizedProjectRoot}/node_modules`)) {
       let pm2 = "npm" /* NPM */;
-      if (fs67.existsSync(path79.join(projectRoot, "yarn.lock"))) {
+      if (fs70.existsSync(path79.join(projectRoot, "yarn.lock"))) {
         pm2 = "yarn" /* YARN */;
-      } else if (fs67.existsSync(path79.join(projectRoot, "pnpm-lock.yaml"))) {
+      } else if (fs70.existsSync(path79.join(projectRoot, "pnpm-lock.yaml"))) {
         pm2 = "pnpm" /* PNPM */;
-      } else if (fs67.existsSync(path79.join(projectRoot, "bun.lockb"))) {
+      } else if (fs70.existsSync(path79.join(projectRoot, "bun.lockb"))) {
         pm2 = "bun" /* BUN */;
       }
       return {
@@ -128476,13 +129009,13 @@ import { spawn as spawn5 } from "child_process";
 var spawnWrapper = spawn5;
 
 // packages/cli/src/utils/handleAutoUpdate.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import os28 from "os";
 import path80 from "path";
 function hasSudoAskpass() {
   const homeDir2 = os28.homedir();
   const sudoGuiPath = path80.join(homeDir2, ".local", "bin", "sudo-gui");
-  return existsSync20(sudoGuiPath);
+  return existsSync23(sudoGuiPath);
 }
 function shouldAttemptAutoUpdate(installationInfo, isGlobal) {
   if (!isGlobal) {
@@ -128931,7 +129464,7 @@ var App = ({ config, settings, startupWarnings = [], version }) => {
   const suggestionsWidth = Math.max(20, Math.floor(terminalWidth * 0.8));
   const isValidPath = useCallback29((filePath) => {
     try {
-      return fs68.existsSync(filePath) && fs68.statSync(filePath).isFile();
+      return fs71.existsSync(filePath) && fs71.statSync(filePath).isFile();
     } catch (_e) {
       return false;
     }
@@ -129629,7 +130162,7 @@ ${queuedText}` : queuedText;
 // packages/cli/src/utils/readStdin.ts
 async function readStdin() {
   const MAX_STDIN_SIZE = 8 * 1024 * 1024;
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve19, reject) => {
     let data = "";
     let totalSize = 0;
     process.stdin.setEncoding("utf8");
@@ -129651,7 +130184,7 @@ async function readStdin() {
     };
     const onEnd = () => {
       cleanup();
-      resolve20(data);
+      resolve19(data);
     };
     const onError = (err) => {
       cleanup();
@@ -129681,7 +130214,7 @@ init_settings();
 import { exec as exec7, execSync as execSync7, spawn as spawn6 } from "node:child_process";
 import os29 from "node:os";
 import path81 from "node:path";
-import fs69 from "node:fs";
+import fs72 from "node:fs";
 import { readFile as readFile12 } from "node:fs/promises";
 import { promisify as promisify6 } from "util";
 var execAsync5 = promisify6(exec7);
@@ -129776,7 +130309,7 @@ function entrypoint(workdir) {
     SETTINGS_DIRECTORY_NAME,
     "sandbox.bashrc"
   );
-  if (fs69.existsSync(projectSandboxBashrc)) {
+  if (fs72.existsSync(projectSandboxBashrc)) {
     shellCmds.push(`source ${getContainerPath(projectSandboxBashrc)};`);
   }
   ports().forEach(
@@ -129809,7 +130342,7 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
           `sandbox-macos-${profile}.sb`
         );
       }
-      if (!fs69.existsSync(profileFile)) {
+      if (!fs72.existsSync(profileFile)) {
         console.error(
           `ERROR: missing macos seatbelt profile file '${profileFile}'`
         );
@@ -129822,22 +130355,22 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
       ].join(" ");
       const args2 = [
         "-D",
-        `TARGET_DIR=${fs69.realpathSync(process.cwd())}`,
+        `TARGET_DIR=${fs72.realpathSync(process.cwd())}`,
         "-D",
-        `TMP_DIR=${fs69.realpathSync(os29.tmpdir())}`,
+        `TMP_DIR=${fs72.realpathSync(os29.tmpdir())}`,
         "-D",
-        `HOME_DIR=${fs69.realpathSync(os29.homedir())}`,
+        `HOME_DIR=${fs72.realpathSync(os29.homedir())}`,
         "-D",
-        `CACHE_DIR=${fs69.realpathSync(execSync7(`getconf DARWIN_USER_CACHE_DIR`).toString().trim())}`
+        `CACHE_DIR=${fs72.realpathSync(execSync7(`getconf DARWIN_USER_CACHE_DIR`).toString().trim())}`
       ];
       const MAX_INCLUDE_DIRS = 5;
-      const targetDir = fs69.realpathSync(cliConfig?.getTargetDir() || "");
+      const targetDir = fs72.realpathSync(cliConfig?.getTargetDir() || "");
       const includedDirs = [];
       if (cliConfig) {
         const workspaceContext = cliConfig.getWorkspaceContext();
         const directories = workspaceContext.getDirectories();
         for (const dir of directories) {
-          const realDir = fs69.realpathSync(dir);
+          const realDir = fs72.realpathSync(dir);
           if (realDir !== targetDir) {
             includedDirs.push(realDir);
           }
@@ -129910,16 +130443,16 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
       sandboxProcess2 = spawn6(config.command, args2, {
         stdio: "inherit"
       });
-      await new Promise((resolve20) => sandboxProcess2?.on("close", resolve20));
+      await new Promise((resolve19) => sandboxProcess2?.on("close", resolve19));
       return;
     }
     console.error(`hopping into sandbox (command: ${config.command}) ...`);
-    const gcPath = fs69.realpathSync(process.argv[1]);
+    const gcPath = fs72.realpathSync(process.argv[1]);
     const projectSandboxDockerfile = path81.join(
       SETTINGS_DIRECTORY_NAME,
       "sandbox.Dockerfile"
     );
-    const isCustomProjectSandbox = fs69.existsSync(projectSandboxDockerfile);
+    const isCustomProjectSandbox = fs72.existsSync(projectSandboxDockerfile);
     const image2 = config.image;
     const workdir = path81.resolve(process.cwd());
     const containerWorkdir = getContainerPath(workdir);
@@ -129976,8 +130509,8 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
     const userSettingsDirInSandbox = getContainerPath(
       `/home/node/${SETTINGS_DIRECTORY_NAME}`
     );
-    if (!fs69.existsSync(userSettingsDirOnHost)) {
-      fs69.mkdirSync(userSettingsDirOnHost);
+    if (!fs72.existsSync(userSettingsDirOnHost)) {
+      fs72.mkdirSync(userSettingsDirOnHost);
     }
     args.push(
       "--volume",
@@ -129991,7 +130524,7 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
     }
     args.push("--volume", `${os29.tmpdir()}:${getContainerPath(os29.tmpdir())}`);
     const gcloudConfigDir = path81.join(os29.homedir(), ".config", "gcloud");
-    if (fs69.existsSync(gcloudConfigDir)) {
+    if (fs72.existsSync(gcloudConfigDir)) {
       args.push(
         "--volume",
         `${gcloudConfigDir}:${getContainerPath(gcloudConfigDir)}:ro`
@@ -129999,7 +130532,7 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
     }
     if (process.env["GOOGLE_APPLICATION_CREDENTIALS"]) {
       const adcFile = process.env["GOOGLE_APPLICATION_CREDENTIALS"];
-      if (fs69.existsSync(adcFile)) {
+      if (fs72.existsSync(adcFile)) {
         args.push("--volume", `${adcFile}:${getContainerPath(adcFile)}:ro`);
         args.push(
           "--env",
@@ -130020,7 +130553,7 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
             );
             process.exit(1);
           }
-          if (!fs69.existsSync(from)) {
+          if (!fs72.existsSync(from)) {
             console.error(
               `ERROR: missing mount path '${from}' listed in SANDBOX_MOUNTS`
             );
@@ -130126,8 +130659,8 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
         SETTINGS_DIRECTORY_NAME,
         "sandbox.venv"
       );
-      if (!fs69.existsSync(sandboxVenvPath)) {
-        fs69.mkdirSync(sandboxVenvPath, { recursive: true });
+      if (!fs72.existsSync(sandboxVenvPath)) {
+        fs72.mkdirSync(sandboxVenvPath, { recursive: true });
       }
       args.push(
         "--volume",
@@ -130164,7 +130697,7 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
     args.push("--env", `SANDBOX=${containerName}`);
     if (config.command === "podman") {
       const emptyAuthFilePath = path81.join(os29.tmpdir(), "empty_auth.json");
-      fs69.writeFileSync(emptyAuthFilePath, "{}", "utf-8");
+      fs72.writeFileSync(emptyAuthFilePath, "{}", "utf-8");
       args.push("--authfile", emptyAuthFilePath);
     }
     let userFlag = "";
@@ -130235,14 +130768,14 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
     sandboxProcess.on("error", (err) => {
       console.error("Sandbox process error:", err);
     });
-    await new Promise((resolve20) => {
+    await new Promise((resolve19) => {
       sandboxProcess?.on("close", (code, signal) => {
         if (code !== 0) {
           console.log(
             `Sandbox process exited with code: ${code}, signal: ${signal}`
           );
         }
-        resolve20();
+        resolve19();
       });
     });
   } finally {
@@ -130250,7 +130783,7 @@ async function start_sandbox(config, nodeArgs = [], cliConfig) {
   }
 }
 async function imageExists(sandbox, image2) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve19) => {
     const args = ["images", "-q", image2];
     const checkProcess = spawn6(sandbox, args);
     let stdoutData = "";
@@ -130263,18 +130796,18 @@ async function imageExists(sandbox, image2) {
       console.warn(
         `Failed to start '${sandbox}' command for image check: ${err.message}`
       );
-      resolve20(false);
+      resolve19(false);
     });
     checkProcess.on("close", (code) => {
       if (code !== 0) {
       }
-      resolve20(stdoutData.trim() !== "");
+      resolve19(stdoutData.trim() !== "");
     });
   });
 }
 async function pullImage(sandbox, image2) {
   console.info(`Attempting to pull image ${image2} using ${sandbox}...`);
-  return new Promise((resolve20) => {
+  return new Promise((resolve19) => {
     const args = ["pull", image2];
     const pullProcess = spawn6(sandbox, args, { stdio: "pipe" });
     let stderrData = "";
@@ -130290,13 +130823,13 @@ async function pullImage(sandbox, image2) {
         `Failed to start '${sandbox} pull ${image2}' command: ${err.message}`
       );
       cleanup();
-      resolve20(false);
+      resolve19(false);
     };
     const onClose = (code) => {
       if (code === 0) {
         console.info(`Successfully pulled image ${image2}.`);
         cleanup();
-        resolve20(true);
+        resolve19(true);
       } else {
         console.warn(
           `Failed to pull image ${image2}. '${sandbox} pull ${image2}' exited with code ${code}.`
@@ -130304,7 +130837,7 @@ async function pullImage(sandbox, image2) {
         if (stderrData.trim()) {
         }
         cleanup();
-        resolve20(false);
+        resolve19(false);
       }
     };
     const cleanup = () => {
@@ -130362,17 +130895,17 @@ init_settings();
 
 // packages/cli/src/utils/startupWarnings.ts
 init_dist2();
-import fs70 from "fs/promises";
+import fs73 from "fs/promises";
 import os30 from "os";
 import { join as pathJoin } from "node:path";
 var warningsFilePath = pathJoin(os30.tmpdir(), "fss-link-warnings.txt");
 async function getStartupWarnings() {
   try {
-    await fs70.access(warningsFilePath);
-    const warningsContent = await fs70.readFile(warningsFilePath, "utf-8");
+    await fs73.access(warningsFilePath);
+    const warningsContent = await fs73.readFile(warningsFilePath, "utf-8");
     const warnings = warningsContent.split("\n").filter((line) => line.trim() !== "");
     try {
-      await fs70.unlink(warningsFilePath);
+      await fs73.unlink(warningsFilePath);
     } catch {
       warnings.push("Warning: Could not delete temporary warnings file.");
     }
@@ -130386,7 +130919,7 @@ async function getStartupWarnings() {
 }
 
 // packages/cli/src/utils/userStartupWarnings.ts
-import fs71 from "fs/promises";
+import fs74 from "fs/promises";
 import * as os31 from "os";
 import path82 from "path";
 var homeDirectoryCheck = {
@@ -130394,8 +130927,8 @@ var homeDirectoryCheck = {
   check: async (workspaceRoot) => {
     try {
       const [workspaceRealPath, homeRealPath] = await Promise.all([
-        fs71.realpath(workspaceRoot),
-        fs71.realpath(os31.homedir())
+        fs74.realpath(workspaceRoot),
+        fs74.realpath(os31.homedir())
       ]);
       if (workspaceRealPath === homeRealPath) {
         return "You are running FSS Link in your home directory. It is recommended to run in a project-specific directory.";
@@ -130410,7 +130943,7 @@ var rootDirectoryCheck = {
   id: "root-directory",
   check: async (workspaceRoot) => {
     try {
-      const workspaceRealPath = await fs71.realpath(workspaceRoot);
+      const workspaceRealPath = await fs74.realpath(workspaceRoot);
       const errorMessage = "Warning: You are running FSS Link in the root directory. Your entire folder structure will be used for context. It is strongly recommended to run in a project-specific directory.";
       if (path82.dirname(workspaceRealPath) === workspaceRealPath) {
         return errorMessage;
@@ -130694,7 +131227,7 @@ var AcpFileSystemService = class {
 // packages/cli/src/zed-integration/zedIntegration.ts
 init_zod();
 init_settings();
-import * as fs72 from "fs/promises";
+import * as fs75 from "fs/promises";
 import { Readable, Writable as Writable2 } from "node:stream";
 import * as path83 from "path";
 
@@ -131161,8 +131694,8 @@ var Connection = class {
   }
   async sendRequest(method, params) {
     const id = this.#nextRequestId++;
-    const responsePromise = new Promise((resolve20, reject) => {
-      this.#pendingResponses.set(id, { resolve: resolve20, reject });
+    const responsePromise = new Promise((resolve19, reject) => {
+      this.#pendingResponses.set(id, { resolve: resolve19, reject });
     });
     await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
     return responsePromise;
@@ -131646,7 +132179,7 @@ var Session = class {
       try {
         const absolutePath = path83.resolve(this.config.getTargetDir(), pathName);
         if (isWithinRoot(absolutePath, this.config.getTargetDir())) {
-          const stats = await fs72.stat(absolutePath);
+          const stats = await fs75.stat(absolutePath);
           if (stats.isDirectory()) {
             currentPathSpec = pathName.endsWith("/") ? `${pathName}**` : `${pathName}/**`;
             this.debug(
@@ -132011,7 +132544,7 @@ async function relaunchWithAdditionalArgs(additionalArgs) {
     stdio: "inherit",
     env: newEnv
   });
-  await new Promise((resolve20) => child.on("close", resolve20));
+  await new Promise((resolve19) => child.on("close", resolve19));
   process.exit(0);
 }
 function setupUnhandledRejectionHandler() {
@@ -132271,6 +132804,11 @@ main().catch((error) => {
  * Copyright 2025 FSS Coding
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /** 
  * @license
  * Copyright 2025 Google LLC