chatroom-cli 1.98.2 → 1.98.4

package/dist/index.js

@@ -110218,7 +110218,8 @@ var init_file_content_fulfillment = __esm(() => {
         return exports_Effect.succeed(Buffer.from("[Error reading file]"));
       });
       if (fileNotFound) {
-        console.log(`[${formatTimestamp()}] ⏳ File not on disk yet, deferring content sync: ${filePath}`);
+        yield* fulfillGzippedContentEffect(session2, workingDir, filePath, "[File not found]", false);
+        console.log(`[${formatTimestamp()}] \uD83D\uDCC4 File not found, fulfilled content request: ${filePath}`);
         continue;
       }
       const classification2 = classifyFileContent(filePath, new Uint8Array(buffer));
@@ -110258,49 +110259,6 @@ var init_file_content_subscription = __esm(() => {
   init_daemon_services();
 });
 
-// ../../services/backend/src/domain/workspace-file-tree/types.ts
-var MAX_TREE_JSON_BYTES;
-var init_types2 = __esm(() => {
-  MAX_TREE_JSON_BYTES = 900 * 1024;
-});
-// ../../services/backend/src/domain/workspace-file-tree/select-strategy.ts
-function treeJsonByteLength(tree) {
-  return Buffer.byteLength(JSON.stringify(tree), "utf8");
-}
-function selectFileTreeSnapshotStrategyId(tree) {
-  return treeJsonByteLength(tree) > MAX_TREE_JSON_BYTES ? "sharded" : "blob";
-}
-var init_select_strategy = __esm(() => {
-  init_types2();
-});
-
-// ../../services/backend/src/domain/workspace-file-tree/registry.ts
-var init_registry5 = __esm(() => {
-  init_select_strategy();
-});
-// ../../services/backend/src/domain/workspace-file-tree/transport/blob-snapshot.ts
-function toLegacyBlobSyncArgs(payload) {
-  return { data: payload.data, dataHash: payload.dataHash, scannedAt: payload.scannedAt };
-}
-
-// ../../services/backend/src/domain/workspace-file-tree/transport/sharded-snapshot.ts
-function toLegacyShardBatchItem(shard) {
-  return { ...shard };
-}
-function toLegacyManifestSyncArgs(manifest) {
-  return { ...manifest };
-}
-// ../../services/backend/src/domain/workspace-file-tree/transport/index.ts
-var init_transport = () => {};
-
-// ../../services/backend/src/domain/workspace-file-tree/index.ts
-var init_workspace_file_tree = __esm(() => {
-  init_types2();
-  init_select_strategy();
-  init_registry5();
-  init_transport();
-});
-
 // src/infrastructure/services/workspace/file-tree-data-hash.ts
 import { createHash as createHash6 } from "node:crypto";
 function computeFileTreeDataHash(tree) {
@@ -110308,166 +110266,212 @@ function computeFileTreeDataHash(tree) {
 }
 var init_file_tree_data_hash = () => {};
 
-// src/infrastructure/services/workspace/transport/blob-snapshot-publish.ts
-import { gzipSync as gzipSync2 } from "node:zlib";
-function buildBlobSnapshotPayload(tree, dataHash) {
-  const compressed = gzipSync2(Buffer.from(JSON.stringify(tree))).toString("base64");
-  return {
-    data: { compression: "gzip", content: compressed },
-    dataHash,
-    scannedAt: tree.scannedAt
-  };
-}
-async function publishBlobSnapshot(session2, workingDir, payload) {
-  await session2.backend.mutation(api.workspaceFiles.syncFileTreeV2, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    workingDir,
-    ...toLegacyBlobSyncArgs(payload)
-  });
-  return {
-    strategyId: "blob",
-    snapshotId: payload.dataHash,
-    scannedAt: payload.scannedAt,
-    entryCount: 0
-  };
-}
-var init_blob_snapshot_publish = __esm(() => {
-  init_api3();
-});
-
-// src/infrastructure/services/workspace/file-tree-partition.ts
-import { createHash as createHash7 } from "node:crypto";
-import { gzipSync as gzipSync3 } from "node:zlib";
-function computeShardDataHash(payload) {
-  return createHash7("md5").update(JSON.stringify(payload)).digest("hex");
-}
-function shardIdForPath(path3) {
-  const slash = path3.indexOf("/");
-  return slash === -1 ? "__root__" : path3.slice(0, slash);
-}
-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 subdivideShardGroup(subgroups, tree) {
-  const shards = [];
-  for (const [subId, subEntries] of subgroups) {
-    shards.push(...prepareShardGroup(subEntries, subId, tree));
-  }
-  return shards;
-}
-function shouldSkipParentCompression(subgroups, entryCount) {
-  return subgroups.size > 1 && entryCount > LARGE_SHARD_ENTRY_THRESHOLD;
-}
-function prepareShardGroup(entries2, shardId, tree) {
-  const subgroups = groupEntriesByShardId(entries2, shardId);
-  if (shouldSkipParentCompression(subgroups, entries2.length)) {
-    return subdivideShardGroup(subgroups, 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 || subgroups.size <= 1) {
-    return [buildPreparedShard(shardId, payload)];
-  }
-  return subdivideShardGroup(subgroups, tree);
-}
-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_BYTES2, MAX_SHARD_JSON_BYTES, MAX_SHARD_BATCH_SIZE = 8, LARGE_SHARD_ENTRY_THRESHOLD = 50000;
-var init_file_tree_partition = __esm(() => {
-  init_workspace_file_tree();
-  MAX_TREE_JSON_BYTES2 = 900 * 1024;
-  MAX_SHARD_JSON_BYTES = 800 * 1024;
-});
-
-// src/infrastructure/services/workspace/transport/sharded-snapshot-publish.ts
-async function publishShardedSnapshot(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);
-    const items = batch.map((s) => ({
-      shardId: s.shardId,
-      data: s.data,
-      dataHash: s.dataHash,
-      scannedAt: tree.scannedAt,
-      entryCount: s.entryCount
-    }));
-    await session2.backend.mutation(api.workspaceFiles.syncFileTreeShardV3Batch, {
-      sessionId: session2.sessionId,
-      machineId: session2.machineId,
-      workingDir,
-      syncGeneration,
-      items: items.map(toLegacyShardBatchItem)
-    });
-    for (const s of batch)
-      shardIds.push(s.shardId);
-  }
-  const manifest = {
-    syncGeneration,
-    shardIds,
-    totalEntryCount: tree.entries.length,
-    complete: true,
-    scannedAt: tree.scannedAt
-  };
-  await session2.backend.mutation(api.workspaceFiles.syncFileTreeManifestV3, {
-    sessionId: session2.sessionId,
-    machineId: session2.machineId,
-    workingDir,
-    ...toLegacyManifestSyncArgs(manifest)
-  });
-  return {
-    strategyId: "sharded",
-    snapshotId: syncGeneration,
-    scannedAt: tree.scannedAt,
-    entryCount: tree.entries.length
-  };
-}
-var init_sharded_snapshot_publish = __esm(() => {
-  init_api3();
-  init_file_tree_partition();
+// src/infrastructure/services/workspace/file-tree-sync-ranker.ts
+function fileExtension(p) {
+  const b = (p.split("/").pop() ?? p).toLowerCase();
+  if (b.endsWith(".min.js"))
+    return ".min.js";
+  if (b.endsWith(".min.css"))
+    return ".min.css";
+  const i2 = b.lastIndexOf(".");
+  return i2 <= 0 ? "" : b.slice(i2);
+}
+function pathSegments(p) {
+  return p.split("/").filter(Boolean);
+}
+function parentDir(p) {
+  const i2 = p.lastIndexOf("/");
+  return i2 < 0 ? "" : p.slice(0, i2);
+}
+function isSourceDirPath(p) {
+  return pathSegments(p).slice(0, -1).some((s) => SOURCE_DIR_NAMES.has(s));
+}
+function isBuildDirPath(p) {
+  return pathSegments(p).some((s) => BUILD_DIR_NAMES.has(s));
+}
+function isMarkdownFile(p) {
+  return MARKDOWN_EXTENSIONS.has(fileExtension(p));
+}
+function isConfigFile(p) {
+  return CONFIG_BASENAMES.has((p.split("/").pop() ?? "").toLowerCase()) || CONFIG_EXTENSIONS.has(fileExtension(p));
+}
+function isSourceFile(p) {
+  return SOURCE_EXTENSIONS.has(fileExtension(p));
+}
+function isBuildOutputFile(p) {
+  return BUILD_OUTPUT_EXTENSIONS.has(fileExtension(p));
+}
+function isDataFile(p) {
+  return !isConfigFile(p) && DATA_EXTENSIONS.has(fileExtension(p));
+}
+function countDataFilesByParent(ps) {
+  const m = new Map;
+  for (const p of ps)
+    if (isDataFile(p)) {
+      const d = parentDir(p);
+      m.set(d, (m.get(d) ?? 0) + 1);
+    }
+  return m;
+}
+function scoreFile(p, m) {
+  let s = 0;
+  if (isSourceFile(p))
+    s += isSourceDirPath(p) ? SCORE_SOURCE_IN_SOURCE_DIR : SCORE_SOURCE_ELSEWHERE;
+  if (isMarkdownFile(p))
+    s += SCORE_MARKDOWN;
+  if (isConfigFile(p))
+    s += SCORE_CONFIG;
+  if (isBuildDirPath(p))
+    s -= PENALTY_BUILD_DIR;
+  if (isBuildOutputFile(p))
+    s -= PENALTY_BUILD_EXT;
+  const n = m.get(parentDir(p)) ?? 0;
+  return s - n * n;
+}
+function compareRankedFiles(a, as7, b, bs) {
+  if (as7 !== bs)
+    return bs - as7;
+  const d = pathSegments(a).length - pathSegments(b).length;
+  return d || a.localeCompare(b);
+}
+var SOURCE_DIR_NAMES, BUILD_DIR_NAMES, SOURCE_EXTENSIONS, MARKDOWN_EXTENSIONS, CONFIG_EXTENSIONS, CONFIG_BASENAMES, BUILD_OUTPUT_EXTENSIONS, DATA_EXTENSIONS, SCORE_SOURCE_IN_SOURCE_DIR = 1000, SCORE_MARKDOWN = 800, SCORE_CONFIG = 700, SCORE_SOURCE_ELSEWHERE = 200, PENALTY_BUILD_DIR = 5000, PENALTY_BUILD_EXT = 2000;
+var init_file_tree_sync_ranker = __esm(() => {
+  SOURCE_DIR_NAMES = new Set([
+    "src",
+    "lib",
+    "app",
+    "apps",
+    "packages",
+    "services",
+    "server",
+    "client",
+    "backend",
+    "frontend",
+    "api",
+    "cmd",
+    "internal",
+    "pkg",
+    "components",
+    "modules",
+    "pages",
+    "routes",
+    "hooks",
+    "domain",
+    "infrastructure",
+    "entry"
+  ]);
+  BUILD_DIR_NAMES = new Set([
+    "dist",
+    "build",
+    "out",
+    "output",
+    "coverage",
+    ".next",
+    ".turbo",
+    ".nx",
+    "_generated",
+    "generated",
+    "__pycache__"
+  ]);
+  SOURCE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".kt",
+    ".swift",
+    ".rb",
+    ".php",
+    ".cs",
+    ".c",
+    ".cc",
+    ".cpp",
+    ".h",
+    ".hpp",
+    ".vue",
+    ".svelte",
+    ".css",
+    ".scss",
+    ".less"
+  ]);
+  MARKDOWN_EXTENSIONS = new Set([".md", ".mdx", ".markdown"]);
+  CONFIG_EXTENSIONS = new Set([".yml", ".yaml", ".toml", ".jsonc", ".ini", ".cfg"]);
+  CONFIG_BASENAMES = new Set([
+    "package.json",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "pnpm-workspace.yaml",
+    "yarn.lock",
+    "bun.lock",
+    "tsconfig.json",
+    "jsconfig.json",
+    "turbo.json",
+    "nx.json",
+    "cargo.toml",
+    "go.mod",
+    "go.sum",
+    "pyproject.toml",
+    "requirements.txt",
+    "dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "makefile",
+    ".gitignore",
+    ".cursorignore",
+    ".editorconfig",
+    ".prettierrc",
+    ".nvmrc",
+    "eslint.config.mjs",
+    "eslint.config.js",
+    "biome.json",
+    ".fallowrc.jsonc"
+  ]);
+  BUILD_OUTPUT_EXTENSIONS = new Set([
+    ".map",
+    ".min.js",
+    ".min.css",
+    ".pyc",
+    ".pyo",
+    ".o",
+    ".obj",
+    ".wasm",
+    ".class",
+    ".jar",
+    ".exe",
+    ".dll",
+    ".so"
+  ]);
+  DATA_EXTENSIONS = new Set([
+    ".json",
+    ".csv",
+    ".tsv",
+    ".ndjson",
+    ".parquet",
+    ".avro",
+    ".bin",
+    ".dat",
+    ".pb",
+    ".sqlite",
+    ".db",
+    ".log",
+    ".gz",
+    ".zip",
+    ".tar",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".webp",
+    ".gif",
+    ".mp4",
+    ".woff",
+    ".woff2"
+  ]);
 });
 
 // ../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
