chatroom-cli 1.68.4 → 1.68.5

package/dist/index.js

@@ -77106,6 +77106,40 @@ function getFileReferenceProofOfCompletionExample() {
 - \`apps/webapp/src/path/to/file.ts\` — <what changed and why>`;
 }
 
+// ../../services/backend/prompts/utils/handoff-quality-principles.ts
+function getHandoffQualityPrinciplesCommentBlock() {
+  const bullets = HANDOFF_QUALITY_PRINCIPLES.map((p) => `- ${p.name}: ${p.description}`).join(`
+`);
+  return `<!-- Demonstrate adherence to:
+${bullets}
+-->`;
+}
+var HANDOFF_QUALITY_PRINCIPLES, PROOF_OF_PRINCIPLES_HEADING_H2 = "## Proof of Principles", PROOF_OF_PRINCIPLES_HEADING_H3 = "### Proof of Principles";
+var init_handoff_quality_principles = __esm(() => {
+  HANDOFF_QUALITY_PRINCIPLES = [
+    {
+      name: "Semantic Consistency",
+      description: "the organization of the code, the code and the functionality of the code use a consistent and well maintained set of terms."
+    },
+    {
+      name: "Organization & Maintainability",
+      description: "a small change in requirements should result in a small change in code in a small number of files and folders."
+    },
+    {
+      name: "Static Evaluability and Provability",
+      description: "the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order."
+    },
+    {
+      name: "No Revisit",
+      description: "implemented in a way so the user does not have to revisit this implementation again."
+    },
+    {
+      name: "Leave It Better",
+      description: "leave the code in a slightly better state than before when touching files."
+    }
+  ];
+});
+
 // ../../services/backend/prompts/cli/role-guidance/command.ts
 function roleGuidanceCommand(params = {}) {
   const prefix = params.cliEnvPrefix ?? "";
@@ -77140,13 +77174,8 @@ function getBuilderToPlannerHandoffTemplate(roleGuidanceContext) {
 - [ ] I confirm that I have seen this template at the start of this task, before implementing or modifying any code
 ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 
-## Proof of Principle
-<!-- Demonstrate adherence to:
-- Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
-- Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
-- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
-- Leave It Better: leave the code in a slightly better state than before when touching files.
--->
+${PROOF_OF_PRINCIPLES_HEADING_H2}
+${getHandoffQualityPrinciplesCommentBlock()}
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
 ## Proof of Completion
@@ -77165,6 +77194,7 @@ ${CODE_CHANGE_VERIFICATION_CONFIRMATION}
 \`\`\``;
 }
 var init_builder_to_planner = __esm(() => {
+  init_handoff_quality_principles();
   init_role_guidance_disclosure();
 });
 
@@ -77303,13 +77333,8 @@ ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 ## What changed
 <high-level view of what changed since the user's message before the detailed proofs below>
 
-### Proof of Principle
-<!-- Demonstrate adherence to:
-- Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
-- Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
-- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
-- Leave It Better: leave the code in a slightly better state than before when touching files.
--->
+${PROOF_OF_PRINCIPLES_HEADING_H3}
+${getHandoffQualityPrinciplesCommentBlock()}
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
 ### Proof of Completion
@@ -77354,6 +77379,7 @@ ${getUnresolvedDecisionsSectionBlock()}
 }
 var init_planner_to_user = __esm(() => {
   init_context_disclosure();
+  init_handoff_quality_principles();
   init_role_guidance_disclosure();
 });
 
@@ -77405,13 +77431,8 @@ ${getRoleGuidanceDisclosureBlock(roleGuidanceContext)}
 ## What changed
 <high-level view of what changed since the user's message before the detailed proofs below>
 
-### Proof of Principle
-<!-- Demonstrate adherence to:
-- Organization & Maintainability: a small change in requirements should result in a small change in code in a small number of files and folders.
-- Static Evaluability and Provability: the system's behavior should be provably correct by looking at the source code, then automated tests, then manual tests, in this order.
-- No Revisit: implemented in a way so the user does not have to revisit this implementation again.
-- Leave It Better: leave the code in a slightly better state than before when touching files.
--->
+${PROOF_OF_PRINCIPLES_HEADING_H3}
+${getHandoffQualityPrinciplesCommentBlock()}
 <how this work follows the principles above — localized changes, readable structure, correctness provable from source then tests>
 
 ### Proof of Completion
@@ -77456,6 +77477,7 @@ ${getUnresolvedDecisionsSectionBlock()}
 }
 var init_solo_to_user = __esm(() => {
   init_context_disclosure();
+  init_handoff_quality_principles();
   init_role_guidance_disclosure();
 });
 
