@plannotator/opencode 0.27.2 → 0.27.3

package/dist/embedded.js

@@ -44411,27 +44411,9 @@ var init_chokidar = __esm(() => {
   chokidar_default = { watch, FSWatcher };
 });
 
-// ../../packages/server/reference-watch.ts
-import { existsSync as existsSync11, statSync as statSync8, watch as watch2 } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute5, relative as relative5, resolve as resolve9 } from "path";
-function serialize(event) {
-  return encoder.encode(`data: ${JSON.stringify(event)}
-
-`);
-}
-function isFileBrowserWatchIgnoredPath(path2, root3) {
-  const rel = relative5(root3, path2).replace(/\\/g, "/");
-  if (!rel || rel.startsWith("..") || isAbsolute5(rel))
-    return false;
-  return isFileBrowserExcludedPath(rel);
-}
-function isValidDirectory(dirPath) {
-  try {
-    return existsSync11(dirPath) && statSync8(dirPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
+// ../../packages/shared/file-browser-watch-core.ts
+import { watch as nodeFsWatch, statSync as statSync8 } from "fs";
+import { resolve as resolve9 } from "path";
 function getFileSignature(filePath) {
   try {
     const stats = statSync8(filePath, { bigint: true });
@@ -44453,59 +44435,51 @@ function createExactFileWatchListener(watchPath, exactFilePath, onChange) {
     } catch {}
   };
 }
-function broadcast(entry, reason) {
-  for (const [subscriber, clientDirPath] of entry.subscribers) {
-    const payload = serialize({
-      type: "changed",
-      dirPath: clientDirPath,
-      reason,
-      timestamp: Date.now()
-    });
-    try {
-      subscriber.enqueue(payload);
-    } catch {
-      entry.subscribers.delete(subscriber);
+function nativeRecursiveSupported() {
+  return process.platform === "darwin" || process.platform === "win32";
+}
+function createFileBrowserWatchRegistry(initialOptions) {
+  const options = { ...initialOptions };
+  const watchers = new Map;
+  let contentWatcherStarts = 0;
+  const teardownGraceMs = () => options.teardownGraceMs ?? DEFAULT_TEARDOWN_GRACE_MS;
+  const debounceMs = () => options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  function broadcast(entry, reason) {
+    const hadSubscribers = entry.subscribers.size > 0;
+    for (const [subscriber, clientDirPath] of entry.subscribers) {
+      const event = {
+        type: "changed",
+        dirPath: clientDirPath,
+        reason,
+        timestamp: Date.now()
+      };
+      let delivered = false;
+      try {
+        delivered = options.send(subscriber, event);
+      } catch {
+        delivered = false;
+      }
+      if (!delivered)
+        entry.subscribers.delete(subscriber);
     }
+    if (hadSubscribers && entry.subscribers.size === 0)
+      scheduleTeardown(entry);
   }
-}
-function scheduleBroadcast(entry, reason) {
-  if (entry.debounceTimer)
-    clearTimeout(entry.debounceTimer);
-  entry.debounceTimer = setTimeout(() => {
-    entry.debounceTimer = null;
-    broadcast(entry, reason);
-  }, DEBOUNCE_MS);
-}
-function closeWatcher(entry) {
-  if (entry.debounceTimer)
-    clearTimeout(entry.debounceTimer);
-  entry.contentWatcher?.close();
-  entry.gitWatcher?.close();
-  if (watchers.get(entry.key) === entry) {
-    watchers.delete(entry.key);
-  }
-}
-function releaseSubscriber(entry, controller) {
-  entry.subscribers.delete(controller);
-  if (entry.subscribers.size === 0)
-    closeWatcher(entry);
-}
-function ensureWatcher(target) {
-  const existing = watchers.get(target.key);
-  if (existing)
-    return existing;
-  const entry = {
-    key: target.key,
-    subscribers: new Map,
-    contentWatcher: null,
-    gitWatcher: null,
-    debounceTimer: null
-  };
-  if (target.exactFilePath) {
-    entry.contentWatcher = watch2(target.watchPath, { persistent: true }, createExactFileWatchListener(target.watchPath, target.exactFilePath, () => scheduleBroadcast(entry, "files")));
-    entry.contentWatcher.on("error", () => scheduleBroadcast(entry, "files"));
-  } else {
-    entry.contentWatcher = chokidar_default.watch(target.watchPath, {
+  function scheduleBroadcast(entry, reason) {
+    if (entry.closed)
+      return;
+    if (entry.debounceTimer)
+      clearTimeout(entry.debounceTimer);
+    entry.debounceTimer = setTimeout(() => {
+      entry.debounceTimer = null;
+      broadcast(entry, reason);
+    }, debounceMs());
+  }
+  function isCurrent(entry) {
+    return !entry.closed && watchers.get(entry.key) === entry;
+  }
+  function startChokidarContentWatcher(entry, target) {
+    const watcher = chokidar_default.watch(target.watchPath, {
       ignoreInitial: true,
       persistent: true,
       ignored: target.ignored,
@@ -44514,34 +44488,201 @@ function ensureWatcher(target) {
         pollInterval: 30
       }
     });
-    entry.contentWatcher.on("all", () => {
-      scheduleBroadcast(entry, "files");
-    });
-    entry.contentWatcher.on("error", () => scheduleBroadcast(entry, "files"));
+    watcher.on("all", () => scheduleBroadcast(entry, "files"));
+    watcher.on("error", () => scheduleBroadcast(entry, "files"));
+    return watcher;
+  }
+  function startContentWatcher(entry, target) {
+    contentWatcherStarts += 1;
+    if (target.exactFilePath) {
+      const exactFilePath = target.exactFilePath;
+      const watcher = (options.nativeWatch ?? nodeFsWatch)(target.watchPath, { persistent: true }, createExactFileWatchListener(target.watchPath, exactFilePath, () => scheduleBroadcast(entry, "files")));
+      watcher.on("error", () => scheduleBroadcast(entry, "files"));
+      entry.contentWatcher = watcher;
+      return;
+    }
+    const backend = options.contentWatchBackend ?? "auto";
+    if (backend === "native" || backend === "auto" && nativeRecursiveSupported()) {
+      try {
+        const nativeWatch = options.nativeWatch ?? nodeFsWatch;
+        const watcher = nativeWatch(target.watchPath, { recursive: true, persistent: true }, (_event, filename) => {
+          try {
+            if (filename != null) {
+              const abs = resolve9(target.watchPath, filename.toString());
+              if (target.ignored?.(abs))
+                return;
+            }
+            scheduleBroadcast(entry, "files");
+          } catch {}
+        });
+        watcher.on("error", (error) => {
+          try {
+            watcher.close();
+          } catch {}
+          if (isCurrent(entry) && entry.contentWatcher === watcher) {
+            console.error(`[plannotator] Native file watching failed for ${target.watchPath}; switching to the fallback watcher:`, error);
+            contentWatcherStarts += 1;
+            entry.contentWatcher = startChokidarContentWatcher(entry, target);
+            scheduleBroadcast(entry, "files");
+          }
+        });
+        entry.contentWatcher = watcher;
+        return;
+      } catch (error) {
+        console.error(`[plannotator] Native file watching unavailable for ${target.watchPath}; using the fallback watcher:`, error);
+      }
+    }
+    entry.contentWatcher = startChokidarContentWatcher(entry, target);
   }
-  const gitWatchPaths = target.watchGit ? getGitMetadataWatchPaths(target.watchPath) : [];
-  if (gitWatchPaths.length > 0) {
-    entry.gitWatcher = chokidar_default.watch(gitWatchPaths, {
-      ignoreInitial: true,
-      persistent: true,
-      depth: 0,
-      awaitWriteFinish: {
-        stabilityThreshold: 80,
-        pollInterval: 30
+  function buildWatchers(entry, target) {
+    if (!isCurrent(entry))
+      return;
+    try {
+      startContentWatcher(entry, target);
+    } catch (error) {
+      console.error(`[plannotator] File watcher failed to start for ${target.watchPath}:`, error);
+    }
+    try {
+      const gitWatchPaths = target.watchGit ? options.getGitMetadataWatchPaths(target.watchPath) : [];
+      if (gitWatchPaths.length > 0) {
+        entry.gitWatcher = chokidar_default.watch(gitWatchPaths, {
+          ignoreInitial: true,
+          persistent: true,
+          depth: 0,
+          awaitWriteFinish: {
+            stabilityThreshold: 80,
+            pollInterval: 30
+          }
+        });
+        entry.gitWatcher.on("all", () => scheduleBroadcast(entry, "git"));
+        entry.gitWatcher.on("error", () => scheduleBroadcast(entry, "git"));
       }
-    });
-    entry.gitWatcher.on("all", () => scheduleBroadcast(entry, "git"));
-    entry.gitWatcher.on("error", () => scheduleBroadcast(entry, "git"));
+    } catch (error) {
+      console.error(`[plannotator] Git metadata watcher failed to start for ${target.watchPath}:`, error);
+    }
+  }
+  function closeEntry(entry) {
+    entry.closed = true;
+    if (entry.debounceTimer)
+      clearTimeout(entry.debounceTimer);
+    if (entry.warmupTimer)
+      clearTimeout(entry.warmupTimer);
+    if (entry.teardownTimer)
+      clearTimeout(entry.teardownTimer);
+    entry.debounceTimer = null;
+    entry.warmupTimer = null;
+    entry.teardownTimer = null;
+    try {
+      entry.contentWatcher?.close();
+    } catch {}
+    try {
+      entry.gitWatcher?.close();
+    } catch {}
+    if (watchers.get(entry.key) === entry) {
+      watchers.delete(entry.key);
+    }
+  }
+  function scheduleTeardown(entry) {
+    if (entry.closed)
+      return;
+    if (entry.teardownTimer)
+      clearTimeout(entry.teardownTimer);
+    const timer = setTimeout(() => {
+      entry.teardownTimer = null;
+      if (entry.subscribers.size === 0)
+        closeEntry(entry);
+    }, teardownGraceMs());
+    timer.unref?.();
+    entry.teardownTimer = timer;
+  }
+  return {
+    ensure(target) {
+      const existing = watchers.get(target.key);
+      if (existing) {
+        if (existing.teardownTimer) {
+          clearTimeout(existing.teardownTimer);
+          existing.teardownTimer = null;
+        }
+        return existing;
+      }
+      const entry = {
+        key: target.key,
+        subscribers: new Map,
+        contentWatcher: null,
+        gitWatcher: null,
+        debounceTimer: null,
+        warmupTimer: null,
+        teardownTimer: null,
+        closed: false
+      };
+      entry.warmupTimer = setTimeout(() => {
+        entry.warmupTimer = null;
+        buildWatchers(entry, target);
+      }, 0);
+      watchers.set(target.key, entry);
+      return entry;
+    },
+    attach(handle2, subscriber, clientDirPath) {
+      const entry = watchers.get(handle2.key);
+      if (!entry || entry.closed)
+        return;
+      entry.subscribers.set(subscriber, clientDirPath);
+    },
+    release(handle2, subscriber) {
+      const entry = watchers.get(handle2.key);
+      if (!entry)
+        return;
+      entry.subscribers.delete(subscriber);
+      if (entry.subscribers.size === 0)
+        scheduleTeardown(entry);
+    },
+    closeAll() {
+      for (const entry of [...watchers.values()])
+        closeEntry(entry);
+    },
+    diagnostics() {
+      return { entries: watchers.size, contentWatcherStarts };
+    },
+    configureForTests(overrides) {
+      Object.assign(options, overrides);
+    }
+  };
+}
+var DEFAULT_TEARDOWN_GRACE_MS = 30000, DEFAULT_DEBOUNCE_MS = 180;
+var init_file_browser_watch_core = __esm(() => {
+  init_chokidar();
+});
+
+// ../../packages/server/reference-watch.ts
+import { existsSync as existsSync11, statSync as statSync9 } from "fs";
+import { dirname as dirname5, isAbsolute as isAbsolute5, relative as relative5 } from "path";
+function serialize(event) {
+  return encoder.encode(`data: ${JSON.stringify(event)}
+
+`);
+}
+function closeAllFileBrowserWatchers() {
+  registry.closeAll();
+}
+function isFileBrowserWatchIgnoredPath(path2, root3) {
+  const rel = relative5(root3, path2).replace(/\\/g, "/");
+  if (!rel || rel.startsWith("..") || isAbsolute5(rel))
+    return false;
+  return isFileBrowserExcludedPath(rel);
+}
+function isValidDirectory(dirPath) {
+  try {
+    return existsSync11(dirPath) && statSync9(dirPath).isDirectory();
+  } catch {
+    return false;
   }
-  watchers.set(target.key, entry);
-  return entry;
 }
 function isValidFileTarget(filePath) {
   if (!filePath)
     return false;
   try {
     if (existsSync11(filePath))
-      return !statSync8(filePath).isDirectory();
+      return !statSync9(filePath).isDirectory();
     return isValidDirectory(dirname5(filePath));
   } catch {
     return false;
@@ -44593,7 +44734,7 @@ function handleFileBrowserFilesStream(req, options) {
   }
   options?.disableIdleTimeout?.();
   const subscriptions = [...targets.values()].map((target) => ({
-    entry: ensureWatcher(target),
+    handle: registry.ensure(target),
     clientDirPath: target.clientDirPath
   }));
   let controllerRef = null;
@@ -44601,8 +44742,8 @@ function handleFileBrowserFilesStream(req, options) {
   const stream = new ReadableStream({
     start(controller) {
       controllerRef = controller;
-      for (const { entry, clientDirPath } of subscriptions) {
-        entry.subscribers.set(controller, clientDirPath);
+      for (const { handle: handle2, clientDirPath } of subscriptions) {
+        registry.attach(handle2, controller, clientDirPath);
         controller.enqueue(serialize({
           type: "ready",
           dirPath: clientDirPath,
@@ -44616,8 +44757,8 @@ function handleFileBrowserFilesStream(req, options) {
 
 `));
         } catch {
-          for (const { entry } of subscriptions)
-            releaseSubscriber(entry, controller);
+          for (const { handle: handle2 } of subscriptions)
+            registry.release(handle2, controller);
           if (heartbeatTimer)
             clearInterval(heartbeatTimer);
         }
@@ -44627,8 +44768,8 @@ function handleFileBrowserFilesStream(req, options) {
       if (heartbeatTimer)
         clearInterval(heartbeatTimer);
       if (controllerRef) {
-        for (const { entry } of subscriptions)
-          releaseSubscriber(entry, controllerRef);
+        for (const { handle: handle2 } of subscriptions)
+          registry.release(handle2, controllerRef);
       }
     }
   });
@@ -44640,14 +44781,24 @@ function handleFileBrowserFilesStream(req, options) {
     }
   });
 }
-var HEARTBEAT_MS = 30000, DEBOUNCE_MS = 180, watchers, encoder;
+var HEARTBEAT_MS = 30000, encoder, registry;
 var init_reference_watch = __esm(() => {
-  init_chokidar();
+  init_file_browser_watch_core();
   init_reference_common();
   init_resolve_file();
   init_workspace_status();
-  watchers = new Map;
   encoder = new TextEncoder;
+  registry = createFileBrowserWatchRegistry({
+    send: (subscriber, event) => {
+      try {
+        subscriber.enqueue(serialize(event));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    getGitMetadataWatchPaths
+  });
 });
 
 // ../../packages/server/editor-annotations.ts
@@ -45512,7 +45663,7 @@ function clampPositiveNumber(value, max) {
 }
 function createAIEndpoints(deps) {
   const {
-    registry,
+    registry: registry2,
     sessionManager,
     getCwd,
     beforeCapabilities,
@@ -45522,12 +45673,12 @@ function createAIEndpoints(deps) {
     "/api/ai/capabilities": async (req) => {
       await beforeCapabilities?.();
       const activateId = new URL(req.url).searchParams.get("activate");
-      if (activateId && registry.get(activateId)) {
+      if (activateId && registry2.get(activateId)) {
         await beforeProviderSession?.(activateId);
       }
-      const defaultEntry = registry.getDefault();
-      const providerDetails = registry.list().map((id) => {
-        const p2 = registry.get(id);
+      const defaultEntry = registry2.getDefault();
+      const providerDetails = registry2.list().map((id) => {
+        const p2 = registry2.get(id);
         return {
           id,
           name: p2.name,
@@ -45550,7 +45701,7 @@ function createAIEndpoints(deps) {
       if (!context?.mode) {
         return Response.json({ error: "Missing context.mode" }, { status: 400 });
       }
-      const providerEntry = providerId ? { id: providerId, provider: registry.get(providerId) } : registry.getDefault();
+      const providerEntry = providerId ? { id: providerId, provider: registry2.get(providerId) } : registry2.getDefault();
       const provider = providerEntry?.provider;
       if (!provider) {
         return Response.json({ error: providerId ? `Provider "${providerId}" not found` : "No AI provider available" }, { status: 503 });
@@ -76815,7 +76966,7 @@ var init_opencode_sdk = __esm(() => {
 // ../../packages/server/ai-runtime.ts
 async function createAIRuntime(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const registry = new ProviderRegistry;
+  const registry2 = new ProviderRegistry;
   const sessionManager = new SessionManager;
   const modelDiscovery = [];
   const providerInitializers = new Map;
@@ -76827,7 +76978,7 @@ async function createAIRuntime(options = {}) {
       cwd,
       ...claudePath && { claudeExecutablePath: claudePath }
     });
-    registry.register(provider);
+    registry2.register(provider);
   } catch {}
   try {
     await Promise.resolve().then(() => (init_codex_app_server(), exports_codex_app_server));
@@ -76838,7 +76989,7 @@ async function createAIRuntime(options = {}) {
         cwd,
         ...codexPath ? { codexExecutablePath: codexPath } : {}
       });
-      const providerId = registry.register(provider);
+      const providerId = registry2.register(provider);
       if ("fetchModels" in provider) {
         providerInitializers.set(providerId, createBestEffortOnce(() => provider.fetchModels()));
       }
@@ -76857,7 +77008,7 @@ async function createAIRuntime(options = {}) {
       if (provider instanceof PiSDKProvider2) {
         modelDiscovery.push(provider.fetchModels().catch(() => {}));
       }
-      registry.register(provider);
+      registry2.register(provider);
     }
   } catch {}
   try {
@@ -76871,11 +77022,11 @@ async function createAIRuntime(options = {}) {
       if (provider instanceof OpenCodeProvider2) {
         modelDiscovery.push(provider.fetchModels().catch(() => {}));
       }
-      registry.register(provider);
+      registry2.register(provider);
     }
   } catch {}
   const endpoints = createAIEndpoints({
-    registry,
+    registry: registry2,
     sessionManager,
     getCwd: options.getCwd,
     beforeCapabilities: async () => {
@@ -76889,7 +77040,7 @@ async function createAIRuntime(options = {}) {
     endpoints,
     dispose: () => {
       sessionManager.disposeAll();
-      registry.disposeAll();
+      registry2.disposeAll();
     }
   };
 }
@@ -77306,6 +77457,7 @@ async function startPlannotatorServer(options) {
   const stop2 = () => {
     stopPromise ??= (async () => {
       try {
+        closeAllFileBrowserWatchers();
         aiRuntime?.dispose();
       } finally {
         await server2.stop(true);
@@ -82872,7 +83024,7 @@ import {
   openSync as openSync3,
   readFileSync as readFileSync10,
   rmSync as rmSync2,
-  statSync as statSync10,
+  statSync as statSync11,
   writeFileSync as writeFileSync6
 } from "fs";
 import { dirname as dirname6, join as join17 } from "path";
@@ -82908,7 +83060,7 @@ async function withCallFlowInstallLock(work, options = {}) {
       if (!hasErrorCode(error, "EEXIST"))
         throw error;
       try {
-        if (now() - statSync10(lockPath).mtimeMs > staleAfterMs) {
+        if (now() - statSync11(lockPath).mtimeMs > staleAfterMs) {
           rmSync2(lockPath);
           continue;
         }
@@ -83213,7 +83365,7 @@ var init_call_flow_types = __esm(() => {
 
 // ../../packages/shared/call-flow.ts
 import { createHash as createHash4 } from "crypto";
-import { chmodSync as chmodSync2, cpSync, existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync11, readdirSync as readdirSync5, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync11, writeFileSync as writeFileSync7 } from "fs";
+import { chmodSync as chmodSync2, cpSync, existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync11, readdirSync as readdirSync5, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync12, writeFileSync as writeFileSync7 } from "fs";
 import { mkdtemp } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { basename as basename7, dirname as dirname7, isAbsolute as isAbsolute7, join as join18 } from "path";
@@ -83698,7 +83850,7 @@ async function preserveValidatedLanguagePacks(nodePath, currentRuntimeDir, candi
 function measureCallFlowDirectoryBytes(path2) {
   if (!existsSync15(path2))
     return 0;
-  const stat5 = statSync11(path2);
+  const stat5 = statSync12(path2);
   if (!stat5.isDirectory())
     return stat5.size;
   return readdirSync5(path2).reduce((total, entry) => total + measureCallFlowDirectoryBytes(join18(path2, entry)), 0);
@@ -86284,7 +86436,7 @@ function createAgentJobHandler(options) {
     }));
     return { mode, providers, available: providers.some((p2) => p2.available) };
   }
-  function broadcast2(event) {
+  function broadcast(event) {
     version++;
     const data = encoder2.encode(serializeAgentSSEEvent(event));
     for (const controller of subscribers) {
@@ -86351,7 +86503,7 @@ function createAgentJobHandler(options) {
         jobOutputPaths.set(`${id}:cwd`, spawnOptions.cwd);
       if (spawnOptions?.changedFilesSnapshot)
         jobChangedFilesSnapshots.set(id, spawnOptions.changedFilesSnapshot);
-      broadcast2({ type: "job:started", job: { ...info } });
+      broadcast({ type: "job:started", job: { ...info } });
       let stderrBuf = "";
       let logPending = "";
       let logFlushTimer = null;
@@ -86366,7 +86518,7 @@ function createAgentJobHandler(options) {
               if (!logFlushTimer) {
                 logFlushTimer = setTimeout(() => {
                   if (logPending) {
-                    broadcast2({ type: "job:log", jobId: id, delta: logPending });
+                    broadcast({ type: "job:log", jobId: id, delta: logPending });
                     logPending = "";
                   }
                   logFlushTimer = null;
@@ -86378,7 +86530,7 @@ function createAgentJobHandler(options) {
               logFlushTimer = null;
             }
             if (logPending) {
-              broadcast2({ type: "job:log", jobId: id, delta: logPending });
+              broadcast({ type: "job:log", jobId: id, delta: logPending });
               logPending = "";
             }
           } catch {}
@@ -86392,7 +86544,7 @@ function createAgentJobHandler(options) {
           if (provider === "claude" || spawnOptions?.engine === "claude") {
             const formatted = formatClaudeLogEvent(line);
             if (formatted !== null)
-              broadcast2({ type: "job:log", jobId: id, delta: formatted + `
+              broadcast({ type: "job:log", jobId: id, delta: formatted + `
 ` });
             return;
           }
@@ -86400,7 +86552,7 @@ function createAgentJobHandler(options) {
           if (markerEngine) {
             const formatted = formatMarkerLogEvent(line, markerEngine);
             if (formatted !== null)
-              broadcast2({ type: "job:log", jobId: id, delta: formatted + `
+              broadcast({ type: "job:log", jobId: id, delta: formatted + `
 ` });
             return;
           }
@@ -86409,7 +86561,7 @@ function createAgentJobHandler(options) {
             if (event.type === "result")
               return;
           } catch {}
-          broadcast2({ type: "job:log", jobId: id, delta: line + `
+          broadcast({ type: "job:log", jobId: id, delta: line + `
 ` });
         };
         try {
@@ -86463,15 +86615,15 @@ function createAgentJobHandler(options) {
         jobOutputPaths.delete(id);
         jobOutputPaths.delete(`${id}:cwd`);
         jobChangedFilesSnapshots.delete(id);
-        broadcast2({ type: "job:completed", job: { ...entry.info } });
+        broadcast({ type: "job:completed", job: { ...entry.info } });
       }).catch(() => {});
     } catch (err) {
       jobs.set(id, { info, proc: null });
-      broadcast2({ type: "job:started", job: { ...info } });
+      broadcast({ type: "job:started", job: { ...info } });
       info.status = "failed";
       info.endedAt = Date.now();
       info.error = err instanceof Error ? err.message : String(err);
-      broadcast2({ type: "job:completed", job: { ...info } });
+      broadcast({ type: "job:completed", job: { ...info } });
     }
     return { ...info };
   }
@@ -86489,7 +86641,7 @@ function createAgentJobHandler(options) {
     jobOutputPaths.delete(id);
     jobOutputPaths.delete(`${id}:cwd`);
     jobChangedFilesSnapshots.delete(id);
-    broadcast2({ type: "job:completed", job: { ...entry.info } });
+    broadcast({ type: "job:completed", job: { ...entry.info } });
     return true;
   }
   function killAll() {
@@ -86519,7 +86671,7 @@ function createAgentJobHandler(options) {
     entry.info.error = undefined;
     entry.info.summary = summary;
     entry.info.exitCode = 0;
-    broadcast2({ type: "job:completed", job: { ...entry.info } });
+    broadcast({ type: "job:completed", job: { ...entry.info } });
     return true;
   }
   return {
@@ -99035,7 +99187,7 @@ var init_html_assets = __esm(() => {
 });
 
 // ../../packages/shared/html-assets-node.ts
-import { existsSync as existsSync18, readFileSync as readFileSync14, realpathSync as realpathSync5, statSync as statSync12 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync14, realpathSync as realpathSync5, statSync as statSync13 } from "fs";
 import { dirname as dirname9, isAbsolute as isAbsolute8, relative as relative8, resolve as resolvePath2, posix as pathPosix2 } from "path";
 function inlineHtmlLocalAssets(html5, htmlFilePath) {
   if (/^https?:\/\//i.test(htmlFilePath))
@@ -99053,7 +99205,7 @@ function inlineHtmlLocalAssets(html5, htmlFilePath) {
           return null;
         if (!existsSync18(resolved))
           return null;
-        const stat5 = statSync12(resolved);
+        const stat5 = statSync13(resolved);
         if (!stat5.isFile() || stat5.size > MAX_HTML_ASSET_BYTES)
           return null;
         let bytes = readFileSync14(resolved);
@@ -104284,11 +104436,15 @@ async function startAnnotateServer(options) {
   const serverUrl = buildAdvertisedUrl(port);
   warmFileListCache(process.cwd(), "code");
   const stop2 = () => {
-    clientLease.cancel();
-    clientLease.closeSessions();
-    aiRuntime?.dispose();
-    agentTerminal.dispose();
-    server2.stop();
+    try {
+      closeAllFileBrowserWatchers();
+      clientLease.cancel();
+      clientLease.closeSessions();
+      aiRuntime?.dispose();
+      agentTerminal.dispose();
+    } finally {
+      server2.stop();
+    }
   };
   if (onReady) {
     try {
@@ -104401,7 +104557,7 @@ var init_annotate_args = __esm(() => {
 });
 
 // ../../packages/shared/annotate-target.ts
-import { existsSync as existsSync22, statSync as statSync13 } from "fs";
+import { existsSync as existsSync22, statSync as statSync14 } from "fs";
 function probeAnnotateToken(token2, projectRoot, options) {
   if (!token2)
     return null;
@@ -104412,7 +104568,7 @@ function probeAnnotateToken(token2, projectRoot, options) {
   if (allowBareDirectory || /[\\/]/.test(token2)) {
     const folder = resolveAtReference(token2, (candidate) => {
       try {
-        return statSync13(resolveUserPath(candidate, projectRoot)).isDirectory();
+        return statSync14(resolveUserPath(candidate, projectRoot)).isDirectory();
       } catch {
         return false;
       }
@@ -104436,7 +104592,7 @@ function probeAnnotateToken(token2, projectRoot, options) {
     return unwrapped;
   const literal = resolveAtReference(token2, (candidate) => {
     try {
-      return statSync13(resolveUserPath(candidate, projectRoot)).isFile();
+      return statSync14(resolveUserPath(candidate, projectRoot)).isFile();
     } catch {
       return false;
     }
@@ -104815,7 +104971,7 @@ var init_url_to_markdown = __esm(() => {
 });
 
 // ../../packages/shared/review-workspace-node.ts
-import { existsSync as existsSync23, readdirSync as readdirSync7, realpathSync as realpathSync7, statSync as statSync14 } from "fs";
+import { existsSync as existsSync23, readdirSync as readdirSync7, realpathSync as realpathSync7, statSync as statSync15 } from "fs";
 import { basename as basename10, relative as relative9, resolve as resolve13 } from "path";
 function normalizeWorkspacePath(path3) {
   return path3.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -104923,7 +105079,7 @@ function hasVcsMarker(dirPath) {
 }
 function resolveDirectoryRealPath(path3) {
   try {
-    if (!statSync14(path3).isDirectory())
+    if (!statSync15(path3).isDirectory())
       return null;
     return realpathSync7(path3);
   } catch {
@@ -105415,7 +105571,7 @@ __export(exports_commands, {
   handleAnnotateLastCommand: () => handleAnnotateLastCommand,
   handleAnnotateCommand: () => handleAnnotateCommand
 });
-import { statSync as statSync15 } from "fs";
+import { statSync as statSync16 } from "fs";
 import path3 from "path";
 async function handleReviewCommand(event, deps) {
   const { client: client3, reviewHtmlContent, getSharingEnabled, getShareBaseUrl, directory } = deps;
@@ -105597,7 +105753,7 @@ async function handleAnnotateCommand(event, deps) {
     const projectRoot = agentCwd;
     const resolvedArg = resolveUserPath(filePath, projectRoot);
     try {
-      isFolder = statSync15(resolvedArg).isDirectory();
+      isFolder = statSync16(resolvedArg).isDirectory();
     } catch {}
     if (isFolder) {
       if (!hasMarkdownFiles(resolvedArg, FILE_BROWSER_EXCLUDED, getAnnotatableDocRegex())) {
@@ -105611,7 +105767,7 @@ async function handleAnnotateCommand(event, deps) {
       client3.app.log({ level: "info", message: `Opening annotation UI for folder ${resolvedArg}...` });
     } else if (/\.html?$/i.test(resolvedArg)) {
       try {
-        statSync15(resolvedArg);
+        statSync16(resolvedArg);
       } catch {
         client3.app.log({ level: "error", message: `File not found: ${filePath}` });
         return;