chatroom-cli 1.98.2 → 1.98.3

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));
@@ -110470,6 +110471,214 @@ var init_sharded_snapshot_publish = __esm(() => {
   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
 var require_ignore = __commonJS((exports, module) => {
   function makeArray(subject) {
@@ -110800,10 +111009,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 +111082,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 +111179,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))
+      for (const ent of dirents) {
+        const relativePath = frame.relDir ? `${frame.relDir}/${ent.name}` : ent.name;
+        if (!isPathVisible(relativePath))
           continue;
-        const syncMode = classifyDirectorySyncMode(ent.name, {
-          relativePath,
-          immediateSiblingCount: siblingCount,
-          immediateChildCount: dirents.length
-        });
-        if (syncMode === "hidden")
-          continue;
-        directoryStubs.push(relativePath);
-        if (syncMode === "shallow")
-          continue;
-        await visitDir(relativePath, ruleSets, dirents.length);
-      } else if (ent.isFile()) {
-        if (isPathIgnoredByRuleSets(ruleSets, relativePath))
-          continue;
-        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 +111241,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 +111258,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 +112322,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;
@@ -113319,7 +113600,7 @@ function diffPathIndexes(previous, next4) {
 // src/infrastructure/services/workspace/workspace-sync-state.ts
 import { createHash as createHash8, 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);
@@ -113397,7 +113678,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 +113828,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);
@@ -113769,12 +114045,450 @@ var init_workspace_sync_queue = __esm(() => {
   lastCompletedAtByKey = new Map;
 });
 
+// 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: [] };
+  }
+  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(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;
+    try {
+      const result = await sendPromise;
+      lastSentAt = Date.now();
+      retryAttempt = 0;
+      options.store?.markDone(options.deliveryKey);
+      for (const waiter of batch.waiters)
+        waiter.resolve(result);
+    } catch (error51) {
+      options.onError?.(error51);
+      options.store?.markPendingRetry(options.deliveryKey, error51);
+      pending3 = mergePending(batch, pending3);
+      retryDelay = Math.min(retryDelayMs * 2 ** retryAttempt, 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] };
+      }
+      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;
+
+// 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 = () => {};
+
+// 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/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/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,
+    onError: options?.onError
+  });
+}
+var WORKSPACE_FILE_TREE_CHECKPOINT_OUTBOX_MIN_INTERVAL_MS = 5000;
+var init_workspace_file_tree_checkpoint_outbox = __esm(() => {
+  init_keyed_coalescing_state_outbox_registry();
+  init_outbox_db_path();
+  init_durable_coalescing_state_store();
+});
+
+// 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 = () => Math.min((o.retryDelayMs ?? 500) * 2 ** retryAttempt++, 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;
+          }
+        } 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 };
+}
+
+// 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,
+        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_durable_fifo_queue_store();
+});
+
+// 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,
+    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;
+var init_workspace_file_tree_delta_outbox = __esm(() => {
+  init_outbox_db_path();
+  init_durable_fifo_queue_store();
+  init_keyed_fifo_batched_outbox_registry();
+});
+
+// src/daemon/infrastructure/outbox/index.ts
+var init_outbox = __esm(() => {
+  init_workspace_file_tree_checkpoint_outbox();
+  init_workspace_file_tree_delta_outbox();
+});
+
 // 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 +114496,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 +114511,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
@@ -113893,6 +114609,22 @@ async function publishCheckpoint(session2, normalizedWorkingDir, tree, revision)
 var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
   const session2 = yield* DaemonSessionService;
   const coordinators = new Map;
+  const checkpointOutboxRegistry = createWorkspaceFileTreeCheckpointOutboxRegistry(session2.machineId, (normalized) => (state) => publishCheckpoint(session2, normalized, state.tree, state.revision), {
+    onError: (normalized, error51) => logSubscriptionWarn(`File tree checkpoint outbox failed for ${normalized}`, error51)
+  });
+  const deltaOutboxRegistry = createWorkspaceFileTreeDeltaOutboxRegistry(session2.machineId, (normalized) => async (unit) => {
+    const result = await session2.backend.mutation(api.workspaceFiles.applyFileTreeDeltaBatch, {
+      sessionId: session2.sessionId,
+      machineId: session2.machineId,
+      workingDir: normalized,
+      operationId: unit.delta.operationId,
+      baseRevision: unit.baseRevision,
+      operations: toDeltaOperations(unit.delta)
+    });
+    if (result.status === "resync-required")
+      return { status: "conflict", revision: result.expectedRevision };
+    return result;
+  });
   const ensureCoordinator = (workingDir, forceReconcile) => {
     const normalized = normalizeWorkingDirForLookup(workingDir);
     let coordinatorPromise = coordinators.get(normalized);
@@ -113900,23 +114632,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,12 +114659,15 @@ 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();
+      })();
     }
   };
 });
@@ -113961,6 +114681,7 @@ var init_file_tree_subscription = __esm(() => {
   init_workspace_file_tree_coordinator();
   init_workspace_sync_queue();
   init_convex_error();
+  init_outbox();
   init_daemon_services();
 });
 
@@ -114074,7 +114795,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 +114894,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 +114972,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 +117272,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 +118311,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 +118347,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 +118578,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 +132293,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 +132318,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 +132335,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 +134066,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=FF157482FA3E83C464756E2164756E21
+//# debugId=DE791FABFBB4390C64756E2164756E21