chatroom-cli 1.65.1 → 1.65.2

package/dist/index.js

@@ -88419,6 +88419,379 @@ function gunzipBase64Payload(base64, maxBytes) {
 }
 var init_workspace_path_security = () => {};
 
+// src/infrastructure/services/workspace/workspace-visibility-policy.ts
+function isAlwaysExcludedDirName(name) {
+  return ALWAYS_EXCLUDE_DIR_NAMES.has(name);
+}
+function isSecretPath(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  return SECRET_PATH_PATTERNS.some((pattern2) => pattern2.test(normalized));
+}
+function hasExcludedDirSegment(relativePath) {
+  const segments = relativePath.split("/");
+  return segments.some((segment) => isAlwaysExcludedDirName(segment));
+}
+function isPathVisible(relativePath) {
+  if (!relativePath)
+    return true;
+  return !isSecretPath(relativePath) && !hasExcludedDirSegment(relativePath);
+}
+function isPathContentReadable(relativePath) {
+  return isPathVisible(relativePath);
+}
+var ALWAYS_EXCLUDE_DIR_NAMES, SECRET_PATH_PATTERNS;
+var init_workspace_visibility_policy = __esm(() => {
+  ALWAYS_EXCLUDE_DIR_NAMES = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    "coverage",
+    "__pycache__",
+    ".turbo",
+    ".cache",
+    ".tmp",
+    "tmp",
+    "_generated",
+    ".vercel"
+  ]);
+  SECRET_PATH_PATTERNS = [
+    /^\.env$/,
+    /^\.env\./,
+    /\.pem$/,
+    /\.key$/,
+    /id_rsa$/,
+    /credentials\.json$/,
+    /^secrets(\/|$)/,
+    /^\.aws(\/|$)/
+  ];
+});
+
+// src/commands/machine/daemon-start/file-content-fulfillment.ts
+import { readFile as readFile7 } from "node:fs/promises";
+import { gzipSync as gzipSync2 } from "node:zlib";
+function getErrorCause(error) {
+  if (typeof error === "object" && error !== null && "cause" in error && error.cause !== undefined) {
+    return error.cause;
+  }
+  return error;
+}
+function isENOENT(error) {
+  const cause3 = getErrorCause(error);
+  return typeof cause3 === "object" && cause3 !== null && "code" in cause3 && cause3.code === "ENOENT";
+}
+function isBinaryFile(path3) {
+  const lastDot = path3.lastIndexOf(".");
+  if (lastDot === -1)
+    return false;
+  return BINARY_EXTENSIONS.has(path3.slice(lastDot).toLowerCase());
+}
+function gzipPlainText(text) {
+  return gzipSync2(Buffer.from(text)).toString("base64");
+}
+function fulfillGzippedContentEffect(session2, workingDir, filePath, plainText, truncated) {
+  return exports_Effect.catchAll(exports_Effect.tryPromise(() => session2.backend.mutation(api.workspaceFiles.fulfillFileContentV2, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir,
+    filePath,
+    data: { compression: "gzip", content: gzipPlainText(plainText) },
+    encoding: "utf8",
+    truncated
+  })), () => exports_Effect.void);
+}
+var MAX_CONTENT_BYTES, BINARY_EXTENSIONS, fulfillFileContentRequestsEffect;
+var init_file_content_fulfillment = __esm(() => {
+  init_esm();
+  init_daemon_services();
+  init_api3();
+  init_assert_registered_working_dir();
+  init_workspace_path_security();
+  init_workspace_visibility_policy();
+  MAX_CONTENT_BYTES = 500 * 1024;
+  BINARY_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".ico",
+    ".svg",
+    ".mp3",
+    ".mp4",
+    ".wav",
+    ".ogg",
+    ".webm",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".bz2",
+    ".7z",
+    ".rar",
+    ".pdf",
+    ".doc",
+    ".docx",
+    ".xls",
+    ".xlsx",
+    ".ppt",
+    ".pptx",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot",
+    ".exe",
+    ".dll",
+    ".so",
+    ".dylib",
+    ".bin",
+    ".dat",
+    ".db",
+    ".sqlite"
+  ]);
+  fulfillFileContentRequestsEffect = exports_Effect.gen(function* () {
+    const session2 = yield* DaemonSessionService;
+    const requests = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => session2.backend.query(api.workspaceFiles.getPendingFileContentRequests, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId
+    })), () => exports_Effect.succeed([]));
+    if (requests.length === 0)
+      return;
+    console.log(`[${formatTimestamp()}] \uD83D\uDCE5 Received ${requests.length} pending file content request(s): ${requests.map((r) => r.filePath).join(", ")}`);
+    for (const request2 of requests) {
+      const startTime = Date.now();
+      const { workingDir, filePath } = request2;
+      const registered = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => assertRegisteredWorkingDir(session2, workingDir)), () => exports_Effect.succeed({ ok: false, error: "Workspace check failed" }));
+      if (!registered.ok) {
+        console.warn(`[${formatTimestamp()}] ⚠️  Rejected unregistered workspace: ${workingDir} (${registered.error})`);
+        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Error: workspace not registered]", false);
+        continue;
+      }
+      const resolved = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => resolvePathWithinWorkspace(workingDir, filePath)), () => exports_Effect.succeed({ ok: false, error: "Invalid file path" }));
+      if (!resolved.ok) {
+        console.warn(`[${formatTimestamp()}] ⚠️  Rejected file path: ${filePath} (${resolved.error})`);
+        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Error reading file]", false);
+        continue;
+      }
+      const absolutePath = resolved.absolutePath;
+      if (isBinaryFile(filePath)) {
+        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Binary file]", false);
+        const elapsed4 = Date.now() - startTime;
+        console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File content synced to Convex: ${filePath} [binary] (${elapsed4}ms)`);
+        continue;
+      }
+      if (!isPathContentReadable(filePath)) {
+        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[File blocked: cannot open sensitive path in remote explorer]", false);
+        const elapsed4 = Date.now() - startTime;
+        console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File content blocked: ${filePath} [secret] (${elapsed4}ms)`);
+        continue;
+      }
+      const readOutcome = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => readFile7(absolutePath)).pipe(exports_Effect.map((buffer) => {
+        if (buffer.length > MAX_CONTENT_BYTES) {
+          return {
+            kind: "ok",
+            content: buffer.subarray(0, MAX_CONTENT_BYTES).toString("utf8"),
+            truncated: true
+          };
+        }
+        return {
+          kind: "ok",
+          content: buffer.toString("utf8"),
+          truncated: false
+        };
+      })), (error) => isENOENT(error) ? exports_Effect.succeed({ kind: "missing" }) : exports_Effect.succeed({
+        kind: "error",
+        content: "[Error reading file]",
+        truncated: false
+      }));
+      if (readOutcome.kind === "missing") {
+        console.log(`[${formatTimestamp()}] ⏳ File not on disk yet, deferring content sync: ${filePath}`);
+        continue;
+      }
+      const { content, truncated } = readOutcome.kind === "ok" ? readOutcome : { content: readOutcome.content, truncated: readOutcome.truncated };
+      const compressed = gzipSync2(Buffer.from(content));
+      const contentCompressed = compressed.toString("base64");
+      yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => session2.backend.mutation(api.workspaceFiles.fulfillFileContentV2, {
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        workingDir,
+        filePath,
+        data: { compression: "gzip", content: contentCompressed },
+        encoding: "utf8",
+        truncated
+      })), () => exports_Effect.void);
+      const elapsed3 = Date.now() - startTime;
+      console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File content synced to Convex: ${filePath} (${(Buffer.byteLength(content) / 1024).toFixed(1)}KB → ${(compressed.length / 1024).toFixed(1)}KB gzip, ${elapsed3}ms)`);
+    }
+  });
+});
+
+// src/commands/machine/daemon-start/file-content-subscription.ts
+var startFileContentSubscriptionEffect = (wsClient2) => exports_Effect.gen(function* () {
+  const session2 = yield* DaemonSessionService;
+  let processing = false;
+  const unsubscribe = wsClient2.onUpdate(api.workspaceFiles.getPendingFileContentRequests, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId
+  }, (requests) => {
+    if (!requests || requests.length === 0)
+      return;
+    if (processing)
+      return;
+    processing = true;
+    exports_Effect.runPromise(fulfillFileContentRequestsEffect.pipe(exports_Effect.provideService(DaemonSessionService, session2))).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️  File content subscription processing failed: ${getErrorMessage2(err)}`);
+    }).finally(() => {
+      processing = false;
+    });
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️  File content subscription error: ${getErrorMessage2(err)}`);
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCC2 File content subscription started (reactive)`);
+  return {
+    stop: () => {
+      unsubscribe();
+      console.log(`[${formatTimestamp()}] \uD83D\uDCC2 File content subscription stopped`);
+    }
+  };
+});
+var init_file_content_subscription = __esm(() => {
+  init_esm();
+  init_daemon_services();
+  init_file_content_fulfillment();
+  init_api3();
+  init_convex_error();
+});
+
+// src/infrastructure/services/workspace/file-tree-data-hash.ts
+import { createHash as createHash4 } from "node:crypto";
+function computeFileTreeDataHash(tree) {
+  return createHash4("md5").update(JSON.stringify(tree)).digest("hex");
+}
+var init_file_tree_data_hash = () => {};
+
+// src/infrastructure/services/workspace/file-tree-partition.ts
+import { createHash as createHash5 } from "node:crypto";
+import { gzipSync as gzipSync3 } from "node:zlib";
+function computeShardDataHash(payload) {
+  return createHash5("md5").update(JSON.stringify(payload)).digest("hex");
+}
+function shardIdForPath(path3) {
+  const slash = path3.indexOf("/");
+  return slash === -1 ? "__root__" : path3.slice(0, slash);
+}
+function shouldUseV3Upload(tree) {
+  return Buffer.byteLength(JSON.stringify(tree), "utf8") > MAX_TREE_JSON_BYTES;
+}
+function childShardId(path3, parentShardId) {
+  if (parentShardId === "__root__") {
+    return shardIdForPath(path3);
+  }
+  if (path3 === parentShardId) {
+    return parentShardId;
+  }
+  const prefix = `${parentShardId}/`;
+  if (!path3.startsWith(prefix)) {
+    return parentShardId;
+  }
+  const remainder = path3.slice(prefix.length);
+  const slash = remainder.indexOf("/");
+  return slash === -1 ? parentShardId : `${parentShardId}/${remainder.slice(0, slash)}`;
+}
+function groupEntriesByShardId(entries2, parentShardId) {
+  const groups = new Map;
+  for (const entry of entries2) {
+    const shardId = parentShardId === "__root__" ? shardIdForPath(entry.path) : childShardId(entry.path, parentShardId);
+    const group = groups.get(shardId) ?? [];
+    group.push(entry);
+    groups.set(shardId, group);
+  }
+  return groups;
+}
+function buildPreparedShard(shardId, payload) {
+  const compressed = gzipSync3(Buffer.from(JSON.stringify(payload))).toString("base64");
+  return {
+    shardId,
+    payload,
+    dataHash: computeShardDataHash(payload),
+    entryCount: payload.entries.length,
+    data: { compression: "gzip", content: compressed }
+  };
+}
+function prepareShardGroup(entries2, shardId, tree) {
+  const payload = {
+    entries: entries2,
+    scannedAt: tree.scannedAt,
+    rootDir: tree.rootDir
+  };
+  const compressed = gzipSync3(Buffer.from(JSON.stringify(payload))).toString("base64");
+  if (Buffer.byteLength(compressed, "utf8") <= MAX_SHARD_JSON_BYTES) {
+    return [buildPreparedShard(shardId, payload)];
+  }
+  const subgroups = groupEntriesByShardId(entries2, shardId);
+  if (subgroups.size <= 1) {
+    return [buildPreparedShard(shardId, payload)];
+  }
+  const shards = [];
+  for (const [subId, subEntries] of subgroups) {
+    shards.push(...prepareShardGroup(subEntries, subId, tree));
+  }
+  return shards;
+}
+function partitionFileTree(tree) {
+  const topGroups = groupEntriesByShardId(tree.entries, "__root__");
+  const shards = [];
+  for (const [shardId, entries2] of topGroups) {
+    shards.push(...prepareShardGroup(entries2, shardId, tree));
+  }
+  return shards;
+}
+var MAX_TREE_JSON_BYTES, MAX_SHARD_JSON_BYTES, MAX_SHARD_BATCH_SIZE = 8;
+var init_file_tree_partition = __esm(() => {
+  MAX_TREE_JSON_BYTES = 900 * 1024;
+  MAX_SHARD_JSON_BYTES = 800 * 1024;
+});
+
+// src/infrastructure/services/workspace/file-tree-v3-upload.ts
+async function uploadFileTreeV3(session2, workingDir, tree, syncGeneration) {
+  const shards = partitionFileTree(tree);
+  const shardIds = [];
+  for (let i2 = 0;i2 < shards.length; i2 += MAX_SHARD_BATCH_SIZE) {
+    const batch = shards.slice(i2, i2 + MAX_SHARD_BATCH_SIZE);
+    await session2.backend.mutation(api.workspaceFiles.syncFileTreeShardV3Batch, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      workingDir,
+      syncGeneration,
+      items: batch.map((s) => ({
+        shardId: s.shardId,
+        data: s.data,
+        dataHash: s.dataHash,
+        scannedAt: tree.scannedAt,
+        entryCount: s.entryCount
+      }))
+    });
+    for (const s of batch)
+      shardIds.push(s.shardId);
+  }
+  await session2.backend.mutation(api.workspaceFiles.syncFileTreeManifestV3, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir,
+    syncGeneration,
+    shardIds,
+    totalEntryCount: tree.entries.length,
+    complete: true,
+    scannedAt: tree.scannedAt
+  });
+  return { shardIds, totalEntryCount: tree.entries.length };
+}
+var init_file_tree_v3_upload = __esm(() => {
+  init_file_tree_partition();
+  init_api3();
+});
+
 // ../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
 var require_ignore = __commonJS((exports, module) => {
   function makeArray(subject) {
@@ -88747,574 +89120,1839 @@ var require_ignore = __commonJS((exports, module) => {
 });
 
 // src/infrastructure/services/workspace/workspace-ignore.ts
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 import path3 from "node:path";
-async function loadWorkspaceIgnore(rootDir) {
-  const ig = import_ignore.default();
-  for (const name of IGNORE_FILES) {
-    try {
-      const content = await readFile7(path3.join(rootDir, name), "utf-8");
-      ig.add(content);
-    } catch {}
-  }
-  return ig;
-}
-function isPathIgnoredByRules(ig, relativePath) {
-  const normalized = relativePath.replace(/\\/g, "/");
-  return ig.ignores(normalized);
-}
-var import_ignore, IGNORE_FILES;
-var init_workspace_ignore = __esm(() => {
-  import_ignore = __toESM(require_ignore(), 1);
-  IGNORE_FILES = [".gitignore", ".cursorignore"];
-});
-
-// src/infrastructure/services/workspace/workspace-visibility-policy.ts
-import { spawn as spawn6 } from "node:child_process";
-function isAlwaysExcludedDirName(name) {
-  return ALWAYS_EXCLUDE_DIR_NAMES.has(name);
+function normalizeRelativePath(relativePath) {
+  return relativePath.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/\/+$/, "");
 }
-function isSecretPath(relativePath) {
-  const normalized = relativePath.replace(/\\/g, "/");
-  return SECRET_PATH_PATTERNS.some((pattern2) => pattern2.test(normalized));
-}
-function hasExcludedDirSegment(relativePath) {
-  const segments = relativePath.split("/");
-  return segments.some((segment) => isAlwaysExcludedDirName(segment));
-}
-function isPathVisible(relativePath) {
-  if (!relativePath)
-    return true;
-  return !isSecretPath(relativePath) && !hasExcludedDirSegment(relativePath);
+async function readIgnoreFile(filePath) {
+  try {
+    return await readFile8(filePath, "utf-8");
+  } catch {
+    return null;
+  }
 }
-function isPathContentReadable(relativePath) {
-  return isPathVisible(relativePath);
+async function loadDirectoryIgnoreRuleSets(rootDir, relativeDir) {
+  const normalizedDir = normalizeRelativePath(relativeDir);
+  const absoluteDir = normalizedDir ? path3.join(rootDir, normalizedDir) : rootDir;
+  const names = normalizedDir ? [".gitignore"] : IGNORE_FILES;
+  const result = [];
+  for (const name of names) {
+    const content = await readIgnoreFile(path3.join(absoluteDir, name));
+    if (content === null)
+      continue;
+    result.push({ baseDir: normalizedDir, matcher: import_ignore.default().add(content) });
+  }
+  return result;
 }
-async function filterIgnoredPaths(rootDir, relativePaths) {
-  if (relativePaths.length === 0)
-    return new Set;
-  const inRepo = await isGitRepo(rootDir);
-  if (inRepo)
-    return filterGitIgnored(rootDir, relativePaths);
-  const ig = await loadWorkspaceIgnore(rootDir);
-  const ignored = new Set;
-  for (const p of relativePaths) {
-    if (isPathIgnoredByRules(ig, p))
-      ignored.add(p);
+function isPathIgnoredByRuleSets(ruleSets, relativePath) {
+  const normalized = normalizeRelativePath(relativePath);
+  let ignored = false;
+  for (const ruleSet of ruleSets) {
+    if (ruleSet.baseDir && normalized !== ruleSet.baseDir && !normalized.startsWith(`${ruleSet.baseDir}/`)) {
+      continue;
+    }
+    const localPath = ruleSet.baseDir ? normalized.slice(ruleSet.baseDir.length).replace(/^\/+/, "") : normalized;
+    if (!localPath)
+      continue;
+    const result = ruleSet.matcher.test(localPath);
+    if (result.ignored)
+      ignored = true;
+    else if (result.unignored)
+      ignored = false;
   }
   return ignored;
 }
-async function filterGitIgnored(rootDir, relativePaths) {
-  if (relativePaths.length === 0)
-    return new Set;
-  const inRepo = await isGitRepo(rootDir);
-  if (!inRepo)
-    return new Set;
-  try {
-    const stdout = await new Promise((resolve5, reject) => {
-      const child = spawn6("git", ["check-ignore", "--stdin", "-z"], {
-        cwd: rootDir,
-        env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_PAGER: "cat", NO_COLOR: "1" }
-      });
-      let output = "";
-      child.stdout.on("data", (chunk2) => {
-        output += chunk2.toString();
-      });
-      child.on("error", reject);
-      child.on("close", () => resolve5(output));
-      child.stdin.write(relativePaths.join(`
-`));
-      child.stdin.end();
-    });
-    const ignored = new Set;
-    if (!stdout)
-      return ignored;
-    for (const entry of stdout.split("\x00")) {
-      const trimmed = entry.trim();
-      if (trimmed)
-        ignored.add(trimmed);
-    }
-    return ignored;
-  } catch {
-    return new Set;
+async function loadApplicableIgnoreRuleSets(rootDir, relativePath) {
+  const normalized = normalizeRelativePath(relativePath);
+  const parentParts = normalized.split("/").slice(0, -1);
+  const ruleSets = [];
+  ruleSets.push(...await loadDirectoryIgnoreRuleSets(rootDir, ""));
+  let currentDir = "";
+  for (const part of parentParts) {
+    currentDir = currentDir ? `${currentDir}/${part}` : part;
+    ruleSets.push(...await loadDirectoryIgnoreRuleSets(rootDir, currentDir));
   }
+  return ruleSets;
 }
-var ALWAYS_EXCLUDE_DIR_NAMES, SECRET_PATH_PATTERNS;
-var init_workspace_visibility_policy = __esm(() => {
-  init_workspace_ignore();
-  init_git_reader();
-  ALWAYS_EXCLUDE_DIR_NAMES = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    ".next",
-    "coverage",
-    "__pycache__",
-    ".turbo",
-    ".cache",
-    ".tmp",
-    "tmp",
-    "_generated",
-    ".vercel"
-  ]);
-  SECRET_PATH_PATTERNS = [
-    /^\.env$/,
-    /^\.env\./,
-    /\.pem$/,
-    /\.key$/,
-    /id_rsa$/,
-    /credentials\.json$/,
-    /^secrets(\/|$)/,
-    /^\.aws(\/|$)/
-  ];
+async function isWorkspacePathIgnored(rootDir, relativePath) {
+  const ruleSets = await loadApplicableIgnoreRuleSets(rootDir, relativePath);
+  return isPathIgnoredByRuleSets(ruleSets, relativePath);
+}
+var import_ignore, IGNORE_FILES;
+var init_workspace_ignore = __esm(() => {
+  import_ignore = __toESM(require_ignore(), 1);
+  IGNORE_FILES = [".gitignore", ".cursorignore"];
 });
 
-// src/commands/machine/daemon-start/file-content-fulfillment.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import { gzipSync as gzipSync2 } from "node:zlib";
-function getErrorCause(error) {
-  if (typeof error === "object" && error !== null && "cause" in error && error.cause !== undefined) {
-    return error.cause;
+// src/infrastructure/services/workspace/workspace-file-walk.ts
+import { promises as fsPromises } from "node:fs";
+import path4 from "node:path";
+async function walkWorkspaceFiles(rootDir, options) {
+  const maxFilePaths = options?.maxFilePaths ?? 1e4;
+  const filePaths = [];
+  let truncated = false;
+  async function visitDir(relDir, inheritedRuleSets) {
+    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 fsPromises.readdir(absDir, { withFileTypes: true });
+    } catch {
+      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);
+      } else if (ent.isFile()) {
+        if (isPathIgnoredByRuleSets(ruleSets, relativePath))
+          continue;
+        filePaths.push(relativePath);
+        if (filePaths.length >= maxFilePaths)
+          truncated = true;
+      }
+    }
   }
-  return error;
-}
-function isENOENT(error) {
-  const cause3 = getErrorCause(error);
-  return typeof cause3 === "object" && cause3 !== null && "code" in cause3 && cause3.code === "ENOENT";
+  await visitDir("", []);
+  return { filePaths, truncated };
 }
-function isBinaryFile(path4) {
-  const lastDot = path4.lastIndexOf(".");
-  if (lastDot === -1)
-    return false;
-  return BINARY_EXTENSIONS.has(path4.slice(lastDot).toLowerCase());
+var init_workspace_file_walk = __esm(() => {
+  init_workspace_ignore();
+  init_workspace_visibility_policy();
+});
+
+// src/infrastructure/services/workspace/file-tree-scanner.ts
+async function scanFileTree(rootDir, options) {
+  const maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const scannedAt = Date.now();
+  const walk = await walkWorkspaceFiles(rootDir, { maxFilePaths: maxEntries });
+  const filteredPaths = walk.filePaths.filter((p) => !isExcluded(p));
+  const entries2 = buildEntries(filteredPaths, maxEntries);
+  return {
+    entries: entries2,
+    scannedAt,
+    rootDir
+  };
 }
-function gzipPlainText(text) {
-  return gzipSync2(Buffer.from(text)).toString("base64");
+function isExcluded(filePath) {
+  return hasExcludedDirSegment(filePath);
 }
-function fulfillGzippedContentEffect(session2, workingDir, filePath, plainText, truncated) {
-  return exports_Effect.catchAll(exports_Effect.tryPromise(() => session2.backend.mutation(api.workspaceFiles.fulfillFileContentV2, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    workingDir,
-    filePath,
-    data: { compression: "gzip", content: gzipPlainText(plainText) },
-    encoding: "utf8",
-    truncated
-  })), () => exports_Effect.void);
+function buildEntries(filePaths, maxEntries) {
+  const directories = new Set;
+  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 file of sortedFiles) {
+    if (entries2.length >= maxEntries)
+      break;
+    entries2.push({ path: file, type: "file" });
+  }
+  return entries2;
 }
-var MAX_CONTENT_BYTES, BINARY_EXTENSIONS, fulfillFileContentRequestsEffect;
-var init_file_content_fulfillment = __esm(() => {
-  init_esm();
-  init_daemon_services();
-  init_api3();
-  init_assert_registered_working_dir();
-  init_workspace_path_security();
+var DEFAULT_MAX_ENTRIES = 1e4;
+var init_file_tree_scanner = __esm(() => {
+  init_workspace_file_walk();
   init_workspace_visibility_policy();
-  MAX_CONTENT_BYTES = 500 * 1024;
-  BINARY_EXTENSIONS = new Set([
-    ".png",
-    ".jpg",
-    ".jpeg",
-    ".gif",
-    ".webp",
-    ".ico",
-    ".svg",
-    ".mp3",
-    ".mp4",
-    ".wav",
-    ".ogg",
-    ".webm",
-    ".zip",
-    ".tar",
-    ".gz",
-    ".bz2",
-    ".7z",
-    ".rar",
-    ".pdf",
-    ".doc",
-    ".docx",
-    ".xls",
-    ".xlsx",
-    ".ppt",
-    ".pptx",
-    ".woff",
-    ".woff2",
-    ".ttf",
-    ".otf",
-    ".eot",
-    ".exe",
-    ".dll",
-    ".so",
-    ".dylib",
-    ".bin",
-    ".dat",
-    ".db",
-    ".sqlite"
+});
+
+// ../../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";
+import { Readable as Readable3 } from "node:stream";
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+var EntryTypes, defaultOptions, RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR", NORMAL_FLOW_ERRORS, ALL_TYPES, DIR_TYPES, FILE_TYPES, isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code), wantBigintFsStats, emptyFn = (_entryInfo) => true, normalizeFilter = (filter11) => {
+  if (filter11 === undefined)
+    return emptyFn;
+  if (typeof filter11 === "function")
+    return filter11;
+  if (typeof filter11 === "string") {
+    const fl = filter11.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter11)) {
+    const trItems = filter11.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+}, ReaddirpStream;
+var init_readdirp = __esm(() => {
+  EntryTypes = {
+    FILE_TYPE: "files",
+    DIR_TYPE: "directories",
+    FILE_DIR_TYPE: "files_directories",
+    EVERYTHING_TYPE: "all"
+  };
+  defaultOptions = {
+    root: ".",
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096
+  };
+  Object.freeze(defaultOptions);
+  NORMAL_FLOW_ERRORS = new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+  ALL_TYPES = [
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE
+  ];
+  DIR_TYPES = new Set([
+    EntryTypes.DIR_TYPE,
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE
   ]);
-  fulfillFileContentRequestsEffect = exports_Effect.gen(function* () {
-    const session2 = yield* DaemonSessionService;
-    const requests = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => session2.backend.query(api.workspaceFiles.getPendingFileContentRequests, {
-      sessionId: session2.sessionId,
-      machineId: session2.machineId
-    })), () => exports_Effect.succeed([]));
-    if (requests.length === 0)
+  FILE_TYPES = new Set([
+    EntryTypes.EVERYTHING_TYPE,
+    EntryTypes.FILE_DIR_TYPE,
+    EntryTypes.FILE_TYPE
+  ]);
+  wantBigintFsStats = process.platform === "win32";
+  ReaddirpStream = class ReaddirpStream extends Readable3 {
+    parents;
+    reading;
+    parent;
+    _stat;
+    _maxDepth;
+    _wantsDir;
+    _wantsFile;
+    _wantsEverything;
+    _root;
+    _isDirent;
+    _statsProp;
+    _rdOptions;
+    _fileFilter;
+    _directoryFilter;
+    constructor(options = {}) {
+      super({
+        objectMode: true,
+        autoDestroy: true,
+        highWaterMark: options.highWaterMark
+      });
+      const opts = { ...defaultOptions, ...options };
+      const { root, type } = opts;
+      this._fileFilter = normalizeFilter(opts.fileFilter);
+      this._directoryFilter = normalizeFilter(opts.directoryFilter);
+      const statMethod = opts.lstat ? lstat : stat2;
+      if (wantBigintFsStats) {
+        this._stat = (path5) => statMethod(path5, { bigint: true });
+      } else {
+        this._stat = statMethod;
+      }
+      this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+      this._wantsDir = type ? DIR_TYPES.has(type) : false;
+      this._wantsFile = type ? FILE_TYPES.has(type) : false;
+      this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+      this._root = presolve(root);
+      this._isDirent = !opts.alwaysStat;
+      this._statsProp = this._isDirent ? "dirent" : "stats";
+      this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+      this.parents = [this._exploreDir(root, 1)];
+      this.reading = false;
+      this.parent = undefined;
+    }
+    async _read(batch) {
+      if (this.reading)
+        return;
+      this.reading = true;
+      try {
+        while (!this.destroyed && batch > 0) {
+          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 awaited = await Promise.all(slice);
+            for (const entry of awaited) {
+              if (!entry)
+                continue;
+              if (this.destroyed)
+                return;
+              const entryType = await this._getEntryType(entry);
+              if (entryType === "directory" && this._directoryFilter(entry)) {
+                if (depth <= this._maxDepth) {
+                  this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                }
+                if (this._wantsDir) {
+                  this.push(entry);
+                  batch--;
+                }
+              } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+                if (this._wantsFile) {
+                  this.push(entry);
+                  batch--;
+                }
+              }
+            }
+          } else {
+            const parent = this.parents.pop();
+            if (!parent) {
+              this.push(null);
+              break;
+            }
+            this.parent = await parent;
+            if (this.destroyed)
+              return;
+          }
+        }
+      } catch (error) {
+        this.destroy(error);
+      } finally {
+        this.reading = false;
+      }
+    }
+    async _exploreDir(path5, depth) {
+      let files;
+      try {
+        files = await readdir(path5, this._rdOptions);
+      } catch (error) {
+        this._onError(error);
+      }
+      return { files, depth, path: path5 };
+    }
+    async _formatEntry(dirent, path5) {
+      let entry;
+      const basename2 = this._isDirent ? dirent.name : dirent;
+      try {
+        const fullPath = presolve(pjoin(path5, basename2));
+        entry = { path: prelative(this._root, fullPath), fullPath, basename: basename2 };
+        entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+      } catch (err) {
+        this._onError(err);
+        return;
+      }
+      return entry;
+    }
+    _onError(err) {
+      if (isNormalFlowError(err) && !this.destroyed) {
+        this.emit("warn", err);
+      } else {
+        this.destroy(err);
+      }
+    }
+    async _getEntryType(entry) {
+      if (!entry && this._statsProp in entry) {
+        return "";
+      }
+      const stats = entry[this._statsProp];
+      if (stats.isFile())
+        return "file";
+      if (stats.isDirectory())
+        return "directory";
+      if (stats && stats.isSymbolicLink()) {
+        const full = entry.fullPath;
+        try {
+          const entryRealPath = await realpath3(full);
+          const entryRealPathStats = await lstat(entryRealPath);
+          if (entryRealPathStats.isFile()) {
+            return "file";
+          }
+          if (entryRealPathStats.isDirectory()) {
+            const len2 = entryRealPath.length;
+            if (full.startsWith(entryRealPath) && full.substr(len2, 1) === psep) {
+              const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+              recursiveError.code = RECURSIVE_ERROR_CODE;
+              return this._onError(recursiveError);
+            }
+            return "directory";
+          }
+        } catch (error) {
+          this._onError(error);
+          return "";
+        }
+      }
+    }
+    _includeAsFile(entry) {
+      const stats = entry && entry[this._statsProp];
+      return stats && this._wantsEverything && !stats.isDirectory();
+    }
+  };
+});
+
+// ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
+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) {
+  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));
+    }
+  };
+  try {
+    return fs_watch(path5, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return;
+  }
+}
+
+class NodeFsHandler {
+  fsw;
+  _boundHandleError;
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  _watchWithNodeFs(path5, listener) {
+    const opts = this.fsw.options;
+    const directory = sp.dirname(path5);
+    const basename3 = sp.basename(path5);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename3);
+    const absolutePath = sp.resolve(path5);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path5, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path5, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
       return;
-    console.log(`[${formatTimestamp()}] \uD83D\uDCE5 Received ${requests.length} pending file content request(s): ${requests.map((r) => r.filePath).join(", ")}`);
-    for (const request2 of requests) {
-      const startTime = Date.now();
-      const { workingDir, filePath } = request2;
-      const registered = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => assertRegisteredWorkingDir(session2, workingDir)), () => exports_Effect.succeed({ ok: false, error: "Workspace check failed" }));
-      if (!registered.ok) {
-        console.warn(`[${formatTimestamp()}] ⚠️  Rejected unregistered workspace: ${workingDir} (${registered.error})`);
-        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Error: workspace not registered]", false);
-        continue;
+    }
+    const dirname10 = sp.dirname(file);
+    const basename3 = sp.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname10);
+    let prevStats = stats;
+    if (parent.has(basename3))
+      return;
+    const listener = async (path5, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat3(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path5);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path5, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname10, basename3);
+        }
+      } else if (parent.has(basename3)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
       }
-      const resolved = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => resolvePathWithinWorkspace(workingDir, filePath)), () => exports_Effect.succeed({ ok: false, error: "Invalid file path" }));
-      if (!resolved.ok) {
-        console.warn(`[${formatTimestamp()}] ⚠️  Rejected file path: ${filePath} (${resolved.error})`);
-        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Error reading file]", false);
-        continue;
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  async _handleSymlink(entry, directory, path5, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path5);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
       }
