chatroom-cli 1.66.0 → 1.68.0

package/dist/index.js

@@ -81119,7 +81119,10 @@ function formatDecodeError(error) {
 
 // ../../services/backend/prompts/native/session-continuity.ts
 function getNativeHandoffTurnEndGuidance(nextRole) {
-  const lines = ["", "**End your turn now** — stop tool calls. Your session stays active."];
+  const lines = [
+    "",
+    "**Handoff must be your last action this turn.** After running handoff, **End your turn now** — stop tool calls. Your session stays active."
+  ];
   if (nextRole.toLowerCase() === "user") {
     lines.push("The system delivers the next chatroom task when the user sends one.");
   } else {
@@ -102198,6 +102201,583 @@ var init_file_tree_scanner = __esm(() => {
   init_workspace_visibility_policy();
 });
 
+// src/infrastructure/services/workspace/git-workspace-porcelain.ts
+import { existsSync as existsSync7 } from "node:fs";
+import path5 from "node:path";
+function isEmptyRepoHeadError(error40) {
+  const message = error40.message.toLowerCase();
+  return message.includes("unknown revision") || message.includes("bad revision") || message.includes("ambiguous argument") || message.includes("needed a single revision");
+}
+function parseGitPorcelainZ(stdout) {
+  const entries2 = [];
+  const parts2 = stdout.split("\x00");
+  let i2 = 0;
+  while (i2 < parts2.length) {
+    const token = parts2[i2];
+    if (!token) {
+      i2++;
+      continue;
+    }
+    const xy = token.slice(0, 2);
+    const rest = token.slice(3);
+    if ((xy[0] === "R" || xy[0] === "C") && rest) {
+      i2++;
+      const dest = parts2[i2] ?? "";
+      entries2.push({
+        xy,
+        path: dest.replace(/\\/g, "/"),
+        fromPath: rest.replace(/\\/g, "/")
+      });
+    } else if (rest) {
+      entries2.push({ xy, path: rest.replace(/\\/g, "/") });
+    }
+    i2++;
+  }
+  return entries2;
+}
+function toWorkspaceRelativePath(args2) {
+  const raw = args2.pathInWorkTree.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (args2.node.pathspec.length > 0) {
+    const spec = (args2.node.pathspec[0] ?? "").replace(/\/+$/, "");
+    if (raw === spec)
+      return args2.node.relativePath || null;
+    if (!raw.startsWith(spec + "/"))
+      return null;
+    const stripped = raw.slice(spec.length + 1);
+    if (args2.node.relativePath) {
+      return `${args2.node.relativePath}/${stripped}`.replace(/\/+/g, "/");
+    }
+    return stripped;
+  }
+  if (args2.node.relativePath) {
+    return `${args2.node.relativePath}/${raw}`.replace(/\/+/g, "/");
+  }
+  return raw;
+}
+function hasDelete(xy) {
+  return xy[0] === "D" || xy[1] === "D";
+}
+function hasAdd(xy) {
+  return xy[0] === "A" || xy[1] === "A";
+}
+function isRename(xy) {
+  return xy[0] === "R" || xy[1] === "R";
+}
+function isCopy(xy) {
+  return xy[0] === "C" || xy[1] === "C";
+}
+function kindForEntry(entry) {
+  const { xy, path: entryPath } = entry;
+  const events = [];
+  const isDir = entryPath.endsWith("/");
+  if (xy === "??") {
+    events.push({ kind: isDir ? "addDir" : "add", path: entryPath });
+  } else if (hasDelete(xy)) {
+    events.push({ kind: isDir ? "unlinkDir" : "unlink", path: entryPath });
+  } else if (hasAdd(xy)) {
+    events.push({ kind: isDir ? "addDir" : "add", path: entryPath });
+  } else if (isRename(xy)) {
+    events.push({ kind: isDir ? "addDir" : "add", path: entryPath });
+  } else if (isCopy(xy)) {
+    events.push({ kind: isDir ? "addDir" : "add", path: entryPath });
+  } else {
+    events.push({ kind: "change", path: entryPath });
+  }
+  return { events };
+}
+function diffPorcelainSnapshots(args2) {
+  const events = [];
+  const prevMap = new Map;
+  for (const entry of args2.prev) {
+    const wsPath = toWorkspaceRelativePath({
+      workspaceRoot: args2.workspaceRoot,
+      node: args2.node,
+      pathInWorkTree: entry.path
+    });
+    if (wsPath !== null) {
+      prevMap.set(wsPath, entry.xy);
+    }
+  }
+  const handledFromPaths = new Set;
+  for (const entry of args2.next) {
+    const wsPath = toWorkspaceRelativePath({
+      workspaceRoot: args2.workspaceRoot,
+      node: args2.node,
+      pathInWorkTree: entry.path
+    });
+    if (wsPath === null)
+      continue;
+    const prevXy = prevMap.get(wsPath);
+    if (prevXy === undefined || prevXy !== entry.xy) {
+      const entryEvents = kindForEntry(entry);
+      for (const e of entryEvents.events) {
+        events.push({ kind: e.kind, path: wsPath });
+      }
+    }
+    if (entry.fromPath && (entry.xy[0] === "R" || entry.xy[1] === "R")) {
+      const fromWsPath = toWorkspaceRelativePath({
+        workspaceRoot: args2.workspaceRoot,
+        node: args2.node,
+        pathInWorkTree: entry.fromPath
+      });
+      if (fromWsPath !== null && !handledFromPaths.has(fromWsPath)) {
+        handledFromPaths.add(fromWsPath);
+        events.push({
+          kind: entry.fromPath.endsWith("/") ? "unlinkDir" : "unlink",
+          path: fromWsPath
+        });
+      }
+    }
+  }
+  events.sort((a, b) => a.path.localeCompare(b.path));
+  return events;
+}
+function diffPorcelainAgainstKnownPaths(args2) {
+  const events = [];
+  for (const entry of args2.next) {
+    const wsPath = toWorkspaceRelativePath({
+      workspaceRoot: args2.workspaceRoot,
+      node: args2.node,
+      pathInWorkTree: entry.path
+    });
+    if (wsPath === null)
+      continue;
+    if (wsPath in args2.knownPaths)
+      continue;
+    const entryEvents = kindForEntry(entry);
+    for (const e of entryEvents.events) {
+      events.push({ kind: e.kind, path: wsPath });
+    }
+  }
+  events.sort((a, b) => a.path.localeCompare(b.path));
+  return events;
+}
+function porcelainPathsLeftSnapshot(args2) {
+  const nextWsPaths = new Set;
+  for (const entry of args2.next) {
+    const wsPath = toWorkspaceRelativePath({
+      workspaceRoot: args2.workspaceRoot,
+      node: args2.node,
+      pathInWorkTree: entry.path
+    });
+    if (wsPath !== null)
+      nextWsPaths.add(wsPath);
+  }
+  const left3 = [];
+  for (const entry of args2.prev) {
+    const wsPath = toWorkspaceRelativePath({
+      workspaceRoot: args2.workspaceRoot,
+      node: args2.node,
+      pathInWorkTree: entry.path
+    });
+    if (wsPath === null)
+      continue;
+    if (!nextWsPaths.has(wsPath))
+      left3.push(wsPath);
+  }
+  return left3.sort((a, b) => a.localeCompare(b));
+}
+function porcelainUntrackedDeletedEvents(args2) {
+  const exists4 = args2.pathExists ?? ((p) => existsSync7(p));
+  const left3 = porcelainPathsLeftSnapshot({
+    workspaceRoot: args2.workspaceRoot,
+    node: args2.node,
+    prev: args2.prev,
+    next: args2.next
+  });
+  if (left3.length === 0)
+    return [];
+  const prevByWsPath = new Map;
+  for (const entry of args2.prev) {
+    const wsPath = toWorkspaceRelativePath({
+      workspaceRoot: args2.workspaceRoot,
+      node: args2.node,
+      pathInWorkTree: entry.path
+    });
+    if (wsPath !== null)
+      prevByWsPath.set(wsPath, entry);
+  }
+  const events = [];
+  for (const wsPath of left3) {
+    const prevEntry = prevByWsPath.get(wsPath);
+    if (prevEntry?.xy !== "??")
+      continue;
+    const absPath = path5.join(args2.node.workTree, prevEntry.path);
+    if (!exists4(absPath)) {
+      events.push({
+        kind: prevEntry.path.endsWith("/") ? "unlinkDir" : "unlink",
+        path: wsPath
+      });
+    }
+  }
+  events.sort((a, b) => a.path.localeCompare(b.path));
+  return events;
+}
+async function readGitHead(workTree) {
+  const result = await runGit(["rev-parse", "HEAD"], workTree, {
+    timeout: GIT_POLL_TIMEOUT_MS
+  });
+  if ("error" in result) {
+    if (isEmptyRepoHeadError(result.error))
+      return { head: null };
+    throw new GitWorkspaceCommandError({
+      operation: "readGitHead",
+      workTree,
+      relativePath: "",
+      cause: result.error
+    });
+  }
+  const head5 = result.stdout.trim();
+  return { head: head5.length > 0 ? head5 : null };
+}
+function headChanged(prev, next4) {
+  if (prev.head === null && next4.head === null)
+    return false;
+  return prev.head !== next4.head;
+}
+async function readGitPorcelainStatus(node) {
+  const args2 = ["status", "--porcelain=v1", "-z", "-uall", "--"];
+  if (node.pathspec.length > 0)
+    args2.push(...node.pathspec);
+  const result = await runGit(args2, node.workTree, { timeout: GIT_POLL_TIMEOUT_MS });
+  if ("error" in result) {
+    throw new GitWorkspaceCommandError({
+      operation: "readGitPorcelainStatus",
+      workTree: node.workTree,
+      relativePath: node.relativePath,
+      cause: result.error
+    });
+  }
+  return parseGitPorcelainZ(result.stdout);
+}
+var GIT_POLL_TIMEOUT_MS = 1e4, GitWorkspaceCommandError;
+var init_git_workspace_porcelain = __esm(() => {
+  init_run_command();
+  GitWorkspaceCommandError = class GitWorkspaceCommandError extends Error {
+    operation;
+    workTree;
+    relativePath;
+    cause;
+    constructor(args2) {
+      const label = args2.relativePath || args2.workTree;
+      super(`${args2.operation} failed for ${label}: ${args2.cause.message}`);
+      this.name = "GitWorkspaceCommandError";
+      this.operation = args2.operation;
+      this.workTree = args2.workTree;
+      this.relativePath = args2.relativePath;
+      this.cause = args2.cause;
+    }
+  };
+});
+
+// src/infrastructure/services/workspace/git-workspace-change-source.ts
+function flattenGitRepoNodes(root) {
+  const out = [root];
+  for (const child of root.children) {
+    out.push(...flattenGitRepoNodes(child));
+  }
+  return out;
+}
+function computeBackoff(failures3, pollIntervalMs) {
+  if (failures3 <= 0)
+    return pollIntervalMs;
+  const backoff = pollIntervalMs * 2 ** Math.min(failures3 - 1, 5);
+  return Math.min(backoff, MAX_BACKOFF_MS);
+}
+async function pollGitWorkspaceNode(args2) {
+  const [nextHead, nextEntries] = await Promise.all([
+    readGitHead(args2.node.workTree),
+    readGitPorcelainStatus(args2.node)
+  ]);
+  let needsReconcile = false;
+  const events = [];
+  if (args2.prev.prevHead.head !== null && headChanged(args2.prev.prevHead, nextHead)) {
+    needsReconcile = true;
+  }
+  if (args2.prev.baselineEstablished) {
+    const left3 = porcelainPathsLeftSnapshot({
+      workspaceRoot: args2.options.hierarchy.workspaceRoot,
+      node: args2.node,
+      prev: args2.prev.prevEntries,
+      next: nextEntries
+    });
+    const deletedUntracked = porcelainUntrackedDeletedEvents({
+      workspaceRoot: args2.options.hierarchy.workspaceRoot,
+      node: args2.node,
+      prev: args2.prev.prevEntries,
+      next: nextEntries
+    });
+    events.push(...deletedUntracked);
+    const deletedPaths = new Set(deletedUntracked.map((e) => e.path));
+    if (left3.some((wsPath) => !deletedPaths.has(wsPath))) {
+      needsReconcile = true;
+    }
+    const diffEvents = diffPorcelainSnapshots({
+      workspaceRoot: args2.options.hierarchy.workspaceRoot,
+      node: args2.node,
+      prev: args2.prev.prevEntries,
+      next: nextEntries
+    });
+    events.push(...diffEvents);
+  } else if (args2.options.getKnownPaths) {
+    const knownPaths = args2.options.getKnownPaths();
+    const gapFillEvents = diffPorcelainAgainstKnownPaths({
+      workspaceRoot: args2.options.hierarchy.workspaceRoot,
+      node: args2.node,
+      knownPaths,
+      next: nextEntries
+    });
+    events.push(...gapFillEvents);
+  }
+  return {
+    events,
+    needsReconcile,
+    nextState: {
+      prevEntries: nextEntries,
+      prevHead: nextHead,
+      baselineEstablished: true
+    }
+  };
+}
+function createGitWorkspaceChangeSource(options) {
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const nodes = flattenGitRepoNodes(options.hierarchy.root);
+  const state = new Map;
+  for (const node of nodes) {
+    state.set(node.workTree, {
+      prevEntries: [],
+      prevHead: { head: null },
+      baselineEstablished: false
+    });
+  }
+  let stopped = false;
+  let timer = null;
+  let currentPoll = Promise.resolve();
+  let nextPollDelayMs = pollIntervalMs;
+  let consecutiveFailureTicks = 0;
+  let persistentFailureReported = false;
+  const nodeFailureCounts = new Map;
+  const schedule2 = (delay3) => {
+    if (stopped)
+      return;
+    timer = setTimeout(() => {
+      timer = null;
+      currentPoll = runPoll();
+      currentPoll.finally(() => {
+        if (!stopped)
+          schedule2(nextPollDelayMs);
+      });
+    }, delay3);
+    timer.unref?.();
+  };
+  const runPoll = async () => {
+    if (stopped)
+      return;
+    const allEvents = [];
+    let needsReconcile = false;
+    let tickHadFailure = false;
+    let maxNodeFailures = 0;
+    const results = await Promise.allSettled(nodes.map(async (node) => {
+      const prev = state.get(node.workTree) ?? {
+        prevEntries: [],
+        prevHead: { head: null },
+        baselineEstablished: false
+      };
+      const result = await pollGitWorkspaceNode({
+        options,
+        node,
+        prev
+      });
+      allEvents.push(...result.events);
+      if (result.needsReconcile)
+        needsReconcile = true;
+      state.set(node.workTree, result.nextState);
+      nodeFailureCounts.set(node.workTree, 0);
+      return node;
+    }));
+    for (let i2 = 0;i2 < results.length; i2++) {
+      const result = results[i2];
+      const node = nodes[i2];
+      if (!node || result.status === "fulfilled")
+        continue;
+      tickHadFailure = true;
+      options.onError?.(result.reason);
+      const prevFailures = nodeFailureCounts.get(node.workTree) ?? 0;
+      const nextFailures = prevFailures + 1;
+      nodeFailureCounts.set(node.workTree, nextFailures);
+      maxNodeFailures = Math.max(maxNodeFailures, nextFailures);
+    }
+    if (tickHadFailure) {
+      consecutiveFailureTicks += 1;
+      nextPollDelayMs = computeBackoff(maxNodeFailures, pollIntervalMs);
+      if (!persistentFailureReported && consecutiveFailureTicks >= PERSISTENT_FAILURE_THRESHOLD) {
+        persistentFailureReported = true;
+        await Promise.resolve(options.onPersistentFailure?.());
+      }
+    } else {
+      consecutiveFailureTicks = 0;
+      nextPollDelayMs = pollIntervalMs;
+    }
+    if (stopped)
+      return;
+    if (needsReconcile) {
+      await Promise.resolve(options.onNeedsReconcile?.());
+    }
+    const filtered = allEvents.filter((event) => {
+      if (!event.path)
+        return false;
+      if (options.shouldIgnore?.(event.path))
+        return false;
+      return true;
+    });
+    if (filtered.length === 0)
+      return;
+    const byPath = new Map;
+    for (const event of filtered)
+      byPath.set(event.path, event);
+    const events = [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+    try {
+      await Promise.resolve(options.onEvents(events));
+    } catch (error40) {
+      options.onError?.(error40);
+    }
+  };
+  let resolveReady;
+  const ready = new Promise((r) => {
+    resolveReady = r;
+  });
+  currentPoll = runPoll();
+  currentPoll.finally(() => {
+    resolveReady();
+    if (!stopped)
+      schedule2(nextPollDelayMs);
+  });
+  return {
+    ready,
+    stop: async () => {
+      stopped = true;
+      if (timer)
+        clearTimeout(timer);
+      timer = null;
+      await currentPoll;
+    }
+  };
+}
+var DEFAULT_POLL_INTERVAL_MS = 1000, MAX_BACKOFF_MS = 30000, PERSISTENT_FAILURE_THRESHOLD = 3;
+var init_git_workspace_change_source = __esm(() => {
+  init_git_workspace_porcelain();
+});
+
+// src/infrastructure/services/workspace/git-workspace-hierarchy.ts
+import { promises as fsPromises3 } from "node:fs";
+import path6 from "node:path";
+function normalizeRel(p) {
+  return p.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+async function revParse(workTree, arg) {
+  const result = await runGit(["rev-parse", arg], workTree);
+  if ("error" in result)
+    return null;
+  const value = result.stdout.trim();
+  return value.length > 0 ? value : null;
+}
+async function resolveGitDir(workTree) {
+  const raw = await revParse(workTree, "--git-dir");
+  if (!raw)
+    return null;
+  return path6.isAbsolute(raw) ? raw : path6.resolve(workTree, raw);
+}
+async function findNestedWorkTrees(workspaceRoot) {
+  const found = [];
+  async function visit(relDir) {
+    const absDir = relDir ? path6.join(workspaceRoot, relDir) : workspaceRoot;
+    let dirents;
+    try {
+      dirents = await fsPromises3.readdir(absDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of dirents) {
+      const name = ent.name;
+      const relativePath = relDir ? `${relDir}/${name}` : name;
+      if (name === ".git") {
+        if (relDir) {
+          found.push(path6.resolve(workspaceRoot, relDir));
+        }
+        continue;
+      }
+      if (!ent.isDirectory())
+        continue;
+      if (isAlwaysExcludedDirName(name))
+        continue;
+      if (!isPathVisible(relativePath))
+        continue;
+      await visit(relativePath);
+    }
+  }
+  await visit("");
+  return [...new Set(found.map((p) => path6.resolve(p)))].sort((a, b) => a.length - b.length || a.localeCompare(b));
+}
+async function discoverGitWorkspaceHierarchy(workingDir) {
+  let workspaceRoot;
+  try {
+    workspaceRoot = await fsPromises3.realpath(workingDir);
+  } catch {
+    return null;
+  }
+  const inside = await runGit(["rev-parse", "--is-inside-work-tree"], workspaceRoot);
+  if ("error" in inside || inside.stdout.trim() !== "true")
+    return null;
+  const toplevelRaw = await revParse(workspaceRoot, "--show-toplevel");
+  const gitDir = await resolveGitDir(workspaceRoot);
+  if (!toplevelRaw || !gitDir)
+    return null;
+  const toplevel = path6.resolve(toplevelRaw);
+  const relFromToplevel = normalizeRel(path6.relative(toplevel, workspaceRoot));
+  if (relFromToplevel.startsWith(".."))
+    return null;
+  const pathspec = relFromToplevel && toplevel !== workspaceRoot ? [relFromToplevel] : [];
+  const nestedWorkTrees = await findNestedWorkTrees(workspaceRoot);
+  const nestedNodes = [];
+  for (const workTree of nestedWorkTrees) {
+    const nestedGitDir = await resolveGitDir(workTree);
+    if (!nestedGitDir)
+      continue;
+    nestedNodes.push({
+      workTree,
+      gitDir: nestedGitDir,
+      relativePath: normalizeRel(path6.relative(workspaceRoot, workTree)),
+      pathspec: [],
+      children: []
+    });
+  }
+  const root = {
+    workTree: toplevel,
+    gitDir,
+    relativePath: "",
+    pathspec,
+    children: []
+  };
+  const sorted = nestedNodes.sort((a, b) => a.workTree.length - b.workTree.length || a.workTree.localeCompare(b.workTree));
+  for (const node of sorted) {
+    let parent = root;
+    for (const candidate of sorted) {
+      if (candidate === node)
+        continue;
+      const prefix = candidate.workTree.endsWith(path6.sep) ? candidate.workTree : candidate.workTree + path6.sep;
+      if (node.workTree.startsWith(prefix) && candidate.workTree.length >= parent.workTree.length) {
+        parent = candidate;
+      }
+    }
+    parent.children.push(node);
+  }
+  return { workspaceRoot, root };
+}
+var init_git_workspace_hierarchy = __esm(() => {
+  init_run_command();
+  init_workspace_visibility_policy();
+});
+
 // ../../node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js
 import { lstat, readdir, realpath as realpath3, stat as stat2 } from "node:fs/promises";
 import { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from "node:path";
@@ -102296,7 +102876,7 @@ var init_readdirp = __esm(() => {
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
       const statMethod = opts.lstat ? lstat : stat2;
       if (wantBigintFsStats) {
-        this._stat = (path5) => statMethod(path5, { bigint: true });
+        this._stat = (path7) => statMethod(path7, { bigint: true });
       } else {
         this._stat = statMethod;
       }
@@ -102321,8 +102901,8 @@ var init_readdirp = __esm(() => {
           const par2 = this.parent;
           const fil = par2 && par2.files;
           if (fil && fil.length > 0) {
-            const { path: path5, depth } = par2;
-            const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path5));
+            const { path: path7, depth } = par2;
+            const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path7));
             const awaited = await Promise.all(slice);
             for (const entry of awaited) {
               if (!entry)
@@ -102362,20 +102942,20 @@ var init_readdirp = __esm(() => {
         this.reading = false;
       }
     }
-    async _exploreDir(path5, depth) {
+    async _exploreDir(path7, depth) {
       let files;
       try {
-        files = await readdir(path5, this._rdOptions);
+        files = await readdir(path7, this._rdOptions);
       } catch (error40) {
         this._onError(error40);
       }
-      return { files, depth, path: path5 };
+      return { files, depth, path: path7 };
     }
-    async _formatEntry(dirent, path5) {
+    async _formatEntry(dirent, path7) {
       let entry;
       const basename2 = this._isDirent ? dirent.name : dirent;
       try {
-        const fullPath = presolve(pjoin(path5, basename2));
+        const fullPath = presolve(pjoin(path7, basename2));
         entry = { path: prelative(this._root, fullPath), fullPath, basename: basename2 };
         entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
       } catch (err) {
@@ -102435,16 +103015,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(path5, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path7, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path5);
-    emitRaw(rawEvent, evPath, { watchedPath: path5 });
-    if (evPath && path5 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path5, evPath), KEY_LISTENERS, sp.join(path5, evPath));
+    listener(path7);
+    emitRaw(rawEvent, evPath, { watchedPath: path7 });
+    if (evPath && path7 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path7, evPath), KEY_LISTENERS, sp.join(path7, evPath));
     }
   };
   try {
-    return fs_watch(path5, {
+    return fs_watch(path7, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error40) {
@@ -102460,13 +103040,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error40) => fsW._handleError(error40);
   }
-  _watchWithNodeFs(path5, listener) {
+  _watchWithNodeFs(path7, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path5);
-    const basename3 = sp.basename(path5);
+    const directory = sp.dirname(path7);
+    const basename3 = sp.basename(path7);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename3);
-    const absolutePath = sp.resolve(path5);
+    const absolutePath = sp.resolve(path7);
     const options = {
       persistent: opts.persistent
     };
@@ -102476,12 +103056,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path5, absolutePath, options, {
+      closer = setFsWatchFileListener(path7, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path5, absolutePath, options, {
+      closer = setFsWatchListener(path7, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -102499,7 +103079,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename3))
       return;
-    const listener = async (path5, newStats) => {
+    const listener = async (path7, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -102513,11 +103093,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file2, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path5);
+            this.fsw._closeFile(path7);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file2, listener);
             if (closer2)
-              this.fsw._addPathCloser(path5, closer2);
+              this.fsw._addPathCloser(path7, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -102541,7 +103121,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path5, item) {
+  async _handleSymlink(entry, directory, path7, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -102551,7 +103131,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path5);
+        linkPath = await fsrealpath(path7);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -102561,12 +103141,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, path5, entry.stats);
+          this.fsw._emit(EV.CHANGE, path7, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path5, entry.stats);
+        this.fsw._emit(EV.ADD, path7, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -102596,9 +103176,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path5 = sp.join(directory, item);
+      let path7 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path5, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path7, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -102607,8 +103187,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path5 = sp.join(dir, sp.relative(dir, path5));
-        this._addToNodeFs(path5, initialAdd, wh, depth + 1);
+        path7 = sp.join(dir, sp.relative(dir, path7));
+        this._addToNodeFs(path7, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve6, reject) => {
@@ -102657,13 +103237,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path5, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path7, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path5) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path5);
+    const wh = this.fsw._getWatchHelpers(path7);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -102679,8 +103259,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path5);
-        const targetPath = follow ? await fsrealpath(path5) : path5;
+        const absPath = sp.resolve(path7);
+        const targetPath = follow ? await fsrealpath(path7) : path7;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -102690,29 +103270,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path5) : path5;
+        const targetPath = follow ? await fsrealpath(path7) : path7;
         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, path5, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path7, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sp.resolve(path5), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path7), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path5, closer);
+        this.fsw._addPathCloser(path7, closer);
       return false;
     } catch (error40) {
       if (this.fsw._handleError(error40)) {
         ready();
-        return path5;
+        return path7;
       }
     }
   }
@@ -102750,12 +103330,12 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
   foreach(cont[listenerType], (listener) => {
     listener(val1, val2, val3);
   });
-}, setFsWatchListener = (path5, fullPath, options, handlers) => {
+}, setFsWatchListener = (path7, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path5, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path7, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -102765,7 +103345,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(path5, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path7, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error40) => {
@@ -102774,7 +103354,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
         cont.watcherUnusable = true;
       if (isWindows && error40.code === "EPERM") {
         try {
-          const fd = await open(path5, "r");
+          const fd = await open(path7, "r");
           await fd.close();
           broadcastErr(error40);
         } catch (err) {}
@@ -102802,7 +103382,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
       Object.freeze(cont);
     }
   };
-}, FsWatchFileInstances, setFsWatchFileListener = (path5, fullPath, options, handlers) => {
+}, FsWatchFileInstances, setFsWatchFileListener = (path7, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -102824,7 +103404,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(path5, curr));
+          foreach(cont.listeners, (listener2) => listener2(path7, curr));
         }
       })
     };
@@ -103160,24 +103740,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path5) {
-  if (typeof path5 !== "string")
+function normalizePath(path7) {
+  if (typeof path7 !== "string")
     throw new Error("string expected");
-  path5 = sp2.normalize(path5);
-  path5 = path5.replace(/\\/g, "/");
+  path7 = sp2.normalize(path7);
+  path7 = path7.replace(/\\/g, "/");
   let prepend4 = false;
-  if (path5.startsWith("//"))
+  if (path7.startsWith("//"))
     prepend4 = true;
-  path5 = path5.replace(DOUBLE_SLASH_RE, "/");
+  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
   if (prepend4)
-    path5 = "/" + path5;
-  return path5;
+    path7 = "/" + path7;
+  return path7;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path5 = normalizePath(testString);
+  const path7 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern2 = patterns[index];
-    if (pattern2(path5, stats)) {
+    if (pattern2(path7, stats)) {
       return true;
     }
   }
@@ -103258,10 +103838,10 @@ class WatchHelper {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path5, follow, fsw) {
+  constructor(path7, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path5;
-    this.path = path5 = path5.replace(REPLACER_RE, "");
+    const watchPath = path7;
+    this.path = path7 = path7.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -103308,17 +103888,17 @@ var SLASH = "/", SLASH_SLASH = "//", ONE_DOT = ".", TWO_DOTS = "..", STRING_TYPE
     str = SLASH + str;
   }
   return str;
-}, normalizePathToUnix = (path5) => toUnix(sp2.normalize(toUnix(path5))), normalizeIgnored = (cwd = "") => (path5) => {
-  if (typeof path5 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path5) ? path5 : sp2.join(cwd, path5));
+}, normalizePathToUnix = (path7) => toUnix(sp2.normalize(toUnix(path7))), normalizeIgnored = (cwd = "") => (path7) => {
+  if (typeof path7 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path7) ? path7 : sp2.join(cwd, path7));
   } else {
-    return path5;
+    return path7;
   }
-}, getAbsolutePath = (path5, cwd) => {
-  if (sp2.isAbsolute(path5)) {
-    return path5;
+}, getAbsolutePath = (path7, cwd) => {
+  if (sp2.isAbsolute(path7)) {
+    return path7;
   }
-  return sp2.join(cwd, path5);
+  return sp2.join(cwd, path7);
 }, EMPTY_SET, STAT_METHOD_F = "stat", STAT_METHOD_L = "lstat", FSWatcher;
 var init_chokidar = __esm(() => {
   init_readdirp();
@@ -103434,20 +104014,20 @@ var init_chokidar = __esm(() => {
       this._closePromise = undefined;
       let paths = unifyPaths(paths_);
       if (cwd) {
-        paths = paths.map((path5) => {
-          const absPath = getAbsolutePath(path5, cwd);
+        paths = paths.map((path7) => {
+          const absPath = getAbsolutePath(path7, cwd);
           return absPath;
         });
       }
-      paths.forEach((path5) => {
-        this._removeIgnoredPath(path5);
+      paths.forEach((path7) => {
+        this._removeIgnoredPath(path7);
       });
       this._userIgnored = undefined;
       if (!this._readyCount)
         this._readyCount = 0;
       this._readyCount += paths.length;
-      Promise.all(paths.map(async (path5) => {
-        const res = await this._nodeFsHandler._addToNodeFs(path5, !_internal, undefined, 0, _origAdd);
+      Promise.all(paths.map(async (path7) => {
+        const res = await this._nodeFsHandler._addToNodeFs(path7, !_internal, undefined, 0, _origAdd);
         if (res)
           this._emitReady();
         return res;
@@ -103466,17 +104046,17 @@ var init_chokidar = __esm(() => {
         return this;
       const paths = unifyPaths(paths_);
       const { cwd } = this.options;
-      paths.forEach((path5) => {
-        if (!sp2.isAbsolute(path5) && !this._closers.has(path5)) {
+      paths.forEach((path7) => {
+        if (!sp2.isAbsolute(path7) && !this._closers.has(path7)) {
           if (cwd)
-            path5 = sp2.join(cwd, path5);
-          path5 = sp2.resolve(path5);
+            path7 = sp2.join(cwd, path7);
+          path7 = sp2.resolve(path7);
         }
-        this._closePath(path5);
-        this._addIgnoredPath(path5);
-        if (this._watched.has(path5)) {
+        this._closePath(path7);
+        this._addIgnoredPath(path7);
+        if (this._watched.has(path7)) {
           this._addIgnoredPath({
-            path: path5,
+            path: path7,
             recursive: true
           });
         }
@@ -103525,38 +104105,38 @@ var init_chokidar = __esm(() => {
       if (event !== EVENTS.ERROR)
         this.emit(EVENTS.ALL, event, ...args2);
     }
-    async _emit(event, path5, stats) {
+    async _emit(event, path7, stats) {
       if (this.closed)
         return;
       const opts = this.options;
       if (isWindows)
-        path5 = sp2.normalize(path5);
+        path7 = sp2.normalize(path7);
       if (opts.cwd)
-        path5 = sp2.relative(opts.cwd, path5);
-      const args2 = [path5];
+        path7 = sp2.relative(opts.cwd, path7);
+      const args2 = [path7];
       if (stats != null)
         args2.push(stats);
       const awf = opts.awaitWriteFinish;
       let pw;
-      if (awf && (pw = this._pendingWrites.get(path5))) {
+      if (awf && (pw = this._pendingWrites.get(path7))) {
         pw.lastChange = new Date;
         return this;
       }
       if (opts.atomic) {
         if (event === EVENTS.UNLINK) {
-          this._pendingUnlinks.set(path5, [event, ...args2]);
+          this._pendingUnlinks.set(path7, [event, ...args2]);
           setTimeout(() => {
-            this._pendingUnlinks.forEach((entry, path6) => {
+            this._pendingUnlinks.forEach((entry, path8) => {
               this.emit(...entry);
               this.emit(EVENTS.ALL, ...entry);
-              this._pendingUnlinks.delete(path6);
+              this._pendingUnlinks.delete(path8);
             });
           }, typeof opts.atomic === "number" ? opts.atomic : 100);
           return this;
         }
-        if (event === EVENTS.ADD && this._pendingUnlinks.has(path5)) {
+        if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
           event = EVENTS.CHANGE;
-          this._pendingUnlinks.delete(path5);
+          this._pendingUnlinks.delete(path7);
         }
       }
       if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -103574,16 +104154,16 @@ var init_chokidar = __esm(() => {
             this.emitWithAll(event, args2);
           }
         };
-        this._awaitWriteFinish(path5, awf.stabilityThreshold, event, awfEmit);
+        this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
         return this;
       }
       if (event === EVENTS.CHANGE) {
-        const isThrottled = !this._throttle(EVENTS.CHANGE, path5, 50);
+        const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 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, path5) : path5;
+        const fullPath = opts.cwd ? sp2.join(opts.cwd, path7) : path7;
         let stats2;
         try {
           stats2 = await stat4(fullPath);
@@ -103602,23 +104182,23 @@ var init_chokidar = __esm(() => {
       }
       return error40 || this.closed;
     }
-    _throttle(actionType, path5, timeout3) {
+    _throttle(actionType, path7, 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(path5);
+      const actionPath = action.get(path7);
       if (actionPath) {
         actionPath.count++;
         return false;
       }
       let timeoutObject;
       const clear = () => {
-        const item = action.get(path5);
+        const item = action.get(path7);
         const count3 = item ? item.count : 0;
-        action.delete(path5);
+        action.delete(path7);
         clearTimeout(timeoutObject);
         if (item)
           clearTimeout(item.timeoutObject);
@@ -103626,50 +104206,50 @@ var init_chokidar = __esm(() => {
       };
       timeoutObject = setTimeout(clear, timeout3);
       const thr = { timeoutObject, clear, count: 0 };
-      action.set(path5, thr);
+      action.set(path7, thr);
       return thr;
     }
     _incrReadyCount() {
       return this._readyCount++;
     }
-    _awaitWriteFinish(path5, threshold, event, awfEmit) {
+    _awaitWriteFinish(path7, threshold, event, awfEmit) {
       const awf = this.options.awaitWriteFinish;
       if (typeof awf !== "object")
         return;
       const pollInterval = awf.pollInterval;
       let timeoutHandler;
-      let fullPath = path5;
-      if (this.options.cwd && !sp2.isAbsolute(path5)) {
-        fullPath = sp2.join(this.options.cwd, path5);
+      let fullPath = path7;
+      if (this.options.cwd && !sp2.isAbsolute(path7)) {
+        fullPath = sp2.join(this.options.cwd, path7);
       }
       const now = new Date;
       const writes = this._pendingWrites;
       function awaitWriteFinishFn(prevStat) {
         statcb(fullPath, (err, curStat) => {
-          if (err || !writes.has(path5)) {
+          if (err || !writes.has(path7)) {
             if (err && err.code !== "ENOENT")
               awfEmit(err);
             return;
           }
           const now2 = Number(new Date);
           if (prevStat && curStat.size !== prevStat.size) {
-            writes.get(path5).lastChange = now2;
+            writes.get(path7).lastChange = now2;
           }
-          const pw = writes.get(path5);
+          const pw = writes.get(path7);
           const df = now2 - pw.lastChange;
           if (df >= threshold) {
-            writes.delete(path5);
+            writes.delete(path7);
             awfEmit(undefined, curStat);
           } else {
             timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
           }
         });
       }
-      if (!writes.has(path5)) {
-        writes.set(path5, {
+      if (!writes.has(path7)) {
+        writes.set(path7, {
           lastChange: now,
           cancelWait: () => {
-            writes.delete(path5);
+            writes.delete(path7);
             clearTimeout(timeoutHandler);
             return event;
           }
@@ -103677,8 +104257,8 @@ var init_chokidar = __esm(() => {
         timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
       }
     }
-    _isIgnored(path5, stats) {
-      if (this.options.atomic && DOT_RE.test(path5))
+    _isIgnored(path7, stats) {
+      if (this.options.atomic && DOT_RE.test(path7))
         return true;
       if (!this._userIgnored) {
         const { cwd } = this.options;
@@ -103688,13 +104268,13 @@ var init_chokidar = __esm(() => {
         const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
         this._userIgnored = anymatch(list, undefined);
       }
-      return this._userIgnored(path5, stats);
+      return this._userIgnored(path7, stats);
     }
-    _isntIgnored(path5, stat5) {
-      return !this._isIgnored(path5, stat5);
+    _isntIgnored(path7, stat5) {
+      return !this._isIgnored(path7, stat5);
     }
-    _getWatchHelpers(path5) {
-      return new WatchHelper(path5, this.options.followSymlinks, this);
+    _getWatchHelpers(path7) {
+      return new WatchHelper(path7, this.options.followSymlinks, this);
     }
     _getWatchedDir(directory) {
       const dir = sp2.resolve(directory);
@@ -103708,57 +104288,57 @@ var init_chokidar = __esm(() => {
       return Boolean(Number(stats.mode) & 256);
     }
     _remove(directory, item, isDirectory) {
-      const path5 = sp2.join(directory, item);
-      const fullPath = sp2.resolve(path5);
-      isDirectory = isDirectory != null ? isDirectory : this._watched.has(path5) || this._watched.has(fullPath);
-      if (!this._throttle("remove", path5, 100))
+      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))
         return;
       if (!isDirectory && this._watched.size === 1) {
         this.add(directory, item, true);
       }
-      const wp = this._getWatchedDir(path5);
+      const wp = this._getWatchedDir(path7);
       const nestedDirectoryChildren = wp.getChildren();
-      nestedDirectoryChildren.forEach((nested2) => this._remove(path5, nested2));
+      nestedDirectoryChildren.forEach((nested2) => this._remove(path7, 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 = path5;
+      let relPath = path7;
       if (this.options.cwd)
-        relPath = sp2.relative(this.options.cwd, path5);
+        relPath = sp2.relative(this.options.cwd, path7);
       if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
         const event = this._pendingWrites.get(relPath).cancelWait();
         if (event === EVENTS.ADD)
           return;
       }
-      this._watched.delete(path5);
+      this._watched.delete(path7);
       this._watched.delete(fullPath);
       const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-      if (wasTracked && !this._isIgnored(path5))
-        this._emit(eventName, path5);
-      this._closePath(path5);
+      if (wasTracked && !this._isIgnored(path7))
+        this._emit(eventName, path7);
+      this._closePath(path7);
     }
-    _closePath(path5) {
-      this._closeFile(path5);
-      const dir = sp2.dirname(path5);
-      this._getWatchedDir(dir).remove(sp2.basename(path5));
+    _closePath(path7) {
+      this._closeFile(path7);
+      const dir = sp2.dirname(path7);
+      this._getWatchedDir(dir).remove(sp2.basename(path7));
     }
-    _closeFile(path5) {
-      const closers = this._closers.get(path5);
+    _closeFile(path7) {
+      const closers = this._closers.get(path7);
       if (!closers)
         return;
       closers.forEach((closer) => closer());
-      this._closers.delete(path5);
+      this._closers.delete(path7);
     }
-    _addPathCloser(path5, closer) {
+    _addPathCloser(path7, closer) {
       if (!closer)
         return;
-      let list = this._closers.get(path5);
+      let list = this._closers.get(path7);
       if (!list) {
         list = [];
-        this._closers.set(path5, list);
+        this._closers.set(path7, list);
       }
       list.push(closer);
     }
@@ -103783,7 +104363,7 @@ var init_chokidar = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/workspace-fs-watcher.ts
-import path5 from "node:path";
+import path7 from "node:path";
 function isTooManyOpenFilesError(error40) {
   if (!(error40 instanceof Error))
     return false;
@@ -103791,10 +104371,10 @@ function isTooManyOpenFilesError(error40) {
   return errno === "EMFILE" || errno === "ENOSPC" || error40.message.includes("EMFILE");
 }
 function toRelativePath(rootDir, absolutePath) {
-  return path5.relative(rootDir, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
+  return path7.relative(rootDir, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
 }
 function createWorkspaceFsWatcher(options) {
-  const absWorkingDir = path5.resolve(options.workingDir);
+  const absWorkingDir = path7.resolve(options.workingDir);
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   let stopped = false;
   let debounceTimer = null;
@@ -103860,22 +104440,46 @@ var init_workspace_fs_watcher = __esm(() => {
   init_workspace_visibility_policy();
 });
 
+// src/infrastructure/services/workspace/workspace-change-source.ts
+function countGitRepoNodes(root) {
+  return 1 + root.children.reduce((sum2, child) => sum2 + countGitRepoNodes(child), 0);
+}
+async function createWorkspaceChangeSource(options) {
+  const hierarchy = await discoverGitWorkspaceHierarchy(options.workingDir);
+  if (hierarchy !== null) {
+    return {
+      mode: "git",
+      source: createGitWorkspaceChangeSource({ ...options, hierarchy }),
+      gitRepoCount: countGitRepoNodes(hierarchy.root)
+    };
+  }
+  return {
+    mode: "fs",
+    source: createWorkspaceFsWatcher(options)
+  };
+}
+var init_workspace_change_source = __esm(() => {
+  init_git_workspace_change_source();
+  init_git_workspace_hierarchy();
+  init_workspace_fs_watcher();
+});
+
 // src/infrastructure/services/workspace/workspace-sync-diff.ts
 function diffPathIndexes(previous, next4) {
   const added = [];
   const removed = [];
   const typeChanged = [];
   const prev = previous ?? {};
-  for (const [path6, type] of Object.entries(next4)) {
-    if (!(path6 in prev)) {
-      added.push(path6);
-    } else if (prev[path6] !== type) {
-      typeChanged.push(path6);
+  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 path6 of Object.keys(prev)) {
-    if (!(path6 in next4)) {
-      removed.push(path6);
+  for (const path8 of Object.keys(prev)) {
+    if (!(path8 in next4)) {
+      removed.push(path8);
     }
   }
   added.sort();
@@ -103961,7 +104565,7 @@ function createManifestFromTree(args2) {
   };
 }
 function entriesFromPathIndex(paths) {
-  return Object.entries(paths).map(([path6, type]) => ({ path: path6, type })).sort((a, b) => a.path.localeCompare(b.path));
+  return Object.entries(paths).map(([path8, type]) => ({ path: path8, type })).sort((a, b) => a.path.localeCompare(b.path));
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
@@ -103970,7 +104574,7 @@ var init_workspace_sync_state = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import path6 from "node:path";
+import path8 from "node:path";
 function deltaEntry(paths, pathValue) {
   const type = paths[pathValue];
   if (type === undefined)
@@ -104036,7 +104640,7 @@ async function addDirectorySubtree(rootDir, relativeDir, paths) {
     return;
   ensureParentDirectories(paths, relativeDir);
   paths[relativeDir] = "directory";
-  const subtree = await scanFileTree(path6.join(rootDir, relativeDir));
+  const subtree = await scanFileTree(path8.join(rootDir, relativeDir));
   for (const entry of subtree.entries) {
     const prefixedPath = `${relativeDir}/${entry.path}`;
     if (await isWorkspacePathIgnored(rootDir, prefixedPath))
@@ -104175,31 +104779,69 @@ async function startWorkspaceFileTreeCoordinator(options) {
   await flushPending();
   const ignoreRuleSets = await loadAllWorkspaceIgnoreRuleSets(workingDir);
   const shouldIgnorePath = (relativePath) => isPathIgnoredByRuleSets(ignoreRuleSets, relativePath);
-  let watcher = createWorkspaceFsWatcher({
-    workingDir,
-    shouldIgnore: shouldIgnorePath,
-    onEvents: async (events) => {
-      await enqueueSerial(async () => {
-        const nextPaths = await applyFsEvents(workingDir, manifest.paths, events);
-        if (nextPaths === null) {
-          await reconcileNow();
-          return;
-        }
-        await commitPaths(nextPaths);
-      });
-    },
-    onError: (error40) => {
-      options.onError?.(error40);
-      if (isTooManyOpenFilesError(error40) && watcher) {
-        const activeWatcher = watcher;
-        watcher = null;
-        activeWatcher.stop().finally(() => scheduleReconcile(1000));
+  let changeSource = null;
+  let changeSourceMode = "fs";
+  let gitDegraded = false;
+  const handleChangeSourceEvents = async (events) => {
+    await enqueueSerial(async () => {
+      const nextPaths = await applyFsEvents(workingDir, manifest.paths, events);
+      if (nextPaths === null) {
+        await reconcileNow();
         return;
       }
-      scheduleReconcile(1000);
+      await commitPaths(nextPaths);
+    });
+  };
+  const handleChangeSourceError = (error40) => {
+    if (error40 instanceof GitWorkspaceCommandError) {
+      console.warn(`[workspace-file-tree] git poll error (${error40.operation}) workTree=${error40.workTree} relativePath=${error40.relativePath || "."}: ${error40.cause.message}`);
     }
-  });
-  await watcher.ready;
+    options.onError?.(error40);
+    if (changeSourceMode === "fs" && isTooManyOpenFilesError(error40) && changeSource) {
+      const active2 = changeSource;
+      changeSource = null;
+      active2.stop().finally(() => scheduleReconcile(1000));
+      return;
+    }
+    scheduleReconcile(1000);
+  };
+  const degradeGitToFs = async (reason) => {
+    if (gitDegraded || changeSourceMode !== "git" || !changeSource)
+      return;
+    gitDegraded = true;
+    console.log(`[workspace-file-tree] degrading to fs watcher: ${reason}`);
+    const active2 = changeSource;
+    changeSource = null;
+    changeSourceMode = "fs";
+    await active2.stop();
+    const fs12 = createWorkspaceFsWatcher({
+      workingDir,
+      shouldIgnore: shouldIgnorePath,
+      onEvents: handleChangeSourceEvents,
+      onError: handleChangeSourceError
+    });
+    changeSource = fs12;
+    await fs12.ready;
+    console.log("[workspace-file-tree] change source: fs (degraded from git)");
+  };
+  const change = await createWorkspaceChangeSource({
+    workingDir,
+    pollIntervalMs: options.changeSourcePollIntervalMs,
+    shouldIgnore: shouldIgnorePath,
+    getKnownPaths: () => manifest.paths,
+    onEvents: handleChangeSourceEvents,
+    onNeedsReconcile: () => enqueueSerial(reconcileNow),
+    onError: handleChangeSourceError,
+    onPersistentFailure: () => degradeGitToFs("persistent git poll failures")
+  });
+  changeSource = change.source;
+  changeSourceMode = change.mode;
+  if (change.mode === "git") {
+    console.log(`[workspace-file-tree] change source: git (${change.gitRepoCount ?? 1} repo${(change.gitRepoCount ?? 1) === 1 ? "" : "s"})`);
+  } else {
+    console.log("[workspace-file-tree] change source: fs");
+  }
+  await changeSource.ready;
   scheduleReconcile();
   return {
     workingDir,
@@ -104212,8 +104854,8 @@ async function startWorkspaceFileTreeCoordinator(options) {
       if (reconcileTimer)
         clearTimeout(reconcileTimer);
       reconcileTimer = null;
-      await watcher?.stop();
-      watcher = null;
+      await changeSource?.stop();
+      changeSource = null;
       await serial;
       await saveWorkspaceSyncManifest(manifest);
     }
@@ -104223,6 +104865,8 @@ var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_CHECKPOINT_EVERY_REVISIONS = 100, REC
 var init_workspace_file_tree_coordinator = __esm(() => {
   init_file_tree_data_hash();
   init_file_tree_scanner();
+  init_git_workspace_porcelain();
+  init_workspace_change_source();
   init_workspace_fs_watcher();
   init_workspace_ignore();
   init_workspace_sync_state();
@@ -111430,7 +112074,7 @@ __export(exports_opencode_install, {
   installTool: () => installTool
 });
 import * as os2 from "os";
-import * as path7 from "path";
+import * as path9 from "path";
 async function isChatroomInstalledDefault() {
   try {
     const { execSync: execSync3 } = await import("child_process");
@@ -111800,9 +112444,9 @@ After logging in, try this command again.\`;
   const fsService = yield* OpenCodeInstallFsService;
   const { checkExisting = true } = options;
   const homeDir = os2.homedir();
-  const toolDir = path7.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path7.join(toolDir, "chatroom.ts");
-  const handoffToolPath = path7.join(toolDir, "chatroom-handoff.ts");
+  const toolDir = path9.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path9.join(toolDir, "chatroom.ts");
+  const handoffToolPath = path9.join(toolDir, "chatroom-handoff.ts");
   if (checkExisting) {
     const existingFiles = [];
     const toolExists = yield* fsService.access(toolPath);
@@ -112357,4 +113001,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=CC11114DB63A703A64756E2164756E21
+//# debugId=B20428C3563382D064756E2164756E21