@wspc/cli 0.1.14 → 0.1.16

package/dist/cli.js

@@ -995,6 +995,15 @@ var driveManifestGet = (options) => (options.client ?? client).get({
   url: "/drive/libraries/{id}/manifest",
   ...options
 });
+var driveFileMove = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drive/libraries/{id}/files/move",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
 var driveFileRestore = (options) => (options.client ?? client).post({
   security: [{ scheme: "bearer", type: "http" }],
   url: "/drive/libraries/{id}/files/restore",
@@ -1520,9 +1529,9 @@ function createConsistencyFetch(opts) {
 }
 
 // src/version.ts
-var VERSION = "0.1.14";
-var SPEC_SHA = "bec760cd";
-var SPEC_FETCHED_AT = "2026-07-08T06:11:14.456Z";
+var VERSION = "0.1.16";
+var SPEC_SHA = "74d4defc";
+var SPEC_FETCHED_AT = "2026-07-13T06:28:22.721Z";
 var API_BASE = "https://api.wspc.ai";
 
 // src/index.ts
@@ -3020,7 +3029,7 @@ var driveFileHistoryCommand = new Command29("history").description("Get drive fi
 
 // src/generated/cli/drive/manifest/get.ts
 import { Command as Command30 } from "commander";
-var driveManifestGetCommand = new Command30("get").description("Get a drive library manifest").argument("<id>", "id").option("--limit <value>", "limit").option("--cursor <value>", "cursor").option("--include-deleted <value>", "include_deleted").option("--path-prefix <value>", "path_prefix").action(async (id, opts) => {
+var driveManifestGetCommand = new Command30("get").description("Get a drive library manifest").argument("<id>", "id").option("--limit <value>", "limit").option("--cursor <value>", "cursor").option("--include-deleted <value>", "include_deleted").option("--path-prefix <value>", "path_prefix").option("--since-cursor <value>", "since_cursor").action(async (id, opts) => {
   const client2 = await loadSdkClient();
   const result = await driveManifestGet({
     client: client2._rawClient,
@@ -3031,7 +3040,8 @@ var driveManifestGetCommand = new Command30("get").description("Get a drive libr
       limit: opts.limit,
       cursor: opts.cursor,
       include_deleted: opts.includeDeleted,
-      path_prefix: opts.pathPrefix
+      path_prefix: opts.pathPrefix,
+      since_cursor: opts.sinceCursor
     }
   });
   if (result.error || !result.response?.ok) {
@@ -4851,6 +4861,9 @@ async function expectJsonResult(result) {
   if (result.data == null) throw new Error("empty response");
   return result.data;
 }
+function syncClientHeaders(clientId) {
+  return { "x-wspc-client": clientId === void 0 ? "drive-sync" : `drive-sync/${clientId}` };
+}
 function driveContentUrl(baseUrl, id) {
   const baseWithTrailingSlash = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
   return new URL(`drive/libraries/${encodeURIComponent(id)}/files/content`, baseWithTrailingSlash);
@@ -4858,6 +4871,7 @@ function driveContentUrl(baseUrl, id) {
 async function createDriveApi(opts = {}) {
   const client2 = await loadSdkClientWithAuthedFetch(opts);
   const rawClient = client2._rawClient;
+  const clientHeaders = syncClientHeaders(opts.clientId);
   return {
     async getLibrary(id) {
       const result = await driveLibraryGet({
@@ -4866,11 +4880,14 @@ async function createDriveApi(opts = {}) {
       });
       return expectJsonResult(result);
     },
-    async getManifest(id, cursor) {
+    async getManifest(id, cursor, sinceCursor) {
+      const query = {};
+      if (cursor !== void 0) query.cursor = cursor;
+      if (sinceCursor !== void 0) query.since_cursor = sinceCursor;
       const result = await driveManifestGet({
         client: rawClient,
         path: { id },
-        ...cursor ? { query: { cursor } } : {}
+        ...Object.keys(query).length > 0 ? { query } : {}
       });
       return expectJsonResult(result);
     },
@@ -4878,6 +4895,7 @@ async function createDriveApi(opts = {}) {
       const result = await driveFileDelete({
         client: rawClient,
         path: { id },
+        headers: clientHeaders,
         body: {
           path,
           expected_entry_version: expectedEntryVersion
@@ -4885,6 +4903,19 @@ async function createDriveApi(opts = {}) {
       });
       return expectJsonResult(result);
     },
+    async moveFile(id, fromPath, toPath, expectedEntryVersion) {
+      const result = await driveFileMove({
+        client: rawClient,
+        path: { id },
+        headers: clientHeaders,
+        body: {
+          from_path: fromPath,
+          to_path: toPath,
+          ...expectedEntryVersion === void 0 ? {} : { expected_entry_version: expectedEntryVersion }
+        }
+      });
+      return expectJsonResult(result);
+    },
     async uploadFile(id, path, body, sha256, expectedEntryVersion) {
       const url = driveContentUrl(client2.baseUrl, id);
       url.searchParams.set("path", path);
@@ -4895,7 +4926,8 @@ async function createDriveApi(opts = {}) {
         method: "PUT",
         headers: {
           "content-type": "application/octet-stream",
-          "x-drive-content-sha256": sha256
+          "x-drive-content-sha256": sha256,
+          ...clientHeaders
         },
         body
       });
@@ -5110,7 +5142,7 @@ function isOptionalIsoTimestamp(value) {
 }
 function isValidDriveState(value) {
   if (!isRecord2(value)) return false;
-  if (value.schema_version !== 1 || typeof value.library_id !== "string" || typeof value.created_at !== "string" || typeof value.updated_at !== "string" || !isRecord2(value.entries) || !isRecord2(value.conflicts) || value.realtime !== void 0 && !isDriveRealtimeState(value.realtime)) {
+  if (value.schema_version !== 1 || typeof value.library_id !== "string" || typeof value.created_at !== "string" || typeof value.updated_at !== "string" || !isRecord2(value.entries) || !isRecord2(value.conflicts) || value.realtime !== void 0 && !isDriveRealtimeState(value.realtime) || value.scan_cache !== void 0 && !isRecord2(value.scan_cache) || value.manifest_cursor !== void 0 && typeof value.manifest_cursor !== "string") {
     return false;
   }
   for (const entry of Object.values(value.entries)) {
@@ -5119,8 +5151,16 @@ function isValidDriveState(value) {
   for (const conflict2 of Object.values(value.conflicts)) {
     if (!isDriveConflict(conflict2)) return false;
   }
+  if (value.scan_cache !== void 0) {
+    for (const entry of Object.values(value.scan_cache)) {
+      if (!isDriveScanCacheEntry(entry)) return false;
+    }
+  }
   return true;
 }
+function isDriveScanCacheEntry(value) {
+  return isRecord2(value) && typeof value.mtime_ms === "number" && typeof value.size_bytes === "number" && typeof value.sha256 === "string";
+}
 
 // src/handwritten/commands/drive/bind.ts
 async function assertExistingDirectory(path) {
@@ -5155,9 +5195,44 @@ function driveBindCommand() {
 // src/handwritten/commands/drive/sync.ts
 import { Command as Command80 } from "commander";
 import { mkdir as mkdir3, readFile as readFile4, rm as rm3, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename3, dirname as dirname2, join as join5, posix as pathPosix2, resolve as resolve3 } from "path";
+import { basename as basename3, dirname as dirname2, join as join6, posix as pathPosix3, resolve as resolve3 } from "path";
 import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
 
+// src/handwritten/commands/drive/debug-log.ts
+import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
+import { join as join3 } from "path";
+var noopDriveDebugLogger = { log() {
+} };
+var DEBUG_LOG_FILE = "debug.log";
+var MAX_DEBUG_LOG_BYTES = 10 * 1024 * 1024;
+function createDriveDebugLogger(root, options = {}) {
+  const clock = options.clock ?? systemDriveClock;
+  const maxBytes = options.maxBytes ?? MAX_DEBUG_LOG_BYTES;
+  const dir = join3(root, DRIVE_DIR);
+  const file = join3(dir, DEBUG_LOG_FILE);
+  let warned = false;
+  return {
+    log(event, fields = {}) {
+      try {
+        mkdirSync(dir, { recursive: true });
+        try {
+          if (statSync(file).size > maxBytes) renameSync(file, `${file}.old`);
+        } catch {
+        }
+        appendFileSync(file, `${JSON.stringify({ ts: driveIsoTimestamp(clock), event, ...fields })}
+`);
+      } catch (error) {
+        if (!warned) {
+          warned = true;
+          const message = error instanceof Error ? error.message : String(error);
+          process.stderr.write(`wspc drive: debug log write failed: ${message}
+`);
+        }
+      }
+    }
+  };
+}
+
 // src/handwritten/commands/drive/decision.ts
 function decideDriveAction(entry, local, remote) {
   if (!entry) return decideWithoutBase(local, remote);
@@ -5166,7 +5241,7 @@ function decideDriveAction(entry, local, remote) {
   const remoteStatus = getRemoteStatus(entry, remote);
   if (!remote) return decideRemoteMissing(localStatus);
   if (!local) return decideLocalMissing(entry, remoteStatus);
-  return decideBothPresent(entry, localStatus, remoteStatus);
+  return decideBothPresent(entry, localStatus, remoteStatus, local, remote);
 }
 function decideWithoutBase(local, remote) {
   if (local && !remote) return { type: "upload_create", expectedEntryVersion: 0 };
@@ -5188,7 +5263,8 @@ function decideLocalMissing(entry, remoteStatus) {
   if (remoteStatus === "unchanged") return { type: "delete_remote", expectedEntryVersion: entry.entry_version };
   return { type: "conflict", reason: "remote_changed_before_delete" };
 }
-function decideBothPresent(entry, localStatus, remoteStatus) {
+function decideBothPresent(entry, localStatus, remoteStatus, local, remote) {
+  const converged = remote.content_sha256 !== void 0 && local.sha256 === remote.content_sha256;
   if (localStatus === "unchanged" && remoteStatus === "content_same_new_version") {
     return { type: "state_only" };
   }
@@ -5196,7 +5272,7 @@ function decideBothPresent(entry, localStatus, remoteStatus) {
     return { type: "conflict", reason: "remote_missing_entry_version" };
   }
   if (localStatus === "unknown" && remoteStatus !== "unchanged") {
-    return { type: "conflict", reason: "unknown_local_base_remote_changed" };
+    return converged ? { type: "state_only" } : { type: "conflict", reason: "unknown_local_base_remote_changed" };
   }
   if (localStatus === "unknown") return { type: "conflict", reason: "unknown_local_base" };
   if (localStatus === "unchanged" && remoteStatus === "changed") return { type: "download" };
@@ -5204,7 +5280,7 @@ function decideBothPresent(entry, localStatus, remoteStatus) {
     return { type: "upload_update", expectedEntryVersion: entry.entry_version };
   }
   if (localStatus !== "unchanged" && remoteStatus !== "unchanged") {
-    return { type: "conflict", reason: "local_and_remote_changed" };
+    return converged ? { type: "state_only" } : { type: "conflict", reason: "local_and_remote_changed" };
   }
   return { type: "unchanged" };
 }
@@ -5378,8 +5454,7 @@ function mergeText3(base, local, remote) {
 }
 function conflictCopyPath(path, side, timestamp, versionId) {
   const parsed = pathPosix.parse(path);
-  const shortVersionId = safeShortVersionId(versionId);
-  const fileName = `${parsed.name}.${side}-conflict-${timestamp}-${shortVersionId}${parsed.ext}`;
+  const fileName = `${parsed.name}.${side}-conflict-${timestamp}-${safeVersionId(versionId)}${parsed.ext}`;
   if (parsed.dir === "") {
     return fileName;
   }
@@ -5408,25 +5483,33 @@ function hasTextHint(path, mimeType) {
 function normalizeLines(text) {
   return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
 }
-function safeShortVersionId(versionId) {
-  const safeVersionId = versionId.replace(/[^A-Za-z0-9_-]/g, "_");
-  return (safeVersionId.length > 0 ? safeVersionId : "unknown").slice(0, 8);
+function safeVersionId(versionId) {
+  const safeVersionId2 = versionId.replace(/[^A-Za-z0-9_-]/g, "_");
+  return safeVersionId2.length > 0 ? safeVersionId2 : "unknown";
 }
 
 // src/handwritten/commands/drive/scanner.ts
 import { createHash } from "crypto";
 import { constants as fsConstants } from "fs";
 import { open as open2, readdir, lstat } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4, posix as pathPosix2 } from "path";
 async function scanDriveFiles(root, options = {}) {
   const candidates = [];
   const files = {};
-  const absRoot = root;
-  await walk(absRoot, "");
+  const startDrivePath = options.startDrivePath ?? "";
+  await walk(startDrivePath === "" ? root : join4(root, ...startDrivePath.split("/")), startDrivePath);
   await addNonCollidingFiles(candidates);
   return files;
   async function walk(currentPath, currentDrivePath) {
-    const entries = await readdir(currentPath, { withFileTypes: true });
+    let entries;
+    try {
+      entries = await readdir(currentPath, { withFileTypes: true });
+    } catch (error) {
+      if (currentDrivePath === startDrivePath && startDrivePath !== "" && isNotFoundError(error)) return;
+      if (currentDrivePath === "" || !isTransientScanError(error) || !options.onPathError) throw error;
+      await options.onPathError(currentDrivePath, error);
+      return;
+    }
     entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
       if (isExcludedRootEntry(currentDrivePath, entry)) {
@@ -5443,23 +5526,35 @@ async function scanDriveFiles(root, options = {}) {
         await options.onPathError(nextDrivePath, error);
         continue;
       }
-      const nextPath = join3(currentPath, entry.name);
-      const stats = await lstat(nextPath);
-      if (stats.isSymbolicLink()) {
-        continue;
-      }
-      if (stats.isDirectory()) {
-        await walk(nextPath, nextDrivePath);
-        continue;
-      }
-      if (!stats.isFile()) {
-        continue;
-      }
-      const digest = await hashDriveFile(nextPath);
-      if (!digest) {
-        continue;
+      const nextPath = join4(currentPath, entry.name);
+      try {
+        const stats = await lstat(nextPath);
+        if (stats.isSymbolicLink()) {
+          continue;
+        }
+        if (stats.isDirectory()) {
+          await walk(nextPath, nextDrivePath);
+          continue;
+        }
+        if (!stats.isFile()) {
+          continue;
+        }
+        const cached = options.cache?.[nextDrivePath];
+        if (cached !== void 0 && cached.mtime_ms === stats.mtimeMs && cached.size_bytes === stats.size) {
+          options.onCacheUpdate?.(nextDrivePath, cached);
+          candidates.push({ path: nextDrivePath, entry: { sha256: cached.sha256, size_bytes: cached.size_bytes } });
+          continue;
+        }
+        const digest = await hashDriveFile(nextPath);
+        if (!digest) {
+          continue;
+        }
+        options.onCacheUpdate?.(nextDrivePath, { mtime_ms: stats.mtimeMs, size_bytes: digest.sizeBytes, sha256: digest.sha256 });
+        candidates.push({ path: nextDrivePath, entry: { sha256: digest.sha256, size_bytes: digest.sizeBytes } });
+      } catch (error) {
+        if (!isTransientScanError(error) || !options.onPathError) throw error;
+        await options.onPathError(nextDrivePath, error);
       }
-      candidates.push({ path: nextDrivePath, entry: { sha256: digest.sha256, size_bytes: digest.sizeBytes } });
     }
   }
   async function addNonCollidingFiles(candidates2) {
@@ -5488,6 +5583,75 @@ async function scanDriveFiles(root, options = {}) {
     return currentDrivePath === "" && entry.name === DRIVE_DIR;
   }
 }
+async function rescanDriveFiles(root, dirtyPaths, options = {}) {
+  const kept = { ...options.cache ?? {} };
+  for (const dirtyPath of new Set(dirtyPaths)) {
+    if (dirtyPath === "" || isInternalSyncArtifactName(pathPosix2.basename(dirtyPath))) continue;
+    try {
+      validateDrivePath(dirtyPath);
+    } catch (error) {
+      if (!options.onPathError) throw error;
+      await options.onPathError(dirtyPath, error);
+      continue;
+    }
+    removePathAndChildren(kept, dirtyPath);
+    const absPath = join4(root, ...dirtyPath.split("/"));
+    let stats;
+    try {
+      stats = await lstat(absPath);
+    } catch (error) {
+      if (isNotFoundError(error)) continue;
+      if (!isTransientScanError(error) || !options.onPathError) throw error;
+      await options.onPathError(dirtyPath, error);
+      continue;
+    }
+    if (stats.isSymbolicLink()) continue;
+    if (stats.isDirectory()) {
+      await scanDriveFiles(root, {
+        ...options,
+        startDrivePath: dirtyPath,
+        onCacheUpdate: (path, entry) => {
+          kept[path] = entry;
+        }
+      });
+      continue;
+    }
+    if (!stats.isFile()) continue;
+    try {
+      const cached = options.cache?.[dirtyPath];
+      if (cached !== void 0 && cached.mtime_ms === stats.mtimeMs && cached.size_bytes === stats.size) {
+        kept[dirtyPath] = cached;
+        continue;
+      }
+      const digest = await hashDriveFile(absPath);
+      if (!digest) continue;
+      kept[dirtyPath] = { mtime_ms: stats.mtimeMs, size_bytes: digest.sizeBytes, sha256: digest.sha256 };
+    } catch (error) {
+      if (!isTransientScanError(error) || !options.onPathError) throw error;
+      await options.onPathError(dirtyPath, error);
+    }
+  }
+  const files = {};
+  for (const [path, entry] of Object.entries(kept)) {
+    options.onCacheUpdate?.(path, entry);
+    files[path] = { sha256: entry.sha256, size_bytes: entry.size_bytes };
+  }
+  return files;
+}
+function removePathAndChildren(view, path) {
+  delete view[path];
+  const prefix = `${path}/`;
+  for (const key of Object.keys(view)) {
+    if (key.startsWith(prefix)) delete view[key];
+  }
+}
+function isNotFoundError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+var TRANSIENT_SCAN_ERROR_CODES = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EBUSY"]);
+function isTransientScanError(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string" && TRANSIENT_SCAN_ERROR_CODES.has(error.code);
+}
 function isInternalSyncArtifactName(name) {
   if (!name.startsWith(".") || !name.endsWith(".tmp")) return false;
   return name.includes(".wspc-download-") || name.includes(".wspc-backup-") || name.includes(".wspc-conflict-") || name.includes(".wspc-merge-");
@@ -5536,13 +5700,13 @@ async function hashDriveFile(path) {
 // src/handwritten/commands/drive/local-mutations.ts
 import { createWriteStream as createWriteStream2 } from "fs";
 import { link, mkdir as mkdir2, readFile as readFile3, rename as rename2, rm as rm2, unlink, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename2, dirname, join as join4 } from "path";
+import { basename as basename2, dirname, join as join5 } from "path";
 import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
 import { Readable as Readable2, Transform } from "stream";
 import { pipeline as pipeline2 } from "stream/promises";
 async function assertLocalStillScanned(localPath, scanned) {
   const snapshot = await hashDriveFile(localPath).catch((error) => {
-    if (isNotFoundError(error)) return void 0;
+    if (isNotFoundError2(error)) return void 0;
     throw error;
   });
   if (!snapshot || snapshot.sha256 !== scanned.sha256 || snapshot.sizeBytes !== scanned.size_bytes) {
@@ -5552,7 +5716,7 @@ async function assertLocalStillScanned(localPath, scanned) {
 async function writeMergedLocalFile(root, path, bytes, digest, scanned, onLocalMutation) {
   const target = resolveInsideRoot(root, path);
   await mkdir2(dirname(target), { recursive: true });
-  const tmp = join4(dirname(target), `.${basename2(target)}.wspc-merge-${randomUUID3()}.tmp`);
+  const tmp = join5(dirname(target), `.${basename2(target)}.wspc-merge-${randomUUID3()}.tmp`);
   try {
     await writeFile2(tmp, bytes, { flag: "wx" });
     return await installMergedLocalFile(root, path, tmp, scanned, digest, bytes.byteLength, onLocalMutation);
@@ -5570,7 +5734,7 @@ async function installMergedLocalFile(root, path, tmp, scanned, mergedSha256, me
       await rename2(target, backup);
       onLocalMutation();
     } catch (error) {
-      if (isNotFoundError(error)) {
+      if (isNotFoundError2(error)) {
         throw new Error("local file changed after scan");
       }
       throw error;
@@ -5604,14 +5768,14 @@ async function installMergedLocalFile(root, path, tmp, scanned, mergedSha256, me
   }
 }
 async function restoreMergedLocalFile(target, backup, backupSha256, backupSizeBytes, mergedSha256, mergedSizeBytes) {
-  const quarantine = join4(dirname(target), `.${basename2(target)}.wspc-merge-restore-${randomUUID3()}.tmp`);
+  const quarantine = join5(dirname(target), `.${basename2(target)}.wspc-merge-restore-${randomUUID3()}.tmp`);
   try {
     await rename2(target, quarantine);
   } catch (error) {
-    if (!isNotFoundError(error)) throw error;
+    if (!isNotFoundError2(error)) throw error;
   }
   const quarantineDigest = await hashDriveFile(quarantine).catch((error) => {
-    if (isNotFoundError(error)) return void 0;
+    if (isNotFoundError2(error)) return void 0;
     throw error;
   });
   if (quarantineDigest !== void 0 && (quarantineDigest.sha256 !== mergedSha256 || quarantineDigest.sizeBytes !== mergedSizeBytes)) {
@@ -5634,7 +5798,7 @@ async function restoreMergedLocalFile(target, backup, backupSha256, backupSizeBy
 async function downloadRemote(root, libraryId, path, api, expectedSha256, entry, onLocalMutation) {
   const target = resolveInsideRoot(root, path);
   await mkdir2(dirname(target), { recursive: true });
-  const tmp = join4(dirname(target), `.${basename2(target)}.wspc-download-${randomUUID3()}.tmp`);
+  const tmp = join5(dirname(target), `.${basename2(target)}.wspc-download-${randomUUID3()}.tmp`);
   try {
     const response = await api.downloadFile(libraryId, path);
     if (!response.body) {
@@ -5673,7 +5837,7 @@ async function installDownloadedFile(root, path, tmp, entry, onLocalMutation) {
       await rename2(target, backup);
       onLocalMutation();
     } catch (error) {
-      if (!isNotFoundError(error)) throw error;
+      if (!isNotFoundError2(error)) throw error;
       await installNoOverwrite(tmp, target, onLocalMutation);
       return;
     }
@@ -5718,7 +5882,7 @@ async function removeLocalIfStillBase(root, path, entry, onLocalMutation) {
       await rename2(target, backup);
       onLocalMutation();
     } catch (error) {
-      if (isNotFoundError(error)) {
+      if (isNotFoundError2(error)) {
         throw new Error("local file changed before delete");
       }
       throw error;
@@ -5756,19 +5920,19 @@ async function restoreBackupWhenPossible(backup, target) {
     return true;
   } catch (error) {
     if (isAlreadyExistsError(error)) return false;
-    if (isNotFoundError(error)) return true;
+    if (isNotFoundError2(error)) return true;
     return false;
   }
 }
 async function localFileExists(path) {
   const digest = await hashDriveFile(path).catch((error) => {
-    if (isNotFoundError(error)) return void 0;
+    if (isNotFoundError2(error)) return void 0;
     throw error;
   });
   return digest !== void 0;
 }
 function localMutationBackupPath(target) {
-  return join4(dirname(target), `.${basename2(target)}.wspc-backup-${randomUUID3()}.tmp`);
+  return join5(dirname(target), `.${basename2(target)}.wspc-backup-${randomUUID3()}.tmp`);
 }
 function expectedLocalBaseSha256(entry) {
   return entry?.last_local_sha256 ?? entry?.content_sha256;
@@ -5778,14 +5942,14 @@ async function readStableUploadBody(localPath, scanned) {
     throw new Error("local file missing from scan");
   }
   const snapshot = await hashDriveFile(localPath).catch((error) => {
-    if (isNotFoundError(error)) return void 0;
+    if (isNotFoundError2(error)) return void 0;
     throw error;
   });
   if (!snapshot || snapshot.sha256 !== scanned.sha256 || snapshot.sizeBytes !== scanned.size_bytes) {
     throw new Error("local file changed after scan");
   }
   const body = await readFile3(localPath).catch((error) => {
-    if (isNotFoundError(error)) return void 0;
+    if (isNotFoundError2(error)) return void 0;
     throw error;
   });
   if (!body) {
@@ -5802,7 +5966,7 @@ async function readStableUploadBody(localPath, scanned) {
 async function assertLocalSafeForDownload(root, path, entry) {
   const target = resolveInsideRoot(root, path);
   const digest = await hashDriveFile(target).catch((error) => {
-    if (isNotFoundError(error)) return void 0;
+    if (isNotFoundError2(error)) return void 0;
     throw error;
   });
   if (!digest) return;
@@ -5815,14 +5979,14 @@ async function assertLocalSafeForDownload(root, path, entry) {
 }
 async function assertLocalAbsentBeforeRemoteDelete(root, path) {
   const digest = await hashDriveFile(resolveInsideRoot(root, path)).catch((error) => {
-    if (isNotFoundError(error)) return void 0;
+    if (isNotFoundError2(error)) return void 0;
     throw error;
   });
   if (digest) {
     throw new Error("local file appeared before remote delete");
   }
 }
-function isNotFoundError(error) {
+function isNotFoundError2(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function isAlreadyExistsError(error) {
@@ -5846,31 +6010,82 @@ function emptySummary() {
 function isActionableAction(action) {
   return action.type !== "unchanged" && action.type !== "state_only" && action.type !== "remove_state";
 }
-async function runDriveSyncOnce(root, api, clock = systemDriveClock, onProgress) {
+async function runDriveSyncOnce(root, api, clock = systemDriveClock, onProgress, debug = noopDriveDebugLogger, options = {}) {
   return withDriveLock(root, async () => {
     let state = await readDriveState(root);
-    const syncApi = api ?? await createDriveApi();
+    const syncApi = api ?? await createDriveApi({ clientId: state.realtime?.client_id });
     const summary = emptySummary();
     const blockedPaths = /* @__PURE__ */ new Set();
-    const localFiles = await scanDriveFiles(root, {
+    const scanStartedMs = Date.now();
+    const nextScanCache = {};
+    const scanOptions = {
+      cache: state.scan_cache,
+      onCacheUpdate: (path, entry) => {
+        nextScanCache[path] = entry;
+      },
       onPathError: async (path, error) => {
-        await recordPathError(summary, blockedPaths, path, error);
+        await recordPathError(summary, blockedPaths, path, error, { debug, op: "scan" });
       }
-    });
-    const remoteFiles = await fetchRemoteManifest(root, state, syncApi, summary, blockedPaths);
+    };
+    const useIncrementalScan = options.dirtyPaths !== void 0 && state.scan_cache !== void 0;
+    const localFiles = useIncrementalScan ? await rescanDriveFiles(root, options.dirtyPaths, scanOptions) : await scanDriveFiles(root, scanOptions);
+    if (JSON.stringify(state.scan_cache ?? {}) !== JSON.stringify(nextScanCache)) {
+      state = { ...state, scan_cache: nextScanCache };
+      await writeDriveState(root, state, clock);
+    }
+    const scanMs = Date.now() - scanStartedMs;
+    const manifestStartedMs = Date.now();
+    const manifest = await fetchRemoteManifest(root, state, syncApi, summary, blockedPaths, debug);
+    const remoteFiles = manifest.remoteFiles;
+    if (manifest.manifestCursor !== void 0 && manifest.manifestCursor !== state.manifest_cursor) {
+      state = { ...state, manifest_cursor: manifest.manifestCursor };
+      await writeDriveState(root, state, clock);
+    }
+    const manifestMs = Date.now() - manifestStartedMs;
     const paths = Array.from(
       /* @__PURE__ */ new Set([...Object.keys(localFiles), ...Object.keys(remoteFiles), ...Object.keys(state.entries)])
     ).filter((path) => !blockedPaths.has(path)).sort((left, right) => left.localeCompare(right));
+    const movedPaths = await applyRenamesAsMoves({
+      root,
+      state,
+      api: syncApi,
+      paths,
+      localFiles,
+      remoteFiles,
+      summary,
+      clock,
+      debug,
+      onStateChange: (nextState) => {
+        state = nextState;
+      }
+    });
     const total = paths.filter(
-      (path) => isActionableAction(decideDriveAction(state.entries[path], localFiles[path], remoteFiles[path]))
+      (path) => !movedPaths.has(path) && isActionableAction(decideDriveAction(state.entries[path], localFiles[path], remoteFiles[path]))
     ).length;
     let processed = 0;
     onProgress?.(processed, total);
+    const processStartedMs = Date.now();
     for (const path of paths) {
+      if (movedPaths.has(path)) continue;
       const remote = remoteFiles[path];
-      const action = decideDriveAction(state.entries[path], localFiles[path], remote);
-      const result = await processPath({ root, state, api: syncApi, path, action, remote, local: localFiles[path], summary, clock });
+      const local = localFiles[path];
+      const action = decideDriveAction(state.entries[path], local, remote);
+      if (isActionableAction(action)) {
+        debug.log("decision", decisionFields(path, action, state.entries[path], local, remote));
+      }
+      const previousConflict = state.conflicts[path];
+      const result = await processPath({ root, state, api: syncApi, path, action, remote, local, summary, clock, debug });
       state = result.state;
+      const recordedConflict = state.conflicts[path];
+      if (recordedConflict !== void 0 && recordedConflict !== previousConflict) {
+        debug.log("conflict", {
+          path,
+          reason: recordedConflict.reason,
+          ...recordedConflict.type === void 0 ? {} : { type: recordedConflict.type },
+          ...recordedConflict.strategy === void 0 ? {} : { strategy: recordedConflict.strategy },
+          ...recordedConflict.conflict_paths === void 0 ? {} : { conflict_paths: recordedConflict.conflict_paths }
+        });
+      }
       if (isActionableAction(action)) {
         processed += 1;
         onProgress?.(processed, total);
@@ -5878,9 +6093,20 @@ async function runDriveSyncOnce(root, api, clock = systemDriveClock, onProgress)
       if (result.stop) break;
     }
     recordUnresolvedConflicts(summary, state);
+    debug.log("sync_phases", { scan_ms: scanMs, manifest_ms: manifestMs, process_ms: Date.now() - processStartedMs });
     return summary;
   });
 }
+function decisionFields(path, action, entry, local, remote) {
+  return {
+    path,
+    action: action.type,
+    ..."reason" in action && action.reason !== void 0 ? { reason: action.reason } : {},
+    ...entry === void 0 ? {} : { base_version_id: entry.current_version_id, base_entry_version: entry.entry_version, base_sha256: entry.content_sha256 },
+    ...local === void 0 ? {} : { local_sha256: local.sha256, local_size_bytes: local.size_bytes },
+    ...remote === void 0 ? {} : { remote_version_id: remote.current_version_id, remote_entry_version: remote.entry_version, remote_sha256: remote.content_sha256 }
+  };
+}
 function driveSyncCommand(api) {
   const sync = new Command80("sync").description("Drive sync commands");
   sync.command("once").description("Run one Drive sync pass").argument("[path]", "local folder path", ".").action(async (path) => {
@@ -5892,24 +6118,64 @@ function driveSyncCommand(api) {
   });
   return sync;
 }
-async function fetchRemoteManifest(root, state, api, summary, blockedPaths) {
+async function fetchRemoteManifest(root, state, api, summary, blockedPaths, debug) {
+  if (state.manifest_cursor !== void 0) {
+    const delta = await api.getManifest(state.library_id, void 0, state.manifest_cursor);
+    if (delta.resync_required !== true) {
+      const remoteFiles = remoteViewFromState(state);
+      const changed = delta.entries.filter((entry) => entry.deleted_at === void 0);
+      const normalized2 = normalizeRemoteManifest(root, changed);
+      for (const pathError of normalized2.pathErrors) {
+        await recordPathError(summary, blockedPaths, pathError.path, pathError.error, {
+          appendPathResult: pathError.appendPathResult,
+          debug,
+          op: "manifest"
+        });
+      }
+      for (const entry of delta.entries) {
+        if (entry.deleted_at !== void 0) delete remoteFiles[entry.path];
+      }
+      Object.assign(remoteFiles, normalized2.remoteFiles);
+      return { remoteFiles, manifestCursor: delta.latest_cursor ?? state.manifest_cursor };
+    }
+  }
   const entries = [];
   let cursor;
+  let latestCursor;
   do {
     const page = await api.getManifest(state.library_id, cursor);
     entries.push(...page.entries);
+    if (page.latest_cursor !== void 0) latestCursor = page.latest_cursor;
     cursor = page.next_cursor ?? void 0;
   } while (cursor !== void 0);
   const normalized = normalizeRemoteManifest(root, entries);
   for (const pathError of normalized.pathErrors) {
     await recordPathError(summary, blockedPaths, pathError.path, pathError.error, {
-      appendPathResult: pathError.appendPathResult
+      appendPathResult: pathError.appendPathResult,
+      debug,
+      op: "manifest"
     });
   }
-  return normalized.remoteFiles;
+  return { remoteFiles: normalized.remoteFiles, manifestCursor: latestCursor };
+}
+function remoteViewFromState(state) {
+  const remoteFiles = {};
+  for (const [path, entry] of Object.entries(state.entries)) {
+    remoteFiles[path] = {
+      id: entry.entry_id,
+      path,
+      kind: "file",
+      entry_version: entry.entry_version,
+      size_bytes: entry.size_bytes,
+      updated_at: entry.last_synced_at,
+      ...entry.current_version_id === void 0 ? {} : { current_version_id: entry.current_version_id },
+      ...entry.content_sha256 === void 0 ? {} : { content_sha256: entry.content_sha256 }
+    };
+  }
+  return remoteFiles;
 }
 async function processPath(args) {
-  const { root, state, api, path, action, remote, local, summary, clock } = args;
+  const { root, state, api, path, action, remote, local, summary, clock, debug } = args;
   summary.paths.push({ path, action: action.type });
   let durableStateRequired = false;
   try {
@@ -6010,35 +6276,17 @@ async function processPath(args) {
           summary.conflicts += 1;
           return { state: nextState2, stop: false };
         }
-        const conflictCopyState = await recordRemoteConflictCopy({
-          root,
-          state,
-          api,
-          path,
-          reason: action.reason,
-          type: "edit_edit",
-          remote,
-          clock
-        });
-        if (conflictCopyState) {
-          summary.conflicts += 1;
-          return { state: conflictCopyState, stop: false };
+        const resolved = await resolveConflictWithLocalAsMain({ root, state, api, path, remote, local, clock });
+        if (resolved) {
+          recordResolvedConflict(summary, debug, path, resolved.copyPath, action.reason, "edit_edit");
+          return { state: resolved.state, stop: false };
         }
       }
       if (action.reason === "local_and_remote_without_base") {
-        const conflictCopyState = await recordRemoteConflictCopy({
-          root,
-          state,
-          api,
-          path,
-          reason: action.reason,
-          type: "create_create",
-          remote,
-          clock
-        });
-        if (conflictCopyState) {
-          summary.conflicts += 1;
-          return { state: conflictCopyState, stop: false };
+        const resolved = await resolveConflictWithLocalAsMain({ root, state, api, path, remote, local, clock });
+        if (resolved) {
+          recordResolvedConflict(summary, debug, path, resolved.copyPath, action.reason, "create_create");
+          return { state: resolved.state, stop: false };
         }
       }
       if (action.reason === "local_changed_remote_deleted") {
@@ -6078,11 +6326,11 @@ async function processPath(args) {
         summary.paths[summary.paths.length - 1] = { path, action: "conflict" };
         return { state: nextState, stop: false };
       } catch (writeError) {
-        await recordPathError(summary, void 0, path, writeError);
+        await recordPathError(summary, void 0, path, writeError, { debug, op: "process" });
         return { state, stop: durableStateRequired };
       }
     }
-    await recordPathError(summary, void 0, path, error);
+    await recordPathError(summary, void 0, path, error, { debug, op: "process" });
     return { state, stop: durableStateRequired };
   }
   return { state, stop: false };
@@ -6144,6 +6392,84 @@ async function downloadBytes(api, libraryId, path, versionId) {
   const response = await api.downloadFile(libraryId, path, versionId);
   return new Uint8Array(await response.arrayBuffer());
 }
+async function applyRenamesAsMoves(args) {
+  const { root, api, paths, localFiles, remoteFiles, summary, clock, debug, onStateChange } = args;
+  const movedPaths = /* @__PURE__ */ new Set();
+  if (api.moveFile === void 0) return movedPaths;
+  let state = args.state;
+  const deletesBySha = /* @__PURE__ */ new Map();
+  const createsBySha = /* @__PURE__ */ new Map();
+  for (const path of paths) {
+    const action = decideDriveAction(state.entries[path], localFiles[path], remoteFiles[path]);
+    if (action.type === "delete_remote") {
+      const sha = state.entries[path]?.last_local_sha256 ?? state.entries[path]?.content_sha256;
+      if (sha !== void 0) deletesBySha.set(sha, [...deletesBySha.get(sha) ?? [], path]);
+    }
+    if (action.type === "upload_create") {
+      const sha = localFiles[path]?.sha256;
+      if (sha !== void 0) createsBySha.set(sha, [...createsBySha.get(sha) ?? [], path]);
+    }
+  }
+  for (const [sha, fromPaths] of deletesBySha) {
+    const toPaths = createsBySha.get(sha);
+    if (fromPaths.length !== 1 || toPaths === void 0 || toPaths.length !== 1) continue;
+    const fromPath = fromPaths[0];
+    const toPath = toPaths[0];
+    const entry = state.entries[fromPath];
+    const local = localFiles[toPath];
+    if (entry === void 0 || local === void 0) continue;
+    try {
+      const moved = await api.moveFile(state.library_id, fromPath, toPath, entry.entry_version);
+      const nextState = cloneDriveState(state);
+      delete nextState.entries[fromPath];
+      delete nextState.conflicts[fromPath];
+      nextState.entries[toPath] = stateEntryFromRemote(moved.entry, local.sha256, clock);
+      delete nextState.conflicts[toPath];
+      await writeDriveState(root, nextState, clock);
+      state = nextState;
+      onStateChange(nextState);
+      movedPaths.add(fromPath);
+      movedPaths.add(toPath);
+      summary.paths.push({ path: toPath, action: "move" });
+      debug.log("decision", { path: toPath, action: "move", from_path: fromPath });
+    } catch (error) {
+      debug.log("error", { path: toPath, op: "move", message: errorMessage(error) });
+    }
+  }
+  return movedPaths;
+}
+function recordResolvedConflict(summary, debug, path, copyPath, reason, type) {
+  summary.conflicts += 1;
+  summary.conflict_paths.push(copyPath);
+  const lastPath = summary.paths.at(-1);
+  if (lastPath?.path === path) {
+    lastPath.conflict_paths = [copyPath];
+  }
+  debug.log("conflict", { path, reason, type, strategy: "conflict_copy", conflict_paths: [copyPath] });
+}
+async function resolveConflictWithLocalAsMain(args) {
+  const { root, state, api, path, remote, local, clock } = args;
+  const remoteVersionId = remote?.current_version_id;
+  if (!remote || remoteVersionId === void 0 || !local) {
+    return void 0;
+  }
+  const previous = state.conflicts[path];
+  let copyPath;
+  if (previous !== void 0 && await canReuseConflictCopy(root, previous, remoteVersionId)) {
+    copyPath = previous.conflict_paths[0];
+  } else {
+    const remoteBytes = await downloadBytes(api, state.library_id, path, remoteVersionId);
+    copyPath = await writeConflictCopy(root, path, "remote", remoteVersionId, remoteBytes, clock);
+  }
+  const localPath = resolveInsideRoot(root, path);
+  const { body, digest } = await readStableUploadBody(localPath, local);
+  const uploaded = await api.uploadFile(state.library_id, path, body, digest, remote.entry_version);
+  const nextState = cloneDriveState(state);
+  nextState.entries[path] = stateEntryFromRemote(uploaded.entry, digest, clock);
+  delete nextState.conflicts[path];
+  await writeDriveState(root, nextState, clock);
+  return { state: nextState, copyPath };
+}
 async function recordRemoteConflictCopy(args) {
   const { root, state, api, path, reason, type, remote, clock } = args;
   const entry = state.entries[path];
@@ -6194,7 +6520,7 @@ async function writeConflictCopy(root, path, side, versionId, bytes, clock) {
     const target = resolveInsideRoot(root, candidate);
     await mkdir3(dirname2(target), { recursive: true });
     for (; ; ) {
-      const tmp = join5(dirname2(target), `.${basename3(target)}.wspc-conflict-${randomUUID4()}.tmp`);
+      const tmp = join6(dirname2(target), `.${basename3(target)}.wspc-conflict-${randomUUID4()}.tmp`);
       let tmpWritten = false;
       try {
         await writeFile3(tmp, bytes, { flag: "wx" });
@@ -6219,12 +6545,12 @@ function conflictCopyPathWithSuffix(path, suffix) {
   if (suffix === 1) {
     return path;
   }
-  const parsed = pathPosix2.parse(path);
+  const parsed = pathPosix3.parse(path);
   const fileName = `${parsed.name}-${suffix}${parsed.ext}`;
   if (parsed.dir === "") {
     return fileName;
   }
-  return pathPosix2.join(parsed.dir, fileName);
+  return pathPosix3.join(parsed.dir, fileName);
 }
 function isExpectedVersionDownloadMissing(error) {
   const structured = error;
@@ -6302,7 +6628,13 @@ async function recordPathError(summary, blockedPaths, path, error, options = {})
   } else {
     summary.paths.push({ path, action: "error" });
   }
-  void errorMessage(error);
+  const code = error instanceof Error && "code" in error ? error.code : void 0;
+  options.debug?.log("error", {
+    path,
+    ...options.op === void 0 ? {} : { op: options.op },
+    ...code === void 0 ? {} : { code },
+    message: errorMessage(error)
+  });
   summary.errors += 1;
 }
 function conflict(reason, remote, clock) {
@@ -6338,7 +6670,7 @@ function containsVersionConflict(value) {
 import { Command as Command81 } from "commander";
 import chokidar from "chokidar";
 import { watch as fsWatch } from "fs";
-import { relative as relative2, resolve as resolve4 } from "path";
+import { basename as basename4, relative as relative2, resolve as resolve4 } from "path";
 
 // src/handwritten/commands/drive/realtime.ts
 function createDriveRealtimeSource(args) {
@@ -6435,12 +6767,15 @@ function createDriveRealtimeSource(args) {
       return;
     }
     if (message.type === "library_changed") {
-      handlers?.onEvent({
-        debounce_ms: 2e3,
-        reason: "library_changed",
-        ...message.cursor === void 0 ? {} : { cursor: message.cursor },
-        ...message.path === void 0 ? {} : { path: message.path }
-      });
+      const ownEcho = message.origin_client_id !== void 0 && message.origin_client_id === currentRealtime.client_id;
+      if (!ownEcho) {
+        handlers?.onEvent({
+          debounce_ms: 2e3,
+          reason: "library_changed",
+          ...message.cursor === void 0 ? {} : { cursor: message.cursor },
+          ...message.path === void 0 ? {} : { path: message.path }
+        });
+      }
       if (message.cursor !== void 0) {
         await persistBestEffort({ ...currentRealtime, last_cursor: message.cursor, last_event_at: driveIsoTimestamp(clock) });
       }
@@ -6527,7 +6862,8 @@ function parseDriveRealtimeMessage(raw) {
     return {
       type: "library_changed",
       ...cursor === void 0 ? {} : { cursor },
-      ...typeof value.path === "string" ? { path: value.path } : {}
+      ...typeof value.path === "string" ? { path: value.path } : {},
+      ...typeof value.origin_client_id === "string" ? { origin_client_id: value.origin_client_id } : {}
     };
   }
   if (messageType === "resync_required") {
@@ -6636,7 +6972,8 @@ function webSocketError(event) {
 
 // src/handwritten/commands/drive/watch.ts
 async function runDriveWatch(root, options = {}) {
-  const runSync = options.runSync ?? ((syncRoot, onProgress) => runDriveSyncOnce(syncRoot, void 0, void 0, onProgress));
+  const dbg = options.debugLogger ?? (options.debug ? createDriveDebugLogger(root) : noopDriveDebugLogger);
+  const runSync = options.runSync ?? ((syncRoot, onProgress, dirtyPaths2) => runDriveSyncOnce(syncRoot, void 0, void 0, onProgress, dbg, dirtyPaths2 === void 0 ? {} : { dirtyPaths: dirtyPaths2 }));
   const debounceMs = options.debounceMs ?? 500;
   const remoteDebounceMs = options.remoteDebounceMs ?? 2e3;
   const emit = options.onEvent ?? ((event) => {
@@ -6647,6 +6984,8 @@ async function runDriveWatch(root, options = {}) {
     }
     render({ kind: "drive_watch", display: { shape: "object" } }, event);
   });
+  let nextTrigger = "initial";
+  const dirtyPaths = /* @__PURE__ */ new Set();
   let debounceTimer;
   let debounceDeadlineMs;
   let retryTimer;
@@ -6671,14 +7010,34 @@ async function runDriveWatch(root, options = {}) {
         rerunRequested = false;
         try {
           emit({ kind: "drive_sync_start" });
-          const summary = await runSync(root, (processed, total) => {
-            emit({ kind: "drive_sync_progress", processed, total });
-          });
+          dbg.log("sync_start", { trigger: nextTrigger });
+          const startedAtMs = Date.now();
+          const dirtySnapshot = nextTrigger === "local" ? [...dirtyPaths] : void 0;
+          dirtyPaths.clear();
+          const summary = await runSync(
+            root,
+            (processed, total) => {
+              emit({ kind: "drive_sync_progress", processed, total });
+            },
+            dirtySnapshot
+          );
           emit({ kind: "drive_sync_once", ...summary });
+          dbg.log("sync_end", {
+            duration_ms: Date.now() - startedAtMs,
+            uploaded: summary.uploaded,
+            downloaded: summary.downloaded,
+            deleted: summary.deleted,
+            merged: summary.merged,
+            unchanged: summary.unchanged,
+            conflicts: summary.conflicts,
+            errors: summary.errors
+          });
           backoffMs = 1e3;
         } catch (error) {
           if (isAuthError(error) || isFatalWatchError(error) || !isRetryableWatchError(error)) throw error;
           emit({ kind: "drive_watch_retry", delay_ms: backoffMs, error: errorMessage2(error) });
+          dbg.log("retry", { delay_ms: backoffMs, error: errorMessage2(error) });
+          nextTrigger = "retry";
           if (stopped) return;
           await waitForManagedTimer(backoffMs);
           if (stopped) return;
@@ -6696,7 +7055,8 @@ async function runDriveWatch(root, options = {}) {
     debounceTimer = void 0;
     debounceDeadlineMs = void 0;
   }
-  function scheduleSync(delayMs) {
+  function scheduleSync(delayMs, trigger) {
+    nextTrigger = trigger;
     if (running) {
       rerunRequested = true;
       return;
@@ -6767,7 +7127,11 @@ async function runDriveWatch(root, options = {}) {
     source = options.source ?? createDefaultWatchSource(root);
     source.onChange((path) => {
       if (isDriveInternalPath(root, path)) return;
-      scheduleSync(debounceMs);
+      if (isInternalSyncArtifactName(basename4(path))) return;
+      const drivePath = relative2(root, path).replace(/\\/g, "/");
+      dirtyPaths.add(drivePath);
+      dbg.log("fs_event", { path: drivePath });
+      scheduleSync(debounceMs, "local");
     });
     emit({ kind: "drive_watch_started", root, library_id: state.library_id });
     realtimeSource?.start({
@@ -6776,11 +7140,12 @@ async function runDriveWatch(root, options = {}) {
       },
       onEvent(event) {
         emit(realtimeEvent(event));
+        dbg.log("realtime_event", { ...event });
         if (event.immediate) {
-          scheduleSync(0);
+          scheduleSync(0, "remote");
           return;
         }
-        scheduleSync(event.debounce_ms ?? remoteDebounceMs);
+        scheduleSync(event.debounce_ms ?? remoteDebounceMs, "remote");
       },
       onReconnect(delayMs, error) {
         emit({ kind: "drive_realtime_reconnecting", delay_ms: delayMs, error });
@@ -6809,8 +7174,9 @@ async function runDriveWatch(root, options = {}) {
   }
 }
 function driveWatchCommand(options = {}) {
-  return new Command81("watch").description("Watch a bound Drive folder and sync local changes").argument("[path]", "local folder path", ".").action(async (path) => {
-    await runDriveWatch(resolve4(path), options);
+  return new Command81("watch").description("Watch a bound Drive folder and sync local changes").argument("[path]", "local folder path", ".").option("--debug", "append debug NDJSON events to <folder>/.wspc-drive/debug.log").action(async (path, flags) => {
+    const debug = options.debug ?? (flags.debug === true || process.env.WSPC_DRIVE_DEBUG === "1");
+    await runDriveWatch(resolve4(path), { ...options, debug });
   });
 }
 function createDefaultWatchSource(root) {