-      const absolutePath = resolved.absolutePath;
-      if (isBinaryFile(filePath)) {
-        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[Binary file]", false);
-        const elapsed4 = Date.now() - startTime;
-        console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File content synced to Convex: ${filePath} [binary] (${elapsed4}ms)`);
-        continue;
+      if (this.fsw.closed)
+        return;
+      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);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path5, entry.stats);
       }
-      if (!isPathContentReadable(filePath)) {
-        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[File blocked: cannot open sensitive path in remote explorer]", false);
-        const elapsed4 = Date.now() - startTime;
-        console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File content blocked: ${filePath} [secret] (${elapsed4}ms)`);
-        continue;
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sp.join(directory, "");
+    const throttleKey = target ? `${directory}:${target}` : directory;
+    throttler = this.fsw._throttle("readdir", throttleKey, 1000);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = new Set;
+    let stream4 = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream4)
+      return;
+    stream4.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream4 = undefined;
+        return;
       }
-      const readOutcome = yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => readFile8(absolutePath)).pipe(exports_Effect.map((buffer) => {
-        if (buffer.length > MAX_CONTENT_BYTES) {
-          return {
-            kind: "ok",
-            content: buffer.subarray(0, MAX_CONTENT_BYTES).toString("utf8"),
-            truncated: true
-          };
+      const item = entry.path;
+      let path5 = sp.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path5, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream4 = undefined;
+        return;
+      }
+      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);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve6, reject) => {
+      if (!stream4)
+        return reject();
+      stream4.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream4 = undefined;
+          return;
         }
-        return {
-          kind: "ok",
-          content: buffer.toString("utf8"),
-          truncated: false
-        };
-      })), (error) => isENOENT(error) ? exports_Effect.succeed({ kind: "missing" }) : exports_Effect.succeed({
-        kind: "error",
-        content: "[Error reading file]",
-        truncated: false
-      }));
-      if (readOutcome.kind === "missing") {
-        console.log(`[${formatTimestamp()}] ⏳ File not on disk yet, deferring content sync: ${filePath}`);
-        continue;
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve6(undefined);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream4 = undefined;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath4) {
+    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir.has(sp.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sp.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath4)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  async _addToNodeFs(path5, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path5) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path5);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sp.resolve(path5);
+        const targetPath = follow ? await fsrealpath(path5) : path5;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path5) : path5;
+        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);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== undefined) {
+          this.fsw._symlinkPaths.set(sp.resolve(path5), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path5, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path5;
+      }
+    }
+  }
+}
+var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH = "watch", statMethods, KEY_LISTENERS = "listeners", KEY_ERR = "errHandlers", KEY_RAW = "rawEmitters", HANDLER_KEYS, binaryExtensions, isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase()), foreach = (val, fn2) => {
+  if (val instanceof Set) {
+    val.forEach(fn2);
+  } else {
+    fn2(val);
+  }
+}, addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = new Set([container]);
+  }
+  container.add(item);
+}, clearItem = (cont) => (key) => {
+  const set7 = cont[key];
+  if (set7 instanceof Set) {
+    set7.clear();
+  } else {
+    delete cont[key];
+  }
+}, delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+}, isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val, FsWatchInstances, fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+}, setFsWatchListener = (path5, 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);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    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));
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path5, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {}
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+}, FsWatchFileInstances, setFsWatchFileListener = (path5, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = undefined;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path5, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = undefined;
+      Object.freeze(cont);
+    }
+  };
+};
+var init_handler = __esm(() => {
+  pl = process.platform;
+  isWindows = pl === "win32";
+  isMacos = pl === "darwin";
+  isLinux = pl === "linux";
+  isFreeBSD = pl === "freebsd";
+  isIBMi = osType() === "OS400";
+  EVENTS = {
+    ALL: "all",
+    READY: "ready",
+    ADD: "add",
+    CHANGE: "change",
+    ADD_DIR: "addDir",
+    UNLINK: "unlink",
+    UNLINK_DIR: "unlinkDir",
+    RAW: "raw",
+    ERROR: "error"
+  };
+  EV = EVENTS;
+  statMethods = { lstat: lstat2, stat: stat3 };
+  HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+  binaryExtensions = new Set([
+    "3dm",
+    "3ds",
+    "3g2",
+    "3gp",
+    "7z",
+    "a",
+    "aac",
+    "adp",
+    "afdesign",
+    "afphoto",
+    "afpub",
+    "ai",
+    "aif",
+    "aiff",
+    "alz",
+    "ape",
+    "apk",
+    "appimage",
+    "ar",
+    "arj",
+    "asf",
+    "au",
+    "avi",
+    "bak",
+    "baml",
+    "bh",
+    "bin",
+    "bk",
+    "bmp",
+    "btif",
+    "bz2",
+    "bzip2",
+    "cab",
+    "caf",
+    "cgm",
+    "class",
+    "cmx",
+    "cpio",
+    "cr2",
+    "cur",
+    "dat",
+    "dcm",
+    "deb",
+    "dex",
+    "djvu",
+    "dll",
+    "dmg",
+    "dng",
+    "doc",
+    "docm",
+    "docx",
+    "dot",
+    "dotm",
+    "dra",
+    "DS_Store",
+    "dsk",
+    "dts",
+    "dtshd",
+    "dvb",
+    "dwg",
+    "dxf",
+    "ecelp4800",
+    "ecelp7470",
+    "ecelp9600",
+    "egg",
+    "eol",
+    "eot",
+    "epub",
+    "exe",
+    "f4v",
+    "fbs",
+    "fh",
+    "fla",
+    "flac",
+    "flatpak",
+    "fli",
+    "flv",
+    "fpx",
+    "fst",
+    "fvt",
+    "g3",
+    "gh",
+    "gif",
+    "graffle",
+    "gz",
+    "gzip",
+    "h261",
+    "h263",
+    "h264",
+    "icns",
+    "ico",
+    "ief",
+    "img",
+    "ipa",
+    "iso",
+    "jar",
+    "jpeg",
+    "jpg",
+    "jpgv",
+    "jpm",
+    "jxr",
+    "key",
+    "ktx",
+    "lha",
+    "lib",
+    "lvp",
+    "lz",
+    "lzh",
+    "lzma",
+    "lzo",
+    "m3u",
+    "m4a",
+    "m4v",
+    "mar",
+    "mdi",
+    "mht",
+    "mid",
+    "midi",
+    "mj2",
+    "mka",
+    "mkv",
+    "mmr",
+    "mng",
+    "mobi",
+    "mov",
+    "movie",
+    "mp3",
+    "mp4",
+    "mp4a",
+    "mpeg",
+    "mpg",
+    "mpga",
+    "mxu",
+    "nef",
+    "npx",
+    "numbers",
+    "nupkg",
+    "o",
+    "odp",
+    "ods",
+    "odt",
+    "oga",
+    "ogg",
+    "ogv",
+    "otf",
+    "ott",
+    "pages",
+    "pbm",
+    "pcx",
+    "pdb",
+    "pdf",
+    "pea",
+    "pgm",
+    "pic",
+    "png",
+    "pnm",
+    "pot",
+    "potm",
+    "potx",
+    "ppa",
+    "ppam",
+    "ppm",
+    "pps",
+    "ppsm",
+    "ppsx",
+    "ppt",
+    "pptm",
+    "pptx",
+    "psd",
+    "pya",
+    "pyc",
+    "pyo",
+    "pyv",
+    "qt",
+    "rar",
+    "ras",
+    "raw",
+    "resources",
+    "rgb",
+    "rip",
+    "rlc",
+    "rmf",
+    "rmvb",
+    "rpm",
+    "rtf",
+    "rz",
+    "s3m",
+    "s7z",
+    "scpt",
+    "sgi",
+    "shar",
+    "snap",
+    "sil",
+    "sketch",
+    "slk",
+    "smv",
+    "snk",
+    "so",
+    "stl",
+    "suo",
+    "sub",
+    "swf",
+    "tar",
+    "tbz",
+    "tbz2",
+    "tga",
+    "tgz",
+    "thmx",
+    "tif",
+    "tiff",
+    "tlz",
+    "ttc",
+    "ttf",
+    "txz",
+    "udf",
+    "uvh",
+    "uvi",
+    "uvm",
+    "uvp",
+    "uvs",
+    "uvu",
+    "viv",
+    "vob",
+    "war",
+    "wav",
+    "wax",
+    "wbmp",
+    "wdp",
+    "weba",
+    "webm",
+    "webp",
+    "whl",
+    "wim",
+    "wm",
+    "wma",
+    "wmv",
+    "wmx",
+    "woff",
+    "woff2",
+    "wrm",
+    "wvx",
+    "xbm",
+    "xif",
+    "xla",
+    "xlam",
+    "xls",
+    "xlsb",
+    "xlsm",
+    "xlsx",
+    "xlt",
+    "xltm",
+    "xltx",
+    "xm",
+    "xmind",
+    "xpi",
+    "xpm",
+    "xwd",
+    "xz",
+    "z",
+    "zip",
+    "zipx"
+  ]);
+  FsWatchInstances = new Map;
+  FsWatchFileInstances = new Map;
+});
+
+// ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
+import { EventEmitter as EventEmitter2 } from "node:events";
+import { stat as statcb, Stats } from "node:fs";
+import { readdir as readdir2, stat as stat4 } from "node:fs/promises";
+import * as sp2 from "node:path";
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string2) => matcher === string2;
+  if (matcher instanceof RegExp)
+    return (string2) => matcher.test(string2);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string2) => {
+      if (matcher.path === string2)
+        return true;
+      if (matcher.recursive) {
+        const relative4 = sp2.relative(matcher.path, string2);
+        if (!relative4) {
+          return false;
+        }
+        return !relative4.startsWith("..") && !sp2.isAbsolute(relative4);
       }
-      const { content, truncated } = readOutcome.kind === "ok" ? readOutcome : { content: readOutcome.content, truncated: readOutcome.truncated };
-      const compressed = gzipSync2(Buffer.from(content));
-      const contentCompressed = compressed.toString("base64");
-      yield* exports_Effect.catchAll(exports_Effect.tryPromise(() => session2.backend.mutation(api.workspaceFiles.fulfillFileContentV2, {
-        sessionId: session2.sessionId,
-        machineId: session2.machineId,
-        workingDir,
-        filePath,
-        data: { compression: "gzip", content: contentCompressed },
-        encoding: "utf8",
-        truncated
-      })), () => exports_Effect.void);
-      const elapsed3 = Date.now() - startTime;
-      console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File content synced to Convex: ${filePath} (${(Buffer.byteLength(content) / 1024).toFixed(1)}KB → ${(compressed.length / 1024).toFixed(1)}KB gzip, ${elapsed3}ms)`);
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path5) {
+  if (typeof path5 !== "string")
+    throw new Error("string expected");
+  path5 = sp2.normalize(path5);
+  path5 = path5.replace(/\\/g, "/");
+  let prepend4 = false;
+  if (path5.startsWith("//"))
+    prepend4 = true;
+  path5 = path5.replace(DOUBLE_SLASH_RE, "/");
+  if (prepend4)
+    path5 = "/" + path5;
+  return path5;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path5 = normalizePath(testString);
+  for (let index = 0;index < patterns.length; index++) {
+    const pattern2 = patterns[index];
+    if (pattern2(path5, stats)) {
+      return true;
     }
-  });
-});
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
 
-// src/commands/machine/daemon-start/file-content-subscription.ts
-var startFileContentSubscriptionEffect = (wsClient2) => exports_Effect.gen(function* () {
-  const session2 = yield* DaemonSessionService;
-  let processing = false;
-  const unsubscribe = wsClient2.onUpdate(api.workspaceFiles.getPendingFileContentRequests, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId
-  }, (requests) => {
-    if (!requests || requests.length === 0)
+class DirEntry {
+  path;
+  _removeWatcher;
+  items;
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = new Set;
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
       return;
-    if (processing)
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
       return;
-    processing = true;
-    exports_Effect.runPromise(fulfillFileContentRequestsEffect.pipe(exports_Effect.provideService(DaemonSessionService, session2))).catch((err) => {
-      console.warn(`[${formatTimestamp()}] ⚠️  File content subscription processing failed: ${getErrorMessage2(err)}`);
-    }).finally(() => {
-      processing = false;
-    });
-  }, (err) => {
-    console.warn(`[${formatTimestamp()}] ⚠️  File content subscription error: ${getErrorMessage2(err)}`);
-  });
-  console.log(`[${formatTimestamp()}] \uD83D\uDCC2 File content subscription started (reactive)`);
-  return {
-    stop: () => {
-      unsubscribe();
-      console.log(`[${formatTimestamp()}] \uD83D\uDCC2 File content subscription stopped`);
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
+      }
     }
-  };
-});
-var init_file_content_subscription = __esm(() => {
-  init_esm();
-  init_daemon_services();
-  init_file_content_fulfillment();
-  init_api3();
-  init_convex_error();
-});
-
-// src/infrastructure/services/workspace/file-tree-data-hash.ts
-import { createHash as createHash4 } from "node:crypto";
-function computeFileTreeDataHash(tree) {
-  return createHash4("md5").update(JSON.stringify(tree)).digest("hex");
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
 }
-var init_file_tree_data_hash = () => {};
 
-// src/infrastructure/services/workspace/file-tree-partition.ts
-import { createHash as createHash5 } from "node:crypto";
-import { gzipSync as gzipSync3 } from "node:zlib";
-function computeShardDataHash(payload) {
-  return createHash5("md5").update(JSON.stringify(payload)).digest("hex");
-}
-function shardIdForPath(path4) {
-  const slash = path4.indexOf("/");
-  return slash === -1 ? "__root__" : path4.slice(0, slash);
-}
-function shouldUseV3Upload(tree) {
-  return Buffer.byteLength(JSON.stringify(tree), "utf8") > MAX_TREE_JSON_BYTES;
-}
-function childShardId(path4, parentShardId) {
-  if (parentShardId === "__root__") {
-    return shardIdForPath(path4);
+class WatchHelper {
+  fsw;
+  path;
+  watchPath;
+  fullWatchPath;
+  dirParts;
+  followSymlinks;
+  statMethod;
+  constructor(path5, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path5;
+    this.path = path5 = path5.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sp2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts2) => {
+      if (parts2.length > 1)
+        parts2.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
   }
-  if (path4 === parentShardId) {
-    return parentShardId;
+  entryPath(entry) {
+    return sp2.join(this.watchPath, sp2.relative(this.watchPath, entry.fullPath));
   }
-  const prefix = `${parentShardId}/`;
-  if (!path4.startsWith(prefix)) {
-    return parentShardId;
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
   }
-  const remainder = path4.slice(prefix.length);
-  const slash = remainder.indexOf("/");
-  return slash === -1 ? parentShardId : `${parentShardId}/${remainder.slice(0, slash)}`;
-}
-function groupEntriesByShardId(entries2, parentShardId) {
-  const groups = new Map;
-  for (const entry of entries2) {
-    const shardId = parentShardId === "__root__" ? shardIdForPath(entry.path) : childShardId(entry.path, parentShardId);
-    const group = groups.get(shardId) ?? [];
-    group.push(entry);
-    groups.set(shardId, group);
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
   }
-  return groups;
 }
-function buildPreparedShard(shardId, payload) {
-  const compressed = gzipSync3(Buffer.from(JSON.stringify(payload))).toString("base64");
-  return {
-    shardId,
-    payload,
-    dataHash: computeShardDataHash(payload),
-    entryCount: payload.entries.length,
-    data: { compression: "gzip", content: compressed }
-  };
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
 }
-function prepareShardGroup(entries2, shardId, tree) {
-  const payload = {
-    entries: entries2,
-    scannedAt: tree.scannedAt,
-    rootDir: tree.rootDir
-  };
-  const compressed = gzipSync3(Buffer.from(JSON.stringify(payload))).toString("base64");
-  if (Buffer.byteLength(compressed, "utf8") <= MAX_SHARD_JSON_BYTES) {
-    return [buildPreparedShard(shardId, payload)];
-  }
-  const subgroups = groupEntriesByShardId(entries2, shardId);
-  if (subgroups.size <= 1) {
-    return [buildPreparedShard(shardId, payload)];
+var SLASH = "/", SLASH_SLASH = "//", ONE_DOT = ".", TWO_DOTS = "..", STRING_TYPE = "string", BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp), unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
   }
-  const shards = [];
-  for (const [subId, subEntries] of subgroups) {
-    shards.push(...prepareShardGroup(subEntries, subId, tree));
+  return paths.map(normalizePathToUnix);
+}, toUnix = (string2) => {
+  let str = string2.replace(BACK_SLASH_RE, SLASH);
+  let prepend4 = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend4 = true;
   }
-  return shards;
-}
-function partitionFileTree(tree) {
-  const topGroups = groupEntriesByShardId(tree.entries, "__root__");
-  const shards = [];
-  for (const [shardId, entries2] of topGroups) {
-    shards.push(...prepareShardGroup(entries2, shardId, tree));
+  str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  if (prepend4) {
+    str = SLASH + str;
   }
-  return shards;
-}
-var MAX_TREE_JSON_BYTES, MAX_SHARD_JSON_BYTES, MAX_SHARD_BATCH_SIZE = 8;
-var init_file_tree_partition = __esm(() => {
-  MAX_TREE_JSON_BYTES = 900 * 1024;
-  MAX_SHARD_JSON_BYTES = 800 * 1024;
-});
-
-// src/infrastructure/services/workspace/workspace-file-walk.ts
-import { promises as fsPromises } from "node:fs";
-import path4 from "node:path";
-async function walkWorkspaceFiles(rootDir, options) {
-  const maxFilePaths = options?.maxFilePaths ?? 1e4;
-  const filePaths = [];
-  let truncated = false;
-  const inRepo = await isGitRepo(rootDir);
-  const parsedIgnore = inRepo ? null : await loadWorkspaceIgnore(rootDir);
-  async function isIgnored(relativePath) {
-    if (inRepo) {
-      const ignored = await filterIgnoredPaths(rootDir, [relativePath]);
-      return ignored.has(relativePath);
+  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));
+  } else {
+    return path5;
+  }
+}, getAbsolutePath = (path5, cwd) => {
+  if (sp2.isAbsolute(path5)) {
+    return path5;
+  }
+  return sp2.join(cwd, path5);
+}, EMPTY_SET, STAT_METHOD_F = "stat", STAT_METHOD_L = "lstat", FSWatcher;
+var init_chokidar = __esm(() => {
+  init_readdirp();
+  init_handler();
+  /*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+  BACK_SLASH_RE = /\\/g;
+  DOUBLE_SLASH_RE = /\/\//g;
+  DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+  REPLACER_RE = /^\.[/\\]/;
+  EMPTY_SET = Object.freeze(new Set);
+  FSWatcher = class FSWatcher extends EventEmitter2 {
+    closed;
+    options;
+    _closers;
+    _ignoredPaths;
+    _throttled;
+    _streams;
+    _symlinkPaths;
+    _watched;
+    _pendingWrites;
+    _pendingUnlinks;
+    _readyCount;
+    _emitReady;
+    _closePromise;
+    _userIgnored;
+    _readyEmitted;
+    _emitRaw;
+    _boundRemove;
+    _nodeFsHandler;
+    constructor(_opts = {}) {
+      super();
+      this.closed = false;
+      this._closers = new Map;
+      this._ignoredPaths = new Set;
+      this._throttled = new Map;
+      this._streams = new Set;
+      this._symlinkPaths = new Map;
+      this._watched = new Map;
+      this._pendingWrites = new Map;
+      this._pendingUnlinks = new Map;
+      this._readyCount = 0;
+      this._readyEmitted = false;
+      const awf = _opts.awaitWriteFinish;
+      const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };
+      const opts = {
+        persistent: true,
+        ignoreInitial: false,
+        ignorePermissionErrors: false,
+        interval: 100,
+        binaryInterval: 300,
+        followSymlinks: true,
+        usePolling: false,
+        atomic: true,
+        ..._opts,
+        ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+        awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+      };
+      if (isIBMi)
+        opts.usePolling = true;
+      if (opts.atomic === undefined)
+        opts.atomic = !opts.usePolling;
+      const envPoll = process.env.CHOKIDAR_USEPOLLING;
+      if (envPoll !== undefined) {
+        const envLower = envPoll.toLowerCase();
+        if (envLower === "false" || envLower === "0")
+          opts.usePolling = false;
+        else if (envLower === "true" || envLower === "1")
+          opts.usePolling = true;
+        else
+          opts.usePolling = !!envLower;
+      }
+      const envInterval = process.env.CHOKIDAR_INTERVAL;
+      if (envInterval)
+        opts.interval = Number.parseInt(envInterval, 10);
+      let readyCalls = 0;
+      this._emitReady = () => {
+        readyCalls++;
+        if (readyCalls >= this._readyCount) {
+          this._emitReady = EMPTY_FN;
+          this._readyEmitted = true;
+          process.nextTick(() => this.emit(EVENTS.READY));
+        }
+      };
+      this._emitRaw = (...args2) => this.emit(EVENTS.RAW, ...args2);
+      this._boundRemove = this._remove.bind(this);
+      this.options = opts;
+      this._nodeFsHandler = new NodeFsHandler(this);
+      Object.freeze(opts);
+    }
+    _addIgnoredPath(matcher) {
+      if (isMatcherObject(matcher)) {
+        for (const ignored of this._ignoredPaths) {
+          if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+            return;
+          }
+        }
+      }
+      this._ignoredPaths.add(matcher);
     }
-    return parsedIgnore !== null && isPathIgnoredByRules(parsedIgnore, relativePath);
-  }
-  async function visitDir(relDir) {
-    if (truncated || filePaths.length >= maxFilePaths) {
-      truncated = true;
-      return;
+    _removeIgnoredPath(matcher) {
+      this._ignoredPaths.delete(matcher);
+      if (typeof matcher === "string") {
+        for (const ignored of this._ignoredPaths) {
+          if (isMatcherObject(ignored) && ignored.path === matcher) {
+            this._ignoredPaths.delete(ignored);
+          }
+        }
+      }
     }
-    const absDir = relDir ? path4.join(rootDir, relDir) : rootDir;
-    let dirents;
-    try {
-      dirents = await fsPromises.readdir(absDir, { withFileTypes: true });
-    } catch {
-      return;
+    add(paths_, _origAdd, _internal) {
+      const { cwd } = this.options;
+      this.closed = false;
+      this._closePromise = undefined;
+      let paths = unifyPaths(paths_);
+      if (cwd) {
+        paths = paths.map((path5) => {
+          const absPath = getAbsolutePath(path5, cwd);
+          return absPath;
+        });
+      }
+      paths.forEach((path5) => {
+        this._removeIgnoredPath(path5);
+      });
+      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);
+        if (res)
+          this._emitReady();
+        return res;
+      })).then((results) => {
+        if (this.closed)
+          return;
+        results.forEach((item) => {
+          if (item)
+            this.add(sp2.dirname(item), sp2.basename(_origAdd || item));
+        });
+      });
+      return this;
     }
-    for (const ent of dirents) {
-      if (truncated || filePaths.length >= maxFilePaths) {
-        truncated = true;
+    unwatch(paths_) {
+      if (this.closed)
+        return this;
+      const paths = unifyPaths(paths_);
+      const { cwd } = this.options;
+      paths.forEach((path5) => {
+        if (!sp2.isAbsolute(path5) && !this._closers.has(path5)) {
+          if (cwd)
+            path5 = sp2.join(cwd, path5);
+          path5 = sp2.resolve(path5);
+        }
+        this._closePath(path5);
+        this._addIgnoredPath(path5);
+        if (this._watched.has(path5)) {
+          this._addIgnoredPath({
+            path: path5,
+            recursive: true
+          });
+        }
+        this._userIgnored = undefined;
+      });
+      return this;
+    }
+    close() {
+      if (this._closePromise) {
+        return this._closePromise;
+      }
+      this.closed = true;
+      this.removeAllListeners();
+      const closers = [];
+      this._closers.forEach((closerList) => closerList.forEach((closer) => {
+        const promise3 = closer();
+        if (promise3 instanceof Promise)
+          closers.push(promise3);
+      }));
+      this._streams.forEach((stream4) => stream4.destroy());
+      this._userIgnored = undefined;
+      this._readyCount = 0;
+      this._readyEmitted = false;
+      this._watched.forEach((dirent) => dirent.dispose());
+      this._closers.clear();
+      this._watched.clear();
+      this._streams.clear();
+      this._symlinkPaths.clear();
+      this._throttled.clear();
+      this._closePromise = closers.length ? Promise.all(closers).then(() => {
+        return;
+      }) : Promise.resolve();
+      return this._closePromise;
+    }
+    getWatched() {
+      const watchList = {};
+      this._watched.forEach((entry, dir) => {
+        const key = this.options.cwd ? sp2.relative(this.options.cwd, dir) : dir;
+        const index = key || ONE_DOT;
+        watchList[index] = entry.getChildren().sort();
+      });
+      return watchList;
+    }
+    emitWithAll(event, args2) {
+      this.emit(event, ...args2);
+      if (event !== EVENTS.ERROR)
+        this.emit(EVENTS.ALL, event, ...args2);
+    }
+    async _emit(event, path5, stats) {
+      if (this.closed)
         return;
+      const opts = this.options;
+      if (isWindows)
+        path5 = sp2.normalize(path5);
+      if (opts.cwd)
+        path5 = sp2.relative(opts.cwd, path5);
+      const args2 = [path5];
+      if (stats != null)
+        args2.push(stats);
+      const awf = opts.awaitWriteFinish;
+      let pw;
+      if (awf && (pw = this._pendingWrites.get(path5))) {
+        pw.lastChange = new Date;
+        return this;
       }
-      if (isAlwaysExcludedDirName(ent.name))
-        continue;
-      const relativePath = relDir ? `${relDir}/${ent.name}` : ent.name;
-      if (!isPathVisible(relativePath))
-        continue;
-      if (ent.isDirectory()) {
-        if (await isIgnored(relativePath))
-          continue;
-        await visitDir(relativePath);
-      } else if (ent.isFile()) {
-        if (await isIgnored(relativePath))
-          continue;
-        filePaths.push(relativePath);
-        if (filePaths.length >= maxFilePaths)
-          truncated = true;
+      if (opts.atomic) {
+        if (event === EVENTS.UNLINK) {
+          this._pendingUnlinks.set(path5, [event, ...args2]);
+          setTimeout(() => {
+            this._pendingUnlinks.forEach((entry, path6) => {
+              this.emit(...entry);
+              this.emit(EVENTS.ALL, ...entry);
+              this._pendingUnlinks.delete(path6);
+            });
+          }, typeof opts.atomic === "number" ? opts.atomic : 100);
+          return this;
+        }
+        if (event === EVENTS.ADD && this._pendingUnlinks.has(path5)) {
+          event = EVENTS.CHANGE;
+          this._pendingUnlinks.delete(path5);
+        }
+      }
+      if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+        const awfEmit = (err, stats2) => {
+          if (err) {
+            event = EVENTS.ERROR;
+            args2[0] = err;
+            this.emitWithAll(event, args2);
+          } else if (stats2) {
+            if (args2.length > 1) {
+              args2[1] = stats2;
+            } else {
+              args2.push(stats2);
+            }
+            this.emitWithAll(event, args2);
+          }
+        };
+        this._awaitWriteFinish(path5, awf.stabilityThreshold, event, awfEmit);
+        return this;
+      }
+      if (event === EVENTS.CHANGE) {
+        const isThrottled = !this._throttle(EVENTS.CHANGE, path5, 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;
+        let stats2;
+        try {
+          stats2 = await stat4(fullPath);
+        } catch (err) {}
+        if (!stats2 || this.closed)
+          return;
+        args2.push(stats2);
+      }
+      this.emitWithAll(event, args2);
+      return this;
+    }
+    _handleError(error) {
+      const code2 = error && error.code;
+      if (error && code2 !== "ENOENT" && code2 !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code2 !== "EPERM" && code2 !== "EACCES")) {
+        this.emit(EVENTS.ERROR, error);
+      }
+      return error || this.closed;
+    }
+    _throttle(actionType, path5, 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);
+      if (actionPath) {
+        actionPath.count++;
+        return false;
+      }
+      let timeoutObject;
+      const clear = () => {
+        const item = action.get(path5);
+        const count3 = item ? item.count : 0;
+        action.delete(path5);
+        clearTimeout(timeoutObject);
+        if (item)
+          clearTimeout(item.timeoutObject);
+        return count3;
+      };
+      timeoutObject = setTimeout(clear, timeout3);
+      const thr = { timeoutObject, clear, count: 0 };
+      action.set(path5, thr);
+      return thr;
+    }
+    _incrReadyCount() {
+      return this._readyCount++;
+    }
+    _awaitWriteFinish(path5, 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);
+      }
+      const now = new Date;
+      const writes = this._pendingWrites;
+      function awaitWriteFinishFn(prevStat) {
+        statcb(fullPath, (err, curStat) => {
+          if (err || !writes.has(path5)) {
+            if (err && err.code !== "ENOENT")
+              awfEmit(err);
+            return;
+          }
+          const now2 = Number(new Date);
+          if (prevStat && curStat.size !== prevStat.size) {
+            writes.get(path5).lastChange = now2;
+          }
+          const pw = writes.get(path5);
+          const df = now2 - pw.lastChange;
+          if (df >= threshold) {
+            writes.delete(path5);
+            awfEmit(undefined, curStat);
+          } else {
+            timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+          }
+        });
+      }
+      if (!writes.has(path5)) {
+        writes.set(path5, {
+          lastChange: now,
+          cancelWait: () => {
+            writes.delete(path5);
+            clearTimeout(timeoutHandler);
+            return event;
+          }
+        });
+        timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+      }
+    }
+    _isIgnored(path5, stats) {
+      if (this.options.atomic && DOT_RE.test(path5))
+        return true;
+      if (!this._userIgnored) {
+        const { cwd } = this.options;
+        const ign = this.options.ignored;
+        const ignored = (ign || []).map(normalizeIgnored(cwd));
+        const ignoredPaths = [...this._ignoredPaths];
+        const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+        this._userIgnored = anymatch(list, undefined);
+      }
+      return this._userIgnored(path5, stats);
+    }
+    _isntIgnored(path5, stat5) {
+      return !this._isIgnored(path5, stat5);
+    }
+    _getWatchHelpers(path5) {
+      return new WatchHelper(path5, this.options.followSymlinks, this);
+    }
+    _getWatchedDir(directory) {
+      const dir = sp2.resolve(directory);
+      if (!this._watched.has(dir))
+        this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+      return this._watched.get(dir);
+    }
+    _hasReadPermissions(stats) {
+      if (this.options.ignorePermissionErrors)
+        return true;
+      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))
+        return;
+      if (!isDirectory && this._watched.size === 1) {
+        this.add(directory, item, true);
+      }
+      const wp = this._getWatchedDir(path5);
+      const nestedDirectoryChildren = wp.getChildren();
+      nestedDirectoryChildren.forEach((nested2) => this._remove(path5, 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;
+      if (this.options.cwd)
+        relPath = sp2.relative(this.options.cwd, path5);
+      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(fullPath);
+      const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+      if (wasTracked && !this._isIgnored(path5))
+        this._emit(eventName, path5);
+      this._closePath(path5);
+    }
+    _closePath(path5) {
+      this._closeFile(path5);
+      const dir = sp2.dirname(path5);
+      this._getWatchedDir(dir).remove(sp2.basename(path5));
+    }
+    _closeFile(path5) {
+      const closers = this._closers.get(path5);
+      if (!closers)
+        return;
+      closers.forEach((closer) => closer());
+      this._closers.delete(path5);
     }
-  }
-  await visitDir("");
-  return { filePaths, truncated };
-}
-var init_workspace_file_walk = __esm(() => {
-  init_workspace_ignore();
-  init_workspace_visibility_policy();
-  init_git_reader();
+    _addPathCloser(path5, closer) {
+      if (!closer)
+        return;
+      let list = this._closers.get(path5);
+      if (!list) {
+        list = [];
+        this._closers.set(path5, list);
+      }
+      list.push(closer);
+    }
+    _readdirp(root, opts) {
+      if (this.closed)
+        return;
+      const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+      let stream4 = readdirp(root, options);
+      this._streams.add(stream4);
+      stream4.once(STR_CLOSE, () => {
+        stream4 = undefined;
+      });
+      stream4.once(STR_END, () => {
+        if (stream4) {
+          this._streams.delete(stream4);
+          stream4 = undefined;
+        }
+      });
+      return stream4;
+    }
+  };
 });
 
-// src/infrastructure/services/workspace/file-tree-scanner.ts
-async function scanFileTree(rootDir, options) {
-  const maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES;
-  const scannedAt = Date.now();
-  const walk = await walkWorkspaceFiles(rootDir, { maxFilePaths: maxEntries });
-  const filteredPaths = walk.filePaths.filter((p) => !isExcluded(p));
-  const entries2 = buildEntries(filteredPaths, maxEntries);
-  return {
-    entries: entries2,
-    scannedAt,
-    rootDir
-  };
-}
-function isExcluded(filePath) {
-  return hasExcludedDirSegment(filePath);
+// src/infrastructure/services/workspace/workspace-fs-watcher.ts
+import path5 from "node:path";
+function toRelativePath(rootDir, absolutePath) {
+  return path5.relative(rootDir, absolutePath).replace(/\\/g, "/").replace(/^\.?\//, "");
 }
-function buildEntries(filePaths, maxEntries) {
-  const directories = new Set;
-  for (const filePath of filePaths) {
-    const parts2 = filePath.split("/");
-    for (let i2 = 1;i2 < parts2.length; i2++) {
-      directories.add(parts2.slice(0, i2).join("/"));
+function createWorkspaceFsWatcher(options) {
+  const absWorkingDir = path5.resolve(options.workingDir);
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  let stopped = false;
+  let debounceTimer = null;
+  const pendingEvents = new Map;
+  const scheduleFlush = () => {
+    if (debounceTimer)
+      clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      if (pendingEvents.size === 0 || stopped)
+        return;
+      const events = [...pendingEvents.values()].sort((a, b) => a.path.localeCompare(b.path));
+      pendingEvents.clear();
+      Promise.resolve(options.onEvents(events)).catch((error) => {
+        options.onError?.(error);
+      });
+    }, debounceMs);
+    debounceTimer.unref?.();
+  };
+  const enqueue = (kind, absolutePath) => {
+    if (stopped)
+      return;
+    const relativePath = toRelativePath(absWorkingDir, absolutePath);
+    if (!relativePath || !isPathVisible(relativePath) || hasExcludedDirSegment(relativePath))
+      return;
+    if (options.shouldIgnore?.(relativePath))
+      return;
+    pendingEvents.set(relativePath, { kind, path: relativePath });
+    scheduleFlush();
+  };
+  const watcher = watch(absWorkingDir, {
+    ignored: (watchPath) => {
+      const relativePath = toRelativePath(absWorkingDir, watchPath);
+      if (!relativePath)
+        return false;
+      return !isPathVisible(relativePath) || hasExcludedDirSegment(relativePath) || options.shouldIgnore?.(relativePath) === true;
+    },
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 25 }
+  });
+  watcher.on("add", (filePath) => enqueue("add", filePath)).on("addDir", (filePath) => enqueue("addDir", filePath)).on("change", (filePath) => enqueue("change", filePath)).on("unlink", (filePath) => enqueue("unlink", filePath)).on("unlinkDir", (filePath) => enqueue("unlinkDir", filePath)).on("error", (error) => options.onError?.(error));
+  const ready = new Promise((resolve7) => {
+    watcher.once("ready", resolve7);
+  });
+  return {
+    ready,
+    stop: async () => {
+      stopped = true;
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      pendingEvents.clear();
+      await watcher.close();
     }
-  }
-  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 file of sortedFiles) {
-    if (entries2.length >= maxEntries)
-      break;
-    entries2.push({ path: file, type: "file" });
-  }
-  return entries2;
+  };
 }
-var DEFAULT_MAX_ENTRIES = 1e4;
-var init_file_tree_scanner = __esm(() => {
-  init_workspace_file_walk();
+var DEFAULT_DEBOUNCE_MS = 250;
+var init_workspace_fs_watcher = __esm(() => {
+  init_chokidar();
   init_workspace_visibility_policy();
 });
 
-// src/infrastructure/services/workspace/file-tree-v3-upload.ts
-async function uploadFileTreeV3(session2, workingDir, tree, syncGeneration) {
-  const shards = partitionFileTree(tree);
-  const shardIds = [];
-  for (let i2 = 0;i2 < shards.length; i2 += MAX_SHARD_BATCH_SIZE) {
-    const batch = shards.slice(i2, i2 + MAX_SHARD_BATCH_SIZE);
-    await session2.backend.mutation(api.workspaceFiles.syncFileTreeShardV3Batch, {
-      sessionId: session2.sessionId,
-      machineId: session2.machineId,
-      workingDir,
-      syncGeneration,
-      items: batch.map((s) => ({
-        shardId: s.shardId,
-        data: s.data,
-        dataHash: s.dataHash,
-        scannedAt: tree.scannedAt,
-        entryCount: s.entryCount
-      }))
-    });
-    for (const s of batch)
-      shardIds.push(s.shardId);
-  }
-  await session2.backend.mutation(api.workspaceFiles.syncFileTreeManifestV3, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    workingDir,
-    syncGeneration,
-    shardIds,
-    totalEntryCount: tree.entries.length,
-    complete: true,
-    scannedAt: tree.scannedAt
-  });
-  return { shardIds, totalEntryCount: tree.entries.length };
-}
-var init_file_tree_v3_upload = __esm(() => {
-  init_file_tree_partition();
-  init_api3();
-});
-
 // src/infrastructure/services/workspace/workspace-sync-diff.ts
 function diffPathIndexes(previous, next4) {
   const added = [];
   const removed = [];
   const typeChanged = [];
   const prev = previous ?? {};
-  for (const [path5, type] of Object.entries(next4)) {
-    if (!(path5 in prev)) {
-      added.push(path5);
-    } else if (prev[path5] !== type) {
-      typeChanged.push(path5);
+  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 path5 of Object.keys(prev)) {
-    if (!(path5 in next4)) {
-      removed.push(path5);
+  for (const path6 of Object.keys(prev)) {
+    if (!(path6 in next4)) {
+      removed.push(path6);
     }
   }
   added.sort();
@@ -89322,57 +90960,12 @@ function diffPathIndexes(previous, next4) {
   typeChanged.sort();
   return { added, removed, typeChanged };
 }
-function formatPathDiffSummary(diff8) {
-  return `+${diff8.added.length} added, -${diff8.removed.length} removed${diff8.typeChanged.length > 0 ? `, ~${diff8.typeChanged.length} type-changed` : ""}`;
-}
-
-// src/infrastructure/services/workspace/workspace-sync-queue.ts
-function queueKey(machineId, workingDir) {
-  return `${machineId}\x00${workingDir}`;
-}
-function getOrCreateState(key) {
-  let state = queues.get(key);
-  if (!state) {
-    state = { running: false, trailing: false, drainPromise: null };
-    queues.set(key, state);
-  }
-  return state;
-}
-async function enqueueFileTreeSync(machineId, workingDir, task) {
-  const key = queueKey(machineId, workingDir);
-  const state = getOrCreateState(key);
-  if (state.running) {
-    state.trailing = true;
-    return state.drainPromise ?? Promise.resolve();
-  }
-  const run3 = async () => {
-    state.running = true;
-    try {
-      do {
-        state.trailing = false;
-        await task();
-      } while (state.trailing);
-    } finally {
-      state.running = false;
-      state.trailing = false;
-      if (!state.trailing) {
-        queues.delete(key);
-      }
-    }
-  };
-  state.drainPromise = run3();
-  return state.drainPromise;
-}
-var queues;
-var init_workspace_sync_queue = __esm(() => {
-  queues = new Map;
-});
 
 // src/infrastructure/services/workspace/workspace-sync-state.ts
 import { createHash as createHash6, randomUUID as randomUUID6 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 function workspaceKeyFor(workingDir) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
   return createHash6("sha256").update(normalized).digest("hex").slice(0, 16);
@@ -89386,15 +90979,32 @@ function buildPathIndex(entries2) {
 }
 function manifestPath(machineId, workingDir) {
   const key = workspaceKeyFor(workingDir);
-  return join18(SYNC_STATE_DIR, machineId, key, "manifest.json");
+  return join20(SYNC_STATE_DIR, machineId, key, "manifest.json");
 }
 async function ensureDir(filePath) {
-  await fs11.mkdir(join18(filePath, ".."), { recursive: true, mode: 448 });
+  await fs11.mkdir(join20(filePath, ".."), { recursive: true, mode: 448 });
 }
 async function loadWorkspaceSyncManifest(machineId, workingDir) {
   try {
     const content = await fs11.readFile(manifestPath(machineId, workingDir), "utf-8");
-    return JSON.parse(content);
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || !parsed.paths)
+      return null;
+    if (parsed.version === "1") {
+      return {
+        ...parsed,
+        version: SYNC_STATE_VERSION,
+        scanner: "filesystem",
+        localRevision: 0,
+        backendRevision: 0,
+        checkpointRevision: 0,
+        lastReconciledAt: parsed.completedAt,
+        pendingDeltas: []
+      };
+    }
+    if (parsed.version !== SYNC_STATE_VERSION)
+      return null;
+    return parsed;
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -89419,15 +91029,275 @@ function createManifestFromTree(args2) {
     scanner: args2.scanner,
     dataHash: args2.dataHash,
     totalEntryCount: args2.tree.entries.length,
-    paths: buildPathIndex(args2.tree.entries)
+    paths: buildPathIndex(args2.tree.entries),
+    localRevision: 0,
+    backendRevision: 0,
+    checkpointRevision: 0,
+    lastReconciledAt: args2.tree.scannedAt,
+    pendingDeltas: []
   };
 }
-var SYNC_STATE_VERSION = "1", SYNC_STATE_DIR;
+function entriesFromPathIndex(paths) {
+  return Object.entries(paths).map(([path6, type]) => ({ path: path6, type })).sort((a, b) => a.path.localeCompare(b.path));
+}
+var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
-  SYNC_STATE_DIR = join18(homedir7(), ".chatroom", "sync-state");
+  SYNC_STATE_DIR = join20(homedir7(), ".chatroom", "sync-state");
+});
+
+// src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
+import { randomUUID as randomUUID7 } from "node:crypto";
+import path6 from "node:path";
+function deltaEntry(paths, pathValue) {
+  const type = paths[pathValue];
+  if (type === undefined)
+    throw new Error(`Missing path type for delta: ${pathValue}`);
+  return { path: pathValue, type };
+}
+function buildPendingDeltas(previous, next4) {
+  const diff8 = diffPathIndexes(previous, next4);
+  if (diff8.added.length === 0 && diff8.removed.length === 0 && diff8.typeChanged.length === 0) {
+    return [];
+  }
+  const operations = [
+    ...diff8.added.map((entryPath) => ({
+      kind: "added",
+      entry: deltaEntry(next4, entryPath)
+    })),
+    ...diff8.removed.map((entryPath) => ({ kind: "removed", path: entryPath })),
+    ...diff8.typeChanged.map((entryPath) => ({
+      kind: "typeChanged",
+      entry: deltaEntry(next4, entryPath)
+    }))
+  ];
+  const result = [];
+  for (let offset = 0;offset < operations.length; offset += MAX_DELTA_OPERATIONS) {
+    const delta = {
+      operationId: randomUUID7(),
+      added: [],
+      removed: [],
+      typeChanged: [],
+      createdAt: Date.now()
+    };
+    for (const operation of operations.slice(offset, offset + MAX_DELTA_OPERATIONS)) {
+      if (operation.kind === "added")
+        delta.added.push(operation.entry);
+      else if (operation.kind === "removed")
+        delta.removed.push(operation.path);
+      else
+        delta.typeChanged.push(operation.entry);
+    }
+    result.push(delta);
+  }
+  return result;
+}
+function isIgnoreFile(relativePath) {
+  return relativePath === ".gitignore" || relativePath === ".cursorignore" || relativePath.endsWith("/.gitignore");
+}
+function removePathAndDescendants(paths, relativePath) {
+  delete paths[relativePath];
+  const prefix = `${relativePath}/`;
+  for (const candidate of Object.keys(paths)) {
+    if (candidate.startsWith(prefix))
+      delete paths[candidate];
+  }
+}
+function ensureParentDirectories(paths, relativePath) {
+  const parts2 = relativePath.split("/");
+  for (let index = 1;index < parts2.length; index++) {
+    paths[parts2.slice(0, index).join("/")] = "directory";
+  }
+}
+async function addDirectorySubtree(rootDir, relativeDir, paths) {
+  if (await isWorkspacePathIgnored(rootDir, relativeDir))
+    return;
+  ensureParentDirectories(paths, relativeDir);
+  paths[relativeDir] = "directory";
+  const subtree = await scanFileTree(path6.join(rootDir, relativeDir));
+  for (const entry of subtree.entries) {
+    const prefixedPath = `${relativeDir}/${entry.path}`;
+    if (await isWorkspacePathIgnored(rootDir, prefixedPath))
+      continue;
+    paths[prefixedPath] = entry.type;
+  }
+}
+async function applyFsEvents(rootDir, previous, events) {
+  if (events.some((event) => isIgnoreFile(event.path)))
+    return null;
+  const next4 = { ...previous };
+  for (const event of events) {
+    if (event.kind === "unlink" || event.kind === "unlinkDir") {
+      removePathAndDescendants(next4, event.path);
+      continue;
+    }
+    if (event.kind === "change" && next4[event.path] !== undefined)
+      continue;
+    if (await isWorkspacePathIgnored(rootDir, event.path)) {
+      removePathAndDescendants(next4, event.path);
+      continue;
+    }
+    if (event.kind === "addDir") {
+      await addDirectorySubtree(rootDir, event.path, next4);
+    } else {
+      ensureParentDirectories(next4, event.path);
+      next4[event.path] = "file";
+    }
+  }
+  return next4;
+}
+function treeFromManifest(manifest) {
+  return {
+    entries: entriesFromPathIndex(manifest.paths),
+    rootDir: manifest.workingDir,
+    scannedAt: manifest.completedAt
+  };
+}
+function nextReconcileDelay(baseMs) {
+  const jitter = baseMs * RECONCILE_JITTER_RATIO;
+  return Math.max(1000, Math.round(baseMs - jitter + Math.random() * jitter * 2));
+}
+async function startWorkspaceFileTreeCoordinator(options) {
+  const workingDir = normalizeWorkingDirForLookup(options.workingDir);
+  let stopped = false;
+  let serial = Promise.resolve();
+  let reconcileTimer = null;
+  const loadedManifest = await loadWorkspaceSyncManifest(options.machineId, workingDir);
+  const isColdStart = loadedManifest === null;
+  let manifest;
+  if (loadedManifest) {
+    manifest = loadedManifest;
+  } else {
+    const tree = await scanFileTree(workingDir);
+    manifest = createManifestFromTree({
+      machineId: options.machineId,
+      workingDir,
+      scanner: "filesystem",
+      dataHash: computeFileTreeDataHash(tree),
+      tree
+    });
+    await saveWorkspaceSyncManifest(manifest);
+  }
+  const publishCheckpoint = async () => {
+    const result = await options.onCheckpoint(treeFromManifest(manifest), manifest.backendRevision);
+    manifest.backendRevision = result.revision;
+    manifest.checkpointRevision = result.revision;
+    manifest.pendingDeltas = [];
+    await saveWorkspaceSyncManifest(manifest);
+  };
+  if (isColdStart)
+    await publishCheckpoint();
+  const flushPending = async () => {
+    while (!stopped && manifest.pendingDeltas.length > 0) {
+      const delta = manifest.pendingDeltas[0];
+      if (!delta)
+        break;
+      const result = await options.onDelta(delta, manifest.backendRevision);
+      if (result.status === "conflict") {
+        manifest.backendRevision = result.revision;
+        await saveWorkspaceSyncManifest(manifest);
+        continue;
+      }
+      manifest.backendRevision = result.revision;
+      manifest.pendingDeltas.shift();
+      await saveWorkspaceSyncManifest(manifest);
+      const checkpointEvery = options.checkpointEveryRevisions ?? DEFAULT_CHECKPOINT_EVERY_REVISIONS;
+      if (manifest.pendingDeltas.length === 0 && manifest.backendRevision - manifest.checkpointRevision >= checkpointEvery) {
+        await publishCheckpoint();
+      }
+    }
+  };
+  const commitPaths = async (nextPaths, reconciledAt) => {
+    const deltas = buildPendingDeltas(manifest.paths, nextPaths);
+    if (reconciledAt !== undefined)
+      manifest.lastReconciledAt = reconciledAt;
+    if (deltas.length === 0) {
+      if (reconciledAt !== undefined)
+        await saveWorkspaceSyncManifest(manifest);
+      await flushPending();
+      return 0;
+    }
+    manifest.paths = nextPaths;
+    manifest.totalEntryCount = Object.keys(nextPaths).length;
+    manifest.completedAt = Date.now();
+    manifest.localRevision += 1;
+    manifest.pendingDeltas.push(...deltas);
+    manifest.dataHash = computeFileTreeDataHash(treeFromManifest(manifest));
+    await saveWorkspaceSyncManifest(manifest);
+    await flushPending();
+    return deltas.reduce((total, delta) => total + delta.added.length + delta.removed.length + delta.typeChanged.length, 0);
+  };
+  const reconcileNow = async () => {
+    const tree = await scanFileTree(workingDir);
+    const corrected = await commitPaths(buildPathIndex(tree.entries), tree.scannedAt);
+    options.onReconciled?.(corrected);
+  };
+  const enqueueSerial = (task) => {
+    serial = serial.then(task, task).catch((error) => {
+      options.onError?.(error);
+    });
+    return serial;
+  };
+  const scheduleReconcile = (delay3) => {
+    if (stopped)
+      return;
+    if (reconcileTimer)
+      clearTimeout(reconcileTimer);
+    const interval = options.reconcileIntervalMs ?? DEFAULT_RECONCILE_INTERVAL_MS;
+    reconcileTimer = setTimeout(() => {
+      reconcileTimer = null;
+      enqueueSerial(reconcileNow).finally(() => scheduleReconcile());
+    }, delay3 ?? nextReconcileDelay(interval));
+    reconcileTimer.unref?.();
+  };
+  await flushPending();
+  const watcher = createWorkspaceFsWatcher({
+    workingDir,
+    onEvents: async (events) => {
+      await enqueueSerial(async () => {
+        const nextPaths = await applyFsEvents(workingDir, manifest.paths, events);
+        if (nextPaths === null) {
+          await reconcileNow();
+          return;
+        }
+        await commitPaths(nextPaths);
+      });
+    },
+    onError: (error) => {
+      options.onError?.(error);
+      scheduleReconcile(1000);
+    }
+  });
+  await watcher.ready;
+  scheduleReconcile();
+  return {
+    workingDir,
+    getManifest: () => manifest,
+    getTree: () => treeFromManifest(manifest),
+    checkpoint: () => enqueueSerial(publishCheckpoint),
+    reconcile: () => enqueueSerial(reconcileNow),
+    stop: async () => {
+      stopped = true;
+      if (reconcileTimer)
+        clearTimeout(reconcileTimer);
+      reconcileTimer = null;
+      await watcher.stop();
+      await serial;
+      await saveWorkspaceSyncManifest(manifest);
+    }
+  };
+}
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_CHECKPOINT_EVERY_REVISIONS = 100, RECONCILE_JITTER_RATIO = 0.2, MAX_DELTA_OPERATIONS = 100;
+var init_workspace_file_tree_coordinator = __esm(() => {
+  init_file_tree_data_hash();
+  init_file_tree_scanner();
+  init_workspace_fs_watcher();
+  init_workspace_ignore();
+  init_workspace_sync_state();
+  DEFAULT_RECONCILE_INTERVAL_MS = 10 * 60 * 1000;
 });
 
 // src/commands/machine/daemon-start/file-tree-subscription.ts
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { gzipSync as gzipSync4 } from "node:zlib";
 function logSubscriptionWarn(label, err) {
   console.warn(`[${formatTimestamp()}] ⚠️  ${label}: ${getErrorMessage2(err)}`);
@@ -89435,7 +91305,7 @@ function logSubscriptionWarn(label, err) {
 async function syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHash, syncGeneration) {
   if (shouldUseV3Upload(tree)) {
     await uploadFileTreeV3(session2, normalizedWorkingDir, tree, syncGeneration);
-    return;
+    return { snapshotKind: "v3", snapshotId: syncGeneration };
   }
   const treeJson = JSON.stringify(tree);
   const compressed = gzipSync4(Buffer.from(treeJson)).toString("base64");
@@ -89447,60 +91317,122 @@ async function syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHas
     dataHash,
     scannedAt: tree.scannedAt
   });
+  return { snapshotKind: "v2", snapshotId: dataHash };
 }
-async function uploadFileTree(session2, workingDir) {
-  const normalizedWorkingDir = normalizeWorkingDirForLookup(workingDir);
-  const previousManifest = await loadWorkspaceSyncManifest(session2.machineId, normalizedWorkingDir);
-  const tree = await scanFileTree(normalizedWorkingDir);
+function toDeltaOperations(delta) {
+  return [
+    ...delta.added.map((entry) => ({
+      operation: "add",
+      path: entry.path,
+      entryType: entry.type
+    })),
+    ...delta.removed.map((entryPath) => ({
+      operation: "remove",
+      path: entryPath
+    })),
+    ...delta.typeChanged.map((entry) => ({
+      operation: "type-change",
+      path: entry.path,
+      entryType: entry.type
+    }))
+  ];
+}
+async function publishCheckpoint(session2, normalizedWorkingDir, tree, revision) {
   const dataHash = computeFileTreeDataHash(tree);
-  if (previousManifest?.dataHash === dataHash) {
-    await session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
+  const syncGeneration = randomUUID8();
+  const snapshot = await syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHash, syncGeneration);
+  let checkpointRevision = revision;
+  let result = await session2.backend.mutation(api.workspaceFiles.publishFileTreeCheckpoint, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir: normalizedWorkingDir,
+    revision: checkpointRevision,
+    ...snapshot
+  });
+  if (result.status === "resync-required") {
+    checkpointRevision = result.expectedRevision + 1;
+    result = await session2.backend.mutation(api.workspaceFiles.publishFileTreeCheckpoint, {
       sessionId: session2.sessionId,
       machineId: session2.machineId,
-      workingDir: normalizedWorkingDir
+      workingDir: normalizedWorkingDir,
+      revision: checkpointRevision,
+      ...snapshot
     });
-    console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree unchanged, skipped upload: ${normalizedWorkingDir}`);
-    return;
   }
