openmates 0.14.8-alpha.0 → 0.14.8-alpha.10

package/dist/{chunk-7BIVPFKJ.js → chunk-WEU7CSZD.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AXNRPVLE.js";
 
 // src/client.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { arch, platform as platform2, release } from "os";
 import { createInterface } from "readline/promises";
 import { stdin, stdout } from "process";
@@ -1190,6 +1190,8 @@ var SUB_CHAT_EVENT_TYPES = /* @__PURE__ */ new Set([
 var SUB_CHAT_PARENT_STATUS_MESSAGE = "I've started the sub-chats and will continue once they finish.";
 var SUB_CHAT_COMPLETION_TIMEOUT_MS = 10 * 6e4;
 var CLIENT_UPDATE_REQUIRED_GUIDANCE = "OpenMates CLI update required. Run `openmates upgrade` and retry.";
+var TASK_STATUSES = /* @__PURE__ */ new Set(["backlog", "todo", "in_progress", "blocked", "done"]);
+var TASK_ASSIGNEES = /* @__PURE__ */ new Set(["ai", "user"]);
 var WebSocketProtocolError = class extends Error {
   code;
   constructor(code, message) {
@@ -1212,14 +1214,121 @@ function websocketProtocolError(envelope) {
   }
   return null;
 }
+function errorFrameBelongsToAiResponse(envelope, userMessageId, chatId, recoveryTurnId) {
+  if (envelope.type === "client_update_required") return true;
+  if (envelope.type !== "error") return true;
+  const payload = envelope.payload && typeof envelope.payload === "object" ? envelope.payload : {};
+  let scoped = false;
+  const errorChatId = typeof payload.chat_id === "string" ? payload.chat_id : null;
+  if (errorChatId) {
+    scoped = true;
+    if (errorChatId !== chatId) return false;
+  }
+  const errorMessageId = typeof payload.user_message_id === "string" ? payload.user_message_id : typeof payload.userMessageId === "string" ? payload.userMessageId : typeof payload.message_id === "string" ? payload.message_id : null;
+  if (errorMessageId) {
+    scoped = true;
+    if (errorMessageId !== userMessageId) return false;
+  }
+  const errorTurnId = typeof payload.turn_id === "string" ? payload.turn_id : null;
+  if (errorTurnId) {
+    scoped = true;
+    if (recoveryTurnId !== errorTurnId) return false;
+  }
+  if (typeof payload.job_id === "string") {
+    scoped = true;
+  }
+  return !scoped || Boolean(errorChatId || errorMessageId || errorTurnId);
+}
+function parseTaskProposals(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+    const raw = item;
+    if (typeof raw.title !== "string" || raw.title.trim().length === 0) return [];
+    const proposal = { title: raw.title };
+    if (typeof raw.description === "string" || raw.description === null) proposal.description = raw.description;
+    if (typeof raw.status === "string" && TASK_STATUSES.has(raw.status)) proposal.status = raw.status;
+    if (typeof raw.assignee_type === "string" && TASK_ASSIGNEES.has(raw.assignee_type)) proposal.assignee_type = raw.assignee_type;
+    return [proposal];
+  });
+}
+function parseTaskUpdateProposals(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+    const raw = item;
+    if (typeof raw.task_id !== "string" || raw.task_id.trim().length === 0) return [];
+    const proposal = { task_id: raw.task_id };
+    if (typeof raw.title === "string" || raw.title === null) proposal.title = raw.title;
+    if (typeof raw.description === "string" || raw.description === null) proposal.description = raw.description;
+    if (typeof raw.status === "string" && TASK_STATUSES.has(raw.status) || raw.status === null) proposal.status = raw.status;
+    if (typeof raw.assignee_type === "string" && TASK_ASSIGNEES.has(raw.assignee_type) || raw.assignee_type === null) proposal.assignee_type = raw.assignee_type;
+    return [proposal];
+  });
+}
+function parseTaskEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.event_id !== "string" || typeof raw.chat_id !== "string") return null;
+  if (typeof raw.task_id !== "string" || typeof raw.event_type !== "string") return null;
+  const event = {
+    event_id: raw.event_id,
+    chat_id: raw.chat_id,
+    task_id: raw.task_id,
+    event_type: raw.event_type
+  };
+  if (typeof raw.short_id === "string" || raw.short_id === null) event.short_id = raw.short_id;
+  if (typeof raw.title === "string" || raw.title === null) event.title = raw.title;
+  if (typeof raw.status === "string" || raw.status === null) event.status = raw.status;
+  if (typeof raw.reason === "string" || raw.reason === null) event.reason = raw.reason;
+  if (typeof raw.created_at === "number" || raw.created_at === null) event.created_at = raw.created_at;
+  if (typeof raw.task_update_job_id === "string" || raw.task_update_job_id === null) event.task_update_job_id = raw.task_update_job_id;
+  return event;
+}
+function parsePendingTaskUpdateJobs(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+    const raw = item;
+    if (typeof raw.job_id !== "string" || typeof raw.task_id !== "string") return [];
+    if (typeof raw.revision !== "number" || typeof raw.task_key_version !== "number" || typeof raw.expires_at !== "number") return [];
+    const job = {
+      job_id: raw.job_id,
+      task_id: raw.task_id,
+      revision: raw.revision,
+      task_key_version: raw.task_key_version,
+      expires_at: raw.expires_at
+    };
+    if (typeof raw.chat_id === "string" || raw.chat_id === null) job.chat_id = raw.chat_id;
+    return [job];
+  });
+}
+function parseAvailableRecoveryJobs(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+    const raw = item;
+    if (typeof raw.job_id !== "string" || typeof raw.chat_id !== "string" || typeof raw.turn_id !== "string" || typeof raw.assistant_message_id !== "string" || typeof raw.chat_key_version !== "number") return [];
+    return [{
+      job_id: raw.job_id,
+      chat_id: raw.chat_id,
+      turn_id: raw.turn_id,
+      assistant_message_id: raw.assistant_message_id,
+      chat_key_version: raw.chat_key_version
+    }];
+  });
+}
 var OpenMatesWsClient = class {
   socket;
+  passiveTaskUpdateJobs = /* @__PURE__ */ new Map();
+  activeResponseCollectors = 0;
   constructor(options) {
     const wsBase = options.apiUrl.replace(/^http/, "ws").replace(/\/$/, "");
     const token = options.wsToken || options.refreshToken || "";
     const query = new URLSearchParams({
       sessionId: options.sessionId,
-      token
+      token,
+      client_capabilities: "task_update_jobs"
     });
     const wsHeaders = {};
     if (options.userAgent) {
@@ -1234,6 +1343,10 @@ var OpenMatesWsClient = class {
     this.socket = new WebSocket(`${wsBase}/v1/ws?${query.toString()}`, {
       headers: wsHeaders
     });
+    this.socket.on("message", (rawData) => {
+      if (this.activeResponseCollectors > 0) return;
+      this.bufferPassiveTaskUpdateJobs(rawData);
+    });
   }
   async open(timeoutMs = 1e4) {
     await new Promise((resolve7, reject) => {
@@ -1279,6 +1392,22 @@ var OpenMatesWsClient = class {
       });
     });
   }
+  bufferPassiveTaskUpdateJobs(rawData) {
+    try {
+      const parsed = JSON.parse(rawData.toString());
+      if (parsed.type !== "task_update_jobs_available") return;
+      const payload = parsed.payload ?? {};
+      for (const job of parsePendingTaskUpdateJobs(payload.jobs)) {
+        this.passiveTaskUpdateJobs.set(job.job_id, job);
+      }
+    } catch {
+    }
+  }
+  drainPassiveTaskUpdateJobs() {
+    const jobs = [...this.passiveTaskUpdateJobs.values()];
+    this.passiveTaskUpdateJobs.clear();
+    return jobs;
+  }
   waitForMessage(expectedType, predicate, timeoutMs = 2e4) {
     return new Promise((resolve7, reject) => {
       const seenTypes = /* @__PURE__ */ new Set();
@@ -1412,6 +1541,16 @@ var OpenMatesWsClient = class {
       let recoveryJobId = null;
       let followUpSuggestions = [];
       let newChatSuggestions = [];
+      let taskProposals = [];
+      let taskUpdateProposals = [];
+      const taskEvents = [];
+      this.activeResponseCollectors += 1;
+      let pendingTaskUpdateJobs = this.drainPassiveTaskUpdateJobs();
+      const mergePendingTaskUpdateJobs = (jobs) => {
+        const byId = new Map(pendingTaskUpdateJobs.map((job) => [job.job_id, job]));
+        for (const job of jobs) byId.set(job.job_id, job);
+        pendingTaskUpdateJobs = [...byId.values()];
+      };
       const subChatEvents = [];
       const pendingSubChatHandlers = /* @__PURE__ */ new Set();
       const pendingMemoryRequestHandlers = /* @__PURE__ */ new Set();
@@ -1472,6 +1611,10 @@ var OpenMatesWsClient = class {
             modelName,
             followUpSuggestions,
             newChatSuggestions,
+            taskProposals,
+            taskUpdateProposals,
+            taskEvents,
+            pendingTaskUpdateJobs,
             embeds: [...embeds.values()],
             subChatEvents,
             recoveryJobId
@@ -1479,6 +1622,7 @@ var OpenMatesWsClient = class {
           return;
         }
         if (!aiResponseDone || !postProcessingDone) return;
+        if (options?.recoveryTurnId && !recoveryJobId) return;
         if (pendingSubChatHandlers.size > 0) return;
         if (pendingMemoryRequestHandlers.size > 0) return;
         if (processingEmbedIds.size > 0 && !asyncEmbedTimer) {
@@ -1493,6 +1637,10 @@ var OpenMatesWsClient = class {
               modelName,
               followUpSuggestions,
               newChatSuggestions,
+              taskProposals,
+              taskUpdateProposals,
+              taskEvents,
+              pendingTaskUpdateJobs,
               embeds: [...embeds.values()],
               subChatEvents,
               recoveryJobId
@@ -1511,6 +1659,10 @@ var OpenMatesWsClient = class {
           modelName,
           followUpSuggestions,
           newChatSuggestions,
+          taskProposals,
+          taskUpdateProposals,
+          taskEvents,
+          pendingTaskUpdateJobs,
           embeds: [...embeds.values()],
           subChatEvents,
           recoveryJobId
@@ -1587,6 +1739,9 @@ var OpenMatesWsClient = class {
           const type = parsed.type;
           const protocolError = websocketProtocolError(parsed);
           if (protocolError) {
+            if (!errorFrameBelongsToAiResponse(parsed, userMessageId, chatId, options?.recoveryTurnId)) {
+              return;
+            }
             cleanup();
             reject(protocolError);
             return;
@@ -1617,6 +1772,29 @@ var OpenMatesWsClient = class {
             }
             return;
           }
+          if (type === "task_event") {
+            const event = parseTaskEvent(p);
+            if (!event || event.chat_id !== chatId) return;
+            taskEvents.push(event);
+            maybeResolve();
+            return;
+          }
+          if (type === "task_update_jobs_available") {
+            mergePendingTaskUpdateJobs(parsePendingTaskUpdateJobs(p.jobs));
+            maybeResolve();
+            return;
+          }
+          if (type === "recovery_jobs_available") {
+            const job = parseAvailableRecoveryJobs(p.jobs).find(
+              (candidate) => candidate.chat_id === chatId && (!options?.recoveryTurnId || candidate.turn_id === options.recoveryTurnId)
+            );
+            if (!job) return;
+            recoveryJobId = job.job_id;
+            messageId = job.assistant_message_id;
+            if (aiResponseDone) maybeResolve();
+            else scheduleResolve(latestContent);
+            return;
+          }
           if (type === "ai_message_update") {
             const msgId = p.user_message_id ?? p.userMessageId;
             if (msgId !== userMessageId && p.chat_id !== chatId) return;
@@ -1695,6 +1873,8 @@ var OpenMatesWsClient = class {
                 (s) => typeof s === "string" && s.length > 0
               );
             }
+            taskProposals = parseTaskProposals(p.task_proposals);
+            taskUpdateProposals = parseTaskUpdateProposals(p.task_update_proposals);
             if (aiResponseDone) {
               if (postProcessingTimer) {
                 clearTimeout(postProcessingTimer);
@@ -1723,6 +1903,10 @@ var OpenMatesWsClient = class {
             modelName,
             followUpSuggestions,
             newChatSuggestions,
+            taskProposals,
+            taskUpdateProposals,
+            taskEvents,
+            pendingTaskUpdateJobs,
             embeds: [...embeds.values()],
             subChatEvents,
             recoveryJobId
@@ -1745,6 +1929,7 @@ var OpenMatesWsClient = class {
         this.socket.off("message", onMessage);
         this.socket.off("error", onError);
         this.socket.off("close", onClose);
+        this.activeResponseCollectors = Math.max(0, this.activeResponseCollectors - 1);
       };
       this.socket.on("message", onMessage);
       this.socket.on("error", onError);
@@ -2473,6 +2658,227 @@ function toArrayBuffer3(input) {
   return output;
 }
 
+// src/tasksCli.ts
+import { createHash as createHash5, randomBytes as randomBytes2, randomUUID as randomUUID3 } from "crypto";
+var TASK_STATUSES2 = ["backlog", "todo", "in_progress", "blocked", "done"];
+var DEFAULT_STANDALONE_PREFIX = "TASK";
+function normalizeTaskStatus(value) {
+  if (value === void 0) return void 0;
+  if (TASK_STATUSES2.includes(value)) return value;
+  throw new Error(`Unknown task status '${value}'. Expected one of: ${TASK_STATUSES2.join(", ")}`);
+}
+function parseAssignee(value) {
+  if (!value || value === "user") return { assigneeType: "user", assigneeHash: null };
+  if (["ai", "openmates", "OpenMates"].includes(value)) return { assigneeType: "ai", assigneeHash: null };
+  return { assigneeType: "user", assigneeHash: value };
+}
+function splitCsvFlag(value) {
+  if (typeof value !== "string") return [];
+  return value.split(/[,\n]/).map((item) => item.trim()).filter(Boolean);
+}
+function parseDueAt(value) {
+  if (value === void 0) return void 0;
+  if (value === false || value === true) throw new Error("--due requires a timestamp or date value.");
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) return Math.floor(numeric);
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) throw new Error(`Invalid --due value '${value}'.`);
+  return Math.floor(parsed / 1e3);
+}
+async function buildCreateUserTaskInput(masterKey, input) {
+  const taskKey = randomBytes2(32);
+  const encryptedTaskKey = await encryptBytesWithAesGcm(taskKey, masterKey);
+  const timestamp = nowSeconds();
+  const assignee = parseAssignee(input.assign);
+  const linkedProjectIds = input.projectIds ?? [];
+  const status = input.status ?? (assignee.assigneeType === "ai" && !input.dueAt ? "in_progress" : "todo");
+  return {
+    task_id: randomUUIDCompat(),
+    short_id: void 0,
+    version: 1,
+    encrypted_task_key: encryptedTaskKey,
+    encrypted_title: await encryptWithAesGcmCombined(input.title, taskKey),
+    encrypted_description: await encryptWithAesGcmCombined(input.description ?? "", taskKey),
+    encrypted_tags: await encryptWithAesGcmCombined("[]", taskKey),
+    encrypted_linked_project_ids: await encryptWithAesGcmCombined(JSON.stringify(linkedProjectIds), taskKey),
+    status,
+    assignee_type: assignee.assigneeType,
+    assignee_hash: assignee.assigneeHash,
+    primary_chat_id: input.chatId ?? null,
+    linked_project_ids: linkedProjectIds,
+    plan_id: input.planId ?? null,
+    due_at: input.dueAt ?? null,
+    priority: 0,
+    position: timestamp,
+    created_at: timestamp,
+    updated_at: timestamp
+  };
+}
+async function buildUpdateUserTaskInput(task, masterKey, input) {
+  const taskKey = await taskKeyFromRecord(task.encrypted, masterKey);
+  const patch = { version: task.version, updated_at: nowSeconds() };
+  if (input.title !== void 0) patch.encrypted_title = await encryptWithAesGcmCombined(input.title, taskKey);
+  if (input.description !== void 0) patch.encrypted_description = await encryptWithAesGcmCombined(input.description, taskKey);
+  if (input.status !== void 0) patch.status = input.status;
+  if (input.assign !== void 0) {
+    const assignee = parseAssignee(input.assign);
+    patch.assignee_type = assignee.assigneeType;
+    patch.assignee_hash = assignee.assigneeHash;
+  }
+  if (input.chatId !== void 0) patch.primary_chat_id = input.chatId;
+  if (input.projectIds !== void 0) {
+    patch.linked_project_ids = input.projectIds;
+    patch.encrypted_linked_project_ids = await encryptWithAesGcmCombined(JSON.stringify(input.projectIds), taskKey);
+  }
+  if (input.planId !== void 0) patch.plan_id = input.planId;
+  return patch;
+}
+async function decryptUserTask(record, masterKey) {
+  if (typeof record.version !== "number") throw new Error(`Task ${record.task_id} is missing version.`);
+  const taskKey = await taskKeyFromRecord(record, masterKey);
+  const tags = parseStringArray(await decryptOptional(record.encrypted_tags, taskKey));
+  const linkedProjectIds = parseStringArray(await decryptOptional(record.encrypted_linked_project_ids, taskKey));
+  return {
+    taskId: record.task_id,
+    shortId: record.short_id || deriveShortId(record),
+    title: await decryptOptional(record.encrypted_title, taskKey) || "(untitled task)",
+    description: await decryptOptional(record.encrypted_description, taskKey),
+    tags,
+    latestInstruction: await decryptOptional(record.encrypted_latest_instruction, taskKey),
+    status: record.status,
+    assigneeType: record.assignee_type,
+    assigneeHash: record.assignee_hash ?? null,
+    primaryChatId: record.primary_chat_id ?? null,
+    linkedProjectIds: linkedProjectIds.length > 0 ? linkedProjectIds : record.linked_project_ids ?? [],
+    planId: record.plan_id ?? null,
+    dueAt: record.due_at ?? null,
+    priority: record.priority ?? 0,
+    position: record.position ?? 0,
+    queueState: record.queue_state ?? "none",
+    blockedReasonCode: record.blocked_reason_code ?? null,
+    aiExecutionState: record.ai_execution_state ?? null,
+    version: record.version,
+    encrypted: record
+  };
+}
+async function decryptUserTasks(records, masterKey) {
+  const output = [];
+  for (const record of records) output.push(await decryptUserTask(record, masterKey));
+  return output;
+}
+function findTask(tasks, id) {
+  const taskIdMatch = tasks.find((candidate) => candidate.taskId === id);
+  if (taskIdMatch) return taskIdMatch;
+  const shortIdMatches = tasks.filter((candidate) => candidate.shortId === id);
+  if (shortIdMatches.length > 1) throw new Error(`Task '${id}' is ambiguous in the current task list. Use the full task ID.`);
+  const task = shortIdMatches[0];
+  if (!task) throw new Error(`Task '${id}' was not found in the current task list.`);
+  return task;
+}
+function renderTaskList(tasks) {
+  if (tasks.length === 0) return "No tasks found.";
+  const lines = ["Tasks", "ID        Status       Assignee    Queue       Title"];
+  for (const task of tasks) {
+    lines.push(`${pad(task.shortId, 9)} ${pad(task.status, 12)} ${pad(assigneeLabel(task), 11)} ${pad(task.queueState, 11)} ${task.title}`);
+  }
+  return lines.join("\n");
+}
+function renderTaskDetail(task) {
+  const lines = [
+    `Task ${task.shortId}`,
+    `Title: ${task.title}`,
+    `Status: ${task.status}`,
+    `Assignee: ${assigneeLabel(task)}`,
+    `Queue: ${task.queueState}`,
+    `Task ID: ${task.taskId}`
+  ];
+  if (task.description) lines.push(`Description: ${task.description}`);
+  if (task.primaryChatId) lines.push(`Chat: ${task.primaryChatId}`);
+  if (task.linkedProjectIds.length > 0) lines.push(`Projects: ${task.linkedProjectIds.join(", ")}`);
+  if (task.planId) lines.push(`Plan: ${task.planId}`);
+  if (task.blockedReasonCode) lines.push(`Blocked reason: ${task.blockedReasonCode}`);
+  if (task.aiExecutionState) lines.push(`AI state: ${task.aiExecutionState}`);
+  return lines.join("\n");
+}
+function renderTaskBoard(tasks, width = process.stdout.columns || 100) {
+  const columns = TASK_STATUSES2.map((status) => ({ status, tasks: tasks.filter((task) => task.status === status).sort(compareTasks) }));
+  if (width < 96) {
+    const lines2 = ["OpenMates Tasks Board"];
+    for (const column of columns) {
+      lines2.push("", `${columnTitle(column.status)} (${column.tasks.length})`, "-".repeat(24));
+      lines2.push(...boardColumnLines(column.tasks, 8));
+    }
+    return lines2.join("\n");
+  }
+  const perColumn = 6;
+  const columnWidth = 22;
+  const lines = ["OpenMates Tasks Board", ""];
+  lines.push(columns.map((column) => pad(`${columnTitle(column.status)} (${column.tasks.length})`, columnWidth)).join("  "));
+  lines.push(columns.map(() => "-".repeat(columnWidth)).join("  "));
+  const renderedColumns = columns.map((column) => boardColumnLines(column.tasks, perColumn).map((line) => truncate(line, columnWidth)));
+  const maxRows = Math.max(...renderedColumns.map((column) => column.length));
+  for (let row = 0; row < maxRows; row += 1) {
+    lines.push(renderedColumns.map((column) => pad(column[row] ?? "", columnWidth)).join("  "));
+  }
+  return lines.join("\n");
+}
+function boardColumnLines(tasks, limit) {
+  if (tasks.length === 0) return ["No tasks here."];
+  const visible = tasks.slice(0, limit).flatMap((task) => [
+    `[${task.shortId}] ${task.title}`,
+    ` ${assigneeLabel(task)} ${task.queueState === "none" ? "" : task.queueState}`.trimEnd()
+  ]);
+  if (tasks.length > limit) visible.push(`... ${tasks.length - limit} more`);
+  return visible;
+}
+function compareTasks(a, b) {
+  return a.position - b.position || a.title.localeCompare(b.title);
+}
+function columnTitle(status) {
+  if (status === "in_progress") return "In progress";
+  return status.slice(0, 1).toUpperCase() + status.slice(1).replace("_", " ");
+}
+function assigneeLabel(task) {
+  return task.assigneeType === "ai" ? "OpenMates" : task.assigneeHash ?? "user";
+}
+async function taskKeyFromRecord(record, masterKey) {
+  if (!record.encrypted_task_key) throw new Error(`Task ${record.task_id} is missing encrypted task key.`);
+  const taskKey = await decryptBytesWithAesGcm(record.encrypted_task_key, masterKey);
+  if (!taskKey) throw new Error(`Failed to decrypt task key for ${record.task_id}.`);
+  return taskKey;
+}
+async function decryptOptional(value, key) {
+  if (!value) return "";
+  return await decryptWithAesGcmCombined(value, key) ?? "";
+}
+function parseStringArray(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function deriveShortId(record) {
+  const prefix = record.short_id_prefix || DEFAULT_STANDALONE_PREFIX;
+  const source = record.task_id || `${record.created_at ?? ""}-${record.position ?? ""}`;
+  const digest = createHash5("sha256").update(source).digest("hex").slice(0, 4).toUpperCase();
+  return `${prefix}-${parseInt(digest, 16) % 1e4}`;
+}
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+function randomUUIDCompat() {
+  return randomUUID3();
+}
+function pad(value, length) {
+  return truncate(value, length).padEnd(length);
+}
+function truncate(value, length) {
+  return value.length <= length ? value : `${value.slice(0, Math.max(0, length - 3))}...`;
+}
+
 // src/client.ts
 function normalizeUnixSeconds(value, fallback) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
@@ -2640,6 +3046,83 @@ function buildAppSettingsMemoryResponseSystemMessage(params) {
     user_message_id: params.userMessageId
   };
 }
+async function buildTaskEventSystemMessage(params) {
+  const content = formatTaskEventSystemContent(params.event);
+  const message = {
+    message_id: `task-event-${params.event.event_id}`,
+    role: "system",
+    encrypted_content: await encryptWithAesGcmCombined(content, params.chatKey),
+    created_at: params.event.created_at ?? Math.floor(Date.now() / 1e3),
+    user_message_id: params.userMessageId
+  };
+  if (params.event.task_update_job_id) message.task_update_job_id = params.event.task_update_job_id;
+  return message;
+}
+function taskUpdateJobBelongsToActiveTurn(job, activeChatId, taskEvents) {
+  void activeChatId;
+  return taskEvents.some((event) => event.task_update_job_id === job.job_id);
+}
+function buildTaskUpdateJobPersistPayload(params) {
+  const encryptedTaskPayload = pruneAbsentTaskPersistFields(params.encryptedTaskPayload);
+  assertTaskPersistPayloadEncrypted(encryptedTaskPayload);
+  return {
+    protocol_version: 1,
+    job_id: params.jobId,
+    lease_token: params.leaseToken,
+    lease_generation: params.leaseGeneration,
+    expected_task_version: params.expectedTaskVersion,
+    encrypted_task_payload: encryptedTaskPayload,
+    encrypted_task_event_message: params.encryptedTaskEventMessage ?? null
+  };
+}
+function pruneAbsentTaskPersistFields(payload) {
+  return Object.fromEntries(
+    Object.entries(payload).filter(([, value]) => value !== void 0 && value !== null)
+  );
+}
+function formatTaskEventSystemContent(event) {
+  const taskLabel = event.short_id || event.task_id;
+  const title = event.title ? ` "${event.title}"` : "";
+  const status = event.status ? ` (${event.status})` : "";
+  const reason = event.reason ? `: ${event.reason}` : "";
+  switch (event.event_type) {
+    case "created":
+      return `${taskLabel} created${title}${status}`;
+    case "updated":
+      return `${taskLabel} updated${title}${status}`;
+    case "blocked":
+      return `${taskLabel} blocked${reason}`;
+    case "completed":
+      return `${taskLabel} completed${title}`;
+    case "unblocked":
+      return `${taskLabel} unblocked`;
+    default:
+      return `${taskLabel} ${event.event_type}${title}${status}${reason}`;
+  }
+}
+function assertTaskPersistPayloadEncrypted(payload) {
+  const allowedSafeKeys = /* @__PURE__ */ new Set([
+    "assignee_hash",
+    "assignee_type",
+    "blocked_reason_code",
+    "created_at",
+    "key_wrappers",
+    "linked_project_ids",
+    "position",
+    "primary_chat_id",
+    "priority",
+    "status",
+    "task_id",
+    "updated_at",
+    "version"
+  ]);
+  for (const key of Object.keys(payload)) {
+    if (key.startsWith("encrypted_") || allowedSafeKeys.has(key)) {
+      continue;
+    }
+    throw new Error("Task update job payload contains plaintext or unsupported field");
+  }
+}
 async function buildSubChatEncryptedMetadataPayloads(params) {
   const createdAt = params.createdAt ?? Math.floor(Date.now() / 1e3);
   const payloads = [];
@@ -3313,11 +3796,11 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     let anonymousId = loadAnonymousId();
     if (!anonymousId) {
-      anonymousId = randomUUID3();
+      anonymousId = randomUUID4();
       saveAnonymousId(anonymousId);
     }
-    const chatId = `anonymous-${randomUUID3()}`;
-    const messageId = `anonymous-message-${randomUUID3()}`;
+    const chatId = `anonymous-${randomUUID4()}`;
+    const messageId = `anonymous-message-${randomUUID4()}`;
     const requestBody = {
       anonymous_id: anonymousId,
       client_chat_id: chatId,
@@ -3352,6 +3835,8 @@ var OpenMatesClient = class _OpenMatesClient {
       modelName: response.data.modelName ?? null,
       mateName: null,
       followUpSuggestions: response.data.followUpSuggestions ?? [],
+      taskProposals: [],
+      taskUpdateProposals: [],
       subChatEvents: [],
       appSettingsMemoryRequests: []
     };
@@ -3509,7 +3994,7 @@ var OpenMatesClient = class _OpenMatesClient {
       pin: pin.trim().toUpperCase(),
       token
     });
-    const sessionId = randomUUID3();
+    const sessionId = randomUUID4();
     const login = await this.http.post(
       "/v1/auth/login",
       {
@@ -3684,7 +4169,7 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     const session = {
       apiUrl: this.apiUrl,
-      sessionId: randomUUID3(),
+      sessionId: randomUUID4(),
       wsToken: null,
       cookies: this.http.getCookieMap(),
       masterKeyExportedB64: material.masterKeyB64,
@@ -3844,7 +4329,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (!markdown) throw new Error("Draft markdown must not be empty.");
     const masterKey = this.getMasterKeyBytes();
     const encrypted = await this.saveEncryptedDraft({
-      chatId: params.chatId ?? randomUUID3(),
+      chatId: params.chatId ?? randomUUID4(),
       encryptedDraftMd: await encryptWithAesGcmCombined(markdown, masterKey),
       encryptedDraftPreview: params.preview ? await encryptWithAesGcmCombined(params.preview, masterKey) : null
     });
@@ -4400,7 +4885,7 @@ var OpenMatesClient = class _OpenMatesClient {
   async sendMessage(params) {
     let chatId;
     if (!params.chatId) {
-      chatId = randomUUID3();
+      chatId = randomUUID4();
     } else if (params.chatId.length < 36) {
       const resolved = await this.resolveFullChatId(params.chatId);
       if (!resolved) {
@@ -4434,7 +4919,7 @@ var OpenMatesClient = class _OpenMatesClient {
       ws.close();
       throw new Error("Authenticated user identity is required for saved chat recovery.");
     }
-    const messageId = randomUUID3();
+    const messageId = randomUUID4();
     const createdAt = Math.floor(Date.now() / 1e3);
     const isNewChat = !params.chatId;
     ws.send("set_active_chat", { chat_id: chatId });
@@ -4451,6 +4936,7 @@ var OpenMatesClient = class _OpenMatesClient {
     let chatKeyBytes = null;
     let encryptedChatKey = null;
     let baselineMessagesV = 0;
+    let terminalExpectedMessagesV = 1;
     let savedTurnId = null;
     if (!params.incognito) {
       const masterKey = this.getMasterKeyBytes();
@@ -4484,6 +4970,7 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     const messagePayload = {
       chat_id: chatId,
+      client_capabilities: ["task_update_jobs"],
       is_incognito: Boolean(params.incognito),
       message: {
         message_id: messageId,
@@ -4567,12 +5054,13 @@ var OpenMatesClient = class _OpenMatesClient {
     if (encryptedEmbeds.length > 0) {
       messagePayload.encrypted_embeds = encryptedEmbeds;
     }
-    let precollectedResponse = params.precollectResponse && params.incognito ? ws.collectAiResponse(messageId, chatId, { onStream: params.onStream }) : null;
+    let precollectedResponse = params.precollectResponse && params.incognito ? ws.collectAiResponse(messageId, chatId, { onStream: params.onStream, timeoutMs: params.responseTimeoutMs }) : null;
     if (!params.incognito && chatKeyBytes && encryptedChatKey) {
       const protocolVersion = 1;
       const chatKeyVersion = 1;
-      const turnId = randomUUID3();
+      const turnId = randomUUID4();
       savedTurnId = turnId;
+      terminalExpectedMessagesV = baselineMessagesV + 1;
       const recoveryKeypair = await deriveChatCompletionRecoveryKeypair(
         Buffer.from(chatKeyBytes).toString("base64url"),
         chatId,
@@ -4638,10 +5126,15 @@ var OpenMatesClient = class _OpenMatesClient {
         protocol_version: protocolVersion,
         preflight_id: ackPayload.preflight_id
       });
+      if (typeof ackPayload.committed_messages_v === "number" && Number.isSafeInteger(ackPayload.committed_messages_v)) {
+        terminalExpectedMessagesV = ackPayload.committed_messages_v;
+      }
     }
     if (params.precollectResponse && !params.incognito) {
       precollectedResponse = ws.collectAiResponse(messageId, chatId, {
-        onStream: params.onStream
+        onStream: params.onStream,
+        timeoutMs: params.responseTimeoutMs,
+        recoveryTurnId: savedTurnId
       });
     }
     const confirmed = ws.waitForMessage(
@@ -4653,12 +5146,19 @@ var OpenMatesClient = class _OpenMatesClient {
       2e4
     );
     await ws.sendAsync("chat_message_added", messagePayload);
-    await confirmed;
+    const confirmedPayload = (await confirmed).payload;
+    if (typeof confirmedPayload.new_messages_v === "number" && Number.isSafeInteger(confirmedPayload.new_messages_v)) {
+      terminalExpectedMessagesV = confirmedPayload.new_messages_v + 1;
+    }
     let assistant = "";
     let assistantMessageId = null;
     let category = null;
     let modelName = null;
     let followUpSuggestions = [];
+    let taskProposals = [];
+    let taskUpdateProposals = [];
+    let taskEvents = [];
+    let pendingTaskUpdateJobs = [];
     let subChatEvents = [];
     const appSettingsMemoryRequests = [];
     const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -4821,6 +5321,225 @@ var OpenMatesClient = class _OpenMatesClient {
         `The assistant requested memories (${event.requestedKeys.join(", ")}). Rerun with --auto-approve-memories to explicitly approve requested memory categories from the CLI, or continue this chat in the web app to approve or reject the request.`
       );
     };
+    const persistEncryptedSystemMessage = async (systemMessage, targetChatId = chatId) => {
+      await ws.sendAsync("chat_system_message_added", {
+        chat_id: targetChatId,
+        message: systemMessage
+      });
+      await ws.waitForMessage(
+        "system_message_confirmed",
+        (payload) => payload.message_id === systemMessage.message_id,
+        2e4
+      );
+    };
+    const persistedTaskEventIds = /* @__PURE__ */ new Set();
+    const persistTaskEventSystemMessages = async (events) => {
+      if (!chatKeyBytes || events.length === 0) return;
+      for (const event of events) {
+        if (persistedTaskEventIds.has(event.event_id)) continue;
+        await persistEncryptedSystemMessage(await buildTaskEventSystemMessage({
+          chatKey: chatKeyBytes,
+          userMessageId: messageId,
+          event
+        }));
+        persistedTaskEventIds.add(event.event_id);
+      }
+    };
+    const persistPendingTaskUpdateJobs = async (jobs, events) => {
+      const handledJobIds = /* @__PURE__ */ new Set();
+      if (jobs.length === 0) return handledJobIds;
+      const masterKey = this.getMasterKeyBytes();
+      let decryptedTasksCache = null;
+      const eventByJobId = new Map(events.map((event) => [event.task_update_job_id, event]));
+      const buildTaskKeyWrappersForChat = async (task, targetChatId, createdAt2) => {
+        const encryptedTaskKey = task.encrypted.encrypted_task_key;
+        if (!encryptedTaskKey) throw new Error(`Task ${task.taskId} is missing encrypted task key.`);
+        const taskKey = await decryptBytesWithAesGcm(encryptedTaskKey, masterKey);
+        if (!taskKey) throw new Error(`Failed to decrypt task key for ${task.taskId}.`);
+        const targetChatKey = await resolveChatKey(targetChatId);
+        const existingProjectWrappers = await listProjectTaskKeyWrappers(task.taskId, createdAt2);
+        const linkedProjectIds = task.linkedProjectIds ?? [];
+        if (linkedProjectIds.length > existingProjectWrappers.length) {
+          throw new Error(`Task ${task.taskId} is missing project key wrappers required for move persistence.`);
+        }
+        return [
+          {
+            key_type: "master",
+            encrypted_task_key: await encryptBytesWithAesGcm(taskKey, masterKey),
+            created_at: createdAt2
+          },
+          {
+            key_type: "chat",
+            hashed_chat_id: computeSHA256(targetChatId),
+            encrypted_task_key: await encryptBytesWithAesGcm(taskKey, targetChatKey),
+            created_at: createdAt2
+          },
+          ...existingProjectWrappers
+        ];
+      };
+      const listProjectTaskKeyWrappers = async (taskId, createdAt2) => {
+        const response = await this.http.get(
+          `/v1/user-tasks/${encodeURIComponent(taskId)}/key-wrappers`,
+          this.getCliRequestHeaders()
+        );
+        if (!response.ok) {
+          throw new Error(`User task key wrapper list failed with HTTP ${response.status}`);
+        }
+        return (response.data.key_wrappers ?? []).filter((wrapper) => wrapper.key_type === "project").map((wrapper) => ({
+          key_type: "project",
+          hashed_project_id: wrapper.hashed_project_id,
+          encrypted_task_key: wrapper.encrypted_task_key,
+          created_at: typeof wrapper.created_at === "number" ? wrapper.created_at : createdAt2,
+          expires_at: wrapper.expires_at ?? null
+        }));
+      };
+      const resolveChatKey = async (targetChatId) => {
+        if (targetChatId === chatId && chatKeyBytes) return chatKeyBytes;
+        const cache = loadSyncCache() ?? await this.ensureSynced();
+        const targetChat = cache.chats.find((chat) => String(chat.details.id ?? "") === targetChatId);
+        const encryptedTargetChatKey = typeof targetChat?.details.encrypted_chat_key === "string" ? targetChat.details.encrypted_chat_key : null;
+        if (!encryptedTargetChatKey) {
+          throw new Error(`Encrypted chat key not found for task move target '${targetChatId}'. Sync and try again.`);
+        }
+        const targetChatKey = await decryptBytesWithAesGcm(encryptedTargetChatKey, masterKey);
+        if (!targetChatKey) {
+          throw new Error(`Failed to decrypt chat key for task move target '${targetChatId}'.`);
+        }
+        return targetChatKey;
+      };
+      const taskEventTypeForOperation = (operation) => {
+        switch (operation) {
+          case "create":
+            return "created";
+          case "move":
+            return "moved";
+          case "update":
+            return "updated";
+          default:
+            return operation || "updated";
+        }
+      };
+      for (const job of jobs) {
+        if (!taskUpdateJobBelongsToActiveTurn(job, chatId, events)) {
+          handledJobIds.add(job.job_id);
+          continue;
+        }
+        const claimPromise = ws.waitForMessage(
+          "task_update_job_claimed",
+          (payload) => payload.job_id === job.job_id,
+          2e4
+        );
+        await ws.sendAsync("task_update_job_claim", {
+          protocol_version: 1,
+          job_id: job.job_id
+        });
+        const claim = (await claimPromise).payload;
+        const privatePatch = claim.private_patch ?? {};
+        const safeMetadata = claim.safe_metadata ?? {};
+        const sourceChatId = claim.chat_id ?? job.chat_id ?? chatId;
+        const sourceChatKey = await resolveChatKey(sourceChatId);
+        const event = eventByJobId.get(job.job_id) ?? {
+          event_id: `task-event-${job.job_id}`,
+          chat_id: sourceChatId,
+          task_id: claim.task_id,
+          event_type: taskEventTypeForOperation(claim.operation),
+          title: typeof privatePatch.title === "string" ? privatePatch.title : null,
+          status: typeof safeMetadata.status === "string" ? safeMetadata.status : null,
+          created_at: typeof safeMetadata.updated_at === "number" ? safeMetadata.updated_at : Math.floor(Date.now() / 1e3),
+          task_update_job_id: job.job_id
+        };
+        const eventMessage = await buildTaskEventSystemMessage({
+          chatKey: sourceChatKey,
+          userMessageId: claim.message_id ?? messageId,
+          event
+        });
+        const confirmTaskEventPersisted = async () => {
+          const confirmedPromise = ws.waitForMessage(
+            "task_update_job_event_confirmed",
+            (payload) => payload.job_id === job.job_id,
+            2e4
+          );
+          await ws.sendAsync("task_update_job_event_confirmed", {
+            protocol_version: 1,
+            job_id: job.job_id,
+            event_system_message_id: eventMessage.message_id
+          });
+          await confirmedPromise;
+        };
+        if (claim.state === "TASK_PERSISTED") {
+          await persistEncryptedSystemMessage(eventMessage, sourceChatId);
+          persistedTaskEventIds.add(event.event_id);
+          await confirmTaskEventPersisted();
+          handledJobIds.add(job.job_id);
+          continue;
+        }
+        if (!claim.lease_token || !Number.isSafeInteger(claim.lease_generation)) {
+          throw new Error("Task update job claim returned an invalid lease.");
+        }
+        let encryptedTaskPayload;
+        if (claim.operation === "create") {
+          const input = await buildCreateUserTaskInput(masterKey, {
+            title: typeof privatePatch.title === "string" ? privatePatch.title : "Untitled task",
+            description: typeof privatePatch.description === "string" ? privatePatch.description : "",
+            status: typeof safeMetadata.status === "string" ? safeMetadata.status : "todo",
+            assign: typeof safeMetadata.assignee_type === "string" ? safeMetadata.assignee_type : "user",
+            chatId: typeof safeMetadata.primary_chat_id === "string" ? safeMetadata.primary_chat_id : claim.chat_id ?? chatId
+          });
+          encryptedTaskPayload = {
+            ...input,
+            task_id: claim.task_id,
+            position: typeof safeMetadata.position === "number" ? safeMetadata.position : input.position,
+            created_at: typeof safeMetadata.created_at === "number" ? safeMetadata.created_at : input.created_at,
+            updated_at: typeof safeMetadata.updated_at === "number" ? safeMetadata.updated_at : input.updated_at
+          };
+        } else {
+          if (!decryptedTasksCache) {
+            decryptedTasksCache = await decryptUserTasks(await this.listUserTasks(), masterKey);
+          }
+          const task = findTask(decryptedTasksCache, claim.task_id);
+          const patch = await buildUpdateUserTaskInput(task, masterKey, {
+            title: typeof privatePatch.title === "string" ? privatePatch.title : void 0,
+            description: typeof privatePatch.description === "string" ? privatePatch.description : void 0,
+            status: typeof safeMetadata.status === "string" ? safeMetadata.status : void 0,
+            assign: typeof safeMetadata.assignee_type === "string" ? safeMetadata.assignee_type : void 0,
+            chatId: typeof safeMetadata.primary_chat_id === "string" ? safeMetadata.primary_chat_id : void 0
+          });
+          encryptedTaskPayload = {
+            ...patch,
+            version: claim.expected_task_version,
+            updated_at: typeof safeMetadata.updated_at === "number" ? safeMetadata.updated_at : patch.updated_at
+          };
+          if (typeof safeMetadata.primary_chat_id === "string") {
+            encryptedTaskPayload.key_wrappers = await buildTaskKeyWrappersForChat(
+              task,
+              safeMetadata.primary_chat_id,
+              typeof safeMetadata.updated_at === "number" ? safeMetadata.updated_at : Math.floor(Date.now() / 1e3)
+            );
+          }
+        }
+        const encryptedEventMessage = eventMessage.encrypted_content;
+        const persistedPromise = ws.waitForMessage(
+          "task_update_job_persisted",
+          (payload) => payload.job_id === job.job_id,
+          2e4
+        );
+        await ws.sendAsync("task_update_job_persist", buildTaskUpdateJobPersistPayload({
+          jobId: job.job_id,
+          leaseToken: claim.lease_token,
+          leaseGeneration: claim.lease_generation,
+          expectedTaskVersion: claim.expected_task_version,
+          encryptedTaskPayload,
+          encryptedTaskEventMessage: encryptedEventMessage
+        }));
+        await persistedPromise;
+        await persistEncryptedSystemMessage(eventMessage, sourceChatId);
+        persistedTaskEventIds.add(event.event_id);
+        await confirmTaskEventPersisted();
+        handledJobIds.add(job.job_id);
+      }
+      clearSyncCache();
+      return handledJobIds;
+    };
     const streamOpts = {
       onStream: params.onStream,
       onSubChatEvent: handleSubChatEvent,
@@ -4828,11 +5547,17 @@ var OpenMatesClient = class _OpenMatesClient {
     };
     if (params.incognito) {
       try {
-        const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId, chatId, streamOpts));
+        const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId, chatId, {
+          ...streamOpts,
+          timeoutMs: params.responseTimeoutMs,
+          recoveryTurnId: savedTurnId
+        }));
         assistantMessageId = resp.messageId;
         assistant = resp.content;
         category = resp.category;
         modelName = resp.modelName;
+        taskEvents = resp.taskEvents;
+        pendingTaskUpdateJobs = resp.pendingTaskUpdateJobs;
         subChatEvents = resp.subChatEvents;
         if (resp.status === "waiting_for_user") {
           return {
@@ -4844,6 +5569,10 @@ var OpenMatesClient = class _OpenMatesClient {
             modelName,
             mateName: category ? MATE_NAMES[category] ?? null : null,
             followUpSuggestions,
+            taskProposals,
+            taskUpdateProposals,
+            taskEvents,
+            pendingTaskUpdateJobs,
             subChatEvents,
             appSettingsMemoryRequests
           };
@@ -4853,12 +5582,19 @@ var OpenMatesClient = class _OpenMatesClient {
       }
     } else {
       try {
-        const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId, chatId, streamOpts));
+        const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId, chatId, {
+          ...streamOpts,
+          timeoutMs: params.responseTimeoutMs
+        }));
         assistantMessageId = resp.messageId;
         assistant = resp.content;
         category = resp.category;
         modelName = resp.modelName;
         followUpSuggestions = resp.followUpSuggestions;
+        taskProposals = resp.taskProposals;
+        taskUpdateProposals = resp.taskUpdateProposals;
+        taskEvents = resp.taskEvents;
+        pendingTaskUpdateJobs = resp.pendingTaskUpdateJobs;
         subChatEvents = resp.subChatEvents;
         if (resp.status === "waiting_for_user") {
           return {
@@ -4870,6 +5606,10 @@ var OpenMatesClient = class _OpenMatesClient {
             modelName,
             mateName: category ? MATE_NAMES[category] ?? null : null,
             followUpSuggestions,
+            taskProposals,
+            taskUpdateProposals,
+            taskEvents,
+            pendingTaskUpdateJobs,
             subChatEvents,
             appSettingsMemoryRequests
           };
@@ -4935,12 +5675,15 @@ var OpenMatesClient = class _OpenMatesClient {
             "model_name",
             "turn_id"
           ];
-          if (Object.keys(recovered).sort().join(",") !== expectedRecoveryFields.join(",") || recovered.assistant_message_id !== assistantId || recovered.chat_id !== chatId || recovered.turn_id !== savedTurnId || recovered.job_id !== recoveryJobId || recovered.key_version !== keyVersion || typeof recovered.content !== "string" || recovered.category !== null && typeof recovered.category !== "string" || recovered.model_name !== null && typeof recovered.model_name !== "string" || recovered.content !== assistant || recovered.category !== category || recovered.model_name !== modelName) {
+          if (Object.keys(recovered).sort().join(",") !== expectedRecoveryFields.join(",") || recovered.assistant_message_id !== assistantId || recovered.chat_id !== chatId || recovered.turn_id !== savedTurnId || recovered.job_id !== recoveryJobId || recovered.key_version !== keyVersion || typeof recovered.content !== "string" || recovered.category !== null && typeof recovered.category !== "string" || recovered.model_name !== null && typeof recovered.model_name !== "string") {
             throw new Error("Recovery job plaintext did not match the terminal completion identity.");
           }
+          assistant = recovered.content;
+          category = recovered.category;
+          modelName = recovered.model_name;
           const completedAt = Math.floor(Date.now() / 1e3);
           const encryptedAssistantContent = await encryptWithAesGcmCombined(
-            recovered.content,
+            assistant,
             chatKeyBytes
           );
           const encryptedSenderName = await encryptWithAesGcmCombined("Assistant", chatKeyBytes);
@@ -4956,7 +5699,7 @@ var OpenMatesClient = class _OpenMatesClient {
             job_id: recoveryJobId,
             lease_token: leaseToken,
             lease_generation: leaseGeneration,
-            expected_messages_v: baselineMessagesV + 1,
+            expected_messages_v: terminalExpectedMessagesV,
             encrypted_assistant_message: {
               client_message_id: assistantId,
               chat_id: chatId,
@@ -4987,6 +5730,9 @@ var OpenMatesClient = class _OpenMatesClient {
             newChatSuggestions: resp.newChatSuggestions,
             encryptedChatKey
           });
+          const persistedTaskJobIds = await persistPendingTaskUpdateJobs(pendingTaskUpdateJobs, taskEvents);
+          pendingTaskUpdateJobs = pendingTaskUpdateJobs.filter((job) => !persistedTaskJobIds.has(job.job_id));
+          await persistTaskEventSystemMessages(taskEvents);
           clearSyncCache();
         }
       } finally {
@@ -5003,6 +5749,10 @@ var OpenMatesClient = class _OpenMatesClient {
       modelName,
       mateName,
       followUpSuggestions,
+      taskProposals,
+      taskUpdateProposals,
+      taskEvents,
+      pendingTaskUpdateJobs,
       subChatEvents,
       appSettingsMemoryRequests
     };
@@ -5935,6 +6685,22 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return response.data.task;
   }
+  async extractUserTaskProposals(input) {
+    const response = await this.http.post(
+      "/v1/user-tasks/extract",
+      {
+        corrected_text: input.correctedText,
+        mode: input.mode ?? "create",
+        context_chat_id: input.contextChatId ?? null,
+        project_ids: input.projectIds ?? []
+      },
+      this.getCliRequestHeaders()
+    );
+    if (!response.ok || !Array.isArray(response.data.proposed_tasks)) {
+      throw new Error(`Failed to extract task proposals (HTTP ${response.status})`);
+    }
+    return response.data.proposed_tasks;
+  }
   async updateUserTask(taskId, input) {
     this.requireSession();
     const response = await this.http.patch(
@@ -5947,7 +6713,7 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return response.data.task;
   }
-  async startUserTaskWithAI(taskId, input = {}) {
+  async startUserTaskWithAI(taskId, input) {
     this.requireSession();
     const response = await this.http.post(
       `/v1/user-tasks/${encodeURIComponent(taskId)}/start-ai`,
@@ -5959,10 +6725,10 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return response.data.task;
   }
-  async deleteUserTask(taskId) {
+  async deleteUserTask(taskId, version) {
     this.requireSession();
     const response = await this.http.delete(
-      `/v1/user-tasks/${encodeURIComponent(taskId)}`,
+      `/v1/user-tasks/${encodeURIComponent(taskId)}?version=${encodeURIComponent(String(version))}`,
       void 0,
       this.getCliRequestHeaders()
     );
@@ -5971,16 +6737,16 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return response.data;
   }
-  async completeUserTask(taskId, input = {}) {
+  async completeUserTask(taskId, input) {
     return this.postUserTaskAction(taskId, "complete", input);
   }
-  async blockUserTask(taskId, input = {}) {
+  async blockUserTask(taskId, input) {
     return this.postUserTaskAction(taskId, "block", input);
   }
-  async unblockUserTask(taskId, input = {}) {
+  async unblockUserTask(taskId, input) {
     return this.postUserTaskAction(taskId, "unblock", input);
   }
-  async skipUserTask(taskId, input = {}) {
+  async skipUserTask(taskId, input) {
     return this.postUserTaskAction(taskId, "skip", input);
   }
   async reorderUserTasks(input) {
@@ -5995,7 +6761,7 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return response.data.tasks ?? [];
   }
-  async postUserTaskAction(taskId, action, input = {}) {
+  async postUserTaskAction(taskId, action, input) {
     this.requireSession();
     const response = await this.http.post(
       `/v1/user-tasks/${encodeURIComponent(taskId)}/${encodeURIComponent(action)}`,
@@ -6753,7 +7519,7 @@ Required: ${schema.required.join(", ")}`
         );
       }
     }
-    const entryId = params.entryId ?? randomUUID3();
+    const entryId = params.entryId ?? randomUUID4();
     const now = Math.floor(Date.now() / 1e3);
     const hashedKey = hashItemKey(params.appId, params.itemType);
     const plaintextPayload = {
@@ -7228,7 +7994,7 @@ Required: ${schema.required.join(", ")}`
   makeWsClient(session) {
     return new OpenMatesWsClient({
       apiUrl: session.apiUrl,
-      sessionId: randomUUID3(),
+      sessionId: randomUUID4(),
       wsToken: session.wsToken,
       refreshToken: session.cookies.auth_refresh_token ?? null,
       // Same User-Agent as login so OS-based device fingerprint hash matches.
@@ -8411,7 +9177,7 @@ var OutputRedactor = class {
 import { readFileSync as readFileSync4, statSync, existsSync as existsSync4 } from "fs";
 import { basename, extname, resolve as resolve2 } from "path";
 import { homedir as homedir4 } from "os";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 var MAX_PER_FILE_SIZE = 100 * 1024 * 1024;
 var BLOCKED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".pem",
@@ -8721,7 +9487,7 @@ function processCodeFile(filePath, filename, redactor) {
       line_count: lineCount
     });
     const textPreview = `${filename} (${language}, ${lineCount} lines)`;
-    const contentHash = createHash5("sha256").update(content).digest("hex");
+    const contentHash = createHash6("sha256").update(content).digest("hex");
     const embed = {
       embedId,
       embedRef,
@@ -10237,7 +11003,7 @@ function formatTs(ts) {
 
 // src/server.ts
 import { execFileSync as execFileSync2, execSync, spawn as nodeSpawn, spawnSync } from "child_process";
-import { createHash as createHash6, randomBytes as randomBytes2 } from "crypto";
+import { createHash as createHash7, randomBytes as randomBytes3 } from "crypto";
 import { chmodSync as chmodSync2, closeSync, copyFileSync, cpSync, existsSync as existsSync5, mkdirSync as mkdirSync3, mkdtempSync, openSync, readFileSync as readFileSync5, readSync, readdirSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { createInterface as createInterface2 } from "readline";
 import { createInterface as createPromptInterface } from "readline/promises";
@@ -10855,10 +11621,10 @@ function resolveTargetImageTag(flags, currentTag, packageVersion) {
   return { tag: getDefaultImageTagForVersion(packageVersion) };
 }
 function randomHex(bytes) {
-  return randomBytes2(bytes).toString("hex");
+  return randomBytes3(bytes).toString("hex");
 }
 function generateInviteCode() {
-  const digits = Array.from(randomBytes2(12), (byte) => String(byte % 10)).join("");
+  const digits = Array.from(randomBytes3(12), (byte) => String(byte % 10)).join("");
   return `${digits.slice(0, 4)}-${digits.slice(4, 8)}-${digits.slice(8, 12)}`;
 }
 function getEnvVar(content, name) {
@@ -10902,7 +11668,7 @@ function packagedCaddyTemplatePath(role) {
 }
 function fileHash(path) {
   if (!existsSync5(path)) return null;
-  return createHash6("sha256").update(readFileSync5(path)).digest("hex");
+  return createHash7("sha256").update(readFileSync5(path)).digest("hex");
 }
 async function loadSelfHostComposeTemplate(templateRef, role) {
   const templateDir = process.env.OPENMATES_SELFHOST_TEMPLATE_DIR;
@@ -11288,7 +12054,7 @@ function formatSecretPreflight(preflight) {
   return parts.join("; ");
 }
 function hashFile(path) {
-  const hash = createHash6("sha256");
+  const hash = createHash7("sha256");
   const fd = openSync(path, "r");
   const buffer = Buffer.allocUnsafe(CHECKSUM_BUFFER_BYTES);
   try {
@@ -29309,7 +30075,10 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     },
     models3d: {
       generate: {
-        text: "Generate 3D model"
+        text: "Generate 3D model",
+        description: {
+          text: "Create a 3D model from a text prompt or reference images."
+        }
       }
     },
     music: {
@@ -30164,6 +30933,12 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
         text: "Create structured idea maps and brainstorm topic trees."
       }
     },
+    models3d: {
+      text: "3D Models",
+      description: {
+        text: "Generate 3D models from prompts or reference images."
+      }
+    },
     math: {
       text: "Math",
       description: {
@@ -46676,7 +47451,7 @@ function buildAssistantFeedbackDecision(rating) {
 }
 
 // src/benchmark.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { existsSync as existsSync6, mkdtempSync as mkdtempSync2, readFileSync as readFileSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
 import { tmpdir } from "os";
 import { dirname as dirname2, join as join4, resolve as resolve5 } from "path";
@@ -46976,7 +47751,7 @@ async function handleBenchmark(client, subcommand, rest, flags) {
   const caseIds = parseCaseIds(flags.case);
   const dryRun = flags["dry-run"] === true;
   const output = typeof flags.output === "string" ? flags.output : void 0;
-  const runId = typeof flags["run-id"] === "string" ? flags["run-id"] : randomUUID4();
+  const runId = typeof flags["run-id"] === "string" ? flags["run-id"] : randomUUID5();
   const imagePath = typeof flags.image === "string" ? resolve5(flags.image) : defaultImageFixturePath();
   if (!dryRun && flags["confirm-spend-credits"] !== true) {
     throw new Error(
@@ -47386,7 +48161,7 @@ function buildLongContextHistory() {
 }
 function appendHistory(history, role, content) {
   history.push({
-    message_id: randomUUID4(),
+    message_id: randomUUID5(),
     role,
     sender_name: role === "user" ? "User" : "Assistant",
     content,
@@ -47921,7 +48696,7 @@ function renderBody(state, width) {
     case "tasks":
       return renderTasks(state, width);
     case "task":
-      return renderTaskDetail(state, width);
+      return renderTaskDetail2(state, width);
     case "start":
     default:
       return renderStart(width);
@@ -47994,7 +48769,7 @@ function renderTasks(state, width) {
   }
   return lines.flatMap((line) => wrap(line, width));
 }
-function renderTaskDetail(state, width) {
+function renderTaskDetail2(state, width) {
   const task = state.activeTask;
   if (!task) return renderTasks(state, width);
   const assignee = task.assigneeType === "ai" ? "OpenMates" : task.assigneeHash ?? "user";
@@ -48311,221 +49086,6 @@ function boxed(line, width) {
   return `\u2502 ${line.padEnd(width)} \u2502`;
 }
 
-// src/tasksCli.ts
-import { createHash as createHash7, randomBytes as randomBytes3, randomUUID as randomUUID5 } from "crypto";
-var TASK_STATUSES = ["backlog", "todo", "in_progress", "blocked", "done"];
-var DEFAULT_STANDALONE_PREFIX = "TASK";
-function normalizeTaskStatus(value) {
-  if (value === void 0) return void 0;
-  if (TASK_STATUSES.includes(value)) return value;
-  throw new Error(`Unknown task status '${value}'. Expected one of: ${TASK_STATUSES.join(", ")}`);
-}
-function parseAssignee(value) {
-  if (!value || value === "user") return { assigneeType: "user", assigneeHash: null };
-  if (["ai", "openmates", "OpenMates"].includes(value)) return { assigneeType: "ai", assigneeHash: null };
-  return { assigneeType: "user", assigneeHash: value };
-}
-function splitCsvFlag(value) {
-  if (typeof value !== "string") return [];
-  return value.split(/[,\n]/).map((item) => item.trim()).filter(Boolean);
-}
-function parseDueAt(value) {
-  if (value === void 0) return void 0;
-  if (value === false || value === true) throw new Error("--due requires a timestamp or date value.");
-  const numeric = Number(value);
-  if (Number.isFinite(numeric) && numeric > 0) return Math.floor(numeric);
-  const parsed = Date.parse(value);
-  if (Number.isNaN(parsed)) throw new Error(`Invalid --due value '${value}'.`);
-  return Math.floor(parsed / 1e3);
-}
-async function buildCreateUserTaskInput(masterKey, input) {
-  const taskKey = randomBytes3(32);
-  const encryptedTaskKey = await encryptBytesWithAesGcm(taskKey, masterKey);
-  const timestamp = nowSeconds();
-  const assignee = parseAssignee(input.assign);
-  const linkedProjectIds = input.projectIds ?? [];
-  const status = input.status ?? (assignee.assigneeType === "ai" && !input.dueAt ? "in_progress" : "todo");
-  return {
-    task_id: randomUUIDCompat(),
-    short_id: void 0,
-    encrypted_task_key: encryptedTaskKey,
-    encrypted_title: await encryptWithAesGcmCombined(input.title, taskKey),
-    encrypted_description: await encryptWithAesGcmCombined(input.description ?? "", taskKey),
-    encrypted_tags: await encryptWithAesGcmCombined("[]", taskKey),
-    encrypted_linked_project_ids: await encryptWithAesGcmCombined(JSON.stringify(linkedProjectIds), taskKey),
-    status,
-    assignee_type: assignee.assigneeType,
-    assignee_hash: assignee.assigneeHash,
-    primary_chat_id: input.chatId ?? null,
-    linked_project_ids: linkedProjectIds,
-    plan_id: input.planId ?? null,
-    due_at: input.dueAt ?? null,
-    priority: 0,
-    position: timestamp,
-    created_at: timestamp,
-    updated_at: timestamp
-  };
-}
-async function buildUpdateUserTaskInput(task, masterKey, input) {
-  const taskKey = await taskKeyFromRecord(task.encrypted, masterKey);
-  const patch = { version: task.version, updated_at: nowSeconds() };
-  if (input.title !== void 0) patch.encrypted_title = await encryptWithAesGcmCombined(input.title, taskKey);
-  if (input.description !== void 0) patch.encrypted_description = await encryptWithAesGcmCombined(input.description, taskKey);
-  if (input.status !== void 0) patch.status = input.status;
-  if (input.assign !== void 0) {
-    const assignee = parseAssignee(input.assign);
-    patch.assignee_type = assignee.assigneeType;
-    patch.assignee_hash = assignee.assigneeHash;
-  }
-  if (input.chatId !== void 0) patch.primary_chat_id = input.chatId;
-  if (input.projectIds !== void 0) {
-    patch.linked_project_ids = input.projectIds;
-    patch.encrypted_linked_project_ids = await encryptWithAesGcmCombined(JSON.stringify(input.projectIds), taskKey);
-  }
-  if (input.planId !== void 0) patch.plan_id = input.planId;
-  return patch;
-}
-async function decryptUserTask(record, masterKey) {
-  const taskKey = await taskKeyFromRecord(record, masterKey);
-  const tags = parseStringArray(await decryptOptional(record.encrypted_tags, taskKey));
-  const linkedProjectIds = parseStringArray(await decryptOptional(record.encrypted_linked_project_ids, taskKey));
-  return {
-    taskId: record.task_id,
-    shortId: record.short_id || deriveShortId(record),
-    title: await decryptOptional(record.encrypted_title, taskKey) || "(untitled task)",
-    description: await decryptOptional(record.encrypted_description, taskKey),
-    tags,
-    latestInstruction: await decryptOptional(record.encrypted_latest_instruction, taskKey),
-    status: record.status,
-    assigneeType: record.assignee_type,
-    assigneeHash: record.assignee_hash ?? null,
-    primaryChatId: record.primary_chat_id ?? null,
-    linkedProjectIds: linkedProjectIds.length > 0 ? linkedProjectIds : record.linked_project_ids ?? [],
-    planId: record.plan_id ?? null,
-    dueAt: record.due_at ?? null,
-    priority: record.priority ?? 0,
-    position: record.position ?? 0,
-    queueState: record.queue_state ?? "none",
-    blockedReasonCode: record.blocked_reason_code ?? null,
-    aiExecutionState: record.ai_execution_state ?? null,
-    version: record.version ?? 1,
-    encrypted: record
-  };
-}
-async function decryptUserTasks(records, masterKey) {
-  const output = [];
-  for (const record of records) output.push(await decryptUserTask(record, masterKey));
-  return output;
-}
-function findTask(tasks, id) {
-  const task = tasks.find((candidate) => candidate.taskId === id || candidate.shortId === id);
-  if (!task) throw new Error(`Task '${id}' was not found in the current task list.`);
-  return task;
-}
-function renderTaskList(tasks) {
-  if (tasks.length === 0) return "No tasks found.";
-  const lines = ["Tasks", "ID        Status       Assignee    Queue       Title"];
-  for (const task of tasks) {
-    lines.push(`${pad(task.shortId, 9)} ${pad(task.status, 12)} ${pad(assigneeLabel(task), 11)} ${pad(task.queueState, 11)} ${task.title}`);
-  }
-  return lines.join("\n");
-}
-function renderTaskDetail2(task) {
-  const lines = [
-    `Task ${task.shortId}`,
-    `Title: ${task.title}`,
-    `Status: ${task.status}`,
-    `Assignee: ${assigneeLabel(task)}`,
-    `Queue: ${task.queueState}`,
-    `Task ID: ${task.taskId}`
-  ];
-  if (task.description) lines.push(`Description: ${task.description}`);
-  if (task.primaryChatId) lines.push(`Chat: ${task.primaryChatId}`);
-  if (task.linkedProjectIds.length > 0) lines.push(`Projects: ${task.linkedProjectIds.join(", ")}`);
-  if (task.planId) lines.push(`Plan: ${task.planId}`);
-  if (task.blockedReasonCode) lines.push(`Blocked reason: ${task.blockedReasonCode}`);
-  if (task.aiExecutionState) lines.push(`AI state: ${task.aiExecutionState}`);
-  return lines.join("\n");
-}
-function renderTaskBoard(tasks, width = process.stdout.columns || 100) {
-  const columns = TASK_STATUSES.map((status) => ({ status, tasks: tasks.filter((task) => task.status === status).sort(compareTasks) }));
-  if (width < 96) {
-    const lines2 = ["OpenMates Tasks Board"];
-    for (const column of columns) {
-      lines2.push("", `${columnTitle(column.status)} (${column.tasks.length})`, "-".repeat(24));
-      lines2.push(...boardColumnLines(column.tasks, 8));
-    }
-    return lines2.join("\n");
-  }
-  const perColumn = 6;
-  const columnWidth = 22;
-  const lines = ["OpenMates Tasks Board", ""];
-  lines.push(columns.map((column) => pad(`${columnTitle(column.status)} (${column.tasks.length})`, columnWidth)).join("  "));
-  lines.push(columns.map(() => "-".repeat(columnWidth)).join("  "));
-  const renderedColumns = columns.map((column) => boardColumnLines(column.tasks, perColumn).map((line) => truncate(line, columnWidth)));
-  const maxRows = Math.max(...renderedColumns.map((column) => column.length));
-  for (let row = 0; row < maxRows; row += 1) {
-    lines.push(renderedColumns.map((column) => pad(column[row] ?? "", columnWidth)).join("  "));
-  }
-  return lines.join("\n");
-}
-function boardColumnLines(tasks, limit) {
-  if (tasks.length === 0) return ["No tasks here."];
-  const visible = tasks.slice(0, limit).flatMap((task) => [
-    `[${task.shortId}] ${task.title}`,
-    ` ${assigneeLabel(task)} ${task.queueState === "none" ? "" : task.queueState}`.trimEnd()
-  ]);
-  if (tasks.length > limit) visible.push(`... ${tasks.length - limit} more`);
-  return visible;
-}
-function compareTasks(a, b) {
-  return a.position - b.position || a.title.localeCompare(b.title);
-}
-function columnTitle(status) {
-  if (status === "in_progress") return "In progress";
-  return status.slice(0, 1).toUpperCase() + status.slice(1).replace("_", " ");
-}
-function assigneeLabel(task) {
-  return task.assigneeType === "ai" ? "OpenMates" : task.assigneeHash ?? "user";
-}
-async function taskKeyFromRecord(record, masterKey) {
-  if (!record.encrypted_task_key) throw new Error(`Task ${record.task_id} is missing encrypted task key.`);
-  const taskKey = await decryptBytesWithAesGcm(record.encrypted_task_key, masterKey);
-  if (!taskKey) throw new Error(`Failed to decrypt task key for ${record.task_id}.`);
-  return taskKey;
-}
-async function decryptOptional(value, key) {
-  if (!value) return "";
-  return await decryptWithAesGcmCombined(value, key) ?? "";
-}
-function parseStringArray(value) {
-  if (!value) return [];
-  try {
-    const parsed = JSON.parse(value);
-    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
-  } catch {
-    return [];
-  }
-}
-function deriveShortId(record) {
-  const prefix = record.short_id_prefix || DEFAULT_STANDALONE_PREFIX;
-  const source = record.task_id || `${record.created_at ?? ""}-${record.position ?? ""}`;
-  const digest = createHash7("sha256").update(source).digest("hex").slice(0, 4).toUpperCase();
-  return `${prefix}-${parseInt(digest, 16) % 1e4}`;
-}
-function nowSeconds() {
-  return Math.floor(Date.now() / 1e3);
-}
-function randomUUIDCompat() {
-  return randomUUID5();
-}
-function pad(value, length) {
-  return truncate(value, length).padEnd(length);
-}
-function truncate(value, length) {
-  return value.length <= length ? value : `${value.slice(0, Math.max(0, length - 3))}...`;
-}
-
 // src/tui.ts
 function defaultModeForStreams(input, output) {
   return input.isTTY === true && output.isTTY === true ? "tui" : "quickstart";
@@ -48959,7 +49519,7 @@ async function handleActiveTaskAction(params) {
         render();
         return;
       }
-      await client.deleteUserTask(task.taskId);
+      await client.deleteUserTask(task.taskId, task.version);
       state.tasks = state.tasks.filter((candidate) => candidate.taskId !== task.taskId);
       state.activeTask = null;
       state.selectedIndex = Math.min(state.selectedIndex, Math.max(0, state.tasks.length - 1));
@@ -48976,7 +49536,7 @@ async function handleActiveTaskAction(params) {
         render();
         return;
       }
-      const updated2 = await client.reorderUserTasks({ moves: [{ task_id: task.taskId, position }] });
+      const updated2 = await client.reorderUserTasks({ moves: [{ task_id: task.taskId, version: task.version, position }] });
       const [decrypted2] = await decryptUserTasks(updated2, client.getMasterKeyBytes());
       if (decrypted2) {
         replaceTask(state, decrypted2);
@@ -50068,7 +50628,7 @@ async function handleTasks(client, subcommand, rest, flags) {
   if (subcommand === "delete") {
     const task = await requiredResolvedTask(client, masterKey, rest[0], scope, "delete");
     if (flags.confirm !== true) throw new Error("Deleting a task requires --confirm.");
-    const result = await client.deleteUserTask(task.taskId);
+    const result = await client.deleteUserTask(task.taskId, task.version);
     if (flags.json === true) printJson2(result);
     else console.log(`Task deleted: ${task.shortId}`);
     return;
@@ -50099,7 +50659,7 @@ async function handleTasks(client, subcommand, rest, flags) {
   }
   if (subcommand === "reorder") {
     const task = await requiredResolvedTask(client, masterKey, rest[0], scope, "reorder");
-    const move = { task_id: task.taskId };
+    const move = { task_id: task.taskId, version: task.version };
     if (typeof flags.before === "string") move.before_task_id = (await resolveTask(client, masterKey, flags.before, scope)).taskId;
     if (typeof flags.after === "string") move.after_task_id = (await resolveTask(client, masterKey, flags.after, scope)).taskId;
     if (typeof flags.status === "string") move.status = normalizeTaskStatus(flags.status);
@@ -50134,7 +50694,7 @@ async function requiredResolvedTask(client, masterKey, id, scope, action) {
 }
 function printTaskOutput(task, flags) {
   if (flags.json === true) printJson2({ task: taskToJson(task) });
-  else console.log(renderTaskDetail2(task));
+  else console.log(renderTaskDetail(task));
 }
 function taskToJson(task) {
   return {
@@ -50239,6 +50799,10 @@ function parsePositiveIntegerFlag(value, flagName) {
   }
   return parsed;
 }
+function parseResponseTimeoutMs(flags) {
+  const seconds = parsePositiveIntegerFlag(flags["response-timeout-seconds"], "--response-timeout-seconds");
+  return seconds === void 0 ? void 0 : seconds * 1e3;
+}
 function parseRemoteAccessSourceType(value) {
   if (value === void 0) return "local_folder";
   if (value === "local_folder" || value === "local_git_repository") {
@@ -50380,7 +50944,9 @@ async function handleChats(client, subcommand, rest, flags, redactor) {
         json: flags.json === true,
         autoApproveSubChats: flags["auto-approve"] === true,
         autoApproveMemories: flags["auto-approve-memories"] === true,
+        acceptTaskProposals: flags["accept-task-proposals"] === true,
         piiDetection: flags["no-pii-detection"] !== true,
+        responseTimeoutMs: parseResponseTimeoutMs(flags),
         anonymousLearningMode: client.hasSession() ? void 0 : parseAnonymousLearningModeFlags(flags)
       },
       redactor
@@ -50455,7 +51021,9 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         json: flags.json === true,
         autoApproveSubChats: flags["auto-approve"] === true,
         autoApproveMemories: flags["auto-approve-memories"] === true,
-        piiDetection: flags["no-pii-detection"] !== true
+        acceptTaskProposals: flags["accept-task-proposals"] === true,
+        piiDetection: flags["no-pii-detection"] !== true,
+        responseTimeoutMs: parseResponseTimeoutMs(flags)
       },
       redactor
     );
@@ -50483,7 +51051,9 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         json: flags.json === true,
         autoApproveSubChats: flags["auto-approve"] === true,
         autoApproveMemories: flags["auto-approve-memories"] === true,
-        piiDetection: flags["no-pii-detection"] !== true
+        acceptTaskProposals: flags["accept-task-proposals"] === true,
+        piiDetection: flags["no-pii-detection"] !== true,
+        responseTimeoutMs: parseResponseTimeoutMs(flags)
       },
       redactor
     );
@@ -50504,7 +51074,8 @@ Run 'openmates chats show ` + chatId + "' to check if suggestions have been save
         json: flags.json === true,
         autoApproveSubChats: flags["auto-approve"] === true,
         autoApproveMemories: flags["auto-approve-memories"] === true,
-        piiDetection: flags["no-pii-detection"] !== true
+        piiDetection: flags["no-pii-detection"] !== true,
+        responseTimeoutMs: parseResponseTimeoutMs(flags)
       },
       redactor
     );
@@ -53891,7 +54462,7 @@ async function sendMessageStreaming(client, params, redactor) {
       process.stdout.write(`${result2.assistant}
 `);
     }
-    return result2;
+    return { ...result2, taskEvents: [], pendingTaskUpdateJobs: [], acceptedTaskProposals: [] };
   }
   const urlResult = prepareUrlEmbeds(finalMessage);
   finalMessage = urlResult.message;
@@ -53906,6 +54477,7 @@ async function sendMessageStreaming(client, params, redactor) {
     onSubChatApprovalRequest,
     autoApproveSubChats: params.autoApproveSubChats,
     autoApproveMemories: params.autoApproveMemories,
+    responseTimeoutMs: params.responseTimeoutMs,
     learningMode,
     preparedEmbeds: preparedEmbeds.length > 0 ? preparedEmbeds : void 0,
     piiMappings: piiResult.mappings.map((mapping) => ({
@@ -53915,6 +54487,9 @@ async function sendMessageStreaming(client, params, redactor) {
     }))
   });
   clearTyping();
+  const acceptedTaskProposals = params.acceptTaskProposals === true && result.status === "completed" ? await acceptChatTaskProposals(client, result.chatId, result.taskProposals, `${finalMessage}
+
+${result.assistant}`) : [];
   if (result.status === "waiting_for_user") {
     const question = parseInteractiveQuestionBlock(result.assistant);
     if (params.json && question) {
@@ -53930,7 +54505,7 @@ async function sendMessageStreaming(client, params, redactor) {
         "\x1B[33mOpenMates needs more input to continue.\x1B[0m\nContinue in the web app, or rerun with --json to inspect the structured waiting state.\n"
       );
     }
-    return result;
+    return { ...result, acceptedTaskProposals: [] };
   }
   if (!params.json) {
     if (!headerPrinted) {
@@ -53994,13 +54569,87 @@ async function sendMessageStreaming(client, params, redactor) {
       process.stdout.write(`${SEP}
 `);
     }
+    if (result.taskEvents.length > 0) {
+      process.stdout.write(`\x1B[2mTask updates:\x1B[0m
+`);
+      for (const event of result.taskEvents) {
+        process.stdout.write(`  \x1B[2m- ${formatTaskEvent(event)}\x1B[0m
+`);
+      }
+      process.stdout.write(`${SEP}
+`);
+    }
+    if (result.pendingTaskUpdateJobs.length > 0) {
+      const count = result.pendingTaskUpdateJobs.length;
+      process.stdout.write(
+        `\x1B[2mPending encrypted task update${count === 1 ? "" : "s"}: ${count}\x1B[0m
+${SEP}
+`
+      );
+    }
     process.stdout.write(
       `\x1B[2mContinue: openmates chats send --chat ${shortId} "your message"\x1B[0m
 \x1B[2mHistory:  openmates chats show ${shortId}\x1B[0m
 `
     );
   }
-  return result;
+  return { ...result, acceptedTaskProposals };
+}
+function formatTaskEvent(event) {
+  const taskLabel = event.short_id || event.task_id;
+  const title = event.title ? ` "${event.title}"` : "";
+  const status = event.status ? ` (${event.status})` : "";
+  const reason = event.reason ? `: ${event.reason}` : "";
+  switch (event.event_type) {
+    case "created":
+      return `${taskLabel} created${title}${status}`;
+    case "updated":
+      return `${taskLabel} updated${title}${status}`;
+    case "blocked":
+      return `${taskLabel} blocked${reason}`;
+    case "completed":
+      return `${taskLabel} completed${title}`;
+    case "unblocked":
+      return `${taskLabel} unblocked`;
+    default:
+      return `${taskLabel} ${event.event_type}${title}${status}${reason}`;
+  }
+}
+async function acceptChatTaskProposals(client, chatId, proposals, fallbackText) {
+  let proposalsToAccept = proposals;
+  if (proposalsToAccept.length === 0 && fallbackText.trim()) {
+    const extractionText = buildTaskProposalFallbackText(fallbackText);
+    proposalsToAccept = await client.extractUserTaskProposals({
+      correctedText: extractionText,
+      contextChatId: chatId
+    });
+  }
+  if (proposalsToAccept.length === 0) return [];
+  const masterKey = client.getMasterKeyBytes();
+  const accepted = [];
+  for (const proposal of proposalsToAccept) {
+    const input = await buildCreateUserTaskInput(masterKey, {
+      title: proposal.title,
+      description: proposal.description ?? "",
+      status: proposal.status,
+      assign: proposal.assignee_type ?? "user",
+      chatId
+    });
+    const created = await client.createUserTask(input);
+    const decrypted = await decryptUserTask(created, masterKey);
+    accepted.push(taskToJson(decrypted));
+  }
+  return accepted;
+}
+function buildTaskProposalFallbackText(text) {
+  const seen = /* @__PURE__ */ new Set();
+  const bulletLines = text.split("\n").map((line) => line.trim()).filter((line) => /^[-*•]\s+/.test(line)).map((line) => line.replace(/^([-*•]\s*)\[[ xX]\]\s*/, "$1")).filter((line) => {
+    const key = line.replace(/^[-*•]\s+/, "").trim().toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  return bulletLines.length > 0 ? bulletLines.join("\n") : text;
 }
 function printIncognitoNoHistoryNotice(json) {
   const message = "Incognito chats are not stored. There is no incognito history to show or clear.";
@@ -55401,10 +56050,10 @@ function printChatsHelp() {
   openmates chats show <chat-id> [--raw] [--json]
   openmates chats open [<n|example-id|slug>] [--json]
   openmates chats search <query> [--json]
-  openmates chats new <message> [--json] [--learning-mode --age-group <group>] [--auto-approve] [--auto-approve-memories] [--no-pii-detection]
-  openmates chats send [--chat <id>] [--incognito] <message> [--json] [--auto-approve] [--auto-approve-memories] [--no-pii-detection]
+  openmates chats new <message> [--json] [--learning-mode --age-group <group>] [--auto-approve] [--auto-approve-memories] [--accept-task-proposals] [--no-pii-detection]
+  openmates chats send [--chat <id>] [--incognito] <message> [--json] [--auto-approve] [--auto-approve-memories] [--accept-task-proposals] [--no-pii-detection]
   openmates chats send --chat <id> --followup <n> [--json] [--auto-approve] [--auto-approve-memories]
-  openmates chats answer-interactive --chat <id> --question-json '<json>' --answer-json '<json>' [--json]
+  openmates chats answer-interactive --chat <id> --question-json '<json>' --answer-json '<json>' [--json] [--accept-task-proposals]
   openmates chats download <chat-id> [--output <path>] [--zip] [--json]
   openmates chats delete <id1> [id2] [id3] ... [--yes]
   openmates chats share [<chat-id>] [--expires <seconds>] [--password <pwd>] [--json]
@@ -55447,6 +56096,11 @@ Options for 'new', 'send', and 'incognito':
   --no-pii-detection       Send the message exactly as typed. By default, the CLI
                             replaces detected PII with placeholders before send.
 
+Saved-chat task options for 'new', 'send', and 'answer-interactive':
+  --accept-task-proposals  Explicitly save assistant task proposals as encrypted
+                            Tasks V1 records scoped to the chat. Without this,
+                            proposals remain review-only, like the web app card.
+
 Guest-only options for logged-out 'new':
   --learning-mode          Opt anonymous chat into request-scoped Learning Mode.
   --age-group <group>      Required with --learning-mode: under_10, 10_12,