@todoforai/cli 0.1.53 → 0.1.55

package/README.md

@@ -70,6 +70,17 @@ todoforai-cli -c                     # continue most recent todo
 todoforai-cli --resume <todo-id>     # resume specific todo
 ```
 
+### Notifications
+
+```bash
+tfa-cli inbox                           # the bell: newest across all tabs
+tfa-cli inbox messages --unread         # one filter: needs-you | messages | activity
+tfa-cli inbox seen                      # mark everything read
+tfa-cli notify "Deploy done" "v2 is live" --href /t/<todo-id>   # note to YOUR user (Messages tab + phone push)
+```
+
+`notify` has no recipient option: it always goes to the user the key belongs to (never a teammate or other account), is shown as from the calling agent, delivers the same text once (`--subject` to control the dedupe key) and is capped at 10 new notes per day.
+
 ## IDE integration (ACP)
 
 `todoforai-cli acp` speaks the [Agent Client Protocol](https://agentclientprotocol.com) over stdio, so any ACP-capable editor can drive your agent: prompts from the editor chat, file edits as native diffs, permission prompts inline, and shell commands running on your machine through the bridge. One ACP thread = one todo. Requires `todoforai-cli login` first; `--isolated` / `--user-id` are not supported in this mode.

package/dist/todoforai-cli.js

@@ -42745,7 +42745,7 @@ function randomTip() {
   return TIPS[Math.floor(Math.random() * TIPS.length)];
 }
 
-// ../packages/shared-api/src/api.ts
+// ../../../home/hm/repo/todoforai/packages/shared-api/src/api.ts
 function restBasePath(apiKey) {
   return apiKey.startsWith("dst_") ? "/dst/v1" : "/api/v1";
 }
@@ -42875,6 +42875,9 @@ class ApiClient {
   setDefaultProject(projectId) {
     return this.request("POST", "/api/v1/users/default-project", { projectId });
   }
+  updateProjectSettings(projectId, settings) {
+    return this.request("PUT", `/api/v1/settings/projects/${projectId}`, { projectId, settings });
+  }
   setProjectDefaultAgent(projectId, agentSettingsId) {
     return this.request("POST", "/api/v1/users/project-agent-mapping", { projectId, agentSettingsId });
   }
@@ -42923,6 +42926,19 @@ class ApiClient {
   upsertProjectGroup(projectId, slug, fields) {
     return this.request("PUT", `/api/v1/projects/${projectId}/groups/${encodeURIComponent(slug)}`, { projectId, slug, ...fields });
   }
+  listFeed(opts = {}) {
+    const qs = new URLSearchParams({ all: "true" });
+    for (const [k, v] of Object.entries(opts))
+      if (v !== undefined)
+        qs.set(k, String(v));
+    return this.request("GET", `/api/v1/feed?${qs}`);
+  }
+  markFeedSeen(opts = {}) {
+    return this.request("POST", "/api/v1/feed/seen", { all: true, ...opts });
+  }
+  sendFeedMessage(msg) {
+    return this.request("POST", "/api/v1/feed/message", msg);
+  }
   listProjectSurfaces(projectId) {
     return this.request("GET", `/api/v1/projects/${projectId}/surfaces`);
   }
@@ -43153,11 +43169,11 @@ class ApiClient {
     return res.json();
   }
 }
-// ../packages/shared-api/src/frontend-ws.ts
+// ../../../home/hm/repo/todoforai/packages/shared-api/src/frontend-ws.ts
 import { randomUUID } from "crypto";
 import WebSocket from "ws";
 
-// ../packages/shared-credentials/src/index.ts
+// ../../../home/hm/repo/todoforai/packages/shared-credentials/src/index.ts
 import { readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir, platform } from "node:os";
@@ -43197,13 +43213,14 @@ function writeCredential(apiUrl, apiKey) {
   writeSecure(c);
 }
 
-// ../packages/shared-api/src/frontend-ws.ts
+// ../../../home/hm/repo/todoforai/packages/shared-api/src/frontend-ws.ts
 var log = (level, ...args) => console.log(`[frontend-ws:${level}]`, ...args);
 
 class FrontendWebSocket {
   apiUrl;
   apiKey;
   ws = null;
+  connecting = null;
   tabId = randomUUID();
   connected = false;
   callbacks = new Map;
@@ -43227,28 +43244,61 @@ class FrontendWebSocket {
       wsUrl = `wss://${url}`;
     return `${wsUrl}/ws/v1/frontend?tabId=${this.tabId}`;
   }
