@arbidocs/cli 0.3.19 → 0.3.20

package/dist/index.js

@@ -10,6 +10,7 @@ var sdk = require('@arbidocs/sdk');
 var prompts = require('@inquirer/prompts');
 var child_process = require('child_process');
 var client = require('@arbidocs/client');
+var url = require('url');
 var module$1 = require('module');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -3250,7 +3251,7 @@ var waitForOthersClosedDelete = (databases, name, openDatabases, cb) => {
 };
 var deleteDatabase = (databases, connectionQueues, name, request, cb) => {
   const deleteDBTask = () => {
-    return new Promise((resolve) => {
+    return new Promise((resolve3) => {
       const db = databases.get(name);
       const oldVersion = db !== void 0 ? db.version : 0;
       const onComplete = (err) => {
@@ -3261,7 +3262,7 @@ var deleteDatabase = (databases, connectionQueues, name, request, cb) => {
             cb(null, oldVersion);
           }
         } finally {
-          resolve();
+          resolve3();
         }
       };
       try {
@@ -3409,7 +3410,7 @@ var runVersionchangeTransaction = (connection, version, request, cb) => {
 };
 var openDatabase = (databases, connectionQueues, name, version, request, cb) => {
   const openDBTask = () => {
-    return new Promise((resolve) => {
+    return new Promise((resolve3) => {
       const onComplete = (err) => {
         try {
           if (err) {
@@ -3418,7 +3419,7 @@ var openDatabase = (databases, connectionQueues, name, version, request, cb) =>
             cb(null, connection);
           }
         } finally {
-          resolve();
+          resolve3();
         }
       };
       let db = databases.get(name);
@@ -3636,7 +3637,7 @@ function getLatestVersion(skipCache = false) {
   }
 }
 function getCurrentVersion() {
-  return "0.3.19";
+  return "0.3.20";
 }
 function readChangelog(fromVersion, toVersion) {
   try {
@@ -3689,17 +3690,17 @@ function showChangelog(fromVersion, toVersion) {
 async function checkForUpdates(autoUpdate) {
   try {
     const latest = getLatestVersion();
-    if (!latest || latest === "0.3.19") return;
+    if (!latest || latest === "0.3.20") return;
     if (autoUpdate) {
       warn(`
-Your arbi version is out of date (${"0.3.19"} \u2192 ${latest}). Updating...`);
+Your arbi version is out of date (${"0.3.20"} \u2192 ${latest}). Updating...`);
       child_process.execSync("npm install -g @arbidocs/cli@latest", { stdio: "inherit" });
-      showChangelog("0.3.19", latest);
+      showChangelog("0.3.20", latest);
       console.log(`Updated to ${latest}.`);
     } else {
       warn(
         `
-Your arbi version is out of date (${"0.3.19"} \u2192 ${latest}).
+Your arbi version is out of date (${"0.3.20"} \u2192 ${latest}).
 Run "arbi update" to upgrade, or "arbi update auto" to always stay up to date.`
       );
     }
@@ -3709,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.19") {
+    if (cached && cached.latest !== "0.3.20") {
       warn(
-        `Your arbi version is out of date (${"0.3.19"} \u2192 ${cached.latest}). Run "arbi update".`
+        `Your arbi version is out of date (${"0.3.20"} \u2192 ${cached.latest}). Run "arbi update".`
       );
     }
   } catch {
@@ -3902,12 +3903,23 @@ async function resolveWorkspace(workspaceOpt) {
     throw err;
   }
 }
+async function resolveDmCrypto() {
+  const authCtx = await resolveAuth();
+  const { arbi, loginResult } = authCtx;
+  const userExtId = arbi.session.getState().userExtId;
+  if (!userExtId) {
+    error("No user ID in session \u2014 cannot set up DM encryption.");
+    process.exit(1);
+  }
+  const crypto = sdk.dm.createDmCryptoContext(arbi, loginResult.signingPrivateKey, userExtId);
+  return { ...authCtx, crypto };
+}
 function printTable(columns, rows) {
   console.log(chalk2__default.default.bold(columns.map((c) => c.header.padEnd(c.width)).join("")));
   for (const row of rows) {
     console.log(
       columns.map((c) => {
-        const val = c.value(row);
+        const val = c.value(row) ?? "";
         return val.slice(0, c.width - 2).padEnd(c.width);
       }).join("")
     );
@@ -3921,10 +3933,324 @@ function parseJsonArg(input2, example) {
     process.exit(1);
   }
 }
+var AGENT_BACKENDS = ["claude", "openclaw"];
+var AGENT_MIN_VERSIONS = {
+  claude: {
+    binary: "claude",
+    minVersion: "2.0.0",
+    installUrl: "https://docs.anthropic.com/en/docs/claude-code"
+  },
+  openclaw: {
+    binary: "openclaw",
+    minVersion: "2026.2.0",
+    installUrl: "https://docs.openclaw.ai/install"
+  }
+};
+function checkAgentDependency(backend) {
+  const { binary, minVersion, installUrl } = AGENT_MIN_VERSIONS[backend];
+  let version;
+  try {
+    version = child_process.execFileSync(binary, ["--version"], { encoding: "utf-8", timeout: 5e3 }).trim();
+  } catch {
+    error(
+      `"${binary}" is not installed or not in PATH.
+  The "${backend}" agent backend requires ${binary} >= ${minVersion}.
+  Install: ${installUrl}`
+    );
+    process.exit(1);
+  }
+  const versionMatch = version.match(/(\d+\.\d+[\d.]*)/);
+  if (!versionMatch) {
+    dim(`Could not parse ${binary} version from: ${version}`);
+    return;
+  }
+  const current = versionMatch[1];
+  if (compareVersions(current, minVersion) < 0) {
+    error(
+      `"${binary}" version ${current} is too old (need >= ${minVersion}).
+  Update: ${installUrl}`
+    );
+    process.exit(1);
+  }
+  dim(`${binary} ${current} \u2713`);
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+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)))), "..");
+  try {
+    return fs2.readFileSync(path.join(cliRoot, "SKILL.md"), "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function createAgent(backend, sessionId) {
+  switch (backend) {
+    case "claude":
+      return new sdk.ClaudeOrchestrator({ sessionId, skillPrompt: loadSkillContent() });
+    case "openclaw":
+      return new sdk.OpenClawOrchestrator({ sessionId });
+    default:
+      throw new Error(`Unknown agent backend: ${backend}`);
+  }
+}
+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 skillPath = path.join(cliRoot, "SKILL.md");
+  let skillContent;
+  try {
+    skillContent = fs2.readFileSync(skillPath, "utf-8");
+  } catch {
+    return;
+  }
+  switch (backend) {
+    case "claude": {
+      const commandsDir = path.join(os.homedir(), ".claude", "commands", "arbi");
+      const targetPath = path.join(commandsDir, "SKILL.md");
+      try {
+        fs2.mkdirSync(commandsDir, { recursive: true });
+        if (fs2.existsSync(targetPath)) {
+          const existing = fs2.readFileSync(targetPath, "utf-8");
+          if (existing === skillContent) return;
+        }
+        fs2.writeFileSync(targetPath, skillContent, "utf-8");
+        dim(`Installed ARBI skill \u2192 ${targetPath}`);
+      } catch {
+      }
+      break;
+    }
+    case "openclaw": {
+      const ocAgentName = "arbi";
+      const ocWorkspace = path.join(os.homedir(), ".arbi", "openclaw-workspace");
+      const bootstrapPath = path.join(ocWorkspace, "BOOTSTRAP.md");
+      try {
+        const list = child_process.execFileSync("openclaw", ["agents", "list", "--json"], {
+          encoding: "utf-8"
+        });
+        const agents = JSON.parse(list);
+        const exists = Array.isArray(agents) ? agents.some((a) => a.id === ocAgentName) : false;
+        if (!exists) {
+          fs2.mkdirSync(ocWorkspace, { recursive: true });
+          child_process.execFileSync(
+            "openclaw",
+            ["agents", "add", ocAgentName, "--workspace", ocWorkspace, "--non-interactive"],
+            { encoding: "utf-8" }
+          );
+          dim(`Created OpenClaw agent "${ocAgentName}" \u2192 ${ocWorkspace}`);
+        }
+      } catch {
+        fs2.mkdirSync(ocWorkspace, { recursive: true });
+        try {
+          child_process.execFileSync(
+            "openclaw",
+            ["agents", "add", ocAgentName, "--workspace", ocWorkspace, "--non-interactive"],
+            { encoding: "utf-8" }
+          );
+          dim(`Created OpenClaw agent "${ocAgentName}" \u2192 ${ocWorkspace}`);
+        } catch {
+        }
+      }
+      try {
+        fs2.mkdirSync(ocWorkspace, { recursive: true });
+        if (fs2.existsSync(bootstrapPath)) {
+          const existing = fs2.readFileSync(bootstrapPath, "utf-8");
+          if (existing === skillContent) break;
+        }
+        fs2.writeFileSync(bootstrapPath, skillContent, "utf-8");
+        dim(`Installed ARBI skill \u2192 ${bootstrapPath}`);
+      } catch {
+      }
+      break;
+    }
+  }
+}
+async function setupAgent(agentName, config) {
+  const backend = agentName ?? config.orchestrator;
+  if (!backend) return void 0;
+  if (!AGENT_BACKENDS.includes(backend)) {
+    error(`Unknown agent backend: "${backend}". Choose from: ${AGENT_BACKENDS.join(", ")}`);
+    process.exit(1);
+  }
+  checkAgentDependency(backend);
+  installSkill(backend);
+  if (agentName && agentName !== config.orchestrator) {
+    updateConfig({ orchestrator: backend });
+    dim(`Default agent backend set to "${backend}"`);
+  }
+  return backend;
+}
+async function startListening(agentName, config) {
+  const backend = agentName ?? config.orchestrator;
+  if (!backend) {
+    error(
+      `No agent backend configured. Use --agent to specify one:
+  arbi connect --agent ${AGENT_BACKENDS[0]} --listen`
+    );
+    process.exit(1);
+  }
+  const creds = store.getCredentials();
+  if (!creds?.parentExtId) {
+    error(
+      "DM listener requires a persistent agent identity (parentExtId).\n  This session was not claimed as a delegated agent."
+    );
+    process.exit(1);
+  }
+  dim("Starting DM listener...");
+  const { arbi, crypto } = await resolveDmCrypto();
+  const sessionId = arbi.session.getState().userExtId ?? "default";
+  const orchestrator = createAgent(backend, sessionId);
+  const fullConfig = resolveConfig();
+  const accessToken = arbi.session.getState().accessToken;
+  if (!accessToken) {
+    error("No access token \u2014 authentication may have failed.");
+    process.exit(1);
+  }
+  const listener = await sdk.startDmListener({
+    arbi,
+    accessToken,
+    baseUrl: fullConfig.baseUrl,
+    crypto,
+    orchestrator,
+    parentExtId: creds.parentExtId,
+    onLog: (msg) => dim(msg),
+    onError: (msg, err) => error(`${msg}${err ? `: ${err}` : ""}`)
+  });
+  success(`Listening for DMs as ${chalk2__default.default.cyan(creds.email)} via ${chalk2__default.default.cyan(backend)}`);
+  dim("Press Ctrl+C to stop.");
+  const shutdown = () => {
+    dim("\nShutting down listener...");
+    listener.close();
+    orchestrator.close?.();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+function registerConnectCommand(program2) {
+  program2.command("connect").description("Claim a session and/or connect to an agent backend").option("--code <claim-code>", "Claim code from parent (required on first run)").option("--agent <name>", `Agent backend (${AGENT_BACKENDS.join(", ")})`).option("--listen", "Start DM listener (agent receives prompts via encrypted DMs)").action((opts) => {
+    const run = async () => {
+      const config = resolveConfig();
+      const creds = store.getCredentials();
+      const hasIdentity = creds?.signingPrivateKeyBase64;
+      if (!hasIdentity) {
+        const claimCode = opts.code?.trim() ?? "";
+        if (!claimCode) {
+          const authorizeUrl = `${config.baseUrl}#/action/authorize-agent`;
+          error(
+            `No saved identity. Provide a claim code:
+  arbi connect --code purple-mountain-river
+
+Get a claim code from the ARBI web UI:
+  ${chalk2__default.default.underline(authorizeUrl)}`
+          );
+          process.exit(1);
+        }
+        dim("Claiming session...");
+        const arbi = client.createArbiClient({
+          baseUrl: config.baseUrl,
+          deploymentDomain: config.deploymentDomain,
+          credentials: "omit"
+        });
+        await arbi.crypto.initSodium();
+        const keypair = arbi.crypto.generateRandomSigningKeypair();
+        const signingPubKeyBase64 = client.bytesToBase64(keypair.publicKey);
+        const signingPrivateKeyBase64 = client.bytesToBase64(keypair.secretKey);
+        const claimResponse = await sdk.sessions.claimSession(arbi, claimCode, signingPubKeyBase64);
+        const parentExtId = claimResponse.user.parent_ext_id ?? void 0;
+        const agentEmail = claimResponse.user.email ?? claimResponse.user.external_id;
+        store.saveCredentials({
+          email: agentEmail,
+          signingPrivateKeyBase64,
+          serverSessionKeyBase64: claimResponse.session_key,
+          accessToken: claimResponse.access_token,
+          parentExtId
+        });
+        const workspaces3 = claimResponse.workspaces ?? [];
+        if (workspaces3.length > 0) {
+          const firstWs = workspaces3[0];
+          const wsId = firstWs.external_id;
+          if (wsId) {
+            updateConfig({ selectedWorkspaceId: wsId });
+          }
+        }
+        success("Session claimed!");
+        console.log(`  Identity: ${chalk2__default.default.cyan(agentEmail)}`);
+        if (parentExtId) {
+          console.log(`  Parent:   ${chalk2__default.default.cyan(parentExtId)}`);
+          console.log(`  Type:     Persistent agent`);
+        } else {
+          console.log(`  Type:     Ephemeral session`);
+        }
+        console.log("");
+        if (parentExtId) {
+          try {
+            arbi.session.setAccessToken(claimResponse.access_token);
+            arbi.session.setUser(agentEmail, claimResponse.user.external_id);
+            const contacts = await sdk.contacts.listContacts(arbi);
+            const parentContact = contacts.find((c) => {
+              const u = c.user;
+              return u?.external_id === parentExtId;
+            });
+            const parentPubKey = parentContact?.user?.encryption_public_key;
+            if (parentPubKey) {
+              const userExtId = claimResponse.user.external_id ?? agentEmail;
+              const crypto = sdk.dm.createDmCryptoContext(
+                arbi,
+                client.base64ToBytes(signingPrivateKeyBase64),
+                userExtId
+              );
+              await sdk.dm.sendEncryptedDM(
+                arbi,
+                [
+                  {
+                    recipient_ext_id: parentExtId,
+                    content: `\u{1F511} Agent recovery key for ${agentEmail}
+signing_key: ${signingPrivateKeyBase64}
+
+Save this key \u2014 it is the only way to recover this agent session.`,
+                    recipient_encryption_public_key: parentPubKey
+                  }
+                ],
+                crypto
+              );
+              dim("Recovery key sent to parent via encrypted DM.");
+            } else {
+              dim("Could not find parent encryption key \u2014 recovery key not sent.");
+              dim(`Backup manually: ${signingPrivateKeyBase64}`);
+            }
+          } catch {
+            dim("Failed to send recovery key DM \u2014 save it manually:");
+            dim(`  ${signingPrivateKeyBase64}`);
+          }
+        }
+      }
+      await setupAgent(opts.agent, config);
+      if (opts.listen) {
+        await startListening(opts.agent, config);
+      } else {
+        success("Connected. Use `arbi --help` to explore.");
+      }
+    };
+    run().catch((err) => {
+      error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    });
+  });
+}
 
 // src/commands/login.ts
 function registerLoginCommand(program2) {
-  program2.command("login").description("Log in to ARBI").option("-e, --email <email>", "Email address (or ARBI_EMAIL env var)").option("-p, --password <password>", "Password (or ARBI_PASSWORD env var)").option("-w, --workspace <id>", "Workspace ID to select after login").option("--sso", "Log in with Auth0 SSO (device flow)").action(
+  program2.command("login").description("Log in to ARBI").option("-e, --email <email>", "Email address (or ARBI_EMAIL env var)").option("-p, --password <password>", "Password (or ARBI_PASSWORD env var)").option("-w, --workspace <id>", "Workspace ID to select after login").option("--sso", "Log in with Auth0 SSO (device flow)").option("--agent <name>", "Agent backend to configure (claude, openclaw)").option("--listen", "Start DM listener after login").action(
     (opts) => runAction(async () => {
       const config = store.requireConfig();
       const email = opts.email || process.env.ARBI_EMAIL || await promptInput("Email");
@@ -3955,35 +4281,37 @@ Open this URL in your browser:
         const wsList = workspaces3 || [];
         updateCompletionCache(wsList);
         const memberWorkspaces = wsList.filter(
-          (ws2) => ws2.users?.some((u) => u.user.email === email)
+          (ws) => ws.users?.some((u) => u.user.email === email)
         );
         if (memberWorkspaces.length === 0) {
           console.log("No workspaces found. Create one with: arbi workspace create <name>");
-          return;
-        }
-        if (opts.workspace) {
-          const ws2 = memberWorkspaces.find((w) => w.external_id === opts.workspace);
-          if (!ws2) {
+        } else if (opts.workspace) {
+          const ws = memberWorkspaces.find((w) => w.external_id === opts.workspace);
+          if (!ws) {
             error(`Workspace ${opts.workspace} not found or you don't have access.`);
             process.exit(1);
           }
-          updateConfig({ selectedWorkspaceId: ws2.external_id });
-          success(`Workspace: ${ws2.name} (${ref(ws2.external_id)})`);
-          return;
-        }
-        if (memberWorkspaces.length === 1) {
+          updateConfig({ selectedWorkspaceId: ws.external_id });
+          success(`Workspace: ${ws.name} (${ref(ws.external_id)})`);
+        } else if (memberWorkspaces.length === 1) {
           updateConfig({ selectedWorkspaceId: memberWorkspaces[0].external_id });
           success(
             `Workspace: ${memberWorkspaces[0].name} (${ref(memberWorkspaces[0].external_id)})`
           );
-          return;
+        } else {
+          const choices = sdk.formatWorkspaceChoices(memberWorkspaces);
+          const selected = await promptSelect("Select workspace", choices);
+          updateConfig({ selectedWorkspaceId: selected });
+          const ws = memberWorkspaces.find((w) => w.external_id === selected);
+          success(`Workspace: ${ws.name} (${ref(selected)})`);
+          dim('\nTip: Run "arbi config alias" to use A as a shortcut for "arbi ask"');
+        }
+        if (opts.agent || opts.listen) {
+          await setupAgent(opts.agent, config);
+          if (opts.listen) {
+            await startListening(opts.agent, config);
+          }
         }
-        const choices = sdk.formatWorkspaceChoices(memberWorkspaces);
-        const selected = await promptSelect("Select workspace", choices);
-        updateConfig({ selectedWorkspaceId: selected });
-        const ws = memberWorkspaces.find((w) => w.external_id === selected);
-        success(`Workspace: ${ws.name} (${ref(selected)})`);
-        dim('\nTip: Run "arbi config alias" to use A as a shortcut for "arbi ask"');
       } catch (err) {
         error(`Login failed: ${formatCliError(err)}`);
         process.exit(1);
@@ -4149,15 +4477,16 @@ async function nonInteractiveRegister(config, opts) {
 }
 async function loginAfterRegister(config, email, password2) {
   try {
-    const { arbi } = await sdk.performPasswordLogin(config, email, password2, store);
+    const { arbi, loginResult } = await sdk.performPasswordLogin(config, email, password2, store);
     success(`Logged in as ${email}`);
     const { data: workspaces3 } = await arbi.fetch.GET("/v1/user/workspaces");
     const wsList = workspaces3 || [];
     updateCompletionCache(wsList);
-    const memberWorkspaces = wsList.filter((ws2) => ws2.users?.some((u) => u.email === email));
+    const memberWorkspaces = wsList.filter((ws2) => ws2.users?.some((u) => u.user.email === email));
     if (memberWorkspaces.length === 0) {
       console.log("Creating your first workspace...");
-      const ws2 = await sdk.workspaces.createWorkspace(arbi, "My First Workspace");
+      const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
+      const ws2 = await sdk.workspaces.createWorkspace(arbi, "My First Workspace", encryptedKey);
       updateConfig({ selectedWorkspaceId: ws2.external_id });
       success(`Workspace: ${ws2.name} (${ref(ws2.external_id)})`);
       return;
@@ -4271,10 +4600,12 @@ 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 } = await resolveAuth();
+      const { arbi, loginResult } = await resolveAuth();
+      const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
       const data = await sdk.workspaces.createWorkspace(
         arbi,
         name,
+        encryptedKey,
         opts.description,
         opts.public ?? false
       );
@@ -4513,7 +4844,10 @@ function registerDocsCommand(program2) {
         const parsed = parseJsonArg(json, `arbi doc update '[{"external_id": "doc-123", "shared": true}]'`);
         const docs = Array.isArray(parsed) ? parsed : parsed.documents;
         const { arbi } = await resolveWorkspace();
-        const data = await sdk.documents.updateDocuments(arbi, docs);
+        const data = await sdk.documents.updateDocuments(
+          arbi,
+          docs
+        );
         success(`Updated ${data.length} document(s).`);
       } else {
         const { arbi, workspaceId } = await resolveWorkspace();
@@ -4556,7 +4890,7 @@ function registerDocsCommand(program2) {
   );
   doc.command("parsed <doc-id> [stage]").description("Get parsed document content (stage: marker, subchunk, final; default: final)").action(
     (docId, stage) => runAction(async () => {
-      const { accessToken, workspaceKeyHeader, config } = await resolveWorkspace();
+      const { accessToken, config } = await resolveWorkspace();
       const validStages = ["marker", "subchunk", "final"];
       const selectedStage = stage ?? "final";
       if (!validStages.includes(selectedStage)) {
@@ -4564,7 +4898,7 @@ function registerDocsCommand(program2) {
         process.exit(1);
       }
       const data = await sdk.documents.getParsedContent(
-        { baseUrl: config.baseUrl, accessToken, workspaceKeyHeader },
+        { baseUrl: config.baseUrl, accessToken },
         docId,
         selectedStage
       );
@@ -4581,11 +4915,9 @@ function registerUploadCommand(program2) {
           process.exit(1);
         }
       }
-      const { config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace(
-        opts.workspace
-      );
+      const { config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace);
       const uploadedDocs = /* @__PURE__ */ new Map();
-      const auth = { baseUrl: config.baseUrl, accessToken, workspaceKeyHeader };
+      const auth = { baseUrl: config.baseUrl, accessToken };
       for (const filePath of paths) {
         const stat = fs2__default.default.statSync(filePath);
         if (stat.isDirectory()) {
@@ -4697,7 +5029,7 @@ Connection closed. ${pending.size} document(s) still processing.`);
 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 () => {
-      const { arbi, config, accessToken, workspaceKeyHeader, workspaceId } = await resolveWorkspace(opts.workspace);
+      const { arbi, config, accessToken, workspaceId } = await resolveWorkspace(opts.workspace);
       if (!docId) {
         const data = await sdk.documents.listDocuments(arbi);
         if (data.length === 0) {
@@ -4712,7 +5044,7 @@ function registerDownloadCommand(program2) {
         docId = await promptSearch("Select document to download", choices);
       }
       const res = await sdk.documents.downloadDocument(
-        { baseUrl: config.baseUrl, accessToken, workspaceKeyHeader },
+        { baseUrl: config.baseUrl, accessToken },
         docId
       );
       let filename = `${docId}`;
@@ -4734,7 +5066,7 @@ function registerAskCommand(program2) {
   program2.command("ask <question...>").description("Ask the RAG assistant a question (no quotes needed)").option("-w, --workspace <id>", "Workspace ID (defaults to selected workspace)").option("-c, --continue <msg-id>", "Continue from a specific message ID").option("--config <id>", "Config ext_id to use (e.g. cfg-xxx)").option("-n, --new", "Start a new conversation (ignore previous context)").option("-b, --background", "Submit as background task (fire and forget)").option("-q, --quiet", "Suppress agent steps and tool calls").option("--json", "Output in JSON format (background mode only)").action(
     (words, opts) => runAction(async () => {
       const question = words.join(" ");
-      const { arbi, accessToken, workspaceKeyHeader, workspaceId, config } = await resolveWorkspace(opts.workspace);
+      const { arbi, accessToken, workspaceId, config } = await resolveWorkspace(opts.workspace);
       let previousResponseId = null;
       if (opts.continue) {
         previousResponseId = opts.continue;
@@ -4755,7 +5087,6 @@ function registerAskCommand(program2) {
         const result2 = await sdk.responses.submitBackgroundQuery({
           baseUrl: config.baseUrl,
           accessToken,
-          workspaceKeyHeader,
           workspaceId,
           question,
           docIds,
@@ -4785,7 +5116,6 @@ function registerAskCommand(program2) {
         res = await sdk.assistant.queryAssistant({
           baseUrl: config.baseUrl,
           accessToken,
-          workspaceKeyHeader,
           workspaceId,
           question,
           docIds,
@@ -4799,7 +5129,6 @@ function registerAskCommand(program2) {
         res = await sdk.assistant.queryAssistant({
           baseUrl: config.baseUrl,
           accessToken,
-          workspaceKeyHeader,
           workspaceId,
           question,
           docIds,
@@ -5190,11 +5519,11 @@ function registerContactsCommand(program2) {
   });
 }
 function registerDmCommand(program2) {
-  const dm = program2.command("dm").description("Direct messages");
-  dm.command("list").description("List all DMs and notifications").action(
+  const dm = program2.command("dm").description("Direct messages (E2E encrypted)");
+  dm.command("list").description("List all DMs and notifications (decrypted)").action(
     runAction(async () => {
-      const { arbi } = await resolveAuth();
-      const data = await sdk.dm.listDMs(arbi);
+      const { arbi, crypto } = await resolveDmCrypto();
+      const data = await sdk.dm.listDecryptedDMs(arbi, crypto);
       if (data.length === 0) {
         console.log("No messages found.");
         return;
@@ -5218,18 +5547,18 @@ function registerDmCommand(program2) {
       );
     })
   );
-  dm.command("send [recipient] [content]").description("Send a DM (interactive if no args; recipient can be email or user ext_id)").action(
-    (recipient, content) => runAction(async () => {
-      const { arbi } = await resolveAuth();
+  dm.command("send [recipient] [content...]").description("Send an E2E encrypted DM (interactive if no args)").action(
+    (recipient, contentParts) => runAction(async () => {
+      const { arbi, crypto } = await resolveDmCrypto();
       if (!recipient) {
-        const contacts = await sdk.contacts.listContacts(arbi);
-        if (contacts.length === 0) {
+        const contacts2 = await sdk.contacts.listContacts(arbi);
+        if (contacts2.length === 0) {
           error("No contacts found. Add contacts first: arbi contacts add <email>");
           process.exit(1);
         }
         recipient = await promptSelect(
           "Send to",
-          contacts.map((c) => {
+          contacts2.map((c) => {
             const u = c.user;
             const name = sdk.formatUserName(u);
             return {
@@ -5240,21 +5569,93 @@ function registerDmCommand(program2) {
           })
         );
       }
+      let content = contentParts?.length ? contentParts.join(" ") : void 0;
       if (!content) {
         content = await promptInput("Message");
       }
+      const contacts = await sdk.contacts.listContacts(arbi);
       let recipientExtId = recipient;
+      let recipientPubKey;
       if (recipient.includes("@")) {
-        const contacts = await sdk.contacts.listContacts(arbi);
         const match = contacts.find((c) => c.email === recipient);
-        if (!match) {
-          error(`No contact found with email: ${recipient}`);
-          error("Add them first: arbi contacts add " + recipient);
-          process.exit(1);
+        if (match) {
+          const u = match.user;
+          recipientExtId = u?.external_id ?? match.external_id;
+          recipientPubKey = u?.encryption_public_key;
+        } else {
+          try {
+            const agentsList = await sdk.agents.listAgents(arbi);
+            const agentMatch = agentsList.find((a) => a.email === recipient);
+            if (agentMatch) {
+              recipientExtId = agentMatch.external_id;
+              recipientPubKey = agentMatch.encryption_public_key;
+            }
+          } catch {
+          }
+          if (!recipientPubKey) {
+            try {
+              const wsUsers = await sdk.workspaces.listWorkspaceUsers(arbi);
+              const wsMatch = wsUsers.find(
+                (wu) => wu.email === recipient
+              );
+              if (wsMatch) {
+                const u = wsMatch;
+                recipientExtId = u.external_id;
+                recipientPubKey = u.encryption_public_key;
+              }
+            } catch {
+            }
+          }
+          if (!recipientExtId || recipientExtId === recipient) {
+            error(`No contact, agent, or workspace member found with email: ${recipient}`);
+            process.exit(1);
+          }
         }
-        recipientExtId = match.user?.external_id ?? match.external_id;
+      } else {
+        const match = contacts.find((c) => {
+          const u = c.user;
+          return u?.external_id === recipient || c.external_id === recipient;
+        });
+        recipientPubKey = match?.user?.encryption_public_key;
+        if (!recipientPubKey) {
+          try {
+            const agentsList = await sdk.agents.listAgents(arbi);
+            const agentMatch = agentsList.find((a) => a.external_id === recipientExtId);
+            if (agentMatch) {
+              recipientPubKey = agentMatch.encryption_public_key;
+            }
+          } catch {
+          }
+        }
+        if (!recipientPubKey) {
+          try {
+            const wsUsers = await sdk.workspaces.listWorkspaceUsers(arbi);
+            const wsMatch = wsUsers.find(
+              (wu) => wu.external_id === recipientExtId
+            );
+            if (wsMatch) {
+              recipientPubKey = wsMatch.encryption_public_key;
+            }
+          } catch {
+          }
+        }
+      }
+      if (!recipientPubKey) {
+        error("Cannot send encrypted DM \u2014 recipient public key not found.");
+        error("The recipient is not in your contacts or workspace.");
+        process.exit(1);
       }
-      const data = await sdk.dm.sendDM(arbi, [{ recipient_ext_id: recipientExtId, content }]);
+      const data = await sdk.dm.sendEncryptedDM(
+        arbi,
+        [
+          {
+            recipient_ext_id: recipientExtId,
+            content,
+            recipient_encryption_public_key: recipientPubKey
+          }
+        ],
+        crypto
+      );
       for (const n of data) {
         success(`Sent: ${n.external_id} \u2192 ${n.recipient.email}`);
       }
@@ -5262,10 +5663,10 @@ function registerDmCommand(program2) {
   );
   dm.command("read [ids...]").description("Mark messages as read (interactive picker if no IDs given)").action(
     (ids) => runAction(async () => {
-      const { arbi } = await resolveAuth();
+      const { arbi, crypto } = await resolveDmCrypto();
       let msgIds = ids && ids.length > 0 ? ids : void 0;
       if (!msgIds) {
-        const data2 = await sdk.dm.listDMs(arbi);
+        const data2 = await sdk.dm.listDecryptedDMs(arbi, crypto);
         const unread = data2.filter((m) => !m.read);
         if (unread.length === 0) {
           console.log("No unread messages.");
@@ -5290,10 +5691,10 @@ function registerDmCommand(program2) {
   );
   dm.command("delete [ids...]").description("Delete messages (interactive picker if no IDs given)").action(
     (ids) => runAction(async () => {
-      const { arbi } = await resolveAuth();
+      const { arbi, crypto } = await resolveDmCrypto();
       let msgIds = ids && ids.length > 0 ? ids : void 0;
       if (!msgIds) {
-        const data = await sdk.dm.listDMs(arbi);
+        const data = await sdk.dm.listDecryptedDMs(arbi, crypto);
         if (data.length === 0) {
           console.log("No messages found.");
           return;
@@ -5385,7 +5786,10 @@ function registerTagsCommand(program2) {
       const shared = interactive ? opts.shared || await promptConfirm("Shared?", false) : opts.shared ?? false;
       const data = await sdk.tags.createTag(arbi, {
         name,
-        tagType: { type: tagType, options: [] },
+        tagType: {
+          type: tagType,
+          options: []
+        },
         instruction,
         shared
       });
@@ -6028,16 +6432,19 @@ function registerQuickstartCommand(program2) {
       password2 = await promptPassword("Password");
     }
     try {
-      const { arbi } = await sdk.performPasswordLogin(config, email, password2, store);
+      const { arbi, loginResult } = await sdk.performPasswordLogin(config, email, password2, store);
       success(`Logged in as ${email}`);
       const { data: workspaces3 } = await arbi.fetch.GET("/v1/user/workspaces");
       const wsList = workspaces3 || [];
-      const memberWorkspaces = wsList.filter((ws) => ws.users?.some((u) => u.email === email));
+      const memberWorkspaces = wsList.filter(
+        (ws) => ws.users?.some((u) => u.user.email === email)
+      );
       let workspaceId;
       let workspaceName;
       if (memberWorkspaces.length === 0) {
         console.log("Creating your first workspace...");
-        const ws = await sdk.workspaces.createWorkspace(arbi, "My Workspace");
+        const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
+        const ws = await sdk.workspaces.createWorkspace(arbi, "My Workspace", encryptedKey);
         workspaceId = ws.external_id;
         workspaceName = ws.name;
       } else {
@@ -6048,7 +6455,8 @@ function registerQuickstartCommand(program2) {
         const selected = await promptSelect("Select workspace", choices);
         if (selected === "__new__") {
           const name = await promptInput("Workspace name", false) || "My Workspace";
-          const ws = await sdk.workspaces.createWorkspace(arbi, name);
+          const encKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
+          const ws = await sdk.workspaces.createWorkspace(arbi, name, encKey);
           workspaceId = ws.external_id;
           workspaceName = ws.name;
         } else {
@@ -6147,8 +6555,14 @@ function registerAgentCreateCommand(program2) {
         process.exit(1);
       }
       try {
-        const { arbi } = await sdk.performPasswordLogin(config, email, opts.password, store);
-        const ws = await sdk.workspaces.createWorkspace(arbi, opts.workspaceName);
+        const { arbi, loginResult } = await sdk.performPasswordLogin(
+          config,
+          email,
+          opts.password,
+          store
+        );
+        const encryptedKey = await sdk.generateNewWorkspaceKey(arbi, loginResult.serverSessionKey);
+        const ws = await sdk.workspaces.createWorkspace(arbi, opts.workspaceName, encryptedKey);
         updateConfig({ selectedWorkspaceId: ws.external_id });
         console.log("");
         success("Agent account created!");
@@ -6166,6 +6580,60 @@ function registerAgentCreateCommand(program2) {
     }
   );
 }
+function registerAgentCommand(program2) {
+  const agent = program2.command("agent").description("Manage persistent agents");
+  agent.command("list").description("List your persistent agents").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = await sdk.agents.listAgents(arbi);
+      if (data.length === 0) {
+        console.log("No agents found.");
+        return;
+      }
+      printTable(
+        [
+          { header: "ID", width: 20, value: (r) => r.external_id },
+          {
+            header: "NAME",
+            width: 24,
+            value: (r) => sdk.formatUserName(r) || r.email || ""
+          },
+          { header: "EMAIL", width: 40, value: (r) => r.email || "" }
+        ],
+        data
+      );
+    })
+  );
+  agent.command("delete [agent-id]").description("Delete a persistent agent (picker if no ID)").action(
+    (agentId) => runAction(async () => {
+      const { arbi } = await resolveAuth();
+      if (!agentId) {
+        const data = await sdk.agents.listAgents(arbi);
+        if (data.length === 0) {
+          console.log("No agents to delete.");
+          return;
+        }
+        agentId = await promptSelect(
+          "Select agent to delete",
+          data.map((a) => ({
+            name: `${sdk.formatUserName(a) || a.email} (${a.external_id})`,
+            value: a.external_id
+          }))
+        );
+      }
+      const confirmed = await promptConfirm(`Delete agent ${agentId}?`, false);
+      if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+      }
+      await sdk.agents.deleteAgents(arbi, [agentId]);
+      success(`Agent ${agentId} deleted.`);
+    })()
+  );
+  agent.action(async () => {
+    await agent.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
+  });
+}
 function formatAge(isoDate) {
   const ms = Date.now() - new Date(isoDate).getTime();
   if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
@@ -6214,11 +6682,8 @@ function registerTaskCommand(program2) {
   task.command("status [task-id]").description("Check current task status (defaults to most recent)").option("-w, --workspace <id>", "Workspace ID").option("--json", "Output in JSON format").action(
     (taskId, opts) => runAction(async () => {
       const id = resolveTaskId(taskId);
-      const { accessToken, workspaceKeyHeader, config } = await resolveWorkspace(opts?.workspace);
-      const result = await sdk.responses.getResponse(
-        { baseUrl: config.baseUrl, accessToken, workspaceKeyHeader },
-        id
-      );
+      const { accessToken, config } = await resolveWorkspace(opts?.workspace);
+      const result = await sdk.responses.getResponse({ baseUrl: config.baseUrl, accessToken }, id);
       if (result.status === "completed" || result.status === "failed") {
         updateTaskStatus(id, result.status);
       }
@@ -6237,11 +6702,8 @@ function registerTaskCommand(program2) {
   task.command("result [task-id]").description("Fetch and print the completed task result").option("-w, --workspace <id>", "Workspace ID").option("--json", "Output in JSON format").action(
     (taskId, opts) => runAction(async () => {
       const id = resolveTaskId(taskId);
-      const { accessToken, workspaceKeyHeader, config } = await resolveWorkspace(opts?.workspace);
-      const result = await sdk.responses.getResponse(
-        { baseUrl: config.baseUrl, accessToken, workspaceKeyHeader },
-        id
-      );
+      const { accessToken, config } = await resolveWorkspace(opts?.workspace);
+      const result = await sdk.responses.getResponse({ baseUrl: config.baseUrl, accessToken }, id);
       if (result.status === "completed" || result.status === "failed") {
         updateTaskStatus(id, result.status);
       }
@@ -6342,6 +6804,220 @@ function registerCompletionCommand(program2) {
     })
   );
 }
+function resolvePath(p) {
+  const raw = p ?? ".";
+  const expanded = raw.startsWith("~") ? raw.replace("~", os.homedir()) : raw;
+  return path.resolve(expanded);
+}
+function formatSize(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`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+}
+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);
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir);
+    } catch {
+      console.error(`Cannot read directory: ${dir}`);
+      process.exit(1);
+    }
+    for (const entry of entries.filter((e) => !e.startsWith(".")).sort()) {
+      if (opts?.long) {
+        try {
+          const stat = fs2.statSync(path.join(dir, entry));
+          const type = stat.isDirectory() ? "dir" : "file";
+          const size = stat.isFile() ? formatSize(stat.size) : "-";
+          console.log(`${type.padEnd(5)} ${size.padStart(10)}  ${entry}`);
+        } catch {
+          console.log(`?     ${"-".padStart(10)}  ${entry}`);
+        }
+      } else {
+        console.log(entry);
+      }
+    }
+  });
+  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 });
+    if (results.length === 0) {
+      console.log(`No files matching "${pattern}" in ${dir}`);
+      return;
+    }
+    for (const file of results) {
+      console.log(file);
+    }
+  });
+  local.command("cat <file>").description("Print file contents").option("--head <lines>", "Only show first N lines").action((file, opts) => {
+    const filePath = resolvePath(file);
+    let content;
+    try {
+      content = fs2.readFileSync(filePath, "utf-8");
+    } catch {
+      console.error(`Cannot read file: ${filePath}`);
+      process.exit(1);
+    }
+    if (opts.head) {
+      const n = parseInt(opts.head, 10);
+      console.log(content.split("\n").slice(0, n).join("\n"));
+    } else {
+      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);
+    const maxDepth = parseInt(opts?.depth ?? "3", 10);
+    console.log(path.basename(dir) + "/");
+    printTree(dir, "", maxDepth, 0);
+  });
+}
+function printTree(dir, prefix, maxDepth, depth) {
+  if (depth >= maxDepth) return;
+  let entries;
+  try {
+    entries = fs2.readdirSync(dir).filter((e) => !e.startsWith(".")).sort();
+  } catch {
+    return;
+  }
+  for (let i = 0; i < entries.length; i++) {
+    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);
+    let isDir = false;
+    try {
+      isDir = fs2.statSync(full).isDirectory();
+    } catch {
+      continue;
+    }
+    console.log(`${prefix}${connector}${entry}${isDir ? "/" : ""}`);
+    if (isDir) {
+      const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+      printTree(full, nextPrefix, maxDepth, depth + 1);
+    }
+  }
+}
+async function authorizeShared(opts) {
+  const { arbi, loginResult } = await resolveAuth();
+  let name = opts.name;
+  if (!name) {
+    name = await promptInput(opts.persist ? "Agent name" : "Session name");
+  }
+  if (!name?.trim()) {
+    error("Name is required");
+    process.exit(1);
+  }
+  const { data: allWorkspaces, error: wsErr } = await arbi.fetch.GET("/v1/user/workspaces");
+  if (wsErr || !allWorkspaces || allWorkspaces.length === 0) {
+    error("No workspaces found");
+    process.exit(1);
+  }
+  let workspaceIds = opts.workspace;
+  if (!workspaceIds || workspaceIds.length === 0) {
+    workspaceIds = await promptCheckbox(
+      "Select workspaces to grant access",
+      allWorkspaces.map((ws) => ({
+        name: `${ws.name} (${ws.external_id})`,
+        value: ws.external_id
+      }))
+    );
+  }
+  if (workspaceIds.length === 0) {
+    error("At least one workspace is required");
+    process.exit(1);
+  }
+  const creds = store.requireCredentials();
+  const workspaceKeysMap = {};
+  for (const wsId of workspaceIds) {
+    const ws = allWorkspaces.find((w) => w.external_id === wsId);
+    if (!ws?.wrapped_key) {
+      error(`Workspace ${wsId} not found or has no encryption key`);
+      process.exit(1);
+    }
+    const encryptedKey = await sdk.generateEncryptedWorkspaceKey(
+      arbi,
+      ws.wrapped_key,
+      loginResult.serverSessionKey,
+      creds.signingPrivateKeyBase64
+    );
+    workspaceKeysMap[wsId] = encryptedKey;
+  }
+  const ttl = parseInt(opts.ttl || "3600", 10);
+  const response = await sdk.sessions.authorizeSession(arbi, workspaceKeysMap, {
+    activeWorkspace: workspaceIds[0],
+    ttl,
+    persistIdentity: opts.persist,
+    name: name.trim()
+  });
+  return { response, ttl };
+}
+function registerAuthorizeCommand(program2) {
+  const authorize = program2.command("authorize").description("Create a claim code for a session or agent");
+  authorize.command("agent").description("Create a persistent agent identity with a claim code").option("--name <name>", "Agent name").option("-w, --workspace <ids...>", "Workspace IDs to grant access to (interactive if omitted)").action(
+    (opts) => runAction(async () => {
+      const { response } = await authorizeShared({ persist: true, ...opts });
+      console.log("");
+      success("Agent authorized!");
+      console.log("");
+      console.log(`  Claim code: ${chalk2__default.default.cyan(chalk2__default.default.bold(response.claim_code))}`);
+      console.log("");
+      dim("On the agent machine: arbi connect --code <claim-code> --agent claude");
+    })()
+  );
+  authorize.command("session").description("Create an ephemeral session with a claim code").option("--name <name>", "Session name").option("--ttl <seconds>", "Session TTL in seconds (default: 3600)", "3600").option("-w, --workspace <ids...>", "Workspace IDs to grant access to (interactive if omitted)").action(
+    (opts) => runAction(async () => {
+      const { response, ttl } = await authorizeShared({ persist: false, ...opts });
+      console.log("");
+      success("Session authorized!");
+      console.log("");
+      console.log(`  Claim code: ${chalk2__default.default.cyan(chalk2__default.default.bold(response.claim_code))}`);
+      console.log(`  Expires in: ${ttl}s`);
+      console.log("");
+      dim("Claim with: arbi connect --code <claim-code>");
+    })()
+  );
+  authorize.action(() => {
+    authorize.help();
+  });
+}
+function registerSessionCommand(program2) {
+  const session = program2.command("session").description("List and manage sessions");
+  session.command("list").description("List active sessions").action(
+    runAction(async () => {
+      const { arbi } = await resolveAuth();
+      const data = await sdk.sessions.listSessions(arbi);
+      if (data.length === 0) {
+        console.log("No active sessions.");
+        return;
+      }
+      printTable(
+        [
+          {
+            header: "ID",
+            width: 18,
+            value: (r) => r.external_id || r.session_id
+          },
+          { header: "NAME", width: 20, value: (r) => r.name || "" },
+          { header: "STATUS", width: 12, value: (r) => r.status },
+          { header: "TTL", width: 10, value: (r) => `${r.ttl}s` },
+          {
+            header: "WORKSPACES",
+            width: 12,
+            value: (r) => String(r.workspaces?.length ?? 0)
+          }
+        ],
+        data
+      );
+    })
+  );
+  session.action(async () => {
+    await session.commands.find((c) => c.name() === "list").parseAsync([], { from: "user" });
+  });
+}
 
 // src/index.ts
 console.debug = () => {
@@ -6352,7 +7028,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.19");
+program.name("arbi").description("ARBI CLI \u2014 interact with ARBI from the terminal").version("0.3.20");
 registerConfigCommand(program);
 registerLoginCommand(program);
 registerRegisterCommand(program);
@@ -6378,8 +7054,13 @@ registerTuiCommand(program);
 registerUpdateCommand(program);
 registerQuickstartCommand(program);
 registerAgentCreateCommand(program);
+registerAgentCommand(program);
 registerTaskCommand(program);
 registerCompletionCommand(program);
+registerConnectCommand(program);
+registerAuthorizeCommand(program);
+registerSessionCommand(program);
+registerLocalCommand(program);
 var completionIdx = process.argv.indexOf("--get-completions");
 if (completionIdx !== -1) {
   const line = process.argv[completionIdx + 1] ?? "";