-  const pathDiff = diffPathIndexes(previousManifest?.paths, buildPathIndex(tree.entries));
-  if (previousManifest) {
-    console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree diff: ${formatPathDiffSummary(pathDiff)} (${normalizedWorkingDir})`);
+  if (result.status === "snapshot-missing") {
+    throw new Error(`File tree checkpoint rejected: ${result.status}`);
   }
-  const scanner = await isGitRepo(normalizedWorkingDir) ? "git" : "filesystem";
-  const manifest = createManifestFromTree({
-    machineId: session2.machineId,
-    workingDir: normalizedWorkingDir,
-    scanner,
-    dataHash,
-    tree
-  });
-  await syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHash, manifest.syncGeneration);
-  await session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    workingDir: normalizedWorkingDir
-  });
-  await saveWorkspaceSyncManifest(manifest);
+  console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree checkpoint: ${normalizedWorkingDir} (${tree.entries.length} entries, revision ${checkpointRevision})`);
+  return { revision: checkpointRevision };
 }
 var startFileTreeSubscriptionEffect = (wsClient2) => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
+  const coordinators = new Map;
+  const ensureCoordinator = (workingDir, forceReconcile) => {
+    const normalized = normalizeWorkingDirForLookup(workingDir);
+    let coordinatorPromise = coordinators.get(normalized);
+    if (!coordinatorPromise) {
+      coordinatorPromise = startWorkspaceFileTreeCoordinator({
+        machineId: session2.machineId,
+        workingDir: normalized,
+        onDelta: async (delta, baseRevision) => {
+          const operations = toDeltaOperations(delta);
+          const result = await session2.backend.mutation(api.workspaceFiles.applyFileTreeDeltaBatch, {
+            sessionId: session2.sessionId,
+            machineId: session2.machineId,
+            workingDir: normalized,
+            operationId: delta.operationId,
+            baseRevision,
+            operations
+          });
+          if (result.status === "resync-required") {
+            return { status: "conflict", revision: result.expectedRevision };
+          }
+          console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree delta: ${normalized} (${operations.length} operations, ${Buffer.byteLength(JSON.stringify(operations))} bytes, revision ${result.revision})`);
+          return result;
+        },
+        onCheckpoint: (tree, revision) => publishCheckpoint(session2, normalized, tree, revision),
+        onError: (error) => logSubscriptionWarn(`File tree coordinator failed for ${normalized}`, error),
+        onReconciled: (correctedPathCount) => {
+          console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree reconciled: ${normalized} (${correctedPathCount} corrected paths)`);
+        }
+      }).catch((error) => {
+        coordinators.delete(normalized);
+        throw error;
+      });
+      coordinators.set(normalized, coordinatorPromise);
+    }
+    return coordinatorPromise.then(async (coordinator) => {
+      const checkpoint = await session2.backend.query(api.workspaceFiles.getFileTreeCheckpoint, {
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        workingDir: normalized
+      });
+      if (checkpoint === null)
+        await coordinator.checkpoint();
+      if (forceReconcile)
+        await coordinator.reconcile();
+      return coordinator;
+    });
+  };
   const unsubscribe = wsClient2.onUpdate(api.workspaceFiles.getPendingFileTreeRequests, { sessionId: session2.sessionId, machineId: session2.machineId }, (requests) => {
     if (!requests?.length)
       return;
-    const uniqueDirs = [
-      ...new Set(requests.map((r) => normalizeWorkingDirForLookup(r.workingDir)))
-    ];
-    for (const workingDir of uniqueDirs) {
-      const normalized = normalizeWorkingDirForLookup(workingDir);
-      enqueueFileTreeSync(session2.machineId, normalized, () => {
-        const start3 = Date.now();
-        return uploadFileTree(session2, normalized).then(() => {
-          console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree fulfilled: ${normalized} (${Date.now() - start3}ms)`);
-        }).catch((err) => {
-          logSubscriptionWarn(`File tree failed for ${normalized}`, err);
-        });
+    const requestsByDir = new Map;
+    for (const request2 of requests) {
+      const normalized = normalizeWorkingDirForLookup(request2.workingDir);
+      requestsByDir.set(normalized, requestsByDir.get(normalized) === true || request2.force === true);
+    }
+    for (const [normalized, force] of requestsByDir) {
+      const start3 = Date.now();
+      ensureCoordinator(normalized, force).then(() => session2.backend.mutation(api.workspaceFiles.fulfillFileTreeRequest, {
+        sessionId: session2.sessionId,
+        machineId: session2.machineId,
+        workingDir: normalized
+      })).then(() => {
+        console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree ready: ${normalized} (${Date.now() - start3}ms${force ? ", reconciled" : ", cached"})`);
       }).catch((err) => {
-        logSubscriptionWarn("File tree queue drain failed", err);
+        logSubscriptionWarn(`File tree failed for ${normalized}`, err);
       });
     }
   }, (err) => {
@@ -89510,6 +91442,10 @@ var startFileTreeSubscriptionEffect = (wsClient2) => exports_Effect.gen(function
   return {
     stop: () => {
       unsubscribe();
+      Promise.all([...coordinators.values()].map((coordinator) => coordinator.then((handle) => handle.stop()).catch(() => {
+        return;
+      })));
+      coordinators.clear();
       console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree subscription stopped`);
     }
   };
@@ -89518,13 +91454,10 @@ var init_file_tree_subscription = __esm(() => {
   init_esm();
   init_daemon_services();
   init_api3();
-  init_git_reader();
   init_file_tree_data_hash();
   init_file_tree_partition();
-  init_file_tree_scanner();
   init_file_tree_v3_upload();
-  init_workspace_sync_queue();
-  init_workspace_sync_state();
+  init_workspace_file_tree_coordinator();
   init_convex_error();
 });
 
@@ -89535,7 +91468,7 @@ function unsupportedFileWriteOperationMessage(operation) {
 
 // src/commands/machine/daemon-start/file-write-fulfillment.ts
 import { access as access4, mkdir as mkdir9, rename as rename5, rm as rm3, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname9 } from "node:path";
+import { dirname as dirname11 } from "node:path";
 function isTerminalFileWriteError(errorMessage) {
   const terminalMessages = new Set([
     "Invalid file path",
@@ -89587,7 +91520,7 @@ async function validateWriteOperation(operation, absolutePath) {
 }
 async function writePayloadToDisk(absolutePath, operation, content) {
   if (operation === "create") {
-    await mkdir9(dirname9(absolutePath), { recursive: true });
+    await mkdir9(dirname11(absolutePath), { recursive: true });
   }
   await writeFile8(absolutePath, content);
 }
@@ -89650,7 +91583,7 @@ async function fulfillOneFileWriteRequest(session2, request2) {
         });
         return;
       }
-      await mkdir9(dirname9(targetResolved.absolutePath), { recursive: true });
+      await mkdir9(dirname11(targetResolved.absolutePath), { recursive: true });
       await rename5(resolved.absolutePath, targetResolved.absolutePath);
       await completeWriteRequest(session2, request2._id, { status: "done" });
       const elapsed4 = Date.now() - startTime;
@@ -92997,11 +94930,11 @@ class AgentProcessManager {
       const initPrompt = await this.fetchInitPromptResult(opts, slot);
       if (!initPrompt.ok)
         return initPrompt.result;
-      const spawn7 = await this.spawnAgentForEnsureRunning(key, slot, opts, initPrompt, wantResume);
-      if (!spawn7.ok)
-        return spawn7.result;
-      await this.finalizeRunningSlot(key, slot, opts, spawn7.spawnResult, wantResume);
-      return { success: true, pid: spawn7.spawnResult.pid };
+      const spawn6 = await this.spawnAgentForEnsureRunning(key, slot, opts, initPrompt, wantResume);
+      if (!spawn6.ok)
+        return spawn6.result;
+      await this.finalizeRunningSlot(key, slot, opts, spawn6.spawnResult, wantResume);
+      return { success: true, pid: spawn6.spawnResult.pid };
     } catch (e) {
       this.resetSlotIdle(slot);
       return { success: false, error: `Unexpected error: ${e.message}` };
@@ -93248,7 +95181,7 @@ var init_daemon_startup_log = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/init.ts
-import { stat as stat2 } from "node:fs/promises";
+import { stat as stat5 } from "node:fs/promises";
 async function discoverModelsForHarness(harness, service3) {
   const installed2 = await service3.isInstalled();
   if (!installed2) {
@@ -93283,7 +95216,7 @@ function createDefaultDeps17() {
       kill: (pid, signal) => process.kill(pid, signal)
     },
     fs: {
-      stat: stat2
+      stat: stat5
     },
     machine: {
       clearAgentPid,
@@ -93294,7 +95227,7 @@ function createDefaultDeps17() {
     },
     clock: {
       now: () => Date.now(),
-      delay: (ms) => new Promise((resolve5) => setTimeout(resolve5, ms))
+      delay: (ms) => new Promise((resolve7) => setTimeout(resolve7, ms))
     },
     spawning: new HarnessSpawningService({ rateLimiter: new SpawnRateLimiter }),
     agentProcessManager: null
@@ -94655,18 +96588,18 @@ var init_jsonc = __esm(() => {
 });
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
-import { readFile as readFile10, readdir, stat as stat3 } from "node:fs/promises";
-import { join as join19, basename as basename2, resolve as resolve5 } from "node:path";
+import { readFile as readFile10, readdir as readdir3, stat as stat6 } from "node:fs/promises";
+import { join as join21, basename as basename4, resolve as resolve7 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
-  const parentDir = join19(rootDir, cleaned.slice(0, -2));
+  const parentDir = join21(rootDir, cleaned.slice(0, -2));
   try {
-    const entries2 = await readdir(parentDir, { withFileTypes: true });
+    const entries2 = await readdir3(parentDir, { withFileTypes: true });
     const dirs = [];
     for (const entry of entries2) {
       if (!entry.isDirectory())
         continue;
-      const dirPath = join19(parentDir, entry.name);
-      if (resolve5(dirPath).startsWith(resolve5(rootDir))) {
+      const dirPath = join21(parentDir, entry.name);
+      if (resolve7(dirPath).startsWith(resolve7(rootDir))) {
         dirs.push(dirPath);
       }
     }
@@ -94676,11 +96609,11 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
   }
 }
 async function resolveLiteralPath(rootDir, cleaned) {
-  const dir = join19(rootDir, cleaned);
+  const dir = join21(rootDir, cleaned);
   try {
-    if (!resolve5(dir).startsWith(resolve5(rootDir)))
+    if (!resolve7(dir).startsWith(resolve7(rootDir)))
       return [];
-    const s = await stat3(dir);
+    const s = await stat6(dir);
     if (s.isDirectory())
       return [dir];
   } catch {}
@@ -94696,10 +96629,10 @@ async function resolveGlobPattern(rootDir, pattern2) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile10(join19(dir, "package.json"), "utf-8");
+    const content = await readFile10(join21(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
-      name: pkg.name || basename2(dir),
+      name: pkg.name || basename4(dir),
       scripts: pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : {}
     };
   } catch {
@@ -94708,7 +96641,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile10(join19(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile10(join21(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -94735,7 +96668,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile10(join19(rootDir, "package.json"), "utf-8");
+    const content = await readFile10(join21(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -94784,11 +96717,11 @@ var init_workspace_resolver = () => {};
 
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access5, readFile as readFile11 } from "node:fs/promises";
-import { join as join20, relative as relative2, basename as basename3 } from "node:path";
+import { join as join22, relative as relative4, basename as basename5 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file, manager } of LOCKFILE_MAP) {
     try {
-      await access5(join20(workingDir, file));
+      await access5(join22(workingDir, file));
       return manager;
     } catch {}
   }
@@ -94856,8 +96789,8 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
   return commands;
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
-  let rootPackageName = basename3(workingDir);
-  const pkg = await readJsonFile(join20(workingDir, "package.json"), "root package.json");
+  let rootPackageName = basename5(workingDir);
+  const pkg = await readJsonFile(join22(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
   if (pkg.name)
@@ -94873,7 +96806,7 @@ async function readRootPackageJson(workingDir, pm, scriptPrefix) {
 }
 async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
   const turboTaskNames = [];
-  const turbo = await readJsonFile(join20(workingDir, "turbo.json"), "turbo.json");
+  const turbo = await readJsonFile(join22(workingDir, "turbo.json"), "turbo.json");
   if (!turbo?.tasks || typeof turbo.tasks !== "object")
     return turboTaskNames;
   for (const taskName of Object.keys(turbo.tasks)) {
@@ -94902,7 +96835,7 @@ async function discoverCommands(workingDir) {
   }
   const subWorkspaces = await resolveSubWorkspaces(workingDir, pm);
   for (const pkg of subWorkspaces) {
-    const wsPath = relative2(workingDir, pkg.dir) || ".";
+    const wsPath = relative4(workingDir, pkg.dir) || ".";
     const pkgSubWorkspace = { type: "npm", path: wsPath, name: pkg.name };
     await addSubWorkspaceCommands(commands, pm, pkg, wsPath, pkgSubWorkspace, turboTaskNames);
   }
@@ -95380,10 +97313,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys5 = Object.keys(promisesObj);
@@ -95629,11 +97562,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -95818,7 +97751,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path5 = []) => {
+  const processError = (error2, path7 = []) => {
     var _a2, _b2;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -95828,7 +97761,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -95858,9 +97791,9 @@ function treeifyError(error, _mapper) {
   processError(error);
   return result;
 }
-function toDotPath(path5) {
+function toDotPath(path7) {
   const segs = [];
-  for (const seg of path5) {
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -106873,7 +108806,7 @@ var init_layers = __esm(() => {
   IntervalClock = class IntervalClock extends exports_Context.Tag("IntervalClock")() {
   };
   IntervalClockLive = exports_Layer.succeed(IntervalClock, {
-    sleep: (ms) => exports_Effect.promise(() => new Promise((resolve6) => setTimeout(resolve6, ms)))
+    sleep: (ms) => exports_Effect.promise(() => new Promise((resolve8) => setTimeout(resolve8, ms)))
   });
 });
 
@@ -107849,8 +109782,8 @@ var init_command_loop = __esm(() => {
     const withTimeout2 = async (p, ms) => {
       await Promise.race([
         Promise.resolve(p).catch(() => {}),
-        new Promise((resolve6) => {
-          const t = setTimeout(resolve6, ms);
+        new Promise((resolve8) => {
+          const t = setTimeout(resolve8, ms);
           t.unref?.();
         })
       ]);
@@ -108004,7 +109937,7 @@ async function daemonStop() {
   console.log(`Stopping daemon (PID: ${pid})...`);
   try {
     process.kill(pid, "SIGTERM");
-    await new Promise((resolve6) => setTimeout(resolve6, 8000));
+    await new Promise((resolve8) => setTimeout(resolve8, 8000));
     try {
       process.kill(pid, 0);
       console.log(`Process did not exit gracefully, forcing...`);
@@ -108128,7 +110061,7 @@ __export(exports_opencode_install, {
   installTool: () => installTool
 });
 import * as os2 from "os";
-import * as path5 from "path";
+import * as path7 from "path";
 async function isChatroomInstalledDefault() {
   try {
     const { execSync: execSync3 } = await import("child_process");
@@ -108498,9 +110431,9 @@ After logging in, try this command again.\`;
   const fsService = yield* OpenCodeInstallFsService;
   const { checkExisting = true } = options;
   const homeDir = os2.homedir();
-  const toolDir = path5.join(homeDir, ".config", "opencode", "tool");
-  const toolPath = path5.join(toolDir, "chatroom.ts");
-  const handoffToolPath = path5.join(toolDir, "chatroom-handoff.ts");
+  const toolDir = path7.join(homeDir, ".config", "opencode", "tool");
+  const toolPath = path7.join(toolDir, "chatroom.ts");
+  const handoffToolPath = path7.join(toolDir, "chatroom-handoff.ts");
   if (checkExisting) {
     const existingFiles = [];
     const toolExists = yield* fsService.access(toolPath);
@@ -108573,7 +110506,7 @@ async function withRetry(fn2, opts) {
         return;
       }
       const delay3 = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
-      await new Promise((resolve6) => setTimeout(resolve6, delay3));
+      await new Promise((resolve8) => setTimeout(resolve8, delay3));
     }
   }
   return;
@@ -109055,4 +110988,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=0F49F7F33D425EFB64756E2164756E21
+//# debugId=D9A06559C6AC810C64756E2164756E21