@todoforai/cli 0.1.10 → 0.1.11

package/dist/todoai.js

@@ -2024,11 +2024,11 @@ var require_core = __commonJS((exports, module) => {
         cmode.illegalRe = langRe(mode.illegal);
       if (!mode.contains)
         mode.contains = [];
-      mode.contains = [].concat(...mode.contains.map(function(c) {
-        return expandOrCloneMode(c === "self" ? mode : c);
+      mode.contains = [].concat(...mode.contains.map(function(c2) {
+        return expandOrCloneMode(c2 === "self" ? mode : c2);
       }));
-      mode.contains.forEach(function(c) {
-        compileMode(c, cmode);
+      mode.contains.forEach(function(c2) {
+        compileMode(c2, cmode);
       });
       if (mode.starts) {
         compileMode(mode.starts, parent);
@@ -2685,8 +2685,8 @@ https://github.com/highlightjs/highlight.js/issues/2277`);
         return;
       initHighlighting.called = true;
       deprecated("10.6.0", "initHighlighting() is deprecated.  Use highlightAll() instead.");
-      const blocks = document.querySelectorAll("pre code");
-      blocks.forEach(highlightElement);
+      const blocks3 = document.querySelectorAll("pre code");
+      blocks3.forEach(highlightElement);
     };
     function initHighlightingOnLoad() {
       deprecated("10.6.0", "initHighlightingOnLoad() is deprecated.  Use highlightAll() instead.");
@@ -2698,8 +2698,8 @@ https://github.com/highlightjs/highlight.js/issues/2277`);
         wantsHighlight = true;
         return;
       }
-      const blocks = document.querySelectorAll("pre code");
-      blocks.forEach(highlightElement);
+      const blocks3 = document.querySelectorAll("pre code");
+      blocks3.forEach(highlightElement);
     }
     function boot() {
       if (wantsHighlight)
@@ -6049,7 +6049,7 @@ var require_c = __commonJS((exports, module) => {
     const joined = args.map((x) => source(x)).join("");
     return joined;
   }
-  function c(hljs) {
+  function c2(hljs) {
     const C_LINE_COMMENT_MODE = hljs.COMMENT("//", "$", {
       contains: [
         {
@@ -6266,7 +6266,7 @@ var require_c = __commonJS((exports, module) => {
       }
     };
   }
-  module.exports = c;
+  module.exports = c2;
 });
 
 // node_modules/highlight.js/lib/languages/cal.js
@@ -15883,10 +15883,10 @@ var require_less = __commonJS((exports, module) => {
     const INTERP_IDENT_RE = "(" + IDENT_RE + "|@\\{" + IDENT_RE + "\\})";
     const RULES = [];
     const VALUE_MODES = [];
-    const STRING_MODE = function(c) {
+    const STRING_MODE = function(c2) {
       return {
         className: "string",
-        begin: "~?" + c + ".*?" + c
+        begin: "~?" + c2 + ".*?" + c2
       };
     };
     const IDENT_MODE = function(name, begin, relevance) {
@@ -41132,10 +41132,10 @@ var require_conversions = __commonJS((exports, module) => {
     if (convert[model].labels.length !== convert[model].channels) {
       throw new Error("channel and label counts mismatch: " + model);
     }
-    const { channels, labels } = convert[model];
+    const { channels: channels2, labels } = convert[model];
     delete convert[model].channels;
     delete convert[model].labels;
-    Object.defineProperty(convert[model], "channels", { value: channels });
+    Object.defineProperty(convert[model], "channels", { value: channels2 });
     Object.defineProperty(convert[model], "labels", { value: labels });
   }
   convert.rgb.hsl = function(rgb) {
@@ -41181,8 +41181,8 @@ var require_conversions = __commonJS((exports, module) => {
     const b = rgb[2] / 255;
     const v = Math.max(r, g, b);
     const diff = v - Math.min(r, g, b);
-    const diffc = function(c) {
-      return (v - c) / 6 / diff + 1 / 2;
+    const diffc = function(c2) {
+      return (v - c2) / 6 / diff + 1 / 2;
     };
     if (diff === 0) {
       h = 0;
@@ -41225,10 +41225,10 @@ var require_conversions = __commonJS((exports, module) => {
     const g = rgb[1] / 255;
     const b = rgb[2] / 255;
     const k = Math.min(1 - r, 1 - g, 1 - b);
-    const c = (1 - r - k) / (1 - k) || 0;
+    const c2 = (1 - r - k) / (1 - k) || 0;
     const m = (1 - g - k) / (1 - k) || 0;
     const y = (1 - b - k) / (1 - k) || 0;
-    return [c * 100, m * 100, y * 100, k * 100];
+    return [c2 * 100, m * 100, y * 100, k * 100];
   };
   function comparativeDistance(x, y) {
     return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
@@ -41430,11 +41430,11 @@ var require_conversions = __commonJS((exports, module) => {
     return [r * 255, g * 255, b * 255];
   };
   convert.cmyk.rgb = function(cmyk) {
-    const c = cmyk[0] / 100;
+    const c2 = cmyk[0] / 100;
     const m = cmyk[1] / 100;
     const y = cmyk[2] / 100;
     const k = cmyk[3] / 100;
-    const r = 1 - Math.min(1, c * (1 - k) + k);
+    const r = 1 - Math.min(1, c2 * (1 - k) + k);
     const g = 1 - Math.min(1, m * (1 - k) + k);
     const b = 1 - Math.min(1, y * (1 - k) + k);
     return [r * 255, g * 255, b * 255];
@@ -41503,16 +41503,16 @@ var require_conversions = __commonJS((exports, module) => {
     if (h < 0) {
       h += 360;
     }
-    const c = Math.sqrt(a * a + b * b);
-    return [l, c, h];
+    const c2 = Math.sqrt(a * a + b * b);
+    return [l, c2, h];
   };
   convert.lch.lab = function(lch) {
     const l = lch[0];
-    const c = lch[1];
+    const c2 = lch[1];
     const h = lch[2];
     const hr = h / 360 * 2 * Math.PI;
-    const a = c * Math.cos(hr);
-    const b = c * Math.sin(hr);
+    const a = c2 * Math.cos(hr);
+    const b = c2 * Math.sin(hr);
     return [l, a, b];
   };
   convert.rgb.ansi16 = function(args, saturation = null) {
@@ -41564,8 +41564,8 @@ var require_conversions = __commonJS((exports, module) => {
   };
   convert.ansi256.rgb = function(args) {
     if (args >= 232) {
-      const c = (args - 232) * 10 + 8;
-      return [c, c, c];
+      const c2 = (args - 232) * 10 + 8;
+      return [c2, c2, c2];
     }
     args -= 16;
     let rem;
@@ -41626,28 +41626,28 @@ var require_conversions = __commonJS((exports, module) => {
   convert.hsl.hcg = function(hsl) {
     const s = hsl[1] / 100;
     const l = hsl[2] / 100;
-    const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
+    const c2 = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
     let f = 0;
-    if (c < 1) {
-      f = (l - 0.5 * c) / (1 - c);
+    if (c2 < 1) {
+      f = (l - 0.5 * c2) / (1 - c2);
     }
-    return [hsl[0], c * 100, f * 100];
+    return [hsl[0], c2 * 100, f * 100];
   };
   convert.hsv.hcg = function(hsv) {
     const s = hsv[1] / 100;
     const v = hsv[2] / 100;
-    const c = s * v;
+    const c2 = s * v;
     let f = 0;
-    if (c < 1) {
-      f = (v - c) / (1 - c);
+    if (c2 < 1) {
+      f = (v - c2) / (1 - c2);
     }
-    return [hsv[0], c * 100, f * 100];
+    return [hsv[0], c2 * 100, f * 100];
   };
   convert.hcg.rgb = function(hcg) {
     const h = hcg[0] / 360;
-    const c = hcg[1] / 100;
+    const c2 = hcg[1] / 100;
     const g = hcg[2] / 100;
-    if (c === 0) {
+    if (c2 === 0) {
       return [g * 255, g * 255, g * 255];
     }
     const pure = [0, 0, 0];
@@ -41686,51 +41686,51 @@ var require_conversions = __commonJS((exports, module) => {
         pure[1] = 0;
         pure[2] = w;
     }
-    mg = (1 - c) * g;
+    mg = (1 - c2) * g;
     return [
-      (c * pure[0] + mg) * 255,
-      (c * pure[1] + mg) * 255,
-      (c * pure[2] + mg) * 255
+      (c2 * pure[0] + mg) * 255,
+      (c2 * pure[1] + mg) * 255,
+      (c2 * pure[2] + mg) * 255
     ];
   };
   convert.hcg.hsv = function(hcg) {
-    const c = hcg[1] / 100;
+    const c2 = hcg[1] / 100;
     const g = hcg[2] / 100;
-    const v = c + g * (1 - c);
+    const v = c2 + g * (1 - c2);
     let f = 0;
     if (v > 0) {
-      f = c / v;
+      f = c2 / v;
     }
     return [hcg[0], f * 100, v * 100];
   };
   convert.hcg.hsl = function(hcg) {
-    const c = hcg[1] / 100;
+    const c2 = hcg[1] / 100;
     const g = hcg[2] / 100;
-    const l = g * (1 - c) + 0.5 * c;
+    const l = g * (1 - c2) + 0.5 * c2;
     let s = 0;
     if (l > 0 && l < 0.5) {
-      s = c / (2 * l);
+      s = c2 / (2 * l);
     } else if (l >= 0.5 && l < 1) {
-      s = c / (2 * (1 - l));
+      s = c2 / (2 * (1 - l));
     }
     return [hcg[0], s * 100, l * 100];
   };
   convert.hcg.hwb = function(hcg) {
-    const c = hcg[1] / 100;
+    const c2 = hcg[1] / 100;
     const g = hcg[2] / 100;
-    const v = c + g * (1 - c);
-    return [hcg[0], (v - c) * 100, (1 - v) * 100];
+    const v = c2 + g * (1 - c2);
+    return [hcg[0], (v - c2) * 100, (1 - v) * 100];
   };
   convert.hwb.hcg = function(hwb) {
     const w = hwb[1] / 100;
     const b = hwb[2] / 100;
     const v = 1 - b;
-    const c = v - w;
+    const c2 = v - w;
     let g = 0;
-    if (c < 1) {
-      g = (v - c) / (1 - c);
+    if (c2 < 1) {
+      g = (v - c2) / (1 - c2);
     }
-    return [hwb[0], c * 100, g * 100];
+    return [hwb[0], c2 * 100, g * 100];
   };
   convert.apple.rgb = function(apple) {
     return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
@@ -42194,16 +42194,16 @@ var require_templates = __commonJS((exports, module) => {
     ["e", "\x1B"],
     ["a", "\x07"]
   ]);
-  function unescape(c) {
-    const u = c[0] === "u";
-    const bracket = c[1] === "{";
-    if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
-      return String.fromCharCode(parseInt(c.slice(1), 16));
+  function unescape(c2) {
+    const u = c2[0] === "u";
+    const bracket = c2[1] === "{";
+    if (u && !bracket && c2.length === 5 || c2[0] === "x" && c2.length === 3) {
+      return String.fromCharCode(parseInt(c2.slice(1), 16));
     }
     if (u && bracket) {
-      return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+      return String.fromCodePoint(parseInt(c2.slice(2, -1), 16));
     }
-    return ESCAPES.get(c) || c;
+    return ESCAPES.get(c2) || c2;
   }
   function parseArguments(name, arguments_) {
     const results = [];
@@ -42798,7 +42798,10 @@ class ApiClient {
     return this.request("GET", `/api/v1/todos/${todoId}`);
   }
   updateTodoStatus(todoId, status) {
-    return this.request("PUT", `/api/v1/todos/${todoId}`, { status });
+    return this.request("PATCH", `/api/v1/todos/${todoId}/status`, { status });
+  }
+  deleteTodo(todoId) {
+    return this.request("DELETE", `/api/v1/todos/${todoId}`);
   }
   listAgentSettings(filters) {
     const params = new URLSearchParams;
@@ -43134,7 +43137,783 @@ var package_default = {
     typescript: "^5.7.0"
   }
 };
+// ../packages/shared-fbe/src/enums.ts
+var TodoStatus;
+((TodoStatus2) => {
+  TodoStatus2["TODO"] = "TODO";
+  TodoStatus2["SCHEDULED"] = "SCHEDULED";
+  TodoStatus2["PAUSED"] = "PAUSED";
+  TodoStatus2["POSTPONED"] = "POSTPONED";
+  TodoStatus2["REVIEW_REQUESTED"] = "REVIEW_REQUESTED";
+  TodoStatus2["RUNNING"] = "RUNNING";
+  TodoStatus2["COMPACTING"] = "COMPACTING";
+  TodoStatus2["STOPPING"] = "STOPPING";
+  TodoStatus2["READY"] = "READY";
+  TodoStatus2["READY_CHECKED"] = "READY_CHECKED";
+  TodoStatus2["DONE"] = "DONE";
+  TodoStatus2["CANCELLED"] = "CANCELLED";
+  TodoStatus2["CANCELLED_CHECKED"] = "CANCELLED_CHECKED";
+  TodoStatus2["ERROR"] = "ERROR";
+  TodoStatus2["ERROR_CHECKED"] = "ERROR_CHECKED";
+  TodoStatus2["ARCHIVED"] = "ARCHIVED";
+  TodoStatus2["DELETED"] = "DELETED";
+})(TodoStatus ||= {});
+// ../packages/shared-fbe/src/mimetypes.json
+var mimetypes_default = {
+  conversionProfiles: {
+    to_jpeg_90: { toMime: "image/jpeg", toExt: "jpg", quality: 0.9 }
+  },
+  types: {
+    image: { icon: "mdi:file-image", color: "yellow", prefixRule: "image/", needsObjectUrl: true },
+    audio: { icon: "mdi:file-music", color: "grey", prefixRule: "audio/", needsObjectUrl: true },
+    video: { icon: "mdi:file-video", color: "yellow", prefixRule: "video/", needsObjectUrl: true },
+    pdf: { icon: "mdi:pdf-box", color: "red", needsObjectUrl: true },
+    document: { icon: "mdi:file-word", color: "lightblue" },
+    spreadsheet: { icon: "mdi:file-excel", color: "green" },
+    text: { icon: "mdi:file", color: "white", prefixRule: "text/" },
+    archive: { icon: "mdi:folder-zip", color: "purple" },
+    unknown: { icon: "mdi:file", color: "grey" },
+    mcp_text: { icon: "mdi:robot", color: "purple" },
+    mcp_image: { icon: "mdi:robot", color: "purple", needsObjectUrl: true },
+    mcp_audio: { icon: "mdi:robot", color: "purple", needsObjectUrl: true },
+    mcp_resource: { icon: "mdi:cloud", color: "purple" }
+  },
+  extensions: {
+    txt: { mime: "text/plain", type: "text" },
+    md: { mime: "text/markdown", type: "text" },
+    json: { mime: "application/json", type: "text" },
+    js: { mime: "text/javascript", type: "text" },
+    ts: { mime: "text/typescript", type: "text" },
+    html: { mime: "text/html", type: "text" },
+    css: { mime: "text/css", type: "text" },
+    xml: { mime: "text/xml", type: "text" },
+    py: { mime: "text/x-python", type: "text" },
+    java: { mime: "text/x-java-source", type: "text" },
+    cpp: { mime: "text/x-c++src", type: "text" },
+    c: { mime: "text/x-csrc", type: "text" },
+    h: { mime: "text/x-chdr", type: "text" },
+    yml: { mime: "text/yaml", type: "text" },
+    yaml: { mime: "text/yaml", type: "text" },
+    csv: { mime: "text/csv", type: "spreadsheet" },
+    png: { mime: "image/png", type: "image" },
+    jpg: { mime: "image/jpeg", type: "image" },
+    jpeg: { mime: "image/jpeg", type: "image" },
+    gif: { mime: "image/gif", type: "image" },
+    webp: { mime: "image/webp", type: "image" },
+    bmp: { mime: "image/bmp", type: "image" },
+    svg: { mime: "image/svg+xml", type: "text" },
+    heic: { mime: "image/heic", type: "image", conversionProfile: "to_jpeg_90" },
+    heif: { mime: "image/heif", type: "image", conversionProfile: "to_jpeg_90" },
+    mp3: { mime: "audio/mpeg", type: "audio" },
+    wav: { mime: "audio/wav", type: "audio" },
+    ogg: { mime: "audio/ogg", type: "audio" },
+    flac: { mime: "audio/flac", type: "audio" },
+    aac: { mime: "audio/aac", type: "audio" },
+    m4a: { mime: "audio/mp4", type: "audio" },
+    wma: { mime: "audio/x-ms-wma", type: "audio" },
+    mp4: { mime: "video/mp4", type: "video" },
+    webm: { mime: "video/webm", type: "video" },
+    avi: { mime: "video/x-msvideo", type: "video" },
+    mkv: { mime: "video/x-matroska", type: "video" },
+    mov: { mime: "video/quicktime", type: "video" },
+    wmv: { mime: "video/x-ms-wmv", type: "video" },
+    flv: { mime: "video/x-flv", type: "video" },
+    pdf: { mime: "application/pdf", type: "pdf" },
+    doc: { mime: "application/msword", type: "document" },
+    docx: { mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document", type: "document", tags: ["docx"] },
+    ppt: { mime: "application/vnd.ms-powerpoint", type: "document" },
+    pptx: { mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation", type: "document" },
+    xls: { mime: "application/vnd.ms-excel", type: "spreadsheet" },
+    xlsx: { mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", type: "spreadsheet" },
+    zip: { mime: "application/zip", type: "archive" },
+    rar: { mime: "application/vnd.rar", type: "archive" },
+    tar: { mime: "application/x-tar", type: "archive" },
+    gz: { mime: "application/gzip", type: "archive" },
+    "7z": { mime: "application/x-7z-compressed", type: "archive" }
+  },
+  aliases: {
+    "application/xml": "text",
+    "application/javascript": "text",
+    "application/x-javascript": "text",
+    "application/typescript": "text",
+    "application/x-typescript": "text",
+    "application/yaml": "text",
+    "application/x-yaml": "text",
+    "application/x-python": "text",
+    "application/x-java-source": "text",
+    "application/x-c++src": "text",
+    "application/x-csrc": "text",
+    "application/x-chdr": "text",
+    "application/octet-stream": "unknown",
+    "text/mcp": "mcp_text",
+    "image/mcp": "mcp_image",
+    "audio/mcp": "mcp_audio"
+  }
+};
 
+// ../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]));
+var EXT_TO_MIME = {};
+var MIME_TO_TYPE = {};
+var PREFIX_RULES = [];
+for (const [ext, entry] of Object.entries(mimetypes_default.extensions)) {
+  const { mime, type } = entry;
+  EXT_TO_MIME[ext] = mime;
+  MIME_TO_TYPE[mime] = type;
+}
+for (const [mime, type] of Object.entries(mimetypes_default.aliases)) {
+  MIME_TO_TYPE[mime] = type;
+}
+for (const [type, meta] of Object.entries(mimetypes_default.types)) {
+  const { prefixRule } = meta;
+  if (prefixRule)
+    PREFIX_RULES.push([prefixRule, type]);
+}
+var TAG_TO_MIMES = {};
+for (const [, entry] of Object.entries(mimetypes_default.extensions)) {
+  const { mime, tags } = entry;
+  if (tags) {
+    for (const tag of tags) {
+      (TAG_TO_MIMES[tag] ??= new Set).add(mime);
+    }
+  }
+}
+var NEEDS_OBJECT_URL = new Set(Object.entries(mimetypes_default.types).filter(([, meta]) => meta.needsObjectUrl).map(([type]) => type));
+var MIME_TO_EXT = {};
+for (const [ext, entry] of Object.entries(mimetypes_default.extensions)) {
+  const { mime } = entry;
+  if (!MIME_TO_EXT[mime])
+    MIME_TO_EXT[mime] = ext;
+}
+// ../packages/shared-fbe/src/blocks/index.ts
+var USER_INPUT_BLOCK_TYPES = new Set([
+  "question" /* Question */,
+  "login_prompt" /* Login */,
+  "business_onboarding" /* BusinessOnboarding */
+]);
+var EDGE_TOOL_TYPES = new Set([
+  "read" /* Read */,
+  "create" /* Create */,
+  "write" /* Write */,
+  "edit" /* Edit */,
+  "modify_file" /* ModifyFile */,
+  "bash" /* Bash */,
+  "search" /* Search */,
+  "grep" /* Grep */,
+  "list" /* List */
+]);
+var BROWSER_TOOL_TYPES = new Set([
+  "browser_interactable" /* BrowserInteractable */,
+  "browser_dom_tree" /* BrowserDomTree */,
+  "browser_navigate" /* BrowserNavigate */,
+  "browser_screenshot" /* BrowserScreenshot */,
+  "browser_click" /* BrowserClick */,
+  "browser_type" /* BrowserType */,
+  "browser_fill" /* BrowserFill */,
+  "browser_scroll" /* BrowserScroll */,
+  "browser_mouse_move" /* BrowserMouseMove */,
+  "browser_key" /* BrowserKey */,
+  "browser_evaluate" /* BrowserEvaluate */,
+  "browser_select" /* BrowserSelect */,
+  "browser_hover" /* BrowserHover */,
+  "browser_text_content" /* BrowserTextContent */,
+  "browser_back" /* BrowserBack */,
+  "browser_forward" /* BrowserForward */,
+  "browser_reload" /* BrowserReload */,
+  "browser_upload_file" /* BrowserUploadFile */,
+  "browser_find_text" /* BrowserFindText */,
+  "browser_find_role" /* BrowserFindRole */,
+  "browser_find_label" /* BrowserFindLabel */,
+  "browser_find_placeholder" /* BrowserFindPlaceholder */,
+  "browser_wait" /* BrowserWait */,
+  "browser_drag" /* BrowserDrag */,
+  "browser_dialog" /* BrowserDialog */,
+  "browser_network_wait" /* BrowserNetworkWait */,
+  "browser_check" /* BrowserCheck */,
+  "browser_uncheck" /* BrowserUncheck */,
+  "browser_focus" /* BrowserFocus */,
+  "browser_find_test_id" /* BrowserFindTestId */,
+  "browser_cookies" /* BrowserCookies */,
+  "browser_storage" /* BrowserStorage */,
+  "browser_pdf" /* BrowserPdf */,
+  "browser_clipboard_read" /* BrowserClipboardRead */,
+  "browser_clipboard_write" /* BrowserClipboardWrite */,
+  "browser_snapshot" /* BrowserSnapshot */,
+  "browser_iframe" /* BrowserIframe */,
+  "browser_console" /* BrowserConsole */,
+  "browser_scroll_into_view" /* BrowserScrollIntoView */,
+  "browser_network_requests" /* BrowserNetworkRequests */,
+  "browser_tap" /* BrowserTap */,
+  "browser_swipe" /* BrowserSwipe */
+]);
+var API_TOOL_TYPES = new Set([
+  "api_get_current_context" /* ApiGetCurrentContext */,
+  "api_get_todo" /* ApiGetTodo */,
+  "api_add_todo_message" /* ApiAddTodoMessage */,
+  "api_update_todo_status" /* ApiUpdateTodoStatus */,
+  "api_delete_todo" /* ApiDeleteTodo */,
+  "api_list_projects" /* ApiListProjects */,
+  "api_get_project" /* ApiGetProject */,
+  "api_create_project" /* ApiCreateProject */,
+  "api_list_project_todos" /* ApiListProjectTodos */,
+  "api_create_todo" /* ApiCreateTodo */,
+  "api_list_agents" /* ApiListAgents */,
+  "api_get_agent" /* ApiGetAgent */,
+  "api_update_agent" /* ApiUpdateAgent */,
+  "api_list_business_contexts" /* ApiListBusinessContexts */,
+  "api_get_business_context" /* ApiGetBusinessContext */,
+  "api_get_context_item" /* ApiGetContextItem */,
+  "api_create_context_item" /* ApiCreateContextItem */,
+  "api_update_context_item" /* ApiUpdateContextItem */,
+  "api_delete_context_item" /* ApiDeleteContextItem */,
+  "api_list_edges" /* ApiListEdges */,
+  "api_get_edge" /* ApiGetEdge */,
+  "api_list_mcps" /* ApiListMcps */,
+  "api_get_usage" /* ApiGetUsage */,
+  "api_get_balance" /* ApiGetBalance */,
+  "api_get_api_schema" /* ApiGetApiSchema */
+]);
+var FILE_TOOL_TYPES = new Set([
+  "read" /* Read */,
+  "create" /* Create */,
+  "write" /* Write */,
+  "edit" /* Edit */,
+  "modify_file" /* ModifyFile */
+]);
+// ../packages/shared-fbe/src/channels.ts
+var SERVER_TO_FRONTENDS = {
+  task: {
+    actionUpdate: (userId) => `${"task_action:update" /* TASK_ACTION_UPDATE */}:${userId}`
+  },
+  businessContext: {
+    updated: (userId) => `${"business_context:updated" /* BUSINESS_CONTEXT_UPDATED */}:${userId}`
+  },
+  resource: {
+    contentUpdated: (userId) => `${"resource:content_updated" /* RESOURCE_CONTENT_UPDATED */}:${userId}`
+  },
+  hexGrid: {
+    updated: (projectId) => `${"hexgrid:updated" /* HEXGRID_UPDATED */}:${projectId}`
+  },
+  sandbox: {
+    state: (userId) => `${"sandbox:state" /* SANDBOX_STATE */}:${userId}`
+  },
+  device: {
+    status: (userId) => `${"device:status" /* DEVICE_STATUS */}:${userId}`
+  },
+  agent: {
+    status: (userId) => `${"agent:status" /* AGENT_STATUS */}:${userId}`,
+    mcpList: () => `${"agent:mcp_list" /* AGENT_MCP_LIST */}:ALL`
+  },
+  edge: {
+    status: (userId) => `${"edge:status" /* EDGE_STATUS */}:${userId}`,
+    configUpdate: (userId) => `${"EDGE_CONFIG_UPDATE" /* EDGE_CONFIG_UPDATE */}:${userId}`,
+    cdResult: (edgeId) => `${"edge:cd_response" /* EDGE_CD_RESPONSE */}:${edgeId}`,
+    getFoldersResult: (edgeId) => `${"edge:get_folders_response" /* EDGE_GET_FOLDERS_RESPONSE */}:${edgeId}`,
+    createFolderResult: (edgeId) => `${"edge:create_folder_response" /* EDGE_CREATE_FOLDER_RESPONSE */}:${edgeId}`,
+    deletePathResult: (edgeId) => `${"edge:delete_path_response" /* EDGE_DELETE_PATH_RESPONSE */}:${edgeId}`,
+    writeFileResult: (edgeId) => `${"edge:write_file_response" /* EDGE_WRITE_FILE_RESPONSE */}:${edgeId}`
+  },
+  project: {
+    new_message: (projectId) => `${"task:new_update" /* TASK_NEW */}:${projectId}`,
+    new_todo: (projectId) => `${"todo:new" /* NEW_TODO */}:${projectId}`,
+    status: (projectId) => `${"project:status" /* PROJECT_STATUS */}:${projectId}`
+  },
+  todo: {
+    msgStart: (todoId) => `${"todo:msg_start" /* TODO_MSG_START */}:${todoId}`,
+    msgDone: (todoId) => `${"todo:msg_done" /* TODO_MSG_DONE */}:${todoId}`,
+    msgStopSequence: (todoId) => `${"todo:msg_stop_sequence" /* TODO_MSG_STOP_SEQUENCE */}:${todoId}`,
+    msgMetaUsr: (todoId) => `${"todo:msg_meta_usr" /* TODO_MSG_META_USR */}:${todoId}`,
+    msgMetaAi: (todoId) => `${"todo:msg_meta_ai" /* TODO_MSG_META_AI */}:${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}`,
+    new_message: (todoId) => `${"todo:new_message" /* TODO_NEW_MESSAGE */}:${todoId}`,
+    sh_msg_result: (todoId) => `${"block:sh_msg_result" /* BLOCK_SH_MSG_RESULT */}:${todoId}`,
+    sh_msg_start_result: (todoId) => `${"block:sh_msg_start" /* BLOCK_SH_MSG_START */}:${todoId}`,
+    sh_msg_done_result: (todoId) => `${"block:sh_done" /* BLOCK_SH_DONE */}:${todoId}`,
+    save_result: (todoId) => `${"block:save_result" /* BLOCK_SAVE_RESULT */}:${todoId}`,
+    diff_result: (todoId) => `${"block:diff_result" /* BLOCK_DIFF_RESULT */}:${todoId}`,
+    frontend_file_chunk_result: (todoId) => `${"frontend:file_chunk_result" /* FRONTEND_FILE_CHUNK_RESULT */}:${todoId}`,
+    status: (todoId) => `todo:${todoId}:status`,
+    block_update: (todoId) => `todo:${todoId}:block_update`,
+    error_result: (todoId) => `${"block:error_result" /* BLOCK_ERROR_RESULT */}:${todoId}`,
+    meta_result: (todoId) => `${"block:meta_result" /* BLOCK_META_RESULT */}:${todoId}`,
+    file_changed: (edgeId, path3) => `${"block:file_changed" /* BLOCK_FILE_CHANGED */}:${edgeId}:${path3}`,
+    notify: (todoId) => `${"NOTIFY" /* NOTIFY */}:${todoId}`
+  },
+  notify: {
+    user: (userId) => `${"NOTIFY" /* NOTIFY */}:user:${userId}`
+  },
+  payment: {
+    status: (userId) => `${"payment:status" /* PAYMENT_STATUS */}:${userId}`
+  },
+  functions: {}
+};
+// ../packages/shared-fbe/src/bashPatterns.ts
+function splitShellCommands(input) {
+  const parts = [];
+  let current = "";
+  let i = 0;
+  const len = input.length;
+  while (i < len) {
+    const ch = input[i];
+    if (ch === "\\" && i + 1 < len && input[i + 1] === `
+`) {
+      current += " ";
+      i += 2;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < len) {
+      current += ch + input[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === "<" && i + 1 < len && input[i + 1] === "<") {
+      i += 2;
+      if (i < len && input[i] === "-")
+        i++;
+      while (i < len && (input[i] === " " || input[i] === "\t"))
+        i++;
+      let delim = "";
+      if (i < len && (input[i] === "'" || input[i] === '"')) {
+        const q = input[i];
+        i++;
+        while (i < len && input[i] !== q) {
+          delim += input[i];
+          i++;
+        }
+        if (i < len)
+          i++;
+      } else {
+        while (i < len && /\w/.test(input[i])) {
+          delim += input[i];
+          i++;
+        }
+      }
+      if (delim) {
+        const rest = input.slice(i);
+        const m = rest.match(new RegExp(`^${delim}$`, "m"));
+        if (m && m.index !== undefined) {
+          i += m.index + delim.length;
+        } else {
+          i = len;
+        }
+      }
+      continue;
+    }
+    if (ch === "#" && (current.length === 0 || /\s$/.test(current))) {
+      while (i < len && input[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      current += ch;
+      i++;
+      while (i < len && input[i] !== quote) {
+        if (input[i] === "\\" && quote === '"' && i + 1 < len) {
+          current += input[i] + input[i + 1];
+          i += 2;
+        } else {
+          current += input[i];
+          i++;
+        }
+      }
+      if (i < len)
+        current += input[i];
+      i++;
+      continue;
+    }
+    if (ch === "|" && i + 1 < len && input[i + 1] === "|") {
+      parts.push(current);
+      current = "";
+      i += 2;
+    } else if (ch === "&" && i + 1 < len && input[i + 1] === "&") {
+      parts.push(current);
+      current = "";
+      i += 2;
+    } else if (ch === "|") {
+      parts.push(current);
+      current = "";
+      i++;
+    } else if (ch === ";" || ch === `
+`) {
+      parts.push(current);
+      current = "";
+      i++;
+    } else {
+      current += ch;
+      i++;
+    }
+  }
+  parts.push(current);
+  return parts.map((s) => s.trim()).filter(Boolean);
+}
+function generalizeToken(token) {
+  if (/^\d+$/.test(token))
+    return "*";
+  if (/^[0-9a-f]{4,}$/i.test(token) && /\d/.test(token))
+    return "*";
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(token))
+    return "*";
+  if (/^https?:\/\//i.test(token)) {
+    try {
+      const u = new URL(token);
+      return `${u.protocol}//${u.host}/*`;
+    } catch {
+      return token;
+    }
+  }
+  return token;
+}
+var SAFE_FLAGS = new Set(["--help", "-h", "--version", "-V", "-v"]);
+function splitTokens(cmd) {
+  const tokens = [];
+  let current = "";
+  let i = 0;
+  const len = cmd.length;
+  while (i < len) {
+    const ch = cmd[i];
+    if (ch === "\\" && i + 1 < len && cmd[i + 1] === `
+`) {
+      i += 2;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < len) {
+      current += ch + cmd[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const q = ch;
+      current += ch;
+      i++;
+      while (i < len && cmd[i] !== q) {
+        if (cmd[i] === "\\" && q === '"' && i + 1 < len) {
+          current += cmd[i] + cmd[i + 1];
+          i += 2;
+        } else {
+          current += cmd[i];
+          i++;
+        }
+      }
+      if (i < len) {
+        current += cmd[i];
+        i++;
+      }
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      i++;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+  if (current)
+    tokens.push(current);
+  return tokens;
+}
+function parseSingle(cmd) {
+  const tokens = splitTokens(cmd);
+  while (tokens.length && /^[A-Za-z_]\w*=/.test(tokens[0])) {
+    const val = tokens[0].slice(tokens[0].indexOf("=") + 1);
+    if (/\$\(|`/.test(val))
+      return { tokens: [], defaultKeep: 0 };
+    tokens.shift();
+  }
+  if (tokens.length === 0)
+    return { tokens: [], defaultKeep: 0 };
+  if (tokens[0].startsWith("#"))
+    return { tokens: [], defaultKeep: 0 };
+  const positionals = [tokens[0]];
+  let hitFlag = false;
+  let defaultKeep = -1;
+  for (let t = 1;t < tokens.length; t++) {
+    if (!hitFlag && SAFE_FLAGS.has(tokens[t])) {
+      positionals.push(tokens[t]);
+      return { tokens: positionals, defaultKeep: positionals.length };
+    }
+    if (tokens[t].startsWith("-")) {
+      if (!hitFlag) {
+        hitFlag = true;
+        defaultKeep = Math.min(3, positionals.length);
+      }
+      positionals.push(tokens[t]);
+      continue;
+    }
+    const g = generalizeToken(tokens[t]);
+    positionals.push(g);
+    if (g !== tokens[t])
+      break;
+  }
+  if (defaultKeep < 0)
+    defaultKeep = Math.min(3, positionals.length);
+  return { tokens: positionals, defaultKeep };
+}
+function buildBashPattern(parsed, keep) {
+  if (parsed.tokens.length === 0)
+    return "BASH(cmd: *)";
+  const k = Math.max(1, Math.min(keep ?? parsed.defaultKeep, parsed.tokens.length));
+  const kept = parsed.tokens.slice(0, k);
+  const suffix = kept[kept.length - 1] === "*" ? "" : " *";
+  return `BASH(cmd: ${kept.join(" ")}${suffix})`;
+}
+function parseBashCmd(fullCmd) {
+  return splitShellCommands(fullCmd).map(parseSingle).filter((p) => p.tokens.length > 0);
+}
+function generalizeBashCmd(fullCmd) {
+  return parseBashCmd(fullCmd).map((p) => buildBashPattern(p));
+}
+function getBlockServerPrefix(block) {
+  const agentPattern = typeof block.generalized_pattern === "string" ? block.generalized_pattern : "";
+  const prefixMatch = agentPattern.match(/^(.*?:)BASH(?:\(|$)/);
+  return prefixMatch ? prefixMatch[1] : "";
+}
+var BASH_LIKE_BLOCK_TYPES = new Set(["bash", "machine_exec"]);
+function getBlockPatterns(block) {
+  if (Array.isArray(block.generalized_pattern))
+    return block.generalized_pattern;
+  const agentPattern = typeof block.generalized_pattern === "string" ? block.generalized_pattern : "";
+  const isBashLike = BASH_LIKE_BLOCK_TYPES.has(block.type.toLowerCase()) || /:BASH(\(|$)/.test(agentPattern);
+  if (isBashLike && block.cmd) {
+    const prefix = getBlockServerPrefix(block);
+    return generalizeBashCmd(block.cmd).map((p) => prefix + p);
+  }
+  if (block.generalized_pattern)
+    return [block.generalized_pattern];
+  return [`${block.type}(*)`];
+}
+function getBlockServerId(block) {
+  const prefix = getBlockServerPrefix(block);
+  return prefix ? prefix.slice(0, -1) : "*";
+}
+
+// ../packages/shared-fbe/src/permissionUtils.ts
+function parsePattern(pattern) {
+  const colonIndex = pattern.indexOf(":");
+  if (colonIndex === -1)
+    return null;
+  const serverId = pattern.slice(0, colonIndex);
+  if (!/^[A-Za-z0-9_*-]+$/.test(serverId)) {
+    return { serverId: "*", toolName: pattern };
+  }
+  return { serverId, toolName: pattern.slice(colonIndex + 1) };
+}
+function serverIdMatches(ruleServerId, targetServerId) {
+  if (ruleServerId === targetServerId)
+    return true;
+  if (ruleServerId === "*")
+    return true;
+  if (ruleServerId.includes("*")) {
+    const escaped = ruleServerId.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp("^" + escaped.replace(/\*/g, "[^:]*") + "$");
+    return regex.test(targetServerId);
+  }
+  if (targetServerId.startsWith(ruleServerId + "_"))
+    return true;
+  return false;
+}
+function patternMatches(rulePattern, targetPattern) {
+  const rule = parsePattern(rulePattern);
+  const target = parsePattern(targetPattern);
+  if (!rule || !target)
+    return rulePattern === targetPattern;
+  if (!serverIdMatches(rule.serverId, target.serverId))
+    return false;
+  if (rule.toolName === target.toolName)
+    return true;
+  if (rule.toolName === "*")
+    return true;
+  if (rule.toolName.endsWith(" *)")) {
+    const rulePrefix = rule.toolName.slice(0, -2);
+    return target.toolName.startsWith(rulePrefix);
+  }
+  return false;
+}
+function bashRuleMatchesCmd(rulePattern, serverId, cmd) {
+  const rule = parsePattern(rulePattern);
+  if (!rule)
+    return false;
+  if (!serverIdMatches(rule.serverId, serverId))
+    return false;
+  if (rule.toolName === "*" || rule.toolName === "BASH")
+    return true;
+  const m = rule.toolName.match(/^BASH\(cmd:\s*(.*)\)$/);
+  if (!m)
+    return false;
+  let body = m[1];
+  const isPrefix = body.endsWith(" *") || body.endsWith("*");
+  if (isPrefix)
+    body = body.replace(/\s*\*$/, "");
+  const subs = splitShellCommands(cmd);
+  if (subs.length === 0)
+    return false;
+  return subs.every((sub) => isPrefix ? sub === body || sub.startsWith(body + " ") : sub === body);
+}
+function isPatternInList(list, pattern) {
+  if (!list)
+    return false;
+  return list.some((p) => patternMatches(p, pattern));
+}
+function isPatternAllowed(permissions, pattern) {
+  return isPatternInList(permissions?.allow, pattern);
+}
+function getNewPatterns(patterns, permissions) {
+  return patterns.filter((p) => !isPatternAllowed(permissions, p));
+}
+function getBlockNewPatterns(block, permissions) {
+  const allow = permissions?.allow ?? [];
+  if (Array.isArray(block.generalized_pattern)) {
+    return getNewPatterns(block.generalized_pattern, permissions);
+  }
+  const agentPattern = typeof block.generalized_pattern === "string" ? block.generalized_pattern : "";
+  const isBash = (block.type.toLowerCase() === "bash" || agentPattern.includes(":BASH(")) && !!block.cmd;
+  if (!isBash) {
+    return getBlockPatterns(block).filter((p) => !isPatternAllowed(permissions, p));
+  }
+  const serverId = getBlockServerId(block);
+  const prefix = serverId === "*" ? "" : `${serverId}:`;
+  const rawSubs = splitShellCommands(block.cmd);
+  const pairs = [];
+  for (const raw of rawSubs) {
+    const parsed = parseBashCmd(raw);
+    if (parsed.length === 0)
+      continue;
+    pairs.push({ raw, pattern: prefix + buildBashPattern(parsed[0]) });
+  }
+  return pairs.filter(({ raw, pattern }) => !isPatternAllowed(permissions, pattern) && !allow.some((rule) => bashRuleMatchesCmd(rule, serverId, raw))).map(({ pattern }) => pattern);
+}
+// ../packages/shared-fbe/src/realtime/topics.ts
+var TOPICS = {
+  ["todo:new" /* NEW_TODO */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.project.new_todo(p.projectId),
+    audience: "frontend"
+  },
+  ["todo:new_message" /* TODO_NEW_MESSAGE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.project.new_message(p.projectId),
+    audience: "frontend"
+  },
+  ["todo:new_message_created" /* TODO_NEW_MESSAGE_CREATED */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.new_message(p.todoId),
+    audience: "frontend"
+  },
+  ["business_context:updated" /* BUSINESS_CONTEXT_UPDATED */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.businessContext.updated(p.userId),
+    audience: "frontend"
+  },
+  ["resource:content_updated" /* RESOURCE_CONTENT_UPDATED */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.resource.contentUpdated(p.userId),
+    audience: "frontend"
+  },
+  ["hexgrid:updated" /* HEXGRID_UPDATED */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.hexGrid.updated(p.projectId),
+    audience: "frontend"
+  },
+  ["sandbox:state" /* SANDBOX_STATE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.sandbox.state(p.userId),
+    audience: "frontend"
+  },
+  ["device:status" /* DEVICE_STATUS */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.device.status(p.userId),
+    audience: "frontend"
+  },
+  ["NOTIFY" /* NOTIFY */]: {
+    channel: (p) => p.userId ? SERVER_TO_FRONTENDS.notify.user(p.userId) : SERVER_TO_FRONTENDS.todo.notify(p.todoId),
+    audience: "frontend"
+  },
+  ["todo:msg_done" /* TODO_MSG_DONE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.msgDone(p.todoId),
+    audience: "frontend"
+  },
+  ["block:start_universal" /* BLOCK_START_UNIVERSAL */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.start_universal(p.todoId),
+    audience: "frontend"
+  },
+  ["block:message" /* BLOCK_MESSAGE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.message(p.todoId),
+    audience: "frontend"
+  },
+  ["BLOCK_UPDATE" /* BLOCK_UPDATE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.block_update(p.todoId),
+    audience: "frontend"
+  },
+  ["block:end" /* BLOCK_END */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.end(p.todoId),
+    audience: "frontend"
+  },
+  ["todo:msg_start" /* TODO_MSG_START */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.msgStart(p.todoId),
+    audience: "frontend"
+  },
+  ["todo:msg_meta_ai" /* TODO_MSG_META_AI */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.msgMetaAi(p.todoId),
+    audience: "frontend"
+  },
+  ["todo:msg_meta_usr" /* TODO_MSG_META_USR */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.msgMetaUsr(p.todoId),
+    audience: "frontend"
+  },
+  ["todo:msg_stop_sequence" /* TODO_MSG_STOP_SEQUENCE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.msgStopSequence(p.todoId),
+    audience: "frontend"
+  },
+  ["block:diff_result" /* BLOCK_DIFF_RESULT */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.diff_result(p.todoId),
+    audience: "frontend"
+  },
+  ["frontend:file_chunk_result" /* FRONTEND_FILE_CHUNK_RESULT */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.frontend_file_chunk_result(p.todoId),
+    audience: "frontend"
+  },
+  ["block:save_result" /* BLOCK_SAVE_RESULT */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.save_result(p.todoId),
+    audience: "frontend"
+  },
+  ["block:sh_msg_start" /* BLOCK_SH_MSG_START */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.sh_msg_start_result(p.todoId),
+    audience: "frontend"
+  },
+  ["block:sh_msg_result" /* BLOCK_SH_MSG_RESULT */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.sh_msg_result(p.todoId),
+    audience: "frontend"
+  },
+  ["block:sh_done" /* BLOCK_SH_DONE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.sh_msg_done_result(p.todoId),
+    audience: "frontend"
+  },
+  ["edge:status" /* EDGE_STATUS */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.edge.status(p.userId),
+    audience: "frontend"
+  },
+  ["EDGE_CONFIG_UPDATE" /* EDGE_CONFIG_UPDATE */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.edge.configUpdate(p.ownerId),
+    audience: "frontend"
+  },
+  ["project:status" /* PROJECT_STATUS */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.project.status(p.projectId),
+    audience: "frontend"
+  },
+  ["todo:status" /* TODO_STATUS */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.todo.status(p.todoId),
+    audience: "frontend"
+  },
+  ["payment:status" /* PAYMENT_STATUS */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.payment.status(p.userId),
+    audience: "frontend"
+  },
+  ["payment:webhook" /* PAYMENT_WEBHOOK */]: {
+    channel: (p) => SERVER_TO_FRONTENDS.payment.status(p.userId),
+    audience: "frontend"
+  }
+};
 // src/args.ts
 var DEFAULT_API_URL = "https://api.todofor.ai";
 var VERSION = package_default.version;
@@ -43151,12 +43930,16 @@ Usage:
   todoai -n "Quick task"               # Non-interactive (run and exit)
   echo "content" | todoai              # Pipe from stdin
   todoai --path /my/project "Fix bug"  # Explicit workspace path
-  todoai -c                            # Resume last todo
-  todoai --resume <todo-id>            # Resume specific todo
-  todoai --inspect <todo-id>[:<msg-id>]  # Print full chat log (read-only); :<msg-id> truncates inclusive
-  todoai --inspect :<msg-id>             # Same, using $TODOFORAI_TODO_ID from edge env
+  todoai -c ["prompt"]                 # Resume last todo (optional prompt sent on attach)
+  todoai --resume <todo-id> ["prompt"] # Resume specific todo (optional prompt sent on attach)
+  todoai --inspect <todo-id>[@<slice>] # Read chat log. <slice> = -3:, :1, 5:10, 7  (Python-style)
   todoai --template <id> [--input k=v] # Start from a registry template
   todoai --list-agents                 # List available agents and exit
+  todoai agent update <agent> model=<model>    # Update agent settings (see 'agent --help')
+  todoai list [-n 30] [--all] [--status S]   # List todos (open + recent first); see 'list --help'
+  todoai status <todo-id> <STATUS>     # Update a todo's status (run 'status --help' for the full list)
+  todoai delete <todo-id>              # Permanently delete a todo
+  todoai addmessage <todo-id> "text"  # Add a message to an existing todo
 
 Options:
   --path <dir>                    Workspace path (default: cwd)
@@ -43165,7 +43948,7 @@ Options:
   --list-agents                   List available agents (name, id, workspace paths) and exit
   --api-url <url>                 API URL
   --api-key <key>                 API key
-  --inspect, -i [<todo-id>][:<msg-id>]  Print full chat log; empty todo-id uses $TODOFORAI_TODO_ID
+  --inspect, -i <todo-id>[@<slice>]     Print chat log (read-only)
   --template, -t <id>            Start from a registry template
   --input <key=value>            Template input (repeatable)
   --resume, -r [todo-id]          Resume existing todo
@@ -43176,6 +43959,8 @@ Options:
   --no-watch                      Create todo and exit
   --no-edge                       Do not auto-spawn edge daemon
   --json                          Output as JSON
+  --detailed                      'inspect --json': keep ids, timestamps, agentSettingsId, scheduledTimestamp
+  --format-anthropic              'inspect --json': Anthropic-style shape (tool_result in next user msg); attachment sources are uri-typed, so not a 1:1 messages.create input
   --safe                          Validate API key upfront
   --debug, -d                     Debug output
   --show-config                   Show config
@@ -43184,6 +43969,27 @@ Options:
   --help, -h                      Show this help
 `);
 }
+var STATUS_HELP = {
+  ["READY" /* READY */]: "AI finished the work on the TODO",
+  ["READY_CHECKED" /* READY_CHECKED */]: "AI finished and the user reviewed it",
+  ["DONE" /* DONE */]: "Completed and finalized",
+  ["REVIEW_REQUESTED" /* REVIEW_REQUESTED */]: "Asks the user to review",
+  ["POSTPONED" /* POSTPONED */]: "Put off for later",
+  ["ARCHIVED" /* ARCHIVED */]: "Archived (hidden from active list)",
+  ["DELETED" /* DELETED */]: "Marked for deletion"
+};
+function printStatusHelp() {
+  process.stderr.write(`
+todoai status <todo-id> <STATUS>
+
+Common statuses:
+${Object.entries(STATUS_HELP).map(([s, d]) => `  ${s.padEnd(18)}${d}`).join(`
+`)}
+
+All valid statuses:
+  ${Object.values(TodoStatus).join(", ")}
+`);
+}
 function parseCliArgs() {
   const { values, positionals } = parseArgs({
     args: process.argv.slice(2),
@@ -43191,6 +43997,7 @@ function parseCliArgs() {
       path: { type: "string", default: "." },
       project: { type: "string" },
       agent: { type: "string", short: "a" },
+      model: { type: "string" },
       "list-agents": { type: "boolean", default: false },
       "api-url": { type: "string" },
       "api-key": { type: "string" },
@@ -43205,6 +44012,8 @@ function parseCliArgs() {
       "no-watch": { type: "boolean", default: false },
       "no-edge": { type: "boolean", default: false },
       json: { type: "boolean", default: false },
+      detailed: { type: "boolean", default: false },
+      "format-anthropic": { type: "boolean", default: false },
       safe: { type: "boolean", default: false },
       debug: { type: "boolean", short: "d", default: false },
       "show-config": { type: "boolean", default: false },
@@ -43223,21 +44032,23 @@ function parseCliArgs() {
 import { createInterface } from "readline";
 
 // src/colors.ts
-var YELLOW = "\x1B[33m";
-var GREEN = "\x1B[32m";
-var RED = "\x1B[31m";
-var DIM = "\x1B[90m";
-var CYAN = "\x1B[36m";
-var BOLD = "\x1B[1m";
-var WHITE = "\x1B[38;2;255;255;255m";
-var BRIGHT_WHITE = "\x1B[97m";
-var BRAND = "\x1B[38;2;249;110;46m";
-var RESET = "\x1B[0m";
-var DIM_ATTR = "\x1B[2m";
-var BG_RED = "\x1B[48;2;55;20;20m";
-var BG_GREEN = "\x1B[48;2;20;45;20m";
-var BG_RED_HL = "\x1B[48;2;100;35;35m";
-var BG_GREEN_HL = "\x1B[48;2;35;85;35m";
+var on = !process.env.NO_COLOR && !!process.stdout.isTTY;
+var c = (seq) => on ? seq : "";
+var YELLOW = c("\x1B[33m");
+var GREEN = c("\x1B[32m");
+var RED = c("\x1B[31m");
+var DIM = c("\x1B[90m");
+var CYAN = c("\x1B[36m");
+var BOLD = c("\x1B[1m");
+var WHITE = c("\x1B[38;2;255;255;255m");
+var BRIGHT_WHITE = c("\x1B[97m");
+var BRAND = c("\x1B[38;2;249;110;46m");
+var RESET = c("\x1B[0m");
+var DIM_ATTR = c("\x1B[2m");
+var BG_RED = c("\x1B[48;2;55;20;20m");
+var BG_GREEN = c("\x1B[48;2;20;45;20m");
+var BG_RED_HL = c("\x1B[48;2;100;35;35m");
+var BG_GREEN_HL = c("\x1B[48;2;35;85;35m");
 
 // src/input.ts
 function readLine(prompt) {
@@ -43475,26 +44286,26 @@ function readMultiline(prompt, history) {
           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 c = chunk.charCodeAt(i);
-            if (c === 3) {
+            const c2 = chunk.charCodeAt(i);
+            if (c2 === 3) {
               finish(true);
               return;
             }
-            if (c === 13 || c === 10) {
+            if (c2 === 13 || c2 === 10) {
               finish(false);
               return;
             }
-            if (c === 23) {
+            if (c2 === 23) {
               deleteWordBack();
-            } else if (c === 11) {
+            } else if (c2 === 11) {
               killToEnd();
-            } else if (c === 127 || c === 8) {
+            } else if (c2 === 127 || c2 === 8) {
               if (cursor > 0) {
                 buf = buf.slice(0, cursor - 1) + buf.slice(cursor);
                 cursor--;
                 redraw();
               }
-            } else if (c === 27) {
+            } else if (c2 === 27) {
               if (i + 1 < chunk.length && chunk.charCodeAt(i + 1) === 13) {
                 buf = buf.slice(0, cursor) + `
 ` + buf.slice(cursor);
@@ -43504,13 +44315,13 @@ function readMultiline(prompt, history) {
               } else {
                 i = handleCSI(chunk, i) - 1;
               }
-            } else if (c === 1) {
+            } else if (c2 === 1) {
               cursor = 0;
               redraw();
-            } else if (c === 5) {
+            } else if (c2 === 5) {
               cursor = buf.length;
               redraw();
-            } else if (c >= 32) {
+            } else if (c2 >= 32) {
               buf = buf.slice(0, cursor) + chunk[i] + buf.slice(cursor);
               cursor++;
               redraw();
@@ -43846,7 +44657,232 @@ function printLogo() {
 }
 
 // src/inspect.ts
-function printFullChat(todo, frontendUrl, untilMessageId) {
+var xmlAttr = (v) => JSON.stringify(String(v));
+var DROP_IF_EMPTY = new Set(["runMeta", "meta", "attachments", "blocks"]);
+var ALWAYS_DROP = new Set(["messageIds", "data"]);
+var DETAILED_ONLY = new Set([
+  "id",
+  "createdAt",
+  "lastActivityAt",
+  "modifiedAt",
+  "agentSettingsId",
+  "scheduledTimestamp",
+  "workflowVersion",
+  "todoId",
+  "blockId",
+  "parentBlockId",
+  "stop_sequence",
+  "permissions",
+  "isPublic",
+  "metadata"
+]);
+var DEBUG_ONLY = new Set([
+  "runMeta",
+  "generationCompleted",
+  "userId",
+  "deviceId",
+  "runMode"
+]);
+var isEmpty = (x) => Array.isArray(x) && x.length === 0 || x && typeof x === "object" && !Array.isArray(x) && Object.keys(x).length === 0;
+function pruneEmpty(v, mode = "default") {
+  if (Array.isArray(v))
+    return v.map((x) => pruneEmpty(x, mode));
+  if (v && typeof v === "object") {
+    const o = {};
+    for (const [k, raw] of Object.entries(v)) {
+      if (ALWAYS_DROP.has(k))
+        continue;
+      if (DEBUG_ONLY.has(k) && mode !== "debug")
+        continue;
+      if (DETAILED_ONLY.has(k) && mode === "default")
+        continue;
+      if (raw === "")
+        continue;
+      if (k === "scheduledTimestamp" && (raw === 0 || raw === 1))
+        continue;
+      if (DROP_IF_EMPTY.has(k) && isEmpty(raw))
+        continue;
+      o[k] = pruneEmpty(raw, mode);
+    }
+    return o;
+  }
+  return v;
+}
+var BLOCK_META_KEYS = new Set([
+  "type",
+  "id",
+  "parentBlockId",
+  "toolCallId",
+  "status",
+  "results",
+  "content",
+  "modifiedContent",
+  "originalContent",
+  "error_message",
+  "stacktrace",
+  "runMeta",
+  "runMode",
+  "generationCompleted",
+  "userId",
+  "deviceId"
+]);
+function blockToAnthropic(block, mode, format) {
+  const t = block.type;
+  if (t === "text")
+    return [{ type: "text", text: block.content ?? "" }];
+  if (t === "reason")
+    return [{ type: "thinking", thinking: block.content ?? "" }];
+  if (t === "error") {
+    const msg = block.error_message || block.content || "(unknown error)";
+    return [{ type: "text", text: `[error] ${msg}` }];
+  }
+  const inputFields = [];
+  for (const [k, v] of Object.entries(block)) {
+    if (BLOCK_META_KEYS.has(k))
+      continue;
+    if (v === undefined || v === null || v === "")
+      continue;
+    inputFields.push([k, v]);
+  }
+  const use = format === "anthropic" ? { type: "tool_use", id: block.id, name: t, input: Object.fromEntries(inputFields) } : { type: "tool_use", content: `<${t}${inputFields.map(([k, v]) => ` ${k}=${xmlAttr(v)}`).join("")}/>` };
+  if (format === "compact" && mode !== "default")
+    use.id = block.id;
+  const items = [use];
+  if (block.results?.length) {
+    if (format === "anthropic") {
+      const content = block.results.flatMap((r) => {
+        const parts = [];
+        for (const att of r.attachments ?? []) {
+          const isImage = (att.mimeType || "").startsWith("image/");
+          const isAutoName = /^(bash|read|list|explore|edit|write|grep):/.test(att.originalName ?? "");
+          const source = { type: "uri", uri: att.uri, mimeType: att.mimeType, size: att.fileSize };
+          if (att.originalName && !isAutoName)
+            source.name = att.originalName;
+          parts.push({ type: isImage ? "image" : "document", source });
+        }
+        if (typeof r.content === "string" && r.content)
+          parts.push({ type: "text", text: r.content });
+        return parts;
+      });
+      const result = { type: "tool_result", tool_use_id: block.id };
+      if (content.length)
+        result.content = content;
+      if (block.status && block.status !== "COMPLETED")
+        result.is_error = true;
+      items.push(result);
+    } else {
+      const parts = [];
+      for (const r of block.results) {
+        for (const att of r.attachments ?? []) {
+          const isAutoName = /^(bash|read|list|explore|edit|write|grep):/.test(att.originalName ?? "");
+          const nameAttr = att.originalName && !isAutoName ? ` name=${xmlAttr(att.originalName)}` : "";
+          parts.push(`<attachment uri=${xmlAttr(att.uri)}${nameAttr} size=${att.fileSize}/>`);
+        }
+        if (typeof r.content === "string" && r.content)
+          parts.push(r.content);
+      }
+      const result = { type: "tool_result", content: parts.join(`
+`) };
+      if (mode !== "default")
+        result.tool_use_id = block.id;
+      if (block.status && block.status !== "COMPLETED")
+        result.status = block.status;
+      items.push(result);
+    }
+  }
+  return items;
+}
+function toAnthropicShape(messages, mode = "default", format = "compact") {
+  const out = [];
+  let prevToolAttachmentIds = new Set;
+  for (const m of messages) {
+    const msg = { role: m.role };
+    if (mode !== "default") {
+      if (m.id)
+        msg.id = m.id;
+      if (m.createdAt)
+        msg.createdAt = m.createdAt;
+    }
+    if (m.role === "user") {
+      const atts = (m.attachments ?? []).filter((a) => !prevToolAttachmentIds.has(a.id)).map((a) => {
+        const isImage = (a.mimeType || "").startsWith("image/");
+        return {
+          type: isImage ? "image" : "document",
+          source: { type: "uri", uri: a.uri, name: a.originalName, mimeType: a.mimeType, size: a.fileSize }
+        };
+      });
+      const hadAttachments = (m.attachments ?? []).length > 0;
+      if (!m.content && hadAttachments && atts.length === 0 && mode === "default") {
+        prevToolAttachmentIds = new Set;
+        continue;
+      }
+      if (atts.length === 0) {
+        msg.content = m.content ?? "";
+      } else {
+        msg.content = [
+          ...m.content ? [{ type: "text", text: m.content }] : [],
+          ...atts
+        ];
+      }
+      out.push(pruneEmpty(msg, mode));
+      prevToolAttachmentIds = new Set;
+      continue;
+    }
+    const content = [];
+    if (m.content)
+      content.push({ type: "text", text: m.content });
+    for (const b of m.blocks ?? []) {
+      for (const r of b.results ?? []) {
+        for (const a of r.attachments ?? [])
+          if (a.id)
+            prevToolAttachmentIds.add(a.id);
+      }
+    }
+    for (const b of m.blocks ?? [])
+      content.push(...blockToAnthropic(b, mode, format));
+    if (format === "anthropic") {
+      const useItems = content.filter((c2) => c2.type !== "tool_result");
+      const resultItems = content.filter((c2) => c2.type === "tool_result");
+      msg.content = useItems;
+      if (mode === "debug" && m.runMeta?.length)
+        msg.runMeta = m.runMeta;
+      out.push(pruneEmpty(msg, mode));
+      if (resultItems.length) {
+        out.push(pruneEmpty({ role: "user", content: resultItems }, mode));
+      }
+    } else {
+      msg.content = content;
+      if (mode === "debug" && m.runMeta?.length)
+        msg.runMeta = m.runMeta;
+      out.push(pruneEmpty(msg, mode));
+    }
+  }
+  return out;
+}
+function applySlice(arr, spec) {
+  if (!spec.includes(":")) {
+    const i = Number(spec);
+    if (!Number.isInteger(i))
+      throw new Error(`Bad slice: '${spec}'`);
+    const r = arr.at(i);
+    return r === undefined ? [] : [r];
+  }
+  const parts = spec.split(":");
+  if (parts.length !== 2)
+    throw new Error(`Bad slice: '${spec}' (use N, N:, :N, or N:M)`);
+  const [a, b] = parts;
+  const start = a === "" ? 0 : Number(a);
+  const end = b === "" ? arr.length : Number(b);
+  if (!Number.isInteger(start) || !Number.isInteger(end))
+    throw new Error(`Bad slice: '${spec}'`);
+  return arr.slice(start, end);
+}
+var trunc = (s, n) => s.length > n ? s.slice(0, n) + `
+${DIM}... (${s.length} chars)${RESET}` : s;
+var indent = (s, pre) => s.split(`
+`).join(`
+${pre}`);
+function printFullChat(todo, frontendUrl, slice, mode = "default", format = "compact") {
   const statusColors = {
     DONE: GREEN,
     READY: GREEN,
@@ -43871,69 +44907,83 @@ function printFullChat(todo, frontendUrl, untilMessageId) {
   if (todo.agentSettingsId)
     process.stderr.write(`${DIM}Agent:${RESET}  ${todo.agentSettingsId}
 `);
-  if (untilMessageId)
-    process.stderr.write(`${DIM}Until:${RESET}  ${untilMessageId}
+  if (slice)
+    process.stderr.write(`${DIM}Slice:${RESET}  [${slice}]
 `);
   process.stderr.write("\u2500".repeat(60) + `
 `);
   let messages = todo.messages || [];
-  if (untilMessageId) {
-    const idx = messages.findIndex((m) => m.id === untilMessageId);
-    if (idx < 0) {
-      process.stderr.write(`${RED}Error: message ${untilMessageId} not found in todo${RESET}
+  if (slice) {
+    try {
+      messages = applySlice(messages, slice);
+    } catch (e) {
+      process.stderr.write(`${RED}${e.message}${RESET}
 `);
       process.exit(2);
     }
-    messages = messages.slice(0, idx + 1);
   }
   if (!messages.length) {
     process.stderr.write(`${DIM}(no messages)${RESET}
 `);
     return;
   }
-  for (const msg of messages) {
-    const roleLabel = msg.role === "user" ? `${CYAN}\u25B6 USER${RESET}` : `${GREEN}\u25C0 ASSISTANT${RESET}`;
+  const shaped = toAnthropicShape(messages, mode, format);
+  let toolUseCount = 0, errorCount = 0;
+  for (let i = 0;i < shaped.length; i++) {
+    const msg = shaped[i];
+    const orig = messages[i];
+    const ts = mode !== "default" && orig?.createdAt ? ` ${DIM}${new Date(orig.createdAt).toLocaleTimeString()}${RESET}` : "";
+    const label = msg.role === "user" ? `${CYAN}\u25B6 USER${RESET}` : `${GREEN}\u25C0 ASSISTANT${RESET}`;
     process.stderr.write(`
-${roleLabel} ${DIM}${new Date(msg.createdAt).toLocaleTimeString()}${RESET}
+${label}${ts}
 `);
-    if (msg.content) {
-      const content = msg.content.length > 2000 ? msg.content.slice(0, 2000) + `
-${DIM}... (${msg.content.length} chars total)${RESET}` : msg.content;
-      process.stdout.write(content + `
+    const items = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
+    for (const it of items) {
+      if (it.type === "text") {
+        if (it.text)
+          process.stdout.write(trunc(it.text, 2000) + `
 `);
-    }
-    for (const block of msg.blocks || []) {
-      const blockStatusColor = block.status === "COMPLETED" ? GREEN : block.status === "ERROR" || block.status === "DENIED" ? RED : YELLOW;
-      process.stderr.write(`
-  ${YELLOW}[${block.type}]${RESET} ${blockStatusColor}${block.status}${RESET}`);
-      for (const key of ["path", "cmd", "name", "server_name", "tool_name"]) {
-        if (block[key])
-          process.stderr.write(` ${DIM}${key}=${RESET}${block[key]}`);
-      }
-      process.stderr.write(`
+      } else if (it.type === "image" || it.type === "document") {
+        const s = it.source ?? {};
+        process.stderr.write(`  ${YELLOW}[${it.type}]${RESET} ${DIM}${s.mimeType ?? ""}${RESET} ${s.name ?? ""} ${DIM}(${s.size ?? "?"} bytes)${RESET}
+  ${DIM}${s.uri ?? ""}${RESET}
 `);
-      if (block.content) {
-        const content = block.content.length > 500 ? block.content.slice(0, 500) + `
-${DIM}... (${block.content.length} chars)${RESET}` : block.content;
-        process.stdout.write(`  ${DIM}\u2502${RESET} ${content.split(`
-`).join(`
-  ${DIM}\u2502${RESET} `)}
+      } else if (it.type === "thinking") {
+        if (it.thinking)
+          process.stderr.write(`${DIM}[thinking]${RESET} ${trunc(it.thinking, 500)}
 `);
-      }
-      if (block.result) {
-        const result = block.result.length > 500 ? block.result.slice(0, 500) + `
-${DIM}... (${block.result.length} chars)${RESET}` : block.result;
-        process.stderr.write(`  ${DIM}\u2514\u2500 result:${RESET} ${result.split(`
-`).join(`
-  ${DIM}\u2502${RESET}  `)}
+      } else if (it.type === "tool_use") {
+        toolUseCount++;
+        if (it.content) {
+          process.stderr.write(`  ${YELLOW}${trunc(it.content, 200)}${RESET}
 `);
-      }
-      if (block.error_message) {
-        process.stderr.write(`  ${RED}\u2514\u2500 error: ${block.error_message}${RESET}
+        } else {
+          const argStr = Object.entries(it.input || {}).map(([k, v]) => `${DIM}${k}=${RESET}${String(v).split(`
+`)[0].slice(0, 80)}`).join(" ");
+          process.stderr.write(`  ${YELLOW}[${it.name}]${RESET} ${argStr}
 `);
-      }
-      if (block.stacktrace) {
-        process.stderr.write(`  ${DIM}${block.stacktrace.slice(0, 300)}${block.stacktrace.length > 300 ? "..." : ""}${RESET}
+        }
+      } else if (it.type === "tool_result") {
+        const errLabel = it.is_error ? ` ${RED}ERROR${RESET}` : it.status && it.status !== "COMPLETED" ? ` ${RED}${it.status}${RESET}` : "";
+        if (errLabel)
+          errorCount++;
+        const status = errLabel;
+        let bodyStr;
+        if (typeof it.content === "string")
+          bodyStr = it.content;
+        else {
+          bodyStr = (it.content || []).map((c2) => {
+            if (c2.type === "text")
+              return c2.text ?? "";
+            if (c2.type === "image" || c2.type === "document") {
+              const s = c2.source ?? {};
+              return `[${c2.type}] ${s.mimeType ?? ""}${s.name ? " " + s.name : ""} (${s.size ?? "?"} B) ${s.uri ?? ""}`;
+            }
+            return "";
+          }).join(`
+`);
+        }
+        process.stderr.write(`  ${DIM}\u2514\u2500 result:${RESET}${status} ${indent(trunc(bodyStr, 500), `     ${DIM}\u2502${RESET} `)}
 `);
       }
     }
@@ -43941,9 +44991,7 @@ ${DIM}... (${block.result.length} chars)${RESET}` : block.result;
   process.stderr.write(`
 ` + "\u2500".repeat(60) + `
 `);
-  const blockCount = messages.reduce((n, m) => n + (m.blocks?.length || 0), 0);
-  const errorBlocks = messages.reduce((n, m) => n + (m.blocks || []).filter((b) => b.status === "ERROR" || b.type === "error").length, 0);
-  process.stderr.write(`${DIM}Messages: ${messages.length} | Blocks: ${blockCount} | Errors: ${errorBlocks}${RESET}
+  process.stderr.write(`${DIM}Messages: ${shaped.length} | Tool calls: ${toolUseCount} | Tool errors: ${errorCount}${RESET}
 `);
 }
 
@@ -44093,347 +45141,6 @@ Please choose an agent:
   })();
 }
 
-// ../packages/shared-fbe/src/bashPatterns.ts
-function splitShellCommands(input) {
-  const parts = [];
-  let current = "";
-  let i = 0;
-  const len = input.length;
-  while (i < len) {
-    const ch = input[i];
-    if (ch === "\\" && i + 1 < len && input[i + 1] === `
-`) {
-      current += " ";
-      i += 2;
-      continue;
-    }
-    if (ch === "\\" && i + 1 < len) {
-      current += ch + input[i + 1];
-      i += 2;
-      continue;
-    }
-    if (ch === "<" && i + 1 < len && input[i + 1] === "<") {
-      i += 2;
-      if (i < len && input[i] === "-")
-        i++;
-      while (i < len && (input[i] === " " || input[i] === "\t"))
-        i++;
-      let delim = "";
-      if (i < len && (input[i] === "'" || input[i] === '"')) {
-        const q = input[i];
-        i++;
-        while (i < len && input[i] !== q) {
-          delim += input[i];
-          i++;
-        }
-        if (i < len)
-          i++;
-      } else {
-        while (i < len && /\w/.test(input[i])) {
-          delim += input[i];
-          i++;
-        }
-      }
-      if (delim) {
-        const rest = input.slice(i);
-        const m = rest.match(new RegExp(`^${delim}$`, "m"));
-        if (m && m.index !== undefined) {
-          i += m.index + delim.length;
-        } else {
-          i = len;
-        }
-      }
-      continue;
-    }
-    if (ch === "#" && (current.length === 0 || /\s$/.test(current))) {
-      while (i < len && input[i] !== `
-`)
-        i++;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      const quote = ch;
-      current += ch;
-      i++;
-      while (i < len && input[i] !== quote) {
-        if (input[i] === "\\" && quote === '"' && i + 1 < len) {
-          current += input[i] + input[i + 1];
-          i += 2;
-        } else {
-          current += input[i];
-          i++;
-        }
-      }
-      if (i < len)
-        current += input[i];
-      i++;
-      continue;
-    }
-    if (ch === "|" && i + 1 < len && input[i + 1] === "|") {
-      parts.push(current);
-      current = "";
-      i += 2;
-    } else if (ch === "&" && i + 1 < len && input[i + 1] === "&") {
-      parts.push(current);
-      current = "";
-      i += 2;
-    } else if (ch === "|") {
-      parts.push(current);
-      current = "";
-      i++;
-    } else if (ch === ";" || ch === `
-`) {
-      parts.push(current);
-      current = "";
-      i++;
-    } else {
-      current += ch;
-      i++;
-    }
-  }
-  parts.push(current);
-  return parts.map((s) => s.trim()).filter(Boolean);
-}
-function generalizeToken(token) {
-  if (/^\d+$/.test(token))
-    return "*";
-  if (/^[0-9a-f]{4,}$/i.test(token) && /\d/.test(token))
-    return "*";
-  if (/^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(token))
-    return "*";
-  if (/^https?:\/\//i.test(token)) {
-    try {
-      const u = new URL(token);
-      return `${u.protocol}//${u.host}/*`;
-    } catch {
-      return token;
-    }
-  }
-  return token;
-}
-var SAFE_FLAGS = new Set(["--help", "-h", "--version", "-V", "-v"]);
-function splitTokens(cmd) {
-  const tokens = [];
-  let current = "";
-  let i = 0;
-  const len = cmd.length;
-  while (i < len) {
-    const ch = cmd[i];
-    if (ch === "\\" && i + 1 < len && cmd[i + 1] === `
-`) {
-      i += 2;
-      continue;
-    }
-    if (ch === "\\" && i + 1 < len) {
-      current += ch + cmd[i + 1];
-      i += 2;
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      const q = ch;
-      current += ch;
-      i++;
-      while (i < len && cmd[i] !== q) {
-        if (cmd[i] === "\\" && q === '"' && i + 1 < len) {
-          current += cmd[i] + cmd[i + 1];
-          i += 2;
-        } else {
-          current += cmd[i];
-          i++;
-        }
-      }
-      if (i < len) {
-        current += cmd[i];
-        i++;
-      }
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-      i++;
-      continue;
-    }
-    current += ch;
-    i++;
-  }
-  if (current)
-    tokens.push(current);
-  return tokens;
-}
-function parseSingle(cmd) {
-  const tokens = splitTokens(cmd);
-  while (tokens.length && /^[A-Za-z_]\w*=/.test(tokens[0])) {
-    const val = tokens[0].slice(tokens[0].indexOf("=") + 1);
-    if (/\$\(|`/.test(val))
-      return { tokens: [], defaultKeep: 0 };
-    tokens.shift();
-  }
-  if (tokens.length === 0)
-    return { tokens: [], defaultKeep: 0 };
-  if (tokens[0].startsWith("#"))
-    return { tokens: [], defaultKeep: 0 };
-  const positionals = [tokens[0]];
-  let hitFlag = false;
-  let defaultKeep = -1;
-  for (let t = 1;t < tokens.length; t++) {
-    if (!hitFlag && SAFE_FLAGS.has(tokens[t])) {
-      positionals.push(tokens[t]);
-      return { tokens: positionals, defaultKeep: positionals.length };
-    }
-    if (tokens[t].startsWith("-")) {
-      if (!hitFlag) {
-        hitFlag = true;
-        defaultKeep = Math.min(3, positionals.length);
-      }
-      positionals.push(tokens[t]);
-      continue;
-    }
-    const g = generalizeToken(tokens[t]);
-    positionals.push(g);
-    if (g !== tokens[t])
-      break;
-  }
-  if (defaultKeep < 0)
-    defaultKeep = Math.min(3, positionals.length);
-  return { tokens: positionals, defaultKeep };
-}
-function buildBashPattern(parsed, keep) {
-  if (parsed.tokens.length === 0)
-    return "BASH(cmd: *)";
-  const k = Math.max(1, Math.min(keep ?? parsed.defaultKeep, parsed.tokens.length));
-  const kept = parsed.tokens.slice(0, k);
-  const suffix = kept[kept.length - 1] === "*" ? "" : " *";
-  return `BASH(cmd: ${kept.join(" ")}${suffix})`;
-}
-function parseBashCmd(fullCmd) {
-  return splitShellCommands(fullCmd).map(parseSingle).filter((p) => p.tokens.length > 0);
-}
-function generalizeBashCmd(fullCmd) {
-  return parseBashCmd(fullCmd).map((p) => buildBashPattern(p));
-}
-function getBlockServerPrefix(block) {
-  const agentPattern = typeof block.generalized_pattern === "string" ? block.generalized_pattern : "";
-  const prefixMatch = agentPattern.match(/^(.*?:)BASH(?:\(|$)/);
-  return prefixMatch ? prefixMatch[1] : "";
-}
-var BASH_LIKE_BLOCK_TYPES = new Set(["bash", "machine_exec"]);
-function getBlockPatterns(block) {
-  if (Array.isArray(block.generalized_pattern))
-    return block.generalized_pattern;
-  const agentPattern = typeof block.generalized_pattern === "string" ? block.generalized_pattern : "";
-  const isBashLike = BASH_LIKE_BLOCK_TYPES.has(block.type.toLowerCase()) || /:BASH(\(|$)/.test(agentPattern);
-  if (isBashLike && block.cmd) {
-    const prefix = getBlockServerPrefix(block);
-    return generalizeBashCmd(block.cmd).map((p) => prefix + p);
-  }
-  if (block.generalized_pattern)
-    return [block.generalized_pattern];
-  return [`${block.type}(*)`];
-}
-function getBlockServerId(block) {
-  const prefix = getBlockServerPrefix(block);
-  return prefix ? prefix.slice(0, -1) : "*";
-}
-
-// ../packages/shared-fbe/src/permissionUtils.ts
-function parsePattern(pattern) {
-  const colonIndex = pattern.indexOf(":");
-  if (colonIndex === -1)
-    return null;
-  const serverId = pattern.slice(0, colonIndex);
-  if (!/^[A-Za-z0-9_*-]+$/.test(serverId)) {
-    return { serverId: "*", toolName: pattern };
-  }
-  return { serverId, toolName: pattern.slice(colonIndex + 1) };
-}
-function serverIdMatches(ruleServerId, targetServerId) {
-  if (ruleServerId === targetServerId)
-    return true;
-  if (ruleServerId === "*")
-    return true;
-  if (ruleServerId.includes("*")) {
-    const escaped = ruleServerId.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp("^" + escaped.replace(/\*/g, "[^:]*") + "$");
-    return regex.test(targetServerId);
-  }
-  if (targetServerId.startsWith(ruleServerId + "_"))
-    return true;
-  return false;
-}
-function patternMatches(rulePattern, targetPattern) {
-  const rule = parsePattern(rulePattern);
-  const target = parsePattern(targetPattern);
-  if (!rule || !target)
-    return rulePattern === targetPattern;
-  if (!serverIdMatches(rule.serverId, target.serverId))
-    return false;
-  if (rule.toolName === target.toolName)
-    return true;
-  if (rule.toolName === "*")
-    return true;
-  if (rule.toolName.endsWith(" *)")) {
-    const rulePrefix = rule.toolName.slice(0, -2);
-    return target.toolName.startsWith(rulePrefix);
-  }
-  return false;
-}
-function bashRuleMatchesCmd(rulePattern, serverId, cmd) {
-  const rule = parsePattern(rulePattern);
-  if (!rule)
-    return false;
-  if (!serverIdMatches(rule.serverId, serverId))
-    return false;
-  if (rule.toolName === "*" || rule.toolName === "BASH")
-    return true;
-  const m = rule.toolName.match(/^BASH\(cmd:\s*(.*)\)$/);
-  if (!m)
-    return false;
-  let body = m[1];
-  const isPrefix = body.endsWith(" *") || body.endsWith("*");
-  if (isPrefix)
-    body = body.replace(/\s*\*$/, "");
-  const subs = splitShellCommands(cmd);
-  if (subs.length === 0)
-    return false;
-  return subs.every((sub) => isPrefix ? sub === body || sub.startsWith(body + " ") : sub === body);
-}
-function isPatternInList(list, pattern) {
-  if (!list)
-    return false;
-  return list.some((p) => patternMatches(p, pattern));
-}
-function isPatternAllowed(permissions, pattern) {
-  return isPatternInList(permissions?.allow, pattern);
-}
-function getNewPatterns(patterns, permissions) {
-  return patterns.filter((p) => !isPatternAllowed(permissions, p));
-}
-function getBlockNewPatterns(block, permissions) {
-  const allow = permissions?.allow ?? [];
-  if (Array.isArray(block.generalized_pattern)) {
-    return getNewPatterns(block.generalized_pattern, permissions);
-  }
-  const agentPattern = typeof block.generalized_pattern === "string" ? block.generalized_pattern : "";
-  const isBash = (block.type.toLowerCase() === "bash" || agentPattern.includes(":BASH(")) && !!block.cmd;
-  if (!isBash) {
-    return getBlockPatterns(block).filter((p) => !isPatternAllowed(permissions, p));
-  }
-  const serverId = getBlockServerId(block);
-  const prefix = serverId === "*" ? "" : `${serverId}:`;
-  const rawSubs = splitShellCommands(block.cmd);
-  const pairs = [];
-  for (const raw of rawSubs) {
-    const parsed = parseBashCmd(raw);
-    if (parsed.length === 0)
-      continue;
-    pairs.push({ raw, pattern: prefix + buildBashPattern(parsed[0]) });
-  }
-  return pairs.filter(({ raw, pattern }) => !isPatternAllowed(permissions, pattern) && !allow.some((rule) => bashRuleMatchesCmd(rule, serverId, raw))).map(({ pattern }) => pattern);
-}
-
 // src/diff-view.ts
 var import_diff_match_patch = __toESM(require_diff_match_patch(), 1);
 var import_cli_highlight = __toESM(require_dist(), 1);
@@ -44635,8 +45342,8 @@ function renderDiff(originalContent, modifiedContent, filePath) {
     return "";
   const visible = new Set;
   for (const idx of changed) {
-    for (let c = Math.max(0, idx - CONTEXT_LINES);c <= Math.min(lines.length - 1, idx + CONTEXT_LINES); c++) {
-      visible.add(c);
+    for (let c2 = Math.max(0, idx - CONTEXT_LINES);c2 <= Math.min(lines.length - 1, idx + CONTEXT_LINES); c2++) {
+      visible.add(c2);
     }
   }
   const parts = [`${CYAN}\u2500\u2500 ${filePath} \u2500\u2500${RESET}
@@ -44799,12 +45506,12 @@ ${YELLOW}Interrupting... (Ctrl+C again to force exit)${RESET}
     if (approvalPromptActive || pendingBlocks.length === 0)
       return;
     approvalPromptActive = true;
-    const blocks = pendingBlocks.splice(0).map((bi) => {
+    const blocks3 = pendingBlocks.splice(0).map((bi) => {
       const latest = bi?.blockId ? blocksStore.get(bi.blockId) || {} : {};
       return { ...latest, ...bi };
     });
     if (approveAll) {
-      for (const bi of blocks) {
+      for (const bi of blocks3) {
         const [tl, disp] = blockDisplay(bi);
         process.stderr.write(`
 ${YELLOW}\u26A0 Auto-approving [${tl}]${RESET} ${disp}
@@ -44817,14 +45524,14 @@ ${YELLOW}\u26A0 Auto-approving [${tl}]${RESET} ${disp}
       }
       return;
     }
-    activeApprovalBlocks = blocks;
-    const hasFileBlocks = blocks.some((bi) => ["create", "edit"].includes(classifyBlock(bi)));
+    activeApprovalBlocks = blocks3;
+    const hasFileBlocks = blocks3.some((bi) => ["create", "edit"].includes(classifyBlock(bi)));
     if (hasFileBlocks)
       await new Promise((r) => setTimeout(r, 1500));
     process.stderr.write(`
-${YELLOW}\u26A0 ${blocks.length} action(s) awaiting approval:${RESET}
+${YELLOW}\u26A0 ${blocks3.length} action(s) awaiting approval:${RESET}
 `);
-    for (const bi of blocks) {
+    for (const bi of blocks3) {
       const [tl, disp] = blockDisplay(bi);
       process.stderr.write(`  ${YELLOW}[${tl}]${RESET} ${disp}
 `);
@@ -44841,7 +45548,7 @@ ${YELLOW}\u26A0 ${blocks.length} action(s) awaiting approval:${RESET}
         process.stderr.write(renderDiff(diff.originalContent, diff.modifiedContent, filePath));
       }
     }
-    const newPatterns = blocks.flatMap((bi) => getBlockNewPatterns({
+    const newPatterns = blocks3.flatMap((bi) => getBlockNewPatterns({
       type: bi.block_type || "unknown",
       generalized_pattern: bi.generalized_pattern,
       cmd: bi.cmd
@@ -44855,7 +45562,7 @@ ${YELLOW}\u26A0 ${blocks.length} action(s) awaiting approval:${RESET}
       }
       if (response === "a" || response === "y" || response === "" || response === "r") {
         const decision = response === "r" ? "allow_remember" : "allow_once";
-        for (const bi of blocks) {
+        for (const bi of blocks3) {
           let patterns;
           if (response === "r") {
             patterns = getBlockNewPatterns({
@@ -44871,14 +45578,14 @@ ${YELLOW}\u26A0 ${blocks.length} action(s) awaiting approval:${RESET}
           sendApproval(ws, bi.blockId, bi.messageId, todoId, decision, patterns);
         }
       } else {
-        for (const bi of blocks) {
+        for (const bi of blocks3) {
           ws.sendBlockDeny(todoId, bi.messageId, bi.blockId);
         }
         process.stderr.write(`  ${RED}\u2717 Denied${RESET}
 `);
       }
     } catch {
-      for (const bi of blocks) {
+      for (const bi of blocks3) {
         sendApproval(ws, bi.blockId, bi.messageId, todoId);
       }
     }
@@ -45028,6 +45735,239 @@ async function listAgentsCommand(api, opts) {
   }
 }
 
+// src/agent-command.ts
+function printAgentHelp() {
+  process.stderr.write(`
+todoai agent \u2014 inspect and update agent settings
+
+Usage:
+  todoai agent list                            List agents (name, model, id, paths)
+  todoai agent get <agent>                     Show a single agent's settings
+  todoai agent update <agent> <field=value>\u2026   Update one or more settings
+
+<agent> is a name or id (unique partial name also works).
+Fields map directly to agent settings; values are parsed as JSON when possible
+(numbers, booleans), otherwise treated as strings. Common fields:
+  model           e.g. claude  |  anthropic:anthropic/claude-opus-4.8
+                  ('claude' is the rolling alias \u2192 latest Claude Opus)
+  systemMessage   freeform prompt text (alias: sysmsg)
+  temperature     number, e.g. 0.7
+  thinkingLevel   low | medium | high | xhigh | max
+  name            agent display name
+
+Examples:
+  todoai agent update <agent> model=claude
+  todoai agent update <agent> model=anthropic:anthropic/claude-opus-4.8 temperature=0.5
+  todoai agent update <agent> sysmsg="You are a terse video editor."
+`);
+}
+var FIELD_ALIASES = {
+  sysmsg: "systemMessage",
+  prompt: "systemMessage",
+  temp: "temperature",
+  thinking: "thinkingLevel"
+};
+function parseAssignment(arg) {
+  const eq = arg.indexOf("=");
+  if (eq < 1) {
+    process.stderr.write(`${RED}Invalid field assignment '${arg}', expected field=value${RESET}
+`);
+    process.exit(2);
+  }
+  const rawKey = arg.slice(0, eq);
+  const key = FIELD_ALIASES[rawKey] || rawKey;
+  const raw = arg.slice(eq + 1);
+  try {
+    return [key, JSON.parse(raw)];
+  } catch {
+    return [key, raw];
+  }
+}
+function resolveAgent(agents, query) {
+  const byId = agents.find((a) => getItemId(a) === query);
+  if (byId)
+    return byId;
+  const q = query.toLowerCase();
+  const exact = agents.filter((a) => getDisplayName(a).toLowerCase() === q);
+  if (exact.length === 1)
+    return exact[0];
+  const partial = agents.filter((a) => getDisplayName(a).toLowerCase().includes(q));
+  if (partial.length === 1)
+    return partial[0];
+  if (partial.length > 1) {
+    process.stderr.write(`${RED}Ambiguous agent '${query}', matches:${RESET}
+`);
+    for (const a of partial)
+      process.stderr.write(`  ${getDisplayName(a)}  ${DIM}${getItemId(a)}${RESET}
+`);
+    process.exit(2);
+  }
+  process.stderr.write(`${RED}No agent matching '${query}'${RESET}
+`);
+  process.exit(2);
+}
+async function agentCommand(api, positionals, args, formatPath) {
+  const sub = positionals[1];
+  if (!sub || sub === "list" || sub === "ls") {
+    await listAgentsCommand(api, { json: !!args.json, formatPath });
+    return;
+  }
+  if (sub === "get") {
+    const agents = await api.listAgentSettings();
+    const agent = resolveAgent(agents, positionals[2] || "");
+    if (args.json) {
+      console.log(JSON.stringify(agent, null, 2));
+      return;
+    }
+    process.stderr.write(`${BRAND}${getDisplayName(agent)}${RESET}  ${DIM}${getItemId(agent)}${RESET}
+`);
+    process.stderr.write(`  ${DIM}model:${RESET} ${CYAN}${agent.model || "(default)"}${RESET}
+`);
+    const paths = getAgentWorkspacePaths(agent).map(formatPath);
+    if (paths.length)
+      process.stderr.write(`  ${DIM}paths:${RESET} ${paths.join(", ")}
+`);
+    return;
+  }
+  if (sub === "update") {
+    const query = positionals[2];
+    const assignments = positionals.slice(3);
+    if (!query || !assignments.length) {
+      process.stderr.write(`${RED}Usage: todoai agent update <name|id> <field=value>\u2026${RESET}
+`);
+      process.exit(2);
+    }
+    const updates = Object.fromEntries(assignments.map(parseAssignment));
+    const agents = await api.listAgentSettings();
+    const agent = resolveAgent(agents, query);
+    const id = getItemId(agent);
+    const updated = await api.updateAgentSettings(id, id, updates);
+    if (args.json) {
+      console.log(JSON.stringify(updated, null, 2));
+      return;
+    }
+    const summary = Object.keys(updates).map((k) => `${k}=${JSON.stringify(updated[k])}`).join(" ");
+    process.stderr.write(`${GREEN}\u2705 ${getDisplayName(agent)} updated: ${summary}${RESET}
+`);
+    return;
+  }
+  process.stderr.write(`${RED}Unknown 'agent' subcommand: ${sub}${RESET}
+`);
+  printAgentHelp();
+  process.exit(2);
+}
+
+// src/list-todos.ts
+import { parseArgs as parseArgs2 } from "util";
+var STATUS_COLOR = {
+  DONE: GREEN,
+  READY: GREEN,
+  READY_CHECKED: GREEN,
+  ERROR: RED,
+  ERROR_CHECKED: RED,
+  CANCELLED: RED,
+  CANCELLED_CHECKED: RED,
+  RUNNING: YELLOW,
+  STOPPING: YELLOW,
+  COMPACTING: YELLOW,
+  REVIEW_REQUESTED: YELLOW,
+  TODO: CYAN,
+  SCHEDULED: CYAN,
+  POSTPONED: CYAN,
+  PAUSED: CYAN
+};
+var CLOSED = new Set([
+  "DONE",
+  "READY_CHECKED",
+  "CANCELLED",
+  "CANCELLED_CHECKED",
+  "ERROR_CHECKED",
+  "ARCHIVED",
+  "DELETED"
+]);
+var VALID_STATUS = new Set(Object.values(TodoStatus));
+var isOpen = (s) => !CLOSED.has(s);
+function printHelp() {
+  process.stderr.write(`
+todoai list \u2014 list todos in a project (recent first)
+
+Usage:
+  todoai list [flags]
+
+Flags:
+  -n, --limit <n>          Max rows to show (default: 30)
+  -s, --status <S[,S2]>    Filter by status (comma-separated, union).
+  -A, --all                Include DONE (also CANCELLED, ARCHIVED, \u2026)
+      --project <id>       Project ID (default: current default project)
+      --json               Output raw JSON
+  -h, --help               Show this help
+
+Examples:
+  todoai list                       # 30 most recent open todos
+  todoai list -n 50                 # last 50 open
+  todoai list --all                 # include DONE
+  todoai list -s RUNNING,REVIEW_REQUESTED
+  todoai list --json | jq '.[].id'
+`);
+}
+async function listTodosCommand(api, defaultProjectId, argv) {
+  const { values } = parseArgs2({
+    args: argv,
+    options: {
+      limit: { type: "string", short: "n" },
+      status: { type: "string", short: "s" },
+      all: { type: "boolean", short: "A", default: false },
+      project: { type: "string" },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    strict: true
+  });
+  if (values.help) {
+    printHelp();
+    return;
+  }
+  const projectId = values.project || defaultProjectId;
+  if (!projectId) {
+    process.stderr.write(`${RED}Error: no project (pass --project <id> or set a default)${RESET}
+`);
+    process.exit(1);
+  }
+  const limit = values.limit ? Math.max(1, Number(values.limit)) : 30;
+  const requested = values.status ? String(values.status).split(",").map((s) => s.trim().toUpperCase()).filter(Boolean) : null;
+  const wantOpen = !!requested?.some((s) => s === "OPEN" || !VALID_STATUS.has(s));
+  const wanted = requested ? new Set(requested.filter((s) => VALID_STATUS.has(s))) : null;
+  const includeClosed = !!values.all || !!wanted && wanted.size > 0;
+  const todos = await api.listTodos(projectId);
+  let rows = todos.filter((t) => includeClosed || !CLOSED.has(String(t.status).toUpperCase())).filter((t) => {
+    if (!requested)
+      return true;
+    const s = String(t.status).toUpperCase();
+    return wantOpen && isOpen(s) || (wanted?.has(s) ?? false);
+  }).sort((a, b) => (b.lastActivityAt ?? b.createdAt ?? 0) - (a.lastActivityAt ?? a.createdAt ?? 0)).slice(0, limit);
+  if (values.json) {
+    process.stdout.write(JSON.stringify(rows, null, 2) + `
+`);
+    return;
+  }
+  if (!rows.length) {
+    process.stderr.write(`${DIM}(no todos)${RESET}
+`);
+    return;
+  }
+  const statusW = rows.reduce((n, r) => Math.max(n, String(r.status).length), 0);
+  for (const t of rows) {
+    const sc = STATUS_COLOR[t.status] || DIM;
+    const ts = new Date(t.lastActivityAt ?? t.createdAt).toISOString().slice(0, 16).replace("T", " ");
+    const title = String(t.content ?? "").split(`
+`)[0].slice(0, 100);
+    process.stdout.write(`${sc}${String(t.status).padEnd(statusW)}${RESET}  ${DIM}${ts}${RESET}  ${t.id}  ${title}
+`);
+  }
+  process.stderr.write(`${DIM}${rows.length} todo(s)${RESET}
+`);
+}
+
 // src/ensure-edge.ts
 import { spawn, spawnSync } from "child_process";
 import fs2 from "fs";
@@ -45171,7 +46111,15 @@ Cancelled by user (Ctrl+C)
     console.log(VERSION);
     process.exit(0);
   }
-  if (args.help) {
+  if (positionals[0] === "status" && args.help) {
+    printStatusHelp();
+    process.exit(0);
+  }
+  if (positionals[0] === "agent" && args.help) {
+    printAgentHelp();
+    process.exit(0);
+  }
+  if (args.help && !["list", "ls", "agent"].includes(positionals[0])) {
     printUsage();
     process.exit(0);
   }
@@ -45247,26 +46195,100 @@ Cancelled by user (Ctrl+C)
     await deviceLogin();
     return;
   }
-  let apiKey = args["api-key"] || getEnv("API_TOKEN") || getEnv("API_KEY") || readCredential(apiUrl) || "";
+  let apiKey = args["api-key"] || readCredential(apiUrl) || getEnv("API_TOKEN") || "";
   if (!apiKey) {
     apiKey = await deviceLogin();
   }
   const api = new ApiClient(apiUrl, apiKey);
+  if (positionals[0] === "status") {
+    const [, todoId, status] = positionals;
+    if (!todoId || !status) {
+      printStatusHelp();
+      process.exit(2);
+    }
+    await api.updateTodoStatus(todoId, status);
+    process.stderr.write(`${GREEN}\u2705 Status of ${todoId} set to ${status}${RESET}
+`);
+    return;
+  }
+  if (positionals[0] === "delete") {
+    const todoId = positionals[1];
+    if (!todoId) {
+      process.stderr.write(`${RED}Usage: todoai delete <todo-id>${RESET}
+`);
+      process.exit(2);
+    }
+    await api.deleteTodo(todoId);
+    process.stderr.write(`${GREEN}\u2705 Deleted ${todoId}${RESET}
+`);
+    return;
+  }
+  if (positionals[0] === "addmessage") {
+    const [, todoId, ...rest] = positionals;
+    const content2 = rest.join(" ") || await readStdin();
+    if (!todoId || !content2) {
+      process.stderr.write(`${RED}Usage: todoai addmessage <todo-id> "content"${RESET}
+`);
+      process.exit(2);
+    }
+    const todo2 = await api.getTodo(todoId);
+    const msg = await api.addMessage(todo2.projectId, content2, todo2.agentSettings || { id: todo2.agentSettingsId }, todoId);
+    if (args.json)
+      console.log(JSON.stringify(msg, null, 2));
+    else
+      process.stderr.write(`${GREEN}\u2705 Message added to ${todoId}${RESET}
+`);
+    return;
+  }
   if (args["list-agents"]) {
     await listAgentsCommand(api, { json: !!args.json, formatPath: formatPathWithTilde });
     return;
   }
+  if (positionals[0] === "agent") {
+    await agentCommand(api, positionals, args, formatPathWithTilde);
+    return;
+  }
+  if (positionals[0] === "list" || positionals[0] === "ls") {
+    let defaultProjectId = args.project || cfgScope.data.default_project_id;
+    if (!defaultProjectId) {
+      const projects2 = await api.listProjects();
+      defaultProjectId = projects2.find((p) => p.project?.isDefault)?.project?.id || projects2[0]?.project?.id;
+    }
+    const sub = process.argv.slice(process.argv.indexOf(positionals[0]) + 1);
+    await listTodosCommand(api, defaultProjectId ?? undefined, sub);
+    return;
+  }
   if (args.inspect !== undefined) {
     const raw = String(args.inspect);
-    const [rawTodoId, untilMessageId] = raw.includes(":") ? raw.split(":", 2) : [raw, undefined];
-    const todoId = rawTodoId || getEnv("TODO_ID");
+    const at = raw.indexOf("@");
+    const todoId = at < 0 ? raw : raw.slice(0, at);
+    const slice = at < 0 ? undefined : raw.slice(at + 1);
     if (!todoId) {
-      process.stderr.write(`${RED}Error: --inspect requires a todoId (or $TODOFORAI_TODO_ID env var)${RESET}
+      process.stderr.write(`${RED}Error: --inspect requires a todoId${RESET}
 `);
       process.exit(2);
     }
     const todo2 = await api.getTodo(todoId);
-    printFullChat(todo2, getFrontendUrl(apiUrl, todo2.projectId, todoId), untilMessageId || undefined);
+    if (args.json) {
+      let messages = todo2.messages || [];
+      if (slice) {
+        try {
+          messages = applySlice(messages, slice);
+        } catch (e) {
+          process.stderr.write(`${RED}${e.message}${RESET}
+`);
+          process.exit(2);
+        }
+      }
+      const mode2 = args.debug ? "debug" : args.detailed ? "detailed" : "default";
+      const format2 = args["format-anthropic"] ? "anthropic" : "compact";
+      process.stdout.write(JSON.stringify(toAnthropicShape(messages, mode2, format2), null, 2) + `
+`);
+      return;
+    }
+    const mode = args.debug ? "debug" : args.detailed ? "detailed" : "default";
+    const format = args["format-anthropic"] ? "anthropic" : "compact";
+    printFullChat(todo2, getFrontendUrl(apiUrl, todo2.projectId, todoId), slice, mode, format);
     return;
   }
   if (process.stderr.isTTY)
@@ -45370,7 +46392,7 @@ ${"\u2500".repeat(40)}
     }
     const todo2 = await api.getTodo(todoId);
     const projectId2 = todo2.projectId;
-    const agent2 = todo2.agentSettings || { name: "default" };
+    const agent2 = todo2.agentSettings || await api.getAgentSettings(todo2.agentSettingsId);
     for (const msg of todo2.messages || []) {
       const role = msg.role === "user" ? `${CYAN}You${RESET}` : `${GREEN}AI${RESET}`;
       process.stderr.write(`${role}: ${(msg.content || "").slice(0, 200)}
@@ -45378,11 +46400,20 @@ ${"\u2500".repeat(40)}
     }
     process.stderr.write(`
 ${"\u2500".repeat(40)}
-Resumed todo: ${todoId}
+Resumed: ${CYAN}${getFrontendUrl(apiUrl, projectId2, todoId)}${RESET}
 `);
     const ws2 = new FrontendWebSocket(apiUrl, apiKey);
     await ws2.connect();
-    await interactiveLoop(ws2, api, todoId, projectId2, agent2, !!args.json, false, cfg);
+    const autoApprove = !!args["dangerously-skip-permissions"];
+    const followUp = positionals.length > 0 ? positionals.join(" ") : process.stdin.isTTY ? "" : await readStdin();
+    if (followUp) {
+      cfg.addToHistory(followUp);
+      await api.addMessage(projectId2, followUp, agent2, todoId);
+      await watchTodo(ws2, todoId, projectId2, { json: !!args.json, autoApprove, agentSettings: agent2 });
+    }
+    if (!args["non-interactive"]) {
+      await interactiveLoop(ws2, api, todoId, projectId2, agent2, !!args.json, autoApprove, cfg);
+    }
     await ws2.close();
     return;
   }