@great-arrow/cli 0.1.65 → 0.1.66

package/README.md

@@ -31,7 +31,9 @@ gad login
 gad login --no-browser
 
 # Direct personal token (CI/CD, headless). Stored as-is; no auto-refresh.
-gad login --token gad_xxxxx
+# Over a signed-in OAuth session it takes a gad_v1_ token, keeps the session
+# when handed the session's own access token, and otherwise needs --force.
+gad login --token gad_v1_xxxxx
 
 # Check who you are (shows auth type + access-token expiry)
 gad whoami

package/dist/index.js

@@ -9437,7 +9437,7 @@ function isNodeError(value) {
 
 // src/lib/version.ts
 var CLI_PACKAGE_NAME = "@great-arrow/cli";
-var CLI_VERSION = "0.1.65";
+var CLI_VERSION = "0.1.66";
 var GAD_INSTALL_VERSION = "2026.08.08";
 var GAD_INSTALL_MIN_VERSION = "2026.06.22";
 var GAD_INSTALL_HEADER = "X-GAD-Install-Version";
@@ -9594,6 +9594,17 @@ async function clearStoredCredential() {
   await deleteToken();
 }
 
+// src/lib/token-login-guard.ts
+function decideTokenLogin(input2) {
+  const { token, stored, force } = input2;
+  if (stored?.kind !== "oauth") return { action: "store" };
+  if (token === stored.credential.accessToken) {
+    return { action: "keep-oauth", reason: "same-access-token" };
+  }
+  if (token.startsWith("gad_v1_") || force) return { action: "store" };
+  return { action: "refuse", reason: "would-replace-oauth" };
+}
+
 // src/lib/cli-locator.ts
 import {
   chmodSync,
@@ -10369,7 +10380,10 @@ var loginCommand = new Command("login").description("Authenticate the CLI with y
 ).option(
   "--no-browser",
   "Print the authorize URL instead of opening a browser"
-).option("--scope <list>", "OAuth scope to request", "mcp").action(
+).option("--scope <list>", "OAuth scope to request", "mcp").option(
+  "--force",
+  "With --token: replace a signed-in OAuth session even if the token may be short-lived"
+).action(
   async (options) => {
     const fmt = createFormatter({
       json: false,
@@ -10380,6 +10394,24 @@ var loginCommand = new Command("login").description("Authenticate the CLI with y
     const config2 = await loadConfig();
     const apiUrl = DEFAULT_API_URL;
     if (options.token) {
+      const decision = decideTokenLogin({
+        token: options.token,
+        stored: await loadStoredCredential(),
+        force: options.force === true
+      });
+      if (decision.action === "keep-oauth") {
+        fmt.success(
+          "Already signed in: that is your OAuth session's current access token. Keeping the self-refreshing session."
+        );
+        return;
+      }
+      if (decision.action === "refuse") {
+        fmt.error(
+          "You are signed in with a self-refreshing OAuth session, and this token is not a personal API token (gad_v1_\u2026). Storing it would replace the session, and if it is an OAuth access token it stops working within the hour. Use a gad_v1_ token, or pass --force to replace the session anyway."
+        );
+        process.exitCode = 1;
+        return;
+      }
       const stored = await savePatToken(options.token);
       if (!stored) {
         fmt.error(
@@ -11072,7 +11104,7 @@ function getCommandWorkspaceTarget(options = {}) {
 }
 
 // ../local-runtime/src/abortable.ts
-function abortable(run3, signal) {
+function abortable(run4, signal) {
   return new Promise((resolve5, reject) => {
     const abort = () => {
       signal.removeEventListener("abort", abort);
@@ -11082,11 +11114,11 @@ function abortable(run3, signal) {
     signal.addEventListener("abort", abort, { once: true });
     Promise.resolve().then(() => {
       signal.throwIfAborted();
-      return run3();
+      return run4();
     }).then(resolve5, reject).finally(() => signal.removeEventListener("abort", abort));
   });
 }
-async function withLocalDeadline(deadlineMs, run3, parentSignal) {
+async function withLocalDeadline(deadlineMs, run4, parentSignal) {
   if (!Number.isSafeInteger(deadlineMs) || deadlineMs <= 0 || deadlineMs > 36e5)
     throw new Error("Invalid local operation deadline");
   const controller = new AbortController();
@@ -11096,7 +11128,7 @@ async function withLocalDeadline(deadlineMs, run3, parentSignal) {
     deadlineMs
   );
   try {
-    return await abortable(() => run3(signal), signal);
+    return await abortable(() => run4(signal), signal);
   } finally {
     clearTimeout(timer);
   }
@@ -11258,6 +11290,7 @@ async function withNativeResponse(context2, path10, init, consume, parentSignal)
 
 // src/lib/client.ts
 var DEFAULT_TIMEOUT_MS2 = 3e4;
+var PRESENCE_TIMEOUT_MS = 4e4;
 var MAX_RETRIES = 5;
 var BASE_DELAY_MS = 1e3;
 function detectGitOrigin() {
@@ -11649,6 +11682,47 @@ var GadClient = class {
         })();
     }
   }
+  /**
+   * One request with NO retry, bounded by `AbortSignal.timeout`. For the
+   * agent-presence routes: a replayed long-poll doubles a hold and the caller
+   * already owns the loop and its backoff. Returns the status and parsed body
+   * (null when not JSON) so the caller can read a 404 itself; a timeout or
+   * network failure throws.
+   */
+  async requestOnce(method, path10, opts = {}) {
+    const qs = opts.params && Object.keys(opts.params).length > 0 ? `?${new URLSearchParams(opts.params).toString()}` : "";
+    const signal = AbortSignal.timeout(opts.timeoutMs ?? PRESENCE_TIMEOUT_MS);
+    const headers = this.buildHeaders();
+    if (method === "GET") delete headers["Content-Type"];
+    if (this.getToken) {
+      const getToken2 = this.getToken;
+      headers.Authorization = `Bearer ${await new Promise(
+        (resolve5, reject) => {
+          signal.addEventListener(
+            "abort",
+            () => reject(networkError("Session renewal timed out.")),
+            { once: true }
+          );
+          getToken2().then(resolve5, reject);
+        }
+      )}`;
+    }
+    const response = await fetch(`${this.apiUrl}${path10}${qs}`, {
+      method,
+      headers,
+      ...opts.body !== void 0 && { body: JSON.stringify(opts.body) },
+      redirect: "error",
+      cache: "no-store",
+      signal
+    });
+    let body = null;
+    try {
+      body = await response.json();
+    } catch {
+      body = null;
+    }
+    return { status: response.status, body };
+  }
   /**
    * Make a GET request to a REST API endpoint.
    *
@@ -12393,8 +12467,8 @@ function text(value) {
 }
 function formatTodoDetail(todo) {
   const assignees = Array.isArray(todo.assignees) ? todo.assignees.map((a) => `${text(a.displayName)} (${text(a.type)})`).join(", ") : "";
-  const run3 = todo.lastRun ?? null;
-  const lastRun = run3 ? `${text(run3.status)} \u2014 ${text(run3.agentName)}` : "";
+  const run4 = todo.lastRun ?? null;
+  const lastRun = run4 ? `${text(run4.status)} \u2014 ${text(run4.agentName)}` : "";
   return {
     id: text(todo.id),
     title: text(todo.title),
@@ -16668,10 +16742,10 @@ async function mcpJsonAtRiskOfCommit(dir) {
   try {
     const { execFile: execFile5 } = await import("node:child_process");
     const { promisify: promisify2 } = await import("node:util");
-    const run3 = promisify2(execFile5);
-    await run3("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir });
+    const run4 = promisify2(execFile5);
+    await run4("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir });
     try {
-      await run3("git", ["check-ignore", "-q", ".mcp.json"], { cwd: dir });
+      await run4("git", ["check-ignore", "-q", ".mcp.json"], { cwd: dir });
       return false;
     } catch {
       return true;
@@ -17191,9 +17265,9 @@ async function resolveProxyScript(override) {
 async function runProxyDiagnostics(scriptPath) {
   const { execFile: execFile5 } = await import("node:child_process");
   const { promisify: promisify2 } = await import("node:util");
-  const run3 = promisify2(execFile5);
+  const run4 = promisify2(execFile5);
   try {
-    const { stdout } = await run3(
+    const { stdout } = await run4(
       process.execPath,
       [scriptPath, "--print-diagnostics"],
       { timeout: 1e4, maxBuffer: 1024 * 1024 }
@@ -17219,8 +17293,8 @@ async function findLegacyStores(cwd) {
   try {
     const { execFile: execFile5 } = await import("node:child_process");
     const { promisify: promisify2 } = await import("node:util");
-    const run3 = promisify2(execFile5);
-    const { stdout } = await run3("git", ["worktree", "list", "--porcelain"], {
+    const run4 = promisify2(execFile5);
+    const { stdout } = await run4("git", ["worktree", "list", "--porcelain"], {
       cwd,
       timeout: 5e3
     });
@@ -17749,6 +17823,137 @@ var agentsCommand = new Command("agents").description(
   process.stdout.write(renderAgentsNow(result) + "\n");
 });
 
+// src/commands/inbox.ts
+var BACKOFF_BASE_MS = 15e3;
+var BACKOFF_MAX_MS = 12e4;
+var DEFAULT_MAX_MINUTES = 50;
+var PRESENCE_NOT_ENABLED = "Agent presence is not enabled.";
+function waitBackoffMs(emptyHolds) {
+  if (emptyHolds < 3) return 0;
+  return Math.min(2 ** (emptyHolds - 3) * BACKOFF_BASE_MS, BACKOFF_MAX_MS);
+}
+function asMessage(body) {
+  if (!body || typeof body !== "object") return null;
+  const b = body;
+  return b.status === "message" && typeof b.messageId === "string" && typeof b.block === "string" ? { messageId: b.messageId, block: b.block } : null;
+}
+async function runInboxWait(o) {
+  const sleep2 = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = o.now ?? Date.now;
+  const write = o.write ?? ((t) => void process.stdout.write(t));
+  const writeErr = o.writeErr ?? ((t) => void process.stderr.write(t));
+  const stopAt = now() + (o.maxMinutes ?? DEFAULT_MAX_MINUTES) * 6e4;
+  let emptyHolds = 0;
+  while (now() < stopAt) {
+    const params = { as: o.as };
+    if (o.after) params.after = o.after;
+    if (o.waitingOn !== void 0) params.waiting_on = o.waitingOn;
+    let res = null;
+    try {
+      res = await o.request(params);
+    } catch {
+      res = null;
+    }
+    if (res?.status === 404) {
+      writeErr(`${PRESENCE_NOT_ENABLED}
+`);
+      return 2;
+    }
+    const msg = res && res.status === 200 ? asMessage(res.body) : null;
+    if (msg) {
+      const block = msg.block.endsWith("\n") ? msg.block : `${msg.block}
+`;
+      write(`${block}after=${msg.messageId}
+`);
+      return 0;
+    }
+    const gap = Math.min(waitBackoffMs(emptyHolds++), stopAt - now());
+    if (gap > 0) await sleep2(gap);
+  }
+  return 3;
+}
+function parseMaxMinutes(raw) {
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_MAX_MINUTES;
+}
+var waitCommand = new Command("wait").description(
+  "Wait for a peer's message to this connection; run as a background task"
+).requiredOption("--as <id>", "Your connection id (from agent_inbox)").option("--after <id>", "Only wake for messages newer than this id").option("--waiting-on <text>", "What you are waiting on, shown to peers").option("--max-minutes <n>", "Give up after this many minutes", "50").action(
+  async (opts) => {
+    const auth = await resolveAuth();
+    const client2 = new GadClient({
+      token: auth.token,
+      getToken: auth.getToken,
+      apiUrl: auth.apiUrl
+    });
+    process.exitCode = await runInboxWait({
+      request: (params) => client2.requestOnce("GET", "/api/agent-comms/wait", { params }),
+      as: opts.as,
+      after: opts.after,
+      waitingOn: opts.waitingOn,
+      maxMinutes: parseMaxMinutes(opts.maxMinutes)
+    });
+  }
+);
+var inboxCommand = new Command("inbox").description("Agent inbox \u2014 wait for a peer's message").addCommand(waitCommand);
+
+// src/commands/presence.ts
+function doNotDisturbBody(raw, as) {
+  if (raw.trim().toLowerCase() === "off") {
+    return { action: "do_not_disturb", as, minutes: null };
+  }
+  const minutes = Number(raw);
+  if (!Number.isFinite(minutes) || minutes <= 0) {
+    throw new CliError(
+      `Expected a number of minutes or "off", got "${raw}".`,
+      3 /* VALIDATION_ERROR */
+    );
+  }
+  return { action: "do_not_disturb", as, minutes };
+}
+async function sendPresence(o) {
+  const write = o.write ?? ((t) => void process.stdout.write(t));
+  const writeErr = o.writeErr ?? ((t) => void process.stderr.write(t));
+  const res = await o.request(o.body);
+  if (res.status === 404) {
+    writeErr(`${PRESENCE_NOT_ENABLED}
+`);
+    return 2;
+  }
+  if (res.status < 200 || res.status >= 300) {
+    writeErr(`Presence update failed (HTTP ${res.status}).
+`);
+    return res.status === 401 || res.status === 403 ? 1 /* AUTH_ERROR */ : res.status === 400 ? 3 /* VALIDATION_ERROR */ : 2 /* NETWORK_ERROR */;
+  }
+  const b = o.body;
+  write(
+    b.action === "sign_off" ? "Signed off.\n" : b.minutes === null ? "Do not disturb is off.\n" : `Do not disturb for ${b.minutes} minutes.
+`
+  );
+  return 0;
+}
+async function run2(body) {
+  const auth = await resolveAuth();
+  const client2 = new GadClient({
+    token: auth.token,
+    getToken: auth.getToken,
+    apiUrl: auth.apiUrl
+  });
+  process.exitCode = await sendPresence({
+    request: (b) => client2.requestOnce("POST", "/api/agent-comms/presence", { body: b }),
+    body
+  });
+}
+var presenceCommand = new Command("presence").description("Tell peers you are away: do not disturb, or sign off").addCommand(
+  new Command("do-not-disturb").description("Tell peers not to disturb you for a while, or turn it off").argument("<minutes|off>", "Minutes (up to 480), or off").requiredOption("--as <id>", "Your connection id (from agent_inbox)").action(async (raw, opts) => {
+    await run2(doNotDisturbBody(raw, opts.as));
+  })
+).addCommand(
+  new Command("sign-off").description("Mark this connection as signed off").requiredOption("--as <id>", "Your connection id (from agent_inbox)").action(async (opts) => {
+    await run2({ action: "sign_off", as: opts.as });
+  })
+);
+
 // src/commands/ask.ts
 var ORCHESTRATOR_TIMEOUT_MS = 9e4;
 var ANSWER_FIELDS = [
@@ -38970,7 +39175,7 @@ function visit(schema, fnOrHandlers) {
     return h ? h(node2, rewritten) : node2;
   };
   const cache = /* @__PURE__ */ new Map();
-  function run3(s2) {
+  function run4(s2) {
     const cached2 = cache.get(s2);
     if (cached2 === RESOLVING) {
       return new $ZodLazy({
@@ -38996,21 +39201,21 @@ function visit(schema, fnOrHandlers) {
         let changed = false;
         const newShape = {};
         for (const k of keys) {
-          const mapped = run3(oldShape[k]);
+          const mapped = run4(oldShape[k]);
           if (mapped !== oldShape[k])
             changed = true;
           newShape[k] = mapped;
         }
         let newCatchall = def.catchall;
         if (def.catchall) {
-          newCatchall = run3(def.catchall);
+          newCatchall = run4(def.catchall);
           if (newCatchall !== def.catchall)
             changed = true;
         }
         return changed ? clone(s2, { ...def, shape: newShape, catchall: newCatchall }) : s2;
       }
       case "array": {
-        const mapped = run3(def.element);
+        const mapped = run4(def.element);
         return mapped === def.element ? s2 : clone(s2, { ...def, element: mapped });
       }
       case "tuple": {
@@ -39018,14 +39223,14 @@ function visit(schema, fnOrHandlers) {
         let changed = false;
         const newItems = [];
         for (const item of oldItems) {
-          const mapped = run3(item);
+          const mapped = run4(item);
           if (mapped !== item)
             changed = true;
           newItems.push(mapped);
         }
         let newRest = def.rest;
         if (def.rest) {
-          newRest = run3(def.rest);
+          newRest = run4(def.rest);
           if (newRest !== def.rest)
             changed = true;
         }
@@ -39033,12 +39238,12 @@ function visit(schema, fnOrHandlers) {
       }
       case "record":
       case "map": {
-        const newKey = run3(def.keyType);
-        const newVal = run3(def.valueType);
+        const newKey = run4(def.keyType);
+        const newVal = run4(def.valueType);
         return newKey === def.keyType && newVal === def.valueType ? s2 : clone(s2, { ...def, keyType: newKey, valueType: newVal });
       }
       case "set": {
-        const newVal = run3(def.valueType);
+        const newVal = run4(def.valueType);
         return newVal === def.valueType ? s2 : clone(s2, { ...def, valueType: newVal });
       }
       case "union": {
@@ -39046,7 +39251,7 @@ function visit(schema, fnOrHandlers) {
         let changed = false;
         const newOptions = [];
         for (const opt of oldOptions) {
-          const mapped = run3(opt);
+          const mapped = run4(opt);
           if (mapped !== opt)
             changed = true;
           newOptions.push(mapped);
@@ -39054,8 +39259,8 @@ function visit(schema, fnOrHandlers) {
         return changed ? clone(s2, { ...def, options: newOptions }) : s2;
       }
       case "intersection": {
-        const newLeft = run3(def.left);
-        const newRight = run3(def.right);
+        const newLeft = run4(def.left);
+        const newRight = run4(def.right);
         return newLeft === def.left && newRight === def.right ? s2 : clone(s2, { ...def, left: newLeft, right: newRight });
       }
       case "optional":
@@ -39067,23 +39272,23 @@ function visit(schema, fnOrHandlers) {
       case "nonoptional":
       case "promise":
       case "success": {
-        const newInner = run3(def.innerType);
+        const newInner = run4(def.innerType);
         return newInner === def.innerType ? s2 : clone(s2, { ...def, innerType: newInner });
       }
       case "pipe": {
-        const newIn = run3(def.in);
-        const newOut = run3(def.out);
+        const newIn = run4(def.in);
+        const newOut = run4(def.out);
         return newIn === def.in && newOut === def.out ? s2 : clone(s2, { ...def, in: newIn, out: newOut });
       }
       case "function": {
-        const newInput = run3(def.input);
-        const newOutput = run3(def.output);
+        const newInput = run4(def.input);
+        const newOutput = run4(def.output);
         return newInput === def.input && newOutput === def.output ? s2 : clone(s2, { ...def, input: newInput, output: newOutput });
       }
       case "lazy": {
         const original = def.getter;
         const { _cachedInner, ...rest } = def;
-        return clone(s2, { ...rest, getter: () => run3(original()) });
+        return clone(s2, { ...rest, getter: () => run4(original()) });
       }
       // A leaf by choice: `parts` are regex fragments, not data positions.
       case "template_literal":
@@ -39114,7 +39319,7 @@ function visit(schema, fnOrHandlers) {
       }
     }
   }
-  return run3(schema);
+  return run4(schema);
 }
 
 // ../../node_modules/zod/v4/classic/deep-partial.js
@@ -50304,7 +50509,7 @@ function helperKind(raw) {
   if (/^store\b/.test(v)) return "store";
   return "other";
 }
-function run2(file2, args) {
+function run3(file2, args) {
   return new Promise((done) => {
     execFile4(
       file2,
@@ -50315,10 +50520,10 @@ function run2(file2, args) {
   });
 }
 async function detectGhCli() {
-  return await run2("gh", ["--version"]) !== null;
+  return await run3("gh", ["--version"]) !== null;
 }
 async function detectGitHelper() {
-  const out2 = await run2("git", [
+  const out2 = await run3("git", [
     "config",
     "--get-urlmatch",
     "credential.helper",
@@ -50547,29 +50752,29 @@ function statusCommand4() {
     const runId = requireRunId(runArg);
     const { client: client2, apiUrl } = await keysContext();
     const res = await client2.get(`/api/key-rotation/runs/${runId}`);
-    const run3 = res?.run ?? {};
+    const run4 = res?.run ?? {};
     if (g.json) {
-      out(JSON.stringify(run3));
+      out(JSON.stringify(run4));
       return;
     }
     const c = createColor(g.noColor || g.quiet);
     out(
-      `${c.bold(`Run ${runId}`)}  ${s(run3.state)}` + (s(run3.waitingOn) ? c.dim(`  waiting on ${s(run3.waitingOn)}`) : "")
+      `${c.bold(`Run ${runId}`)}  ${s(run4.state)}` + (s(run4.waitingOn) ? c.dim(`  waiting on ${s(run4.waitingOn)}`) : "")
     );
-    for (const st of run3.steps ?? []) {
+    for (const st of run4.steps ?? []) {
       const detail = s(st.detailCode);
       out(
         `  ${s(st.step)} ${c.dim(s(st.targetKind))}  ${s(st.status)}` + (detail ? c.dim(` (${detail})`) : "")
       );
     }
-    const open4 = (run3.checklist ?? []).filter((i) => i.ticked !== true);
+    const open4 = (run4.checklist ?? []).filter((i) => i.ticked !== true);
     if (open4.length > 0) {
       out(c.yellow("Checklist (tick these in the browser):"));
       for (const item of open4) {
         out(`  \u2610 ${s(item.label)}  ${c.cyan(s(item.href))}`);
       }
     }
-    for (const d of run3.devices ?? []) {
+    for (const d of run4.devices ?? []) {
       out(`  device ${s(d.label)}  ${s(d.state)}`);
     }
     out(c.dim(`${apiUrl}${keyRotationRunPath(runId)}`));
@@ -50910,6 +51115,8 @@ var COMMANDS = [
   "smoke",
   "agent",
   "ask",
+  "inbox",
+  "presence",
   "runtime",
   "open",
   "completions"
@@ -50951,6 +51158,12 @@ _gad_completions() {
     agent)
       COMPREPLY=( $(compgen -W "list invoke" -- "\${cur}") )
       ;;
+    inbox)
+      COMPREPLY=( $(compgen -W "wait" -- "\${cur}") )
+      ;;
+    presence)
+      COMPREPLY=( $(compgen -W "do-not-disturb sign-off" -- "\${cur}") )
+      ;;
     runtime)
       COMPREPLY=( $(compgen -W "status set sync policy" -- "\${cur}") )
       ;;
@@ -50986,6 +51199,8 @@ _gad() {
     'smoke:Run smoke tests'
     'agent:Manage agents (list, invoke)'
     'ask:Ask the orchestrator a question'
+    'inbox:Agent inbox (wait)'
+    'presence:Agent presence (do-not-disturb, sign-off)'
     'runtime:Choose your computer or the cloud per lane'
     'open:Open an app surface in the browser'
     'completions:Generate shell completions'
@@ -51021,6 +51236,14 @@ _gad() {
       subcommands=('list:List agents' 'invoke:Invoke an agent')
       _describe -t subcommands 'agent subcommands' subcommands
       ;;
+    inbox)
+      subcommands=('wait:Wait for a peer message')
+      _describe -t subcommands 'inbox subcommands' subcommands
+      ;;
+    presence)
+      subcommands=('do-not-disturb:Do not disturb for a while, or off' 'sign-off:Sign off this connection')
+      _describe -t subcommands 'presence subcommands' subcommands
+      ;;
     runtime)
       subcommands=('status:Where each lane runs' 'set:Set a lane' 'sync:Apply to this checkout' 'policy:Workspace policy')
       _describe -t subcommands 'runtime subcommands' subcommands
@@ -51049,6 +51272,8 @@ function generateFish() {
     smoke: "Run smoke tests",
     agent: "Manage agents",
     ask: "Ask the orchestrator a question",
+    inbox: "Agent inbox",
+    presence: "Agent presence",
     runtime: "Choose your computer or the cloud per lane",
     open: "Open an app surface in the browser",
     completions: "Generate shell completions"
@@ -51087,6 +51312,13 @@ function generateFish() {
       list: "List agents",
       invoke: "Invoke an agent"
     },
+    inbox: {
+      wait: "Wait for a peer message"
+    },
+    presence: {
+      "do-not-disturb": "Do not disturb for a while, or off",
+      "sign-off": "Sign off this connection"
+    },
     runtime: {
       status: "Where each lane runs",
       set: "Set a lane",
@@ -54566,6 +54798,8 @@ program2.addCommand(integrations_default);
 program2.addCommand(mcp_default);
 program2.addCommand(agentCommand);
 program2.addCommand(agentsCommand);
+program2.addCommand(inboxCommand);
+program2.addCommand(presenceCommand);
 program2.addCommand(askCommand());
 program2.addCommand(localCommand());
 program2.addCommand(runtimeCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@great-arrow/cli",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "GreatArrow.ai CLI tool",
   "type": "module",
   "bin": {