@@ -110800,10 +110804,68 @@ var require_ignore = __commonJS((exports, module) => {
 // src/infrastructure/services/workspace/workspace-ignore.ts
 import { promises as fsPromises } from "node:fs";
 import { readFile as readFile10 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
 import path3 from "node:path";
 function normalizeRelativePath(relativePath) {
   return relativePath.replace(/\\/g, "/").replace(/^\.?\//, "").replace(/\/+$/, "");
 }
+function expandUserPath(filePath) {
+  if (filePath === "~")
+    return homedir7();
+  if (filePath.startsWith("~/"))
+    return path3.join(homedir7(), filePath.slice(2));
+  return filePath;
+}
+function readExcludesFileFromGitconfig(content) {
+  let inCore = false;
+  for (const line of content.split(/\r?\n/)) {
+    const section = line.match(/^\s*\[([^\]]+)\]/);
+    if (section) {
+      inCore = section[1].trim().toLowerCase() === "core";
+      continue;
+    }
+    if (!inCore)
+      continue;
+    const match17 = line.match(/^\s*excludesfile\s*=\s*(.*?)\s*(?:[#;].*)?$/i);
+    if (!match17)
+      continue;
+    const value = match17[1].trim().replace(/^(["'])(.*)\1$/, "$2");
+    return value ? expandUserPath(value) : null;
+  }
+  return null;
+}
+async function readGitconfigExcludesFilePath(configPath) {
+  const content = await readIgnoreFile(configPath);
+  if (content === null)
+    return null;
+  const raw = readExcludesFileFromGitconfig(content);
+  if (!raw)
+    return null;
+  return path3.isAbsolute(raw) ? expandUserPath(raw) : path3.resolve(path3.dirname(configPath), raw);
+}
+async function resolveGitExtraExcludeFilePaths(rootDir) {
+  const globalConfig2 = process.env.GIT_CONFIG_GLOBAL?.length ? process.env.GIT_CONFIG_GLOBAL : path3.join(homedir7(), ".gitconfig");
+  const localConfig = path3.join(rootDir, ".git", "config");
+  let excludesFile = await readGitconfigExcludesFilePath(localConfig) ?? await readGitconfigExcludesFilePath(globalConfig2);
+  if (!excludesFile) {
+    excludesFile = path3.join(process.env.XDG_CONFIG_HOME?.length ? process.env.XDG_CONFIG_HOME : path3.join(homedir7(), ".config"), "git", "ignore");
+  }
+  const candidates = [excludesFile, path3.join(rootDir, ".git", "info", "exclude")];
+  const existing = [];
+  for (const candidate of candidates)
+    if (await readIgnoreFile(candidate) !== null)
+      existing.push(candidate);
+  return existing;
+}
+async function loadGitExtraExcludeRuleSets(rootDir) {
+  const result = [];
+  for (const filePath of await resolveGitExtraExcludeFilePaths(rootDir)) {
+    const content = await readIgnoreFile(filePath);
+    if (content !== null)
+      result.push({ baseDir: "", matcher: import_ignore.default().add(content) });
+  }
+  return result;
+}
 async function readIgnoreFile(filePath) {
   try {
     return await readFile10(filePath, "utf-8");
@@ -110815,7 +110877,7 @@ 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 = [];
+  const result = normalizedDir ? [] : await loadGitExtraExcludeRuleSets(rootDir);
   for (const name of names) {
     const content = await readIgnoreFile(path3.join(absoluteDir, name));
     if (content === null)
@@ -110912,48 +110974,57 @@ async function walkWorkspaceFiles(rootDir, options) {
   const filePaths = [];
   const directoryStubs = [];
   let truncated = false;
-  async function visitDir(relDir, inheritedRuleSets, siblingCount) {
-    if (truncated || filePaths.length >= maxFilePaths) {
+  let currentLevel = [{ relDir: "", inheritedRuleSets: [], siblingCount: 0 }];
+  while (currentLevel.length > 0) {
+    if (filePaths.length >= maxFilePaths) {
       truncated = true;
-      return;
+      break;
     }
-    const localRuleSets = await loadDirectoryIgnoreRuleSets(rootDir, relDir);
-    const ruleSets = mergeWorkspaceIgnoreRuleSets(inheritedRuleSets, localRuleSets);
-    const dirents = await readWorkspaceDirectoryDirents(rootDir, relDir);
-    if (!dirents)
-      return;
-    for (const ent of dirents) {
-      if (truncated || filePaths.length >= maxFilePaths) {
+    const nextLevel = [];
+    for (const frame of currentLevel) {
+      if (filePaths.length >= maxFilePaths) {
         truncated = true;
-        return;
+        break;
       }
-      const relativePath = relDir ? `${relDir}/${ent.name}` : ent.name;
-      if (!isPathVisible(relativePath))
+      const localRuleSets = await loadDirectoryIgnoreRuleSets(rootDir, frame.relDir);
+      const ruleSets = mergeWorkspaceIgnoreRuleSets(frame.inheritedRuleSets, localRuleSets);
+      const dirents = await readWorkspaceDirectoryDirents(rootDir, frame.relDir);
+      if (!dirents)
         continue;
-      if (ent.isDirectory()) {
-        if (isPathIgnoredByRuleSets(ruleSets, relativePath))
-          continue;
-        const syncMode = classifyDirectorySyncMode(ent.name, {
-          relativePath,
-          immediateSiblingCount: siblingCount,
-          immediateChildCount: dirents.length
-        });
-        if (syncMode === "hidden")
+      for (const ent of dirents) {
+        const relativePath = frame.relDir ? `${frame.relDir}/${ent.name}` : ent.name;
+        if (!isPathVisible(relativePath))
           continue;
-        directoryStubs.push(relativePath);
-        if (syncMode === "shallow")
-          continue;
-        await visitDir(relativePath, ruleSets, dirents.length);
-      } else if (ent.isFile()) {
-        if (isPathIgnoredByRuleSets(ruleSets, relativePath))
-          continue;
-        filePaths.push(relativePath);
-        if (filePaths.length >= maxFilePaths)
-          truncated = true;
+        if (ent.isDirectory()) {
+          if (isPathIgnoredByRuleSets(ruleSets, relativePath))
+            continue;
+          const syncMode = classifyDirectorySyncMode(ent.name, {
+            relativePath,
+            immediateSiblingCount: frame.siblingCount,
+            immediateChildCount: dirents.length
+          });
+          if (syncMode === "hidden")
+            continue;
+          directoryStubs.push(relativePath);
+          if (syncMode === "full")
+            nextLevel.push({
+              relDir: relativePath,
+              inheritedRuleSets: ruleSets,
+              siblingCount: dirents.length
+            });
+        } else if (ent.isFile() && !isPathIgnoredByRuleSets(ruleSets, relativePath)) {
+          if (filePaths.length >= maxFilePaths) {
+            truncated = true;
+            continue;
+          }
+          filePaths.push(relativePath);
+          if (filePaths.length >= maxFilePaths)
+            truncated = true;
+        }
       }
     }
+    currentLevel = truncated ? [] : nextLevel;
   }
-  await visitDir("", [], 0);
   return { filePaths, directoryStubs, truncated };
 }
 var init_workspace_file_walk = __esm(() => {
@@ -110965,7 +111036,7 @@ var init_workspace_file_walk = __esm(() => {
 async function scanFileTree(rootDir, options) {
   const maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES;
   const scannedAt = Date.now();
-  const walk = await walkWorkspaceFiles(rootDir, { maxFilePaths: maxEntries });
+  const walk = await walkWorkspaceFiles(rootDir, { maxFilePaths: DEFAULT_CANDIDATE_FILE_PATHS });
   const filteredPaths = walk.filePaths.filter((p) => !isExcluded(p));
   const filteredStubs = walk.directoryStubs.filter((p) => !isExcluded(p));
   const entries2 = buildEntries(filteredPaths, filteredStubs, maxEntries);
@@ -110982,30 +111053,35 @@ function entryDepth(entryPath) {
   return entryPath.split("/").length;
 }
 function buildEntries(filePaths, directoryStubs, maxEntries) {
-  const directories = new Set(directoryStubs);
-  for (const filePath of filePaths) {
-    const parts2 = filePath.split("/");
-    for (let i2 = 1;i2 < parts2.length; i2++) {
-      directories.add(parts2.slice(0, i2).join("/"));
-    }
+  const selected = new Map;
+  const data = countDataFilesByParent(filePaths);
+  const ranked = [...filePaths].sort((a, b) => compareRankedFiles(a, scoreFile(a, data), b, scoreFile(b, data)));
+  for (const file2 of ranked) {
+    const parts2 = file2.split("/");
+    const needed = [file2, ...parts2.slice(0, -1).map((_, i2) => parts2.slice(0, i2 + 1).join("/"))];
+    const missing = needed.filter((p) => !selected.has(p));
+    if (selected.size + missing.length > maxEntries)
+      continue;
+    for (const p of needed)
+      selected.set(p, { path: p, type: p === file2 ? "file" : "directory" });
   }
-  const entries2 = [
-    ...Array.from(directories).map((dir) => ({ path: dir, type: "directory" })),
-    ...filePaths.map((file2) => ({ path: file2, type: "file" }))
-  ];
-  const uniqueByPath = new Map;
-  for (const entry of entries2) {
-    uniqueByPath.set(entry.path, entry);
+  for (const dir of [...directoryStubs].sort((a, b) => entryDepth(a) - entryDepth(b) || a.localeCompare(b))) {
+    if (selected.has(dir))
+      continue;
+    if (selected.size >= maxEntries)
+      break;
+    selected.set(dir, { path: dir, type: "directory" });
   }
-  return Array.from(uniqueByPath.values()).sort((left3, right3) => {
+  return Array.from(selected.values()).sort((left3, right3) => {
     const depthDelta = entryDepth(left3.path) - entryDepth(right3.path);
     if (depthDelta !== 0)
       return depthDelta;
     return left3.path.localeCompare(right3.path);
-  }).slice(0, maxEntries);
+  });
 }
-var DEFAULT_MAX_ENTRIES = 1e4;
+var DEFAULT_MAX_ENTRIES = 1e4, DEFAULT_CANDIDATE_FILE_PATHS = 50000;
 var init_file_tree_scanner = __esm(() => {
+  init_file_tree_sync_ranker();
   init_workspace_file_walk();
   init_workspace_visibility_policy();
 });
@@ -112041,12 +112117,12 @@ class NodeFsHandler {
     });
   }
   async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath3) {
-    const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
-    const tracked = parentDir.has(sp.basename(dir));
+    const parentDir2 = this.fsw._getWatchedDir(sp.dirname(dir));
+    const tracked = parentDir2.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));
+    parentDir2.add(sp.basename(dir));
     this.fsw._getWatchedDir(dir);
     let throttler;
     let closer;
@@ -113317,13 +113393,13 @@ function diffPathIndexes(previous, next4) {
 }
 
 // src/infrastructure/services/workspace/workspace-sync-state.ts
-import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { join as join24 } from "node:path";
 function workspaceKeyFor(workingDir) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
-  return createHash8("sha256").update(normalized).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function buildPathIndex(entries2) {
   const paths = {};
@@ -113397,7 +113473,7 @@ function entriesFromPathIndex(paths) {
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
-  SYNC_STATE_DIR = join24(homedir7(), ".chatroom", "sync-state");
+  SYNC_STATE_DIR = join24(homedir8(), ".chatroom", "sync-state");
 });
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
@@ -113547,11 +113623,6 @@ async function startWorkspaceFileTreeCoordinator(options) {
       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);
@@ -113644,137 +113715,899 @@ async function startWorkspaceFileTreeCoordinator(options) {
     await active2.stop();
     const fs12 = createWorkspaceFsWatcher({
       workingDir,
-      shouldIgnore: shouldIgnorePath,
-      onEvents: handleChangeSourceEvents,
-      onError: handleChangeSourceError
+      shouldIgnore: shouldIgnorePath,
+      onEvents: handleChangeSourceEvents,
+      onError: handleChangeSourceError
+    });
+    changeSource = fs12;
+    await fs12.ready;
+    console.log("[workspace-file-tree] change source: fs (degraded from git)");
+  };
+  const change = await createWorkspaceChangeSource({
+    workingDir,
+    pollIntervalMs: options.changeSourcePollIntervalMs,
+    shouldIgnore: shouldIgnorePath,
+    getKnownPaths: () => manifest.paths,
+    onEvents: handleChangeSourceEvents,
+    onNeedsReconcile: () => enqueueSerial(reconcileNow),
+    onError: handleChangeSourceError,
+    onPersistentFailure: () => degradeGitToFs("persistent git poll failures")
+  });
+  changeSource = change.source;
+  changeSourceMode = change.mode;
+  if (change.mode === "git") {
+    console.log(`[workspace-file-tree] change source: git (${change.gitRepoCount ?? 1} repo${(change.gitRepoCount ?? 1) === 1 ? "" : "s"})`);
+  } else {
+    console.log("[workspace-file-tree] change source: fs");
+  }
+  await changeSource.ready;
+  scheduleReconcile();
+  return {
+    workingDir,
+    getManifest: () => manifest,
+    getTree: () => treeFromManifest(manifest),
+    checkpoint: () => enqueueSerial(publishCheckpoint),
+    reconcile: () => enqueueSerial(reconcileNow),
+    stop: async () => {
+      stopped = true;
+      if (reconcileTimer)
+        clearTimeout(reconcileTimer);
+      reconcileTimer = null;
+      await changeSource?.stop();
+      changeSource = null;
+      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_git_workspace_porcelain();
+  init_workspace_change_source();
+  init_workspace_fs_watcher();
+  init_workspace_ignore();
+  init_workspace_sync_state();
+  DEFAULT_RECONCILE_INTERVAL_MS = 10 * 60 * 1000;
+});
+
+// src/infrastructure/services/workspace/workspace-sync-config.ts
+var FILE_TREE_SYNC_DEBOUNCE_MS = 5000;
+
+// 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 = { drainPromise: null, pendingTask: null, scheduled: false };
+    queues.set(key, state);
+  }
+  return state;
+}
+function sleep7(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+async function drainQueue(state, key, debounceMs) {
+  try {
+    while (state.pendingTask) {
+      const lastCompletedAt = lastCompletedAtByKey.get(key) ?? 0;
+      const elapsed3 = Date.now() - lastCompletedAt;
+      const waitMs = lastCompletedAt === 0 ? 0 : Math.max(0, debounceMs - elapsed3);
+      if (waitMs > 0) {
+        await sleep7(waitMs);
+      }
+      const task = state.pendingTask;
+      if (!task)
+        break;
+      state.pendingTask = null;
+      await task();
+      lastCompletedAtByKey.set(key, Date.now());
+    }
+  } finally {
+    state.drainPromise = null;
+    state.scheduled = false;
+    if (state.pendingTask) {
+      kickDrain(state, key, debounceMs);
+    } else {
+      queues.delete(key);
+    }
+  }
+}
+function kickDrain(state, key, debounceMs) {
+  if (state.scheduled || state.drainPromise)
+    return;
+  state.scheduled = true;
+  state.drainPromise = new Promise((resolve8, reject) => {
+    queueMicrotask(() => {
+      drainQueue(state, key, debounceMs).then(resolve8, reject);
+    });
+  });
+}
+async function enqueueFileTreeSync(machineId, workingDir, task, options) {
+  const debounceMs = options?.debounceMs ?? FILE_TREE_SYNC_DEBOUNCE_MS;
+  const key = queueKey(machineId, workingDir);
+  const state = getOrCreateState(key);
+  state.pendingTask = task;
+  kickDrain(state, key, debounceMs);
+  return state.drainPromise ?? Promise.resolve();
+}
+var queues, lastCompletedAtByKey;
+var init_workspace_sync_queue = __esm(() => {
+  queues = new Map;
+  lastCompletedAtByKey = new Map;
+});
+
+// src/daemon/infrastructure/outbox/lib/durable-coalescing-state-schema.ts
+var DURABLE_COALESCING_STATE_MIGRATIONS;
+var init_durable_coalescing_state_schema = __esm(() => {
+  DURABLE_COALESCING_STATE_MIGRATIONS = [
+    `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS coalescing_outbox_entries (delivery_key TEXT PRIMARY KEY, payload_json TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', attempts INTEGER NOT NULL DEFAULT 0, last_error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`
+  ];
+});
+
+// src/daemon/infrastructure/outbox/lib/durable-coalescing-state-store.ts
+import { mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function openDurableCoalescingStateStore(path8) {
+  mkdirSync6(dirname12(path8), { recursive: true });
+  const db = new DatabaseSync(path8);
+  for (const sql of DURABLE_COALESCING_STATE_MIGRATIONS)
+    db.exec(sql);
+  db.prepare("UPDATE coalescing_outbox_entries SET status='pending' WHERE status='in_flight'").run();
+  return { upsertPending: (key, payload) => {
+    const now = Date.now();
+    db.prepare("INSERT INTO coalescing_outbox_entries(delivery_key,payload_json,status,created_at,updated_at) VALUES(?,?,'pending',?,?) ON CONFLICT(delivery_key) DO UPDATE SET payload_json=excluded.payload_json,status='pending',updated_at=excluded.updated_at").run(key, payload, now, now);
+  }, getPending: (key) => db.prepare("SELECT payload_json as payloadJson, attempts FROM coalescing_outbox_entries WHERE delivery_key=? AND status IN ('pending','in_flight')").get(key) ?? null, markDone: (key) => {
+    db.prepare("DELETE FROM coalescing_outbox_entries WHERE delivery_key=?").run(key);
+  }, markPendingRetry: (key, error51) => {
+    db.prepare("UPDATE coalescing_outbox_entries SET status='pending',last_error=?,attempts=attempts+1,updated_at=? WHERE delivery_key=?").run(String(error51), Date.now(), key);
+  }, listPendingKeys: () => db.prepare("SELECT delivery_key as key FROM coalescing_outbox_entries WHERE status IN ('pending','in_flight')").all().map((r) => String(r.key)), close: () => db.close() };
+}
+var init_durable_coalescing_state_store = __esm(() => {
+  init_durable_coalescing_state_schema();
+});
+
+// src/daemon/infrastructure/outbox/lib/outbox-retry-backoff.ts
+function computeExponentialRetryDelayMs(attempt, retryDelayMs, maxRetryDelayMs) {
+  const exponent = Math.min(Math.max(0, attempt), MAX_RETRY_EXPONENT);
+  return Math.min(retryDelayMs * 2 ** exponent, maxRetryDelayMs);
+}
+var MAX_RETRY_EXPONENT = 20;
+
+// src/daemon/infrastructure/outbox/lib/coalescing-state-outbox.ts
+function createCoalescingStateOutbox(options) {
+  const durable = [options.store, options.deliveryKey, options.serialize, options.deserialize];
+  if (durable.some(Boolean) && durable.some((value) => !value))
+    throw new Error("Durable outbox requires store, deliveryKey, serialize, and deserialize");
+  const minIntervalMs = options.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  const maxRetryDelayMs = options.maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+  let pending3 = null;
+  let inFlight2 = null;
+  let timer = null;
+  let lastSentAt = 0;
+  let retryAttempt = 0;
+  let stopped = false;
+  if (options.store && options.deliveryKey && options.deserialize) {
+    const recovered = options.store.getPending(options.deliveryKey);
+    if (recovered) {
+      pending3 = { state: options.deserialize(recovered.payloadJson), waiters: [] };
+      retryAttempt = recovered.attempts;
+    }
+  }
+  const rejectWaiters = (waiters, error51) => {
+    for (const waiter of waiters)
+      waiter.reject(error51);
+  };
+  const mergePending = (older, newer) => ({
+    state: newer?.state ?? older.state,
+    waiters: [...older.waiters, ...newer?.waiters ?? []]
+  });
+  const clearTimer = () => {
+    if (timer)
+      clearTimeout(timer);
+    timer = null;
+  };
+  const schedule2 = (delayMs) => {
+    if (stopped || !pending3 || inFlight2 || timer)
+      return;
+    timer = setTimeout(() => {
+      timer = null;
+      drain2().catch(() => {
+        return;
+      });
+    }, Math.max(0, delayMs));
+    timer.unref?.();
+  };
+  if (pending3) {
+    schedule2(retryAttempt > 0 ? computeExponentialRetryDelayMs(retryAttempt - 1, retryDelayMs, maxRetryDelayMs) : 0);
+  }
+  async function drain2() {
+    if (stopped || !pending3 || inFlight2)
+      return;
+    const batch = pending3;
+    pending3 = null;
+    const sendPromise = Promise.resolve().then(() => options.send(batch.state));
+    inFlight2 = { ...batch, promise: sendPromise };
+    let retryDelay = null;
+    const store = options.store;
+    const deliveryKey = options.deliveryKey;
+    try {
+      const result = await sendPromise;
+      lastSentAt = Date.now();
+      retryAttempt = 0;
+      if (store && deliveryKey)
+        store.markDone(deliveryKey);
+      for (const waiter of batch.waiters)
+        waiter.resolve(result);
+    } catch (error51) {
+      options.onError?.(error51);
+      if (store && deliveryKey)
+        store.markPendingRetry(deliveryKey, error51);
+      pending3 = mergePending(batch, pending3);
+      retryDelay = computeExponentialRetryDelayMs(retryAttempt, retryDelayMs, maxRetryDelayMs);
+      retryAttempt++;
+      throw error51;
+    } finally {
+      inFlight2 = null;
+      if (pending3) {
+        const intervalDelay = Math.max(0, minIntervalMs - (Date.now() - lastSentAt));
+        schedule2(retryDelay ?? intervalDelay);
+      }
+    }
+  }
+  const enqueue = (state) => {
+    if (stopped)
+      return Promise.reject(new Error("Outbox is stopped"));
+    const promise4 = new Promise((resolve8, reject) => {
+      const waiter = { resolve: resolve8, reject };
+      if (pending3) {
+        pending3 = { state, waiters: [...pending3.waiters, waiter] };
+      } else {
+        pending3 = { state, waiters: [waiter] };
+      }
+      if (options.store && options.deliveryKey && options.serialize) {
+        options.store.upsertPending(options.deliveryKey, options.serialize(state));
+      }
+    });
+    if (!inFlight2 && !timer) {
+      const delay3 = lastSentAt === 0 ? 0 : Math.max(0, minIntervalMs - (Date.now() - lastSentAt));
+      schedule2(delay3);
+    }
+    return promise4;
+  };
+  const flushNow = async () => {
+    if (stopped)
+      return;
+    clearTimer();
+    if (inFlight2) {
+      await inFlight2.promise.catch(() => {
+        return;
+      });
+    }
+    if (pending3)
+      await drain2();
+  };
+  const stop4 = async () => {
+    if (stopped)
+      return;
+    await flushNow();
+    stopped = true;
+    clearTimer();
+    if (inFlight2)
+      await inFlight2.promise.catch(() => {
+        return;
+      });
+    const unsent = pending3;
+    pending3 = null;
+    if (unsent)
+      rejectWaiters(unsent.waiters, new Error("Outbox stopped before send completed"));
+  };
+  return { enqueue, flushNow, stop: stop4 };
+}
+var DEFAULT_MIN_INTERVAL_MS = 5000, DEFAULT_RETRY_DELAY_MS = 500, DEFAULT_MAX_RETRY_DELAY_MS = 5000;
+var init_coalescing_state_outbox = () => {};
+
+// src/daemon/infrastructure/outbox/lib/keyed-coalescing-state-outbox-registry.ts
+function createKeyedCoalescingStateOutboxRegistry(options) {
+  const outboxes = new Map;
+  const getOrCreate = (key) => {
+    let outbox = outboxes.get(key);
+    if (!outbox) {
+      outbox = createCoalescingStateOutbox({
+        send: (state) => options.createSend(key)(state),
+        minIntervalMs: options.minIntervalMs,
+        retryDelayMs: options.retryDelayMs,
+        maxRetryDelayMs: options.maxRetryDelayMs,
+        onError: (error51) => options.onError?.(key, error51),
+        ...options.store ? { store: options.store, deliveryKey: key, serialize: options.serialize, deserialize: options.deserialize } : {}
+      });
+      outboxes.set(key, outbox);
+    }
+    return outbox;
+  };
+  const stop4 = async (key) => {
+    const outbox = outboxes.get(key);
+    outboxes.delete(key);
+    await outbox?.flushNow().catch(() => {
+      return;
+    });
+    await outbox?.stop().catch(() => {
+      return;
+    });
+  };
+  return {
+    enqueue: (key, state) => getOrCreate(key).enqueue(state),
+    stop: stop4,
+    stopAll: async () => {
+      for (const key of [...outboxes.keys()])
+        await stop4(key);
+      options.store?.close();
+    }
+  };
+}
+var init_keyed_coalescing_state_outbox_registry = __esm(() => {
+  init_coalescing_state_outbox();
+});
+
+// src/daemon/infrastructure/outbox/outbox-db-path.ts
+import { homedir as homedir9 } from "node:os";
+import { join as join25 } from "node:path";
+function resolveOutboxDbPath(machineId, kind) {
+  return join25(homedir9(), ".chatroom", "daemon", machineId, `outbox-${kind}.sqlite`);
+}
+var init_outbox_db_path = () => {};
+
+// src/daemon/infrastructure/outbox/workspace-file-tree-checkpoint-outbox.ts
+function createWorkspaceFileTreeCheckpointOutboxRegistry(machineId, createSend, options) {
+  return createKeyedCoalescingStateOutboxRegistry({
+    store: openDurableCoalescingStateStore(resolveOutboxDbPath(machineId, "file-tree-checkpoint")),
+    serialize: JSON.stringify,
+    deserialize: JSON.parse,
+    createSend,
+    minIntervalMs: WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MIN_INTERVAL_MS,
+    retryDelayMs: WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_RETRY_DELAY_MS,
+    maxRetryDelayMs: WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MAX_RETRY_DELAY_MS,
+    onError: options?.onError
+  });
+}
+var WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MIN_INTERVAL_MS = 5000, WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_RETRY_DELAY_MS = 5000, WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MAX_RETRY_DELAY_MS;
+var init_workspace_file_tree_checkpoint_outbox = __esm(() => {
+  init_durable_coalescing_state_store();
+  init_keyed_coalescing_state_outbox_registry();
+  init_outbox_db_path();
+  WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MAX_RETRY_DELAY_MS = 5 * 60000;
+});
+
+// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-schema.ts
+var DURABLE_FIFO_QUEUE_MIGRATIONS;
+var init_durable_fifo_queue_schema = __esm(() => {
+  DURABLE_FIFO_QUEUE_MIGRATIONS = [
+    `CREATE TABLE IF NOT EXISTS schema_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+    `CREATE TABLE IF NOT EXISTS fifo_outbox_entries (id INTEGER PRIMARY KEY AUTOINCREMENT, delivery_key TEXT NOT NULL, payload_json TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', attempts INTEGER NOT NULL DEFAULT 0, last_error TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL)`,
+    `CREATE INDEX IF NOT EXISTS idx_fifo_outbox_pending ON fifo_outbox_entries(delivery_key, status, id)`
+  ];
+});
+
+// src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { mkdirSync as mkdirSync7 } from "node:fs";
+import { dirname as dirname13 } from "node:path";
+function openDurableFifoQueueStore(dbPath) {
+  mkdirSync7(dirname13(dbPath), { recursive: true });
+  const db = new DatabaseSync2(dbPath);
+  for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
+    db.exec(sql);
+  db.prepare("UPDATE fifo_outbox_entries SET status='pending', updated_at=? WHERE status='in_flight'").run(Date.now());
+  return {
+    enqueue: (key, payloadJson) => {
+      const now = Date.now();
+      return Number(db.prepare("INSERT INTO fifo_outbox_entries(delivery_key,payload_json,created_at,updated_at) VALUES(?,?,?,?) RETURNING id").get(key, payloadJson, now, now).id);
+    },
+    claimNextBatch: (key, limit) => db.prepare("UPDATE fifo_outbox_entries SET status='in_flight', attempts=attempts+1, updated_at=? WHERE id IN (SELECT id FROM fifo_outbox_entries WHERE delivery_key=? AND status='pending' ORDER BY id LIMIT ?) RETURNING id, delivery_key as deliveryKey, payload_json as payloadJson, attempts").all(Date.now(), key, limit),
+    markDone: (id3) => {
+      db.prepare("DELETE FROM fifo_outbox_entries WHERE id=?").run(id3);
+    },
+    markPending: (id3) => {
+      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=NULL, updated_at=? WHERE id=?").run(Date.now(), id3);
+    },
+    updatePayload: (id3, payloadJson) => {
+      db.prepare("UPDATE fifo_outbox_entries SET payload_json=?, updated_at=? WHERE id=?").run(payloadJson, Date.now(), id3);
+    },
+    markPendingRetry: (id3, error51) => {
+      db.prepare("UPDATE fifo_outbox_entries SET status='pending', last_error=?, updated_at=? WHERE id=?").run(String(error51), Date.now(), id3);
+    },
+    listPendingForRecovery: (key) => db.prepare("SELECT id, delivery_key as deliveryKey, payload_json as payloadJson, attempts FROM fifo_outbox_entries WHERE delivery_key=? AND status IN ('pending','in_flight') ORDER BY id").all(key),
+    close: () => db.close()
+  };
+}
+var init_durable_fifo_queue_store = __esm(() => {
+  init_durable_fifo_queue_schema();
+});
+
+// src/daemon/infrastructure/outbox/lib/fifo-batched-outbox.ts
+function createFifoBatchedOutbox(o) {
+  const waiters = new Map;
+  let running3;
+  let stopped = false;
+  let retryTimer;
+  let retryAttempt = 0;
+  const retryDelay = () => computeExponentialRetryDelayMs(retryAttempt++, o.retryDelayMs ?? 500, o.maxRetryDelayMs ?? 5000);
+  const scheduleRetry = () => {
+    if (!stopped && !retryTimer) {
+      retryTimer = setTimeout(() => {
+        retryTimer = undefined;
+        drain2().catch(() => {
+          return;
+        });
+      }, retryDelay());
+      retryTimer.unref?.();
+    }
+  };
+  const drain2 = async () => {
+    if (running3)
+      return running3;
+    running3 = (async () => {
+      while (true) {
+        const rows2 = o.store.claimNextBatch(o.deliveryKey, o.batchSize);
+        if (!rows2.length)
+          break;
+        try {
+          const results = await o.send(rows2.map((r) => o.deserialize(r.payloadJson)));
+          let hasRetry = false;
+          for (let i2 = 0;i2 < results.length; i2++) {
+            const item = o.deserialize(rows2[i2].payloadJson);
+            const outcome = o.classifyOutcome?.(results[i2], item) ?? { kind: "success" };
+            if (outcome.kind === "retry") {
+              o.store.updatePayload(rows2[i2].id, o.serialize(outcome.item));
+              o.store.markPending(rows2[i2].id);
+              hasRetry = true;
+              continue;
+            }
+            o.store.markDone(rows2[i2].id);
+            waiters.get(rows2[i2].id)?.resolve(results[i2]);
+            waiters.delete(rows2[i2].id);
+          }
+          for (let i2 = results.length;i2 < rows2.length; i2++)
+            o.store.markPending(rows2[i2].id);
+          if (hasRetry) {
+            scheduleRetry();
+            break;
+          }
+          retryAttempt = 0;
+        } catch (e) {
+          o.onError?.(e);
+          for (const r of rows2)
+            o.store.markPendingRetry(r.id, e);
+          scheduleRetry();
+          break;
+        }
+      }
+    })().finally(() => {
+      running3 = undefined;
+    });
+    return running3;
+  };
+  const enqueue = (item) => {
+    if (stopped)
+      return Promise.reject(new Error("Outbox is stopped"));
+    const id3 = o.store.enqueue(o.deliveryKey, o.serialize(item));
+    const p = new Promise((resolve8, reject) => waiters.set(id3, { resolve: resolve8, reject }));
+    drain2().catch(() => {
+      return;
+    });
+    return p;
+  };
+  const flushNow = async () => {
+    while (o.store.listPendingForRecovery(o.deliveryKey).length) {
+      await drain2();
+    }
+  };
+  const stop4 = async () => {
+    if (stopped)
+      return;
+    if (retryTimer)
+      clearTimeout(retryTimer);
+    retryTimer = undefined;
+    await flushNow();
+    stopped = true;
+  };
+  return { enqueue, flushNow, stop: stop4 };
+}
+var init_fifo_batched_outbox = () => {};
+
+// src/daemon/infrastructure/outbox/lib/keyed-fifo-batched-outbox-registry.ts
+function createKeyedFifoBatchedOutboxRegistry(o) {
+  const boxes = new Map;
+  const get13 = (key) => {
+    let b = boxes.get(key);
+    if (!b) {
+      b = createFifoBatchedOutbox({
+        batchSize: o.batchSize,
+        send: o.createSend(key),
+        store: o.store,
+        deliveryKey: key,
+        serialize: o.serialize,
+        deserialize: o.deserialize,
+        retryDelayMs: o.retryDelayMs,
+        maxRetryDelayMs: o.maxRetryDelayMs,
+        onError: (e) => o.onError?.(key, e),
+        classifyOutcome: o.classifyOutcome
+      });
+      boxes.set(key, b);
+    }
+    return b;
+  };
+  const stop4 = async (k) => {
+    const b = boxes.get(k);
+    if (b) {
+      await b.stop();
+      boxes.delete(k);
+    }
+  };
+  return {
+    enqueue: (k, i2) => get13(k).enqueue(i2),
+    flushNow: async (k) => {
+      if (k)
+        await get13(k).flushNow();
+      else
+        for (const b of boxes.values())
+          await b.flushNow();
+    },
+    stop: stop4,
+    stopAll: async () => {
+      for (const k of [...boxes.keys()])
+        await stop4(k);
+      o.store.close();
+    }
+  };
+}
+var init_keyed_fifo_batched_outbox_registry = __esm(() => {
+  init_fifo_batched_outbox();
+});
+
+// src/daemon/infrastructure/outbox/workspace-file-tree-delta-outbox.ts
+function createWorkspaceFileTreeDeltaOutboxRegistry(machineId, createSend, options) {
+  const store = openDurableFifoQueueStore(resolveOutboxDbPath(machineId, "file-tree-delta"));
+  return createKeyedFifoBatchedOutboxRegistry({
+    store,
+    batchSize: options?.batchSize ?? WORKSPACE_FILE_TREE_DELTA_OUTBOX_BATCH_SIZE,
+    createSend: (key) => async (units) => {
+      const out = [];
+      for (const u of units) {
+        const r = await createSend(key)(u);
+        out.push(r);
+      }
+      return out;
+    },
+    serialize: JSON.stringify,
+    deserialize: JSON.parse,
+    retryDelayMs: WORKSPACE_FILE_TREE_DELTA_OUTBOX_RETRY_DELAY_MS,
+    maxRetryDelayMs: WORKSPACE_FILE_TREE_DELTA_OUTBOX_MAX_RETRY_DELAY_MS,
+    onError: options?.onError,
+    classifyOutcome: (result, unit) => result.status === "conflict" ? { kind: "retry", item: { ...unit, baseRevision: result.revision } } : { kind: "success" }
+  });
+}
+var WORKSPACE_FILE_TREE_DELTA_OUTBOX_BATCH_SIZE = 5, WORKSPACE_FILE_TREE_DELTA_OUTBOX_RETRY_DELAY_MS = 5000, WORKSPACE_FILE_TREE_DELTA_OUTBOX_MAX_RETRY_DELAY_MS;
+var init_workspace_file_tree_delta_outbox = __esm(() => {
+  init_durable_fifo_queue_store();
+  init_keyed_fifo_batched_outbox_registry();
+  init_outbox_db_path();
+  WORKSPACE_FILE_TREE_DELTA_OUTBOX_MAX_RETRY_DELAY_MS = 5 * 60000;
+});
+
+// src/daemon/infrastructure/outbox/index.ts
+var init_outbox = __esm(() => {
+  init_workspace_file_tree_checkpoint_outbox();
+  init_workspace_file_tree_delta_outbox();
+});
+
+// ../../services/backend/src/domain/workspace-file-tree/types.ts
+var MAX_TREE_JSON_BYTES;
+var init_types2 = __esm(() => {
+  MAX_TREE_JSON_BYTES = 900 * 1024;
+});
+// ../../services/backend/src/domain/workspace-file-tree/select-strategy.ts
+function treeJsonByteLength(tree) {
+  return Buffer.byteLength(JSON.stringify(tree), "utf8");
+}
+function selectFileTreeSnapshotStrategyId(tree) {
+  return treeJsonByteLength(tree) > MAX_TREE_JSON_BYTES ? "sharded" : "blob";
+}
+var init_select_strategy = __esm(() => {
+  init_types2();
+});
+
+// ../../services/backend/src/domain/workspace-file-tree/registry.ts
+var init_registry5 = __esm(() => {
+  init_select_strategy();
+});
+// ../../services/backend/src/domain/workspace-file-tree/transport/blob-snapshot.ts
+function toLegacyBlobSyncArgs(payload) {
+  return { data: payload.data, dataHash: payload.dataHash, scannedAt: payload.scannedAt };
+}
+
+// ../../services/backend/src/domain/workspace-file-tree/transport/sharded-snapshot.ts
+function toLegacyShardBatchItem(shard) {
+  return { ...shard };
+}
+function toLegacyManifestSyncArgs(manifest) {
+  return { ...manifest };
+}
+// ../../services/backend/src/domain/workspace-file-tree/transport/index.ts
+var init_transport = () => {};
+
+// ../../services/backend/src/domain/workspace-file-tree/index.ts
+var init_workspace_file_tree = __esm(() => {
+  init_types2();
+  init_select_strategy();
+  init_registry5();
+  init_transport();
+});
+
+// src/infrastructure/services/workspace/transport/blob-snapshot-publish.ts
+import { gzipSync as gzipSync2 } from "node:zlib";
+function buildBlobSnapshotPayload(tree, dataHash) {
+  const compressed = gzipSync2(Buffer.from(JSON.stringify(tree))).toString("base64");
+  return {
+    data: { compression: "gzip", content: compressed },
+    dataHash,
+    scannedAt: tree.scannedAt
+  };
+}
+async function publishBlobSnapshot(session2, workingDir, payload) {
+  await session2.backend.mutation(api.workspaceFiles.syncFileTreeV2, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir,
+    ...toLegacyBlobSyncArgs(payload)
+  });
+  return {
+    strategyId: "blob",
+    snapshotId: payload.dataHash,
+    scannedAt: payload.scannedAt,
+    entryCount: 0
+  };
+}
+var init_blob_snapshot_publish = __esm(() => {
+  init_api3();
+});
+
+// src/infrastructure/services/workspace/file-tree-partition.ts
+import { createHash as createHash8 } from "node:crypto";
+import { gzipSync as gzipSync3 } from "node:zlib";
+function computeShardDataHash(payload) {
+  return createHash8("md5").update(JSON.stringify(payload)).digest("hex");
+}
+function shardIdForPath(path8) {
+  const slash = path8.indexOf("/");
+  return slash === -1 ? "__root__" : path8.slice(0, slash);
+}
+function childShardId(path8, parentShardId) {
+  if (parentShardId === "__root__") {
+    return shardIdForPath(path8);
+  }
+  if (path8 === parentShardId) {
+    return parentShardId;
+  }
+  const prefix = `${parentShardId}/`;
+  if (!path8.startsWith(prefix)) {
+    return parentShardId;
+  }
+  const remainder = path8.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 subdivideShardGroup(subgroups, tree) {
+  const shards = [];
+  for (const [subId, subEntries] of subgroups) {
+    shards.push(...prepareShardGroup(subEntries, subId, tree));
+  }
+  return shards;
+}
+function shouldSkipParentCompression(subgroups, entryCount) {
+  return subgroups.size > 1 && entryCount > LARGE_SHARD_ENTRY_THRESHOLD;
+}
+function prepareShardGroup(entries2, shardId, tree) {
+  const subgroups = groupEntriesByShardId(entries2, shardId);
+  if (shouldSkipParentCompression(subgroups, entries2.length)) {
+    return subdivideShardGroup(subgroups, 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 || subgroups.size <= 1) {
+    return [buildPreparedShard(shardId, payload)];
+  }
+  return subdivideShardGroup(subgroups, tree);
+}
+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_BYTES2, MAX_SHARD_JSON_BYTES, MAX_SHARD_BATCH_SIZE = 8, LARGE_SHARD_ENTRY_THRESHOLD = 50000;
+var init_file_tree_partition = __esm(() => {
+  init_workspace_file_tree();
+  MAX_TREE_JSON_BYTES2 = 900 * 1024;
+  MAX_SHARD_JSON_BYTES = 800 * 1024;
+});
+
+// src/infrastructure/services/workspace/transport/sharded-snapshot-publish.ts
+async function publishShardedSnapshot(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);
+    const items = batch.map((s) => ({
+      shardId: s.shardId,
+      data: s.data,
+      dataHash: s.dataHash,
+      scannedAt: tree.scannedAt,
+      entryCount: s.entryCount
+    }));
+    await session2.backend.mutation(api.workspaceFiles.syncFileTreeShardV3Batch, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      workingDir,
+      syncGeneration,
+      items: items.map(toLegacyShardBatchItem)
     });
-    changeSource = fs12;
-    await fs12.ready;
-    console.log("[workspace-file-tree] change source: fs (degraded from git)");
+    for (const s of batch)
+      shardIds.push(s.shardId);
+  }
+  const manifest = {
+    syncGeneration,
+    shardIds,
+    totalEntryCount: tree.entries.length,
+    complete: true,
+    scannedAt: tree.scannedAt
   };
-  const change = await createWorkspaceChangeSource({
+  await session2.backend.mutation(api.workspaceFiles.syncFileTreeManifestV3, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
     workingDir,
-    pollIntervalMs: options.changeSourcePollIntervalMs,
-    shouldIgnore: shouldIgnorePath,
-    getKnownPaths: () => manifest.paths,
-    onEvents: handleChangeSourceEvents,
-    onNeedsReconcile: () => enqueueSerial(reconcileNow),
-    onError: handleChangeSourceError,
-    onPersistentFailure: () => degradeGitToFs("persistent git poll failures")
+    ...toLegacyManifestSyncArgs(manifest)
   });
-  changeSource = change.source;
-  changeSourceMode = change.mode;
-  if (change.mode === "git") {
-    console.log(`[workspace-file-tree] change source: git (${change.gitRepoCount ?? 1} repo${(change.gitRepoCount ?? 1) === 1 ? "" : "s"})`);
-  } else {
-    console.log("[workspace-file-tree] change source: fs");
-  }
-  await changeSource.ready;
-  scheduleReconcile();
   return {
-    workingDir,
-    getManifest: () => manifest,
-    getTree: () => treeFromManifest(manifest),
-    checkpoint: () => enqueueSerial(publishCheckpoint),
-    reconcile: () => enqueueSerial(reconcileNow),
-    stop: async () => {
-      stopped = true;
-      if (reconcileTimer)
-        clearTimeout(reconcileTimer);
-      reconcileTimer = null;
-      await changeSource?.stop();
-      changeSource = null;
-      await serial;
-      await saveWorkspaceSyncManifest(manifest);
-    }
+    strategyId: "sharded",
+    snapshotId: syncGeneration,
+    scannedAt: tree.scannedAt,
+    entryCount: tree.entries.length
   };
 }
-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_git_workspace_porcelain();
-  init_workspace_change_source();
-  init_workspace_fs_watcher();
-  init_workspace_ignore();
-  init_workspace_sync_state();
-  DEFAULT_RECONCILE_INTERVAL_MS = 10 * 60 * 1000;
+var init_sharded_snapshot_publish = __esm(() => {
+  init_api3();
+  init_file_tree_partition();
 });
 
-// src/infrastructure/services/workspace/workspace-sync-config.ts
-var FILE_TREE_SYNC_DEBOUNCE_MS = 5000;
-
-// src/infrastructure/services/workspace/workspace-sync-queue.ts
-function queueKey(machineId, workingDir) {
-  return `${machineId}\x00${workingDir}`;
+// src/daemon/infrastructure/outbox/workspace-file-tree-checkpoint-send.ts
+import { randomUUID as randomUUID11 } from "node:crypto";
+function needsMoreCheckpointPrune(result) {
+  return (result.status === "published" || result.status === "unchanged") && result.pruneComplete === false;
 }
-function getOrCreateState(key) {
-  let state = queues.get(key);
-  if (!state) {
-    state = { drainPromise: null, pendingTask: null, scheduled: false };
-    queues.set(key, state);
+function assertCheckpointAccepted(result) {
+  if (result.status === "snapshot-missing" || result.status === "resync-required") {
+    throw new Error(`File tree checkpoint rejected: ${result.status}`);
   }
-  return state;
 }
-function sleep7(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
-}
-async function drainQueue(state, key, debounceMs) {
-  try {
-    while (state.pendingTask) {
-      const lastCompletedAt = lastCompletedAtByKey.get(key) ?? 0;
-      const elapsed3 = Date.now() - lastCompletedAt;
-      const waitMs = lastCompletedAt === 0 ? 0 : Math.max(0, debounceMs - elapsed3);
-      if (waitMs > 0) {
-        await sleep7(waitMs);
-      }
-      const task = state.pendingTask;
-      if (!task)
-        break;
-      state.pendingTask = null;
-      await task();
-      lastCompletedAtByKey.set(key, Date.now());
-    }
-  } finally {
-    state.drainPromise = null;
-    state.scheduled = false;
-    if (state.pendingTask) {
-      kickDrain(state, key, debounceMs);
-    } else {
-      queues.delete(key);
-    }
+async function syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHash, syncGeneration) {
+  if (selectFileTreeSnapshotStrategyId(tree) === "sharded") {
+    const ref2 = await publishShardedSnapshot(session2, normalizedWorkingDir, tree, syncGeneration);
+    return { strategyId: ref2.strategyId, snapshotId: ref2.snapshotId };
   }
+  const ref = await publishBlobSnapshot(session2, normalizedWorkingDir, buildBlobSnapshotPayload(tree, dataHash));
+  return { strategyId: ref.strategyId, snapshotId: ref.snapshotId };
 }
-function kickDrain(state, key, debounceMs) {
-  if (state.scheduled || state.drainPromise)
-    return;
-  state.scheduled = true;
-  state.drainPromise = new Promise((resolve8, reject) => {
-    queueMicrotask(() => {
-      drainQueue(state, key, debounceMs).then(resolve8, reject);
-    });
+async function publishCheckpointUntilPruned(session2, normalizedWorkingDir, snapshot, revision) {
+  let checkpointRevision = revision;
+  const publish = () => session2.backend.mutation(api.workspaceFiles.publishFileTreeCheckpoint, {
+    sessionId: session2.sessionId,
+    machineId: session2.machineId,
+    workingDir: normalizedWorkingDir,
+    revision: checkpointRevision,
+    ...snapshot
   });
+  let result = await publish();
+  if (result.status === "resync-required") {
+    checkpointRevision = result.expectedRevision + 1;
+    result = await publish();
+  }
+  while (needsMoreCheckpointPrune(result))
+    result = await publish();
+  assertCheckpointAccepted(result);
+  return checkpointRevision;
 }
-async function enqueueFileTreeSync(machineId, workingDir, task, options) {
-  const debounceMs = options?.debounceMs ?? FILE_TREE_SYNC_DEBOUNCE_MS;
-  const key = queueKey(machineId, workingDir);
-  const state = getOrCreateState(key);
-  state.pendingTask = task;
-  kickDrain(state, key, debounceMs);
-  return state.drainPromise ?? Promise.resolve();
+function createWorkspaceFileTreeCheckpointSend(session2, normalizedWorkingDir) {
+  return async (state) => {
+    const snapshot = await syncScannedFileTree(session2, normalizedWorkingDir, state.tree, computeFileTreeDataHash(state.tree), randomUUID11());
+    const revision = await publishCheckpointUntilPruned(session2, normalizedWorkingDir, snapshot, state.revision);
+    return { revision };
+  };
 }
-var queues, lastCompletedAtByKey;
-var init_workspace_sync_queue = __esm(() => {
-  queues = new Map;
-  lastCompletedAtByKey = new Map;
+var init_workspace_file_tree_checkpoint_send = __esm(() => {
+  init_workspace_file_tree();
+  init_api3();
+  init_file_tree_data_hash();
+  init_blob_snapshot_publish();
+  init_sharded_snapshot_publish();
+});
+
+// src/daemon/infrastructure/outbox/workspace-file-tree-delta-send.ts
+function toDeltaOperations(delta) {
+  return [
+    ...delta.added.map((entry) => ({
+      o: "a",
+      p: entry.path,
+      e: entry.type === "directory" ? "d" : "f"
+    })),
+    ...delta.removed.map((entryPath) => ({
+      o: "r",
+      p: entryPath
+    })),
+    ...delta.typeChanged.map((entry) => ({
+      o: "t",
+      p: entry.path,
+      e: entry.type === "directory" ? "d" : "f"
+    }))
+  ];
+}
+function createWorkspaceFileTreeDeltaSend(session2, normalizedWorkingDir) {
+  return async (unit) => {
+    const result = await session2.backend.mutation(api.workspaceFiles.applyFileTreeDeltaBatch, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      workingDir: normalizedWorkingDir,
+      operationId: unit.delta.operationId,
+      baseRevision: unit.baseRevision,
+      operations: toDeltaOperations(unit.delta)
+    });
+    if (result.status === "resync-required") {
+      return { status: "conflict", revision: result.expectedRevision };
+    }
+    return result;
+  };
+}
+var init_workspace_file_tree_delta_send = __esm(() => {
+  init_api3();
 });
 
 // src/daemon/entry/files/file-tree-subscription.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
 function logSubscriptionWarn(label, err) {
   console.warn(`[${formatTimestamp()}] ⚠️  ${label}: ${getErrorMessage(err)}`);
 }
-async function stopCoordinatorForWorkingDir(coordinators, normalized) {
+async function stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized) {
   const coordinatorPromise = coordinators.get(normalized);
   if (!coordinatorPromise)
     return;
@@ -113782,8 +114615,10 @@ async function stopCoordinatorForWorkingDir(coordinators, normalized) {
   await coordinatorPromise.then((coordinator2) => coordinator2.stop()).catch(() => {
     return;
   });
+  await checkpointOutboxRegistry.stop(normalized);
+  await deltaOutboxRegistry.stop(normalized);
 }
-async function drainPendingFileTreeReleaseRequests(session2, coordinators) {
+async function drainPendingFileTreeReleaseRequests(session2, coordinators, checkpointOutboxRegistry, deltaOutboxRegistry) {
   const releases = await session2.backend.query(api.workspaceFiles.getPendingFileTreeReleaseRequests, {
     sessionId: session2.sessionId,
     machineId: session2.machineId
@@ -113795,7 +114630,7 @@ async function drainPendingFileTreeReleaseRequests(session2, coordinators) {
     releasesByDir.add(normalizeWorkingDirForLookup(release.workingDir));
   }
   for (const normalized of releasesByDir) {
-    await stopCoordinatorForWorkingDir(coordinators, normalized).then(() => session2.backend.mutation(api.workspaceFiles.fulfillFileTreeReleaseRequest, {
+    await stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized).then(() => session2.backend.mutation(api.workspaceFiles.fulfillFileTreeReleaseRequest, {
       sessionId: session2.sessionId,
       machineId: session2.machineId,
       workingDir: normalized
@@ -113836,63 +114671,20 @@ async function drainPendingFileTreeRequests(session2, coordinators, ensureCoordi
   });
   await processPendingFileTreeRequests(session2, coordinators, ensureCoordinator, requests);
 }
-async function syncScannedFileTree(session2, normalizedWorkingDir, tree, dataHash, syncGeneration) {
-  if (selectFileTreeSnapshotStrategyId(tree) === "sharded") {
-    const ref2 = await publishShardedSnapshot(session2, normalizedWorkingDir, tree, syncGeneration);
-    return { strategyId: ref2.strategyId, snapshotId: ref2.snapshotId };
-  }
-  const ref = await publishBlobSnapshot(session2, normalizedWorkingDir, buildBlobSnapshotPayload(tree, dataHash));
-  return { strategyId: ref.strategyId, snapshotId: ref.snapshotId };
-}
-function toDeltaOperations(delta) {
-  return [
-    ...delta.added.map((entry) => ({
-      o: "a",
-      p: entry.path,
-      e: entry.type === "directory" ? "d" : "f"
-    })),
-    ...delta.removed.map((entryPath) => ({
-      o: "r",
-      p: entryPath
-    })),
-    ...delta.typeChanged.map((entry) => ({
-      o: "t",
-      p: entry.path,
-      e: entry.type === "directory" ? "d" : "f"
-    }))
-  ];
-}
-async function publishCheckpoint(session2, normalizedWorkingDir, tree, revision) {
-  const dataHash = computeFileTreeDataHash(tree);
-  const syncGeneration = randomUUID11();
-  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,
-      revision: checkpointRevision,
-      ...snapshot
-    });
-  }
-  if (result.status === "snapshot-missing") {
-    throw new Error(`File tree checkpoint rejected: ${result.status}`);
-  }
-  console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree checkpoint: ${normalizedWorkingDir} (${tree.entries.length} entries, revision ${checkpointRevision})`);
-  return { revision: checkpointRevision };
-}
 var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const coordinators = new Map;
+  const checkpointOutboxRegistry = createWorkspaceFileTreeCheckpointOutboxRegistry(session2.machineId, (normalized) => {
+    const send = createWorkspaceFileTreeCheckpointSend(session2, normalized);
+    return async (state) => {
+      const result = await send(state);
+      console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree checkpoint: ${normalized} (${state.tree.entries.length} entries, revision ${result.revision})`);
+      return result;
+    };
+  }, {
+    onError: (normalized, error51) => logSubscriptionWarn(`File tree checkpoint outbox failed for ${normalized}`, error51)
+  });
+  const deltaOutboxRegistry = createWorkspaceFileTreeDeltaOutboxRegistry(session2.machineId, (normalized) => createWorkspaceFileTreeDeltaSend(session2, normalized));
   const ensureCoordinator = (workingDir, forceReconcile) => {
     const normalized = normalizeWorkingDirForLookup(workingDir);
     let coordinatorPromise = coordinators.get(normalized);
@@ -113900,23 +114692,8 @@ var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
       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),
+        onDelta: (delta, baseRevision) => deltaOutboxRegistry.enqueue(normalized, { delta, baseRevision }),
+        onCheckpoint: (tree, revision) => checkpointOutboxRegistry.enqueue(normalized, { tree, revision }),
         onError: (error51) => logSubscriptionWarn(`File tree coordinator failed for ${normalized}`, error51),
         onReconciled: (correctedPathCount) => {
           console.log(`[${formatTimestamp()}] \uD83C\uDF33 File tree reconciled: ${normalized} (${correctedPathCount} corrected paths)`);
@@ -113942,25 +114719,27 @@ var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
   };
   return {
     drainPendingFileTreeRequests: () => drainPendingFileTreeRequests(session2, coordinators, ensureCoordinator),
-    drainPendingFileTreeReleaseRequests: () => drainPendingFileTreeReleaseRequests(session2, coordinators),
+    drainPendingFileTreeReleaseRequests: () => drainPendingFileTreeReleaseRequests(session2, coordinators, checkpointOutboxRegistry, deltaOutboxRegistry),
     stop: () => {
-      Promise.all([...coordinators.values()].map((coordinator2) => coordinator2.then((handle) => handle.stop()).catch(() => {
-        return;
-      })));
-      coordinators.clear();
+      (async () => {
+        const keys3 = [...coordinators.keys()];
+        await Promise.all(keys3.map((normalized) => stopCoordinatorForWorkingDir(coordinators, checkpointOutboxRegistry, deltaOutboxRegistry, normalized)));
+        await deltaOutboxRegistry.stopAll();
+        await checkpointOutboxRegistry.stopAll();
+        coordinators.clear();
+      })();
     }
   };
 });
 var init_file_tree_subscription = __esm(() => {
-  init_workspace_file_tree();
   init_esm();
   init_api3();
-  init_file_tree_data_hash();
-  init_blob_snapshot_publish();
-  init_sharded_snapshot_publish();
   init_workspace_file_tree_coordinator();
   init_workspace_sync_queue();
   init_convex_error();
+  init_outbox();
+  init_workspace_file_tree_checkpoint_send();
+  init_workspace_file_tree_delta_send();
   init_daemon_services();
 });
 
@@ -114074,7 +114853,7 @@ var init_file_write_request_priority = __esm(() => {
 
 // src/daemon/entry/files/file-write-fulfillment.ts
 import { access as access4, mkdir as mkdir10, rename as rename4, rm as rm4, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 function isTerminalFileWriteError(errorMessage) {
   const terminalMessages = new Set([
     "Invalid file path",
@@ -114173,7 +114952,7 @@ async function validateWriteOperation(operation, absolutePath) {
 }
 async function writePayloadToDisk(absolutePath, operation, content) {
   if (operation === "create") {
-    await mkdir10(dirname12(absolutePath), { recursive: true });
+    await mkdir10(dirname14(absolutePath), { recursive: true });
     await writeFile9(absolutePath, content, { flag: "wx" });
     return;
   }
@@ -114251,7 +115030,7 @@ async function fulfillOneFileWriteRequest(session2, request2) {
         });
         return;
       }
-      await mkdir10(dirname12(targetResolved.absolutePath), { recursive: true });
+      await mkdir10(dirname14(targetResolved.absolutePath), { recursive: true });
       await rename4(resolved.absolutePath, targetResolved.absolutePath);
       await completeWriteRequest(session2, claimed._id, claimed.revision, { status: "done" });
       const elapsed4 = Date.now() - startTime;
@@ -116551,10 +117330,10 @@ var init_deps = __esm(() => {
 });
 
 // src/daemon/entry/persistence-path.ts
-import { homedir as homedir8 } from "node:os";
-import { join as join25 } from "node:path";
+import { homedir as homedir10 } from "node:os";
+import { join as join26 } from "node:path";
 function resolvePersistenceDbPath(machineId) {
-  return join25(homedir8(), ".chatroom", "daemon", machineId, "events.sqlite");
+  return join26(homedir10(), ".chatroom", "daemon", machineId, "events.sqlite");
 }
 var init_persistence_path = () => {};
 
@@ -117590,10 +118369,10 @@ function resolveEnvSlug(convexUrl) {
 }
 
 // src/infrastructure/log-server/resolve-logs-db-path.ts
-import { homedir as homedir9 } from "node:os";
-import { join as join26 } from "node:path";
+import { homedir as homedir11 } from "node:os";
+import { join as join27 } from "node:path";
 function resolveLogsDbPath(convexUrl) {
-  return join26(homedir9(), ".chatroom", resolveEnvSlug(convexUrl ?? getConvexUrl()), "logs.sqlite");
+  return join27(homedir11(), ".chatroom", resolveEnvSlug(convexUrl ?? getConvexUrl()), "logs.sqlite");
 }
 var init_resolve_logs_db_path = __esm(() => {
   init_client2();
@@ -117626,12 +118405,12 @@ var init_log_schema = __esm(() => {
 });
 
 // src/infrastructure/log-server/open-log-database.ts
-import { mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { mkdirSync as mkdirSync8 } from "node:fs";
+import { dirname as dirname15 } from "node:path";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 function openLogDatabase(dbPath) {
-  mkdirSync6(dirname13(dbPath), { recursive: true });
-  const db = new DatabaseSync(dbPath);
+  mkdirSync8(dirname15(dbPath), { recursive: true });
+  const db = new DatabaseSync3(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
   db.exec("PRAGMA synchronous = NORMAL");
@@ -117857,12 +118636,12 @@ var init_schema = __esm(() => {
 });
 
 // src/daemon/infrastructure/persistence/open-database.ts
-import { mkdirSync as mkdirSync7 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { mkdirSync as mkdirSync9 } from "node:fs";
+import { dirname as dirname16 } from "node:path";
+import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 function openDatabase(dbPath) {
-  mkdirSync7(dirname14(dbPath), { recursive: true });
-  const db = new DatabaseSync2(dbPath);
+  mkdirSync9(dirname16(dbPath), { recursive: true });
+  const db = new DatabaseSync4(dbPath);
   for (const sql of MIGRATIONS2) {
     db.exec(sql);
   }
@@ -131572,19 +132351,19 @@ function routeRequest(req, res, deps) {
 
 // src/daemon/local-web/server/serve-static.ts
 import { existsSync as existsSync10, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname15, join as join27 } from "node:path";
+import { dirname as dirname17, join as join28 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function clientDistCandidates(here) {
   return [
-    join27(here, "client/build"),
-    join27(here, "../client/build"),
-    join27(here, "../src/daemon/local-web/client/build")
+    join28(here, "client/build"),
+    join28(here, "../client/build"),
+    join28(here, "../src/daemon/local-web/client/build")
   ];
 }
-function resolveClientDistDir(here = dirname15(fileURLToPath7(import.meta.url))) {
+function resolveClientDistDir(here = dirname17(fileURLToPath7(import.meta.url))) {
   const candidates = clientDistCandidates(here);
   for (const dir of candidates) {
-    if (existsSync10(join27(dir, "index.html")))
+    if (existsSync10(join28(dir, "index.html")))
       return dir;
   }
   return candidates[0];
@@ -131597,7 +132376,7 @@ function tryServeStatic(req, res, distDir) {
     return false;
   }
   const safePath = pathname === "/" ? "/index.html" : pathname;
-  const filePath = join27(distDir, safePath);
+  const filePath = join28(distDir, safePath);
   if (!filePath.startsWith(distDir)) {
     res.writeHead(403);
     res.end();
@@ -131614,7 +132393,7 @@ function tryServeStatic(req, res, distDir) {
     }
     return true;
   }
-  const indexPath = join27(distDir, "index.html");
+  const indexPath = join28(distDir, "index.html");
   if (existsSync10(indexPath)) {
     res.writeHead(200, { "Content-Type": "text/html" });
     if (req.method === "HEAD") {
@@ -133345,4 +134124,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=FF157482FA3E83C464756E2164756E21
+//# debugId=6381A1F83F16A2C964756E2164756E21