-  async connect() {
+  connect() {
     if (this.connected && this.ws)
-      return true;
+      return Promise.resolve(true);
+    this.connecting ??= this.open().finally(() => {
+      this.connecting = null;
+    });
+    return this.connecting;
+  }
+  open() {
     return new Promise((resolve) => {
       const wsUrl = this.getWsUrl();
-      this.ws = new WebSocket(wsUrl, [this.apiKey], { maxPayload: 5 * 1024 * 1024 });
-      this.ws.on("open", () => {
+      const sock = new WebSocket(wsUrl, [this.apiKey], { maxPayload: 5 * 1024 * 1024, handshakeTimeout: 1e4 });
+      this.ws = sock;
+      const current = () => this.ws === sock;
+      let alive = true;
+      let heartbeat;
+      sock.on("pong", () => {
+        alive = true;
+      });
+      sock.on("open", () => {
+        if (!current())
+          return;
         this.connected = true;
+        heartbeat = setInterval(() => {
+          if (!alive) {
+            sock.terminate();
+            return;
+          }
+          alive = false;
+          try {
+            sock.ping();
+          } catch {}
+        }, 15000);
+        heartbeat.unref?.();
         resolve(true);
       });
-      this.ws.on("message", (data) => {
+      sock.on("message", (data) => {
+        if (!current())
+          return;
         try {
           this.handleMessage(JSON.parse(data.toString()));
         } catch {}
       });
-      this.ws.on("close", () => {
+      sock.on("close", () => {
+        clearInterval(heartbeat);
+        if (!current())
+          return;
         this.connected = false;
         this.settleAll();
+        resolve(false);
       });
-      this.ws.on("error", (err) => {
+      sock.on("error", (err) => {
         log("error", "WS error:", err.message);
-        this.connected = false;
+        if (current())
+          this.connected = false;
         resolve(false);
       });
     });
@@ -43317,7 +43367,7 @@ class FrontendWebSocket {
       }
     }
   }
-  async subscribe(todoId, callback) {
+  async subscribe(todoId, callback, opts = {}) {
     if (!this.connected && !await this.connect())
       return false;
     if (callback)
@@ -43325,8 +43375,16 @@ class FrontendWebSocket {
     const res = await fetch(`${this.apiUrl}/api/v1/todos/${todoId}/subscribe`, {
       method: "POST",
       headers: { "x-api-key": this.apiKey, "x-tab-id": this.tabId, "Content-Type": "application/json" },
-      body: JSON.stringify({ todoId })
+      body: JSON.stringify({ todoId }),
+      signal: AbortSignal.timeout(15000)
     });
+    if (res.ok && opts.replayStatus) {
+      this.pendingBlocks.delete(todoId);
+      this.lastReadyPayload.delete(todoId);
+      const status = (await res.json().catch(() => null))?.status;
+      if (status)
+        this.handleMessage({ type: "todo:status", payload: { todoId, status } });
+    }
     return res.ok;
   }
   setCallback(todoId, callback) {
@@ -43336,17 +43394,16 @@ class FrontendWebSocket {
       this.callbacks.delete(todoId);
   }
   async sendInterrupt(projectId, todoId) {
-    if (!this.connected || !this.ws)
+    const ws = this.ws;
+    if (!this.connected || !ws)
       return false;
-    try {
-      this.ws.send(JSON.stringify({
-        type: "todo:interrupt_signal",
-        payload: { projectId, todoId }
-      }));
-      return true;
-    } catch {
-      return false;
-    }
+    return new Promise((resolve) => {
+      try {
+        ws.send(JSON.stringify({ type: "todo:interrupt_signal", payload: { projectId, todoId } }), (err) => resolve(!err));
+      } catch {
+        resolve(false);
+      }
+    });
   }
   async sendQueueCancel(todoId, messageId) {
     if (!this.connected || !this.ws)
@@ -43404,6 +43461,10 @@ class FrontendWebSocket {
     return this.completion(todoId);
   }
   completion(todoId) {
+    if (!this.connected && !this.completionResults.has(todoId)) {
+      this.callbacks.delete(todoId);
+      return Promise.resolve({ type: "socket:closed", payload: { todoId, status: "DISCONNECTED" }, success: false });
+    }
     const early = this.completionResults.get(todoId);
     if (early) {
       this.completionResults.delete(todoId);
@@ -43422,7 +43483,7 @@ class FrontendWebSocket {
     });
   }
 }
-// ../packages/shared-fbe/src/enums.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/enums.ts
 var TodoStatus;
 ((TodoStatus2) => {
   TodoStatus2["PROPOSED"] = "PROPOSED";
@@ -43446,7 +43507,7 @@ var TodoStatus;
   TodoStatus2["ARCHIVED"] = "ARCHIVED";
   TodoStatus2["DELETED"] = "DELETED";
 })(TodoStatus ||= {});
-// ../packages/shared-fbe/src/models.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/models.ts
 var DEFAULT_MODEL = "anthropic:anthropic/claude-opus-5.5";
 var MODEL_ALIASES = {
   claude: DEFAULT_MODEL
@@ -43517,7 +43578,7 @@ function qualifiedModelIds(listing, filter) {
   }
   return q ? ids.filter((id) => id.toLowerCase().includes(q)) : ids;
 }
-// ../packages/shared-fbe/src/billing.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/billing.ts
 var USAGE_WINDOWS = {
   SESSION_MS: 5 * 60 * 60 * 1000,
   WEEK_MS: 7 * 24 * 60 * 60 * 1000,
@@ -43525,7 +43586,7 @@ var USAGE_WINDOWS = {
   SESSION_FACTOR: 1 / 5
 };
 var NEVER_SCHEDULED_TIMESTAMP = 8640000000000000;
-// ../packages/shared-fbe/src/mimetypes.json
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/mimetypes.json
 var mimetypes_default = {
   conversionProfiles: {
     to_jpeg_90: { toMime: "image/jpeg", toExt: "jpg", quality: 0.9 }
@@ -43618,7 +43679,7 @@ var mimetypes_default = {
   }
 };
 
-// ../packages/shared-fbe/src/attachmentUtils.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/attachmentUtils.ts
 var MCP_TEXT_MIME = Object.entries(mimetypes_default.aliases).find(([, type]) => type === "mcp_text")[0];
 var MCP_AUDIO_MIME = Object.entries(mimetypes_default.aliases).find(([, type]) => type === "mcp_audio")[0];
 var AttachmentType = Object.fromEntries(Object.keys(mimetypes_default.types).map((k) => [k.toUpperCase(), k]));
@@ -43658,7 +43719,7 @@ for (const [ext, entry] of Object.entries(mimetypes_default.extensions)) {
   if (!MIME_TO_EXT[mime])
     MIME_TO_EXT[mime] = ext;
 }
-// ../packages/shared-fbe/src/edgeTypes.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/edgeTypes.ts
 var NON_SHELL_TYPES = new Set([
   "WEB_EXTENSION" /* WEB_EXTENSION */,
   "EXTENSION" /* EXTENSION */,
@@ -43666,7 +43727,7 @@ var NON_SHELL_TYPES = new Set([
   "ANDROID" /* ANDROID */,
   "IOS" /* IOS */
 ]);
-// ../packages/shared-fbe/src/blocks/index.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/blocks/index.ts
 var USER_INPUT_BLOCK_TYPES = new Set([
   "question" /* Question */,
   "login_prompt" /* Login */,
@@ -43720,7 +43781,7 @@ var FILE_TOOL_TYPES = new Set([
   "edit" /* Edit */,
   "modify_file" /* ModifyFile */
 ]);
-// ../packages/shared-fbe/src/channels.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/channels.ts
 var privateSuffix = (privateOwnerId) => privateOwnerId ? `:private:${privateOwnerId}` : "";
 var SERVER_TO_FRONTENDS = {
   task: {
@@ -43779,6 +43840,7 @@ var SERVER_TO_FRONTENDS = {
     msgMetaAi: (todoId) => `${"todo:msg_meta_ai" /* TODO_MSG_META_AI */}:${todoId}`,
     msgQueueUpdate: (todoId) => `${"todo:msg_queue_update" /* TODO_MSG_QUEUE_UPDATE */}:${todoId}`,
     message_removed: (todoId) => `${"todo:message_removed" /* TODO_MESSAGE_REMOVED */}:${todoId}`,
+    commentUpdate: (todoId) => `${"todo:comment_update" /* TODO_COMMENT_UPDATE */}:${todoId}`,
     start_universal: (todoId) => `${"block:start_universal" /* BLOCK_START_UNIVERSAL */}:${todoId}`,
     message: (todoId) => `${"block:message" /* BLOCK_MESSAGE */}:${todoId}`,
     end: (todoId) => `${"block:end" /* BLOCK_END */}:${todoId}`,
@@ -43809,7 +43871,7 @@ var SERVER_TO_FRONTENDS = {
     function_call_request: (userId) => `${"FUNCTION_CALL_REQUEST_AGENT" /* FUNCTION_CALL_REQUEST_AGENT */}:frontend:${userId}`
   }
 };
-// ../packages/shared-fbe/src/REST_types.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/REST_types.ts
 var MANUAL_CHANNEL = "Manual";
 function manualAnswersOf(sources) {
   const manual = sources?.find((s) => s.channel === MANUAL_CHANNEL);
@@ -43820,7 +43882,8 @@ function manualAnswersOf(sources) {
   return out;
 }
 var manualSamples = (answers) => Object.entries(answers).filter(([, a]) => a.trim()).map(([prompt, text]) => ({ prompt, text: text.trim() }));
-// ../packages/shared-fbe/src/templateBody.ts
+var senderLabel = (s) => s.kind === "team" ? `${s.name} · TODO for AI team` : `${s.name} · your agent`;
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/templateBody.ts
 var USER_HEADINGS = new Set([
   "your task",
   "your tasks",
@@ -43829,7 +43892,7 @@ var USER_HEADINGS = new Set([
   "steps",
   "data needed"
 ]);
-// ../packages/shared-fbe/src/bashPatterns.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/bashPatterns.ts
 function splitShellCommands(input) {
   const parts = [];
   let current = "";
@@ -44071,7 +44134,7 @@ function getBlockServerId(block) {
   return prefix ? prefix.slice(0, -1) : "*";
 }
 
-// ../packages/shared-fbe/src/permissionUtils.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/permissionUtils.ts
 function parsePattern(pattern) {
   const colonIndex = pattern.indexOf(":");
   if (colonIndex === -1)
@@ -44172,7 +44235,7 @@ function getBlockNewPatterns(block, permissions) {
   }
   return pairs.filter(({ raw, pattern }) => !isPatternAllowed(permissions, pattern) && !allow.some((rule) => bashRuleMatchesCmd(rule, serverId, raw))).map(({ pattern }) => pattern);
 }
-// ../packages/shared-fbe/src/systemAgents.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/systemAgents.ts
 var BUSINESS_ANALYZER_AGENT = {
   id: "00000000-0000-0000-0000-202601013151",
   name: "Business Analyzer",
@@ -44318,7 +44381,7 @@ var SYSTEM_AGENTS = {
   [ONBOARDING_AGENT.id]: ONBOARDING_AGENT
 };
 var RECOMMEND_STEP = "Recommend growth TODOs for this project: materialize the ones you genuinely believe fit " + "as proposal cards on the board (api_recommend_template, one call per recommendation). " + "No quota — fewer good cards beat padding.";
-// ../packages/shared-fbe/src/outputLimits.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/outputLimits.ts
 var MAX_LINE_LEN = 300;
 var STREAM_FIRST = 1e4;
 var STREAM_LAST = 1e4;
@@ -44329,7 +44392,7 @@ var OUTPUT_POLICIES = {
   full: { firstLimit: Infinity, lastLimit: 0, hardCap: RUN_OUTPUT_CAP, lineLimit: MAX_LINE_LEN },
   raw: { firstLimit: Infinity, lastLimit: 0, hardCap: Infinity, lineLimit: Infinity }
 };
-// ../packages/shared-fbe/src/model_promos.json
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/model_promos.json
 var model_promos_default = {
   _doc: [
     "Single source of truth for TODOforAI promotional model discounts.",
@@ -44371,10 +44434,10 @@ var model_promos_default = {
   ]
 };
 
-// ../packages/shared-fbe/src/modelPromos.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/modelPromos.ts
 var BOOST_FACTOR = model_promos_default.boost_remaining_price_factor;
 var MODEL_PROMOS = model_promos_default.promos;
-// ../packages/shared-fbe/src/realtime/topics.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/realtime/topics.ts
 var TOPICS = {
   ["todo:new" /* NEW_TODO */]: {
     channel: (p) => SERVER_TO_FRONTENDS.project.new_todo(p.projectId, p.privateOwnerId),
@@ -44480,6 +44543,10 @@ var TOPICS = {
     channel: (p) => SERVER_TO_FRONTENDS.todo.message_removed(p.todoId),
     audience: "frontend"
   },
+  ["todo:comment_update" /* TODO_COMMENT_UPDATE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.commentUpdate(p.todoId),
+    audience: "frontend"
+  },
   ["todo:msg_meta_usr" /* TODO_MSG_META_USR */]: {
     channel: (p) => SERVER_TO_FRONTENDS.todo.msgMetaUsr(p.todoId),
     audience: "frontend"
@@ -44537,12 +44604,12 @@ var TOPICS = {
     audience: "frontend"
   }
 };
-// ../packages/shared-fbe/src/modelNames.ts
+// ../../../home/hm/repo/todoforai/packages/shared-fbe/src/modelNames.ts
 var LEGACY_MODEL_MAPPING = {
   claude: DEFAULT_MODEL.slice(DEFAULT_MODEL.indexOf(":") + 1),
   "gemini-pro": "google/gemini-3.1-pro-preview"
 };
-// ../packages/shared-credentials/src/index.ts
+// ../../../home/hm/repo/todoforai/packages/shared-credentials/src/index.ts
 function normalizeApiUrl2(url) {
   if (url.startsWith("localhost"))
     return `http://${url}`;
@@ -44556,7 +44623,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@todoforai/cli",
-  version: "0.1.53",
+  version: "0.1.55",
   type: "module",
   bin: {
     "todoforai-cli": "bin/todoforai-cli.js",
@@ -44624,6 +44691,9 @@ Examples:
   tfa-cli show list|rm …              # List / take down shown files
   tfa-cli open <url> [todo-id]        # Live url preview in the chat
   tfa-cli recommend --template <id>    # Add a template as a recommendation card
+  tfa-cli inbox [needs-you|messages|activity] [--unread]  # Read the notification feed (the bell)
+  tfa-cli inbox seen [tab]              # Mark notifications read
+  tfa-cli notify "Title" "message" [--href /t/<id>]  # Note to YOUR OWN user only (Messages tab + phone push); no --to
   tfa-cli claim mint --seed <projectId> [--emails a@x,b@y] [--ttl <sec>]  # Mint /claim/<token> links for a project you own
   tfa-cli next [--direction "<text>"]  # Analyzer growth recommendation cards
   tfa-cli <command> help                # Details per command
@@ -44704,7 +44774,7 @@ var WORD_FLAGS = {
   agents: "list-agents",
   config: "show-config"
 };
-var HELP_SUBCOMMANDS = ["agent", "todo", "project", "brand", "device", "list", "ls", "status", "show", "open"];
+var HELP_SUBCOMMANDS = ["agent", "todo", "project", "brand", "device", "list", "ls", "status", "show", "open", "inbox", "notify"];
 function parseCliArgs() {
   const { values, positionals } = parseArgs({
     args: process.argv.slice(2),
@@ -44739,6 +44809,10 @@ function parseCliArgs() {
       seed: { type: "string" },
       emails: { type: "string" },
       ttl: { type: "string" },
+      subject: { type: "string" },
+      href: { type: "string" },
+      unread: { type: "boolean", default: false },
+      limit: { type: "string" },
       resume: { type: "string", short: "r" },
       continue: { type: "boolean", short: "c", default: false },
       "non-interactive": { type: "boolean", short: "n", default: false },
@@ -46996,7 +47070,88 @@ function renderDiff(originalContent, modifiedContent, filePath) {
   return parts.join("");
 }
 
+// src/shutdown.ts
+var activeRun = null;
+var cleanups = [];
+var exiting = null;
+var cancelling = null;
+var CANCEL_TIMEOUT_MS = 5000;
+function setActiveRun(run) {
+  activeRun = run;
+}
+function withTimeout(p, ms, fallback) {
+  let timer;
+  const timeout = new Promise((r) => {
+    timer = setTimeout(() => r(fallback), ms);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+}
+function cancelActiveRun(timeoutMs = CANCEL_TIMEOUT_MS) {
+  if (cancelling)
+    return cancelling;
+  const pending = activeRun;
+  if (!pending)
+    return Promise.resolve({ ok: false, todoId: null });
+  const res = { ok: false };
+  const attempt = (async () => {
+    const run = await pending;
+    res.todoId = run?.todoId ?? null;
+    if (!run)
+      return res;
+    if (!run.ws.connected && !await run.ws.connect())
+      return res;
+    res.ok = await run.ws.sendInterrupt(run.projectId, run.todoId);
+    return res;
+  })().catch(() => res);
+  cancelling = withTimeout(attempt, timeoutMs, res).finally(() => {
+    if (activeRun === pending)
+      activeRun = null;
+    cancelling = null;
+  });
+  return cancelling;
+}
+function shutdown(code, reason) {
+  return exiting ??= (async () => {
+    if (reason)
+      process.stderr.write(`
+${reason}
+`);
+    if (activeRun) {
+      const { ok, todoId } = await cancelActiveRun();
+      if (ok)
+        process.stderr.write(`Stopped todo ${todoId}
+`);
+      else if (todoId)
+        process.stderr.write(`Warning: could not stop todo ${todoId} (backend unreachable)
+`);
+      else if (todoId === undefined)
+        process.stderr.write(`Warning: could not stop the todo being created (timed out)
+`);
+    }
+    for (const fn of cleanups.splice(0)) {
+      try {
+        fn();
+      } catch {}
+    }
+    process.exit(code);
+  })();
+}
+
 // src/watch.ts
+var RECONNECT_WINDOW_MS = 60000;
+var DISCONNECTED = { type: "socket:closed", success: false };
+async function resubscribe(ws, todoId, callback, windowMs = RECONNECT_WINDOW_MS) {
+  const deadline = Date.now() + windowMs;
+  for (let delay = 1000;; delay = Math.min(delay * 2, 5000)) {
+    await new Promise((r) => setTimeout(r, Math.max(0, Math.min(delay, deadline - Date.now()))));
+    const left = deadline - Date.now();
+    if (left <= 0)
+      return false;
+    const attempt = ws.subscribe(todoId, callback, { replayStatus: true }).catch(() => false);
+    if (await withTimeout(attempt, left, false))
+      return true;
+  }
+}
 var diffStoreByWs = new WeakMap;
 function classifyBlock(info) {
   const inner = (info.block_type || "").toLowerCase();
@@ -47078,12 +47233,8 @@ async function watchTodo(ws, todoId, projectId, opts = {}) {
   process.removeAllListeners("SIGINT");
   process.on("SIGINT", () => {
     interruptCount++;
-    if (interruptCount >= 2) {
-      process.stderr.write(`
-${RED}Force exit (double Ctrl+C)${RESET}
-`);
-      process.exit(130);
-    }
+    if (opts.exitOnInterrupt || interruptCount >= 2)
+      return void shutdown(130, "Cancelled by user (Ctrl+C)");
     process.stderr.write(`
 ${YELLOW}Interrupting... (Ctrl+C again to force exit)${RESET}
 `);
@@ -47282,8 +47433,22 @@ ${DIM}[todo:status] ${status}${RESET}
       callback(msgType, payload);
     }
   }
+  setActiveRun({ ws, projectId, todoId });
   try {
-    const result = await ws.waitForCompletion(todoId, callback);
+    const subscribed = await ws.subscribe(todoId, callback).catch(() => false);
+    let result = subscribed ? await ws.completion(todoId) : DISCONNECTED;
+    while (result?.type === "socket:closed") {
+      process.stderr.write(`
+${YELLOW}Connection lost — reconnecting...${RESET}
+`);
+      if (!await resubscribe(ws, todoId, callback)) {
+        await shutdown(1, `${RED}Error: backend unreachable for ${RECONNECT_WINDOW_MS / 1000}s — giving up on todo ${todoId}${RESET}`);
+      }
+      process.stderr.write(`${DIM}Reconnected.${RESET}
+`);
+      result = await ws.completion(todoId);
+    }
+    setActiveRun(null);
     process.stdout.write(`
 `);
     if (!result?.success) {
@@ -47296,6 +47461,8 @@ ${DIM}[todo:status] ${status}${RESET}
     }
     return true;
   } catch (e) {
+    await cancelActiveRun();
+    process.exitCode = 1;
     if (!opts.suppressCancelNotice) {
       process.stderr.write(`${YELLOW}Interrupted${RESET}
 `);
@@ -47860,7 +48027,7 @@ function printProjectHelp() {
   process.stderr.write(`
 tfa-cli project — edit the current project
 
---project <id> or $TODOFORAI_PROJECT_ID selects the project.
+--project <id>, $TODOFORAI_PROJECT_ID, or the configured default selects the project.
 
 Usage:
   tfa-cli project list                             Projects you can access (* = default)
@@ -47893,6 +48060,7 @@ var TODO_ALIASES = {
   agent: "agentSettingsId",
   public: "isPublic"
 };
+var NO_PROJECT = "No project — pass --project <id> or set TODOFORAI_PROJECT_ID";
 function fail(msg) {
   process.stderr.write(`${RED}${msg}${RESET}
 `);
@@ -47943,9 +48111,8 @@ async function todoCommand(api, positionals, args) {
   process.stderr.write(`${GREEN}✅ ${todoId} updated: ${Object.keys(updates).join(", ")}${RESET}
 `);
 }
-async function projectCommand(api, positionals, args) {
+async function projectCommand(api, positionals, args, projectId) {
   const [, sub, ...rest] = positionals;
-  const projectId = args.project || getEnv2("PROJECT_ID");
   if (!sub) {
     printProjectHelp();
     process.exit(0);
@@ -47964,7 +48131,7 @@ async function projectCommand(api, positionals, args) {
     return;
   }
   if (!projectId)
-    fail("No project — pass --project <id> or set TODOFORAI_PROJECT_ID");
+    fail(NO_PROJECT);
   if (sub === "set") {
     if (!rest.length)
       fail("Usage: tfa-cli project set <field=value>…");
@@ -48077,7 +48244,7 @@ function printBrandHelp() {
   process.stderr.write(`
 tfa-cli brand — the project's brand page and its learned writing voice
 
-The project IS the brand. --project <id> or $TODOFORAI_PROJECT_ID selects it.
+The project IS the brand. --project <id>, $TODOFORAI_PROJECT_ID, or the configured default selects it.
 The brand page text itself is a file: read/write todoforai:business-context.
 
 Usage:
@@ -48107,15 +48274,9 @@ Questions the UI asks (keys for 'answers'):
   "A frustrated customer says things aren't working. How do you reply?"
 `);
 }
-function requireProject(args) {
-  const projectId = args.project || getEnv2("PROJECT_ID");
-  if (!projectId)
-    fail("No project — pass --project <id> or set TODOFORAI_PROJECT_ID");
-  return projectId;
-}
-async function brandCommand(api, positionals, args) {
+async function brandCommand(api, positionals, args, scoped) {
   const [, sub, ...rest] = positionals;
-  const projectId = requireProject(args);
+  const projectId = scoped || fail(NO_PROJECT);
   if (!sub || sub === "show") {
     const brand = await api.getBusinessContext(projectId);
     if (args.json) {
@@ -48572,6 +48733,425 @@ async function listTodosCommand(api, defaultProjectId, argv) {
 `);
 }
 
+// src/notify-command.ts
+import { createHash } from "crypto";
+
+// src/input.ts
+function readMultiline2(prompt, history) {
+  let cancelFn = () => {};
+  const promise = new Promise((resolve4, reject) => {
+    const out = process.stderr;
+    let buf = "";
+    let cursor = 0;
+    let pasting = false;
+    let done = false;
+    let screenRow = 0;
+    let historyIndex = -1;
+    let savedCurrent = "";
+    const promptLen = prompt.replace(/\x1b\[[0-9;]*m/g, "").length;
+    out.write(prompt);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    out.write("\x1B[?2004h");
+    function rowOf(pos) {
+      const cols = process.stderr.columns || 80;
+      const lines = buf.slice(0, pos).split(`
+`);
+      let row = 0;
+      for (let i = 0;i < lines.length; i++) {
+        const len = (i === 0 ? promptLen : 0) + lines[i].length;
+        if (i < lines.length - 1) {
+          row += len === 0 ? 1 : Math.ceil(len / cols);
+        } else {
+          row += len > 0 ? Math.ceil(len / cols) - 1 : 0;
+        }
+      }
+      return row;
+    }
+    function colOf(pos) {
+      const cols = process.stderr.columns || 80;
+      const lastNl = buf.lastIndexOf(`
+`, pos - 1);
+      const lineStart = lastNl + 1;
+      const offset = lineStart === 0 ? promptLen : 0;
+      const linePos = offset + (pos - lineStart);
+      if (linePos > 0 && linePos % cols === 0)
+        return cols;
+      return linePos % cols;
+    }
+    function totalRows() {
+      const cols = process.stderr.columns || 80;
+      const lines = buf.split(`
+`);
+      let rows = 0;
+      for (let i = 0;i < lines.length; i++) {
+        const len = (i === 0 ? promptLen : 0) + lines[i].length;
+        rows += len === 0 ? 1 : Math.ceil(len / cols);
+      }
+      return rows;
+    }
+    function redraw() {
+      const cols = process.stderr.columns || 80;
+      out.write("\r");
+      if (screenRow > 0)
+        out.write(`\x1B[${screenRow}A`);
+      out.write("\x1B[J");
+      out.write(prompt + buf.replace(/\n/g, `\r
+`));
+      const targetRow = rowOf(cursor);
+      const endRow = totalRows() - 1;
+      const rowsBack = endRow - targetRow;
+      const col = colOf(cursor);
+      if (rowsBack > 0)
+        out.write(`\x1B[${rowsBack}A`);
+      if (col <= cols) {
+        out.write("\r");
+        if (col > 0 && col < cols)
+          out.write(`\x1B[${col}C`);
+        if (col === cols)
+          out.write(`\x1B[${cols}G`);
+      }
+      screenRow = targetRow;
+    }
+    function finish(cancelled) {
+      if (done)
+        return;
+      done = true;
+      const rowsDown = totalRows() - 1 - screenRow;
+      if (rowsDown > 0)
+        out.write(`\x1B[${rowsDown}B`);
+      out.write("\x1B[?2004l");
+      out.write(`
+`);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.removeListener("data", onData);
+      if (cancelled)
+        reject(new Error("cancelled"));
+      else
+        resolve4(buf.trim());
+    }
+    function wordRight() {
+      let p = cursor;
+      while (p < buf.length && buf[p] === " ")
+        p++;
+      while (p < buf.length && buf[p] !== " ")
+        p++;
+      return p;
+    }
+    function wordLeft() {
+      let p = cursor;
+      while (p > 0 && buf[p - 1] === " ")
+        p--;
+      while (p > 0 && buf[p - 1] !== " ")
+        p--;
+      return p;
+    }
+    function killToEnd() {
+      buf = buf.slice(0, cursor);
+      redraw();
+    }
+    function deleteWordBack() {
+      const to = wordLeft();
+      if (to === cursor)
+        return;
+      buf = buf.slice(0, to) + buf.slice(cursor);
+      cursor = to;
+      redraw();
+    }
+    function handleCSI(chunk, start) {
+      let i = start + 1;
+      if (i >= chunk.length || chunk[i] !== "[") {
+        if (i < chunk.length)
+          i++;
+        return i;
+      }
+      i++;
+      let params = "";
+      while (i < chunk.length && /[0-9;]/.test(chunk[i])) {
+        params += chunk[i];
+        i++;
+      }
+      const final = i < chunk.length ? chunk[i] : "";
+      i++;
+      const parts = params.split(";");
+      const modifier = parts.length > 1 ? parseInt(parts[1]) : 0;
+      const code = parts[0] || "";
+      const ctrl = modifier === 5;
+      switch (final) {
+        case "D":
+          if (ctrl) {
+            cursor = wordLeft();
+            redraw();
+          } else if (cursor > 0) {
+            cursor--;
+            redraw();
+          }
+          break;
+        case "C":
+          if (ctrl) {
+            cursor = wordRight();
+            redraw();
+          } else if (cursor < buf.length) {
+            cursor++;
+            redraw();
+          }
+          break;
+        case "A":
+          if (history && history.length > 0) {
+            if (historyIndex === -1)
+              savedCurrent = buf;
+            if (historyIndex < history.length - 1) {
+              historyIndex++;
+              buf = history[history.length - 1 - historyIndex];
+              cursor = buf.length;
+              redraw();
+            }
+          }
+          break;
+        case "B":
+          if (history && historyIndex >= 0) {
+            historyIndex--;
+            if (historyIndex === -1) {
+              buf = savedCurrent;
+            } else {
+              buf = history[history.length - 1 - historyIndex];
+            }
+            cursor = buf.length;
+            redraw();
+          }
+          break;
+        case "H":
+          cursor = 0;
+          redraw();
+          break;
+        case "F":
+          cursor = buf.length;
+          redraw();
+          break;
+        case "~":
+          if (code === "3" && cursor < buf.length) {
+            buf = buf.slice(0, cursor) + buf.slice(cursor + 1);
+            redraw();
+          }
+          break;
+      }
+      return i;
+    }
+    function onData(data) {
+      let s = data.toString("utf-8");
+      while (s.length > 0 && !done) {
+        if (pasting) {
+          const end = s.indexOf("\x1B[201~");
+          if (end >= 0) {
+            const text = s.slice(0, end).replace(/\r\n?|\n/g, `
+`);
+            buf = buf.slice(0, cursor) + text + buf.slice(cursor);
+            cursor += text.length;
+            pasting = false;
+            s = s.slice(end + 6);
+            redraw();
+          } else {
+            const text = s.replace(/\r\n?|\n/g, `
+`);
+            buf = buf.slice(0, cursor) + text + buf.slice(cursor);
+            cursor += text.length;
+            s = "";
+            redraw();
+          }
+        } else {
+          const ps = s.indexOf("\x1B[200~");
+          const chunk = ps >= 0 ? s.slice(0, ps) : s;
+          for (let i = 0;i < chunk.length && !done; i++) {
+            const c3 = chunk.charCodeAt(i);
+            if (c3 === 3) {
+              finish(true);
+              return;
+            }
+            if (c3 === 13 || c3 === 10) {
+              finish(false);
+              return;
+            }
+            if (c3 === 23) {
+              deleteWordBack();
+            } else if (c3 === 11) {
+              killToEnd();
+            } else if (c3 === 127 || c3 === 8) {
+              if (cursor > 0) {
+                buf = buf.slice(0, cursor - 1) + buf.slice(cursor);
+                cursor--;
+                redraw();
+              }
+            } else if (c3 === 27) {
+              if (i + 1 < chunk.length && chunk.charCodeAt(i + 1) === 13) {
+                buf = buf.slice(0, cursor) + `
+` + buf.slice(cursor);
+                cursor++;
+                i++;
+                redraw();
+              } else {
+                i = handleCSI(chunk, i) - 1;
+              }
+            } else if (c3 === 1) {
+              cursor = 0;
+              redraw();
+            } else if (c3 === 5) {
+              cursor = buf.length;
+              redraw();
+            } else if (c3 >= 32) {
+              buf = buf.slice(0, cursor) + chunk[i] + buf.slice(cursor);
+              cursor++;
+              redraw();
+            }
+          }
+          if (ps >= 0) {
+            pasting = true;
+            s = s.slice(ps + 6);
+          } else
+            s = "";
+        }
+      }
+    }
+    process.stdin.on("data", onData);
+    cancelFn = () => finish(true);
+  });
+  return { promise, cancel: () => cancelFn() };
+}
+async function readStdin2() {
+  if (process.stdin.isTTY) {
+    try {
+      const content2 = await readMultiline2(`${BRIGHT_WHITE}TODO>${RESET} `).promise;
+      if (!content2) {
+        process.stderr.write(`Error: Empty input
+`);
+        process.exit(1);
+      }
+      return content2;
+    } catch {
+      process.stderr.write(`
+Cancelled
+`);
+      process.exit(1);
+    }
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin)
+    chunks.push(chunk);
+  const content = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!content) {
+    process.stderr.write(`Error: Empty input
+`);
+    process.exit(1);
+  }
+  return content;
+}
+
+// src/notify-command.ts
+var TIERS = { "needs-you": "priority", priority: "priority", activity: "activity", messages: "user_messages" };
+function printInboxHelp() {
+  process.stderr.write(`
+tfa-cli inbox — the user's notification feed (the bell)
+
+Usage:
+  tfa-cli inbox [needs-you|messages|activity] [--unread] [--limit 20] [--json]
+  tfa-cli inbox seen [needs-you|messages|activity]    Mark read (omit = everything)
+
+Filters (same as the bell's chips):
+  needs-you  invites, offers, a todo waiting on the user, a failed todo   (alias: priority)
+  messages   notes from the TODO for AI team or from an agent
+  activity   finished / recommended todos
+`);
+}
+function printNotifyHelp() {
+  process.stderr.write(`
+tfa-cli notify — leave a note for YOUR user (their Messages tab + phone push)
+
+Usage:
+  tfa-cli notify "Title" "message" [--href /t/<todo-id>] [--subject <key>] [--json]
+  echo "message" | tfa-cli notify "Title"
+
+Recipient: ALWAYS the user this key belongs to (the person you work for). There is no --to:
+it cannot message a teammate, a customer or any other account. Shown as from your agent.
+--subject dedupes: the same subject is delivered once (default: hash of title+message,
+so a retry never double-notifies). --href must be an in-app path. Max 10 new notes/day.
+`);
+}
+function tierArg(name) {
+  if (!name)
+    return;
+  const tier = TIERS[name];
+  if (!tier) {
+    process.stderr.write(`${RED}Unknown tab "${name}" — use needs-you, messages, activity${RESET}
+`);
+    process.exit(2);
+  }
+  return tier;
+}
+var when = (ms) => new Date(ms).toLocaleString(undefined, { dateStyle: "short", timeStyle: "short" });
+async function inboxCommand(api, positionals, args) {
+  const [, first, second] = positionals;
+  if (first === "seen") {
+    const tier2 = tierArg(second);
+    await api.markFeedSeen(tier2 ? { tier: tier2 } : {});
+    process.stderr.write(`${GREEN}✅ Marked ${second ?? "everything"} read${RESET}
+`);
+    return;
+  }
+  const tier = tierArg(first);
+  const limit = args.limit ? Number(args.limit) : 20;
+  const page = await api.listFeed({ tier, limit, sinceSeen: !!args.unread || undefined });
+  if (args.json) {
+    console.log(JSON.stringify(page));
+    return;
+  }
+  const counts = page.unseenByTier;
+  if (counts)
+    process.stderr.write(`${DIM}unread — needs you ${counts.priority} · messages ${counts.user_messages} · activity ${counts.activity}${RESET}
+`);
+  if (!page.items.length) {
+    process.stderr.write(`${DIM}Nothing here${RESET}
+`);
+    return;
+  }
+  for (const e of page.items) {
+    const from = e.sender ? `${CYAN}${senderLabel(e.sender)}${RESET} ` : "";
+    const dot = e.unread ? `${YELLOW}●${RESET}` : " ";
+    const state = e.resolution ? ` ${DIM}[${e.resolution}]${RESET}` : "";
+    console.log(`${dot} ${DIM}${when(e.createdAt)}${RESET} ${from}${BOLD}${e.title ?? e.message}${RESET}${state}`);
+    if (e.title && e.message)
+      console.log(`    ${e.message.replace(/\n/g, `
+    `)}`);
+    if (e.href)
+      console.log(`    ${DIM}${e.href}${RESET}`);
+  }
+}
+var RECIPIENT_FLAGS = ["--to", "--email", "--user", "--recipient", "--cc"];
+async function notifyCommand(api, positionals, args) {
+  const argv = process.argv.slice(2);
+  const bad = argv.find((a) => RECIPIENT_FLAGS.some((f) => a === f || a.startsWith(`${f}=`)));
+  if (bad) {
+    process.stderr.write(`${RED}notify has no recipient option (${bad.split("=")[0]}): it only reaches the user this key belongs to — your own user. Messaging other people is not supported.${RESET}
+`);
+    process.exit(2);
+  }
+  const [, title, ...rest] = positionals;
+  const message = rest.join(" ") || (process.stdin.isTTY ? "" : (await readStdin2()).trim());
+  if (!title || !message) {
+    printNotifyHelp();
+    process.exit(2);
+  }
+  const subject = args.subject || createHash("sha256").update(`${title}
+${message}`).digest("hex").slice(0, 16);
+  const row = await api.sendFeedMessage({ subject, title, message, ...args.href ? { href: String(args.href) } : {} });
+  if (args.json) {
+    console.log(JSON.stringify(row));
+    return;
+  }
+  process.stderr.write(row.created !== false ? `${GREEN}✅ Delivered to your own user's Messages inbox (not anyone else)${RESET} ${DIM}(subject ${subject})${RESET}
+` : `${DIM}Already sent (subject ${subject}) — nothing new delivered${RESET}
+`);
+}
+
 // src/index.ts
 import { randomUUID as randomUUID3 } from "crypto";
 
@@ -48836,7 +49416,7 @@ async function spawnMayflyBridge(apiUrl, todoId, workspace, opts = {}) {
       }
     });
   });
-  return { child, stop };
+  return { child, stop, stopped: () => stopped };
 }
 
 // src/acp.ts
@@ -72901,6 +73481,93 @@ async function runAcp(apiUrl, apiKey, opts) {
   await agent2.close();
 }
 
+// src/shutdown.ts
+var activeRun2 = null;
+var cleanups2 = [];
+var exiting2 = null;
+var cancelling2 = null;
+var CANCEL_TIMEOUT_MS2 = 5000;
+function setActiveRun2(run2) {
+  activeRun2 = run2;
+}
+function trackStart(ws, projectId, started) {
+  setActiveRun2(started.then((todoId) => ({ ws, projectId, todoId }), () => null));
+}
+function onShutdown(fn) {
+  cleanups2.push(fn);
+}
+function withTimeout2(p, ms, fallback) {
+  let timer;
+  const timeout = new Promise((r) => {
+    timer = setTimeout(() => r(fallback), ms);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+}
+function cancelActiveRun2(timeoutMs = CANCEL_TIMEOUT_MS2) {
+  if (cancelling2)
+    return cancelling2;
+  const pending = activeRun2;
+  if (!pending)
+    return Promise.resolve({ ok: false, todoId: null });
+  const res = { ok: false };
+  const attempt = (async () => {
+    const run2 = await pending;
+    res.todoId = run2?.todoId ?? null;
+    if (!run2)
+      return res;
+    if (!run2.ws.connected && !await run2.ws.connect())
+      return res;
+    res.ok = await run2.ws.sendInterrupt(run2.projectId, run2.todoId);
+    return res;
+  })().catch(() => res);
+  cancelling2 = withTimeout2(attempt, timeoutMs, res).finally(() => {
+    if (activeRun2 === pending)
+      activeRun2 = null;
+    cancelling2 = null;
+  });
+  return cancelling2;
+}
+function shutdown2(code, reason) {
+  return exiting2 ??= (async () => {
+    if (reason)
+      process.stderr.write(`
+${reason}
+`);
+    if (activeRun2) {
+      const { ok, todoId } = await cancelActiveRun2();
+      if (ok)
+        process.stderr.write(`Stopped todo ${todoId}
+`);
+      else if (todoId)
+        process.stderr.write(`Warning: could not stop todo ${todoId} (backend unreachable)
+`);
+      else if (todoId === undefined)
+        process.stderr.write(`Warning: could not stop the todo being created (timed out)
+`);
+    }
+    for (const fn of cleanups2.splice(0)) {
+      try {
+        fn();
+      } catch {}
+    }
+    process.exit(code);
+  })();
+}
+function finish(code) {
+  if (exiting2)
+    return;
+  process.exitCode = code;
+  process.stdout.end(() => {
+    if (!exiting2)
+      process.exit(code);
+  });
+}
+function installSignalHandlers() {
+  process.on("SIGINT", () => void shutdown2(130, "Cancelled by user (Ctrl+C)"));
+  process.on("SIGTERM", () => void shutdown2(143, "Terminated (SIGTERM)"));
+  process.on("SIGHUP", () => void shutdown2(129, "Hangup (SIGHUP)"));
+}
+
 // src/index.ts
 try {
   const pkgPath = path4.resolve(fileURLToPath(import.meta.url), "../../package.json");
@@ -72976,7 +73643,7 @@ async function interactiveLoop(ws, api2, todoId, projectId, agent2, json2, autoA
       cfg.addToHistory(input2);
       process.stderr.write("\u2500".repeat(40) + `
 `);
-      await api2.addMessage(projectId, input2, agent2, todoId);
+      await appendTracked(api2, ws, projectId, input2, agent2, todoId);
       await watchTodo(ws, todoId, projectId, {
         json: json2,
         autoApprove,
@@ -72987,6 +73654,11 @@ async function interactiveLoop(ws, api2, todoId, projectId, agent2, json2, autoA
     }
   }
 }
+async function appendTracked(api2, ws, projectId, text, agent2, todoId) {
+  const sent = api2.addMessage(projectId, text, agent2, todoId).then(() => todoId);
+  trackStart(ws, projectId, sent);
+  await sent;
+}
 async function linkToSpawningBlock(api2, todoId) {
   const { TODOFORAI_TODO_ID: pTodo, TODOFORAI_MESSAGE_ID: pMsg, TODOFORAI_BLOCK_ID: pBlock } = process.env;
   if (!pTodo || !pMsg || !pBlock || pTodo === todoId)
@@ -72995,12 +73667,7 @@ async function linkToSpawningBlock(api2, todoId) {
 `));
 }
 async function main() {
-  process.on("SIGINT", () => {
-    process.stderr.write(`
-Cancelled by user (Ctrl+C)
-`);
-    process.exit(130);
-  });
+  installSignalHandlers();
   const { values: args, positionals } = parseCliArgs();
   const groupTag = args.group === undefined ? getEnv("GROUP_ID") : String(args.group);
   const groupName = args["group-name"] === undefined ? undefined : String(args["group-name"]);
@@ -73045,11 +73712,19 @@ Cancelled by user (Ctrl+C)
     printDeviceHelp();
     process.exit(0);
   }
+  if (positionals[0] === "inbox" && args.help) {
+    printInboxHelp();
+    process.exit(0);
+  }
+  if (positionals[0] === "notify" && args.help) {
+    printNotifyHelp();
+    process.exit(0);
+  }
   if ((positionals[0] === "list" || positionals[0] === "ls") && args.help) {
     printListTodosHelp();
     process.exit(0);
   }
-  if (args.help && !["list", "ls", "agent", "todo", "project", "brand", "device"].includes(positionals[0])) {
+  if (args.help && !["list", "ls", "agent", "todo", "project", "brand", "device", "inbox", "notify"].includes(positionals[0])) {
     printUsage();
     process.exit(0);
   }
@@ -73167,18 +73842,27 @@ Cancelled by user (Ctrl+C)
     await todoCommand(api2, positionals, args);
     return;
   }
+  const scopedProject = args.project || getEnv("PROJECT_ID") || cfgScope.data.default_project_id || undefined;
   if (positionals[0] === "project") {
-    await projectCommand(api2, positionals, args);
+    await projectCommand(api2, positionals, args, scopedProject);
     return;
   }
   if (positionals[0] === "brand") {
-    await brandCommand(api2, positionals, args);
+    await brandCommand(api2, positionals, args, scopedProject);
     return;
   }
   if (positionals[0] === "device") {
     await deviceCommand(api2, positionals, args);
     return;
   }
+  if (positionals[0] === "inbox") {
+    await inboxCommand(api2, positionals, args);
+    return;
+  }
+  if (positionals[0] === "notify") {
+    await notifyCommand(api2, positionals, args);
+    return;
+  }
   if (positionals[0] === "delete") {
     const todoId = positionals[1];
     if (!todoId) {
@@ -73535,6 +74219,7 @@ Cancelled by user (Ctrl+C)
     }
     if (!args["no-watch"]) {
       const ws2 = new FrontendWebSocket(apiUrl, apiKey);
+      setActiveRun2({ ws: ws2, projectId: projectId2, todoId });
       await ws2.connect();
       const autoApprove = !!args["dangerously-skip-permissions"];
       let agent3 = todo2.agentSettings || { id: todo2.agentSettingsId };
@@ -73545,7 +74230,8 @@ Cancelled by user (Ctrl+C)
       await watchTodo(ws2, todoId, projectId2, {
         json: !!args.json,
         autoApprove,
-        agentSettings: agent3
+        agentSettings: agent3,
+        exitOnInterrupt: !!args["non-interactive"]
       });
       if (!args["non-interactive"]) {
         process.stderr.write(`
@@ -73594,9 +74280,9 @@ Resumed: ${CYAN2}${getFrontendUrl(apiUrl, todoId)}${RESET2}
     const followUp = promptArg(positionals) ?? (process.stdin.isTTY ? "" : await readStdin());
     if (followUp) {
       cfg.addToHistory(followUp);
-      await api2.addMessage(projectId2, followUp, agent3, todoId);
+      await appendTracked(api2, ws2, projectId2, followUp, agent3, todoId);
       await linkToSpawningBlock(api2, todoId);
-      await watchTodo(ws2, todoId, projectId2, { json: !!args.json, autoApprove, agentSettings: agent3 });
+      await watchTodo(ws2, todoId, projectId2, { json: !!args.json, autoApprove, agentSettings: agent3, exitOnInterrupt: !!args["non-interactive"] });
     }
     if (!args["non-interactive"]) {
       await interactiveLoop(ws2, api2, todoId, projectId2, agent3, !!args.json, autoApprove, cfg);
@@ -73615,9 +74301,15 @@ Resumed: ${CYAN2}${getFrontendUrl(apiUrl, todoId)}${RESET2}
   const bridgeReady = !args["no-bridge"] && !args["no-watch"] && !args.isolated ? ensureBridgeRunning2(apiUrl, apiKey) : null;
   const isolatedTodoId = args.isolated ? randomUUID3() : undefined;
   const mayfly = isolatedTodoId ? await spawnMayflyBridge(apiUrl, isolatedTodoId, realpathSync2(resolve4(args.path || ".")), { debug: !!args.debug, apiKey }) : null;
-  if (mayfly)
+  if (mayfly) {
     process.stderr.write(`${DIM2}Isolated bridge:${RESET2} ${CYAN2}mayfly-${isolatedTodoId}${RESET2}
 `);
+    onShutdown(mayfly.stop);
+    mayfly.child.on("exit", (code, sig) => {
+      if (!mayfly.stopped())
+        shutdown2(1, `${RED3}Error: isolated bridge died (${sig ?? `code ${code}`}) \u2014 stopping todo${RESET2}`);
+    });
+  }
   let preMatchedAgent = null;
   let agents = null;
   if (args.agent) {
@@ -73721,15 +74413,16 @@ Resumed: ${CYAN2}${getFrontendUrl(apiUrl, todoId)}${RESET2}
     agent2 = { ...agent2, permissions: { ...perms, allow: [...perms.allow || [], "*:*"] } };
   }
   cfg.addToHistory(content);
+  const created = api2.addMessage(projectId, content, agent2, isolatedTodoId, undefined, undefined, groupTag || undefined, groupName);
+  if (ws)
+    trackStart(ws, projectId, created.then((t) => t.id));
   let todo;
   try {
-    todo = await api2.addMessage(projectId, content, agent2, isolatedTodoId, undefined, undefined, groupTag || undefined, groupName);
+    todo = await created;
   } catch (e) {
     if (!args.project && !envProjectId && cfgScope.data.default_project_id === projectId && /failed: 403/.test(e.message || "")) {
       cfgScope.clearDefaultProject();
-      process.stderr.write(`${RED3}Not authorized for cached default project ${projectName} (${projectId}) \u2014 cleared it. Re-run to pick a project.${RESET2}
-`);
-      process.exit(1);
+      throw new Error(`Not authorized for cached default project ${projectName} (${projectId}) \u2014 cleared it. Re-run to pick a project.`);
     }
     throw e;
   }
@@ -73750,7 +74443,8 @@ Resumed: ${CYAN2}${getFrontendUrl(apiUrl, todoId)}${RESET2}
     await watchTodo(ws, actualTodoId, projectId, {
       json: !!args.json,
       autoApprove,
-      agentSettings: agent2
+      agentSettings: agent2,
+      exitOnInterrupt: !!args["non-interactive"]
     });
     if (!args["non-interactive"]) {
       process.stderr.write(`
@@ -73762,10 +74456,6 @@ ${"\u2500".repeat(40)}
   }
   mayfly?.stop();
 }
-var finish = (code) => {
-  process.exitCode = code;
-  process.stdout.end(() => process.exit(code));
-};
 main().then(() => finish(process.exitCode ?? 0)).catch((e) => {
   process.stderr.write(`Error: ${e.message}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@todoforai/cli",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "type": "module",
   "bin": {
     "todoforai-cli": "bin/todoforai-cli.js",