@@ -101119,8 +101141,31 @@ function gunzipBase64Payload(base643, maxBytes) {
 var init_workspace_path_security = () => {};
 
 // src/infrastructure/services/workspace/workspace-visibility-policy.ts
+function isHiddenDirName(name) {
+  return HIDDEN_DIR_NAMES.has(name);
+}
+function isShallowSyncDirName(name) {
+  return SHALLOW_SYNC_DIR_NAMES.has(name);
+}
 function isAlwaysExcludedDirName(name) {
-  return ALWAYS_EXCLUDE_DIR_NAMES.has(name);
+  return isHiddenDirName(name) || isShallowSyncDirName(name);
+}
+function shouldShallowSyncByHeuristics(context5) {
+  if (context5.immediateChildCount >= SHALLOW_HEURISTIC_MIN_CHILD_COUNT)
+    return true;
+  if (!context5.relativePath.includes("/") && context5.immediateSiblingCount >= 300) {
+    return context5.immediateChildCount >= 100;
+  }
+  return false;
+}
+function classifyDirectorySyncMode(dirName, context5) {
+  if (isHiddenDirName(dirName))
+    return "hidden";
+  if (isShallowSyncDirName(dirName))
+    return "shallow";
+  if (shouldShallowSyncByHeuristics(context5))
+    return "shallow";
+  return "full";
 }
 function isSecretPath(relativePath) {
   const normalized = relativePath.replace(/\\/g, "/");
@@ -101128,7 +101173,15 @@ function isSecretPath(relativePath) {
 }
 function hasExcludedDirSegment(relativePath) {
   const segments = relativePath.split("/");
-  return segments.some((segment) => isAlwaysExcludedDirName(segment));
+  const lastIndex = segments.length - 1;
+  for (let index = 0;index < segments.length; index++) {
+    const name = segments[index];
+    if (isHiddenDirName(name))
+      return true;
+    if (isShallowSyncDirName(name) && index < lastIndex)
+      return true;
+  }
+  return false;
 }
 function isPathVisible(relativePath) {
   if (!relativePath)
@@ -101138,11 +101191,11 @@ function isPathVisible(relativePath) {
 function isPathContentReadable(relativePath) {
   return isPathVisible(relativePath);
 }
-var ALWAYS_EXCLUDE_DIR_NAMES, SECRET_PATH_PATTERNS;
+var HIDDEN_DIR_NAMES, SHALLOW_SYNC_DIR_NAMES, ALWAYS_EXCLUDE_DIR_NAMES, SECRET_PATH_PATTERNS, SHALLOW_HEURISTIC_MIN_CHILD_COUNT = 500;
 var init_workspace_visibility_policy = __esm(() => {
-  ALWAYS_EXCLUDE_DIR_NAMES = new Set([
+  HIDDEN_DIR_NAMES = new Set([".git"]);
+  SHALLOW_SYNC_DIR_NAMES = new Set([
     "node_modules",
-    ".git",
     "dist",
     "build",
     ".next",
@@ -101155,6 +101208,7 @@ var init_workspace_visibility_policy = __esm(() => {
     "_generated",
     ".vercel"
   ]);
+  ALWAYS_EXCLUDE_DIR_NAMES = new Set([...HIDDEN_DIR_NAMES, ...SHALLOW_SYNC_DIR_NAMES]);
   SECRET_PATH_PATTERNS = [
     /^\.env$/,
     /^\.env\./,
@@ -101928,29 +101982,41 @@ async function isWorkspacePathIgnored(rootDir, relativePath) {
   const ruleSets = await loadApplicableIgnoreRuleSets(rootDir, relativePath);
   return isPathIgnoredByRuleSets(ruleSets, relativePath);
 }
+function mergeWorkspaceIgnoreRuleSets(inheritedRuleSets, localRuleSets) {
+  return localRuleSets.length === 0 ? [...inheritedRuleSets] : [...inheritedRuleSets, ...localRuleSets];
+}
+async function readWorkspaceDirectoryDirents(rootDir, relDir) {
+  const absDir = relDir ? path3.join(rootDir, relDir) : rootDir;
+  try {
+    return await fsPromises.readdir(absDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
 async function loadAllWorkspaceIgnoreRuleSets(rootDir) {
   const collected = [];
   async function visit(relDir, inheritedRuleSets) {
     const localRuleSets = await loadDirectoryIgnoreRuleSets(rootDir, relDir);
-    const ruleSets = localRuleSets.length === 0 ? inheritedRuleSets : [...inheritedRuleSets, ...localRuleSets];
+    const ruleSets = mergeWorkspaceIgnoreRuleSets(inheritedRuleSets, localRuleSets);
     collected.push(...localRuleSets);
-    const absDir = relDir ? path3.join(rootDir, relDir) : rootDir;
-    let dirents;
-    try {
-      dirents = await fsPromises.readdir(absDir, { withFileTypes: true });
-    } catch {
+    const dirents = await readWorkspaceDirectoryDirents(rootDir, relDir);
+    if (!dirents)
       return;
-    }
     for (const ent of dirents) {
       if (!ent.isDirectory())
         continue;
-      if (isAlwaysExcludedDirName(ent.name))
-        continue;
       const relativePath = relDir ? `${relDir}/${ent.name}` : ent.name;
       if (!isPathVisible(relativePath))
         continue;
       if (isPathIgnoredByRuleSets(ruleSets, relativePath))
         continue;
+      const syncMode = classifyDirectorySyncMode(ent.name, {
+        relativePath,
+        immediateSiblingCount: dirents.length,
+        immediateChildCount: 0
+      });
+      if (syncMode !== "full")
+        continue;
       await visit(relativePath, ruleSets);
     }
   }
@@ -101965,40 +102031,43 @@ var init_workspace_ignore = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/workspace-file-walk.ts
-import { promises as fsPromises2 } from "node:fs";
-import path4 from "node:path";
 async function walkWorkspaceFiles(rootDir, options) {
   const maxFilePaths = options?.maxFilePaths ?? 1e4;
   const filePaths = [];
+  const directoryStubs = [];
   let truncated = false;
-  async function visitDir(relDir, inheritedRuleSets) {
+  async function visitDir(relDir, inheritedRuleSets, siblingCount) {
     if (truncated || filePaths.length >= maxFilePaths) {
       truncated = true;
       return;
     }
     const localRuleSets = await loadDirectoryIgnoreRuleSets(rootDir, relDir);
-    const ruleSets = localRuleSets.length === 0 ? inheritedRuleSets : [...inheritedRuleSets, ...localRuleSets];
-    const absDir = relDir ? path4.join(rootDir, relDir) : rootDir;
-    let dirents;
-    try {
-      dirents = await fsPromises2.readdir(absDir, { withFileTypes: true });
-    } catch {
+    const ruleSets = mergeWorkspaceIgnoreRuleSets(inheritedRuleSets, localRuleSets);
+    const dirents = await readWorkspaceDirectoryDirents(rootDir, relDir);
+    if (!dirents)
       return;
-    }
     for (const ent of dirents) {
       if (truncated || filePaths.length >= maxFilePaths) {
         truncated = true;
         return;
       }
-      if (isAlwaysExcludedDirName(ent.name))
-        continue;
       const relativePath = relDir ? `${relDir}/${ent.name}` : ent.name;
       if (!isPathVisible(relativePath))
         continue;
       if (ent.isDirectory()) {
         if (isPathIgnoredByRuleSets(ruleSets, relativePath))
           continue;
-        await visitDir(relativePath, ruleSets);
+        const syncMode = classifyDirectorySyncMode(ent.name, {
+          relativePath,
+          immediateSiblingCount: siblingCount,
+          immediateChildCount: dirents.length
+        });
+        if (syncMode === "hidden")
+          continue;
+        directoryStubs.push(relativePath);
+        if (syncMode === "shallow")
+          continue;
+        await visitDir(relativePath, ruleSets, dirents.length);
       } else if (ent.isFile()) {
         if (isPathIgnoredByRuleSets(ruleSets, relativePath))
           continue;
@@ -102008,8 +102077,8 @@ async function walkWorkspaceFiles(rootDir, options) {
       }
     }
   }
-  await visitDir("", []);
-  return { filePaths, truncated };
+  await visitDir("", [], 0);
+  return { filePaths, directoryStubs, truncated };
 }
 var init_workspace_file_walk = __esm(() => {
   init_workspace_ignore();
@@ -102022,7 +102091,8 @@ async function scanFileTree(rootDir, options) {
   const scannedAt = Date.now();
   const walk = await walkWorkspaceFiles(rootDir, { maxFilePaths: maxEntries });
   const filteredPaths = walk.filePaths.filter((p) => !isExcluded(p));
-  const entries2 = buildEntries(filteredPaths, maxEntries);
+  const filteredStubs = walk.directoryStubs.filter((p) => !isExcluded(p));
+  const entries2 = buildEntries(filteredPaths, filteredStubs, maxEntries);
   return {
     entries: entries2,
     scannedAt,
@@ -102032,28 +102102,31 @@ async function scanFileTree(rootDir, options) {
 function isExcluded(filePath) {
   return hasExcludedDirSegment(filePath);
 }
-function buildEntries(filePaths, maxEntries) {
-  const directories = new Set;
+function entryDepth(entryPath) {
+  return entryPath.split("/").length;
+}
+function buildEntries(filePaths, directoryStubs, maxEntries) {
+  const directories = new Set(directoryStubs);
   for (const filePath of filePaths) {
     const parts2 = filePath.split("/");
     for (let i2 = 1;i2 < parts2.length; i2++) {
       directories.add(parts2.slice(0, i2).join("/"));
     }
   }
-  const entries2 = [];
-  const sortedDirs = Array.from(directories).sort();
-  for (const dir of sortedDirs) {
-    if (entries2.length >= maxEntries)
-      break;
-    entries2.push({ path: dir, type: "directory" });
-  }
-  const sortedFiles = filePaths.slice().sort();
-  for (const file2 of sortedFiles) {
-    if (entries2.length >= maxEntries)
-      break;
-    entries2.push({ path: file2, type: "file" });
+  const entries2 = [
+    ...Array.from(directories).map((dir) => ({ path: dir, type: "directory" })),
+    ...filePaths.map((file2) => ({ path: file2, type: "file" }))
+  ];
+  const uniqueByPath = new Map;
+  for (const entry of entries2) {
+    uniqueByPath.set(entry.path, entry);
   }
-  return entries2;
+  return Array.from(uniqueByPath.values()).sort((left3, right3) => {
+    const depthDelta = entryDepth(left3.path) - entryDepth(right3.path);
+    if (depthDelta !== 0)
+      return depthDelta;
+    return left3.path.localeCompare(right3.path);
+  }).slice(0, maxEntries);
 }
 var DEFAULT_MAX_ENTRIES = 1e4;
 var init_file_tree_scanner = __esm(() => {
@@ -102063,7 +102136,7 @@ var init_file_tree_scanner = __esm(() => {
 
 // src/infrastructure/services/workspace/git-workspace-porcelain.ts
 import { existsSync as existsSync7 } from "node:fs";
-import path5 from "node:path";
+import path4 from "node:path";
 function isEmptyRepoHeadError(error51) {
   const message = error51.message.toLowerCase();
   return message.includes("unknown revision") || message.includes("bad revision") || message.includes("ambiguous argument") || message.includes("needed a single revision");
@@ -102262,7 +102335,7 @@ function porcelainUntrackedDeletedEvents(args2) {
     const prevEntry = prevByWsPath.get(wsPath);
     if (prevEntry?.xy !== "??")
       continue;
-    const absPath = path5.join(args2.node.workTree, prevEntry.path);
+    const absPath = path4.join(args2.node.workTree, prevEntry.path);
     if (!exists3(absPath)) {
       events.push({
         kind: prevEntry.path.endsWith("/") ? "unlinkDir" : "unlink",
@@ -102529,8 +102602,8 @@ var init_git_workspace_change_source = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/git-workspace-hierarchy.ts
-import { promises as fsPromises3 } from "node:fs";
-import path6 from "node:path";
+import { promises as fsPromises2 } from "node:fs";
+import path5 from "node:path";
 function normalizeRel(p) {
   return p.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
 }
@@ -102545,15 +102618,15 @@ async function resolveGitDir(workTree) {
   const raw = await revParse(workTree, "--git-dir");
   if (!raw)
     return null;
-  return path6.isAbsolute(raw) ? raw : path6.resolve(workTree, raw);
+  return path5.isAbsolute(raw) ? raw : path5.resolve(workTree, raw);
 }
 async function findNestedWorkTrees(workspaceRoot) {
   const found = [];
   async function visit(relDir) {
-    const absDir = relDir ? path6.join(workspaceRoot, relDir) : workspaceRoot;
+    const absDir = relDir ? path5.join(workspaceRoot, relDir) : workspaceRoot;
     let dirents;
     try {
-      dirents = await fsPromises3.readdir(absDir, { withFileTypes: true });
+      dirents = await fsPromises2.readdir(absDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -102562,7 +102635,7 @@ async function findNestedWorkTrees(workspaceRoot) {
       const relativePath = relDir ? `${relDir}/${name}` : name;
       if (name === ".git") {
         if (relDir) {
-          found.push(path6.resolve(workspaceRoot, relDir));
+          found.push(path5.resolve(workspaceRoot, relDir));
         }
         continue;
       }
@@ -102576,12 +102649,12 @@ async function findNestedWorkTrees(workspaceRoot) {
     }
   }
   await visit("");
-  return [...new Set(found.map((p) => path6.resolve(p)))].sort((a, b) => a.length - b.length || a.localeCompare(b));
+  return [...new Set(found.map((p) => path5.resolve(p)))].sort((a, b) => a.length - b.length || a.localeCompare(b));
 }
 async function discoverGitWorkspaceHierarchy(workingDir) {
   let workspaceRoot;
   try {
-    workspaceRoot = await fsPromises3.realpath(workingDir);
+    workspaceRoot = await fsPromises2.realpath(workingDir);
   } catch {
     return null;
   }
@@ -102592,8 +102665,8 @@ async function discoverGitWorkspaceHierarchy(workingDir) {
   const gitDir = await resolveGitDir(workspaceRoot);
   if (!toplevelRaw || !gitDir)
     return null;
-  const toplevel = path6.resolve(toplevelRaw);
-  const relFromToplevel = normalizeRel(path6.relative(toplevel, workspaceRoot));
+  const toplevel = path5.resolve(toplevelRaw);
+  const relFromToplevel = normalizeRel(path5.relative(toplevel, workspaceRoot));
   if (relFromToplevel.startsWith(".."))
     return null;
   const pathspec = relFromToplevel && toplevel !== workspaceRoot ? [relFromToplevel] : [];
@@ -102606,7 +102679,7 @@ async function discoverGitWorkspaceHierarchy(workingDir) {
     nestedNodes.push({
       workTree,
       gitDir: nestedGitDir,
-      relativePath: normalizeRel(path6.relative(workspaceRoot, workTree)),
+      relativePath: normalizeRel(path5.relative(workspaceRoot, workTree)),
       pathspec: [],
       children: []
     });
@@ -102624,7 +102697,7 @@ async function discoverGitWorkspaceHierarchy(workingDir) {
     for (const candidate of sorted) {
       if (candidate === node)
         continue;
-      const prefix = candidate.workTree.endsWith(path6.sep) ? candidate.workTree : candidate.workTree + path6.sep;
+      const prefix = candidate.workTree.endsWith(path5.sep) ? candidate.workTree : candidate.workTree + path5.sep;
       if (node.workTree.startsWith(prefix) && candidate.workTree.length >= parent.workTree.length) {
         parent = candidate;
       }
@@ -102736,7 +102809,7 @@ var init_readdirp = __esm(() => {
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
       const statMethod = opts.lstat ? lstat : stat2;
       if (wantBigintFsStats) {
-        this._stat = (path7) => statMethod(path7, { bigint: true });
+        this._stat = (path6) => statMethod(path6, { bigint: true });
       } else {
         this._stat = statMethod;
       }
@@ -102761,8 +102834,8 @@ var init_readdirp = __esm(() => {
           const par2 = this.parent;
           const fil = par2 && par2.files;
           if (fil && fil.length > 0) {
-            const { path: path7, depth } = par2;
-            const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path7));
+            const { path: path6, depth } = par2;
+            const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path6));
             const awaited = await Promise.all(slice);
             for (const entry of awaited) {
               if (!entry)
@@ -102802,20 +102875,20 @@ var init_readdirp = __esm(() => {
         this.reading = false;
       }
     }
-    async _exploreDir(path7, depth) {
+    async _exploreDir(path6, depth) {
       let files;
       try {
-        files = await readdir(path7, this._rdOptions);
+        files = await readdir(path6, this._rdOptions);
       } catch (error51) {
         this._onError(error51);
       }
-      return { files, depth, path: path7 };
+      return { files, depth, path: path6 };
     }
-    async _formatEntry(dirent, path7) {
+    async _formatEntry(dirent, path6) {
       let entry;
       const basename2 = this._isDirent ? dirent.name : dirent;
       try {
-        const fullPath = presolve(pjoin(path7, basename2));
+        const fullPath = presolve(pjoin(path6, basename2));
         entry = { path: prelative(this._root, fullPath), fullPath, basename: basename2 };
         entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
       } catch (err) {
@@ -102875,16 +102948,16 @@ import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
 import { realpath as fsrealpath, lstat as lstat2, open, stat as stat3 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp from "node:path";
-function createFsWatchInstance(path7, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path6, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path7);
-    emitRaw(rawEvent, evPath, { watchedPath: path7 });
-    if (evPath && path7 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path7, evPath), KEY_LISTENERS, sp.join(path7, evPath));
+    listener(path6);
+    emitRaw(rawEvent, evPath, { watchedPath: path6 });
+    if (evPath && path6 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path6, evPath), KEY_LISTENERS, sp.join(path6, evPath));
     }
   };
   try {
-    return fs_watch(path7, {
+    return fs_watch(path6, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error51) {
@@ -102900,13 +102973,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error51) => fsW._handleError(error51);
   }
-  _watchWithNodeFs(path7, listener) {
+  _watchWithNodeFs(path6, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path7);
-    const basename3 = sp.basename(path7);
+    const directory = sp.dirname(path6);
+    const basename3 = sp.basename(path6);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path7);
+    const absolutePath = sp.resolve(path6);
     const options = {
       persistent: opts.persistent
     };
@@ -102916,12 +102989,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path7, absolutePath, options, {
+      closer = setFsWatchFileListener(path6, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path7, absolutePath, options, {
+      closer = setFsWatchListener(path6, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -102939,7 +103012,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path7, newStats) => {
+    const listener = async (path6, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -102953,11 +103026,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file2, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path7);
+            this.fsw._closeFile(path6);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file2, listener);
             if (closer2)
-              this.fsw._addPathCloser(path7, closer2);
+              this.fsw._addPathCloser(path6, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -102981,7 +103054,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path7, item) {
+  async _handleSymlink(entry, directory, path6, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -102991,7 +103064,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path7);
+        linkPath = await fsrealpath(path6);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -103001,12 +103074,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path7, entry.stats);
+          this.fsw._emit(EV.CHANGE, path6, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path7, entry.stats);
+        this.fsw._emit(EV.ADD, path6, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -103036,9 +103109,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path7 = sp.join(directory, item);
+      let path6 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path7, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path6, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -103047,8 +103120,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path7 = sp.join(dir, sp.relative(dir, path7));
-        this._addToNodeFs(path7, initialAdd, wh, depth + 1);
+        path6 = sp.join(dir, sp.relative(dir, path6));
+        this._addToNodeFs(path6, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve6, reject) => {
@@ -103097,13 +103170,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path7, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path6, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path6) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path7);
+    const wh = this.fsw._getWatchHelpers(path6);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -103119,8 +103192,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path7);
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const absPath = sp.resolve(path6);
+        const targetPath = follow ? await fsrealpath(path6) : path6;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -103130,29 +103203,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path7) : path7;
+        const targetPath = follow ? await fsrealpath(path6) : path6;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path7, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path6, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sp.resolve(path7), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path6), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path7, closer);
+        this.fsw._addPathCloser(path6, closer);
       return false;
     } catch (error51) {
       if (this.fsw._handleError(error51)) {
         ready();
-        return path7;
+        return path6;
       }
     }
   }
@@ -103190,12 +103263,12 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
   foreach(cont[listenerType], (listener) => {
     listener(val1, val2, val3);
   });
-}, setFsWatchListener = (path7, fullPath, options, handlers) => {
+}, setFsWatchListener = (path6, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path7, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path6, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -103205,7 +103278,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path7, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path6, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error51) => {
@@ -103214,7 +103287,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
         cont.watcherUnusable = true;
       if (isWindows && error51.code === "EPERM") {
         try {
-          const fd = await open(path7, "r");
+          const fd = await open(path6, "r");
           await fd.close();
           broadcastErr(error51);
         } catch (err) {}
@@ -103242,7 +103315,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
       Object.freeze(cont);
     }
   };
-}, FsWatchFileInstances, setFsWatchFileListener = (path7, fullPath, options, handlers) => {
+}, FsWatchFileInstances, setFsWatchFileListener = (path6, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -103264,7 +103337,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path7, curr));
+          foreach(cont.listeners, (listener2) => listener2(path6, curr));
         }
       })
     };
@@ -103600,24 +103673,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path7) {
-  if (typeof path7 !== "string")
+function normalizePath(path6) {
+  if (typeof path6 !== "string")
     throw new Error("string expected");
-  path7 = sp2.normalize(path7);
-  path7 = path7.replace(/\\/g, "/");
+  path6 = sp2.normalize(path6);
+  path6 = path6.replace(/\\/g, "/");
   let prepend4 = false;
-  if (path7.startsWith("//"))
+  if (path6.startsWith("//"))
     prepend4 = true;
-  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
+  path6 = path6.replace(DOUBLE_SLASH_RE, "/");
   if (prepend4)
-    path7 = "/" + path7;
-  return path7;
+    path6 = "/" + path6;
+  return path6;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path7 = normalizePath(testString);
+  const path6 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path7, stats)) {
+    if (pattern(path6, stats)) {
       return true;
     }
   }
@@ -103698,10 +103771,10 @@ class WatchHelper {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path7, follow, fsw) {
+  constructor(path6, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path7;
-    this.path = path7 = path7.replace(REPLACER_RE, "");
+    const watchPath = path6;
+    this.path = path6 = path6.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -103748,17 +103821,17 @@ var SLASH = "/", SLASH_SLASH = "//", ONE_DOT = ".", TWO_DOTS = "..", STRING_TYPE
     str = SLASH + str;
   }
   return str;
-}, normalizePathToUnix = (path7) => toUnix(sp2.normalize(toUnix(path7))), normalizeIgnored = (cwd = "") => (path7) => {
-  if (typeof path7 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path7) ? path7 : sp2.join(cwd, path7));
+}, normalizePathToUnix = (path6) => toUnix(sp2.normalize(toUnix(path6))), normalizeIgnored = (cwd = "") => (path6) => {
+  if (typeof path6 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path6) ? path6 : sp2.join(cwd, path6));
   } else {
-    return path7;
+    return path6;
   }
-}, getAbsolutePath = (path7, cwd) => {
-  if (sp2.isAbsolute(path7)) {
-    return path7;
+}, getAbsolutePath = (path6, cwd) => {
+  if (sp2.isAbsolute(path6)) {
+    return path6;
   }
-  return sp2.join(cwd, path7);
+  return sp2.join(cwd, path6);
 }, EMPTY_SET, STAT_METHOD_F = "stat", STAT_METHOD_L = "lstat", FSWatcher;
 var init_chokidar = __esm(() => {
   init_readdirp();
@@ -103874,20 +103947,20 @@ var init_chokidar = __esm(() => {
       this._closePromise = undefined;
       let paths = unifyPaths(paths_);
       if (cwd) {
-        paths = paths.map((path7) => {
-          const absPath = getAbsolutePath(path7, cwd);
+        paths = paths.map((path6) => {
+          const absPath = getAbsolutePath(path6, cwd);
           return absPath;
         });
       }
-      paths.forEach((path7) => {
-        this._removeIgnoredPath(path7);
+      paths.forEach((path6) => {
+        this._removeIgnoredPath(path6);
       });
       this._userIgnored = undefined;
       if (!this._readyCount)
         this._readyCount = 0;
       this._readyCount += paths.length;
-      Promise.all(paths.map(async (path7) => {
-        const res = await this._nodeFsHandler._addToNodeFs(path7, !_internal, undefined, 0, _origAdd);
+      Promise.all(paths.map(async (path6) => {
+        const res = await this._nodeFsHandler._addToNodeFs(path6, !_internal, undefined, 0, _origAdd);
         if (res)
           this._emitReady();
         return res;
@@ -103906,17 +103979,17 @@ var init_chokidar = __esm(() => {
         return this;
       const paths = unifyPaths(paths_);
       const { cwd } = this.options;
-      paths.forEach((path7) => {
-        if (!sp2.isAbsolute(path7) && !this._closers.has(path7)) {
+      paths.forEach((path6) => {
+        if (!sp2.isAbsolute(path6) && !this._closers.has(path6)) {
           if (cwd)
-            path7 = sp2.join(cwd, path7);
-          path7 = sp2.resolve(path7);
+            path6 = sp2.join(cwd, path6);
+          path6 = sp2.resolve(path6);
         }
-        this._closePath(path7);
-        this._addIgnoredPath(path7);
-        if (this._watched.has(path7)) {
+        this._closePath(path6);
+        this._addIgnoredPath(path6);
+        if (this._watched.has(path6)) {
           this._addIgnoredPath({
-            path: path7,
+            path: path6,
             recursive: true
           });
         }
@@ -103965,38 +104038,38 @@ var init_chokidar = __esm(() => {
       if (event !== EVENTS.ERROR)
         this.emit(EVENTS.ALL, event, ...args2);
     }
-    async _emit(event, path7, stats) {
+    async _emit(event, path6, stats) {
       if (this.closed)
         return;
       const opts = this.options;
       if (isWindows)
-        path7 = sp2.normalize(path7);
+        path6 = sp2.normalize(path6);
       if (opts.cwd)
-        path7 = sp2.relative(opts.cwd, path7);
-      const args2 = [path7];
+        path6 = sp2.relative(opts.cwd, path6);
+      const args2 = [path6];
       if (stats != null)
         args2.push(stats);
       const awf = opts.awaitWriteFinish;
       let pw;
-      if (awf && (pw = this._pendingWrites.get(path7))) {
+      if (awf && (pw = this._pendingWrites.get(path6))) {
         pw.lastChange = new Date;
         return this;
       }
       if (opts.atomic) {
         if (event === EVENTS.UNLINK) {
-          this._pendingUnlinks.set(path7, [event, ...args2]);
+          this._pendingUnlinks.set(path6, [event, ...args2]);
           setTimeout(() => {
-            this._pendingUnlinks.forEach((entry, path8) => {
+            this._pendingUnlinks.forEach((entry, path7) => {
               this.emit(...entry);
               this.emit(EVENTS.ALL, ...entry);
-              this._pendingUnlinks.delete(path8);
+              this._pendingUnlinks.delete(path7);
             });
           }, typeof opts.atomic === "number" ? opts.atomic : 100);
           return this;
         }
-        if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
+        if (event === EVENTS.ADD && this._pendingUnlinks.has(path6)) {
           event = EVENTS.CHANGE;
-          this._pendingUnlinks.delete(path7);
+          this._pendingUnlinks.delete(path6);
         }
       }
       if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -104014,16 +104087,16 @@ var init_chokidar = __esm(() => {
             this.emitWithAll(event, args2);
           }
         };
-        this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
+        this._awaitWriteFinish(path6, awf.stabilityThreshold, event, awfEmit);
         return this;
       }
       if (event === EVENTS.CHANGE) {
-        const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 50);
+        const isThrottled = !this._throttle(EVENTS.CHANGE, path6, 50);
         if (isThrottled)
           return this;
       }
       if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-        const fullPath = opts.cwd ? sp2.join(opts.cwd, path7) : path7;
+        const fullPath = opts.cwd ? sp2.join(opts.cwd, path6) : path6;
         let stats2;
         try {
           stats2 = await stat4(fullPath);
@@ -104042,23 +104115,23 @@ var init_chokidar = __esm(() => {
       }
       return error51 || this.closed;
     }
-    _throttle(actionType, path7, timeout3) {
+    _throttle(actionType, path6, timeout3) {
       if (!this._throttled.has(actionType)) {
         this._throttled.set(actionType, new Map);
       }
       const action = this._throttled.get(actionType);
       if (!action)
         throw new Error("invalid throttle");
-      const actionPath = action.get(path7);
+      const actionPath = action.get(path6);
       if (actionPath) {
         actionPath.count++;
         return false;
       }
       let timeoutObject;
       const clear = () => {
-        const item = action.get(path7);
+        const item = action.get(path6);
         const count3 = item ? item.count : 0;
-        action.delete(path7);
+        action.delete(path6);
         clearTimeout(timeoutObject);
         if (item)
           clearTimeout(item.timeoutObject);
@@ -104066,50 +104139,50 @@ var init_chokidar = __esm(() => {
       };
       timeoutObject = setTimeout(clear, timeout3);
       const thr = { timeoutObject, clear, count: 0 };
-      action.set(path7, thr);
+      action.set(path6, thr);
       return thr;
     }
     _incrReadyCount() {
       return this._readyCount++;
     }
-    _awaitWriteFinish(path7, threshold, event, awfEmit) {
+    _awaitWriteFinish(path6, threshold, event, awfEmit) {
       const awf = this.options.awaitWriteFinish;
       if (typeof awf !== "object")
         return;
       const pollInterval = awf.pollInterval;
       let timeoutHandler;
-      let fullPath = path7;
-      if (this.options.cwd && !sp2.isAbsolute(path7)) {
-        fullPath = sp2.join(this.options.cwd, path7);
+      let fullPath = path6;
+      if (this.options.cwd && !sp2.isAbsolute(path6)) {
+        fullPath = sp2.join(this.options.cwd, path6);
       }
       const now = new Date;
       const writes = this._pendingWrites;
       function awaitWriteFinishFn(prevStat) {
         statcb(fullPath, (err, curStat) => {
-          if (err || !writes.has(path7)) {
+          if (err || !writes.has(path6)) {
             if (err && err.code !== "ENOENT")
               awfEmit(err);
             return;
           }
           const now2 = Number(new Date);
           if (prevStat && curStat.size !== prevStat.size) {
-            writes.get(path7).lastChange = now2;
+            writes.get(path6).lastChange = now2;
           }
-          const pw = writes.get(path7);
+          const pw = writes.get(path6);
           const df = now2 - pw.lastChange;
           if (df >= threshold) {
-            writes.delete(path7);
+            writes.delete(path6);
             awfEmit(undefined, curStat);
           } else {
             timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
           }
         });
       }
-      if (!writes.has(path7)) {
-        writes.set(path7, {
+      if (!writes.has(path6)) {
+        writes.set(path6, {
           lastChange: now,
           cancelWait: () => {
-            writes.delete(path7);
+            writes.delete(path6);
             clearTimeout(timeoutHandler);
             return event;
           }
@@ -104117,8 +104190,8 @@ var init_chokidar = __esm(() => {
         timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
       }
     }
-    _isIgnored(path7, stats) {
-      if (this.options.atomic && DOT_RE.test(path7))
+    _isIgnored(path6, stats) {
+      if (this.options.atomic && DOT_RE.test(path6))
         return true;
       if (!this._userIgnored) {
         const { cwd } = this.options;
@@ -104128,13 +104201,13 @@ var init_chokidar = __esm(() => {
         const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
         this._userIgnored = anymatch(list, undefined);
       }
-      return this._userIgnored(path7, stats);
+      return this._userIgnored(path6, stats);
     }
-    _isntIgnored(path7, stat5) {
-      return !this._isIgnored(path7, stat5);
+    _isntIgnored(path6, stat5) {
+      return !this._isIgnored(path6, stat5);
     }
-    _getWatchHelpers(path7) {
-      return new WatchHelper(path7, this.options.followSymlinks, this);
+    _getWatchHelpers(path6) {
+      return new WatchHelper(path6, this.options.followSymlinks, this);
     }
     _getWatchedDir(directory) {
       const dir = sp2.resolve(directory);
@@ -104148,57 +104221,57 @@ var init_chokidar = __esm(() => {
       return Boolean(Number(stats.mode) & 256);
     }
     _remove(directory, item, isDirectory) {
-      const path7 = sp2.join(directory, item);
-      const fullPath = sp2.resolve(path7);
-      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path7) || this._watched.has(fullPath);
-      if (!this._throttle("remove", path7, 100))
+      const path6 = sp2.join(directory, item);
+      const fullPath = sp2.resolve(path6);
+      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path6) || this._watched.has(fullPath);
+      if (!this._throttle("remove", path6, 100))
         return;
       if (!isDirectory && this._watched.size === 1) {
         this.add(directory, item, true);
       }
-      const wp = this._getWatchedDir(path7);
+      const wp = this._getWatchedDir(path6);
       const nestedDirectoryChildren = wp.getChildren();
-      nestedDirectoryChildren.forEach((nested2) => this._remove(path7, nested2));
+      nestedDirectoryChildren.forEach((nested2) => this._remove(path6, nested2));
       const parent = this._getWatchedDir(directory);
       const wasTracked = parent.has(item);
       parent.remove(item);
       if (this._symlinkPaths.has(fullPath)) {
         this._symlinkPaths.delete(fullPath);
       }
-      let relPath = path7;
+      let relPath = path6;
       if (this.options.cwd)
-        relPath = sp2.relative(this.options.cwd, path7);
+        relPath = sp2.relative(this.options.cwd, path6);
       if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
         const event = this._pendingWrites.get(relPath).cancelWait();
         if (event === EVENTS.ADD)
           return;
       }
-      this._watched.delete(path7);
+      this._watched.delete(path6);
       this._watched.delete(fullPath);
       const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-      if (wasTracked && !this._isIgnored(path7))
-        this._emit(eventName, path7);
-      this._closePath(path7);
+      if (wasTracked && !this._isIgnored(path6))
+        this._emit(eventName, path6);
+      this._closePath(path6);
     }
-    _closePath(path7) {
-      this._closeFile(path7);
-      const dir = sp2.dirname(path7);
-      this._getWatchedDir(dir).remove(sp2.basename(path7));
+    _closePath(path6) {
+      this._closeFile(path6);
+      const dir = sp2.dirname(path6);
+      this._getWatchedDir(dir).remove(sp2.basename(path6));
     }
-    _closeFile(path7) {
-      const closers = this._closers.get(path7);
+    _closeFile(path6) {
+      const closers = this._closers.get(path6);
       if (!closers)
         return;
       closers.forEach((closer) => closer());
-      this._closers.delete(path7);
+      this._closers.delete(path6);
     }
-    _addPathCloser(path7, closer) {
+    _addPathCloser(path6, closer) {
       if (!closer)
         return;
-      let list = this._closers.get(path7);
+      let list = this._closers.get(path6);
       if (!list) {
         list = [];
-        this._closers.set(path7, list);
+        this._closers.set(path6, list);
       }
       list.push(closer);
     }
@@ -104223,7 +104296,7 @@ var init_chokidar = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/workspace-fs-watcher.ts
-import path7 from "node:path";
+import path6 from "node:path";
 function isTooManyOpenFilesError(error51) {
   if (!(error51 instanceof Error))
     return false;
@@ -104231,10 +104304,10 @@ function isTooManyOpenFilesError(error51) {
   return errno === "EMFILE" || errno === "ENOSPC" || error51.message.includes("EMFILE");
 }
 function toRelativePath(rootDir, absolutePath) {
-  return path7.relative(rootDir, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
+  return path6.relative(rootDir, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
 }
 function createWorkspaceFsWatcher(options) {
-  const absWorkingDir = path7.resolve(options.workingDir);
+  const absWorkingDir = path6.resolve(options.workingDir);
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   let stopped = false;
   let debounceTimer = null;
@@ -104330,16 +104403,16 @@ function diffPathIndexes(previous, next4) {
   const removed = [];
   const typeChanged = [];
   const prev = previous ?? {};
-  for (const [path8, type] of Object.entries(next4)) {
-    if (!(path8 in prev)) {
-      added.push(path8);
-    } else if (prev[path8] !== type) {
-      typeChanged.push(path8);
+  for (const [path7, type] of Object.entries(next4)) {
+    if (!(path7 in prev)) {
+      added.push(path7);
+    } else if (prev[path7] !== type) {
+      typeChanged.push(path7);
     }
   }
-  for (const path8 of Object.keys(prev)) {
-    if (!(path8 in next4)) {
-      removed.push(path8);
+  for (const path7 of Object.keys(prev)) {
+    if (!(path7 in next4)) {
+      removed.push(path7);
     }
   }
   added.sort();
@@ -104425,7 +104498,7 @@ function createManifestFromTree(args2) {
   };
 }
 function entriesFromPathIndex(paths) {
-  return Object.entries(paths).map(([path8, type]) => ({ path: path8, type })).sort((a, b) => a.path.localeCompare(b.path));
+  return Object.entries(paths).map(([path7, type]) => ({ path: path7, type })).sort((a, b) => a.path.localeCompare(b.path));
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
@@ -104434,7 +104507,7 @@ var init_workspace_sync_state = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import path8 from "node:path";
+import path7 from "node:path";
 function deltaEntry(paths, pathValue) {
   const type = paths[pathValue];
   if (type === undefined)
@@ -104500,7 +104573,7 @@ async function addDirectorySubtree(rootDir, relativeDir, paths) {
     return;
   ensureParentDirectories(paths, relativeDir);
   paths[relativeDir] = "directory";
-  const subtree = await scanFileTree(path8.join(rootDir, relativeDir));
+  const subtree = await scanFileTree(path7.join(rootDir, relativeDir));
   for (const entry of subtree.entries) {
     const prefixedPath = `${relativeDir}/${entry.path}`;
     if (await isWorkspacePathIgnored(rootDir, prefixedPath))
@@ -111934,7 +112007,7 @@ __export(exports_opencode_install, {
   installTool: () => installTool
 });
 import * as os2 from "os";
-import * as path9 from "path";
+import * as path8 from "path";
 async function isChatroomInstalledDefault() {
   try {
     const { execSync: execSync3 } = await import("child_process");
@@ -112304,9 +112377,9 @@ After logging in, try this command again.\`;
   const fsService = yield* OpenCodeInstallFsService;
   const { checkExisting = true } = options;
   const homeDir = os2.homedir();
-  const toolDir = path9.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path9.join(toolDir, "chatroom.ts");
-  const handoffToolPath = path9.join(toolDir, "chatroom-handoff.ts");
+  const toolDir = path8.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path8.join(toolDir, "chatroom.ts");
+  const handoffToolPath = path8.join(toolDir, "chatroom-handoff.ts");
   if (checkExisting) {
     const existingFiles = [];
     const toolExists = yield* fsService.access(toolPath);
@@ -112861,4 +112934,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=5C6D9BF3DF7B24AB64756E2164756E21
+//# debugId=4AEC2FD829D3A5B464756E2164756E21