openmates 0.27.0-alpha.6 → 0.27.0-alpha.8

package/dist/{chunk-WQOBJUWS.js → chunk-IUOCCXVD.js}

@@ -12586,7 +12586,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (!userId) {
       throw new Error("Could not resolve current user id for local connected-account connector.");
     }
-    const { createHash: createHash31 } = await import("crypto");
+    const { createHash: createHash32 } = await import("crypto");
     const accountId = randomUUID10();
     const masterKey = this.getMasterKeyBytes();
     const encryptLocalConnectorValue = async (value) => {
@@ -12595,9 +12595,9 @@ var OpenMatesClient = class _OpenMatesClient {
     };
     const payload = {
       id: accountId,
-      hashed_user_id: createHash31("sha256").update(userId).digest("hex"),
+      hashed_user_id: createHash32("sha256").update(userId).digest("hex"),
       encrypted_provider_type: await encryptLocalConnectorValue(input.provider_id),
-      provider_type_hash: createHash31("sha256").update(input.provider_id).digest("hex"),
+      provider_type_hash: createHash32("sha256").update(input.provider_id).digest("hex"),
       encrypted_account_label: await encryptLocalConnectorValue(input.label),
       encrypted_capabilities: await encryptLocalConnectorValue(input.capabilities),
       encrypted_app_permissions: await encryptLocalConnectorValue({
@@ -13388,7 +13388,61 @@ var OpenMatesClient = class _OpenMatesClient {
       createdAt: typeof d.created_at === "number" ? d.created_at : null,
       updatedAt: typeof d.last_edited_overall_timestamp === "number" ? d.last_edited_overall_timestamp : null,
       category,
-      mateName: category ? MATE_NAMES[category] ?? null : null
+      mateName: category ? MATE_NAMES[category] ?? null : null,
+      parentId: typeof d.parent_id === "string" ? d.parent_id : null,
+      isSubChat: d.is_sub_chat === true,
+      isHiddenCandidate: !chatKeyBytes
+    };
+  }
+  /** Global activity snapshot; decrypt only running chats and their ancestors. */
+  async getChatActivity(options = {}) {
+    this.requireSession();
+    const teamId = this.resolveTeamContext(options), master = Buffer.from(this.getMasterKeyBytes());
+    const response = await this.http.get(
+      this.appendTeamQuery("/v1/chats/activity", options),
+      this.getCliRequestHeaders()
+    );
+    if (!response.ok) throw new Error(`Chat activity unavailable: HTTP ${response.status}`);
+    if (!this.hasSession() || teamId !== this.resolveTeamContext(options) || !master.equals(Buffer.from(this.getMasterKeyBytes()))) throw new Error("Chat workspace changed");
+    const ids = response.data.active_tasks.map((task) => task.chat_id);
+    if (!ids.length) return { ids, chats: [] };
+    const chats = await this.getSidebarChats(response.data.chats.map((chat) => chat.chat_id), options);
+    if (teamId !== this.resolveTeamContext(options)) throw new Error("Chat workspace changed");
+    return { ids, chats };
+  }
+  /** Minimal encrypted metadata; unreadable keys stay excluded from normal surfaces. */
+  async getSidebarChats(ids, options = {}) {
+    this.requireSession();
+    const teamId = this.resolveTeamContext(options), master = Buffer.from(this.getMasterKeyBytes());
+    const key = await this.getChatWrappingKey(teamId, master), result = [];
+    const current = () => this.hasSession() && teamId === this.resolveTeamContext(options) && master.equals(Buffer.from(this.getMasterKeyBytes()));
+    for (let start = 0; start < ids.length; start += 100) {
+      if (!current()) throw new Error("Chat workspace changed");
+      const response = await this.http.post(
+        this.appendTeamQuery("/v1/chats/metadata/batch", options),
+        { chat_ids: ids.slice(start, start + 100) },
+        this.getCliRequestHeaders()
+      );
+      if (!response.ok) throw new Error(`Sidebar metadata unavailable: HTTP ${response.status}`);
+      for (const details of response.data.chats) {
+        const timestamp = Number(details.updated_at);
+        result.push(await this.decryptChatListItem({ details: {
+          ...details,
+          last_edited_overall_timestamp: Number.isFinite(timestamp) ? timestamp : Date.parse(String(details.updated_at)) / 1e3
+        }, messages: [] }, key, null, teamId));
+      }
+    }
+    if (!current()) throw new Error("Chat workspace changed");
+    return result;
+  }
+  /** Observe lifecycle metadata without claiming or collecting AI responses. */
+  async observeChatActivity(onChange) {
+    const { ws } = await this.openWsClient({ taskUpdateJobs: false });
+    const types = ["ai_task_initiated", "ai_typing_started", "ai_typing_ended", "ai_background_response_completed", "ai_task_cancel_requested", "ai_task_error", "pending_ai_response"];
+    const cleanup = types.map((type) => ws.onMessageType(type, onChange));
+    return () => {
+      cleanup.forEach((remove) => remove());
+      ws.close();
     };
   }
   async listChats(limit = 10, page = 1, options = {}) {
@@ -14391,8 +14445,8 @@ var OpenMatesClient = class _OpenMatesClient {
       );
     }
     const embedId = String(embed.embed_id ?? embed.id ?? "");
-    const { createHash: createHash31 } = await import("crypto");
-    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
+    const { createHash: createHash32 } = await import("crypto");
+    const hashedEmbedId = createHash32("sha256").update(embedId).digest("hex");
     const embedKeyBytes = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -14494,7 +14548,7 @@ var OpenMatesClient = class _OpenMatesClient {
   async resolveEmbedKey(cache, masterKey, embed, embedId, hashedEmbedId, visited = /* @__PURE__ */ new Set()) {
     if (visited.has(embedId)) return null;
     visited.add(embedId);
-    const { createHash: createHash31 } = await import("crypto");
+    const { createHash: createHash32 } = await import("crypto");
     const masterKeyEntry = cache.embedKeys.find(
       (ek) => ek.hashed_embed_id === hashedEmbedId && String(ek.key_type) === "master"
     );
@@ -14511,7 +14565,7 @@ var OpenMatesClient = class _OpenMatesClient {
     if (chatKeyEntry && typeof chatKeyEntry.encrypted_embed_key === "string") {
       const hashedChatId = String(chatKeyEntry.hashed_chat_id ?? "");
       const owningChat = cache.chats.find((c) => {
-        const chatHash = createHash31("sha256").update(String(c.details.id ?? "")).digest("hex");
+        const chatHash = createHash32("sha256").update(String(c.details.id ?? "")).digest("hex");
         return chatHash === hashedChatId;
       });
       if (owningChat) {
@@ -14540,7 +14594,7 @@ var OpenMatesClient = class _OpenMatesClient {
         const parentFullId = String(
           parentEmbed2.embed_id ?? parentEmbed2.id ?? ""
         );
-        const parentHashedId = createHash31("sha256").update(parentFullId).digest("hex");
+        const parentHashedId = createHash32("sha256").update(parentFullId).digest("hex");
         const parentKey = await this.resolveEmbedKey(
           cache,
           masterKey,
@@ -16737,6 +16791,7 @@ var OpenMatesClient = class _OpenMatesClient {
     );
   }
   async resolveWorkflowId(query, options = {}) {
+    if (CANONICAL_UUID_PATTERN.test(query)) return query;
     const workflows = await this.listWorkflows(options);
     const exactId = workflows.find((workflow) => workflow.id === query);
     if (exactId) return exactId.id;
@@ -16835,6 +16890,39 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return this.decryptWorkflowSlug(response.data.workflow, { personal: true });
   }
+  async saveWorkflowAsReusable(workflowId, options) {
+    this.requireSession();
+    if (!options.idempotencyKey.trim()) throw new Error("Workflow save-as-reusable requires a stable idempotencyKey");
+    const response = await this.http.post(
+      `/v1/workflows/${encodeURIComponent(workflowId)}/save-as-reusable`,
+      {},
+      { ...this.getCliRequestHeaders(), "Idempotency-Key": options.idempotencyKey }
+    );
+    if (!response.ok || !response.data.workflow) throw new Error(`Workflow save-as-reusable failed with HTTP ${response.status}`);
+    return this.decryptWorkflowSlug(response.data.workflow, { personal: true });
+  }
+  async workflowRunRouting(params) {
+    const routing = {};
+    if (params.sourceChatId !== void 0) routing.source_chat_id = await this.resolveRequiredChatId(params.sourceChatId, { personal: true });
+    if (params.messageDestinationOverrides !== void 0) {
+      routing.message_destination_overrides = Object.fromEntries(await Promise.all(
+        Object.entries(params.messageDestinationOverrides).map(async ([nodeId, chatId]) => [nodeId, await this.resolveRequiredChatId(chatId, { personal: true })])
+      ));
+    }
+    if (params.returnOutputs !== void 0) routing.return_outputs = params.returnOutputs;
+    return routing;
+  }
+  async runWorkflowOnce(params) {
+    this.requireSession();
+    if (!params.idempotencyKey.trim()) throw new Error("Workflow run-once requires a stable idempotencyKey");
+    const response = await this.http.post(
+      "/v1/workflows/run-once",
+      { title: params.title, graph: params.graph, input: params.input ?? {}, ...await this.workflowRunRouting(params) },
+      { ...this.getCliRequestHeaders(), "Idempotency-Key": params.idempotencyKey }
+    );
+    if (!response.ok || !response.data.workflow || !response.data.run) throw new Error(`Workflow run-once failed with HTTP ${response.status}`);
+    return { workflow: await this.decryptWorkflowSlug(response.data.workflow, { personal: true }), run: response.data.run };
+  }
   async enableWorkflow(workflowId) {
     return this.setWorkflowEnabled(workflowId, true);
   }
@@ -16848,7 +16936,7 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     const response = await this.http.post(
       `/v1/workflows/${encodeURIComponent(workflowId)}/run`,
-      { mode: params.mode ?? "manual", input: params.input ?? {} },
+      { mode: params.mode ?? "manual", input: params.input ?? {}, ...await this.workflowRunRouting(params) },
       { ...this.getCliRequestHeaders(), "Idempotency-Key": params.idempotencyKey }
     );
     if (!response.ok || !response.data.run) {
@@ -17357,7 +17445,7 @@ var OpenMatesClient = class _OpenMatesClient {
     this.requireSession();
     const response = await this.http.post(
       "/v1/projects/ask/plan",
-      { instruction: input.instruction },
+      { instruction: input.instruction, ...input.chatTitles !== void 0 ? { chat_titles: input.chatTitles } : {} },
       this.getCliRequestHeaders()
     );
     if (!response.ok) throw new Error(`Project ask planning failed with HTTP ${response.status}`);
@@ -17366,7 +17454,7 @@ var OpenMatesClient = class _OpenMatesClient {
   async listProjectItems(projectId, options = {}) {
     this.requireSession();
     const response = await this.http.get(
-      this.appendTeamQuery(`/v1/projects/${encodeURIComponent(projectId)}/items`, options),
+      this.appendTeamQuery(`/v1/projects/${encodeURIComponent(projectId)}/items${options.chatOnly ? "?chat_only=true" : ""}`, options),
       this.getCliRequestHeaders()
     );
     if (!response.ok) throw this.projectRequestError("item list", response);
@@ -17503,10 +17591,10 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return { ws: opened.ws, ownerId: opened.ownerId };
   }
-  async createProjectItem(projectId, input) {
+  async createProjectItem(projectId, input, options = {}) {
     this.requireSession();
     const response = await this.http.post(
-      `/v1/projects/${encodeURIComponent(projectId)}/items`,
+      this.appendTeamQuery(`/v1/projects/${encodeURIComponent(projectId)}/items`, options),
       input,
       this.getCliRequestHeaders()
     );
@@ -17515,6 +17603,20 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return response.data.item;
   }
+  async moveProjectItemToFolder(projectId, itemId, folderId, options = {}) {
+    this.requireSession();
+    const response = await this.http.patch(
+      this.appendTeamQuery(`/v1/projects/${encodeURIComponent(projectId)}/items/${encodeURIComponent(itemId)}`, options),
+      { folder_id: folderId, updated_at: Math.floor(Date.now() / 1e3) },
+      this.getCliRequestHeaders()
+    );
+    if (!response.ok) throw this.projectRequestError("folder move", response);
+  }
+  async createProjectFolder(projectId, input, options = {}) {
+    this.requireSession();
+    const response = await this.http.post(this.appendTeamQuery(`/v1/projects/${encodeURIComponent(projectId)}/folders`, options), input, this.getCliRequestHeaders());
+    if (!response.ok) throw this.projectRequestError("folder create", response);
+  }
   async deleteProjectItemByTarget(projectId, itemType, targetId, options = {}) {
     this.requireSession();
     const params = new URLSearchParams({ item_type: itemType, target_id: targetId });
@@ -19150,7 +19252,7 @@ Required: ${schema.required.join(", ")}`
     const session = this.requireSession();
     const masterKey = base64ToBytes(session.masterKeyExportedB64);
     const cache = await this.ensureSynced();
-    const { createHash: createHash31 } = await import("crypto");
+    const { createHash: createHash32 } = await import("crypto");
     const embed = cache.embeds.find(
       (e) => String(e.embed_id ?? "").startsWith(embedIdOrShort) || String(e.id ?? "").startsWith(embedIdOrShort)
     );
@@ -19158,7 +19260,7 @@ Required: ${schema.required.join(", ")}`
       throw new Error(`Embed '${embedIdOrShort}' not found in local cache.`);
     }
     const embedId = String(embed.embed_id ?? embed.id ?? "");
-    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
+    const hashedEmbedId = createHash32("sha256").update(embedId).digest("hex");
     const embedKeyBytes = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -19266,8 +19368,8 @@ Required: ${schema.required.join(", ")}`
     if (!embed) {
       throw new Error(`Embed '${embedId}' not found in local cache. Run 'openmates chats list' to sync first.`);
     }
-    const { createHash: createHash31 } = await import("crypto");
-    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
+    const { createHash: createHash32 } = await import("crypto");
+    const hashedEmbedId = createHash32("sha256").update(embedId).digest("hex");
     const embedKey = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -19383,8 +19485,8 @@ Required: ${schema.required.join(", ")}`
     if (!embed) {
       throw new Error(`Embed '${embedId}' not found in local cache. Run 'openmates chats list' to sync first.`);
     }
-    const { createHash: createHash31 } = await import("crypto");
-    const hashedEmbedId = createHash31("sha256").update(embedId).digest("hex");
+    const { createHash: createHash32 } = await import("crypto");
+    const hashedEmbedId = createHash32("sha256").update(embedId).digest("hex");
     const embedKey = await this.resolveEmbedKey(
       cache,
       masterKey,
@@ -19916,9 +20018,9 @@ Required: ${schema.required.join(", ")}`
     chats.splice(0, chats.length, ...reconciledChats);
     if (totalChatCount === 0) totalChatCount = chats.length;
     if (reconciliation.deleted_chat_ids?.length) {
-      const { createHash: createHash31 } = await import("crypto");
+      const { createHash: createHash32 } = await import("crypto");
       const deletedHashes = new Set(
-        reconciliation.deleted_chat_ids.map((id) => createHash31("sha256").update(id).digest("hex"))
+        reconciliation.deleted_chat_ids.map((id) => createHash32("sha256").update(id).digest("hex"))
       );
       const keptEmbeds = embeds.filter((embed) => !deletedHashes.has(String(embed.hashed_chat_id ?? "")));
       const keptKeys = embedKeys.filter((key) => !deletedHashes.has(String(key.hashed_chat_id ?? "")));
@@ -30556,12 +30658,47 @@ var OpenMatesWorkflows = class {
     if (!response.workflow) throw new OpenMatesApiError(500, { detail: "Workflow response missing workflow" });
     return this.decryptWorkflowSlug(response.workflow);
   }
+  async saveAsReusable(workflowId, options) {
+    if (!options.idempotencyKey.trim()) throw new OpenMatesConfigError("Workflow save-as-reusable requires a stable idempotencyKey");
+    const resolvedWorkflowId = await this.resolveId(workflowId);
+    const response = await this.client.request(
+      `/v1/workflows/${encodeURIComponent(resolvedWorkflowId)}/save-as-reusable`,
+      {},
+      void 0,
+      { "Idempotency-Key": options.idempotencyKey }
+    );
+    if (!response.workflow) throw new OpenMatesApiError(500, { detail: "Workflow response missing workflow" });
+    return this.decryptWorkflowSlug(response.workflow);
+  }
+  async runRouting(params) {
+    const routing = {};
+    if (params.sourceChatId !== void 0) routing.source_chat_id = await resolveSdkChatId(this.client, params.sourceChatId);
+    if (params.messageDestinationOverrides !== void 0) {
+      routing.message_destination_overrides = Object.fromEntries(await Promise.all(
+        Object.entries(params.messageDestinationOverrides).map(async ([nodeId, chatId]) => [nodeId, await resolveSdkChatId(this.client, chatId)])
+      ));
+    }
+    if (params.returnOutputs !== void 0) routing.return_outputs = params.returnOutputs;
+    return routing;
+  }
+  async runOnce(params) {
+    if (!params.idempotencyKey.trim()) throw new OpenMatesConfigError("Workflow run-once requires a stable idempotencyKey");
+    const response = await this.client.request(
+      "/v1/workflows/run-once",
+      { title: params.title, graph: params.graph, input: params.input ?? {}, ...await this.runRouting(params) },
+      void 0,
+      { "Idempotency-Key": params.idempotencyKey }
+    );
+    if (!response.workflow || !response.run) throw new OpenMatesApiError(500, { detail: "Workflow run-once response missing workflow or run" });
+    return { workflow: await this.decryptWorkflowSlug(response.workflow), run: response.run };
+  }
   async run(workflowId, params) {
     if (!params.idempotencyKey.trim()) throw new OpenMatesConfigError("Workflow run requires a stable idempotencyKey");
     const resolvedWorkflowId = await this.resolveId(workflowId);
     const response = await this.client.request(`/v1/workflows/${encodeURIComponent(resolvedWorkflowId)}/run`, {
       mode: params.mode ?? "manual",
-      input: params.input ?? {}
+      input: params.input ?? {},
+      ...await this.runRouting(params)
     }, void 0, { "Idempotency-Key": params.idempotencyKey });
     if (!response.run) throw new OpenMatesApiError(500, { detail: "Workflow response missing run" });
     return response.run;
@@ -31158,7 +31295,7 @@ async function flushPendingTaskActivities(client2, teamId, stateDir2 = resolveSt
 import { existsSync as existsSync26, readFileSync as readFileSync24, realpathSync as realpathSync12, readdirSync as readdirSync14, statSync as statSync11, writeFileSync as writeFileSync16 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { basename as basename9, dirname as dirname16, join as join29 } from "path";
-import { createHash as createHash30, randomBytes as randomBytes14, randomUUID as randomUUID23 } from "crypto";
+import { createHash as createHash31, randomBytes as randomBytes14, randomUUID as randomUUID24 } from "crypto";
 import { arch as arch2, platform as platform3 } from "os";
 import { parse as parseYaml, parseDocument as parseYamlDocument, stringify as stringifyYaml } from "yaml";
 
@@ -31270,7 +31407,7 @@ function assertPortable(value) {
 }
 function remapGraph(graph, ids) {
   const escaped = Array.from(ids.keys()).sort((a, b) => b.length - a.length).map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-  const references = escaped.length ? new RegExp(`(\\$nodes\\.|\\{\\{\\s*steps\\.)(${escaped.join("|")})(?=[.}\\s]|$)`, "g") : null;
+  const references = escaped.length ? new RegExp(`(\\$nodes\\.|\\{\\{\\s*steps\\.|\\$items\\.|\\{\\{\\s*items\\.)(${escaped.join("|")})(?=[.}\\s]|$)`, "g") : null;
   function visit(value) {
     if (typeof value === "string") return references ? value.replace(references, (_match, prefix, id) => prefix + ids.get(id)) : value;
     if (Array.isArray(value)) return value.map((item) => visit(item));
@@ -60704,6 +60841,15 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
       manual_intro: {
         text: "Use this skill directly by entering your request below."
       },
+      requirements: {
+        text: "Requirements"
+      },
+      optional: {
+        text: "(optional)"
+      },
+      requirements_placeholder: {
+        text: "Describe what the results should match."
+      },
       via: {
         text: "via"
       },
@@ -60905,6 +61051,21 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     request_error: {
       text: "The request could not finish. You can try again."
     },
+    saving: {
+      text: "Saving results\u2026"
+    },
+    saved: {
+      text: "Results saved"
+    },
+    save_failed: {
+      text: "Results are available. Saving failed."
+    },
+    retry_save: {
+      text: "Retry saving"
+    },
+    saving_results: {
+      text: "Results awaiting save"
+    },
     viewer_read_only: {
       text: "Your team role allows viewing results. Ask a team member to run this skill."
     },
@@ -62135,6 +62296,64 @@ Only output the final Markdown table. Do NOT include explanations, notes, or any
     }
   },
   chats: {
+    projects: {
+      move: {
+        text: "Move to project"
+      },
+      move_here: {
+        text: "Move here"
+      },
+      add: {
+        text: "Add to project"
+      },
+      create: {
+        text: "Create new project"
+      },
+      add_here: {
+        text: "Add here"
+      },
+      new_folder: {
+        text: "New subfolder"
+      },
+      folder_name: {
+        text: "Folder name"
+      },
+      path: {
+        text: "Project path"
+      },
+      up: {
+        text: "Go up one level"
+      },
+      ancestors: {
+        text: "Show full path"
+      },
+      open: {
+        text: "Open project"
+      },
+      organizing: {
+        text: "Organizing chats\u2026"
+      },
+      error: {
+        text: "Could not organize chats. Please try again."
+      }
+    },
+    activity: {
+      heading: {
+        text: "Active chats"
+      },
+      count: {
+        text: "{count} chats active\u2026"
+      },
+      count_single: {
+        text: "1 chat active\u2026"
+      },
+      subchats: {
+        text: "{count} subchats running"
+      },
+      subchats_single: {
+        text: "1 subchat running"
+      }
+    },
     chat: {
       welcome: {
         back_to_recent: {
@@ -81647,6 +81866,108 @@ As of mid-2026, the severe supply shocks from the 2024\u20132025 avian flu have
       if_unsure: {
         text: "If unsure"
       },
+      check_result: {
+        text: "Result"
+      },
+      check_result_boolean: {
+        text: "True or False"
+      },
+      check_result_options: {
+        text: "Multiple choice"
+      },
+      check_selection_mode: {
+        text: "Select"
+      },
+      check_select_one: {
+        text: "Exactly one"
+      },
+      check_select_multiple: {
+        text: "All that apply"
+      },
+      check_option_name: {
+        text: "Option name"
+      },
+      check_option_description: {
+        text: "Select when (optional)"
+      },
+      add_option: {
+        text: "Add option"
+      },
+      remove_option: {
+        text: "Remove option"
+      },
+      if_no_match: {
+        text: "If none match"
+      },
+      selected: {
+        text: "Selected"
+      },
+      no_match: {
+        text: "No match"
+      },
+      ai_check_options_guidance: {
+        text: "Choose from the named options using earlier results. A variable alone is enough; an instruction is optional. Unsure is used when evidence is missing."
+      },
+      branch_mapping_required: {
+        text: "This branch contains steps. Move or remove those steps before changing its result or deleting it."
+      },
+      for_each: {
+        text: "For each"
+      },
+      for_each_items: {
+        text: "List to process"
+      },
+      for_each_max_items: {
+        text: "Maximum items"
+      },
+      for_each_advanced_limits: {
+        text: "Advanced limits"
+      },
+      for_each_duration: {
+        text: "Total time limit (seconds)"
+      },
+      for_each_credits: {
+        text: "Credit limit"
+      },
+      for_each_timeout: {
+        text: "Time limit per item (seconds)"
+      },
+      for_each_limits: {
+        text: "Processes items one at a time. Defaults: 100 items, 300 seconds, 100 credits and 60 seconds per item."
+      },
+      for_each_array_required: {
+        text: "Choose an earlier list and a maximum of 1 to 100 items."
+      },
+      for_each_body: {
+        text: "For each item"
+      },
+      this_item: {
+        text: "This item"
+      },
+      start_input: {
+        text: "Start input"
+      },
+      item_number: {
+        text: "Item"
+      },
+      chat_actions: {
+        text: "Workflow actions"
+      },
+      chat_open_workflow: {
+        text: "Open workflow"
+      },
+      chat_save_reusable: {
+        text: "Save as reusable"
+      },
+      chat_open_saved_copy: {
+        text: "Open saved copy"
+      },
+      chat_snapshot_note: {
+        text: "Showing the workflow saved with this chat. Open the Workflows workspace to edit it."
+      },
+      chat_copy_failed: {
+        text: "Could not save this workflow."
+      },
       if: {
         text: "If"
       },
@@ -83994,7 +84315,7 @@ function formatMetricDelta(delta, suffix) {
 // src/tui.ts
 import { createInterface as createInterface4 } from "readline/promises";
 import { stdin as nodeStdin, stdout as nodeStdout } from "process";
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID21 } from "crypto";
 
 // src/tuiExampleContinuation.ts
 function buildExampleContinuationHistory(conversation) {
@@ -84687,13 +85008,13 @@ function storedPath(metadata, displayName) {
     return null;
   }
 }
-async function loadTuiProject(client2, id) {
+async function loadTuiProject(client2, id, chatOnly = false) {
   const context = contextFor(client2);
   const detail = await client2.getProject(id, context);
   const project = await projectFromRecord(client2, detail.project, context);
   const [itemsResponse, sourceRecords] = await Promise.all([
-    client2.listProjectItems(id, context),
-    client2.listProjectSources(id, context)
+    client2.listProjectItems(id, { ...context, chatOnly }),
+    chatOnly ? Promise.resolve([]) : client2.listProjectSources(id, context)
   ]);
   const folderIds = itemsResponse.folders.map((folder) => String(folder.folder_id ?? "")).filter(Boolean);
   const folderByHash = new Map(folderIds.map((folderId) => [createHash21("sha256").update(folderId).digest("hex"), folderId]));
@@ -84927,7 +85248,7 @@ function buildProjectForm() {
     ]
   };
 }
-async function submitProjectForm(client2, form) {
+async function submitProjectForm(client2, form, chatOrganizationOnly = false) {
   const name = formValue(form, "name").trim();
   if (!name) throw new Error("Project name is required.");
   const writeMode = formValue(form, "write_mode");
@@ -84951,7 +85272,7 @@ async function submitProjectForm(client2, form) {
     created_at: timestamp,
     updated_at: timestamp,
     last_opened_at: timestamp,
-    write_mode: writeMode,
+    write_mode: chatOrganizationOnly ? null : writeMode,
     default_focus_id: focus.focus_id,
     encrypted_settings: await encryptWithAesGcmCombined(JSON.stringify({ default_focus: focus }), key),
     key_wrappers: wrapping.teamId ? [{
@@ -84963,7 +85284,7 @@ async function submitProjectForm(client2, form) {
       created_at: timestamp
     }] : []
   };
-  const result = await client2.createProject(payload, context);
+  const result = await client2.createProject({ ...payload, ...chatOrganizationOnly ? { chat_organization_only: true } : {} }, context);
   return projectFromRecord(client2, { ...payload, ...result.project ?? {} }, context);
 }
 
@@ -85538,6 +85859,10 @@ var TUI_ACTIONS = [
   { label: "Move selected task", command: "/task-status" },
   { label: "Add task activity", command: "/task-activity" },
   { label: "Create Project", command: "/project-create" },
+  { label: "Add chat to project", command: "/chat-add-to-project" },
+  { label: "Move chat to project", command: "/chat-move-to-project" },
+  { label: "Create project from chats", command: "/chat-create-project" },
+  { label: "Show active chats", command: "/active" },
   { label: "New chat in Project", command: "/project-chat" },
   { label: "Edit workflow step", command: "/workflow-edit" },
   { label: "Enable or disable workflow", command: "/workflow-toggle" },
@@ -85552,6 +85877,259 @@ function paletteActions(query) {
   return TUI_ACTIONS.filter((item) => `${item.label} ${item.command}`.toLowerCase().includes(needle));
 }
 
+// src/tuiChatSidebar.ts
+import { createHash as createHash22, randomUUID as randomUUID18 } from "crypto";
+
+// ../ui/src/utils/chatActivity.ts
+function processingAncestorIds(chats, runningIds) {
+  const byId = new Map(chats.map((chat) => [chat.chat_id, chat]));
+  const result = /* @__PURE__ */ new Set();
+  for (const id of runningIds) {
+    const ancestry = [];
+    const visited = /* @__PURE__ */ new Set();
+    let chat = byId.get(id);
+    while (chat && !visited.has(chat.chat_id)) {
+      visited.add(chat.chat_id);
+      ancestry.push(chat);
+      chat = chat.parent_id ? byId.get(chat.parent_id) : void 0;
+    }
+    if (ancestry.some((chat2) => chat2.is_hidden || chat2.is_hidden_candidate)) continue;
+    for (const ancestor of ancestry) result.add(ancestor.chat_id);
+  }
+  return result;
+}
+function aggregateRunningChats(chats, runningIds) {
+  const byId = new Map(chats.map((chat) => [chat.chat_id, chat]));
+  const groups = /* @__PURE__ */ new Map();
+  for (const id of runningIds) {
+    let root = byId.get(id);
+    if (!root) continue;
+    const visited = /* @__PURE__ */ new Set([id]);
+    let hidden = root.is_hidden || root.is_hidden_candidate;
+    while (root.parent_id && byId.has(root.parent_id) && !visited.has(root.parent_id)) {
+      visited.add(root.parent_id);
+      root = byId.get(root.parent_id);
+      hidden ||= root.is_hidden || root.is_hidden_candidate;
+    }
+    if (hidden) continue;
+    let group = groups.get(root.chat_id);
+    if (!group) {
+      group = { chat: root, activeSubChatCount: 0 };
+      groups.set(root.chat_id, group);
+    }
+    if (id !== root.chat_id) group.activeSubChatCount += 1;
+  }
+  return [...groups.values()];
+}
+
+// ../ui/src/utils/chatProjectNavigation.ts
+function projectBreadcrumbs(project, folderId) {
+  const ancestors = [];
+  const visited = /* @__PURE__ */ new Set();
+  let folder = project.folders.find((folder2) => folder2.id === folderId);
+  while (folder && !visited.has(folder.id)) {
+    visited.add(folder.id);
+    ancestors.unshift({ id: folder.id, name: folder.name });
+    folder = project.folders.find((candidate) => candidate.hash === folder.parentHash);
+  }
+  return [{ id: null, name: project.name }, ...ancestors];
+}
+function projectFolderChatIds(project, folderId, recursive = false) {
+  const folder = project.folders.find((folder2) => folder2.id === folderId);
+  if (folderId !== null && !folder) return /* @__PURE__ */ new Set();
+  const hashes = /* @__PURE__ */ new Set([folder?.hash ?? null]);
+  if (recursive) {
+    let previous = -1;
+    while (previous !== hashes.size) {
+      previous = hashes.size;
+      for (const candidate of project.folders) if (hashes.has(candidate.parentHash)) hashes.add(candidate.hash);
+    }
+  }
+  return new Set(project.chats.filter((chat) => hashes.has(chat.folderHash)).map((chat) => chat.chatId));
+}
+function locationHasRunningChats(project, folderId, runningIds) {
+  return [...projectFolderChatIds(project, folderId, true)].some((id) => runningIds.has(id));
+}
+
+// src/tuiChatSidebar.ts
+function rowKey(row) {
+  return [row.kind, row.chatId ?? "", row.projectId ?? "", row.folderId ?? ""].join(":");
+}
+function updateTuiChatSidebar(state, update) {
+  const selected = tuiChatSidebarRows(state)[state.sidebarIndex];
+  update();
+  if (state.workspace !== "chats" || state.focus !== "sidebar") return;
+  const rows2 = tuiChatSidebarRows(state);
+  const index = selected ? rows2.findIndex((row) => rowKey(row) === rowKey(selected)) : -1;
+  state.sidebarIndex = index >= 0 ? index : Math.max(0, Math.min(state.sidebarIndex, rows2.length - 1));
+}
+function runningTuiChatGroups(state) {
+  const chats = new Map([...state.recentChats, ...state.activityChats].map((chat) => [chat.id, chat]));
+  return aggregateRunningChats([...chats.values()].map((chat) => ({ chat_id: chat.id, parent_id: chat.parentId, is_hidden_candidate: chat.isHiddenCandidate })), new Set(state.runningChatIds)).map((group) => ({ ...group, chat: chats.get(group.chat.chat_id) }));
+}
+function tuiSidebarProjects(state) {
+  return state.chatSidebarProjects.map((project) => ({
+    id: project.id,
+    name: project.name,
+    folders: project.folders.map((folder) => ({
+      id: folder.id,
+      name: folder.name,
+      hash: createHash22("sha256").update(folder.id).digest("hex"),
+      parentHash: folder.parentHash ?? null
+    })),
+    chats: project.items.filter((item) => item.type === "chat").map((item) => ({
+      id: item.id,
+      chatId: item.targetId,
+      folderHash: item.folderId ? createHash22("sha256").update(item.folderId).digest("hex") : null
+    }))
+  }));
+}
+function tuiChatBreadcrumb(state, width = 23) {
+  const location = state.chatSidebarLocation;
+  const project = tuiSidebarProjects(state).find((project2) => project2.id === location?.projectId);
+  if (!project || !location) return null;
+  const crumbs = projectBreadcrumbs(project, location.folderId);
+  if (crumbs.length === 1) return truncateCells(project.name, width);
+  const separator = crumbs.length > 2 ? " \u203A \u2026 \u203A " : " \u203A ";
+  const current = crumbs.at(-1).name, budget = Math.max(2, width - cells(separator));
+  if (cells(project.name) + cells(current) <= budget) return `${project.name}${separator}${current}`;
+  const leafWidth = Math.min(cells(current), Math.max(1, budget - Math.min(cells(project.name), Math.ceil(budget / 2))));
+  return `${truncateCells(project.name, budget - leafWidth)}${separator}${truncateCells(current, leafWidth)}`;
+}
+function tuiChatSidebarRows(state) {
+  const groups = runningTuiChatGroups(state);
+  const records = [...state.recentChats, ...state.activityChats].map((chat) => ({ chat_id: chat.id, parent_id: chat.parentId, is_hidden_candidate: chat.isHiddenCandidate }));
+  const running = processingAncestorIds(records, new Set(state.runningChatIds));
+  const rows2 = groups.map((group) => ({
+    kind: "chat",
+    chatId: group.chat.id,
+    running: true,
+    label: `${group.chat.title || "Untitled chat"}${group.activeSubChatCount ? ` (${group.activeSubChatCount} ${group.activeSubChatCount === 1 ? "subchat" : "subchats"})` : ""}`
+  }));
+  rows2.push({ kind: "new", label: "+ New chat" });
+  if (state.chatProjectOperation) rows2.push({ kind: "create", label: "+ Create new project" });
+  const projects = tuiSidebarProjects(state), location = state.chatSidebarLocation;
+  const project = projects.find((project2) => project2.id === location?.projectId);
+  let contents = null;
+  if (project && location) {
+    const crumbs = projectBreadcrumbs(project, location.folderId);
+    rows2.push({ kind: "up", label: "\u2039 Up one level", projectId: project.id, folderId: crumbs.length > 1 ? crumbs[crumbs.length - 2].id : void 0 });
+    if (crumbs.length > 2) rows2.push({ kind: "path", label: "\u2026 Show full path" });
+    if (state.chatSidebarAncestors) for (const crumb of crumbs) rows2.push({ kind: "folder", label: crumb.name, projectId: project.id, folderId: crumb.id });
+    if (state.chatProjectOperation) rows2.push({ kind: "choose", label: state.chatProjectOperation.mode === "move" ? "Move here" : "Add here", projectId: project.id, folderId: location.folderId });
+    const hash2 = project.folders.find((folder) => folder.id === location.folderId)?.hash ?? null;
+    rows2.push(...project.folders.filter((folder) => folder.parentHash === hash2).map((folder) => ({
+      kind: "folder",
+      label: folder.name,
+      projectId: project.id,
+      folderId: folder.id,
+      running: locationHasRunningChats(project, folder.id, running)
+    })));
+    contents = projectFolderChatIds(project, location.folderId);
+  } else rows2.push(...projects.map((project2) => ({
+    kind: "project",
+    label: project2.name,
+    projectId: project2.id,
+    running: locationHasRunningChats(project2, null, running)
+  })));
+  const organized = new Set(projects.flatMap((project2) => project2.chats.map((chat) => chat.chatId)));
+  const candidates = new Map([...state.recentChats, ...state.sidebarLinkedChats].filter((chat) => !chat.isHiddenCandidate).map((chat) => [chat.id, { id: chat.id, title: chat.title, parentId: chat.parentId, isSubChat: chat.isSubChat }]));
+  if (contents && location) for (const item of state.chatSidebarProjects.find((project2) => project2.id === location.projectId)?.items ?? []) {
+    const verified = candidates.get(item.targetId);
+    if (item.type === "chat" && contents.has(item.targetId) && verified && !verified.title)
+      candidates.set(item.targetId, { ...verified, title: item.name });
+  }
+  if (!state.chatProjectOperation) rows2.push(...[...candidates.values()].filter((chat) => !running.has(chat.id) && (contents ? contents.has(chat.id) : !chat.parentId && !chat.isSubChat && !organized.has(chat.id))).map((chat) => ({ kind: "chat", chatId: chat.id, label: chat.title || "Untitled chat" })));
+  return rows2;
+}
+async function refreshTuiChatSidebar(state, client2, render, includeProjects = false) {
+  if (!state.signedIn) return;
+  const team = typeof client2.getActiveTeamId === "function" ? client2.getActiveTeamId() : null;
+  const master = typeof client2.getMasterKeyBytes === "function" ? Buffer.from(client2.getMasterKeyBytes()) : null;
+  const current = () => state.signedIn && (typeof client2.getActiveTeamId !== "function" || client2.getActiveTeamId() === team) && (!master || master.equals(Buffer.from(client2.getMasterKeyBytes())));
+  if (typeof client2.getChatActivity === "function") {
+    try {
+      const activity = await client2.getChatActivity();
+      if (current()) {
+        updateTuiChatSidebar(state, () => {
+          state.runningChatIds = activity.ids;
+          state.activityChats = activity.chats;
+        });
+        render();
+      }
+    } catch {
+      if (current()) {
+        state.status = "Running chat status unavailable.";
+        render();
+      }
+    }
+  }
+  if (includeProjects && typeof client2.listProjects === "function") {
+    const summaries = await loadTuiProjects(client2), projects = [];
+    for (let start = 0; start < summaries.length; start += 4) projects.push(...await Promise.all(summaries.slice(start, start + 4).map((project) => loadTuiProject(client2, project.id, true))));
+    const linkedIds = [...new Set(projects.flatMap((project) => project.items.filter((item) => item.type === "chat").map((item) => item.targetId)))];
+    const linkedChats = typeof client2.getSidebarChats === "function" ? await client2.getSidebarChats(linkedIds) : [];
+    if (current()) {
+      updateTuiChatSidebar(state, () => {
+        state.chatSidebarProjects = projects;
+        state.sidebarLinkedChats = linkedChats;
+      });
+      render();
+    }
+  }
+}
+async function placeTuiChats(state, client2, chatIds, location, mode) {
+  const context = { teamId: client2.getActiveTeamId() }, master = Buffer.from(client2.getMasterKeyBytes());
+  const fence = () => {
+    if (!state.signedIn || context.teamId !== client2.getActiveTeamId() || !master.equals(Buffer.from(client2.getMasterKeyBytes()))) throw new Error("Chat workspace changed");
+  };
+  const destination = await loadTuiProject(client2, location.projectId, true);
+  if (location.folderId && !destination.folders.some((folder) => folder.id === location.folderId)) throw new Error("Folder unavailable");
+  for (const chatId of chatIds) {
+    fence();
+    const existing = destination.items.find((item) => item.type === "chat" && item.targetId === chatId);
+    if (existing) {
+      if ((existing.folderId ?? null) !== location.folderId) await client2.moveProjectItemToFolder(destination.id, existing.id, location.folderId, context);
+    } else {
+      const title = [...state.recentChats, ...state.activityChats].find((chat) => chat.id === chatId)?.title || "Untitled chat";
+      const timestamp = Math.floor(Date.now() / 1e3);
+      const payload = {
+        project_item_id: randomUUID18(),
+        folder_id: location.folderId,
+        item_type: "chat",
+        target_id: chatId,
+        target_id_encrypted: await encryptWithAesGcmCombined(chatId, destination.projectKey),
+        encrypted_display_name: await encryptWithAesGcmCombined(title, destination.projectKey),
+        created_at: timestamp,
+        updated_at: timestamp,
+        position: timestamp
+      };
+      fence();
+      await client2.createProjectItem(destination.id, payload, context);
+    }
+  }
+  if (mode === "move") for (const source of state.chatSidebarProjects.filter((project) => project.id !== destination.id)) {
+    for (const chatId of chatIds.filter((id) => source.items.some((item) => item.type === "chat" && item.targetId === id))) {
+      fence();
+      await client2.deleteProjectItemByTarget(source.id, "chat", chatId, context);
+    }
+  }
+}
+async function createTuiChatProject(state, client2, chatIds) {
+  if (!state.signedIn || !chatIds.length) throw new Error("Choose a saved chat first.");
+  const context = client2.getActiveTeamId(), master = Buffer.from(client2.getMasterKeyBytes());
+  const titles = chatIds.slice(0, 8).map((id) => [...state.recentChats, ...state.activityChats, ...state.sidebarLinkedChats].find((chat) => chat.id === id)?.title?.slice(0, 200) || "Untitled chat");
+  const plan = await client2.planProjectAsk({ instruction: "Name a new project from chat titles.", chatTitles: titles });
+  const proposed = plan.proposed_project, name = proposed?.name?.trim();
+  if (!name || name.length > 200) throw new Error("Could not generate a project title.");
+  if (context !== client2.getActiveTeamId() || !master.equals(Buffer.from(client2.getMasterKeyBytes()))) throw new Error("Chat workspace changed");
+  const form = buildProjectForm();
+  form.fields.find((field) => field.name === "name").value = name;
+  const project = await submitProjectForm(client2, form, true);
+  await placeTuiChats(state, client2, chatIds, { projectId: project.id, folderId: null }, "move");
+  return project.id;
+}
+
 // src/tuiLayout.ts
 var WORKSPACES = ["chats", "apps", "projects", "workflows", "tasks"];
 var DEFAULT_CHAT_BACKGROUND = "#4867cd";
@@ -85562,7 +86140,13 @@ function sidebarLines(state) {
   const selected = (label3, index) => `${state.focus === "sidebar" && state.sidebarIndex === index ? ">" : " "} ${label3}`;
   switch (state.workspace) {
     case "chats":
-      return ["Chats", "", selected("+ New chat", 0), "", "Recent chats", "", ...state.recentChats.map((c, i) => selected(c.title || "Untitled chat", i + 1)), "", "/chats browse   /examples"];
+      return [
+        tuiChatBreadcrumb(state) ?? "Chats",
+        "",
+        ...tuiChatSidebarRows(state).map((row, index) => selected(`${row.running ? ["\u25F4", "\u25F7", "\u25F6", "\u25F5"][state.activityFrame % 4] + " " : ""}${row.label}`, index)),
+        "",
+        "/active  /chat-add-to-project"
+      ];
     case "projects":
       return ["Projects", "", ...state.projects.map((p, i) => selected(p.name, i)), "", "/project-create new"];
     case "tasks":
@@ -86025,6 +86609,8 @@ function homeHeader(state, width, height) {
 }
 function renderHomeChatCards(state, width, height) {
   const chats = homeChatItems(state), result = homeHeader(state, width, height);
+  const activeCount = runningTuiChatGroups(state).length;
+  if (activeCount) result.push(centered2(`${activeCount} ${activeCount === 1 ? "chat" : "chats"} active\u2026  /active`, width), "");
   if (!chats.length) {
     result.push(centered2(state.homeLoading ? "Loading your recent chats\u2026" : "Start a chat below. Your recent chats will appear here.", width), "");
     return result;
@@ -86048,7 +86634,7 @@ function renderHomeChatCards(state, width, height) {
 }
 
 // src/tuiAppsWorkspace.ts
-import { randomBytes as randomBytes11, randomUUID as randomUUID18 } from "crypto";
+import { randomBytes as randomBytes11, randomUUID as randomUUID19 } from "crypto";
 
 // ../ui/src/components/apps/appsSkillFormUtils.ts
 var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -86505,7 +87091,7 @@ async function saveEncryptedResult(client2, ownerId, rootId, key, encryptedKey,
     const value = record5(result);
     const type = string2(value.type, string2(value.embed_type));
     if (!type && typeof value.embed_id !== "string") return [];
-    const id = typeof value.embed_id === "string" && UUID.test(value.embed_id) ? value.embed_id : randomUUID18();
+    const id = typeof value.embed_id === "string" && UUID.test(value.embed_id) ? value.embed_id : randomUUID19();
     return [(async () => ({
       embed_id: id,
       encrypted_type: await encryptWithAesGcmCombined(type || "app_skill_use", key),
@@ -86550,7 +87136,7 @@ async function executeConfirmedTuiAppsSkill(client2, run) {
   const owner = record5(await client2.whoAmI());
   const ownerId = string2(owner.id, string2(owner.user_id));
   if (!ownerId) throw new Error("Account identity unavailable; skill was not run.");
-  const rootId = randomUUID18();
+  const rootId = randomUUID19();
   const key = randomBytes11(32);
   const encryptedKey = await encryptBytesWithAesGcm(key, client2.getMasterKeyBytes());
   await saveEncryptedResult(client2, ownerId, rootId, key, encryptedKey, run, { status: "processing" }, "processing");
@@ -86796,6 +87382,15 @@ function createInitialTuiState() {
     taskStatusFilter: "",
     taskContext: null,
     recentChats: [],
+    runningChatIds: [],
+    activityChats: [],
+    sidebarLinkedChats: [],
+    activityFrame: 0,
+    chatSidebarProjects: [],
+    chatSidebarLocation: null,
+    chatSidebarAncestors: false,
+    chatProjectOperation: null,
+    chatProjectBusy: false,
     activeChatId: null,
     activeChat: null,
     headerState: "new",
@@ -87207,7 +87802,7 @@ function wrap(line, width) {
 }
 
 // src/tuiWorkspaceController.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 function chatDraftKey(state) {
   return state.screen === "example" ? `example:${state.activeExample?.chat.id}` : state.activeChatId ?? "new";
 }
@@ -87254,6 +87849,7 @@ async function recent(context) {
   if (request !== state.routeVersion || homeRequest !== state.homeLoadVersion || !state.signedIn) return;
   state.recentChats = chats;
   render();
+  await refreshTuiChatSidebar(state, client2, render, true);
 }
 async function openSavedChat(context, id) {
   const { state, client: client2, render } = context;
@@ -87455,6 +88051,64 @@ async function handleWorkspaceCommand(context, command) {
       state.selectedProjectId = null;
       render();
       return true;
+    case "/active":
+      state.sidebarOpen = true;
+      state.focus = "sidebar";
+      state.sidebarIndex = 0;
+      render();
+      await refreshTuiChatSidebar(state, client2, render, true);
+      state.sidebarIndex = 0;
+      render();
+      return true;
+    case "/chat-add-to-project":
+    case "/chat-move-to-project":
+    case "/chat-create-project": {
+      if (state.chatProjectBusy) return true;
+      if (!state.signedIn) throw new Error("Sign in to organize chats.");
+      const selected = state.focus === "sidebar" ? tuiChatSidebarRows(state)[state.sidebarIndex]?.chatId : ["start", "chats"].includes(state.screen) ? homeChatItems(state)[state.selectedIndex]?.id : state.activeChatId;
+      const ids = arg ? arg.split(/\s+/).filter(Boolean) : selected ? [selected] : [];
+      if (!ids.length) throw new Error("Choose a saved chat first.");
+      await refreshTuiChatSidebar(state, client2, render, true);
+      if (name === "/chat-create-project") {
+        state.chatProjectBusy = true;
+        state.status = "Organizing chats\u2026";
+        render();
+        try {
+          const id = await createTuiChatProject(state, client2, ids);
+          state.chatProjectOperation = null;
+          await openProject(context, id);
+        } finally {
+          state.chatProjectBusy = false;
+        }
+      } else {
+        state.chatProjectOperation = { chatIds: ids, mode: name === "/chat-move-to-project" ? "move" : "add" };
+        state.chatSidebarLocation = null;
+        state.sidebarOpen = true;
+        state.focus = "sidebar";
+        state.sidebarIndex = 0;
+        state.status = "Choose a project or subfolder.";
+      }
+      render();
+      return true;
+    }
+    case "/chat-subfolder": {
+      const location = state.chatSidebarLocation;
+      if (!location || !arg.trim()) throw new Error("Open a project folder and enter /chat-subfolder followed by a name.");
+      const project = state.chatSidebarProjects.find((project2) => project2.id === location.projectId);
+      if (!project) throw new Error("Project unavailable.");
+      const timestamp = Math.floor(Date.now() / 1e3);
+      await client2.createProjectFolder(project.id, {
+        folder_id: randomUUID20(),
+        parent_folder_id: location.folderId,
+        encrypted_name: await encryptWithAesGcmCombined(arg.trim().slice(0, 200), project.projectKey),
+        encrypted_sort_key: await encryptWithAesGcmCombined(arg.trim().toLowerCase().slice(0, 200), project.projectKey),
+        created_at: timestamp,
+        updated_at: timestamp,
+        position: timestamp
+      });
+      await refreshTuiChatSidebar(state, client2, render, true);
+      return true;
+    }
     case "/sidebar":
       state.sidebarOpen = !state.sidebarOpen;
       state.focus = state.sidebarOpen ? "sidebar" : state.workspace === "chats" && !["start", "chats"].includes(state.screen) ? "composer" : "content";
@@ -87695,7 +88349,7 @@ async function saveForm(context) {
     } else if (form.kind === "workflow-create") {
       const description = formValue(form, "description").trim();
       if (!description) throw new Error("Describe what this workflow should do.");
-      const request = state.routeVersion, session = await client2.startWorkflowInput({ text: description, inputType: "text", optimisticSave: true, timezone: Intl.DateTimeFormat().resolvedOptions().timeZone, idempotencyKey: randomUUID19() });
+      const request = state.routeVersion, session = await client2.startWorkflowInput({ text: description, inputType: "text", optimisticSave: true, timezone: Intl.DateTimeFormat().resolvedOptions().timeZone, idempotencyKey: randomUUID20() });
       if (request !== state.routeVersion || state.form !== form) return;
       const workflow = session.workflow ?? session.workflows?.[0];
       if (workflow) {
@@ -87721,7 +88375,7 @@ async function saveForm(context) {
   }
 }
 async function handleWorkspaceKey(context, chunk, key) {
-  const { state, render } = context;
+  const { state, render, client: client2 } = context;
   if (state.form) {
     const form = state.form, field = form.fields[form.fieldIndex];
     if (!field) {
@@ -87802,6 +88456,13 @@ async function handleWorkspaceKey(context, chunk, key) {
     return true;
   }
   if (key.name === "escape") {
+    if (state.chatProjectBusy) return true;
+    if (state.chatProjectOperation) {
+      state.chatProjectOperation = null;
+      state.status = null;
+      render();
+      return true;
+    }
     if (state.focus === "sidebar") {
       state.sidebarOpen = false;
       state.focus = chatHome ? "content" : state.workspace === "chats" ? "composer" : "content";
@@ -87878,11 +88539,34 @@ async function handleWorkspaceKey(context, chunk, key) {
     if (chunk !== "/") return true;
   }
   if (state.focus === "sidebar") {
-    const count = state.workspace === "chats" ? state.recentChats.length + 1 : state.workspace === "projects" ? state.projects.length : state.workspace === "tasks" ? state.tasks.length : state.workspace === "apps" ? state.apps.length : state.workflows.length;
+    const chatRows = tuiChatSidebarRows(state);
+    const count = state.workspace === "chats" ? chatRows.length : state.workspace === "projects" ? state.projects.length : state.workspace === "tasks" ? state.tasks.length : state.workspace === "apps" ? state.apps.length : state.workflows.length;
     if (key.name === "up" || key.name === "down") state.sidebarIndex = Math.max(0, Math.min(count - 1, state.sidebarIndex + (key.name === "up" ? -1 : 1)));
     else if (key.name === "return") {
-      if (state.workspace === "chats") await context.command(state.sidebarIndex === 0 ? "/new" : `/chat ${state.recentChats[state.sidebarIndex - 1]?.id}`);
-      else if (state.workspace === "projects") await context.command(`/project ${state.projects[state.sidebarIndex]?.id}`);
+      if (state.workspace === "chats") {
+        if (state.chatProjectBusy) return true;
+        const row = chatRows[state.sidebarIndex];
+        if (row?.kind === "new") await context.command("/new");
+        else if (row?.kind === "chat") await context.command(`/chat ${row.chatId}`);
+        else if (row?.kind === "path") state.chatSidebarAncestors = !state.chatSidebarAncestors;
+        else if (row?.kind === "create" && state.chatProjectOperation) await context.command(`/chat-create-project ${state.chatProjectOperation.chatIds.join(" ")}`);
+        else if (row?.kind === "choose" && state.chatProjectOperation) {
+          const operation = state.chatProjectOperation;
+          state.chatProjectBusy = true;
+          try {
+            await placeTuiChats(state, client2, operation.chatIds, { projectId: row.projectId, folderId: row.folderId ?? null }, operation.mode);
+            state.chatProjectOperation = null;
+            state.status = null;
+          } finally {
+            state.chatProjectBusy = false;
+            await refreshTuiChatSidebar(state, client2, render, true);
+          }
+        } else if (row && ["project", "folder", "up"].includes(row.kind)) {
+          state.chatSidebarLocation = row.kind === "up" && row.folderId === void 0 ? null : { projectId: row.projectId, folderId: row.folderId ?? null };
+          state.chatSidebarAncestors = false;
+          state.sidebarIndex = 0;
+        }
+      } else if (state.workspace === "projects") await context.command(`/project ${state.projects[state.sidebarIndex]?.id}`);
       else if (state.workspace === "tasks") await openTask(context, state.tasks[state.sidebarIndex]?.taskId ?? "");
       else if (state.workspace === "workflows") await context.command(`/workflow ${state.workflows[state.sidebarIndex]?.id}`);
       else if (state.workspace === "apps") await context.command(`/app ${state.apps[state.sidebarIndex]?.id}`);
@@ -88269,6 +88953,27 @@ async function runTui(client2, terminal = new TuiTerminal()) {
   let resolveResult = null;
   let renderTimer = null;
   let closed = false;
+  let stopActivity;
+  let activityTimer;
+  let refreshingActivity = false;
+  const refreshActivity = async () => {
+    if (closed || refreshingActivity || !state.signedIn) return;
+    refreshingActivity = true;
+    try {
+      await refreshTuiChatSidebar(state, client2, render);
+    } finally {
+      refreshingActivity = false;
+    }
+  };
+  const activityPoll = setInterval(() => {
+    void refreshActivity();
+  }, 3e4);
+  const activityAnimation = setInterval(() => {
+    if (!closed && state.runningChatIds.length) {
+      state.activityFrame = (state.activityFrame + 1) % 4;
+      render();
+    }
+  }, 250);
   const render = () => {
     if (closed) return;
     if (state.screen !== "chat") client2.clearInteractiveChatViewer();
@@ -88284,6 +88989,10 @@ async function runTui(client2, terminal = new TuiTerminal()) {
   };
   const finish = (result) => {
     closed = true;
+    stopActivity?.();
+    clearTimeout(activityTimer);
+    clearInterval(activityPoll);
+    clearInterval(activityAnimation);
     client2.endInteractiveViewerSession();
     if (renderTimer) clearTimeout(renderTimer);
     renderTimer = null;
@@ -88300,6 +89009,19 @@ async function runTui(client2, terminal = new TuiTerminal()) {
   });
   render();
   void loadHomeData(state, client2, render);
+  void refreshActivity();
+  if (state.signedIn && typeof client2.observeChatActivity === "function") {
+    void client2.observeChatActivity(() => {
+      clearTimeout(activityTimer);
+      activityTimer = setTimeout(() => {
+        void refreshActivity();
+      }, 300);
+    }).then((stop) => {
+      if (closed) stop();
+      else stopActivity = stop;
+    }).catch(() => {
+    });
+  }
   return new Promise((resolve18) => {
     resolveResult = resolve18;
   });
@@ -88612,12 +89334,12 @@ async function sendTuiMessage(params) {
   if (sourceExample) state.messages = sourceExample.messages.map((m) => ({ role: m.role === "user" ? "user" : "assistant", content: m.content, title: m.senderName }));
   const messages = state.messages;
   const existingChatId = sourceExample ? null : state.activeChatId;
-  const chatId = existingChatId ?? randomUUID20();
+  const chatId = existingChatId ?? randomUUID21();
   const draftKey = sourceExample ? `example:${sourceExample.chat.id}` : existingChatId ?? "new";
   state.drafts[draftKey] = "";
   state.input = "";
   state.inputCursor = null;
-  const anonymousHistory = history ?? messages.filter((m) => m.role !== "system").map((m) => ({ message_id: randomUUID20(), role: m.role, content: m.content, sender_name: m.title ?? (m.role === "user" ? "User" : "Assistant"), created_at: Math.floor(Date.now() / 1e3) }));
+  const anonymousHistory = history ?? messages.filter((m) => m.role !== "system").map((m) => ({ message_id: randomUUID21(), role: m.role, content: m.content, sender_name: m.title ?? (m.role === "user" ? "User" : "Assistant"), created_at: Math.floor(Date.now() / 1e3) }));
   state.activeChatId = chatId;
   state.headerState = existingChatId ? "ready" : "loading";
   state.headerError = null;
@@ -89042,7 +89764,7 @@ function clamp(value, min, max) {
 }
 
 // src/codexTaskBridge.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync15, readFileSync as readFileSync16, readdirSync as readdirSync8 } from "fs";
 import { isAbsolute as isAbsolute4, join as join18, resolve as resolve10 } from "path";
@@ -89085,7 +89807,7 @@ async function flushCodexChatDeletions(client2, teamId, stateRoot, notice) {
   const session = client2.getSession();
   const scope2 = [session.apiUrl, session.hashedEmail, teamId || "personal"];
   const account = JSON.stringify(scope2);
-  const directory = join18(stateRoot, "codex-chat-deletions", createHash22("sha256").update(account).digest("hex"));
+  const directory = join18(stateRoot, "codex-chat-deletions", createHash23("sha256").update(account).digest("hex"));
   if (!existsSync15(directory)) return;
   const release2 = await lockfile5.lock(directory, { retries: 0, stale: 24e4 });
   try {
@@ -89119,14 +89841,14 @@ async function flushCodexChatDeletions(client2, teamId, stateRoot, notice) {
 }
 
 // src/taskCommandDelivery.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 import { existsSync as existsSync16, readFileSync as readFileSync17, readdirSync as readdirSync9 } from "fs";
 import { join as join19 } from "path";
 import lockfile6 from "proper-lockfile";
 async function flushTaskCommands(client2, teamId, root = resolveStateDir(), onNotice) {
   const session = client2.getSession();
   const scope2 = [session.apiUrl, session.hashedEmail, teamId || "personal"];
-  const directory = join19(root, "task-command-delivery", createHash23("sha256").update(JSON.stringify(scope2)).digest("hex"));
+  const directory = join19(root, "task-command-delivery", createHash24("sha256").update(JSON.stringify(scope2)).digest("hex"));
   if (!existsSync16(directory)) return;
   const release2 = await lockfile6.lock(directory, { retries: 0, stale: 24e4 });
   try {
@@ -89236,7 +89958,7 @@ import {
   writeFileSync as writeFileSync13
 } from "fs";
 import { spawn as spawn7 } from "child_process";
-import { createHash as createHash29 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 import { extname as extname4, join as join26, resolve as resolve16, relative as relative11 } from "path";
 
 // src/projectSourceRootPolicy.ts
@@ -89271,7 +89993,7 @@ function isEqualOrInside(parent, candidate) {
 }
 
 // src/projectPathPolicy.ts
-import { createHash as createHash24, randomBytes as randomBytes12 } from "crypto";
+import { createHash as createHash25, randomBytes as randomBytes12 } from "crypto";
 import {
   chmodSync as chmodSync9,
   closeSync as closeSync5,
@@ -89552,7 +90274,7 @@ function isInside2(root, candidate) {
   return relation === "" || !relation.startsWith("..") && !isAbsolute5(relation);
 }
 function sha2563(value) {
-  return createHash24("sha256").update(value).digest("hex");
+  return createHash25("sha256").update(value).digest("hex");
 }
 function stableJson2(value) {
   return JSON.stringify(value, (_key, item) => {
@@ -89562,7 +90284,7 @@ function stableJson2(value) {
 }
 
 // src/remoteFileWrites.ts
-import { createHash as createHash25, randomBytes as randomBytes13 } from "crypto";
+import { createHash as createHash26, randomBytes as randomBytes13 } from "crypto";
 import {
   chmodSync as chmodSync10,
   closeSync as closeSync7,
@@ -89827,7 +90549,7 @@ var MAX_FILE_BYTES2 = 200 * 1024;
 var LOCK_ROOT = join22(tmpdir5(), `openmates-remote-file-locks-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
 var DEFAULT_JOURNAL_ROOT = join22(tmpdir5(), `openmates-remote-file-journal-${typeof process.getuid === "function" ? process.getuid() : "user"}`);
 function sha256ProjectFile(content) {
-  return createHash25("sha256").update(content).digest("hex");
+  return createHash26("sha256").update(content).digest("hex");
 }
 async function executeRemoteFileMutation(options) {
   const mutation = validateMutation(options.mutation);
@@ -90515,13 +91237,13 @@ import { existsSync as existsSync23, realpathSync as realpathSync10, statSync as
 import { basename as basename7, dirname as dirname13, relative as relative10, resolve as resolve15 } from "path";
 
 // src/remoteCommandRuntime.ts
-import { createHash as createHash27, randomUUID as randomUUID21 } from "crypto";
+import { createHash as createHash28, randomUUID as randomUUID22 } from "crypto";
 import { spawn as spawn6, spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync21, lstatSync as lstatSync9, readdirSync as readdirSync12, realpathSync as realpathSync7, statSync as statSync6 } from "fs";
 import { isAbsolute as isAbsolute8, join as join23, relative as relative7, resolve as resolve14, sep } from "path";
 
 // src/remoteCommandAppArmor.ts
-import { createHash as createHash26 } from "crypto";
+import { createHash as createHash27 } from "crypto";
 import { spawn as spawn5 } from "child_process";
 import { lstatSync as lstatSync8, readFileSync as readFileSync19, realpathSync as realpathSync6, statSync as statSync5 } from "fs";
 import { isAbsolute as isAbsolute7, relative as relative6 } from "path";
@@ -90738,7 +91460,7 @@ function hasControl2(value) {
   });
 }
 function sha2564(value) {
-  return createHash26("sha256").update(value).digest("hex");
+  return createHash27("sha256").update(value).digest("hex");
 }
 
 // src/remoteCommandRuntime.ts
@@ -91142,7 +91864,7 @@ var RemoteCommandRuntime = class {
 };
 function createRemoteCommandPreflight(request) {
   if (!request || typeof request !== "object") throw new RemoteCommandError("invalid_request", "Command request must be an object");
-  const executionId = request.execution_id ?? randomUUID21();
+  const executionId = request.execution_id ?? randomUUID22();
   if (typeof executionId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(executionId)) throw new RemoteCommandError("invalid_request", "Invalid execution ID");
   if (typeof request.project_id !== "string" || !request.project_id || request.project_id.length > 256) throw new RemoteCommandError("invalid_request", "Invalid Project ID");
   if (typeof request.source_root !== "string" || !request.source_root) throw new RemoteCommandError("invalid_request", "Invalid Project source root");
@@ -91579,7 +92301,7 @@ function stableJson4(value) {
   return JSON.stringify(value);
 }
 function sha2565(value) {
-  return createHash27("sha256").update(value).digest("hex");
+  return createHash28("sha256").update(value).digest("hex");
 }
 function deepFreeze(value) {
   if (value && typeof value === "object") {
@@ -91857,7 +92579,7 @@ function capabilityError(message) {
 }
 
 // src/remoteCommandResourceGrants.ts
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 import { chmodSync as chmodSync12, existsSync as existsSync22, lstatSync as lstatSync10, mkdirSync as mkdirSync18, readFileSync as readFileSync20, realpathSync as realpathSync9, renameSync as renameSync9, statSync as statSync8, writeFileSync as writeFileSync12 } from "fs";
 import { isAbsolute as isAbsolute10, join as join25, relative as relative9 } from "path";
 var STORE_FILE = "remote-command-resource-grants.json";
@@ -91952,7 +92674,7 @@ function resolveRemoteCommandResourceGrants(context) {
   return { writable_targets, network_profiles, credential_profiles };
 }
 function definitionDigest(kind, definition) {
-  return createHash28("sha256").update(JSON.stringify(["openmates-command-resource-v1", kind, definition])).digest("hex");
+  return createHash29("sha256").update(JSON.stringify(["openmates-command-resource-v1", kind, definition])).digest("hex");
 }
 function upsert(grant) {
   validateIdentity(grant.project_id, grant.source_id, grant.profile_id);
@@ -93122,7 +93844,7 @@ function readRemoteAccessTextFile(options) {
       truncated,
       sizeBytes: stats.size,
       lineCount: countTextLines(content),
-      expected_base: truncated ? null : createHash29("sha256").update(bytes2.subarray(0, bytesRead)).digest("hex")
+      expected_base: truncated ? null : createHash30("sha256").update(bytes2.subarray(0, bytesRead)).digest("hex")
     };
   } catch (error) {
     const code = error.code;
@@ -93172,7 +93894,7 @@ function readRemoteAccessImageChunk(options) {
       mime_type: mimeType,
       size_bytes: stats.size,
       offset: options.offset,
-      content_hash: createHash29("sha256").update(bytes2).digest("hex")
+      content_hash: createHash30("sha256").update(bytes2).digest("hex")
     };
   } catch (error) {
     if (error.code === "ELOOP") throw new Error("Remote source path is a symbolic link");
@@ -93220,8 +93942,8 @@ function readRemoteAccessFileChunk(options) {
       content_base64: bytes2.toString("base64"),
       size_bytes: stats.size,
       offset: options.offset,
-      file_identity: createHash29("sha256").update(`${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`).digest("hex"),
-      chunk_hash: createHash29("sha256").update(bytes2).digest("hex")
+      file_identity: createHash30("sha256").update(`${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`).digest("hex"),
+      chunk_hash: createHash30("sha256").update(bytes2).digest("hex")
     };
   } catch (error) {
     if (error.code === "ELOOP") throw new Error("Remote source path is a symbolic link");
@@ -94783,7 +95505,7 @@ function writeWorkRecoveryAtomically(path2, document) {
 
 // src/revolutBusinessCertificate.ts
 import { execFileSync as execFileSync6 } from "child_process";
-import { createSign, randomUUID as randomUUID22 } from "crypto";
+import { createSign, randomUUID as randomUUID23 } from "crypto";
 import { chmodSync as chmodSync14, existsSync as existsSync25, mkdirSync as mkdirSync22, readFileSync as readFileSync23 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join28, resolve as resolve17 } from "path";
@@ -94857,7 +95579,7 @@ function generateRevolutBusinessClientAssertion(options) {
     aud: REVOLUT_BUSINESS_AUDIENCE,
     exp: now + 3600,
     iat: now,
-    jti: randomUUID22()
+    jti: randomUUID23()
   });
   const unsigned = `${header2}.${payload}`;
   const signer = createSign("RSA-SHA256");
@@ -96230,6 +96952,7 @@ async function tryResolveWorkflow(client2, target, flags) {
   return singleExactNameMatch(workflows, target, (workflow) => workflow.title);
 }
 async function requiredResolvedWorkflowId(client2, target, flags, _action) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(target)) return target;
   const workflow = await tryResolveWorkflow(client2, target, flags);
   if (!workflow) throw new Error(`Workflow '${target}' not found.`);
   return workflow.id;
@@ -96329,7 +97052,7 @@ async function resolveAddToProjectStorageChoice(client2, project, flags, objectT
 async function createEncryptedProjectItem(client2, project, input) {
   const timestamp = nowSeconds3();
   return client2.createProjectItem(project.projectId, {
-    project_item_id: randomUUID23(),
+    project_item_id: randomUUID24(),
     folder_id: input.folderId ?? null,
     item_type: input.itemType,
     target_id: input.targetId,
@@ -96528,7 +97251,7 @@ async function handlePlans(client2, subcommand, rest, flags, redactor) {
     const encryptedSources = proof.length ? await encryptPlanAssumptionSources(plan, masterKey, proof) : void 0;
     if (action === "create" || action === "add") {
       const assumption = await client2.createPlanAssumption(plan.planId, {
-        assumption_id: typeof flags.id === "string" ? flags.id : randomUUID23(),
+        assumption_id: typeof flags.id === "string" ? flags.id : randomUUID24(),
         encrypted_text: await encryptPlanAssumptionSources(plan, masterKey, requiredStringFlag(flags.text ?? rest.slice(2).join(" "), "--text <assumption>")),
         status: typeof flags.status === "string" ? flags.status : void 0,
         linked_sub_chat_id: typeof flags["sub-chat"] === "string" ? flags["sub-chat"] : void 0,
@@ -96570,7 +97293,7 @@ async function handlePlans(client2, subcommand, rest, flags, redactor) {
     if (action === "diff") throw new Error("Revision diffs are reviewed in the authenticated web review page; use submit-for-review to print its URL.");
     if (action !== "submit-for-review") throw new Error("Usage: openmates plans revisions list|submit-for-review|status|diff <plan-id>");
     const snapshot2 = JSON.stringify(planToJson(plan));
-    const revision = await client2.submitPlanRevision(plan.planId, { fingerprint: createHash30("sha256").update(snapshot2).digest("hex"), encrypted_snapshot: await encryptPlanAssumptionSources(plan, masterKey, snapshot2), created_at: nowSeconds3() });
+    const revision = await client2.submitPlanRevision(plan.planId, { fingerprint: createHash31("sha256").update(snapshot2).digest("hex"), encrypted_snapshot: await encryptPlanAssumptionSources(plan, masterKey, snapshot2), created_at: nowSeconds3() });
     const reviewUrl = `${deriveAppUrl(client2.apiUrl)}/plans/${plan.planId}/review?revision=${revision.revision_id}`;
     if (flags.json === true) printJson2({ revision, review_url: reviewUrl });
     else console.log(`Plan revision submitted for web review: ${reviewUrl}`);
@@ -97464,7 +98187,7 @@ async function handleProjects(client2, subcommand, rest, flags, redactor) {
     const writeMode = await resolveProjectWriteMode(flags, `Choose how OpenMates may change files in ${JSON.stringify(name)}:`);
     const projectKey = randomBytes14(32);
     const wrapping = await client2.projectWrappingKey(context);
-    const projectId = randomUUID23();
+    const projectId = randomUUID24();
     const timestamp = nowSeconds3();
     const defaultFocus = buildProjectDefaultFocus(name);
     const slugMetadata = await buildEncryptedObjectSlugMetadata({
@@ -97490,7 +98213,7 @@ async function handleProjects(client2, subcommand, rest, flags, redactor) {
       encrypted_settings: await encryptWithAesGcmCombined(JSON.stringify({ default_focus: defaultFocus }), projectKey),
       key_wrappers: wrapping.teamId ? [{
         key_type: "team",
-        hashed_team_id: createHash30("sha256").update(wrapping.teamId).digest("hex"),
+        hashed_team_id: createHash31("sha256").update(wrapping.teamId).digest("hex"),
         team_key_epoch: 1,
         encrypted_project_key: await encryptBytesWithAesGcm(projectKey, wrapping.key),
         wrapper_version: 1,
@@ -97730,7 +98453,7 @@ async function handleProjects(client2, subcommand, rest, flags, redactor) {
     const proposal = isShortWorkspaceAsk(instruction) ? { name: instruction, description: "", icon: "folder", color: "default" } : extractRecord(await client2.planProjectAsk({ instruction }), "proposed_project");
     const projectKey = randomBytes14(32);
     const timestamp = Math.floor(Date.now() / 1e3);
-    const projectId = randomUUID23();
+    const projectId = randomUUID24();
     const name = requiredString(proposal, "name", instruction);
     const slugMetadata = await buildEncryptedObjectSlugMetadata({
       value: typeof flags.slug === "string" ? flags.slug : name,
@@ -97853,8 +98576,8 @@ async function handleProjectFiles(client2, masterKey, rest, flags, context) {
     ...flags["include-ignored"] === true ? {
       approvedIgnoredRead: {
         path: String(argumentsValue.path),
-        chatId: `cli-direct-${randomUUID23()}`,
-        operationId: `cli-direct-${randomUUID23()}`
+        chatId: `cli-direct-${randomUUID24()}`,
+        operationId: `cli-direct-${randomUUID24()}`
       }
     } : {}
   });
@@ -98642,7 +99365,7 @@ async function handleRemoteAccess(client2, subcommand, rest, flags) {
     const projects = await loadProjects(client2, masterKey, hostingFlags, hostingContext);
     const bindings = await resolveRemoteAccessBindings(client2, masterKey, projects, candidateRoots, hostingFlags, hostingContext);
     if (bindings.length === 0) throw new Error("No Project folders were approved for remote access.");
-    const sourceSessionId = randomUUID23();
+    const sourceSessionId = randomUUID24();
     const controller = new AbortController();
     const stop = () => controller.abort();
     process.once("SIGINT", stop);
@@ -98796,7 +99519,7 @@ async function resolveRemoteAccessBindings(client2, masterKey, projects, candida
           updated_at: nowSeconds3()
         }, context);
       }
-      resolved.push({ rootPath, project, sourceId: randomUUID23() });
+      resolved.push({ rootPath, project, sourceId: randomUUID24() });
     }
   }
   const bindings = [];
@@ -98840,7 +99563,7 @@ async function resolveRemoteAccessBindings(client2, masterKey, projects, candida
 }
 async function createEncryptedRemoteAccessProject(client2, name, rootPath, writeMode, context) {
   const projectKey = randomBytes14(32);
-  const projectId = randomUUID23();
+  const projectId = randomUUID24();
   const timestamp = Math.floor(Date.now() / 1e3);
   const wrapping = await client2.projectWrappingKey(context);
   const importedInstructions = readRootProjectInstructions(rootPath);
@@ -98866,7 +99589,7 @@ async function createEncryptedRemoteAccessProject(client2, name, rootPath, write
     encrypted_settings: await encryptWithAesGcmCombined(JSON.stringify({ default_focus: defaultFocus }), projectKey),
     key_wrappers: wrapping.teamId ? [{
       key_type: "team",
-      hashed_team_id: createHash30("sha256").update(wrapping.teamId).digest("hex"),
+      hashed_team_id: createHash31("sha256").update(wrapping.teamId).digest("hex"),
       team_key_epoch: 1,
       encrypted_project_key: await encryptBytesWithAesGcm(projectKey, wrapping.key),
       wrapper_version: 1,
@@ -98924,7 +99647,7 @@ async function ensureProjectDefaultFocus(client2, project, context, rootPath) {
 function buildProjectDefaultFocus(projectName, instructions, source = "generated") {
   const name = projectName.trim() || "Untitled project";
   return {
-    focus_id: randomUUID23(),
+    focus_id: randomUUID24(),
     name: `Work on ${name}`,
     instructions: instructions?.trim() || `Help with work in ${name}. Follow the user's instructions and the Project's connected source guidance.`,
     source
@@ -100257,7 +100980,7 @@ function normalizeApiKeyLoadedChat(payload) {
   const messages = rawMessages.map((message) => {
     const messageId = String(message.client_message_id ?? message.message_id ?? message.id ?? "");
     const directEmbedIds = Array.isArray(message.embedIds) ? message.embedIds : Array.isArray(message.embed_ids) ? message.embed_ids : [];
-    const hashedMessageId = messageId ? createHash30("sha256").update(messageId).digest("hex") : null;
+    const hashedMessageId = messageId ? createHash31("sha256").update(messageId).digest("hex") : null;
     const matchedEmbedIds = hashedMessageId ? rawEmbeds.filter((embed) => embed.hashed_message_id === hashedMessageId && !embed.parent_embed_id).map((embed) => String(embed.embed_id ?? embed.id ?? "")).filter(Boolean) : [];
     return {
       id: messageId,
@@ -100805,6 +101528,52 @@ async function handleWorkflows(client2, subcommand, rest, flags, redactor) {
     }
     return;
   }
+  if (subcommand === "save-as-reusable") {
+    const workflowId = rest[0] ? await requiredResolvedWorkflowId(client2, rest[0], flags, "save-as-reusable") : void 0;
+    if (!workflowId) throw new Error("Missing workflow ID. Example: openmates workflows save-as-reusable <id>");
+    const idempotencyKey = typeof flags["idempotency-key"] === "string" ? flags["idempotency-key"] : "";
+    if (!idempotencyKey) throw new Error("Missing --idempotency-key for workflow save-as-reusable.");
+    const workflow = await client2.saveWorkflowAsReusable(workflowId, { idempotencyKey });
+    if (flags.json === true) printJson2(workflow);
+    else printWorkflowDetail(workflow);
+    return;
+  }
+  const runRouting = () => ({
+    ...typeof flags["source-chat"] === "string" ? { sourceChatId: flags["source-chat"] } : {},
+    ...typeof flags["message-destination-overrides"] === "string" ? { messageDestinationOverrides: parseJsonFlag(flags["message-destination-overrides"], "--message-destination-overrides") } : {},
+    ...typeof flags["return-outputs"] === "string" ? { returnOutputs: parseJsonFlag(flags["return-outputs"], "--return-outputs") } : {}
+  });
+  if (subcommand === "run-once") {
+    const titleFlag = typeof flags.title === "string" ? flags.title.trim() : "";
+    const graphFlag = typeof flags.graph === "string" ? flags.graph : "";
+    const fileFlag = typeof flags.file === "string" ? flags.file : "";
+    if (Boolean(graphFlag) === Boolean(fileFlag)) throw new Error("Specify exactly one of --graph JSON or --file definition.workflow.yml for run-once.");
+    let graph;
+    let title = titleFlag;
+    if (fileFlag) {
+      assertWorkflowFilePath(fileFlag);
+      if (statSync11(fileFlag).size > WORKFLOW_FILE_MAX_BYTES) throw new Error("Workflow file exceeds the size limit.");
+      const yaml = parseYamlDocument(readFileSync24(fileFlag, "utf8"), { uniqueKeys: true, strict: true });
+      if (yaml.errors.length > 0) throw new Error(`Invalid workflow YAML: ${yaml.errors[0].message}`);
+      const document = validateWorkflowFile(yaml.toJS({ maxAliasCount: 20 }));
+      graph = document.workflow.graph;
+      title ||= document.workflow.title;
+    } else graph = parseJsonFlag(graphFlag, "--graph");
+    if (!title) throw new Error("Missing --title for workflow run-once.");
+    const idempotencyKey = typeof flags["idempotency-key"] === "string" ? flags["idempotency-key"] : "";
+    if (!idempotencyKey) throw new Error("Missing --idempotency-key for workflow run-once.");
+    const sourceChatId = flags["source-chat"];
+    if (typeof sourceChatId !== "string" || !sourceChatId) throw new Error("Missing --source-chat for workflow run-once.");
+    const input = typeof flags.input === "string" ? parseJsonFlag(flags.input, "--input") : {};
+    const result = await client2.runWorkflowOnce({ title, graph, idempotencyKey, input, ...runRouting(), sourceChatId });
+    if (flags.wait === true) result.run = await waitForWorkflowRun(client2, result.workflow.id, result.run);
+    if (flags.json === true) printJson2(result);
+    else {
+      printWorkflowDetail(result.workflow);
+      printWorkflowRun(result.run);
+    }
+    return;
+  }
   if (subcommand === "run") {
     const workflowId = rest[0] ? await requiredResolvedWorkflowId(client2, rest[0], flags, "run") : void 0;
     if (!workflowId) throw new Error("Missing workflow ID. Example: openmates workflows run <id>");
@@ -100812,7 +101581,7 @@ async function handleWorkflows(client2, subcommand, rest, flags, redactor) {
     if (!idempotencyKey) throw new Error("Missing --idempotency-key. Reuse this stable key when retrying the same workflow run.");
     const mode = flags.mode === "test" ? "test" : "manual";
     const input = typeof flags.input === "string" ? parseJsonFlag(flags.input, "--input") : {};
-    let run = await client2.runWorkflow(workflowId, { idempotencyKey, mode, input });
+    let run = await client2.runWorkflow(workflowId, { idempotencyKey, mode, input, ...runRouting() });
     if (flags.wait === true) {
       run = await waitForWorkflowRun(client2, workflowId, run);
     }
@@ -102454,7 +103223,7 @@ async function runAccountImport(client2, parserFormat, file, flags) {
   if (flags.yes !== true) {
     await confirmOrExit(`Import ${selectedCount} chat(s) into new encrypted OpenMates chats? [y/N] `);
   }
-  const importId = typeof preview.import_id === "string" ? preview.import_id : randomUUID23();
+  const importId = typeof preview.import_id === "string" ? preview.import_id : randomUUID24();
   const selectedChats = parsed.chats.slice(0, selectedCount);
   const selectedFingerprints = selectedChats.map((chat) => chat.source_fingerprint);
   const confirmation = await client2.confirmAccountImport(importId, selectedFingerprints);
@@ -102948,8 +103717,8 @@ async function handleFinance(client2, subcommand, _rest, flags) {
         refresh_token_envelope: connectedAccount.refreshTokenBundle
       }
     ] : [],
-    chatId: `cli-finance-${randomUUID23()}`,
-    messageId: `cli-finance-message-${randomUUID23()}`,
+    chatId: `cli-finance-${randomUUID24()}`,
+    messageId: `cli-finance-message-${randomUUID24()}`,
     apiKey: resolveApiKey(flags) ?? void 0,
     promptInjectionProtection: false
   });
@@ -107174,7 +107943,9 @@ function printWorkflowsHelp() {
   openmates workflows show <workflow-id> [--json]
   openmates workflows enable <workflow-id> [--json]
   openmates workflows disable <workflow-id> [--json]
-  openmates workflows run <workflow-id> --idempotency-key <stable-key> [--mode manual|test] [--input '<json>'] [--wait] [--json]
+  openmates workflows run <workflow-id> --idempotency-key <stable-key> [--mode manual|test] [--input '<json>'] [--source-chat <id>] [--message-destination-overrides '<json>'] [--return-outputs '<json>'] [--wait] [--json]
+  openmates workflows run-once (--title <title> --graph '<json>' | --file definition.workflow.yml) --source-chat <id> --idempotency-key <stable-key> [--input '<json>'] [--message-destination-overrides '<json>'] [--return-outputs '<json>'] [--wait] [--json]
+  openmates workflows save-as-reusable <workflow-id> --idempotency-key <stable-key> [--json]
   openmates workflows runs <workflow-id> [--json]
   openmates workflows run-show <workflow-id> <run-id> [--json]
   openmates workflows run-cancel <workflow-id> <run-id> [--json]
@@ -107189,6 +107960,9 @@ Workflows run on the OpenMates server, not in this terminal process. The CLI
 uses your paired session and shows the same workflow/run records as web, SDKs,
 and Apple clients.
 Export writes a saved workflow's portable authoring graph to .workflow.yml.
+Run-once keeps its definition with the source chat. Save-as-reusable creates a new disabled workflow.
+--message-destination-overrides maps Send step IDs to owned chat IDs.
+--return-outputs maps result names to {"ref":"$nodes.<step>.output.<field>","type":"string"}.
 Run history and account bindings are excluded. Import creates a disabled workflow;
 review and complete its bindings before enabling it.
 Import creates a Personal Workflow. In an active Team context, pass --personal