chatroom-cli 1.98.3 → 1.98.4

package/dist/index.js

@@ -110259,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) {
@@ -110309,168 +110266,6 @@ 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();
@@ -113598,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 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 = {};
@@ -114045,6 +113840,45 @@ var init_workspace_sync_queue = __esm(() => {
   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];
@@ -114061,8 +113895,10 @@ function createCoalescingStateOutbox(options) {
   let stopped = false;
   if (options.store && options.deliveryKey && options.deserialize) {
     const recovered = options.store.getPending(options.deliveryKey);
-    if (recovered)
+    if (recovered) {
       pending3 = { state: options.deserialize(recovered.payloadJson), waiters: [] };
+      retryAttempt = recovered.attempts;
+    }
   }
   const rejectWaiters = (waiters, error51) => {
     for (const waiter of waiters)
@@ -114088,8 +113924,9 @@ function createCoalescingStateOutbox(options) {
     }, Math.max(0, delayMs));
     timer.unref?.();
   };
-  if (pending3)
-    schedule2(0);
+  if (pending3) {
+    schedule2(retryAttempt > 0 ? computeExponentialRetryDelayMs(retryAttempt - 1, retryDelayMs, maxRetryDelayMs) : 0);
+  }
   async function drain2() {
     if (stopped || !pending3 || inFlight2)
       return;
@@ -114098,18 +113935,22 @@ function createCoalescingStateOutbox(options) {
     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;
-      options.store?.markDone(options.deliveryKey);
+      if (store && deliveryKey)
+        store.markDone(deliveryKey);
       for (const waiter of batch.waiters)
         waiter.resolve(result);
     } catch (error51) {
       options.onError?.(error51);
-      options.store?.markPendingRetry(options.deliveryKey, error51);
+      if (store && deliveryKey)
+        store.markPendingRetry(deliveryKey, error51);
       pending3 = mergePending(batch, pending3);
-      retryDelay = Math.min(retryDelayMs * 2 ** retryAttempt, maxRetryDelayMs);
+      retryDelay = computeExponentialRetryDelayMs(retryAttempt, retryDelayMs, maxRetryDelayMs);
       retryAttempt++;
       throw error51;
     } finally {
@@ -114130,7 +113971,9 @@ function createCoalescingStateOutbox(options) {
       } else {
         pending3 = { state, waiters: [waiter] };
       }
-      options.store?.upsertPending(options.deliveryKey, options.serialize(state));
+      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));
@@ -114168,6 +114011,7 @@ function createCoalescingStateOutbox(options) {
   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) {
@@ -114207,7 +114051,9 @@ function createKeyedCoalescingStateOutboxRegistry(options) {
     }
   };
 }
-var init_keyed_coalescing_state_outbox_registry = () => {};
+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";
@@ -114217,54 +114063,25 @@ function resolveOutboxDbPath(machineId, kind) {
 }
 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/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
@@ -114320,7 +114137,7 @@ function createFifoBatchedOutbox(o) {
   let stopped = false;
   let retryTimer;
   let retryAttempt = 0;
-  const retryDelay = () => Math.min((o.retryDelayMs ?? 500) * 2 ** retryAttempt++, o.maxRetryDelayMs ?? 5000);
+  const retryDelay = () => computeExponentialRetryDelayMs(retryAttempt++, o.retryDelayMs ?? 500, o.maxRetryDelayMs ?? 5000);
   const scheduleRetry = () => {
     if (!stopped && !retryTimer) {
       retryTimer = setTimeout(() => {
@@ -114362,6 +114179,7 @@ function createFifoBatchedOutbox(o) {
             scheduleRetry();
             break;
           }
+          retryAttempt = 0;
         } catch (e) {
           o.onError?.(e);
           for (const r of rows2)
@@ -114401,6 +114219,7 @@ function createFifoBatchedOutbox(o) {
   };
   return { enqueue, flushNow, stop: stop4 };
 }
+var init_fifo_batched_outbox = () => {};
 
 // src/daemon/infrastructure/outbox/lib/keyed-fifo-batched-outbox-registry.ts
 function createKeyedFifoBatchedOutboxRegistry(o) {
@@ -114415,6 +114234,8 @@ function createKeyedFifoBatchedOutboxRegistry(o) {
         deliveryKey: key,
         serialize: o.serialize,
         deserialize: o.deserialize,
+        retryDelayMs: o.retryDelayMs,
+        maxRetryDelayMs: o.maxRetryDelayMs,
         onError: (e) => o.onError?.(key, e),
         classifyOutcome: o.classifyOutcome
       });
@@ -114447,7 +114268,7 @@ function createKeyedFifoBatchedOutboxRegistry(o) {
   };
 }
 var init_keyed_fifo_batched_outbox_registry = __esm(() => {
-  init_durable_fifo_queue_store();
+  init_fifo_batched_outbox();
 });
 
 // src/daemon/infrastructure/outbox/workspace-file-tree-delta-outbox.ts
@@ -114466,15 +114287,18 @@ function createWorkspaceFileTreeDeltaOutboxRegistry(machineId, createSend, optio
     },
     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;
+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_outbox_db_path();
   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
@@ -114483,8 +114307,303 @@ var init_outbox = __esm(() => {
   init_workspace_file_tree_delta_outbox();
 });
 
-// src/daemon/entry/files/file-tree-subscription.ts
+// ../../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)
+    });
+    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/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 assertCheckpointAccepted(result) {
+  if (result.status === "snapshot-missing" || result.status === "resync-required") {
+    throw new Error(`File tree checkpoint rejected: ${result.status}`);
+  }
+}
+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 };
+}
+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;
+}
+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 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
 function logSubscriptionWarn(label, err) {
   console.warn(`[${formatTimestamp()}] ⚠️  ${label}: ${getErrorMessage(err)}`);
 }
@@ -114552,79 +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) => (state) => publishCheckpoint(session2, normalized, state.tree, state.revision), {
+  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) => 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 deltaOutboxRegistry = createWorkspaceFileTreeDeltaOutboxRegistry(session2.machineId, (normalized) => createWorkspaceFileTreeDeltaSend(session2, normalized));
   const ensureCoordinator = (workingDir, forceReconcile) => {
     const normalized = normalizeWorkingDirForLookup(workingDir);
     let coordinatorPromise = coordinators.get(normalized);
@@ -114672,16 +114732,14 @@ var startFileTreeSubscriptionEffect = () => exports_Effect.gen(function* () {
   };
 });
 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();
 });
 
@@ -134066,4 +134124,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=DE791FABFBB4390C64756E2164756E21
+//# debugId=6381A1F83F16A2C964756E2164756E21