@arbidocs/cli 0.3.28 → 0.3.30

package/dist/index.js

@@ -2,8 +2,8 @@
 'use strict';
 
 var commander = require('commander');
-var fs2 = require('fs');
-var path = require('path');
+var fs4 = require('fs');
+var path4 = require('path');
 var os = require('os');
 var chalk2 = require('chalk');
 var sdk = require('@arbidocs/sdk');
@@ -16,24 +16,24 @@ var module$1 = require('module');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var fs4__default = /*#__PURE__*/_interopDefault(fs4);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var chalk2__default = /*#__PURE__*/_interopDefault(chalk2);
 
 function getCacheFile() {
-  const configDir = process.env.ARBI_CONFIG_DIR ?? path__default.default.join(os__default.default.homedir(), ".arbi");
-  return path__default.default.join(configDir, "completions.json");
+  const configDir = process.env.ARBI_CONFIG_DIR ?? path4__default.default.join(os__default.default.homedir(), ".arbi");
+  return path4__default.default.join(configDir, "completions.json");
 }
 function ensureDir(filePath) {
-  const dir = path__default.default.dirname(filePath);
-  if (!fs2__default.default.existsSync(dir)) {
-    fs2__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
+  const dir = path4__default.default.dirname(filePath);
+  if (!fs4__default.default.existsSync(dir)) {
+    fs4__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function getCachedWorkspaceIds() {
   try {
-    const content = fs2__default.default.readFileSync(getCacheFile(), "utf-8");
+    const content = fs4__default.default.readFileSync(getCacheFile(), "utf-8");
     const cache = JSON.parse(content);
     return cache.workspaces.map((w) => w.id);
   } catch {
@@ -47,7 +47,7 @@ function updateCompletionCache(workspaces3) {
   };
   const filePath = getCacheFile();
   ensureDir(filePath);
-  fs2__default.default.writeFileSync(filePath, JSON.stringify(cache, null, 2) + "\n", { mode: 384 });
+  fs4__default.default.writeFileSync(filePath, JSON.stringify(cache, null, 2) + "\n", { mode: 384 });
 }
 
 // src/completion.ts
@@ -194,12 +194,12 @@ var ALIAS_LINE = 'alias A="arbi ask"';
 var ALIAS_MARKER = "# arbi-cli alias";
 function getShellRcPath() {
   const shell = process.env.SHELL || "";
-  if (shell.includes("zsh")) return path.join(os.homedir(), ".zshrc");
-  return path.join(os.homedir(), ".bashrc");
+  if (shell.includes("zsh")) return path4.join(os.homedir(), ".zshrc");
+  return path4.join(os.homedir(), ".bashrc");
 }
 function isAliasInstalled(rcPath) {
-  if (!fs2.existsSync(rcPath)) return false;
-  const content = fs2.readFileSync(rcPath, "utf-8");
+  if (!fs4.existsSync(rcPath)) return false;
+  const content = fs4.readFileSync(rcPath, "utf-8");
   return content.includes(ALIAS_LINE) || content.includes(ALIAS_MARKER);
 }
 function registerConfigCommand(program2) {
@@ -278,7 +278,7 @@ function registerConfigCommand(program2) {
       dim("Usage: A what is the meaning of life");
       return;
     }
-    fs2.appendFileSync(rcPath, `
+    fs4.appendFileSync(rcPath, `
 ${ALIAS_MARKER}
 ${ALIAS_LINE}
 `);
@@ -3600,11 +3600,11 @@ async function promptPassword(message) {
 async function promptConfirm(message, defaultValue = true) {
   return prompts.confirm({ message, default: defaultValue });
 }
-var CACHE_FILE = path__default.default.join(os__default.default.homedir(), ".arbi", "version-cache.json");
+var CACHE_FILE = path4__default.default.join(os__default.default.homedir(), ".arbi", "version-cache.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function readCache() {
   try {
-    const data = JSON.parse(fs2__default.default.readFileSync(CACHE_FILE, "utf8"));
+    const data = JSON.parse(fs4__default.default.readFileSync(CACHE_FILE, "utf8"));
     if (data.latest && data.checkedAt && Date.now() - data.checkedAt < CACHE_TTL_MS) {
       return data;
     }
@@ -3614,9 +3614,9 @@ function readCache() {
 }
 function writeCache(latest) {
   try {
-    const dir = path__default.default.dirname(CACHE_FILE);
-    if (!fs2__default.default.existsSync(dir)) fs2__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs2__default.default.writeFileSync(CACHE_FILE, JSON.stringify({ latest, checkedAt: Date.now() }) + "\n");
+    const dir = path4__default.default.dirname(CACHE_FILE);
+    if (!fs4__default.default.existsSync(dir)) fs4__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs4__default.default.writeFileSync(CACHE_FILE, JSON.stringify({ latest, checkedAt: Date.now() }) + "\n");
   } catch {
   }
 }
@@ -3637,13 +3637,13 @@ function getLatestVersion(skipCache = false) {
   }
 }
 function getCurrentVersion() {
-  return "0.3.28";
+  return "0.3.30";
 }
 function readChangelog(fromVersion, toVersion) {
   try {
     const globalRoot = child_process.execSync("npm root -g", { encoding: "utf8", timeout: 5e3 }).trim();
-    const changelogPath = path__default.default.join(globalRoot, "@arbidocs", "cli", "CHANGELOG.md");
-    const text = fs2__default.default.readFileSync(changelogPath, "utf8");
+    const changelogPath = path4__default.default.join(globalRoot, "@arbidocs", "cli", "CHANGELOG.md");
+    const text = fs4__default.default.readFileSync(changelogPath, "utf8");
     return extractSections(text, fromVersion, toVersion);
   } catch {
     return null;
@@ -3690,17 +3690,17 @@ function showChangelog(fromVersion, toVersion) {
 async function checkForUpdates(autoUpdate) {
   try {
     const latest = getLatestVersion();
-    if (!latest || latest === "0.3.28") return;
+    if (!latest || latest === "0.3.30") return;
     if (autoUpdate) {
       warn(`
-Your arbi version is out of date (${"0.3.28"} \u2192 ${latest}). Updating...`);
+Your arbi version is out of date (${"0.3.30"} \u2192 ${latest}). Updating...`);
       child_process.execSync("npm install -g @arbidocs/cli@latest", { stdio: "inherit" });
-      showChangelog("0.3.28", latest);
+      showChangelog("0.3.30", latest);
       console.log(`Updated to ${latest}.`);
     } else {
       warn(
         `
-Your arbi version is out of date (${"0.3.28"} \u2192 ${latest}).
+Your arbi version is out of date (${"0.3.30"} \u2192 ${latest}).
 Run "arbi update" to upgrade, or "arbi update auto" to always stay up to date.`
       );
     }
@@ -3710,9 +3710,9 @@ Run "arbi update" to upgrade, or "arbi update auto" to always stay up to date.`
 function hintUpdateOnError() {
   try {
     const cached = readCache();
-    if (cached && cached.latest !== "0.3.28") {
+    if (cached && cached.latest !== "0.3.30") {
       warn(
-        `Your arbi version is out of date (${"0.3.28"} \u2192 ${cached.latest}). Run "arbi update".`
+        `Your arbi version is out of date (${"0.3.30"} \u2192 ${cached.latest}). Run "arbi update".`
       );
     }
   } catch {
@@ -3721,18 +3721,18 @@ function hintUpdateOnError() {
 var MAX_TASKS = 50;
 var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 function getTasksFile() {
-  const configDir = process.env.ARBI_CONFIG_DIR ?? path__default.default.join(os__default.default.homedir(), ".arbi");
-  return path__default.default.join(configDir, "tasks.json");
+  const configDir = process.env.ARBI_CONFIG_DIR ?? path4__default.default.join(os__default.default.homedir(), ".arbi");
+  return path4__default.default.join(configDir, "tasks.json");
 }
 function ensureDir2(filePath) {
-  const dir = path__default.default.dirname(filePath);
-  if (!fs2__default.default.existsSync(dir)) {
-    fs2__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
+  const dir = path4__default.default.dirname(filePath);
+  if (!fs4__default.default.existsSync(dir)) {
+    fs4__default.default.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function readTasks() {
   try {
-    const content = fs2__default.default.readFileSync(getTasksFile(), "utf-8");
+    const content = fs4__default.default.readFileSync(getTasksFile(), "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -3741,7 +3741,7 @@ function readTasks() {
 function writeTasks(tasks) {
   const filePath = getTasksFile();
   ensureDir2(filePath);
-  fs2__default.default.writeFileSync(filePath, JSON.stringify(tasks, null, 2) + "\n", { mode: 384 });
+  fs4__default.default.writeFileSync(filePath, JSON.stringify(tasks, null, 2) + "\n", { mode: 384 });
 }
 function getTasks() {
   const now = Date.now();
@@ -3886,11 +3886,11 @@ async function resolveAuth() {
     throw err;
   }
 }
-async function resolveWorkspace(workspaceOpt) {
+async function resolveWorkspace(workspaceOpt, { skipNotifications = false } = {}) {
   try {
     resolveConfig();
     const ctx = await sdk.resolveWorkspace(store, workspaceOpt);
-    if (getConfig()?.notifications !== false) {
+    if (!skipNotifications && getConfig()?.notifications !== false) {
       startBackgroundNotifications(ctx.config.baseUrl, ctx.accessToken).catch(() => {
       });
     }
@@ -3975,39 +3975,39 @@ function checkAgentDependency(backend) {
   dim(`${binary} ${match?.[1] ?? version} \u2713`);
 }
 function loadSkillContent() {
-  const cliRoot = path.resolve(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)))), "..");
+  const cliRoot = path4.resolve(path4.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)))), "..");
   try {
-    return fs2.readFileSync(path.join(cliRoot, "SKILL.md"), "utf-8");
+    return fs4.readFileSync(path4.join(cliRoot, "SKILL.md"), "utf-8");
   } catch {
     return void 0;
   }
 }
 function installSkill(backend) {
-  const cliRoot = path.resolve(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)))), "..");
+  const cliRoot = path4.resolve(path4.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)))), "..");
   let skillContent;
   try {
-    skillContent = fs2.readFileSync(path.join(cliRoot, "SKILL.md"), "utf-8");
+    skillContent = fs4.readFileSync(path4.join(cliRoot, "SKILL.md"), "utf-8");
   } catch {
     return;
   }
   if (backend === "claude") {
-    const dir = path.join(os.homedir(), ".claude", "commands", "arbi");
-    const target = path.join(dir, "SKILL.md");
+    const dir = path4.join(os.homedir(), ".claude", "commands", "arbi");
+    const target = path4.join(dir, "SKILL.md");
     try {
-      fs2.mkdirSync(dir, { recursive: true });
-      if (!fs2.existsSync(target) || fs2.readFileSync(target, "utf-8") !== skillContent) {
-        fs2.writeFileSync(target, skillContent, "utf-8");
+      fs4.mkdirSync(dir, { recursive: true });
+      if (!fs4.existsSync(target) || fs4.readFileSync(target, "utf-8") !== skillContent) {
+        fs4.writeFileSync(target, skillContent, "utf-8");
         dim(`Installed ARBI skill \u2192 ${target}`);
       }
     } catch {
     }
   } else if (backend === "openclaw") {
-    const workspace = path.join(os.homedir(), ".arbi", "openclaw-workspace");
-    const bootstrap = path.join(workspace, "BOOTSTRAP.md");
+    const workspace = path4.join(os.homedir(), ".arbi", "openclaw-workspace");
+    const bootstrap = path4.join(workspace, "BOOTSTRAP.md");
     try {
-      fs2.mkdirSync(workspace, { recursive: true });
-      if (!fs2.existsSync(bootstrap) || fs2.readFileSync(bootstrap, "utf-8") !== skillContent) {
-        fs2.writeFileSync(bootstrap, skillContent, "utf-8");
+      fs4.mkdirSync(workspace, { recursive: true });
+      if (!fs4.existsSync(bootstrap) || fs4.readFileSync(bootstrap, "utf-8") !== skillContent) {
+        fs4.writeFileSync(bootstrap, skillContent, "utf-8");
         dim(`Installed ARBI skill \u2192 ${bootstrap}`);
       }
     } catch {
@@ -4335,8 +4335,16 @@ async function loginAfterRegister(config, email, password2) {
     const memberWorkspaces = wsList.filter((ws2) => ws2.users?.some((u) => u.user.email === email));
     if (memberWorkspaces.length === 0) {
       console.log("Creating your first workspace...");
+      const userProjects = await sdk.projects.listProjects(arbi);
+      const defaultProjectExtId = userProjects[0]?.external_id;
+      if (!defaultProjectExtId) throw new Error("No projects found for user");
       const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
-      const ws2 = await sdk.workspaces.createWorkspace(arbi, "My First Workspace", encryptedKey);
+      const ws2 = await sdk.workspaces.createWorkspace(
+        arbi,
+        "My First Workspace",
+        encryptedKey,
+        defaultProjectExtId
+      );
       updateConfig({ selectedWorkspaceId: ws2.external_id });
       success(`Workspace: ${ws2.name} (${ref(ws2.external_id)})`);
       return;
@@ -4451,11 +4459,15 @@ function registerWorkspacesCommand(program2) {
   workspace.command("create <name>").description("Create a new workspace").option("-d, --description <text>", "Workspace description").option("--public", "Make workspace public", false).action(
     (name, opts) => runAction(async () => {
       const { arbi, loginResult } = await resolveAuth();
+      const userProjects = await sdk.projects.listProjects(arbi);
+      if (!userProjects.length) throw new Error("No projects found. Create a project first.");
+      const projectExtId = userProjects[0].external_id;
       const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
       const data = await sdk.workspaces.createWorkspace(
         arbi,
         name,
         encryptedKey,
+        projectExtId,
         opts.description,
         opts.public ?? false
       );
@@ -4588,7 +4600,63 @@ function statusSymbol(status2) {
       return "\u25CF";
   }
 }
-async function fetchDocChoices(arbi, workspaceId) {
+function statusColor(status2) {
+  switch (status2) {
+    case "completed":
+      return chalk2__default.default.green;
+    case "failed":
+      return chalk2__default.default.red;
+    case "queued":
+      return chalk2__default.default.yellow;
+    case "processing":
+    case "parsing":
+    case "indexing":
+    case "analysing":
+    case "encrypting":
+      return chalk2__default.default.cyan;
+    default:
+      return (s) => s;
+  }
+}
+function formatSize(bytes) {
+  if (!bytes) return "-";
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)}K`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}G`;
+}
+function filterDocs(data, opts) {
+  let result = data;
+  if (opts.status) {
+    const statuses = opts.status.split(",");
+    result = result.filter((d) => statuses.includes(d.status));
+  }
+  if (opts.folder) {
+    const pattern = opts.folder.toLowerCase();
+    result = result.filter((d) => (d.folder ?? "").toLowerCase().includes(pattern));
+  }
+  if (opts.ext) {
+    const exts = opts.ext.split(",").map((e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`);
+    result = result.filter((d) => {
+      const fn = d.file_name ?? "";
+      const dotIdx = fn.lastIndexOf(".");
+      const ext = dotIdx >= 0 ? fn.slice(dotIdx).toLowerCase() : "";
+      return exts.includes(ext);
+    });
+  }
+  if (opts.query) {
+    const q = opts.query.toLowerCase();
+    result = result.filter((d) => {
+      const fn = (d.file_name ?? "").toLowerCase();
+      const meta = d.doc_metadata;
+      const title = (meta?.title ?? "").toLowerCase();
+      const subject = (meta?.doc_subject ?? "").toLowerCase();
+      return fn.includes(q) || title.includes(q) || subject.includes(q);
+    });
+  }
+  return result;
+}
+async function fetchDocChoices(arbi, _workspaceId) {
   const data = await sdk.documents.listDocuments(arbi);
   if (data.length === 0) {
     console.log("No documents found.");
@@ -4601,18 +4669,102 @@ async function fetchDocChoices(arbi, workspaceId) {
   }));
 }
 function registerDocsCommand(program2) {
-  program2.command("docs").description("List documents in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
+  program2.command("docs").description("List documents in the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("--json", "Output as JSON").option("--csv", "Output as CSV").option("--ids", "Output only document IDs (one per line)").option("--count", "Output only the count (combine with --status for filtered count)").option("-s, --status <status>", "Filter by status (comma-separated: completed,failed,queued)").option("-f, --folder <pattern>", "Filter by folder (substring match)").option("-e, --ext <extensions>", "Filter by file extension (comma-separated: pdf,docx,eml)").option("-q, --query <text>", "Search file name, title, or summary").option("--sort <field>", "Sort by field (name, status, date, size, created)", "status").option("-n, --limit <n>", "Limit number of results").action(
     (opts) => runAction(async () => {
-      const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
-      const data = await sdk.documents.listDocuments(arbi);
+      const { arbi } = await resolveWorkspace(opts.workspace);
+      let data = await sdk.documents.listDocuments(arbi);
       if (data.length === 0) {
         console.log("No documents found.");
         return;
       }
+      data = filterDocs(data, opts);
+      const sortField = opts.sort ?? "status";
+      data.sort((a, b) => {
+        switch (sortField) {
+          case "name":
+            return (a.file_name ?? "").localeCompare(b.file_name ?? "");
+          case "size":
+            return (b.file_size ?? 0) - (a.file_size ?? 0);
+          case "date":
+          case "created":
+            return (b.created_at ?? "").localeCompare(a.created_at ?? "");
+          case "status":
+          default:
+            return (a.status ?? "").localeCompare(b.status ?? "");
+        }
+      });
+      if (opts.limit) {
+        data = data.slice(0, parseInt(opts.limit, 10));
+      }
+      if (opts.count) {
+        if (opts.status || opts.folder || opts.ext || opts.query) {
+          console.log(String(data.length));
+        } else {
+          const counts = {};
+          data.forEach((d) => {
+            const s = d.status ?? "unknown";
+            counts[s] = (counts[s] ?? 0) + 1;
+          });
+          const withSummary = data.filter((d) => {
+            const m = d.doc_metadata;
+            return m?.doc_subject;
+          }).length;
+          const totalPages = data.reduce((sum, d) => sum + (d.n_pages ?? 0), 0);
+          const totalTokens = data.reduce((sum, d) => sum + (d.tokens ?? 0), 0);
+          console.log(chalk2__default.default.bold(`Total: ${data.length} documents`));
+          for (const [status2, count] of Object.entries(counts).sort()) {
+            const colorFn = statusColor(status2);
+            const pct = (count / data.length * 100).toFixed(1);
+            console.log(`  ${colorFn(statusSymbol(status2))} ${status2}: ${count} (${pct}%)`);
+          }
+          console.log(`  With summaries: ${withSummary}`);
+          console.log(`  Total pages: ${totalPages.toLocaleString()}`);
+          console.log(`  Total tokens: ${totalTokens.toLocaleString()}`);
+        }
+        return;
+      }
+      if (opts.ids) {
+        data.forEach((d) => console.log(d.external_id));
+        return;
+      }
+      if (opts.json) {
+        console.log(JSON.stringify(data));
+        return;
+      }
+      if (opts.csv) {
+        console.log("external_id,status,file_name,file_size,folder,n_pages,tokens,doc_date,title");
+        for (const d of data) {
+          const meta = d.doc_metadata;
+          const csvEscape = (s) => `"${(s ?? "").replace(/"/g, '""')}"`;
+          console.log(
+            [
+              d.external_id,
+              d.status,
+              csvEscape(d.file_name ?? ""),
+              d.file_size ?? "",
+              csvEscape(d.folder ?? ""),
+              d.n_pages ?? "",
+              d.tokens ?? "",
+              meta?.doc_date ?? "",
+              csvEscape(meta?.title ?? "")
+            ].join(",")
+          );
+        }
+        return;
+      }
+      console.log(chalk2__default.default.dim(`${data.length} documents
+`));
       printTable(
         [
           { header: "ID", width: 24, value: (r) => r.external_id },
-          { header: "S", width: 2, value: (r) => statusSymbol(r.status) },
+          {
+            header: "S",
+            width: 4,
+            value: (r) => {
+              const s = r.status;
+              return statusColor(s)(statusSymbol(s));
+            }
+          },
           {
             header: "TITLE",
             width: 34,
@@ -4621,6 +4773,16 @@ function registerDocsCommand(program2) {
               return meta?.title ?? r.file_name ?? "Unnamed";
             }
           },
+          {
+            header: "SIZE",
+            width: 8,
+            value: (r) => formatSize(r.file_size)
+          },
+          {
+            header: "PAGES",
+            width: 6,
+            value: (r) => r.n_pages ? String(r.n_pages) : "-"
+          },
           {
             header: "DATE",
             width: 12,
@@ -4630,12 +4792,9 @@ function registerDocsCommand(program2) {
             }
           },
           {
-            header: "SUMMARY",
-            width: 50,
-            value: (r) => {
-              const meta = r.doc_metadata;
-              return meta?.doc_subject ?? "-";
-            }
+            header: "FOLDER",
+            width: 30,
+            value: (r) => r.folder ?? "-"
           }
         ],
         data
@@ -4732,9 +4891,11 @@ function registerDocsCommand(program2) {
     (urls, opts) => runAction(async () => {
       const { arbi, workspaceId } = await resolveWorkspace(opts.workspace);
       const data = await sdk.documents.uploadUrl(arbi, urls, workspaceId, opts.shared ?? false);
-      success(`Uploaded: ${data.doc_ext_ids.join(", ")}`);
-      if (data.duplicates && data.duplicates.length > 0) {
-        warn(`Duplicates: ${data.duplicates.join(", ")}`);
+      success(`Uploaded: ${(data.doc_ext_ids ?? []).join(", ")}`);
+      if (data.skipped && data.skipped.length > 0) {
+        warn(
+          `Skipped: ${data.skipped.map((s) => `${s.file_name} (${s.reason})`).join(", ")}`
+        );
       }
     })()
   );
@@ -4755,68 +4916,262 @@ function registerDocsCommand(program2) {
       console.log(JSON.stringify(data, null, 2));
     })()
   );
+  doc.command("reprocess [ids...]").description("Reprocess failed/completed documents (sets status back to processing)").option("-s, --status <status>", "Reprocess all docs with this status (e.g. failed)").option("-f, --folder <pattern>", "Filter by folder (substring match)").option("--dry-run", "Show what would be reprocessed without doing it").option("-b, --batch-size <n>", "Batch size for update requests", "50").action(
+    (ids, opts) => runAction(async () => {
+      const { arbi } = await resolveWorkspace();
+      let docIds;
+      if (ids && ids.length > 0) {
+        docIds = ids;
+      } else if (opts.status) {
+        const allDocs = await sdk.documents.listDocuments(arbi);
+        let filtered = allDocs.filter((d) => d.status === opts.status);
+        if (opts.folder) {
+          const pattern = opts.folder.toLowerCase();
+          filtered = filtered.filter(
+            (d) => (d.folder ?? "").toLowerCase().includes(pattern)
+          );
+        }
+        docIds = filtered.map((d) => d.external_id);
+      } else {
+        error("Provide document IDs or use --status to select documents to reprocess.");
+        process.exit(1);
+        return;
+      }
+      if (docIds.length === 0) {
+        console.log("No documents match the criteria.");
+        return;
+      }
+      console.log(`${docIds.length} document(s) to reprocess.`);
+      if (opts.dryRun) {
+        docIds.forEach((id) => console.log(`  ${id}`));
+        console.log(chalk2__default.default.dim("\n(dry run \u2014 no changes made)"));
+        return;
+      }
+      const batchSize = parseInt(opts.batchSize ?? "50", 10);
+      let processed = 0;
+      for (let i = 0; i < docIds.length; i += batchSize) {
+        const batch = docIds.slice(i, i + batchSize);
+        const updates = batch.map((id) => ({ external_id: id, status: "processing" }));
+        await sdk.documents.updateDocuments(
+          arbi,
+          updates
+        );
+        processed += batch.length;
+        console.log(`  [${processed}/${docIds.length}] Triggered reprocessing...`);
+      }
+      success(`Triggered reprocessing for ${docIds.length} document(s).`);
+    })()
+  );
+}
+function printSummary(summary) {
+  console.log("");
+  console.log("Upload summary:");
+  console.log(`  Files found:  ${summary.totalFiles}`);
+  success(`  Uploaded:     ${summary.uploaded}`);
+  if (summary.skipped > 0) {
+    warn(`  Skipped:      ${summary.skipped}`);
+  }
+  console.log(`  Folders:      ${summary.folders}`);
+  if (summary.skippedDetails.length > 0) {
+    console.log("");
+    warn("Skipped files:");
+    for (const s of summary.skippedDetails) {
+      warn(`  ${s.file_name}: ${s.reason}`);
+    }
+  }
 }
 function registerUploadCommand(program2) {
-  program2.command("add <paths...>").alias("upload").description("Add files, directories, or zip archives to the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-W, --watch", "Watch document processing progress after upload").option("--no-watch", "Skip watching document processing").action(
+  program2.command("add [paths...]").alias("upload").description("Add files, directories, or zip archives to the active workspace").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-W, --watch", "Watch document processing progress after upload").option("--no-watch", "Skip watching document processing").option("--dry-run", "Show what would be uploaded without uploading").option("--json", "Output results as JSON").option("--config <id>", "Config ext_id to use (e.g. cfg-xxx for SKIP_DUPLICATES)").option("--manifest <file>", "Read newline-delimited paths from file (eDiscovery mode)").option("--log <file>", "Append per-file JSONL audit log (eDiscovery mode)").option("--resume", "Skip paths already completed in --log (requires --log)").option("--fail-fast", "Abort on first upload error").option("--root <dir>", "Root directory for backend folder paths (defaults to common parent)").option(
+    "--limit <n>",
+    "Max files to upload this run (applied after --resume filter, manifest mode only)"
+  ).action(
     (paths, opts) => runAction(async () => {
-      for (const p of paths) {
-        if (!fs2__default.default.existsSync(p)) {
+      const isManifestMode = Boolean(opts.manifest || opts.log || opts.resume);
+      const inputPaths = paths ?? [];
+      if (isManifestMode) {
+        await runManifestMode(inputPaths, opts);
+        return;
+      }
+      if (inputPaths.length === 0) {
+        error("No paths provided. Pass file/dir args or use --manifest <file>.");
+        process.exit(1);
+      }
+      for (const p of inputPaths) {
+        if (!fs4__default.default.existsSync(p)) {
           error(`Path not found: ${p}`);
           process.exit(1);
         }
       }
-      const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace);
+      const isInteractive = process.stdout.isTTY === true;
+      const watchPref = getConfig()?.watch !== false;
+      const willWatch = opts.watch === false ? false : opts.watch === true || watchPref && isInteractive;
+      const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace, {
+        skipNotifications: willWatch
+      });
       const uploadedDocs = /* @__PURE__ */ new Map();
       const auth = { baseUrl: config.baseUrl, accessToken };
-      for (const filePath of paths) {
-        const stat = fs2__default.default.statSync(filePath);
+      const summary = {
+        totalFiles: 0,
+        uploaded: 0,
+        skipped: 0,
+        duplicates: 0,
+        folders: 0,
+        docIds: [],
+        skippedDetails: []
+      };
+      const progressCallbacks = {
+        configExtId: opts.config,
+        onBatchStart: (progress) => {
+          if (!opts.json) {
+            dim(
+              `  [${progress.batch}/${progress.totalBatches}] Uploading ${progress.filesInBatch} file(s) from ${progress.folder}...`
+            );
+          }
+        },
+        onBatchComplete: (progress) => {
+          const uploaded = progress.result.doc_ext_ids?.length ?? 0;
+          const skipped = progress.result.skipped?.length ?? 0;
+          if (!opts.json) {
+            success(
+              `  [${progress.batch}/${progress.totalBatches}] ${uploaded} uploaded, ${skipped} skipped (${progress.filesUploaded}/${progress.totalFiles} total)`
+            );
+          }
+        }
+      };
+      for (const filePath of inputPaths) {
+        const stat = fs4__default.default.statSync(filePath);
         if (stat.isDirectory()) {
-          const result = await sdk.documentsNode.uploadDirectory(auth, workspaceId, filePath);
-          if (result.doc_ext_ids.length === 0) {
+          if (opts.dryRun) {
+            const count = countSupportedFiles(filePath);
+            console.log(`${filePath}: ${count} supported file(s) would be uploaded`);
+            summary.totalFiles += count;
+            continue;
+          }
+          const result = await sdk.documentsNode.uploadDirectory(
+            auth,
+            workspaceId,
+            filePath,
+            progressCallbacks
+          );
+          if (result.doc_ext_ids.length === 0 && result.skipped.length === 0) {
             warn(`No supported files found in directory: ${filePath}`);
             continue;
           }
-          for (const [folder, info] of result.folders) {
+          if (!opts.json) {
+            for (const [folder, info] of result.folders) {
+              success(
+                `  ${folder}: ${info.fileCount} file(s) \u2192 ${info.doc_ext_ids.length} uploaded`
+              );
+              if (info.skipped.length > 0) {
+                warn(
+                  `    Skipped: ${info.skipped.map((s) => `${s.file_name} (${s.reason})`).join(", ")}`
+                );
+              }
+            }
             success(
-              `  ${folder}: ${info.fileCount} file(s) \u2192 ${info.doc_ext_ids.length} uploaded`
+              `Uploaded directory: ${filePath} (${result.doc_ext_ids.length} document(s) total)`
             );
-            if (info.duplicates.length > 0) {
-              warn(`    Duplicates: ${info.duplicates.join(", ")}`);
-            }
           }
-          success(
-            `Uploaded directory: ${filePath} (${result.doc_ext_ids.length} document(s) total)`
-          );
+          updateSummary(summary, result);
           for (const id of result.doc_ext_ids) uploadedDocs.set(id, filePath);
         } else if (filePath.toLowerCase().endsWith(".zip")) {
-          const result = await sdk.documentsNode.uploadZip(auth, workspaceId, filePath);
-          if (result.doc_ext_ids.length === 0) {
+          if (opts.dryRun) {
+            console.log(`${filePath}: zip archive (contents would be extracted and uploaded)`);
+            continue;
+          }
+          const result = await sdk.documentsNode.uploadZip(
+            auth,
+            workspaceId,
+            filePath,
+            progressCallbacks
+          );
+          if (result.doc_ext_ids.length === 0 && result.skipped.length === 0) {
             warn(`No supported files found in zip: ${filePath}`);
             continue;
           }
-          for (const [folder, info] of result.folders) {
+          if (!opts.json) {
+            for (const [folder, info] of result.folders) {
+              success(
+                `  ${folder}: ${info.fileCount} file(s) \u2192 ${info.doc_ext_ids.length} uploaded`
+              );
+              if (info.skipped.length > 0) {
+                warn(
+                  `    Skipped: ${info.skipped.map((s) => `${s.file_name} (${s.reason})`).join(", ")}`
+                );
+              }
+            }
+            success(`Uploaded zip: ${filePath} (${result.doc_ext_ids.length} document(s) total)`);
+          }
+          updateSummary(summary, result);
+          for (const id of result.doc_ext_ids) uploadedDocs.set(id, filePath);
+        } else if (sdk.documentsNode.ARCHIVE_EXTENSIONS.has(
+          filePath.slice(filePath.lastIndexOf(".")).toLowerCase()
+        )) {
+          if (opts.dryRun) {
+            console.log(`${filePath}: archive (contents would be extracted and uploaded)`);
+            continue;
+          }
+          const result = await sdk.documentsNode.uploadArchive(
+            auth,
+            workspaceId,
+            filePath,
+            progressCallbacks
+          );
+          if (result.doc_ext_ids.length === 0 && result.skipped.length === 0) {
+            warn(`No supported files found in archive: ${filePath}`);
+            continue;
+          }
+          if (!opts.json) {
+            for (const [folder, info] of result.folders) {
+              success(
+                `  ${folder}: ${info.fileCount} file(s) \u2192 ${info.doc_ext_ids.length} uploaded`
+              );
+              if (info.skipped.length > 0) {
+                warn(
+                  `    Skipped: ${info.skipped.map((s) => `${s.file_name} (${s.reason})`).join(", ")}`
+                );
+              }
+            }
             success(
-              `  ${folder}: ${info.fileCount} file(s) \u2192 ${info.doc_ext_ids.length} uploaded`
+              `Uploaded archive: ${filePath} (${result.doc_ext_ids.length} document(s) total)`
             );
-            if (info.duplicates.length > 0) {
-              warn(`    Duplicates: ${info.duplicates.join(", ")}`);
-            }
           }
-          success(`Uploaded zip: ${filePath} (${result.doc_ext_ids.length} document(s) total)`);
+          updateSummary(summary, result);
           for (const id of result.doc_ext_ids) uploadedDocs.set(id, filePath);
         } else {
+          if (opts.dryRun) {
+            console.log(`${filePath}: single file would be uploaded`);
+            summary.totalFiles += 1;
+            continue;
+          }
           const result = await sdk.documentsNode.uploadLocalFile(auth, workspaceId, filePath);
-          success(`Uploaded: ${result.fileName} (${result.doc_ext_ids.join(", ")})`);
-          if (result.duplicates && result.duplicates.length > 0) {
-            warn(`  Duplicates: ${result.duplicates.join(", ")}`);
+          if (!opts.json) {
+            success(`Uploaded: ${result.fileName} (${(result.doc_ext_ids ?? []).join(", ")})`);
+            if (result.skipped && result.skipped.length > 0) {
+              warn(
+                `  Skipped: ${result.skipped.map((s) => `${s.file_name} (${s.reason})`).join(", ")}`
+              );
+            }
+          }
+          summary.totalFiles += 1;
+          summary.uploaded += result.doc_ext_ids?.length ?? 0;
+          summary.docIds.push(...result.doc_ext_ids ?? []);
+          if (result.skipped) {
+            summary.skipped += result.skipped.length;
+            summary.skippedDetails.push(...result.skipped);
           }
-          for (const id of result.doc_ext_ids) uploadedDocs.set(id, result.fileName);
+          for (const id of result.doc_ext_ids ?? []) uploadedDocs.set(id, result.fileName);
         }
       }
-      const isInteractive = process.stdout.isTTY === true;
-      const watchPref = getConfig()?.watch !== false;
-      const shouldWatch = opts.watch === false ? false : opts.watch === true || watchPref && isInteractive;
-      if (shouldWatch && uploadedDocs.size > 0) {
+      if (opts.dryRun) {
+        return;
+      }
+      if (opts.json) {
+        console.log(JSON.stringify(summary));
+      } else {
+        printSummary(summary);
+      }
+      if (willWatch && uploadedDocs.size > 0) {
         const pending = new Set(uploadedDocs.keys());
         const failed = /* @__PURE__ */ new Map();
         console.log(`
@@ -4868,7 +5223,7 @@ Connection closed. ${pending.size} document(s) still processing.`);
           }
         });
         await done;
-      } else if (uploadedDocs.size > 0 && !shouldWatch) {
+      } else if (uploadedDocs.size > 0 && !willWatch) {
         dim(
           'Tip: Use -W/--watch to monitor processing progress, or run "arbi docs" to check status.'
         );
@@ -4876,6 +5231,501 @@ Connection closed. ${pending.size} document(s) still processing.`);
     })()
   );
 }
+function updateSummary(summary, result) {
+  let totalFiles = 0;
+  for (const [, info] of result.folders) {
+    totalFiles += info.fileCount;
+    summary.folders += 1;
+  }
+  summary.totalFiles += totalFiles;
+  summary.uploaded += result.doc_ext_ids.length;
+  summary.skipped += result.skipped.length;
+  summary.docIds.push(...result.doc_ext_ids);
+  summary.skippedDetails.push(...result.skipped);
+}
+function countSupportedFiles(dirPath) {
+  let count = 0;
+  for (const entry of fs4__default.default.readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = `${dirPath}/${entry.name}`;
+    if (entry.isDirectory()) {
+      count += countSupportedFiles(fullPath);
+    } else if (entry.isFile()) {
+      const ext = entry.name.toLowerCase().lastIndexOf(".");
+      if (ext >= 0) {
+        const extStr = entry.name.slice(ext).toLowerCase();
+        if (sdk.documents.SUPPORTED_EXTENSIONS.has(extStr)) {
+          count++;
+        }
+      }
+    }
+  }
+  return count;
+}
+function readLogState(logPath) {
+  const state = /* @__PURE__ */ new Map();
+  if (!fs4__default.default.existsSync(logPath)) return state;
+  const text = fs4__default.default.readFileSync(logPath, "utf8");
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    try {
+      const rec = JSON.parse(trimmed);
+      if (rec.event) continue;
+      if (typeof rec.path === "string" && typeof rec.status === "string") {
+        state.set(rec.path, rec.status);
+      }
+    } catch {
+    }
+  }
+  return state;
+}
+function readTextManifest(manifestPath) {
+  const text = fs4__default.default.readFileSync(manifestPath, "utf8");
+  const out = [];
+  for (const raw of text.split("\n")) {
+    const line = raw.replace(/\r$/, "").trim();
+    if (!line || line.startsWith("#")) continue;
+    out.push(line);
+  }
+  return out;
+}
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let cur = "";
+  let inQuotes = false;
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          cur += '"';
+          i += 2;
+          continue;
+        }
+        inQuotes = false;
+        i++;
+      } else {
+        cur += ch;
+        i++;
+      }
+    } else if (ch === '"' && cur === "") {
+      inQuotes = true;
+      i++;
+    } else if (ch === ",") {
+      row.push(cur);
+      cur = "";
+      i++;
+    } else if (ch === "\n" || ch === "\r") {
+      row.push(cur);
+      cur = "";
+      rows.push(row);
+      row = [];
+      if (ch === "\r" && text[i + 1] === "\n") i += 2;
+      else i++;
+    } else {
+      cur += ch;
+      i++;
+    }
+  }
+  if (cur !== "" || row.length > 0) {
+    row.push(cur);
+    rows.push(row);
+  }
+  if (rows.length > 0 && rows[rows.length - 1].length === 1 && rows[rows.length - 1][0] === "") {
+    rows.pop();
+  }
+  return rows;
+}
+function csvField(v) {
+  if (v.includes(",") || v.includes('"') || v.includes("\n") || v.includes("\r")) {
+    return '"' + v.replace(/"/g, '""') + '"';
+  }
+  return v;
+}
+function writeCsvAtomic(filePath, header, rows) {
+  const lines = [header.map(csvField).join(",")];
+  for (const row of rows) {
+    const padded = row.slice();
+    while (padded.length < header.length) padded.push("");
+    lines.push(padded.map(csvField).join(","));
+  }
+  const tmp = filePath + ".tmp";
+  fs4__default.default.writeFileSync(tmp, lines.join("\n") + "\n");
+  fs4__default.default.renameSync(tmp, filePath);
+}
+function findColumn(header, candidates) {
+  const normalized = header.map((h) => h.trim().toLowerCase());
+  for (const cand of candidates) {
+    const i = normalized.indexOf(cand.toLowerCase());
+    if (i >= 0) return i;
+  }
+  return -1;
+}
+function loadCsvManifest(csvPath, rootDir) {
+  const text = fs4__default.default.readFileSync(csvPath, "utf8");
+  const all = parseCsv(text);
+  if (all.length === 0) {
+    error(`Empty CSV: ${csvPath}`);
+    process.exit(1);
+  }
+  const header = all[0];
+  const rows = all.slice(1);
+  const nameCol = findColumn(header, ["Document Name", "Name", "File Name", "Filename"]);
+  if (nameCol < 0) {
+    error(`CSV ${csvPath} is missing a Document Name / Name column.`);
+    process.exit(1);
+  }
+  const folderCol = findColumn(header, ["Folder", "Path", "Directory"]);
+  if (folderCol < 0) {
+    error(`CSV ${csvPath} is missing a Folder / Path column.`);
+    process.exit(1);
+  }
+  let docIdCol = findColumn(header, ["ARBI Doc ID", "Doc ID", "DocId"]);
+  let statusCol = findColumn(header, ["ARBI Status", "Status"]);
+  if (docIdCol < 0) {
+    header.push("ARBI Doc ID");
+    docIdCol = header.length - 1;
+  }
+  if (statusCol < 0) {
+    header.push("ARBI Status");
+    statusCol = header.length - 1;
+  }
+  for (const row of rows) {
+    while (row.length < header.length) row.push("");
+  }
+  const root = rootDir ? path4__default.default.resolve(rootDir) : process.cwd();
+  const paths = [];
+  const pathToRow = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const name = (row[nameCol] ?? "").trim();
+    if (!name) continue;
+    const folder = (row[folderCol] ?? "").trim();
+    const rel = folder ? path4__default.default.join(folder, name) : name;
+    const abs = path4__default.default.resolve(root, rel);
+    paths.push(abs);
+    pathToRow.set(abs, i);
+  }
+  return {
+    filePath: csvPath,
+    header,
+    rows,
+    nameCol,
+    folderCol,
+    docIdCol,
+    statusCol,
+    paths,
+    pathToRow
+  };
+}
+async function runManifestMode(inputPaths, opts) {
+  if (opts.resume && !opts.log) {
+    error("--resume requires --log <file>");
+    process.exit(1);
+  }
+  const rawPaths = [];
+  let csv = null;
+  if (opts.manifest) {
+    if (!fs4__default.default.existsSync(opts.manifest)) {
+      error(`Manifest not found: ${opts.manifest}`);
+      process.exit(1);
+    }
+    const ext = path4__default.default.extname(opts.manifest).toLowerCase();
+    if (ext === ".csv" || ext === ".tsv") {
+      csv = loadCsvManifest(opts.manifest, opts.root);
+      rawPaths.push(...csv.paths);
+    } else {
+      rawPaths.push(...readTextManifest(opts.manifest));
+    }
+  }
+  for (const p of inputPaths) {
+    if (!fs4__default.default.existsSync(p)) {
+      error(`Path not found: ${p}`);
+      process.exit(1);
+    }
+    const stat = fs4__default.default.statSync(p);
+    if (stat.isDirectory()) {
+      rawPaths.push(...sdk.documentsNode.walkSupportedFiles(p));
+    } else {
+      rawPaths.push(path4__default.default.resolve(p));
+    }
+  }
+  if (rawPaths.length === 0) {
+    error("Manifest is empty. Nothing to upload.");
+    process.exit(1);
+  }
+  let pathsToUpload = rawPaths;
+  const priorState = opts.log ? readLogState(opts.log) : /* @__PURE__ */ new Map();
+  let resumedCount = 0;
+  if (opts.resume) {
+    pathsToUpload = rawPaths.filter((p) => {
+      const prior = priorState.get(p);
+      if (prior === "uploaded" || prior === "duplicate" || prior === "rejected" || prior === "skipped") {
+        resumedCount++;
+        return false;
+      }
+      return true;
+    });
+  }
+  let limit = null;
+  let limitedOut = 0;
+  if (opts.limit !== void 0) {
+    const n = Number.parseInt(opts.limit, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+      error(`Invalid --limit: ${opts.limit}. Must be a positive integer.`);
+      process.exit(1);
+    }
+    limit = n;
+    if (pathsToUpload.length > n) {
+      limitedOut = pathsToUpload.length - n;
+      pathsToUpload = pathsToUpload.slice(0, n);
+    }
+  }
+  const isInteractive = process.stdout.isTTY === true;
+  const humanOutput = !opts.json;
+  if (humanOutput) {
+    console.log(
+      `Manifest: ${rawPaths.length} file(s)` + (csv ? ` from ${path4__default.default.basename(csv.filePath)}` : "") + (resumedCount ? ` (${resumedCount} already done, skipping)` : "") + (limit !== null && limitedOut > 0 ? ` (limit=${limit}, ${limitedOut} deferred to next run)` : "")
+    );
+  }
+  if (opts.dryRun) {
+    if (opts.json) {
+      console.log(
+        JSON.stringify({
+          total: rawPaths.length,
+          resumed: resumedCount,
+          toUpload: pathsToUpload.length
+        })
+      );
+    } else {
+      console.log(`Would upload ${pathsToUpload.length} file(s)`);
+    }
+    return;
+  }
+  if (pathsToUpload.length === 0) {
+    if (humanOutput) success("Nothing to do \u2014 all paths already completed in log.");
+    return;
+  }
+  const watchPref = getConfig()?.watch !== false;
+  const willWatch = opts.watch === false ? false : opts.watch === true || watchPref && isInteractive;
+  const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace, {
+    skipNotifications: willWatch
+  });
+  const auth = { baseUrl: config.baseUrl, accessToken };
+  let logFd = null;
+  if (opts.log) {
+    const dir = path4__default.default.dirname(path4__default.default.resolve(opts.log));
+    fs4__default.default.mkdirSync(dir, { recursive: true });
+    logFd = fs4__default.default.openSync(opts.log, "a");
+    const header = JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "run_start",
+      workspace: workspaceId,
+      config: opts.config ?? null,
+      inputs: rawPaths.length,
+      toUpload: pathsToUpload.length,
+      resumed: resumedCount
+    });
+    fs4__default.default.writeSync(logFd, header + "\n");
+    fs4__default.default.fsyncSync(logFd);
+  }
+  const uploadedDocs = /* @__PURE__ */ new Map();
+  const runStart = Date.now();
+  const writeLog = (o) => {
+    if (logFd === null) return;
+    const rec = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      path: o.path,
+      folder: o.folder,
+      sizeBytes: o.sizeBytes,
+      status: o.status,
+      ...o.docId ? { docId: o.docId } : {},
+      ...o.reason ? { reason: o.reason } : {},
+      attempt: o.attempt,
+      ...o.batchId ? { batchId: o.batchId } : {}
+    };
+    fs4__default.default.writeSync(logFd, JSON.stringify(rec) + "\n");
+    fs4__default.default.fsyncSync(logFd);
+  };
+  const total = pathsToUpload.length;
+  let done = 0;
+  let uploadedCount = 0;
+  let duplicateCount = 0;
+  let rejectedCount = 0;
+  let errorCount = 0;
+  let skippedCount = 0;
+  const renderProgress = () => {
+    if (!humanOutput || !isInteractive) return;
+    const pct = total > 0 ? Math.floor(done / total * 100) : 100;
+    const line = `  ${done}/${total} (${pct}%)  ok=${uploadedCount}` + (duplicateCount > 0 ? ` dup=${duplicateCount}` : "") + (rejectedCount > 0 ? ` rej=${rejectedCount}` : "") + (skippedCount > 0 ? ` skip=${skippedCount}` : "") + (errorCount > 0 ? ` err=${errorCount}` : "");
+    process.stderr.write("\r" + line.padEnd(80, " "));
+  };
+  const clearProgress = () => {
+    if (humanOutput && isInteractive) process.stderr.write("\r" + " ".repeat(80) + "\r");
+  };
+  const printInlineOutcome = (o) => {
+    if (!humanOutput) return;
+    const name = path4__default.default.basename(o.path);
+    if (o.status === "rejected") {
+      clearProgress();
+      warn(`  \u2717 ${name}: ${o.reason}`);
+    } else if (o.status === "error") {
+      clearProgress();
+      error(`  ! ${name}: ${o.reason}`);
+    }
+  };
+  let sinceCheckpoint = 0;
+  const CHECKPOINT_EVERY = 25;
+  const csvStatusText = (o) => {
+    if (o.status === "uploaded") return "uploaded";
+    if (o.status === "duplicate") return `duplicate: ${o.reason ?? ""}`.trim();
+    if (o.status === "rejected") return `rejected: ${o.reason ?? ""}`.trim();
+    if (o.status === "skipped") return `skipped: ${o.reason ?? ""}`.trim();
+    return `error: ${o.reason ?? ""}`.trim();
+  };
+  const flushCsv = () => {
+    if (csv === null) return;
+    writeCsvAtomic(csv.filePath, csv.header, csv.rows);
+  };
+  const result = await sdk.documentsNode.uploadManifest(auth, workspaceId, pathsToUpload, {
+    rootDir: opts.root,
+    configExtId: opts.config,
+    failFast: opts.failFast,
+    onFile: async (outcome) => {
+      writeLog(outcome);
+      done++;
+      switch (outcome.status) {
+        case "uploaded":
+          uploadedCount++;
+          if (outcome.docId) uploadedDocs.set(outcome.docId, path4__default.default.basename(outcome.path));
+          break;
+        case "duplicate":
+          duplicateCount++;
+          break;
+        case "rejected":
+          rejectedCount++;
+          break;
+        case "error":
+          errorCount++;
+          break;
+        case "skipped":
+          skippedCount++;
+          break;
+      }
+      printInlineOutcome(outcome);
+      renderProgress();
+      if (csv !== null) {
+        const rowIdx = csv.pathToRow.get(outcome.path);
+        if (rowIdx !== void 0) {
+          if (outcome.docId) csv.rows[rowIdx][csv.docIdCol] = outcome.docId;
+          csv.rows[rowIdx][csv.statusCol] = csvStatusText(outcome);
+          sinceCheckpoint++;
+          if (sinceCheckpoint >= CHECKPOINT_EVERY) {
+            flushCsv();
+            sinceCheckpoint = 0;
+          }
+        }
+      }
+    }
+  });
+  if (csv !== null && sinceCheckpoint > 0) flushCsv();
+  if (logFd !== null) {
+    const footer = JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "run_end",
+      ...result.summary,
+      elapsedMs: Date.now() - runStart
+    });
+    fs4__default.default.writeSync(logFd, footer + "\n");
+    fs4__default.default.fsyncSync(logFd);
+    fs4__default.default.closeSync(logFd);
+  }
+  clearProgress();
+  if (opts.json) {
+    console.log(
+      JSON.stringify({
+        ...result.summary,
+        elapsedMs: Date.now() - runStart,
+        docIds: result.outcomes.filter((o) => o.docId).map((o) => o.docId)
+      })
+    );
+  } else {
+    const elapsed = ((Date.now() - runStart) / 1e3).toFixed(1);
+    console.log("");
+    console.log("Upload summary");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`  Files:       ${result.summary.total}`);
+    if (result.summary.uploaded > 0) success(`  Uploaded:    ${result.summary.uploaded}`);
+    if (result.summary.duplicate > 0) dim(`  Duplicates:  ${result.summary.duplicate}`);
+    if (result.summary.rejected > 0) warn(`  Rejected:    ${result.summary.rejected}`);
+    if (result.summary.skipped > 0) dim(`  Skipped:     ${result.summary.skipped}`);
+    if (result.summary.error > 0) error(`  Errors:      ${result.summary.error}`);
+    console.log(`  Elapsed:     ${elapsed}s`);
+    if (opts.log) dim(`  Log:         ${opts.log}`);
+    if (csv) dim(`  CSV:         ${csv.filePath} (updated)`);
+  }
+  if (result.summary.error > 0) {
+    if (!opts.json) {
+      dim("\nSome files errored. Re-run with --resume to retry failed entries.");
+    }
+    process.exit(1);
+  }
+  if (willWatch && uploadedDocs.size > 0) {
+    const pending = new Set(uploadedDocs.keys());
+    const failed = /* @__PURE__ */ new Map();
+    console.log(`
+Watching ${pending.size} document(s)...`);
+    let onDone;
+    const done2 = new Promise((r) => {
+      onDone = r;
+    });
+    const conn = await sdk.connectWebSocket({
+      baseUrl: config.baseUrl,
+      accessToken,
+      onMessage: (msg) => {
+        if (client.isMessageType(msg, "task_update")) {
+          if (!pending.has(msg.doc_ext_id)) return;
+          const docName = uploadedDocs.get(msg.doc_ext_id) || msg.file_name;
+          const extra = msg;
+          if (msg.status === "failed") {
+            const reason = extra.error_reason || extra.status_details || extra.detail || "Unknown error";
+            failed.set(msg.doc_ext_id, reason);
+            console.log(`  ${docName}: ${status(msg.status)} \u2014 ${reason}`);
+            pending.delete(msg.doc_ext_id);
+          } else {
+            console.log(`  ${docName}: ${status(msg.status)} (${msg.progress}%)`);
+            if (msg.status === "completed") {
+              pending.delete(msg.doc_ext_id);
+            }
+          }
+          if (pending.size === 0) {
+            conn.close();
+          }
+        }
+      },
+      onClose: () => {
+        if (failed.size > 0) {
+          error(`
+${failed.size} document(s) failed to process:`);
+          for (const [docId, reason] of failed) {
+            error(`  ${uploadedDocs.get(docId) || docId}: ${reason}`);
+          }
+        }
+        if (pending.size > 0) {
+          warn(`
+Connection closed. ${pending.size} document(s) still processing.`);
+          dim('Run "arbi watch" to continue monitoring, or "arbi docs" to check status.');
+        } else if (failed.size === 0 && uploadedDocs.size > 0) {
+          success("\nAll documents processed successfully.");
+        }
+        onDone();
+      }
+    });
+    await done2;
+  }
+}
 function registerDownloadCommand(program2) {
   program2.command("download [doc-id]").description("Download a document (interactive picker if no ID given)").option("-o, --output <path>", "Output file path").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").action(
     (docId, opts) => runAction(async () => {
@@ -4903,11 +5753,11 @@ function registerDownloadCommand(program2) {
         const match = disposition.match(/filename[*]?=(?:UTF-8''|"?)([^";]+)/i);
         if (match) filename = decodeURIComponent(match[1].replace(/"/g, ""));
       }
-      const outputPath = opts.output || path__default.default.join(process.cwd(), filename);
+      const outputPath = opts.output || path4__default.default.join(process.cwd(), filename);
       const buffer = Buffer.from(await res.arrayBuffer());
-      fs2__default.default.writeFileSync(outputPath, buffer);
+      fs4__default.default.writeFileSync(outputPath, buffer);
       success(
-        `Downloaded: ${path__default.default.basename(outputPath)} (${(buffer.length / (1024 * 1024)).toFixed(1)} MB)`
+        `Downloaded: ${path4__default.default.basename(outputPath)} (${(buffer.length / (1024 * 1024)).toFixed(1)} MB)`
       );
     })()
   );
@@ -5237,7 +6087,9 @@ function colorize2(level, text) {
 function registerWatchCommand(program2) {
   program2.command("watch").description("Watch workspace activity in real time").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-t, --timeout <seconds>", "Auto-close after N seconds").option("-n, --count <n>", "Stop after N messages").option("--json", "Output NDJSON (one JSON object per line)").action(
     (opts) => runAction(async () => {
-      const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace);
+      const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace, {
+        skipNotifications: true
+      });
       const timeoutSec = opts.timeout ? parseInt(opts.timeout, 10) : void 0;
       const maxCount = opts.count ? parseInt(opts.count, 10) : void 0;
       const jsonMode = opts.json ?? false;
@@ -6289,12 +7141,20 @@ function registerQuickstartCommand(program2) {
       const memberWorkspaces = wsList.filter(
         (ws) => ws.users?.some((u) => u.user.email === email)
       );
+      const userProjects = await sdk.projects.listProjects(arbi);
+      const defaultProjectExtId = userProjects[0]?.external_id;
+      if (!defaultProjectExtId) throw new Error("No projects found for user");
       let workspaceId;
       let workspaceName;
       if (memberWorkspaces.length === 0) {
         console.log("Creating your first workspace...");
         const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
-        const ws = await sdk.workspaces.createWorkspace(arbi, "My Workspace", encryptedKey);
+        const ws = await sdk.workspaces.createWorkspace(
+          arbi,
+          "My Workspace",
+          encryptedKey,
+          defaultProjectExtId
+        );
         workspaceId = ws.external_id;
         workspaceName = ws.name;
       } else {
@@ -6306,7 +7166,7 @@ function registerQuickstartCommand(program2) {
         if (selected === "__new__") {
           const name = await promptInput("Workspace name", false) || "My Workspace";
           const encKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
-          const ws = await sdk.workspaces.createWorkspace(arbi, name, encKey);
+          const ws = await sdk.workspaces.createWorkspace(arbi, name, encKey, defaultProjectExtId);
           workspaceId = ws.external_id;
           workspaceName = ws.name;
         } else {
@@ -6411,8 +7271,16 @@ function registerAgentCreateCommand(program2) {
           opts.password,
           store
         );
+        const userProjects = await sdk.projects.listProjects(arbi);
+        const defaultProjectExtId = userProjects[0]?.external_id;
+        if (!defaultProjectExtId) throw new Error("No projects found for agent");
         const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
-        const ws = await sdk.workspaces.createWorkspace(arbi, opts.workspaceName, encryptedKey);
+        const ws = await sdk.workspaces.createWorkspace(
+          arbi,
+          opts.workspaceName,
+          encryptedKey,
+          defaultProjectExtId
+        );
         updateConfig({ selectedWorkspaceId: ws.external_id });
         console.log("");
         success("Agent account created!");
@@ -6582,7 +7450,7 @@ function resolveTaskId(taskIdArg) {
   }
   return latest.id;
 }
-function statusColor(s) {
+function statusColor2(s) {
   if (s === "completed") return chalk2__default.default.green(s);
   if (s === "failed") return chalk2__default.default.red(s);
   if (s === "queued" || s === "in_progress") return chalk2__default.default.yellow(s);
@@ -6603,7 +7471,7 @@ function registerTaskCommand(program2) {
       printTable(
         [
           { header: "ID", width: 20, value: (r) => r.id },
-          { header: "STATUS", width: 14, value: (r) => statusColor(r.status) },
+          { header: "STATUS", width: 14, value: (r) => statusColor2(r.status) },
           { header: "QUESTION", width: 42, value: (r) => r.question },
           { header: "AGE", width: 6, value: (r) => formatAge(r.submittedAt) }
         ],
@@ -6623,7 +7491,7 @@ function registerTaskCommand(program2) {
         console.log(JSON.stringify(result, null, 2));
       } else {
         console.log(`${chalk2__default.default.bold("ID:")}     ${result.id}`);
-        console.log(`${chalk2__default.default.bold("Status:")} ${statusColor(result.status)}`);
+        console.log(`${chalk2__default.default.bold("Status:")} ${statusColor2(result.status)}`);
         if (result.model) console.log(`${chalk2__default.default.bold("Model:")}  ${result.model}`);
         if (result.usage) {
           console.log(`${chalk2__default.default.bold("Tokens:")} ${result.usage.total_tokens.toLocaleString()}`);
@@ -6680,15 +7548,15 @@ compdef _arbi_completions arbi
 ${MARKER_END}`;
 function getShellRcPath2() {
   const shell = process.env.SHELL || "";
-  if (shell.includes("zsh")) return path.join(os.homedir(), ".zshrc");
-  return path.join(os.homedir(), ".bashrc");
+  if (shell.includes("zsh")) return path4.join(os.homedir(), ".zshrc");
+  return path4.join(os.homedir(), ".bashrc");
 }
 function isZsh() {
   return (process.env.SHELL || "").includes("zsh");
 }
 function isCompletionInstalled(rcPath) {
-  if (!fs2.existsSync(rcPath)) return false;
-  const content = fs2.readFileSync(rcPath, "utf-8");
+  if (!fs4.existsSync(rcPath)) return false;
+  const content = fs4.readFileSync(rcPath, "utf-8");
   return content.includes(MARKER_START);
 }
 function removeCompletionBlock(content) {
@@ -6709,7 +7577,7 @@ function registerCompletionCommand(program2) {
       return;
     }
     const snippet = isZsh() ? ZSH_COMPLETION : BASH_COMPLETION;
-    fs2.appendFileSync(rcPath, snippet + "\n");
+    fs4.appendFileSync(rcPath, snippet + "\n");
     success(`Installed tab completion in ${rcPath}`);
     dim("");
     dim(`Run: source ${rcPath}`);
@@ -6721,9 +7589,9 @@ function registerCompletionCommand(program2) {
       dim("Completion is not installed.");
       return;
     }
-    const content = fs2.readFileSync(rcPath, "utf-8");
+    const content = fs4.readFileSync(rcPath, "utf-8");
     const cleaned = removeCompletionBlock(content);
-    fs2.writeFileSync(rcPath, cleaned);
+    fs4.writeFileSync(rcPath, cleaned);
     success(`Removed tab completion from ${rcPath}`);
     dim(`Run: source ${rcPath}`);
   });
@@ -6739,9 +7607,9 @@ function registerCompletionCommand(program2) {
 function resolvePath(p) {
   const raw = p ?? ".";
   const expanded = raw.startsWith("~") ? raw.replace("~", os.homedir()) : raw;
-  return path.resolve(expanded);
+  return path4.resolve(expanded);
 }
-function formatSize(bytes) {
+function formatSize2(bytes) {
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
   if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
@@ -6749,11 +7617,11 @@ function formatSize(bytes) {
 }
 function registerLocalCommand(program2) {
   const local = program2.command("local").description("Local filesystem operations");
-  local.command("ls [path]").description("List files in a directory").option("-l, --long", "Show file sizes and types").action((path5, opts) => {
-    const dir = resolvePath(path5);
+  local.command("ls [path]").description("List files in a directory").option("-l, --long", "Show file sizes and types").action((path6, opts) => {
+    const dir = resolvePath(path6);
     let entries;
     try {
-      entries = fs2.readdirSync(dir);
+      entries = fs4.readdirSync(dir);
     } catch {
       console.error(`Cannot read directory: ${dir}`);
       process.exit(1);
@@ -6761,9 +7629,9 @@ function registerLocalCommand(program2) {
     for (const entry of entries.filter((e) => !e.startsWith(".")).sort()) {
       if (opts?.long) {
         try {
-          const stat = fs2.statSync(path.join(dir, entry));
+          const stat = fs4.statSync(path4.join(dir, entry));
           const type = stat.isDirectory() ? "dir" : "file";
-          const size = stat.isFile() ? formatSize(stat.size) : "-";
+          const size = stat.isFile() ? formatSize2(stat.size) : "-";
           console.log(`${type.padEnd(5)} ${size.padStart(10)}  ${entry}`);
         } catch {
           console.log(`?     ${"-".padStart(10)}  ${entry}`);
@@ -6775,7 +7643,7 @@ function registerLocalCommand(program2) {
   });
   local.command("find <pattern>").description('Find files matching a glob (e.g. "**/*.pdf")').option("-d, --dir <path>", "Directory to search in", ".").action((pattern, opts) => {
     const dir = resolvePath(opts.dir);
-    const results = fs2.globSync(pattern, { cwd: dir });
+    const results = fs4.globSync(pattern, { cwd: dir });
     if (results.length === 0) {
       console.log(`No files matching "${pattern}" in ${dir}`);
       return;
@@ -6788,7 +7656,7 @@ function registerLocalCommand(program2) {
     const filePath = resolvePath(file);
     let content;
     try {
-      content = fs2.readFileSync(filePath, "utf-8");
+      content = fs4.readFileSync(filePath, "utf-8");
     } catch {
       console.error(`Cannot read file: ${filePath}`);
       process.exit(1);
@@ -6800,10 +7668,10 @@ function registerLocalCommand(program2) {
       console.log(content);
     }
   });
-  local.command("tree [path]").description("Show directory tree").option("-d, --depth <n>", "Maximum depth", "3").action((path5, opts) => {
-    const dir = resolvePath(path5);
+  local.command("tree [path]").description("Show directory tree").option("-d, --depth <n>", "Maximum depth", "3").action((path6, opts) => {
+    const dir = resolvePath(path6);
     const maxDepth = parseInt(opts?.depth ?? "3", 10);
-    console.log(path.basename(dir) + "/");
+    console.log(path4.basename(dir) + "/");
     printTree(dir, "", maxDepth, 0);
   });
 }
@@ -6811,7 +7679,7 @@ function printTree(dir, prefix, maxDepth, depth) {
   if (depth >= maxDepth) return;
   let entries;
   try {
-    entries = fs2.readdirSync(dir).filter((e) => !e.startsWith(".")).sort();
+    entries = fs4.readdirSync(dir).filter((e) => !e.startsWith(".")).sort();
   } catch {
     return;
   }
@@ -6819,10 +7687,10 @@ function printTree(dir, prefix, maxDepth, depth) {
     const entry = entries[i];
     const isLast = i === entries.length - 1;
     const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-    const full = path.join(dir, entry);
+    const full = path4.join(dir, entry);
     let isDir = false;
     try {
-      isDir = fs2.statSync(full).isDirectory();
+      isDir = fs4.statSync(full).isDirectory();
     } catch {
       continue;
     }
@@ -6877,7 +7745,7 @@ console.info = (...args) => {
   _origInfo(...args);
 };
 var program = new commander.Command();
-program.name("arbi").description("ARBI CLI \u2014 interact with ARBI from the terminal").version("0.3.28");
+program.name("arbi").description("ARBI CLI \u2014 interact with ARBI from the terminal").version("0.3.30");
 registerConfigCommand(program);
 registerLoginCommand(program);
 registerRegisterCommand(program);