openmates 0.27.0-alpha.80 → 0.27.0-alpha.82

package/dist/{chunk-VTD4VHNF.js → chunk-4TPIRQDS.js}

@@ -778,6 +778,45 @@ function assertCodexClaimCaller(threadId, currentThread = process.env.CODEX_THRE
   }
 }
 
+// src/recoveryBatch.ts
+async function runRecoveryBatch(items, work, dependsOn = () => false) {
+  const results = new Array(items.length);
+  const pending = new Set(items.map((_, index) => index));
+  const complete = /* @__PURE__ */ new Set();
+  const active = /* @__PURE__ */ new Map();
+  let failed = false;
+  let failure2;
+  while (pending.size || active.size) {
+    if (!failed) for (const index of pending) {
+      if (active.size >= 4) break;
+      if (items.some((dependency, other) => other !== index && !complete.has(other) && dependsOn(items[index], dependency, index, other))) continue;
+      pending.delete(index);
+      const task = Promise.resolve().then(() => work(items[index], index)).then(
+        (result) => {
+          results[index] = result;
+          complete.add(index);
+        },
+        (error) => {
+          if (!failed) {
+            failed = true;
+            failure2 = error;
+          }
+        }
+      ).finally(() => {
+        active.delete(index);
+      });
+      active.set(index, task);
+    }
+    if (!active.size) {
+      if (failed) throw failure2;
+      throw new Error("Recovery embed dependency is cyclic or unresolved; outputs remain pending.");
+    }
+    await Promise.race(active.values());
+    if (failed && !active.size) throw failure2;
+  }
+  return results;
+}
+
 // src/preparedPrivacy.ts
 var PREPARED_PRIVACY_IDLE_MS = 2 * 60 * 6e4;
 var PreparedPrivacyCache = class {
@@ -6217,6 +6256,68 @@ function parseFocusAuthoringDocument(document) {
     throw new Error("invalid_focus_document");
   }
 }
+async function collectSelectedCliProjectFocusRoutingCatalog(client2, projectId, options) {
+  const detail = await client2.getProject(projectId, options);
+  if (detail.project.project_id !== projectId || detail.project.archived) throw new Error("Project catalog unavailable.");
+  const key = await client2.decryptProjectKey(detail.project, options);
+  const focuses = [];
+  for (const item of detail.items) {
+    if (!(["embed", "upload"].includes(item.item_type) && item.target_id_hash && !item.deleted_target_state && typeof item.encrypted_metadata === "string")) continue;
+    const decrypted = await decryptWithAesGcmCombined(item.encrypted_metadata, key);
+    if (!decrypted) throw new Error("Project catalog metadata unavailable.");
+    const metadata = JSON.parse(decrypted);
+    const path2 = metadata.display_path;
+    if (typeof path2 !== "string" || !/^\.openmates\/focuses\/[a-zA-Z0-9_-]+\/SKILL\.md$/.test(path2) || typeof metadata.focus_title !== "string" || typeof metadata.focus_description !== "string" || typeof metadata.focus_when_to_use !== "string") continue;
+    focuses.push({
+      item_id: item.project_item_id,
+      revision: createHash9("sha256").update(["updated_at", "encrypted_metadata", "encrypted_note", "target_id_hash", "deleted_target_state"].map((field3) => item[field3] ? String(item[field3]) : "").join("\0")).digest("hex"),
+      title: metadata.focus_title.slice(0, 180),
+      description: metadata.focus_description.slice(0, 640),
+      when_to_use: metadata.focus_when_to_use.slice(0, 640)
+    });
+    if (focuses.length >= 20) break;
+  }
+  return focuses;
+}
+function registerCliProjectFocusCatalogResponder(input) {
+  let active = true;
+  const answered = /* @__PURE__ */ new Set();
+  const stopEvent = input.ws.onMessageType("project_focus_catalog_requested", (event) => {
+    if (!active || !input.ws.isOpen() || !input.isCurrent() || event.chat_id !== input.chatId || typeof event.request_id !== "string" || !event.request_id || event.request_id.length > 128 || typeof event.project_id !== "string" || !event.project_id || event.project_id.length > 128 || event.team_id !== input.teamId || !input.isOfferedProject(event.project_id) || answered.has(event.request_id)) return;
+    answered.add(event.request_id);
+    void (async () => {
+      let focuses;
+      try {
+        focuses = await collectSelectedCliProjectFocusRoutingCatalog(
+          input.client,
+          event.project_id,
+          { teamId: input.teamId, personal: !input.teamId }
+        );
+      } catch {
+        focuses = null;
+      }
+      if (!active || !input.ws.isOpen() || !input.isCurrent()) return;
+      await input.ws.sendAsync("project_focus_catalog_result", {
+        chat_id: input.chatId,
+        request_id: event.request_id,
+        project_id: event.project_id,
+        focuses
+      });
+    })().catch((error) => {
+      if (!active || !input.ws.isOpen() || !input.isCurrent()) return;
+      input.onDeliveryFailure(error instanceof Error ? error : new Error("Project catalog delivery failed."));
+    });
+  });
+  const stopClose = input.ws.onClose(() => {
+    active = false;
+    stopEvent();
+  });
+  return () => {
+    active = false;
+    stopEvent();
+    stopClose();
+  };
+}
 async function discoverCliProjectCandidates(client2, options, requireComplete = false) {
   const records = (await client2.listProjects(options)).filter((record10) => !record10.archived).slice(0, 40);
   const entries = await Promise.all(records.map(async (record10) => {
@@ -13605,6 +13706,39 @@ var OpenMatesClient = class _OpenMatesClient {
   chatActivitySocket = null;
   preparedSendSocket = null;
   preparedSendSocketAttemptOwner = null;
+  foregroundSendCount = 0;
+  pendingSendSocketRearm = null;
+  cancelSendSocketRearm() {
+    const pending = this.pendingSendSocketRearm;
+    this.pendingSendSocketRearm = null;
+    pending?.removeClose();
+  }
+  maybeRearmSendSocket() {
+    const pending = this.pendingSendSocketRearm;
+    if (!pending || this.foregroundSendCount > 0 || pending.ws.isOpen()) return;
+    this.cancelSendSocketRearm();
+    if (!this.interactiveViewerAllowed || !this.preparedChatOwnerCurrent(pending.owner, pending.teamId) || pending.ownerKey !== this.sendSocketOwnerKey(this.requireSession(), pending.teamId) || authCookieFingerprint(this.http.getCookieMap()) !== authCookieFingerprint(this.requireSession().cookies)) return;
+    this.preparedSendSocketAttemptOwner = null;
+    this.warmSendSocket();
+  }
+  rearmSendSocketWhenClosed(ws, teamId) {
+    if (!this.interactiveViewerAllowed || !this.hasSession()) return;
+    this.cancelSendSocketRearm();
+    const session = this.requireSession();
+    const pending = {
+      ws,
+      teamId,
+      owner: this.preparedChatOwner(session, teamId),
+      ownerKey: this.sendSocketOwnerKey(session, teamId),
+      removeClose: () => {
+      }
+    };
+    this.pendingSendSocketRearm = pending;
+    pending.removeClose = ws.onClose(() => {
+      this.maybeRearmSendSocket();
+    });
+    this.maybeRearmSendSocket();
+  }
   sendSocketOwnerKey(session, teamId) {
     return JSON.stringify([
       this.preparedChatOwner(session, teamId),
@@ -13631,7 +13765,7 @@ var OpenMatesClient = class _OpenMatesClient {
   }
   /** Prepare one authenticated send socket for the interactive TUI's next turn. */
   warmSendSocket() {
-    if (!this.interactiveViewerAllowed || this.explicitSession || !this.hasSession()) return;
+    if (!this.interactiveViewerAllowed || this.foregroundSendCount > 0 || this.explicitSession || !this.hasSession()) return;
     const session = this.requireSession();
     const teamId = this.getActiveTeamId();
     const owner2 = this.preparedChatOwner(session, teamId);
@@ -15562,14 +15696,32 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     return { bySubject, acknowledged: /* @__PURE__ */ new Map(), visiting: /* @__PURE__ */ new Set() };
   }
+  captureRecoveryOwner() {
+    const account = this.captureTeamAccountOwner();
+    const team = this.getActiveTeamId();
+    const master = Buffer.from(this.getMasterKeyBytes());
+    return () => {
+      if (!this.hasSession() || !account.isCurrent() || this.getActiveTeamId() !== team || !master.equals(Buffer.from(this.getMasterKeyBytes()))) {
+        throw new Error("Recovery account, Team or key changed; outputs remain pending.");
+      }
+    };
+  }
   async persistAvailableRecoveryOutputs(ws, ownerId2, cache, outputs, teamId, dependencies = this.recoveryReplayDependencies([outputs])) {
     if (outputs.length > 100) throw new Error("Recovery output discovery exceeded the bounded batch size.");
     const order = { message: 0, embed: 1, diff: 2, summary: 3, checkpoint: 4 };
     const ordered = [...outputs].sort((a, b) => order[a.output_kind] - order[b.output_kind] || (a.output_kind === "message" && b.output_kind === "message" ? (a.message_role === "user" ? 0 : 1) - (b.message_role === "user" ? 0 : 1) : 0) || a.output_version - b.output_version);
+    const assertOwner = this.captureRecoveryOwner();
     const masterKey = this.getMasterKeyBytes();
     const wrappingKey = await this.getChatWrappingKey(teamId, masterKey);
+    const http = { get: async (path2, headers) => {
+      assertOwner();
+      const result = await this.http.get(path2, headers);
+      assertOwner();
+      return result;
+    } };
     let acknowledged = 0;
     const request = async (type, responseType, recordId, payload) => {
+      assertOwner();
       const requestId = randomUUID9();
       const response = ws.waitForMessage(responseType, (value) => {
         const frame = value;
@@ -15577,10 +15729,14 @@ var OpenMatesClient = class _OpenMatesClient {
       }, 2e4);
       void response.catch(() => {
       });
+      assertOwner();
       await ws.sendAsync(type, { protocol_version: 1, record_id: recordId, request_id: requestId, ...payload });
-      return (await response).payload;
+      const received = await response;
+      assertOwner();
+      return received.payload;
     };
     const storeWithReceipt = async (type, responseType, embedId, payload, recoveryRecordId, version2) => {
+      assertOwner();
       const requestId = randomUUID9();
       const receipt = ws.waitForMessage(
         responseType,
@@ -15589,8 +15745,11 @@ var OpenMatesClient = class _OpenMatesClient {
       );
       void receipt.catch(() => {
       });
+      assertOwner();
       await ws.sendAsync(type, { ...payload, request_id: requestId, recovery_record_id: recoveryRecordId });
-      return (await receipt).payload;
+      const received = await receipt;
+      assertOwner();
+      return received.payload;
     };
     const reconcileAcknowledgedEmbed = async (output, chatKey, sealedContent) => {
       if (output.output_kind !== "embed" && output.output_kind !== "diff") {
@@ -15613,7 +15772,7 @@ var OpenMatesClient = class _OpenMatesClient {
         throw new Error(`Recovery output ${output.record_id} lacks verified canonical acknowledgement.`);
       }
       const embedPath = `/v1/embeds/chats/${encodeURIComponent(output.target_chat_id)}/embeds/${encodeURIComponent(output.subject_id)}` + (teamId ? `?team_id=${encodeURIComponent(teamId)}` : "");
-      const canonical = await this.http.get(embedPath, this.getCliRequestHeaders());
+      const canonical = await http.get(embedPath, this.getCliRequestHeaders());
       const row3 = canonical.data?.embed;
       if (!canonical.ok || !row3 || row3.hashed_chat_id !== computeSHA256(output.target_chat_id) || typeof row3.encrypted_content !== "string" || typeof row3.encrypted_type !== "string") {
         throw new Error(`Recovery output ${output.record_id} canonical embed is unavailable.`);
@@ -15638,7 +15797,7 @@ var OpenMatesClient = class _OpenMatesClient {
       } else {
         const query = new URLSearchParams({ capability: "bounded-v1", chat_id: output.target_chat_id });
         if (teamId) query.set("team_id", teamId);
-        const history = await this.http.get(
+        const history = await http.get(
           `/v1/embeds/${encodeURIComponent(output.subject_id)}/versions/${output.output_version}?${query}`,
           this.getCliRequestHeaders()
         );
@@ -15652,12 +15811,14 @@ var OpenMatesClient = class _OpenMatesClient {
         if (typeof encryptedPatch === "string") await decryptWithAesGcmCombined(encryptedPatch, embedKey);
       }
     };
-    for (const output of ordered) {
+    const rootKeys = /* @__PURE__ */ new Map();
+    const prepareOne = async (output) => {
+      assertOwner();
       const identity3 = recoveryOutputIdentity(output);
       const committed = dependencies.acknowledged.get(output.record_id);
       if (committed !== void 0) {
         if (committed !== identity3) throw new Error("Acknowledged recovery dependency changed identity.");
-        continue;
+        return null;
       }
       if (dependencies.visiting.has(output.record_id) || dependencies.visiting.size >= 32) {
         throw new Error("Recovery embed dependency is cyclic or exceeds the bounded depth.");
@@ -15665,26 +15826,35 @@ var OpenMatesClient = class _OpenMatesClient {
       if (output.root_hashed_team_id !== void 0 && output.root_hashed_team_id !== (teamId ? computeSHA256(teamId) : null)) {
         throw new Error(`Recovery output ${output.record_id} Team key context is unavailable; output remains pending.`);
       }
-      let root = cache.chats.find((chat) => String(chat.details.id ?? "") === output.root_chat_id);
-      let rootKey = root ? await this.resolveChatKey(cache, root, wrappingKey, teamId) : null;
-      if (!rootKey) {
-        const response = await this.http.get(
-          `/v1/chats/${encodeURIComponent(output.root_chat_id)}/wrappers/window` + (teamId ? `?team_id=${encodeURIComponent(teamId)}` : ""),
-          this.getCliRequestHeaders()
-        );
-        if (!response.ok) throw new Error(`Recovery root key lookup failed (HTTP ${response.status}); output remains pending.`);
-        const keyType = teamId ? "team" : "master";
-        const wrapper = (response.data.wrappers ?? []).find((item) => item.key_type === keyType && typeof item.encrypted_chat_key === "string" && item.encrypted_chat_key);
-        if (!wrapper) throw new Error(`Recovery root chat ${output.root_chat_id} key wrapper is unavailable.`);
-        cache.chatKeyWrappers ??= [];
-        cache.chatKeyWrappers.push(wrapper);
-        if (!root) {
-          root = { details: { id: output.root_chat_id, encrypted_chat_key: wrapper.encrypted_chat_key }, messages: [] };
-          cache.chats.push(root);
-        }
-        rootKey = await this.resolveChatKey(cache, root, wrappingKey, teamId);
-      }
-      if (!rootKey) throw new Error(`Recovery root chat ${output.root_chat_id} key is unavailable.`);
+      let rootKeyPromise = rootKeys.get(output.root_chat_id);
+      if (!rootKeyPromise) {
+        rootKeyPromise = (async () => {
+          let root = cache.chats.find((chat) => String(chat.details.id ?? "") === output.root_chat_id);
+          let rootKey2 = root ? await this.resolveChatKey(cache, root, wrappingKey, teamId) : null;
+          if (!rootKey2) {
+            const response = await http.get(
+              `/v1/chats/${encodeURIComponent(output.root_chat_id)}/wrappers/window` + (teamId ? `?team_id=${encodeURIComponent(teamId)}` : ""),
+              this.getCliRequestHeaders()
+            );
+            if (!response.ok) throw new Error(`Recovery root key lookup failed (HTTP ${response.status}); output remains pending.`);
+            const keyType = teamId ? "team" : "master";
+            const wrapper = (response.data.wrappers ?? []).find((item) => item.key_type === keyType && typeof item.encrypted_chat_key === "string" && item.encrypted_chat_key);
+            if (!wrapper) throw new Error(`Recovery root chat ${output.root_chat_id} key wrapper is unavailable.`);
+            cache.chatKeyWrappers ??= [];
+            cache.chatKeyWrappers.push(wrapper);
+            if (!root) {
+              root = { details: { id: output.root_chat_id, encrypted_chat_key: wrapper.encrypted_chat_key }, messages: [] };
+              cache.chats.push(root);
+            }
+            rootKey2 = await this.resolveChatKey(cache, root, wrappingKey, teamId);
+          }
+          if (!rootKey2) throw new Error(`Recovery root chat ${output.root_chat_id} key is unavailable.`);
+          return rootKey2;
+        })();
+        rootKeys.set(output.root_chat_id, rootKeyPromise);
+      }
+      const rootKey = await rootKeyPromise;
+      assertOwner();
       let ready2;
       try {
         ready2 = await request("recovery_output_get", "recovery_output_ready", output.record_id, {});
@@ -15693,7 +15863,7 @@ var OpenMatesClient = class _OpenMatesClient {
         await reconcileAcknowledgedEmbed(output, rootKey);
         dependencies.acknowledged.set(output.record_id, identity3);
         acknowledged += 1;
-        continue;
+        return null;
       }
       for (const field3 of ["record_id", "root_chat_id", "target_chat_id", "turn_id", "subject_id", "output_kind", "output_version", "chat_key_version"]) {
         if (ready2[field3] !== output[field3]) throw new Error(`Recovery output ${output.record_id} identity mismatch: ${field3}.`);
@@ -15729,6 +15899,27 @@ var OpenMatesClient = class _OpenMatesClient {
         throw new Error("Recovery output plaintext identity mismatch.");
       }
       const content = recovered.content;
+      assertOwner();
+      if (typeof content.parent_embed_id === "string") {
+        const candidates = (dependencies.bySubject.get(content.parent_embed_id) ?? []).filter((candidate) => candidate.output_kind === "embed");
+        if (candidates.length && !candidates.some((candidate) => candidate.output_kind === "embed" && candidate.root_chat_id === output.root_chat_id && candidate.target_chat_id === output.target_chat_id && candidate.turn_id === output.turn_id && candidate.chat_key_version === output.chat_key_version && (candidate.root_hashed_team_id ?? null) === (output.root_hashed_team_id ?? null))) {
+          const parentPath = `/v1/embeds/chats/${encodeURIComponent(output.target_chat_id)}/embeds/${encodeURIComponent(content.parent_embed_id)}` + (teamId ? `?team_id=${encodeURIComponent(teamId)}` : "");
+          const parent = await http.get(parentPath, this.getCliRequestHeaders());
+          if (!parent.ok) throw new Error("Canonical recovery parent embed key scope was unavailable.");
+        }
+      }
+      return { output, ready: ready2, content, rootKey, identity: identity3 };
+    };
+    const prepared = [];
+    for (const output of ordered) prepared.push(await prepareOne(output));
+    const persistOne = async ({ output, ready: ready2, content, rootKey, identity: identity3 }) => {
+      assertOwner();
+      const committed = dependencies.acknowledged.get(output.record_id);
+      if (committed !== void 0) {
+        if (committed !== identity3) throw new Error("Acknowledged recovery dependency changed identity.");
+        return;
+      }
+      const messageRole = output.message_role ?? "assistant";
       const childKey = rootKey;
       const now = Math.floor(Date.now() / 1e3);
       const encryptedChatKey = typeof ready2.encrypted_chat_key === "string" && ready2.encrypted_chat_key ? ready2.encrypted_chat_key : await encryptBytesWithAesGcm(childKey, wrappingKey);
@@ -15803,6 +15994,7 @@ var OpenMatesClient = class _OpenMatesClient {
         }, 2e4);
         void stored.catch(() => {
         });
+        assertOwner();
         await ws.sendAsync("store_chat_compression_checkpoint", {
           chat_id: output.target_chat_id,
           checkpoint_id: output.subject_id,
@@ -15830,7 +16022,7 @@ var OpenMatesClient = class _OpenMatesClient {
       } else {
         if (content.embed_id !== output.subject_id) throw new Error("Recovery embed identity mismatch.");
         const embedPath = `/v1/embeds/chats/${encodeURIComponent(output.target_chat_id)}/embeds/${encodeURIComponent(output.subject_id)}` + (teamId ? `?team_id=${encodeURIComponent(teamId)}` : "");
-        let canonicalBefore = await this.http.get(
+        let canonicalBefore = await http.get(
           embedPath,
           this.getCliRequestHeaders()
         );
@@ -15929,7 +16121,7 @@ var OpenMatesClient = class _OpenMatesClient {
           }
           const query = new URLSearchParams({ capability: "bounded-v1", chat_id: output.target_chat_id });
           if (teamId) query.set("team_id", teamId);
-          const existing = await this.http.get(
+          const existing = await http.get(
             `/v1/embeds/${encodeURIComponent(output.subject_id)}/versions/${output.output_version}?${query}`,
             this.getCliRequestHeaders()
           );
@@ -15985,7 +16177,7 @@ var OpenMatesClient = class _OpenMatesClient {
             } else {
               const query = new URLSearchParams({ capability: "bounded-v1", chat_id: output.target_chat_id });
               if (teamId) query.set("team_id", teamId);
-              const history = await this.http.get(
+              const history = await http.get(
                 `/v1/embeds/${encodeURIComponent(output.subject_id)}/versions/${output.output_version}?${query}`,
                 this.getCliRequestHeaders()
               );
@@ -16106,7 +16298,7 @@ var OpenMatesClient = class _OpenMatesClient {
         }
         const keyPath = `/v1/embeds/chats/${encodeURIComponent(output.target_chat_id)}/embeds/${encodeURIComponent(keySubject)}` + (teamId ? `?team_id=${encodeURIComponent(teamId)}` : "");
         const bootstrapRootKeys = output.output_kind === "embed" && !parentId && !canonicalBefore.ok && canonicalBefore.status === 404;
-        const keyPage = bootstrapRootKeys ? null : keySubject === output.subject_id && canonicalBefore.ok ? canonicalBefore : parentPage ?? await this.http.get(
+        const keyPage = bootstrapRootKeys ? null : keySubject === output.subject_id && canonicalBefore.ok ? canonicalBefore : parentPage ?? await http.get(
           keyPath,
           this.getCliRequestHeaders()
         );
@@ -16133,20 +16325,24 @@ var OpenMatesClient = class _OpenMatesClient {
           }
         ].filter((key) => !existingTypes.has(key.key_type));
         if (keys2.length > 0) {
+          assertOwner();
           const requestId = randomUUID9();
           const receipt = ws.waitForMessage("store_embed_keys_confirmed", (value) => value.request_id === requestId, 3e4);
           void receipt.catch(() => {
           });
+          assertOwner();
           await ws.sendAsync("store_embed_keys", {
             request_id: requestId,
             recovery_record_id: output.record_id,
             keys: keys2
           });
-          const result = (await receipt).payload;
+          const received = await receipt;
+          assertOwner();
+          const result = received.payload;
           if (result.failed_count !== 0 || result.created_count !== keys2.length || result.requested_count !== keys2.length) {
             throw new Error("Recovery embed key wrappers were not exactly confirmed.");
           }
-          const durable = await this.http.get(
+          const durable = await http.get(
             keyPath,
             this.getCliRequestHeaders()
           );
@@ -16156,7 +16352,7 @@ var OpenMatesClient = class _OpenMatesClient {
             throw new Error("Recovery embed key wrappers are not both durable.");
           }
         }
-        const canonicalAfter = await this.http.get(
+        const canonicalAfter = await http.get(
           embedPath,
           this.getCliRequestHeaders()
         );
@@ -16171,7 +16367,7 @@ var OpenMatesClient = class _OpenMatesClient {
         } else {
           const query = new URLSearchParams({ capability: "bounded-v1", chat_id: output.target_chat_id });
           if (teamId) query.set("team_id", teamId);
-          const history = await this.http.get(
+          const history = await http.get(
             `/v1/embeds/${encodeURIComponent(output.subject_id)}/versions/${output.output_version}?${query}`,
             this.getCliRequestHeaders()
           );
@@ -16195,7 +16391,14 @@ var OpenMatesClient = class _OpenMatesClient {
         }
       }
       dependencies.acknowledged.set(output.record_id, identity3);
+      assertOwner();
       acknowledged += 1;
+    };
+    for (const kind of ["message", "embed", "diff", "summary", "checkpoint"]) {
+      const group = prepared.filter((item) => item !== null && item.output.output_kind === kind);
+      if (kind === "embed" || kind === "diff") {
+        await runRecoveryBatch(group, persistOne, (item, dependency, index, other) => item.output.subject_id === dependency.output.subject_id && other < index || item.content.parent_embed_id === dependency.output.subject_id && item.output.root_chat_id === dependency.output.root_chat_id && item.output.target_chat_id === dependency.output.target_chat_id && item.output.turn_id === dependency.output.turn_id && item.output.chat_key_version === dependency.output.chat_key_version && (item.output.root_hashed_team_id ?? null) === (dependency.output.root_hashed_team_id ?? null) || typeof item.content.parent_embed_id === "string" && item.content.parent_embed_id === dependency.content.parent_embed_id && other < index && !group.some((candidate) => candidate.output.subject_id === item.content.parent_embed_id));
+      } else for (const item of group) await persistOne(item);
     }
     return acknowledged;
   }
@@ -16321,1651 +16524,1577 @@ var OpenMatesClient = class _OpenMatesClient {
     }
   }
   async sendMessage(params) {
-    const preWsStartedAt = performance.now();
-    const traceSendTiming = (phase) => {
-      if (process.env.OPENMATES_TRACE_SEND_TIMING === "1") {
-        console.error(`[chat send timing] phase=${phase} elapsed_ms=${Math.round(performance.now() - preWsStartedAt)}`);
-      }
-    };
-    traceSendTiming("send_begin");
-    if (this.preparedSendSocket && !this.preparedSendSocket.opened) this.closePreparedSendSocket();
-    const teamId = this.resolveTeamContext({ teamId: params.teamId, personal: params.personal });
-    const teamSenderName = teamId ? await this.ownTeamSenderName(teamId) : "User";
-    if (params.chatId && params.newChatId) {
-      throw new Error("chatId and newChatId cannot be used together.");
-    }
-    if (params.newChatId && !CANONICAL_UUID_PATTERN.test(params.newChatId)) {
-      throw new Error("newChatId must be a canonical UUID.");
-    }
-    if (params.incognito && params.projectId) {
-      throw new Error("Project file execution requires a saved chat.");
-    }
-    const ownsPreparedId = Boolean(params.newChatId && this.preparedChatKey?.chatId === params.newChatId && this.preparedChatOwnerCurrent(this.preparedChatKey.owner, teamId));
-    const sdkMintedChatId = params.chatId === void 0 && params.projectId === void 0 && (params.newChatId === void 0 || ownsPreparedId);
-    let chatId;
-    if (params.newChatId) {
-      chatId = params.newChatId;
-    } else if (!params.chatId) {
-      chatId = randomUUID9();
-    } else if (!CANONICAL_UUID_PATTERN.test(params.chatId)) {
-      const resolved = await this.resolveFullChatId(params.chatId, { teamId });
-      if (!resolved) {
-        throw new Error(
-          `Chat not found for '${params.chatId}'. Use a slug, full UUID, or the first 8 characters of an existing chat ID.`
-        );
-      }
-      chatId = resolved;
-    } else {
-      chatId = params.chatId;
-    }
-    const historyAbort = new AbortController();
-    let savedPrivacyHistoryRead = null;
-    let historySnapshotOwner = null;
-    const readSavedPrivacyHistory = () => {
-      if (!savedPrivacyHistoryRead) {
-        savedPrivacyHistoryRead = withHttpAbortSignal(historyAbort.signal, () => this.getChatMessages(
+    this.cancelSendSocketRearm();
+    this.foregroundSendCount++;
+    try {
+      const preWsStartedAt = performance.now();
+      const traceSendTiming = (phase) => {
+        if (process.env.OPENMATES_TRACE_SEND_TIMING === "1") {
+          console.error(`[chat send timing] phase=${phase} elapsed_ms=${Math.round(performance.now() - preWsStartedAt)}`);
+        }
+      };
+      traceSendTiming("send_begin");
+      if (this.preparedSendSocket && !this.preparedSendSocket.opened) this.closePreparedSendSocket();
+      const teamId = this.resolveTeamContext({ teamId: params.teamId, personal: params.personal });
+      const teamSenderName = teamId ? await this.ownTeamSenderName(teamId) : "User";
+      if (params.chatId && params.newChatId) {
+        throw new Error("chatId and newChatId cannot be used together.");
+      }
+      if (params.newChatId && !CANONICAL_UUID_PATTERN.test(params.newChatId)) {
+        throw new Error("newChatId must be a canonical UUID.");
+      }
+      if (params.incognito && params.projectId) {
+        throw new Error("Project file execution requires a saved chat.");
+      }
+      const ownsPreparedId = Boolean(params.newChatId && this.preparedChatKey?.chatId === params.newChatId && this.preparedChatOwnerCurrent(this.preparedChatKey.owner, teamId));
+      const sdkMintedChatId = params.chatId === void 0 && params.projectId === void 0 && (params.newChatId === void 0 || ownsPreparedId);
+      let chatId;
+      if (params.newChatId) {
+        chatId = params.newChatId;
+      } else if (!params.chatId) {
+        chatId = randomUUID9();
+      } else if (!CANONICAL_UUID_PATTERN.test(params.chatId)) {
+        const resolved = await this.resolveFullChatId(params.chatId, { teamId });
+        if (!resolved) {
+          throw new Error(
+            `Chat not found for '${params.chatId}'. Use a slug, full UUID, or the first 8 characters of an existing chat ID.`
+          );
+        }
+        chatId = resolved;
+      } else {
+        chatId = params.chatId;
+      }
+      const historyAbort = new AbortController();
+      let savedPrivacyHistoryRead = null;
+      let historySnapshotOwner = null;
+      const readSavedPrivacyHistory = () => {
+        if (!savedPrivacyHistoryRead) {
+          savedPrivacyHistoryRead = withHttpAbortSignal(historyAbort.signal, () => this.getChatMessages(
+            chatId,
+            { personal: !teamId, teamId, freshChatOnly: true, signal: historyAbort.signal }
+          )).then((history) => {
+            historySnapshotOwner = this.preparedChatOwner(this.requireSession(), teamId);
+            return history;
+          });
+          void savedPrivacyHistoryRead.catch(() => {
+          });
+        }
+        return savedPrivacyHistoryRead;
+      };
+      const joinSavedPrivacyHistory = async () => {
+        const history = await readSavedPrivacyHistory();
+        if (!historySnapshotOwner || !this.preparedChatOwnerCurrent(historySnapshotOwner, teamId)) {
+          throw new Error("Chat workspace changed during history preparation.");
+        }
+        return history;
+      };
+      try {
+        let finalMessage = params.message;
+        if (hasRememberMessageReference(finalMessage)) {
+          const rememberedHistory = (params.messageHistory ?? []).map((message) => ({ id: message.message_id, content: message.content })).filter((message) => Boolean(message.id) && typeof message.content === "string");
+          finalMessage = rewriteRememberMessageReferences(finalMessage, rememberedHistory);
+        }
+        if (params.chatId && !params.incognito && hasRememberMessageReference(finalMessage)) {
+          const { messages } = await joinSavedPrivacyHistory();
+          finalMessage = rewriteRememberMessageReferences(finalMessage, messages);
+        }
+        const shouldWaitForAi = shouldWaitForTeamAi(finalMessage, teamId);
+        const explicitTasksAppSkill = messageExplicitlyRequestsTasksAppSkill(finalMessage);
+        const taskUpdateJobsEnabled = params.taskUpdateJobs !== false && !explicitTasksAppSkill;
+        const sendSocketOptions = {
+          taskUpdateJobs: taskUpdateJobsEnabled,
+          projectFileJobs: !params.incognito,
+          remoteCommandJobs: !params.incognito,
+          interactiveHuman: params.interactiveHuman === true && this.interactiveViewerAllowed && process.stdin.isTTY === true && process.stdout.isTTY === true
+        };
+        const independentKeyOwner = this.preparedChatOwner(this.requireSession(), teamId);
+        const independentNewChatKey = !params.incognito && !params.chatId ? (async () => {
+          if (ownsPreparedId && this.preparedChatKey?.chatId === chatId) {
+            const prepared = await this.preparedChatKey.value;
+            if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(prepared.wrappingKey)).digest("hex");
+            return prepared;
+          }
+          const wrappingKey = await this.getChatWrappingKey(teamId, this.getMasterKeyBytes());
+          if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(wrappingKey)).digest("hex");
+          const key = new Uint8Array(randomBytes4(32));
+          return { key, wrappingKey, encryptedKey: await encryptBytesWithAesGcm(key, wrappingKey) };
+        })() : null;
+        void independentNewChatKey?.catch(() => {
+        });
+        const independentRecoveryKeypair = independentNewChatKey?.then((prepared) => deriveChatCompletionRecoveryKeypair(
+          Buffer.from(prepared.key).toString("base64url"),
           chatId,
-          { personal: !teamId, teamId, freshChatOnly: true, signal: historyAbort.signal }
-        )).then((history) => {
-          historySnapshotOwner = this.preparedChatOwner(this.requireSession(), teamId);
-          return history;
+          1
+        ));
+        void independentRecoveryKeypair?.catch(() => {
         });
-        void savedPrivacyHistoryRead.catch(() => {
+        const privacyTurnId = params.incognito ? null : randomUUID9();
+        let conditionalPrivacyReceipt = null;
+        let compiledPrivacy;
+        let memorySocket = null;
+        let socketSnapshotAttempted = false;
+        let socketSnapshotResultRows = null;
+        let socketProjectCandidateRows = null;
+        let verifiedProjectCandidates = null;
+        let deferredProjectDirectory = false;
+        let usePersonalRoutingDirectory = false;
+        let projectCandidatesReadyFromSendStartMs = null;
+        let socketMemoryReceipt = null;
+        const socketMemoryOptionsKey = () => JSON.stringify([
+          this.sendSocketOptionsKey(sendSocketOptions),
+          params.projectId ?? null,
+          params.teamId ?? null,
+          params.personal === true,
+          params.incognito === true,
+          params.autoApproveMemories === true,
+          params.piiDetection !== false,
+          params.learningMode?.enabled ?? null,
+          params.learningMode?.ageGroup ?? null
+        ]);
+        if (!params.incognito && params.chatId) readSavedPrivacyHistory();
+        const followupDiscoveryOwner = !params.incognito && params.chatId && !teamId && !params.projectId ? this.preparedChatOwner(this.requireSession(), teamId) : null;
+        const followupDiscoveryRead = followupDiscoveryOwner ? withHttpAbortSignal(historyAbort.signal, async () => prefetchCliJevDiscovery(this, chatId, { personal: true, teamId })) : null;
+        void followupDiscoveryRead?.catch(() => {
         });
-      }
-      return savedPrivacyHistoryRead;
-    };
-    const joinSavedPrivacyHistory = async () => {
-      const history = await readSavedPrivacyHistory();
-      if (!historySnapshotOwner || !this.preparedChatOwnerCurrent(historySnapshotOwner, teamId)) {
-        throw new Error("Chat workspace changed during history preparation.");
-      }
-      return history;
-    };
-    try {
-      let finalMessage = params.message;
-      if (hasRememberMessageReference(finalMessage)) {
-        const rememberedHistory = (params.messageHistory ?? []).map((message) => ({ id: message.message_id, content: message.content })).filter((message) => Boolean(message.id) && typeof message.content === "string");
-        finalMessage = rewriteRememberMessageReferences(finalMessage, rememberedHistory);
-      }
-      if (params.chatId && !params.incognito && hasRememberMessageReference(finalMessage)) {
-        const { messages } = await joinSavedPrivacyHistory();
-        finalMessage = rewriteRememberMessageReferences(finalMessage, messages);
-      }
-      const shouldWaitForAi = shouldWaitForTeamAi(finalMessage, teamId);
-      const explicitTasksAppSkill = messageExplicitlyRequestsTasksAppSkill(finalMessage);
-      const taskUpdateJobsEnabled = params.taskUpdateJobs !== false && !explicitTasksAppSkill;
-      const sendSocketOptions = {
-        taskUpdateJobs: taskUpdateJobsEnabled,
-        projectFileJobs: !params.incognito,
-        remoteCommandJobs: !params.incognito,
-        interactiveHuman: params.interactiveHuman === true && this.interactiveViewerAllowed && process.stdin.isTTY === true && process.stdout.isTTY === true
-      };
-      const independentKeyOwner = this.preparedChatOwner(this.requireSession(), teamId);
-      const independentNewChatKey = !params.incognito && !params.chatId ? (async () => {
-        if (ownsPreparedId && this.preparedChatKey?.chatId === chatId) {
-          const prepared = await this.preparedChatKey.value;
-          if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(prepared.wrappingKey)).digest("hex");
-          return prepared;
-        }
-        const wrappingKey = await this.getChatWrappingKey(teamId, this.getMasterKeyBytes());
-        if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(wrappingKey)).digest("hex");
-        const key = new Uint8Array(randomBytes4(32));
-        return { key, wrappingKey, encryptedKey: await encryptBytesWithAesGcm(key, wrappingKey) };
-      })() : null;
-      void independentNewChatKey?.catch(() => {
-      });
-      const independentRecoveryKeypair = independentNewChatKey?.then((prepared) => deriveChatCompletionRecoveryKeypair(
-        Buffer.from(prepared.key).toString("base64url"),
-        chatId,
-        1
-      ));
-      void independentRecoveryKeypair?.catch(() => {
-      });
-      const privacyTurnId = params.incognito ? null : randomUUID9();
-      let conditionalPrivacyReceipt = null;
-      let compiledPrivacy;
-      let memorySocket = null;
-      let socketSnapshotAttempted = false;
-      let socketSnapshotResultRows = null;
-      let socketProjectCandidateRows = null;
-      let verifiedProjectCandidates = null;
-      let deferredProjectDirectory = false;
-      let usePersonalRoutingDirectory = false;
-      let projectCandidatesReadyFromSendStartMs = null;
-      let socketMemoryReceipt = null;
-      const socketMemoryOptionsKey = () => JSON.stringify([
-        this.sendSocketOptionsKey(sendSocketOptions),
-        params.projectId ?? null,
-        params.teamId ?? null,
-        params.personal === true,
-        params.incognito === true,
-        params.autoApproveMemories === true,
-        params.piiDetection !== false,
-        params.learningMode?.enabled ?? null,
-        params.learningMode?.ageGroup ?? null
-      ]);
-      if (!params.incognito && params.chatId) readSavedPrivacyHistory();
-      const followupDiscoveryOwner = !params.incognito && params.chatId && !teamId && !params.projectId ? this.preparedChatOwner(this.requireSession(), teamId) : null;
-      const followupDiscoveryRead = followupDiscoveryOwner ? withHttpAbortSignal(historyAbort.signal, async () => prefetchCliJevDiscovery(this, chatId, { personal: true, teamId })) : null;
-      void followupDiscoveryRead?.catch(() => {
-      });
-      const memoryStartedAt = performance.now();
-      let availableMemories = params.memorySnapshot ?? [];
-      let memoryCountsLoaded = false;
-      let memoryMetadataKeys = [];
-      if (!params.incognito) {
-        try {
-          if (!teamId) {
-            try {
-              socketSnapshotAttempted = true;
-              memorySocket = (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient(sendSocketOptions);
-              const ownerKey = JSON.stringify([
-                this.sendSocketOwnerKey(this.requireSession(), teamId),
-                authCookieFingerprint(this.http.getCookieMap())
-              ]);
-              const conditionalSupported = await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v2");
-              const combinedSupported = conditionalSupported || await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v1");
-              const supported = combinedSupported || await memorySocket.ws.waitForServerCapability("personal_memory_snapshot_v1");
-              if (supported) {
-                const deferProjectDirectory = sdkMintedChatId && !teamId && !params.incognito && !params.projectId && shouldWaitForAi && memorySocket.ws.supportsServerCapability("personal_memory_snapshot_v1") && memorySocket.ws.supportsServerCapability("chat_turn_admit_v1") && memorySocket.ws.supportsServerCapability("chat_turn_context_v1");
-                deferredProjectDirectory = deferProjectDirectory;
-                usePersonalRoutingDirectory = deferProjectDirectory && memorySocket.ws.supportsServerCapability("personal_project_routing_directory_v1");
-                traceSendTiming("snapshot_request");
-                const privacyOwnerKey = this.preparedPrivacyOwnerKey(null);
-                const preferencesKey = JSON.stringify(await readPrivacyPreferences());
-                const preparedBundle = conditionalSupported ? this.preparedPrivacy.get(privacyOwnerKey, preferencesKey) : null;
-                const conditional = conditionalSupported ? await memorySocket.ws.requestPersonalSendContextSnapshotV2({
-                  request_id: randomUUID9(),
-                  purpose: "send",
-                  turn_id: privacyTurnId,
-                  ...preparedBundle ? { known_generation: preparedBundle.generation } : {}
-                }) : null;
-                const combined = !conditional && combinedSupported && !deferProjectDirectory ? await memorySocket.ws.requestPersonalSendContextSnapshot(randomUUID9()) : null;
-                const snapshot2 = conditional ? conditional.personal_memories ?? null : combined?.personal_memories ?? await memorySocket.ws.requestPersonalMemorySnapshot(randomUUID9());
-                traceSendTiming("snapshot_ready");
-                if (conditional || combined) {
-                  socketProjectCandidateRows = (conditional ?? combined).project_candidates;
-                  verifiedProjectCandidates = await decodePersonalProjectCandidates(this, (conditional ?? combined).project_candidates);
-                  projectCandidatesReadyFromSendStartMs = Math.round(performance.now() - preWsStartedAt);
-                }
-                if (conditional?.unchanged) {
-                  if (!preparedBundle || conditional.privacy_generation !== preparedBundle.generation) throw new Error("Unchanged privacy snapshot has no matching prepared bundle.");
-                  availableMemories = preparedBundle.memories;
-                  compiledPrivacy = preparedBundle.privacy;
-                  socketSnapshotResultRows = [];
-                } else {
-                  if (!snapshot2) throw new Error("Full Personal privacy snapshot is required.");
-                  socketSnapshotResultRows = snapshot2.memories;
-                  availableMemories = await this.listMemoriesUnshared({ personal: true }, snapshot2);
+        const memoryStartedAt = performance.now();
+        let availableMemories = params.memorySnapshot ?? [];
+        let memoryCountsLoaded = false;
+        let memoryMetadataKeys = [];
+        if (!params.incognito) {
+          try {
+            if (!teamId) {
+              try {
+                socketSnapshotAttempted = true;
+                memorySocket = (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient(sendSocketOptions);
+                const ownerKey = JSON.stringify([
+                  this.sendSocketOwnerKey(this.requireSession(), teamId),
+                  authCookieFingerprint(this.http.getCookieMap())
+                ]);
+                const conditionalSupported = await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v2");
+                const combinedSupported = conditionalSupported || await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v1");
+                const supported = combinedSupported || await memorySocket.ws.waitForServerCapability("personal_memory_snapshot_v1");
+                if (supported) {
+                  const deferProjectDirectory = sdkMintedChatId && !teamId && !params.incognito && !params.projectId && shouldWaitForAi && memorySocket.ws.supportsServerCapability("personal_memory_snapshot_v1") && memorySocket.ws.supportsServerCapability("chat_turn_admit_v1") && memorySocket.ws.supportsServerCapability("chat_turn_context_v1");
+                  deferredProjectDirectory = deferProjectDirectory;
+                  usePersonalRoutingDirectory = deferProjectDirectory && memorySocket.ws.supportsServerCapability("personal_project_routing_directory_v1");
+                  traceSendTiming("snapshot_request");
+                  const privacyOwnerKey = this.preparedPrivacyOwnerKey(null);
+                  const preferencesKey = JSON.stringify(await readPrivacyPreferences());
+                  const preparedBundle = conditionalSupported ? this.preparedPrivacy.get(privacyOwnerKey, preferencesKey) : null;
+                  const conditional = conditionalSupported ? await memorySocket.ws.requestPersonalSendContextSnapshotV2({
+                    request_id: randomUUID9(),
+                    purpose: "send",
+                    turn_id: privacyTurnId,
+                    ...preparedBundle ? { known_generation: preparedBundle.generation } : {}
+                  }) : null;
+                  const combined = !conditional && combinedSupported && !deferProjectDirectory ? await memorySocket.ws.requestPersonalSendContextSnapshot(randomUUID9()) : null;
+                  const snapshot2 = conditional ? conditional.personal_memories ?? null : combined?.personal_memories ?? await memorySocket.ws.requestPersonalMemorySnapshot(randomUUID9());
+                  traceSendTiming("snapshot_ready");
+                  if (conditional || combined) {
+                    socketProjectCandidateRows = (conditional ?? combined).project_candidates;
+                    verifiedProjectCandidates = await decodePersonalProjectCandidates(this, (conditional ?? combined).project_candidates);
+                    projectCandidatesReadyFromSendStartMs = Math.round(performance.now() - preWsStartedAt);
+                  }
+                  if (conditional?.unchanged) {
+                    if (!preparedBundle || conditional.privacy_generation !== preparedBundle.generation) throw new Error("Unchanged privacy snapshot has no matching prepared bundle.");
+                    availableMemories = preparedBundle.memories;
+                    compiledPrivacy = preparedBundle.privacy;
+                    socketSnapshotResultRows = [];
+                  } else {
+                    if (!snapshot2) throw new Error("Full Personal privacy snapshot is required.");
+                    socketSnapshotResultRows = snapshot2.memories;
+                    availableMemories = await this.listMemoriesUnshared({ personal: true }, snapshot2);
+                    if (conditional) {
+                      this.preparedPrivacy.set(privacyOwnerKey, preferencesKey, conditional.privacy_generation, availableMemories);
+                      compiledPrivacy = this.preparedPrivacy.get(privacyOwnerKey, preferencesKey)?.privacy;
+                    }
+                  }
                   if (conditional) {
-                    this.preparedPrivacy.set(privacyOwnerKey, preferencesKey, conditional.privacy_generation, availableMemories);
-                    compiledPrivacy = this.preparedPrivacy.get(privacyOwnerKey, preferencesKey)?.privacy;
+                    if (!conditional.receipt_id || conditional.turn_id !== privacyTurnId) throw new Error("Conditional privacy snapshot has no valid send receipt.");
+                    conditionalPrivacyReceipt = {
+                      receiptId: conditional.receipt_id,
+                      generation: conditional.privacy_generation,
+                      preferencesKey,
+                      epoch: this.preparedPrivacyEpoch
+                    };
                   }
-                }
-                if (conditional) {
-                  if (!conditional.receipt_id || conditional.turn_id !== privacyTurnId) throw new Error("Conditional privacy snapshot has no valid send receipt.");
-                  conditionalPrivacyReceipt = {
-                    receiptId: conditional.receipt_id,
-                    generation: conditional.privacy_generation,
-                    preferencesKey,
-                    epoch: this.preparedPrivacyEpoch
+                  traceSendTiming("memory_decrypt_ready");
+                  if (!memorySocket.ws.isOpen() || JSON.stringify([
+                    this.sendSocketOwnerKey(this.requireSession(), teamId),
+                    authCookieFingerprint(this.http.getCookieMap())
+                  ]) !== ownerKey) {
+                    throw new Error("Personal Memory snapshot owner or socket changed during preparation.");
+                  }
+                  socketMemoryReceipt = {
+                    ws: memorySocket.ws,
+                    snapshot: availableMemories,
+                    resultRows: socketSnapshotResultRows,
+                    projectRows: socketProjectCandidateRows,
+                    candidates: verifiedProjectCandidates,
+                    ownerKey,
+                    optionsKey: socketMemoryOptionsKey(),
+                    used: false
                   };
+                } else {
+                  memorySocket.ws.close();
+                  memorySocket = null;
+                  socketSnapshotAttempted = false;
                 }
-                traceSendTiming("memory_decrypt_ready");
-                if (!memorySocket.ws.isOpen() || JSON.stringify([
-                  this.sendSocketOwnerKey(this.requireSession(), teamId),
-                  authCookieFingerprint(this.http.getCookieMap())
-                ]) !== ownerKey) {
-                  throw new Error("Personal Memory snapshot owner or socket changed during preparation.");
-                }
-                socketMemoryReceipt = {
-                  ws: memorySocket.ws,
-                  snapshot: availableMemories,
-                  resultRows: socketSnapshotResultRows,
-                  projectRows: socketProjectCandidateRows,
-                  candidates: verifiedProjectCandidates,
-                  ownerKey,
-                  optionsKey: socketMemoryOptionsKey(),
-                  used: false
-                };
-              } else {
-                memorySocket.ws.close();
+              } catch (error) {
+                memorySocket?.ws.close();
                 memorySocket = null;
-                socketSnapshotAttempted = false;
+                throw error;
               }
-            } catch (error) {
-              memorySocket?.ws.close();
-              memorySocket = null;
-              throw error;
             }
-          }
-          if (!socketMemoryReceipt) availableMemories = teamId && params.memorySnapshot ? params.memorySnapshot : await this.listMemoriesUnshared({ teamId }, void 0, !teamId);
-          memoryCountsLoaded = true;
-          memoryMetadataKeys = [
-            ...new Set(
-              availableMemories.filter((memory) => memory.app_id && memory.item_type).map((memory) => `${memory.app_id}-${memory.item_type}`)
-            )
-          ];
-        } catch (error) {
-          if (socketSnapshotAttempted || !teamId) throw error;
-          if (params.autoApproveMemories) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to load memories for auto-approval: ${message}`);
+            if (!socketMemoryReceipt) availableMemories = teamId && params.memorySnapshot ? params.memorySnapshot : await this.listMemoriesUnshared({ teamId }, void 0, !teamId);
+            memoryCountsLoaded = true;
+            memoryMetadataKeys = [
+              ...new Set(
+                availableMemories.filter((memory) => memory.app_id && memory.item_type).map((memory) => `${memory.app_id}-${memory.item_type}`)
+              )
+            ];
+          } catch (error) {
+            if (socketSnapshotAttempted || !teamId) throw error;
+            if (params.autoApproveMemories) {
+              const message = error instanceof Error ? error.message : String(error);
+              throw new Error(`Failed to load memories for auto-approval: ${message}`);
+            }
           }
         }
-      }
-      try {
-        const snapshotAuthHandoff = this.personalMemoryAuthHandoff?.snapshot.deref() === availableMemories ? this.personalMemoryAuthHandoff.auth : null;
-        this.personalMemoryAuthHandoff = null;
-        this.pendingWhoAmIAuthHandoff = null;
-        const personalSendAuthHandoff = !teamId && !params.incognito ? snapshotAuthHandoff : null;
-        const memoryPrepMs = Math.round(performance.now() - memoryStartedAt);
-        const privacyStartedAt = performance.now();
-        traceSendTiming("privacy_begin");
-        const savedPrivacyHistory = !params.incognito && params.chatId ? await joinSavedPrivacyHistory() : null;
-        let piiMappings = [...savedPrivacyHistory?.messages.flatMap((message) => (message.piiMappings ?? []).map((mapping) => ({ ...mapping, type: mapping.type ?? "OTHER" }))) ?? [], ...params.piiMappings ?? []];
         try {
-          if (params.piiDetection !== false) {
-            const prepared = await prepareCliMessagePrivacy(finalMessage, availableMemories, piiMappings, { kind: "message" }, params.onPrivacyProgress, compiledPrivacy);
-            finalMessage = prepared.message;
-            piiMappings = prepared.mappings;
-            for (const embed of params.preparedEmbeds ?? []) {
-              if (!["code-code", "docs-doc", "sheets-sheet"].includes(embed.type)) continue;
-              const decoded = toonDecode(embed.content);
-              for (const field3 of ["code", "html", "table", "text"]) if (typeof decoded[field3] === "string") {
-                const value = await prepareCliMessagePrivacy(decoded[field3], availableMemories, piiMappings, { kind: "document" }, params.onPrivacyProgress, compiledPrivacy);
-                decoded[field3] = value.message;
-                piiMappings = value.mappings;
-              }
-              embed.content = toonEncodeContent(decoded);
-              const content = decoded.code ?? decoded.table ?? decoded.html ?? decoded.text;
-              if (typeof content === "string") {
-                embed.contentHash = createHash14("sha256").update(content).digest("hex");
-                embed.textLengthChars = content.length;
+          const snapshotAuthHandoff = this.personalMemoryAuthHandoff?.snapshot.deref() === availableMemories ? this.personalMemoryAuthHandoff.auth : null;
+          this.personalMemoryAuthHandoff = null;
+          this.pendingWhoAmIAuthHandoff = null;
+          const personalSendAuthHandoff = !teamId && !params.incognito ? snapshotAuthHandoff : null;
+          const memoryPrepMs = Math.round(performance.now() - memoryStartedAt);
+          const privacyStartedAt = performance.now();
+          traceSendTiming("privacy_begin");
+          const savedPrivacyHistory = !params.incognito && params.chatId ? await joinSavedPrivacyHistory() : null;
+          let piiMappings = [...savedPrivacyHistory?.messages.flatMap((message) => (message.piiMappings ?? []).map((mapping) => ({ ...mapping, type: mapping.type ?? "OTHER" }))) ?? [], ...params.piiMappings ?? []];
+          try {
+            if (params.piiDetection !== false) {
+              const prepared = await prepareCliMessagePrivacy(finalMessage, availableMemories, piiMappings, { kind: "message" }, params.onPrivacyProgress, compiledPrivacy);
+              finalMessage = prepared.message;
+              piiMappings = prepared.mappings;
+              for (const embed of params.preparedEmbeds ?? []) {
+                if (!["code-code", "docs-doc", "sheets-sheet"].includes(embed.type)) continue;
+                const decoded = toonDecode(embed.content);
+                for (const field3 of ["code", "html", "table", "text"]) if (typeof decoded[field3] === "string") {
+                  const value = await prepareCliMessagePrivacy(decoded[field3], availableMemories, piiMappings, { kind: "document" }, params.onPrivacyProgress, compiledPrivacy);
+                  decoded[field3] = value.message;
+                  piiMappings = value.mappings;
+                }
+                embed.content = toonEncodeContent(decoded);
+                const content = decoded.code ?? decoded.table ?? decoded.html ?? decoded.text;
+                if (typeof content === "string") {
+                  embed.contentHash = createHash14("sha256").update(content).digest("hex");
+                  embed.textLengthChars = content.length;
+                }
               }
             }
+            params.onPrivacyPrepared?.(finalMessage);
+          } catch (error) {
+            memorySocket?.ws.close();
+            throw error;
           }
-          params.onPrivacyPrepared?.(finalMessage);
-        } catch (error) {
-          memorySocket?.ws.close();
-          throw error;
-        }
-        const privacyPrepMs = Math.round(performance.now() - privacyStartedAt);
-        traceSendTiming("privacy_ready");
-        const preWsMs = Math.round(performance.now() - preWsStartedAt);
-        const contextSession = this.requireSession();
-        const {
-          apiUrl: contextApiUrl,
-          hashedEmail: contextHashedEmail,
-          sessionId: contextSessionId,
-          createdAt: contextSessionCreatedAt,
-          masterKeyExportedB64: contextMasterKey,
-          activeTeamId: contextActiveTeamId
-        } = contextSession;
-        const contextScope = { teamId, personal: !teamId };
-        const suppliedContext = deferredProjectDirectory ? { ...params.jevContext, project_focus_candidates: void 0 } : params.jevContext;
-        const contextStartedAt = Date.now();
-        let publishRouting;
-        const routingContext = new Promise((resolve20) => {
-          publishRouting = resolve20;
-        });
-        let publishProjectRouting;
-        let rejectProjectRouting;
-        const projectRoutingContext = new Promise((resolve20, reject) => {
-          publishProjectRouting = resolve20;
-          rejectProjectRouting = reject;
-        });
-        void projectRoutingContext.catch(() => {
-        });
-        const publishProjectRoutingTimed = (context) => {
-          projectCandidatesReadyFromSendStartMs ??= Math.round(performance.now() - preWsStartedAt);
-          publishProjectRouting(deferredProjectDirectory ? { ...context, project_focus_candidates: context.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) } : context);
-        };
-        let recoveryMs = 0;
-        const contextOwnerIsCurrent = () => {
-          const current2 = this.session;
-          return Boolean(current2 && current2.apiUrl === contextApiUrl && current2.hashedEmail === contextHashedEmail && current2.sessionId === contextSessionId && current2.createdAt === contextSessionCreatedAt && current2.masterKeyExportedB64 === contextMasterKey && current2.activeTeamId === contextActiveTeamId);
-        };
-        const earlyContextAbort = new AbortController();
-        const earlyContext = !params.incognito && !params.chatId && !params.projectId ? withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
-          sdkMintedChatId,
-          onRouting: publishRouting,
-          verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
-          usePersonalRoutingDirectory,
-          onProjectRouting: publishProjectRoutingTimed,
-          onProjectRoutingError: rejectProjectRouting
-        })).then(
-          (value) => ({ ok: true, value, elapsedMs: Date.now() - contextStartedAt }),
-          (error) => ({ ok: false, error, elapsedMs: Date.now() - contextStartedAt })
-        ) : null;
-        const authSocketStartedAt = Date.now();
-        let opened;
-        try {
-          opened = memorySocket ?? (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient({ ...sendSocketOptions, personalSendAuthHandoff });
-        } catch (error) {
-          earlyContextAbort.abort();
-          if (earlyContext) await earlyContext;
-          throw error;
-        }
-        const { ws, ownerId: ownerId2 } = opened;
-        const consumeSocketMemoryReceipt = async () => {
-          if (!socketMemoryReceipt) return;
-          const receipt = socketMemoryReceipt;
-          if (receipt.used || receipt.ws !== ws || receipt.snapshot !== availableMemories || receipt.resultRows !== socketSnapshotResultRows || receipt.projectRows !== socketProjectCandidateRows || receipt.candidates !== verifiedProjectCandidates || !ws.isOpen() || receipt.optionsKey !== socketMemoryOptionsKey()) {
-            throw new Error("Personal Memory snapshot socket receipt is invalid.");
-          }
-          await this.withFreshStoredSession(async () => {
-            if (!ws.isOpen() || JSON.stringify([
-              this.sendSocketOwnerKey(this.requireSession(), teamId),
-              authCookieFingerprint(this.http.getCookieMap())
-            ]) !== receipt.ownerKey) {
-              throw new Error("Personal Memory snapshot owner changed before send.");
-            }
+          const privacyPrepMs = Math.round(performance.now() - privacyStartedAt);
+          traceSendTiming("privacy_ready");
+          const preWsMs = Math.round(performance.now() - preWsStartedAt);
+          const contextSession = this.requireSession();
+          const {
+            apiUrl: contextApiUrl,
+            hashedEmail: contextHashedEmail,
+            sessionId: contextSessionId,
+            createdAt: contextSessionCreatedAt,
+            masterKeyExportedB64: contextMasterKey,
+            activeTeamId: contextActiveTeamId
+          } = contextSession;
+          const contextScope = { teamId, personal: !teamId };
+          const suppliedContext = deferredProjectDirectory ? { ...params.jevContext, project_focus_candidates: void 0 } : params.jevContext;
+          const contextStartedAt = Date.now();
+          let publishRouting;
+          const routingContext = new Promise((resolve20) => {
+            publishRouting = resolve20;
+          });
+          let publishProjectRouting;
+          let rejectProjectRouting;
+          const projectRoutingContext = new Promise((resolve20, reject) => {
+            publishProjectRouting = resolve20;
+            rejectProjectRouting = reject;
           });
-          if (conditionalPrivacyReceipt && (conditionalPrivacyReceipt.epoch !== this.preparedPrivacyEpoch || conditionalPrivacyReceipt.preferencesKey !== JSON.stringify(await readPrivacyPreferences()))) {
-            throw new Error("Privacy preferences changed before send; prepare the turn again.");
+          void projectRoutingContext.catch(() => {
+          });
+          const catalogEligibleProjectIds = /* @__PURE__ */ new Set();
+          const publishProjectRoutingTimed = (context) => {
+            projectCandidatesReadyFromSendStartMs ??= Math.round(performance.now() - preWsStartedAt);
+            const offered = context.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) ?? [];
+            for (const candidate of offered) catalogEligibleProjectIds.add(candidate.project_id);
+            publishProjectRouting(deferredProjectDirectory ? { ...context, project_focus_candidates: offered } : context);
+          };
+          let recoveryMs = 0;
+          const contextOwnerIsCurrent = () => {
+            const current2 = this.session;
+            return Boolean(current2 && current2.apiUrl === contextApiUrl && current2.hashedEmail === contextHashedEmail && current2.sessionId === contextSessionId && current2.createdAt === contextSessionCreatedAt && current2.masterKeyExportedB64 === contextMasterKey && current2.activeTeamId === contextActiveTeamId);
+          };
+          const earlyContextAbort = new AbortController();
+          const earlyContext = !params.incognito && !params.chatId && !params.projectId ? withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
+            sdkMintedChatId,
+            onRouting: publishRouting,
+            verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
+            usePersonalRoutingDirectory,
+            onProjectRouting: publishProjectRoutingTimed,
+            onProjectRoutingError: rejectProjectRouting
+          })).then(
+            (value) => ({ ok: true, value, elapsedMs: Date.now() - contextStartedAt }),
+            (error) => ({ ok: false, error, elapsedMs: Date.now() - contextStartedAt })
+          ) : null;
+          const authSocketStartedAt = Date.now();
+          let opened;
+          try {
+            opened = memorySocket ?? (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient({ ...sendSocketOptions, personalSendAuthHandoff });
+          } catch (error) {
+            earlyContextAbort.abort();
+            if (earlyContext) await earlyContext;
+            throw error;
           }
-          receipt.used = true;
-        };
-        let metadataTransportOwned = false;
-        let metadataHandoffReady = false;
-        let metadataHandoffSuggestion = null;
-        let initialHeaderWork = null;
-        let initialHeaderNotice = null;
-        let initialAdmissionDurable = false;
-        let initialHeaderStopped = false;
-        let initialTitleScheduled;
-        let initialIconScheduled;
-        let persistOptionalHeader;
-        let optionalMetadata = null;
-        const socketReadyForSendAt = performance.now();
-        let capabilitiesWaitMs = 0;
-        let keyWaitMs = 0;
-        let recoveryKeypairMs = 0;
-        let encryptPayloadMs = 0;
-        if (!params.incognito && !ownerId2) {
-          earlyContextAbort.abort();
-          ws.close();
-          if (earlyContext) await earlyContext;
-          throw new Error("Authenticated user identity is required for saved chat recovery.");
-        }
-        const authSocketMs = Date.now() - authSocketStartedAt;
-        const mayDeferRecovery = !params.incognito && sdkMintedChatId && !teamId && !params.projectId && shouldWaitForAi;
-        let recoveryDiscovery = null;
-        let recoveryDiscoveryError = null;
-        let contextAckRejection = null;
-        let removeContextAckWatcher = null;
-        try {
-          if (!params.incognito) {
-            try {
-              ws.send("chat_metadata_warmup", teamId ? { team_id: teamId } : {});
-            } catch {
+          const { ws, ownerId: ownerId2 } = opened;
+          let catalogTurnId = null;
+          let rejectCatalogDelivery;
+          const catalogDeliveryFailure = new Promise((_resolve, reject) => {
+            rejectCatalogDelivery = reject;
+          });
+          void catalogDeliveryFailure.catch(() => {
+          });
+          const stopProjectCatalogResponder = !params.incognito ? registerCliProjectFocusCatalogResponder({
+            ws,
+            client: this,
+            chatId,
+            teamId: teamId ?? null,
+            isCurrent: () => contextOwnerIsCurrent() && !!catalogTurnId && this.activeSubmittedChatTurns.get(chatId) === catalogTurnId,
+            isOfferedProject: (projectId) => catalogEligibleProjectIds.has(projectId),
+            onDeliveryFailure: (error) => rejectCatalogDelivery(error)
+          }) : () => {
+          };
+          const consumeSocketMemoryReceipt = async () => {
+            if (!socketMemoryReceipt) return;
+            const receipt = socketMemoryReceipt;
+            if (receipt.used || receipt.ws !== ws || receipt.snapshot !== availableMemories || receipt.resultRows !== socketSnapshotResultRows || receipt.projectRows !== socketProjectCandidateRows || receipt.candidates !== verifiedProjectCandidates || !ws.isOpen() || receipt.optionsKey !== socketMemoryOptionsKey()) {
+              throw new Error("Personal Memory snapshot socket receipt is invalid.");
             }
-            const recoveryStartedAt = Date.now();
-            recoveryDiscovery = ws.waitForRecoveryOutputDiscovery().then(
-              () => {
-                recoveryMs = Date.now() - recoveryStartedAt;
-              },
-              (error) => {
-                recoveryDiscoveryError = error;
-                throw error;
+            await this.withFreshStoredSession(async () => {
+              if (!ws.isOpen() || JSON.stringify([
+                this.sendSocketOwnerKey(this.requireSession(), teamId),
+                authCookieFingerprint(this.http.getCookieMap())
+              ]) !== receipt.ownerKey) {
+                throw new Error("Personal Memory snapshot owner changed before send.");
               }
-            );
-            void recoveryDiscovery.catch(() => {
             });
-            if (mayDeferRecovery) {
-              const capabilitiesWaitStartedAt = performance.now();
-              await Promise.race([ws.waitForServerCapabilities(), recoveryDiscovery]);
-              capabilitiesWaitMs = Math.round(performance.now() - capabilitiesWaitStartedAt);
-            } else await recoveryDiscovery;
-          }
-          const messageId2 = randomUUID9();
-          const wallCreatedAt = Math.floor(Date.now() / 1e3);
-          const createdAt = !teamId && !params.incognito && params.chatId ? nextPersonalUserCreatedAt(wallCreatedAt, savedPrivacyHistory?.messages.map((row3) => row3.createdAt) ?? []) : wallCreatedAt;
-          const isNewChat = !params.chatId;
-          let messageHistoryForRequest = params.messageHistory;
-          if (!params.incognito && !isNewChat && !messageHistoryForRequest) {
-            const { messages } = savedPrivacyHistory;
-            messageHistoryForRequest = buildSavedChatMessageHistory(messages, chatId);
+            if (conditionalPrivacyReceipt && (conditionalPrivacyReceipt.epoch !== this.preparedPrivacyEpoch || conditionalPrivacyReceipt.preferencesKey !== JSON.stringify(await readPrivacyPreferences()))) {
+              throw new Error("Privacy preferences changed before send; prepare the turn again.");
+            }
+            receipt.used = true;
+          };
+          let metadataTransportOwned = false;
+          let metadataHandoffReady = false;
+          let metadataHandoffSuggestion = null;
+          let initialHeaderWork = null;
+          let initialHeaderNotice = null;
+          let initialAdmissionDurable = false;
+          let initialHeaderStopped = false;
+          let initialTitleScheduled;
+          let initialIconScheduled;
+          let persistOptionalHeader;
+          let optionalMetadata = null;
+          const socketReadyForSendAt = performance.now();
+          let capabilitiesWaitMs = 0;
+          let keyWaitMs = 0;
+          let recoveryKeypairMs = 0;
+          let encryptPayloadMs = 0;
+          if (!params.incognito && !ownerId2) {
+            earlyContextAbort.abort();
+            ws.close();
+            if (earlyContext) await earlyContext;
+            throw new Error("Authenticated user identity is required for saved chat recovery.");
           }
-          ws.send("set_active_chat", { chat_id: chatId, ...teamId ? { team_id: teamId } : {} });
-          const connectedAccountDirectory = buildConnectedAccountDirectoryPayload(
-            params.connectedAccountDirectory
-          );
-          const connectedAccountTokenRefs = params.connectedAccountTokenRefInputs?.length ? await this.createTurnTokenRefs({
-            chatId,
-            messageId: messageId2,
-            refs: params.connectedAccountTokenRefInputs,
-            teamId
-          }) : [];
-          assertNoConnectedAccountSecretLeak(connectedAccountTokenRefs);
-          let chatKeyBytes = null;
-          let activeFocusId = null;
-          let encryptedChatKey = null;
-          let chatSlugLookupKey = null;
-          let focusPhaseState = {};
-          let baselineMessagesV = 0;
-          let notificationTitle = null;
-          let terminalExpectedMessagesV = 1;
-          let savedTurnId = null;
-          if (!params.incognito) {
-            traceSendTiming("key_begin");
-            const masterKey = this.getMasterKeyBytes();
-            const preparedKey = isNewChat && ownsPreparedId && this.preparedChatKey?.chatId === chatId && this.preparedChatOwnerCurrent(this.preparedChatKey.owner, teamId) ? this.preparedChatKey : null;
-            if (preparedKey) this.preparedChatKey = null;
-            const keyWaitStartedAt = performance.now();
-            const prepared = independentNewChatKey ? await independentNewChatKey : preparedKey ? await preparedKey.value : null;
-            if (prepared && !this.preparedChatOwnerCurrent(independentKeyOwner, teamId)) throw new Error("Chat key preparation owner changed before send.");
-            const wrappingKey = prepared?.wrappingKey ?? await this.getChatWrappingKey(teamId, masterKey);
-            keyWaitMs = Math.round(performance.now() - keyWaitStartedAt);
-            chatSlugLookupKey = wrappingKey;
-            if (isNewChat && prepared) {
-              chatKeyBytes = prepared.key;
-              encryptedChatKey = prepared.encryptedKey;
-            } else if (isNewChat) {
-              chatKeyBytes = globalThis.crypto ? new Uint8Array(globalThis.crypto.getRandomValues(new Uint8Array(32))) : new Uint8Array(
-                (await import("crypto")).webcrypto.getRandomValues(
-                  new Uint8Array(32)
-                )
-              );
-              encryptedChatKey = await encryptBytesWithAesGcm(
-                chatKeyBytes,
-                wrappingKey
-              );
-            } else {
-              const cache = (savedPrivacyHistory && this.scopedChatHistory.get(savedPrivacyHistory)) ?? loadSyncCache(teamId) ?? await this.ensureSynced(false, [], { teamId });
-              const chat = cache.chats.find(
-                (c) => String(c.details.id ?? "") === chatId || String(c.details.id ?? "").startsWith(chatId)
+          const authSocketMs = Date.now() - authSocketStartedAt;
+          const mayDeferRecovery = !params.incognito && sdkMintedChatId && !teamId && !params.projectId && shouldWaitForAi;
+          let recoveryDiscovery = null;
+          let recoveryDiscoveryError = null;
+          let contextAckRejection = null;
+          let removeContextAckWatcher = null;
+          try {
+            if (!params.incognito) {
+              try {
+                ws.send("chat_metadata_warmup", teamId ? { team_id: teamId } : {});
+              } catch {
+              }
+              const recoveryStartedAt = Date.now();
+              recoveryDiscovery = ws.waitForRecoveryOutputDiscovery().then(
+                () => {
+                  recoveryMs = Date.now() - recoveryStartedAt;
+                },
+                (error) => {
+                  recoveryDiscoveryError = error;
+                  throw error;
+                }
               );
-              if (chat) {
-                baselineMessagesV = typeof chat.details.messages_v === "number" ? chat.details.messages_v : 0;
-                const encKey = typeof chat.details.encrypted_chat_key === "string" ? chat.details.encrypted_chat_key : null;
-                if (encKey) {
-                  chatKeyBytes = await this.resolveChatKey(cache, chat, wrappingKey, teamId);
-                  encryptedChatKey = encKey;
-                  if (!chatKeyBytes) throw new Error("Could not decrypt the saved chat key.");
-                  if (typeof chat.details.encrypted_title === "string") {
-                    try {
-                      notificationTitle = await decryptWithAesGcmCombined(chat.details.encrypted_title, chatKeyBytes);
-                    } catch {
+              void recoveryDiscovery.catch(() => {
+              });
+              if (mayDeferRecovery) {
+                const capabilitiesWaitStartedAt = performance.now();
+                await Promise.race([ws.waitForServerCapabilities(), recoveryDiscovery]);
+                capabilitiesWaitMs = Math.round(performance.now() - capabilitiesWaitStartedAt);
+              } else await recoveryDiscovery;
+            }
+            const messageId2 = randomUUID9();
+            const wallCreatedAt = Math.floor(Date.now() / 1e3);
+            const createdAt = !teamId && !params.incognito && params.chatId ? nextPersonalUserCreatedAt(wallCreatedAt, savedPrivacyHistory?.messages.map((row3) => row3.createdAt) ?? []) : wallCreatedAt;
+            const isNewChat = !params.chatId;
+            let messageHistoryForRequest = params.messageHistory;
+            if (!params.incognito && !isNewChat && !messageHistoryForRequest) {
+              const { messages } = savedPrivacyHistory;
+              messageHistoryForRequest = buildSavedChatMessageHistory(messages, chatId);
+            }
+            ws.send("set_active_chat", { chat_id: chatId, ...teamId ? { team_id: teamId } : {} });
+            const connectedAccountDirectory = buildConnectedAccountDirectoryPayload(
+              params.connectedAccountDirectory
+            );
+            const connectedAccountTokenRefs = params.connectedAccountTokenRefInputs?.length ? await this.createTurnTokenRefs({
+              chatId,
+              messageId: messageId2,
+              refs: params.connectedAccountTokenRefInputs,
+              teamId
+            }) : [];
+            assertNoConnectedAccountSecretLeak(connectedAccountTokenRefs);
+            let chatKeyBytes = null;
+            let activeFocusId = null;
+            let encryptedChatKey = null;
+            let chatSlugLookupKey = null;
+            let focusPhaseState = {};
+            let baselineMessagesV = 0;
+            let notificationTitle = null;
+            let terminalExpectedMessagesV = 1;
+            let savedTurnId = null;
+            if (!params.incognito) {
+              traceSendTiming("key_begin");
+              const masterKey = this.getMasterKeyBytes();
+              const preparedKey = isNewChat && ownsPreparedId && this.preparedChatKey?.chatId === chatId && this.preparedChatOwnerCurrent(this.preparedChatKey.owner, teamId) ? this.preparedChatKey : null;
+              if (preparedKey) this.preparedChatKey = null;
+              const keyWaitStartedAt = performance.now();
+              const prepared = independentNewChatKey ? await independentNewChatKey : preparedKey ? await preparedKey.value : null;
+              if (prepared && !this.preparedChatOwnerCurrent(independentKeyOwner, teamId)) throw new Error("Chat key preparation owner changed before send.");
+              const wrappingKey = prepared?.wrappingKey ?? await this.getChatWrappingKey(teamId, masterKey);
+              keyWaitMs = Math.round(performance.now() - keyWaitStartedAt);
+              chatSlugLookupKey = wrappingKey;
+              if (isNewChat && prepared) {
+                chatKeyBytes = prepared.key;
+                encryptedChatKey = prepared.encryptedKey;
+              } else if (isNewChat) {
+                chatKeyBytes = globalThis.crypto ? new Uint8Array(globalThis.crypto.getRandomValues(new Uint8Array(32))) : new Uint8Array(
+                  (await import("crypto")).webcrypto.getRandomValues(
+                    new Uint8Array(32)
+                  )
+                );
+                encryptedChatKey = await encryptBytesWithAesGcm(
+                  chatKeyBytes,
+                  wrappingKey
+                );
+              } else {
+                const cache = (savedPrivacyHistory && this.scopedChatHistory.get(savedPrivacyHistory)) ?? loadSyncCache(teamId) ?? await this.ensureSynced(false, [], { teamId });
+                const chat = cache.chats.find(
+                  (c) => String(c.details.id ?? "") === chatId || String(c.details.id ?? "").startsWith(chatId)
+                );
+                if (chat) {
+                  baselineMessagesV = typeof chat.details.messages_v === "number" ? chat.details.messages_v : 0;
+                  const encKey = typeof chat.details.encrypted_chat_key === "string" ? chat.details.encrypted_chat_key : null;
+                  if (encKey) {
+                    chatKeyBytes = await this.resolveChatKey(cache, chat, wrappingKey, teamId);
+                    encryptedChatKey = encKey;
+                    if (!chatKeyBytes) throw new Error("Could not decrypt the saved chat key.");
+                    if (typeof chat.details.encrypted_title === "string") {
+                      try {
+                        notificationTitle = await decryptWithAesGcmCombined(chat.details.encrypted_title, chatKeyBytes);
+                      } catch {
+                      }
                     }
-                  }
-                  const encryptedPhaseState = chat.details.encrypted_focus_phase_state;
-                  if (typeof encryptedPhaseState === "string" && encryptedPhaseState) {
-                    const phaseText = await decryptWithAesGcmCombined(encryptedPhaseState, chatKeyBytes);
-                    if (!phaseText) throw new Error("Could not decrypt focus phase progress. Sync before sending again.");
-                    focusPhaseState = JSON.parse(phaseText);
-                  }
-                  const encryptedFocusId = chat.details.encrypted_active_focus_id;
-                  if (typeof encryptedFocusId === "string" && encryptedFocusId) {
-                    activeFocusId = await decryptWithAesGcmCombined(encryptedFocusId, chatKeyBytes);
-                    if (!activeFocusId) {
-                      throw new Error("Could not decrypt the chat's active focus. Sync before sending again.");
+                    const encryptedPhaseState = chat.details.encrypted_focus_phase_state;
+                    if (typeof encryptedPhaseState === "string" && encryptedPhaseState) {
+                      const phaseText = await decryptWithAesGcmCombined(encryptedPhaseState, chatKeyBytes);
+                      if (!phaseText) throw new Error("Could not decrypt focus phase progress. Sync before sending again.");
+                      focusPhaseState = JSON.parse(phaseText);
+                    }
+                    const encryptedFocusId = chat.details.encrypted_active_focus_id;
+                    if (typeof encryptedFocusId === "string" && encryptedFocusId) {
+                      activeFocusId = await decryptWithAesGcmCombined(encryptedFocusId, chatKeyBytes);
+                      if (!activeFocusId) {
+                        throw new Error("Could not decrypt the chat's active focus. Sync before sending again.");
+                      }
                     }
                   }
                 }
+                if (!chatKeyBytes || !encryptedChatKey) {
+                  throw new Error(`Encrypted chat key not found for chat '${chatId}'. Sync and try again.`);
+                }
               }
-              if (!chatKeyBytes || !encryptedChatKey) {
-                throw new Error(`Encrypted chat key not found for chat '${chatId}'. Sync and try again.`);
-              }
+              traceSendTiming("key_ready");
             }
-            traceSendTiming("key_ready");
-          }
-          let focusPersistence = Promise.resolve();
-          let focusPersistenceError = null;
-          const chatContextEvents = !params.incognito && chatKeyBytes ? registerChatContextEvents({
-            ws,
-            chatId,
-            chatKey: chatKeyBytes,
-            existingMessageIds: savedPrivacyHistory?.messages.map(canonicalSavedChatMessageId) ?? [],
-            previousRulesSetKey: savedPrivacyHistory?.messages.filter((message) => message.role === "system").map((message) => parseChatContextContent(message.content)).filter((event) => event?.type === "rules_loaded").at(-1)?.set_key,
-            onApplied: params.onChatContextApplied
-          }) : null;
-          let projectAuthoringAvailable = null;
-          if (!params.incognito) ws.onMessageType("project_authoring_available", (value) => {
-            if (!value || typeof value !== "object") return;
-            const frame = value;
-            if (frame.chat_id === chatId && frame.user_message_id === messageId2 && typeof frame.project_id === "string")
-              projectAuthoringAvailable = { chat_id: chatId, project_id: frame.project_id, user_message_id: messageId2 };
-          });
-          const projectFocusCountdown = !params.incognito ? registerProjectFocusCountdown({
-            client: this,
-            ws,
-            chatId,
-            teamId,
-            onPending: params.onProjectFocusPending,
-            onError: (error) => {
-              focusPersistenceError = error;
-            }
-          }) : null;
-          ws.onMessageType("focus_mode_activated", (event) => {
-            if (event.chat_id !== chatId || !event.focus_id || !chatKeyBytes || params.incognito) return;
-            const focusId = event.focus_id;
-            if (!focusId.startsWith("project-")) delete focusPhaseState[focusId];
-            const key = chatKeyBytes;
-            focusPersistence = focusPersistence.then(async () => {
-              const encryptedFocusId = await encryptWithAesGcmCombined(focusId, key);
-              await ws.sendAsync("update_encrypted_active_focus_id", {
-                chat_id: chatId,
-                encrypted_active_focus_id: encryptedFocusId
-              });
-            }).catch((error) => {
-              focusPersistenceError = error;
+            let focusPersistence = Promise.resolve();
+            let focusPersistenceError = null;
+            const chatContextEvents = !params.incognito && chatKeyBytes ? registerChatContextEvents({
+              ws,
+              chatId,
+              chatKey: chatKeyBytes,
+              existingMessageIds: savedPrivacyHistory?.messages.map(canonicalSavedChatMessageId) ?? [],
+              previousRulesSetKey: savedPrivacyHistory?.messages.filter((message) => message.role === "system").map((message) => parseChatContextContent(message.content)).filter((event) => event?.type === "rules_loaded").at(-1)?.set_key,
+              onApplied: params.onChatContextApplied
+            }) : null;
+            let projectAuthoringAvailable = null;
+            if (!params.incognito) ws.onMessageType("project_authoring_available", (value) => {
+              if (!value || typeof value !== "object") return;
+              const frame = value;
+              if (frame.chat_id === chatId && frame.user_message_id === messageId2 && typeof frame.project_id === "string")
+                projectAuthoringAvailable = { chat_id: chatId, project_id: frame.project_id, user_message_id: messageId2 };
             });
-          });
-          ws.onMessageType("focus_phases_updated", (event) => {
-            if (event.chat_id !== chatId || !event.states || !chatKeyBytes || params.incognito) return;
-            const key = chatKeyBytes;
-            const states2 = event.states;
-            focusPersistence = focusPersistence.then(async () => {
-              for (const [focusId, phase] of Object.entries(states2)) {
-                if (phase.schema_version !== 1 || phase.chat_id !== chatId || phase.focus_id !== focusId || !Number.isSafeInteger(phase.version) || phase.version < 0 || !Array.isArray(phase.transitions) || phase.transitions.length > 32) {
-                  throw new Error("Invalid focus phase state received");
-                }
-                if (focusPhaseState[focusId]?.run_id === phase.run_id && focusPhaseState[focusId].version > phase.version) states2[focusId] = focusPhaseState[focusId];
+            const projectFocusCountdown = !params.incognito ? registerProjectFocusCountdown({
+              client: this,
+              ws,
+              chatId,
+              teamId,
+              onPending: params.onProjectFocusPending,
+              onError: (error) => {
+                focusPersistenceError = error;
               }
-              focusPhaseState = states2;
-              const encryptedState = await encryptWithAesGcmCombined(JSON.stringify(states2), key);
-              const persisted = ws.waitForMessage(
-                "encrypted_metadata_stored",
-                (payload) => payload.chat_id === chatId,
-                2e4
-              );
-              await ws.sendAsync("encrypted_chat_metadata", {
-                chat_id: chatId,
-                ...teamId ? { team_id: teamId } : {},
-                encrypted_focus_phase_state: encryptedState
-              });
-              await persisted;
-              const eventIds = /* @__PURE__ */ new Set();
-              for (const phase of Object.values(states2)) for (const transition of phase.transitions) {
-                if (transition.chat_id !== chatId || transition.focus_id !== phase.focus_id || !transition.event_id || eventIds.has(transition.event_id)) continue;
-                eventIds.add(transition.event_id);
-                const content = JSON.stringify(transition);
-                await ws.sendAsync("chat_system_message_added", {
+            }) : null;
+            ws.onMessageType("focus_mode_activated", (event) => {
+              if (event.chat_id !== chatId || !event.focus_id || !chatKeyBytes || params.incognito) return;
+              const focusId = event.focus_id;
+              if (!focusId.startsWith("project-")) delete focusPhaseState[focusId];
+              const key = chatKeyBytes;
+              focusPersistence = focusPersistence.then(async () => {
+                const encryptedFocusId = await encryptWithAesGcmCombined(focusId, key);
+                await ws.sendAsync("update_encrypted_active_focus_id", {
                   chat_id: chatId,
-                  message: {
-                    message_id: transition.event_id,
-                    role: "system",
-                    status: "synced",
-                    encrypted_content: await encryptWithAesGcmCombined(content, key),
-                    created_at: transition.created_at
-                  }
+                  encrypted_active_focus_id: encryptedFocusId
                 });
-              }
-              clearSyncCache(teamId);
-            }).catch((error) => {
-              focusPersistenceError = error;
+              }).catch((error) => {
+                focusPersistenceError = error;
+              });
             });
-          });
-          const clientCapabilities = taskUpdateJobsEnabled ? ["task_update_jobs"] : [];
-          if (!params.incognito && chatKeyBytes) {
-            registerCliProjectFileExecutor({
-              client: this,
-              ws,
-              chatId,
-              chatKey: chatKeyBytes,
-              piiMappings,
-              memories: availableMemories,
-              requestApproval: params.onProjectWriteApproval,
-              requestReadApproval: params.onProjectReadApproval,
-              onHostedVersionCommitted: params.onHostedVersionCommitted
+            ws.onMessageType("focus_phases_updated", (event) => {
+              if (event.chat_id !== chatId || !event.states || !chatKeyBytes || params.incognito) return;
+              const key = chatKeyBytes;
+              const states2 = event.states;
+              focusPersistence = focusPersistence.then(async () => {
+                for (const [focusId, phase] of Object.entries(states2)) {
+                  if (phase.schema_version !== 1 || phase.chat_id !== chatId || phase.focus_id !== focusId || !Number.isSafeInteger(phase.version) || phase.version < 0 || !Array.isArray(phase.transitions) || phase.transitions.length > 32) {
+                    throw new Error("Invalid focus phase state received");
+                  }
+                  if (focusPhaseState[focusId]?.run_id === phase.run_id && focusPhaseState[focusId].version > phase.version) states2[focusId] = focusPhaseState[focusId];
+                }
+                focusPhaseState = states2;
+                const encryptedState = await encryptWithAesGcmCombined(JSON.stringify(states2), key);
+                const persisted = ws.waitForMessage(
+                  "encrypted_metadata_stored",
+                  (payload) => payload.chat_id === chatId,
+                  2e4
+                );
+                await ws.sendAsync("encrypted_chat_metadata", {
+                  chat_id: chatId,
+                  ...teamId ? { team_id: teamId } : {},
+                  encrypted_focus_phase_state: encryptedState
+                });
+                await persisted;
+                const eventIds = /* @__PURE__ */ new Set();
+                for (const phase of Object.values(states2)) for (const transition of phase.transitions) {
+                  if (transition.chat_id !== chatId || transition.focus_id !== phase.focus_id || !transition.event_id || eventIds.has(transition.event_id)) continue;
+                  eventIds.add(transition.event_id);
+                  const content = JSON.stringify(transition);
+                  await ws.sendAsync("chat_system_message_added", {
+                    chat_id: chatId,
+                    message: {
+                      message_id: transition.event_id,
+                      role: "system",
+                      status: "synced",
+                      encrypted_content: await encryptWithAesGcmCombined(content, key),
+                      created_at: transition.created_at
+                    }
+                  });
+                }
+                clearSyncCache(teamId);
+              }).catch((error) => {
+                focusPersistenceError = error;
+              });
             });
-            clientCapabilities.push("project_file_jobs");
-            registerRemoteCommandOriginClient({ ws, client: this, chatId, onReview: params.onRemoteCommandReview, onEvent: params.onRemoteCommandEvent });
-            clientCapabilities.push("remote_command_jobs");
-          }
-          const messagePayload = {
-            chat_id: chatId,
-            ...teamId ? { team_id: teamId } : {},
-            client_capabilities: clientCapabilities,
-            // Only decrypted current metadata restores focus; history is never authority.
-            active_focus_id: activeFocusId,
-            focus_phase_state: focusPhaseState,
-            is_incognito: Boolean(params.incognito),
-            message: {
-              message_id: messageId2,
-              chat_id: chatId,
-              role: "user",
-              sender_name: "User",
-              status: "sent",
-              content: finalMessage,
-              created_at: createdAt,
-              chat_has_title: Boolean(params.chatId)
-            }
-          };
-          const useCombinedAdmission = ws.supportsServerCapability?.("chat_turn_admit_v1") === true;
-          const useDeferredContext = useCombinedAdmission && !params.chatId && !params.projectId && !teamId && ws.supportsServerCapability?.("chat_turn_context_v1") === true;
-          const useSelectionDetailsV2 = useDeferredContext && sdkMintedChatId && ws.supportsServerCapability?.("chat_turn_context_selection_details_v2") === true;
-          const contextRequestId = !params.incognito && shouldWaitForAi && useDeferredContext ? randomUUID9() : null;
-          let pendingContext = null;
-          if (!params.incognito && shouldWaitForAi) {
-            if (contextRequestId) {
-              messagePayload.client_context_pending = true;
-              messagePayload.client_context_request_id = contextRequestId;
+            const clientCapabilities = taskUpdateJobsEnabled ? ["task_update_jobs"] : [];
+            if (!params.incognito && chatKeyBytes) {
+              registerCliProjectFileExecutor({
+                client: this,
+                ws,
+                chatId,
+                chatKey: chatKeyBytes,
+                piiMappings,
+                memories: availableMemories,
+                requestApproval: params.onProjectWriteApproval,
+                requestReadApproval: params.onProjectReadApproval,
+                onHostedVersionCommitted: params.onHostedVersionCommitted
+              });
+              clientCapabilities.push("project_file_jobs");
+              registerRemoteCommandOriginClient({ ws, client: this, chatId, onReview: params.onRemoteCommandReview, onEvent: params.onRemoteCommandEvent });
+              clientCapabilities.push("remote_command_jobs");
             }
-            pendingContext = (async () => {
-              const prefetchedDiscovery2 = followupDiscoveryRead ? await followupDiscoveryRead : void 0;
-              if (followupDiscoveryOwner && !this.preparedChatOwnerCurrent(followupDiscoveryOwner, teamId)) {
-                throw new Error("Chat workspace changed during context discovery.");
-              }
-              const prepared = earlyContext ? await earlyContext : { ok: true, value: await withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
-                prefetchedDiscovery: prefetchedDiscovery2,
-                sdkMintedChatId,
-                onRouting: publishRouting,
-                verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
-                usePersonalRoutingDirectory,
-                onProjectRouting: publishProjectRoutingTimed,
-                onProjectRoutingError: rejectProjectRouting
-              })), elapsedMs: Date.now() - contextStartedAt };
-              if (!prepared.ok) throw prepared.error;
-              if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-              if (process.env.OPENMATES_DEBUG === "1") {
-                console.error(`[chat preparation] pre_ws_ms=${preWsMs} memory_ms=${memoryPrepMs} privacy_ms=${privacyPrepMs} auth_ws_ms=${authSocketMs} recovery_ms=${recoveryMs} context_ms=${prepared.elapsedMs} project_candidates_ready_from_send_start_ms=${projectCandidatesReadyFromSendStartMs ?? "pending"}`);
+            const messagePayload = {
+              chat_id: chatId,
+              ...teamId ? { team_id: teamId } : {},
+              client_capabilities: clientCapabilities,
+              // Only decrypted current metadata restores focus; history is never authority.
+              active_focus_id: activeFocusId,
+              focus_phase_state: focusPhaseState,
+              is_incognito: Boolean(params.incognito),
+              message: {
+                message_id: messageId2,
+                chat_id: chatId,
+                role: "user",
+                sender_name: "User",
+                status: "sent",
+                content: finalMessage,
+                created_at: createdAt,
+                chat_has_title: Boolean(params.chatId)
               }
-              return deferredProjectDirectory ? { ...prepared.value, project_focus_candidates: prepared.value.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) } : prepared.value;
-            })();
-            void pendingContext.catch(() => {
-            });
-          }
-          if (params.testMockMarker !== void 0) {
-            const { capacityReplayMarker } = await import("./capacityReplayMarker-3NFJNDTZ.js");
-            messagePayload.test_mock_marker = capacityReplayMarker(
-              params.testMockMarker,
-              this.apiUrl,
-              process.env.OPENMATES_CAPACITY_CLIENT_REPLAY === "1"
-            );
-          }
-          if (isNewChat && encryptedChatKey) {
-            messagePayload.encrypted_chat_key = encryptedChatKey;
-          }
-          if (memoryMetadataKeys.length > 0) {
-            messagePayload.app_settings_memories_metadata = memoryMetadataKeys;
-          }
-          if (connectedAccountDirectory) {
-            messagePayload.connected_account_directory = connectedAccountDirectory;
-          }
-          if (connectedAccountTokenRefs.length > 0) {
-            messagePayload.connected_account_token_refs = connectedAccountTokenRefs;
-          }
-          if (params.benchmarkMetadata) {
-            messagePayload.benchmark_metadata = params.benchmarkMetadata;
-          }
-          if (params.learningMode) {
-            messagePayload.learning_mode = {
-              enabled: params.learningMode.enabled,
-              age_group: params.learningMode.ageGroup ?? null
             };
-          }
-          if (params.incognito) {
-            const providedHistory = (params.messageHistory ?? []).map(
-              (historyMessage) => buildInferenceHistoryMessage(historyMessage, historyMessage.chat_id ?? chatId)
-            );
-            messagePayload.message_history = [...providedHistory, {
-              message_id: messageId2,
-              chat_id: chatId,
-              role: "user",
-              sender_name: "User",
-              content: finalMessage,
-              created_at: createdAt
-            }];
-          } else if (messageHistoryForRequest && messageHistoryForRequest.length > 0) {
-            messagePayload.message_history = messageHistoryForRequest.map(
-              (historyMessage) => buildInferenceHistoryMessage(historyMessage, chatId)
-            );
-          }
-          if (params.preparedEmbeds && params.preparedEmbeds.length > 0) {
-            messagePayload.embeds = params.preparedEmbeds.map((embed) => ({
-              embed_id: embed.embedId,
-              type: embed.type,
-              content: embed.content,
-              status: embed.status,
-              text_preview: embed.textPreview
-            }));
-          }
-          const encryptedEmbeds = [...params.encryptedEmbeds ?? []];
-          if (!params.incognito && params.preparedEmbeds && params.preparedEmbeds.length > 0) {
-            if (!ownerId2) {
-              throw new Error("Authenticated user identity is required to encrypt embeds.");
+            const useCombinedAdmission = ws.supportsServerCapability?.("chat_turn_admit_v1") === true;
+            const useDeferredContext = useCombinedAdmission && !params.chatId && !params.projectId && !teamId && ws.supportsServerCapability?.("chat_turn_context_v1") === true;
+            const useSelectionDetailsV2 = useDeferredContext && sdkMintedChatId && ws.supportsServerCapability?.("chat_turn_context_selection_details_v2") === true;
+            const contextRequestId = !params.incognito && shouldWaitForAi && useDeferredContext ? randomUUID9() : null;
+            let pendingContext = null;
+            if (!params.incognito && shouldWaitForAi) {
+              if (contextRequestId) {
+                messagePayload.client_context_pending = true;
+                messagePayload.client_context_request_id = contextRequestId;
+              }
+              pendingContext = (async () => {
+                const prefetchedDiscovery2 = followupDiscoveryRead ? await followupDiscoveryRead : void 0;
+                if (followupDiscoveryOwner && !this.preparedChatOwnerCurrent(followupDiscoveryOwner, teamId)) {
+                  throw new Error("Chat workspace changed during context discovery.");
+                }
+                const prepared = earlyContext ? await earlyContext : { ok: true, value: await withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
+                  prefetchedDiscovery: prefetchedDiscovery2,
+                  sdkMintedChatId,
+                  onRouting: publishRouting,
+                  verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
+                  usePersonalRoutingDirectory,
+                  onProjectRouting: publishProjectRoutingTimed,
+                  onProjectRoutingError: rejectProjectRouting
+                })), elapsedMs: Date.now() - contextStartedAt };
+                if (!prepared.ok) throw prepared.error;
+                if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
+                if (process.env.OPENMATES_DEBUG === "1") {
+                  console.error(`[chat preparation] pre_ws_ms=${preWsMs} memory_ms=${memoryPrepMs} privacy_ms=${privacyPrepMs} auth_ws_ms=${authSocketMs} recovery_ms=${recoveryMs} context_ms=${prepared.elapsedMs} project_candidates_ready_from_send_start_ms=${projectCandidatesReadyFromSendStartMs ?? "pending"}`);
+                }
+                return deferredProjectDirectory ? { ...prepared.value, project_focus_candidates: prepared.value.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) } : prepared.value;
+              })();
+              void pendingContext.catch(() => {
+              });
             }
-            if (!chatKeyBytes) {
-              throw new Error("Saved chat key is required to encrypt every prepared embed.");
+            if (params.testMockMarker !== void 0) {
+              const { capacityReplayMarker } = await import("./capacityReplayMarker-3NFJNDTZ.js");
+              messagePayload.test_mock_marker = capacityReplayMarker(
+                params.testMockMarker,
+                this.apiUrl,
+                process.env.OPENMATES_CAPACITY_CLIENT_REPLAY === "1"
+              );
             }
-            if (new Set(params.preparedEmbeds.map((embed) => embed.embedId)).size !== params.preparedEmbeds.length) {
-              throw new Error("Prepared message embed IDs must be unique.");
+            if (isNewChat && encryptedChatKey) {
+              messagePayload.encrypted_chat_key = encryptedChatKey;
             }
-            const preparedIds = params.preparedEmbeds.map((embed) => embed.embedId);
-            if (preparedIds.some((id) => !id || id.length > 128)) {
-              throw new Error("Prepared message embed ID is invalid.");
+            if (memoryMetadataKeys.length > 0) {
+              messagePayload.app_settings_memories_metadata = memoryMetadataKeys;
             }
-            const canonicalReady = /* @__PURE__ */ new Set();
-            for (let offset = 0; offset < preparedIds.length; offset += 20) {
-              const selectedIds = preparedIds.slice(offset, offset + 20);
-              if (Buffer.byteLength(JSON.stringify({ embed_ids: selectedIds }), "utf8") > 4096) {
-                throw new Error("Message embed availability request exceeds its byte limit.");
-              }
-              const path2 = this.appendTeamQuery(
-                `/v1/embeds/chats/${encodeURIComponent(chatId)}/references/availability`,
-                { teamId }
-              );
-              const availability = await this.http.post(path2, { embed_ids: selectedIds }, this.getCliRequestHeaders());
-              if (!availability.ok) {
-                throw new Error(`Message embed availability lookup failed with HTTP ${availability.status}.`);
-              }
-              const page = classifyMessageEmbedAvailability(selectedIds, availability.data.results);
-              for (const id of page.ready) canonicalReady.add(id);
+            if (connectedAccountDirectory) {
+              messagePayload.connected_account_directory = connectedAccountDirectory;
             }
-            const masterKey = this.getMasterKeyBytes();
-            for (const embed of params.preparedEmbeds) {
-              if (canonicalReady.has(embed.embedId)) continue;
-              const encrypted = await encryptEmbed(
-                embed,
-                masterKey,
-                chatKeyBytes,
-                chatId,
-                messageId2,
-                ownerId2
+            if (connectedAccountTokenRefs.length > 0) {
+              messagePayload.connected_account_token_refs = connectedAccountTokenRefs;
+            }
+            if (params.benchmarkMetadata) {
+              messagePayload.benchmark_metadata = params.benchmarkMetadata;
+            }
+            if (params.learningMode) {
+              messagePayload.learning_mode = {
+                enabled: params.learningMode.enabled,
+                age_group: params.learningMode.ageGroup ?? null
+              };
+            }
+            if (params.incognito) {
+              const providedHistory = (params.messageHistory ?? []).map(
+                (historyMessage) => buildInferenceHistoryMessage(historyMessage, historyMessage.chat_id ?? chatId)
+              );
+              messagePayload.message_history = [...providedHistory, {
+                message_id: messageId2,
+                chat_id: chatId,
+                role: "user",
+                sender_name: "User",
+                content: finalMessage,
+                created_at: createdAt
+              }];
+            } else if (messageHistoryForRequest && messageHistoryForRequest.length > 0) {
+              messagePayload.message_history = messageHistoryForRequest.map(
+                (historyMessage) => buildInferenceHistoryMessage(historyMessage, chatId)
               );
-              if (!encrypted?.encrypted_content || !encrypted.encrypted_type || encrypted.embed_keys.length !== 2) {
-                throw new Error(`Prepared message embed ${embed.embedId} is missing required ciphertext or key wrappers.`);
-              }
-              encryptedEmbeds.push(encrypted);
             }
-          }
-          if (!params.incognito && encryptedEmbeds.length > 0) {
-            if (!ownerId2) throw new Error("Authenticated owner identity is required for encrypted message embeds.");
-            assertCompleteEncryptedEmbedBundle(encryptedEmbeds, { chatId, messageId: messageId2, ownerId: ownerId2 });
-          }
-          if (encryptedEmbeds.length > 0) {
-            messagePayload.encrypted_embeds = encryptedEmbeds;
-          }
-          let dispatchHandlersReady = () => {
-          };
-          const handlersReady = new Promise((resolve20) => {
-            dispatchHandlersReady = resolve20;
-          });
-          let admissionPayload = null;
-          let precollectedResponse = params.precollectResponse && params.incognito && shouldWaitForAi ? ws.collectAiResponse(messageId2, chatId, { onStream: params.onStream, timeoutMs: params.responseTimeoutMs }) : null;
-          if (!params.incognito && chatKeyBytes && encryptedChatKey) {
-            traceSendTiming("preflight_begin");
-            const protocolVersion = 1;
-            const chatKeyVersion = 1;
-            const turnId = privacyTurnId;
-            savedTurnId = turnId;
-            terminalExpectedMessagesV = baselineMessagesV + 1;
-            const recoveryKeypairStartedAt = performance.now();
-            const recoveryKeypair = independentRecoveryKeypair ? await independentRecoveryKeypair : await deriveChatCompletionRecoveryKeypair(
-              Buffer.from(chatKeyBytes).toString("base64url"),
-              chatId,
-              chatKeyVersion
-            );
-            recoveryKeypairMs = Math.round(performance.now() - recoveryKeypairStartedAt);
-            const encryptPayloadStartedAt = performance.now();
-            const [encryptedContent, encryptedSenderName, encryptedPiiMappings] = await Promise.all([
-              encryptWithAesGcmCombined(finalMessage, chatKeyBytes),
-              encryptWithAesGcmCombined(teamSenderName, chatKeyBytes),
-              piiMappings.length ? encryptWithAesGcmCombined(JSON.stringify(piiMappings), chatKeyBytes) : null
-            ]);
-            const encryptedUserMessage = {
-              client_message_id: messageId2,
-              chat_id: chatId,
-              encrypted_content: encryptedContent,
-              role: "user",
-              created_at: createdAt,
-              updated_at: createdAt
-            };
-            encryptedUserMessage.encrypted_sender_name = encryptedSenderName;
-            if (encryptedPiiMappings) encryptedUserMessage.encrypted_pii_mappings = encryptedPiiMappings;
-            Object.assign(messagePayload, {
-              turn_id: turnId,
-              recovery_public_key: recoveryKeypair.publicKey,
-              chat_key_version: chatKeyVersion
-            });
-            let preflightInferenceRequest = messagePayload;
-            if (teamId) {
-              const teamInferenceHistory = [
-                ...(messageHistoryForRequest ?? []).map((historyMessage) => ({
-                  role: historyMessage.role,
-                  content: historyMessage.content,
-                  category: historyMessage.category ?? null,
-                  sender_name: historyMessage.sender_name ?? historyMessage.role,
-                  created_at: historyMessage.created_at
-                })),
-                {
-                  role: "user",
-                  content: finalMessage,
-                  category: null,
-                  sender_name: teamSenderName,
-                  created_at: createdAt
+            if (params.preparedEmbeds && params.preparedEmbeds.length > 0) {
+              messagePayload.embeds = params.preparedEmbeds.map((embed) => ({
+                embed_id: embed.embedId,
+                type: embed.type,
+                content: embed.content,
+                status: embed.status,
+                text_preview: embed.textPreview
+              }));
+            }
+            const encryptedEmbeds = [...params.encryptedEmbeds ?? []];
+            if (!params.incognito && params.preparedEmbeds && params.preparedEmbeds.length > 0) {
+              if (!ownerId2) {
+                throw new Error("Authenticated user identity is required to encrypt embeds.");
+              }
+              if (!chatKeyBytes) {
+                throw new Error("Saved chat key is required to encrypt every prepared embed.");
+              }
+              if (new Set(params.preparedEmbeds.map((embed) => embed.embedId)).size !== params.preparedEmbeds.length) {
+                throw new Error("Prepared message embed IDs must be unique.");
+              }
+              const preparedIds = params.preparedEmbeds.map((embed) => embed.embedId);
+              if (preparedIds.some((id) => !id || id.length > 128)) {
+                throw new Error("Prepared message embed ID is invalid.");
+              }
+              const canonicalReady = /* @__PURE__ */ new Set();
+              for (let offset = 0; offset < preparedIds.length; offset += 20) {
+                const selectedIds = preparedIds.slice(offset, offset + 20);
+                if (Buffer.byteLength(JSON.stringify({ embed_ids: selectedIds }), "utf8") > 4096) {
+                  throw new Error("Message embed availability request exceeds its byte limit.");
                 }
-              ];
-              const teamMessageEnvelope = { ...encryptedUserMessage, message_id: messageId2 };
-              delete messagePayload.message_history;
-              messagePayload.message = teamMessageEnvelope;
-              if (shouldWaitForAi) {
-                messagePayload.team_ai_invocation = { history: teamInferenceHistory };
-                preflightInferenceRequest = {
-                  ...messagePayload,
-                  message_history: teamInferenceHistory
-                };
+                const path2 = this.appendTeamQuery(
+                  `/v1/embeds/chats/${encodeURIComponent(chatId)}/references/availability`,
+                  { teamId }
+                );
+                const availability = await this.http.post(path2, { embed_ids: selectedIds }, this.getCliRequestHeaders());
+                if (!availability.ok) {
+                  throw new Error(`Message embed availability lookup failed with HTTP ${availability.status}.`);
+                }
+                const page = classifyMessageEmbedAvailability(selectedIds, availability.data.results);
+                for (const id of page.ready) canonicalReady.add(id);
+              }
+              const masterKey = this.getMasterKeyBytes();
+              for (const embed of params.preparedEmbeds) {
+                if (canonicalReady.has(embed.embedId)) continue;
+                const encrypted = await encryptEmbed(
+                  embed,
+                  masterKey,
+                  chatKeyBytes,
+                  chatId,
+                  messageId2,
+                  ownerId2
+                );
+                if (!encrypted?.encrypted_content || !encrypted.encrypted_type || encrypted.embed_keys.length !== 2) {
+                  throw new Error(`Prepared message embed ${embed.embedId} is missing required ciphertext or key wrappers.`);
+                }
+                encryptedEmbeds.push(encrypted);
               }
             }
-            const preflightPayload = {
-              protocol_version: protocolVersion,
-              chat_id: chatId,
-              ...teamId ? { team_id: teamId } : {},
-              turn_id: turnId,
-              message_id: messageId2,
-              chat_key_version: chatKeyVersion,
-              encrypted_chat_key: encryptedChatKey,
-              recovery_public_key: recoveryKeypair.publicKey,
-              expected_messages_v: baselineMessagesV,
-              encrypted_user_message: encryptedUserMessage,
-              inference_request: preflightInferenceRequest,
-              ...conditionalPrivacyReceipt ? {
-                privacy_receipt_id: conditionalPrivacyReceipt.receiptId,
-                privacy_generation: conditionalPrivacyReceipt.generation
-              } : {}
+            if (!params.incognito && encryptedEmbeds.length > 0) {
+              if (!ownerId2) throw new Error("Authenticated owner identity is required for encrypted message embeds.");
+              assertCompleteEncryptedEmbedBundle(encryptedEmbeds, { chatId, messageId: messageId2, ownerId: ownerId2 });
+            }
+            if (encryptedEmbeds.length > 0) {
+              messagePayload.encrypted_embeds = encryptedEmbeds;
+            }
+            let dispatchHandlersReady = () => {
             };
-            if (isNewChat) {
-              if (!chatSlugLookupKey) {
-                throw new Error("Encrypted chat slug lookup key was not initialized.");
-              }
-              const initialTitle = teamId && !shouldWaitForAi ? teamChatTitleFromMessage(params.message) : "";
-              const slugMetadata = await buildEncryptedObjectSlugMetadata({
-                value: selectNewChatSlugValue({
-                  message: finalMessage,
-                  chatId,
-                  explicitSlug: params.slug
-                }),
-                encryptionKey: chatKeyBytes,
-                lookupKey: chatSlugLookupKey
-              });
-              preflightPayload.encrypted_chat_metadata = {
-                encrypted_title: await encryptWithAesGcmCombined(initialTitle, chatKeyBytes),
-                encrypted_slug: slugMetadata.encrypted_slug,
-                slug_lookup_hash: slugMetadata.slug_lookup_hash,
-                encrypted_chat_key: encryptedChatKey,
+            const handlersReady = new Promise((resolve20) => {
+              dispatchHandlersReady = resolve20;
+            });
+            let admissionPayload = null;
+            let precollectedResponse = params.precollectResponse && params.incognito && shouldWaitForAi ? ws.collectAiResponse(messageId2, chatId, { onStream: params.onStream, timeoutMs: params.responseTimeoutMs }) : null;
+            if (!params.incognito && chatKeyBytes && encryptedChatKey) {
+              traceSendTiming("preflight_begin");
+              const protocolVersion = 1;
+              const chatKeyVersion = 1;
+              const turnId = privacyTurnId;
+              savedTurnId = turnId;
+              catalogTurnId = turnId;
+              terminalExpectedMessagesV = baselineMessagesV + 1;
+              const recoveryKeypairStartedAt = performance.now();
+              const recoveryKeypair = independentRecoveryKeypair ? await independentRecoveryKeypair : await deriveChatCompletionRecoveryKeypair(
+                Buffer.from(chatKeyBytes).toString("base64url"),
+                chatId,
+                chatKeyVersion
+              );
+              recoveryKeypairMs = Math.round(performance.now() - recoveryKeypairStartedAt);
+              const encryptPayloadStartedAt = performance.now();
+              const [encryptedContent, encryptedSenderName, encryptedPiiMappings] = await Promise.all([
+                encryptWithAesGcmCombined(finalMessage, chatKeyBytes),
+                encryptWithAesGcmCombined(teamSenderName, chatKeyBytes),
+                piiMappings.length ? encryptWithAesGcmCombined(JSON.stringify(piiMappings), chatKeyBytes) : null
+              ]);
+              const encryptedUserMessage = {
+                client_message_id: messageId2,
+                chat_id: chatId,
+                encrypted_content: encryptedContent,
+                role: "user",
                 created_at: createdAt,
                 updated_at: createdAt
               };
-            }
-            encryptPayloadMs = Math.round(performance.now() - encryptPayloadStartedAt);
-            try {
+              encryptedUserMessage.encrypted_sender_name = encryptedSenderName;
+              if (encryptedPiiMappings) encryptedUserMessage.encrypted_pii_mappings = encryptedPiiMappings;
+              Object.assign(messagePayload, {
+                turn_id: turnId,
+                recovery_public_key: recoveryKeypair.publicKey,
+                chat_key_version: chatKeyVersion
+              });
+              let preflightInferenceRequest = messagePayload;
               if (teamId) {
-                await stageCliTeamNotificationPreview(ws, {
-                  teamId,
-                  chatId,
-                  messageId: messageId2,
-                  content: finalMessage,
-                  title: notificationTitle
+                const teamInferenceHistory = [
+                  ...(messageHistoryForRequest ?? []).map((historyMessage) => ({
+                    role: historyMessage.role,
+                    content: historyMessage.content,
+                    category: historyMessage.category ?? null,
+                    sender_name: historyMessage.sender_name ?? historyMessage.role,
+                    created_at: historyMessage.created_at
+                  })),
+                  {
+                    role: "user",
+                    content: finalMessage,
+                    category: null,
+                    sender_name: teamSenderName,
+                    created_at: createdAt
+                  }
+                ];
+                const teamMessageEnvelope = { ...encryptedUserMessage, message_id: messageId2 };
+                delete messagePayload.message_history;
+                messagePayload.message = teamMessageEnvelope;
+                if (shouldWaitForAi) {
+                  messagePayload.team_ai_invocation = { history: teamInferenceHistory };
+                  preflightInferenceRequest = {
+                    ...messagePayload,
+                    message_history: teamInferenceHistory
+                  };
+                }
+              }
+              const preflightPayload = {
+                protocol_version: protocolVersion,
+                chat_id: chatId,
+                ...teamId ? { team_id: teamId } : {},
+                turn_id: turnId,
+                message_id: messageId2,
+                chat_key_version: chatKeyVersion,
+                encrypted_chat_key: encryptedChatKey,
+                recovery_public_key: recoveryKeypair.publicKey,
+                expected_messages_v: baselineMessagesV,
+                encrypted_user_message: encryptedUserMessage,
+                inference_request: preflightInferenceRequest,
+                ...conditionalPrivacyReceipt ? {
+                  privacy_receipt_id: conditionalPrivacyReceipt.receiptId,
+                  privacy_generation: conditionalPrivacyReceipt.generation
+                } : {}
+              };
+              if (isNewChat) {
+                if (!chatSlugLookupKey) {
+                  throw new Error("Encrypted chat slug lookup key was not initialized.");
+                }
+                const initialTitle = teamId && !shouldWaitForAi ? teamChatTitleFromMessage(params.message) : "";
+                const slugMetadata = await buildEncryptedObjectSlugMetadata({
+                  value: selectNewChatSlugValue({
+                    message: finalMessage,
+                    chatId,
+                    explicitSlug: params.slug
+                  }),
+                  encryptionKey: chatKeyBytes,
+                  lookupKey: chatSlugLookupKey
                 });
+                preflightPayload.encrypted_chat_metadata = {
+                  encrypted_title: await encryptWithAesGcmCombined(initialTitle, chatKeyBytes),
+                  encrypted_slug: slugMetadata.encrypted_slug,
+                  slug_lookup_hash: slugMetadata.slug_lookup_hash,
+                  encrypted_chat_key: encryptedChatKey,
+                  created_at: createdAt,
+                  updated_at: createdAt
+                };
+              }
+              encryptPayloadMs = Math.round(performance.now() - encryptPayloadStartedAt);
+              try {
+                if (teamId) {
+                  await stageCliTeamNotificationPreview(ws, {
+                    teamId,
+                    chatId,
+                    messageId: messageId2,
+                    content: finalMessage,
+                    title: notificationTitle
+                  });
+                }
+                if (params.projectId) {
+                  await prepareCliProjectFocusForPreflight({
+                    ws,
+                    chatId,
+                    teamId,
+                    isNewChat,
+                    encryptedChatKey,
+                    createdAt,
+                    activateFocus: () => activateCliProjectFocus(this, params.projectId, chatId, teamId)
+                  });
+                  const focusedContext = await prepareCliJevContext(
+                    this,
+                    chatId,
+                    { teamId, personal: !teamId },
+                    params.jevContext,
+                    finalMessage
+                  );
+                  pendingContext = Promise.resolve(focusedContext);
+                }
+                admissionPayload = preflightPayload;
+                traceSendTiming("preflight_ready");
+              } catch (error) {
+                ws.close();
+                throw error;
               }
-              if (params.projectId) {
-                await prepareCliProjectFocusForPreflight({
+            }
+            const initialHeaderOwner = this.preparedChatOwner(this.requireSession(), teamId);
+            const startInitialHeader = () => {
+              if (!initialAdmissionDurable || !initialHeaderNotice || !chatKeyBytes || !isNewChat || params.incognito || !savedTurnId) return;
+              const notice = { ...initialHeaderNotice }, key = chatKeyBytes, turn = savedTurnId;
+              const titleChanged = !!notice.chatTitle && notice.chatTitle !== initialTitleScheduled;
+              const iconChanged = !!notice.chatIcon && notice.chatIcon !== initialIconScheduled;
+              if (!titleChanged && !iconChanged) return;
+              initialTitleScheduled = notice.chatTitle ?? initialTitleScheduled;
+              initialIconScheduled = notice.chatIcon ?? initialIconScheduled;
+              const current2 = () => !initialHeaderStopped && ws.isOpen() && this.preparedChatOwnerCurrent(initialHeaderOwner, teamId) && this.activeSubmittedChatTurns.get(chatId) === turn;
+              initialHeaderWork = (initialHeaderWork ?? Promise.resolve()).then(async () => {
+                if (!current2()) return;
+                if (titleChanged) await this.persistPostProcessingMetadata({
                   ws,
                   chatId,
                   teamId,
-                  isNewChat,
+                  chatKeyBytes: key,
                   encryptedChatKey,
-                  createdAt,
-                  activateFocus: () => activateCliProjectFocus(this, params.projectId, chatId, teamId)
+                  followUpSuggestions: [],
+                  suggestedFollowupMessage: null,
+                  newChatSuggestions: [],
+                  chatSummary: null,
+                  chatTags: [],
+                  updatedChatTitle: notice.chatTitle ?? null,
+                  sourceTitleVersion: notice.sourceTitleVersion ?? null,
+                  sourceMetadataVersion: notice.sourceMetadataVersion ?? null,
+                  unversionedGeneratedTitle: notice.sourceTitleVersion === void 0 && notice.sourceMetadataVersion === void 0,
+                  ownerCurrent: current2
                 });
-                const focusedContext = await prepareCliJevContext(
-                  this,
-                  chatId,
-                  { teamId, personal: !teamId },
-                  params.jevContext,
-                  finalMessage
-                );
-                pendingContext = Promise.resolve(focusedContext);
+                if (!current2()) return;
+                if (iconChanged || notice.category) {
+                  const [encryptedIcon, encryptedCategory] = await Promise.all([
+                    notice.chatIcon ? encryptWithAesGcmCombined(notice.chatIcon, key) : null,
+                    notice.category ? encryptWithAesGcmCombined(notice.category, key) : null
+                  ]);
+                  if (!current2()) return;
+                  const stored = ws.waitForMessage("encrypted_metadata_stored", (value) => value.chat_id === chatId, 2e4);
+                  void stored.catch(() => {
+                  });
+                  await ws.sendAsync("encrypted_chat_metadata", {
+                    chat_id: chatId,
+                    ...teamId ? { team_id: teamId } : {},
+                    encrypted_chat_key: encryptedChatKey,
+                    ...encryptedIcon ? { encrypted_icon: encryptedIcon } : {},
+                    ...encryptedCategory ? { encrypted_chat_category: encryptedCategory } : {}
+                  });
+                  await stored;
+                }
+                if (current2()) clearSyncCache(teamId);
+              }).catch(() => {
+              });
+            };
+            const onTurnStream = (event) => {
+              if (isNewChat && event.kind === "typing" && (event.chatTitle || event.chatIcon) && event.chatId === chatId && event.userMessageId === messageId2 && event.turnId === savedTurnId && event.taskId && (!initialHeaderNotice?.taskId || event.taskId === initialHeaderNotice.taskId)) {
+                initialHeaderNotice = { ...initialHeaderNotice, ...event };
+                startInitialHeader();
               }
-              admissionPayload = preflightPayload;
-              traceSendTiming("preflight_ready");
-            } catch (error) {
-              ws.close();
-              throw error;
-            }
-          }
-          const initialHeaderOwner = this.preparedChatOwner(this.requireSession(), teamId);
-          const startInitialHeader = () => {
-            if (!initialAdmissionDurable || !initialHeaderNotice || !chatKeyBytes || !isNewChat || params.incognito || !savedTurnId) return;
-            const notice = { ...initialHeaderNotice }, key = chatKeyBytes, turn = savedTurnId;
-            const titleChanged = !!notice.chatTitle && notice.chatTitle !== initialTitleScheduled;
-            const iconChanged = !!notice.chatIcon && notice.chatIcon !== initialIconScheduled;
-            if (!titleChanged && !iconChanged) return;
-            initialTitleScheduled = notice.chatTitle ?? initialTitleScheduled;
-            initialIconScheduled = notice.chatIcon ?? initialIconScheduled;
-            const current2 = () => !initialHeaderStopped && ws.isOpen() && this.preparedChatOwnerCurrent(initialHeaderOwner, teamId) && this.activeSubmittedChatTurns.get(chatId) === turn;
-            initialHeaderWork = (initialHeaderWork ?? Promise.resolve()).then(async () => {
-              if (!current2()) return;
-              if (titleChanged) await this.persistPostProcessingMetadata({
+              params.onStream?.(event);
+            };
+            if (!params.incognito && chatKeyBytes && savedTurnId) {
+              const key = chatKeyBytes;
+              const ownedTurnId = savedTurnId;
+              this.activeSubmittedChatTurns.set(chatId, ownedTurnId);
+              const owner2 = this.preparedChatOwner(this.requireSession(), teamId);
+              const stopOwned = () => optionalMetadata?.stop();
+              optionalMetadata = observeOwnedTurnMetadata({
                 ws,
                 chatId,
-                teamId,
-                chatKeyBytes: key,
-                encryptedChatKey,
-                followUpSuggestions: [],
-                suggestedFollowupMessage: null,
-                newChatSuggestions: [],
-                chatSummary: null,
-                chatTags: [],
-                updatedChatTitle: notice.chatTitle ?? null,
-                sourceTitleVersion: notice.sourceTitleVersion ?? null,
-                sourceMetadataVersion: notice.sourceMetadataVersion ?? null,
-                unversionedGeneratedTitle: notice.sourceTitleVersion === void 0 && notice.sourceMetadataVersion === void 0,
-                ownerCurrent: current2
+                turnId: savedTurnId,
+                userMessageId: messageId2,
+                closeAfterMetadata: true,
+                ownerCurrent: () => this.preparedChatOwnerCurrent(owner2, teamId),
+                persist: async (metadata) => {
+                  await this.persistPostProcessingMetadata({ ws, teamId, chatKeyBytes: key, encryptedChatKey, ...metadata });
+                  clearSyncCache(teamId);
+                },
+                onMetadata: params.onMetadata,
+                onReleased: () => {
+                  this.ownedMetadataSubscriptions.delete(stopOwned);
+                  if (this.activeSubmittedChatTurns.get(chatId) === ownedTurnId) this.activeSubmittedChatTurns.delete(chatId);
+                  if (metadataTransportOwned) ws.close();
+                }
               });
-              if (!current2()) return;
-              if (iconChanged || notice.category) {
-                const [encryptedIcon, encryptedCategory] = await Promise.all([
-                  notice.chatIcon ? encryptWithAesGcmCombined(notice.chatIcon, key) : null,
-                  notice.category ? encryptWithAesGcmCombined(notice.category, key) : null
-                ]);
-                if (!current2()) return;
-                const stored = ws.waitForMessage("encrypted_metadata_stored", (value) => value.chat_id === chatId, 2e4);
-                void stored.catch(() => {
-                });
-                await ws.sendAsync("encrypted_chat_metadata", {
-                  chat_id: chatId,
-                  ...teamId ? { team_id: teamId } : {},
-                  encrypted_chat_key: encryptedChatKey,
-                  ...encryptedIcon ? { encrypted_icon: encryptedIcon } : {},
-                  ...encryptedCategory ? { encrypted_chat_category: encryptedCategory } : {}
-                });
-                await stored;
-              }
-              if (current2()) clearSyncCache(teamId);
-            }).catch(() => {
-            });
-          };
-          const onTurnStream = (event) => {
-            if (isNewChat && event.kind === "typing" && (event.chatTitle || event.chatIcon) && event.chatId === chatId && event.userMessageId === messageId2 && event.turnId === savedTurnId && event.taskId && (!initialHeaderNotice?.taskId || event.taskId === initialHeaderNotice.taskId)) {
-              initialHeaderNotice = { ...initialHeaderNotice, ...event };
-              startInitialHeader();
+              while (this.ownedMetadataSubscriptions.size >= 8) this.ownedMetadataSubscriptions.values().next().value?.();
+              this.ownedMetadataSubscriptions.add(stopOwned);
             }
-            params.onStream?.(event);
-          };
-          if (!params.incognito && chatKeyBytes && savedTurnId) {
-            const key = chatKeyBytes;
-            const ownedTurnId = savedTurnId;
-            this.activeSubmittedChatTurns.set(chatId, ownedTurnId);
-            const owner2 = this.preparedChatOwner(this.requireSession(), teamId);
-            const stopOwned = () => optionalMetadata?.stop();
-            optionalMetadata = observeOwnedTurnMetadata({
-              ws,
-              chatId,
-              turnId: savedTurnId,
-              userMessageId: messageId2,
-              closeAfterMetadata: true,
-              ownerCurrent: () => this.preparedChatOwnerCurrent(owner2, teamId),
-              persist: async (metadata) => {
-                await this.persistPostProcessingMetadata({ ws, teamId, chatKeyBytes: key, encryptedChatKey, ...metadata });
-                clearSyncCache(teamId);
-              },
-              onMetadata: params.onMetadata,
-              onReleased: () => {
-                this.ownedMetadataSubscriptions.delete(stopOwned);
-                if (this.activeSubmittedChatTurns.get(chatId) === ownedTurnId) this.activeSubmittedChatTurns.delete(chatId);
-                if (metadataTransportOwned) ws.close();
-              }
+            if (!params.incognito && shouldWaitForAi) {
+              precollectedResponse = ws.collectAiResponse(messageId2, chatId, {
+                waitForPostProcessing: false,
+                onStream: onTurnStream,
+                onSubChatEvent: async (event) => {
+                  await handlersReady;
+                  await handleSubChatEvent(event);
+                },
+                onAppSettingsMemoriesRequest: async (event) => {
+                  await handlersReady;
+                  await handleAppSettingsMemoriesRequest(event);
+                },
+                timeoutMs: params.responseTimeoutMs,
+                recoveryTurnId: savedTurnId,
+                projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
+                remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
+              });
+            }
+            const queuedAdmission = !params.incognito && shouldWaitForAi ? ws.waitForMessage("message_queued", (payload) => {
+              const event = payload;
+              return event.chat_id === chatId && event.user_message_id === messageId2;
+            }, params.responseTimeoutMs ?? 9e4) : null;
+            if (queuedAdmission) void queuedAdmission.catch(() => {
             });
-            while (this.ownedMetadataSubscriptions.size >= 8) this.ownedMetadataSubscriptions.values().next().value?.();
-            this.ownedMetadataSubscriptions.add(stopOwned);
-          }
-          if (!params.incognito && shouldWaitForAi) {
-            precollectedResponse = ws.collectAiResponse(messageId2, chatId, {
-              waitForPostProcessing: false,
-              onStream: onTurnStream,
-              onSubChatEvent: async (event) => {
-                await handlersReady;
-                await handleSubChatEvent(event);
-              },
-              onAppSettingsMemoriesRequest: async (event) => {
-                await handlersReady;
-                await handleAppSettingsMemoriesRequest(event);
-              },
-              timeoutMs: params.responseTimeoutMs,
-              recoveryTurnId: savedTurnId,
-              projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
-              remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
+            const pausedHandoff = !params.incognito && shouldWaitForAi ? ws.waitForMessage("queued_handoff_paused", (payload) => {
+              const event = payload;
+              return event.chat_id === chatId && (event.message_id === messageId2 || event.message_id === void 0);
+            }, params.responseTimeoutMs ?? 9e4) : null;
+            if (pausedHandoff) void pausedHandoff.catch(() => {
             });
-          }
-          const queuedAdmission = !params.incognito && shouldWaitForAi ? ws.waitForMessage("message_queued", (payload) => {
-            const event = payload;
-            return event.chat_id === chatId && event.user_message_id === messageId2;
-          }, params.responseTimeoutMs ?? 9e4) : null;
-          if (queuedAdmission) void queuedAdmission.catch(() => {
-          });
-          const pausedHandoff = !params.incognito && shouldWaitForAi ? ws.waitForMessage("queued_handoff_paused", (payload) => {
-            const event = payload;
-            return event.chat_id === chatId && (event.message_id === messageId2 || event.message_id === void 0);
-          }, params.responseTimeoutMs ?? 9e4) : null;
-          if (pausedHandoff) void pausedHandoff.catch(() => {
-          });
-          const confirmed = ws.waitForMessage(
-            "chat_message_confirmed",
-            (payload) => {
-              const eventPayload = payload;
-              return eventPayload.chat_id === chatId && eventPayload.message_id === messageId2;
-            },
-            params.responseTimeoutMs ?? DEFAULT_CHAT_MESSAGE_CONFIRMATION_TIMEOUT_MS
-          );
-          let confirmedPayload;
-          let admissionContinuationPhase = "before_dispatch";
-          let admissionAckObserved = false;
-          let routingFrameSent = false;
-          let detailsFrameSent = false;
-          const admissionContinuationStartedAt = performance.now();
-          try {
-            if (admissionPayload) {
-              if (!useDeferredContext && recoveryDiscovery) await recoveryDiscovery;
-              if (recoveryDiscoveryError) throw recoveryDiscoveryError;
-              if (!contextRequestId && pendingContext) {
-                const context = await pendingContext;
-                Object.assign(messagePayload, context);
-                Object.assign(admissionPayload.inference_request, context);
-              }
-              if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-              const admissionAck = ws.waitForMessage("chat_turn_preflight_ack", (payload) => payload.turn_id === savedTurnId);
-              void admissionAck.catch(() => {
-              });
-              const frameDispatchAt = performance.now();
-              admissionContinuationPhase = "await_ack";
-              await consumeSocketMemoryReceipt();
-              await ws.sendAsync(useCombinedAdmission ? "chat_turn_admit" : "chat_turn_preflight", admissionPayload);
-              traceSendTiming("admission_frame");
-              if (process.env.OPENMATES_DEBUG === "1") {
-                console.error(`[chat admission preparation] sdk_minted=${sdkMintedChatId} defer_recovery=${mayDeferRecovery} combined_admission=${useCombinedAdmission} caps_wait_ms=${capabilitiesWaitMs} key_wait_ms=${keyWaitMs} recovery_keypair_ms=${recoveryKeypairMs} encrypt_payload_ms=${encryptPayloadMs} socket_ready_to_frame_dispatch_ms=${Math.round(frameDispatchAt - socketReadyForSendAt)} frame_dispatch_from_send_start_ms=${Math.round(frameDispatchAt - preWsStartedAt)} wire_send_ms=${Math.round(performance.now() - frameDispatchAt)}`);
-              }
-              const ackPayload = (await admissionAck).payload;
-              traceSendTiming("admission_ack");
-              admissionAckObserved = true;
-              if (typeof ackPayload.preflight_id !== "string" || !ackPayload.preflight_id) {
-                throw new Error("Encrypted chat admission acknowledgement omitted preflight_id.");
-              }
-              if (typeof ackPayload.committed_messages_v === "number" && Number.isSafeInteger(ackPayload.committed_messages_v)) {
-                terminalExpectedMessagesV = ackPayload.committed_messages_v;
-              }
-              initialAdmissionDurable = true;
-              startInitialHeader();
-              if (!useCombinedAdmission) {
-                Object.assign(messagePayload, { protocol_version: admissionPayload.protocol_version, preflight_id: ackPayload.preflight_id });
-                await ws.sendAsync("chat_message_added", messagePayload);
-              }
-              if (pendingContext && contextRequestId) {
-                admissionContinuationPhase = "await_routing";
-                const identity3 = {
-                  chat_id: chatId,
-                  turn_id: savedTurnId,
-                  message_id: messageId2,
-                  request_id: contextRequestId,
-                  ...teamId ? { team_id: teamId } : {}
-                };
-                let failureNotice = null;
-                const notifyContextFailure = (reason) => {
-                  if (failureNotice) return failureNotice;
-                  if (!ws.supportsServerCapability("chat_turn_context_failure_v1") || !ws.isOpen() || !contextOwnerIsCurrent() || !savedTurnId) return Promise.resolve();
-                  failureNotice = (async () => {
-                    const failureAck = ws.waitForMessage("chat_turn_context_failed_ack", (payload) => {
-                      const event = payload;
-                      return event.chat_id === chatId && event.turn_id === savedTurnId && event.message_id === messageId2 && event.request_id === contextRequestId;
-                    }, 5e3);
-                    void failureAck.catch(() => {
-                    });
-                    await ws.sendAsync("chat_turn_context_failed", { ...identity3, reason });
-                    const status = (await failureAck).payload;
-                    if (status.status !== "accepted" && status.status !== "duplicate") {
-                      throw new Error("Chat context failure receipt was rejected.");
-                    }
-                  })();
-                  return failureNotice;
-                };
-                let routing;
-                try {
-                  routing = useSelectionDetailsV2 ? await projectRoutingContext : deferredProjectDirectory ? (await Promise.all([pendingContext, projectRoutingContext]))[0] : params.projectId ? await pendingContext : await Promise.race([routingContext, pendingContext]);
-                } catch (error) {
-                  try {
-                    await notifyContextFailure(useSelectionDetailsV2 ? "project_discovery_failed" : "context_preparation_failed");
-                  } catch {
-                  }
-                  throw error;
+            const confirmed = ws.waitForMessage(
+              "chat_message_confirmed",
+              (payload) => {
+                const eventPayload = payload;
+                return eventPayload.chat_id === chatId && eventPayload.message_id === messageId2;
+              },
+              params.responseTimeoutMs ?? DEFAULT_CHAT_MESSAGE_CONFIRMATION_TIMEOUT_MS
+            );
+            let confirmedPayload;
+            let admissionContinuationPhase = "before_dispatch";
+            let admissionAckObserved = false;
+            let routingFrameSent = false;
+            let detailsFrameSent = false;
+            const admissionContinuationStartedAt = performance.now();
+            try {
+              if (admissionPayload) {
+                if (!useDeferredContext && recoveryDiscovery) await recoveryDiscovery;
+                if (recoveryDiscoveryError) throw recoveryDiscoveryError;
+                if (!contextRequestId && pendingContext) {
+                  const context = await pendingContext;
+                  Object.assign(messagePayload, context);
+                  Object.assign(admissionPayload.inference_request, context);
                 }
                 if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-                let rejectContextAck;
-                contextAckRejection = new Promise((_resolve, reject) => {
-                  rejectContextAck = reject;
+                const admissionAck = ws.waitForMessage("chat_turn_preflight_ack", (payload) => payload.turn_id === savedTurnId);
+                void admissionAck.catch(() => {
                 });
-                void contextAckRejection.catch(() => {
-                });
-                let rejectedPhaseSeen = false;
-                const attemptedContextPhases = /* @__PURE__ */ new Set();
-                removeContextAckWatcher = ws.onMessageType("chat_turn_context_ack", (event) => {
-                  if (rejectedPhaseSeen || event.chat_id !== chatId || event.turn_id !== savedTurnId || event.message_id !== messageId2 || event.request_id !== contextRequestId || event.phase !== "routing" && event.phase !== "details" || !attemptedContextPhases.has(event.phase)) return;
-                  if (event.status === "accepted" || event.status === "duplicate") {
-                    traceSendTiming(event.phase === "routing" ? "routing_ack" : "details_ack");
-                    return;
-                  }
-                  if (event.status !== "rejected") return;
-                  rejectedPhaseSeen = true;
-                  if (!contextOwnerIsCurrent()) {
-                    rejectContextAck(new Error("Chat workspace changed while preparing context."));
-                    return;
+                const frameDispatchAt = performance.now();
+                admissionContinuationPhase = "await_ack";
+                await consumeSocketMemoryReceipt();
+                await ws.sendAsync(useCombinedAdmission ? "chat_turn_admit" : "chat_turn_preflight", admissionPayload);
+                traceSendTiming("admission_frame");
+                if (process.env.OPENMATES_DEBUG === "1") {
+                  console.error(`[chat admission preparation] sdk_minted=${sdkMintedChatId} defer_recovery=${mayDeferRecovery} combined_admission=${useCombinedAdmission} caps_wait_ms=${capabilitiesWaitMs} key_wait_ms=${keyWaitMs} recovery_keypair_ms=${recoveryKeypairMs} encrypt_payload_ms=${encryptPayloadMs} socket_ready_to_frame_dispatch_ms=${Math.round(frameDispatchAt - socketReadyForSendAt)} frame_dispatch_from_send_start_ms=${Math.round(frameDispatchAt - preWsStartedAt)} wire_send_ms=${Math.round(performance.now() - frameDispatchAt)}`);
+                }
+                const ackPayload = (await admissionAck).payload;
+                traceSendTiming("admission_ack");
+                admissionAckObserved = true;
+                if (typeof ackPayload.preflight_id !== "string" || !ackPayload.preflight_id) {
+                  throw new Error("Encrypted chat admission acknowledgement omitted preflight_id.");
+                }
+                if (typeof ackPayload.committed_messages_v === "number" && Number.isSafeInteger(ackPayload.committed_messages_v)) {
+                  terminalExpectedMessagesV = ackPayload.committed_messages_v;
+                }
+                initialAdmissionDurable = true;
+                startInitialHeader();
+                if (!useCombinedAdmission) {
+                  Object.assign(messagePayload, { protocol_version: admissionPayload.protocol_version, preflight_id: ackPayload.preflight_id });
+                  await ws.sendAsync("chat_message_added", messagePayload);
+                }
+                if (pendingContext && contextRequestId) {
+                  admissionContinuationPhase = "await_routing";
+                  const identity3 = {
+                    chat_id: chatId,
+                    turn_id: savedTurnId,
+                    message_id: messageId2,
+                    request_id: contextRequestId,
+                    ...teamId ? { team_id: teamId } : {}
+                  };
+                  let failureNotice = null;
+                  const notifyContextFailure = (reason) => {
+                    if (failureNotice) return failureNotice;
+                    if (!ws.supportsServerCapability("chat_turn_context_failure_v1") || !ws.isOpen() || !contextOwnerIsCurrent() || !savedTurnId) return Promise.resolve();
+                    failureNotice = (async () => {
+                      const failureAck = ws.waitForMessage("chat_turn_context_failed_ack", (payload) => {
+                        const event = payload;
+                        return event.chat_id === chatId && event.turn_id === savedTurnId && event.message_id === messageId2 && event.request_id === contextRequestId;
+                      }, 5e3);
+                      void failureAck.catch(() => {
+                      });
+                      await ws.sendAsync("chat_turn_context_failed", { ...identity3, reason });
+                      const status = (await failureAck).payload;
+                      if (status.status !== "accepted" && status.status !== "duplicate") {
+                        throw new Error("Chat context failure receipt was rejected.");
+                      }
+                    })();
+                    return failureNotice;
+                  };
+                  let routing;
+                  try {
+                    routing = useSelectionDetailsV2 ? await projectRoutingContext : deferredProjectDirectory ? (await Promise.all([pendingContext, projectRoutingContext]))[0] : params.projectId ? await pendingContext : await Promise.race([routingContext, pendingContext]);
+                  } catch (error) {
+                    try {
+                      await notifyContextFailure(useSelectionDetailsV2 ? "project_discovery_failed" : "context_preparation_failed");
+                    } catch {
+                    }
+                    throw error;
                   }
-                  void notifyContextFailure("context_preparation_failed").catch(() => {
-                  }).then(() => {
-                    rejectContextAck(new Error("Chat context delivery was rejected."));
+                  if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
+                  let rejectContextAck;
+                  contextAckRejection = new Promise((_resolve, reject) => {
+                    rejectContextAck = reject;
                   });
-                });
-                const { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } = routing;
-                traceSendTiming("routing_prepared");
-                attemptedContextPhases.add("routing");
-                await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "routing", context: useSelectionDetailsV2 ? { project_focus_candidates } : { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } });
-                routingFrameSent = true;
-                traceSendTiming("routing_frame");
-                admissionContinuationPhase = "await_details";
-                let context;
-                try {
-                  context = await Promise.race([pendingContext, contextAckRejection]);
-                } catch (error) {
+                  void contextAckRejection.catch(() => {
+                  });
+                  let rejectedPhaseSeen = false;
+                  const attemptedContextPhases = /* @__PURE__ */ new Set();
+                  removeContextAckWatcher = ws.onMessageType("chat_turn_context_ack", (event) => {
+                    if (rejectedPhaseSeen || event.chat_id !== chatId || event.turn_id !== savedTurnId || event.message_id !== messageId2 || event.request_id !== contextRequestId || event.phase !== "routing" && event.phase !== "details" || !attemptedContextPhases.has(event.phase)) return;
+                    if (event.status === "accepted" || event.status === "duplicate") {
+                      traceSendTiming(event.phase === "routing" ? "routing_ack" : "details_ack");
+                      return;
+                    }
+                    if (event.status !== "rejected") return;
+                    rejectedPhaseSeen = true;
+                    if (!contextOwnerIsCurrent()) {
+                      rejectContextAck(new Error("Chat workspace changed while preparing context."));
+                      return;
+                    }
+                    void notifyContextFailure("context_preparation_failed").catch(() => {
+                    }).then(() => {
+                      rejectContextAck(new Error("Chat context delivery was rejected."));
+                    });
+                  });
+                  const { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } = routing;
+                  traceSendTiming("routing_prepared");
+                  attemptedContextPhases.add("routing");
+                  await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "routing", context: useSelectionDetailsV2 ? { project_focus_candidates } : { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } });
+                  routingFrameSent = true;
+                  traceSendTiming("routing_frame");
+                  admissionContinuationPhase = "await_details";
+                  let context;
                   try {
-                    await notifyContextFailure("context_preparation_failed");
-                  } catch {
+                    context = await Promise.race([pendingContext, contextAckRejection, catalogDeliveryFailure]);
+                  } catch (error) {
+                    try {
+                      await notifyContextFailure("context_preparation_failed");
+                    } catch {
+                    }
+                    throw error;
                   }
-                  throw error;
+                  if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
+                  traceSendTiming("details_prepared");
+                  attemptedContextPhases.add("details");
+                  await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "details", context: {
+                    custom_memory_documents: context.custom_memory_documents ?? [],
+                    project_focus_documents: context.project_focus_documents ?? [],
+                    project_context_documents: context.project_context_documents ?? [],
+                    ...useSelectionDetailsV2 ? {
+                      related_task_candidates: context.related_task_candidates ?? [],
+                      project_focus_catalog: context.project_focus_catalog ?? [],
+                      accepted_plan_context: context.accepted_plan_context ?? null,
+                      ...connectedAccountDirectory ? { connected_account_directory: connectedAccountDirectory } : {}
+                    } : {}
+                  } });
+                  detailsFrameSent = true;
+                  traceSendTiming("details_frame");
                 }
-                if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-                traceSendTiming("details_prepared");
-                attemptedContextPhases.add("details");
-                await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "details", context: {
-                  custom_memory_documents: context.custom_memory_documents ?? [],
-                  project_focus_documents: context.project_focus_documents ?? [],
-                  project_context_documents: context.project_context_documents ?? [],
-                  ...useSelectionDetailsV2 ? {
-                    related_task_candidates: context.related_task_candidates ?? [],
-                    project_focus_catalog: context.project_focus_catalog ?? [],
-                    accepted_plan_context: context.accepted_plan_context ?? null,
-                    ...connectedAccountDirectory ? { connected_account_directory: connectedAccountDirectory } : {}
-                  } : {}
-                } });
-                detailsFrameSent = true;
-                traceSendTiming("details_frame");
+                admissionContinuationPhase = "await_confirmation";
+              } else {
+                await consumeSocketMemoryReceipt();
+                await ws.sendAsync("chat_message_added", messagePayload);
               }
-              admissionContinuationPhase = "await_confirmation";
-            } else {
-              await consumeSocketMemoryReceipt();
-              await ws.sendAsync("chat_message_added", messagePayload);
-            }
-            confirmedPayload = (await (contextAckRejection ? Promise.race([confirmed, contextAckRejection]) : confirmed)).payload;
-          } catch (error) {
-            if (process.env.OPENMATES_DEBUG === "1" && admissionPayload) {
-              console.error(`[chat admission continuation] phase=${admissionContinuationPhase} ack_observed=${admissionAckObserved} routing_sent=${routingFrameSent} details_sent=${detailsFrameSent} socket_open=${ws.isOpen()} elapsed_ms=${Math.round(performance.now() - admissionContinuationStartedAt)}`);
+              confirmedPayload = (await Promise.race([confirmed, catalogDeliveryFailure, ...contextAckRejection ? [contextAckRejection] : []])).payload;
+            } catch (error) {
+              if (process.env.OPENMATES_DEBUG === "1" && admissionPayload) {
+                console.error(`[chat admission continuation] phase=${admissionContinuationPhase} ack_observed=${admissionAckObserved} routing_sent=${routingFrameSent} details_sent=${detailsFrameSent} socket_open=${ws.isOpen()} elapsed_ms=${Math.round(performance.now() - admissionContinuationStartedAt)}`);
+              }
+              dispatchHandlersReady();
+              void confirmed.catch(() => {
+              });
+              if (precollectedResponse) void precollectedResponse.catch(() => {
+              });
+              ws.close();
+              throw error;
             }
-            dispatchHandlersReady();
-            void confirmed.catch(() => {
-            });
-            if (precollectedResponse) void precollectedResponse.catch(() => {
-            });
-            ws.close();
-            throw error;
-          }
-          if (!params.incognito && typeof confirmedPayload.new_messages_v === "number" && Number.isSafeInteger(confirmedPayload.new_messages_v)) {
-            terminalExpectedMessagesV = confirmedPayload.new_messages_v;
-          }
-          if (!params.incognito && (!teamId || shouldWaitForAi)) {
-            clearSyncCache(teamId);
-          }
-          let assistant = "";
-          let assistantMessageId = null;
-          let category = null;
-          let modelName = null;
-          let tokenUsage = null;
-          let promptBudget = null;
-          let followUpSuggestions = [];
-          let suggestedFollowupMessage = null;
-          let taskProposals = [];
-          let taskUpdateProposals = [];
-          let taskEvents = [];
-          let pendingTaskUpdateJobs = [];
-          let subChatEvents = [];
-          const appSettingsMemoryRequests = [];
-          const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-          const isApprovalWithinServerLimits = (request) => {
-            const count = request.subChats.length;
-            if (count === 0) return false;
-            if (request.remainingSubChats !== null && count > request.remainingSubChats) {
-              return false;
+            if (!params.incognito && typeof confirmedPayload.new_messages_v === "number" && Number.isSafeInteger(confirmedPayload.new_messages_v)) {
+              terminalExpectedMessagesV = confirmedPayload.new_messages_v;
             }
-            if (request.maxDirectSubChats !== null && request.existingSubChats !== null && request.existingSubChats + count > request.maxDirectSubChats) {
-              return false;
+            if (!params.incognito && (!teamId || shouldWaitForAi)) {
+              clearSyncCache(teamId);
             }
-            return true;
-          };
-          const isAutoApprovalWithinServerLimits = (request) => {
-            if (!isApprovalWithinServerLimits(request)) return false;
-            return request.maxAutoSubChats === null || request.subChats.length <= request.maxAutoSubChats;
-          };
-          const handleSubChatEvent = async (event) => {
-            params.onSubChatEvent?.(event);
-            if (event.type === "spawn_sub_chats") {
-              if (params.incognito || !chatKeyBytes) return;
-              const rawSubChats = event.payload.sub_chats;
-              if (!Array.isArray(rawSubChats)) return;
-              const metadataPayloads = await buildSubChatEncryptedMetadataPayloads({
-                parentChatId: chatId,
-                parentChatKey: chatKeyBytes,
-                encryptedParentChatKey: encryptedChatKey,
-                subChats: rawSubChats
-              });
-              for (const metadataPayload of metadataPayloads) {
-                await ws.sendAsync("encrypted_chat_metadata", metadataPayload);
+            let assistant = "";
+            let assistantMessageId = null;
+            let category = null;
+            let modelName = null;
+            let tokenUsage = null;
+            let promptBudget = null;
+            let followUpSuggestions = [];
+            let suggestedFollowupMessage = null;
+            let taskProposals = [];
+            let taskUpdateProposals = [];
+            let taskEvents = [];
+            let pendingTaskUpdateJobs = [];
+            let subChatEvents = [];
+            const appSettingsMemoryRequests = [];
+            const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+            const isApprovalWithinServerLimits = (request) => {
+              const count = request.subChats.length;
+              if (count === 0) return false;
+              if (request.remainingSubChats !== null && count > request.remainingSubChats) {
+                return false;
               }
-              return;
-            }
-            if (event.type !== "sub_chat_confirmation_required") return;
-            const payload = event.payload;
-            const confirmationChatId = typeof payload.chat_id === "string" ? payload.chat_id : chatId;
-            const taskId = typeof payload.task_id === "string" ? payload.task_id : null;
-            const subChats = Array.isArray(payload.sub_chats) ? payload.sub_chats : [];
-            if (!taskId) return;
-            const request = {
-              chatId: confirmationChatId,
-              taskId,
-              subChats,
-              maxAutoSubChats: numberOrNull(payload.max_auto_sub_chats),
-              maxDirectSubChats: numberOrNull(payload.max_direct_sub_chats),
-              existingSubChats: numberOrNull(payload.existing_sub_chats),
-              remainingSubChats: numberOrNull(payload.remaining_sub_chats)
-            };
-            const withinLimits = isApprovalWithinServerLimits(request);
-            const approved = params.autoApproveSubChats ? isAutoApprovalWithinServerLimits(request) : withinLimits && params.onSubChatApprovalRequest ? await params.onSubChatApprovalRequest(request) : false;
-            await ws.sendAsync(
-              "sub_chat_confirmation",
-              buildSubChatConfirmationPayload({
-                chatId: request.chatId,
-                taskId: request.taskId,
-                approved,
-                approveCount: approved ? request.subChats.length : void 0
-              })
-            );
-          };
-          const persistSystemMessage = async (systemMessage) => {
-            if (!chatKeyBytes) return;
-            await ws.sendAsync("chat_system_message_added", {
-              chat_id: chatId,
-              message: {
-                message_id: systemMessage.message_id,
-                role: "system",
-                encrypted_content: await encryptWithAesGcmCombined(
-                  systemMessage.content,
-                  chatKeyBytes
-                ),
-                created_at: systemMessage.created_at,
-                user_message_id: systemMessage.user_message_id
+              if (request.maxDirectSubChats !== null && request.existingSubChats !== null && request.existingSubChats + count > request.maxDirectSubChats) {
+                return false;
               }
-            });
-            await ws.waitForMessage(
-              "system_message_confirmed",
-              (payload) => {
-                const p = payload;
-                return p.message_id === systemMessage.message_id;
-              },
-              2e4
-            );
-          };
-          const persistMemoryRequestSystemMessage = async (event) => {
-            const requestId = event.requestId ?? `${messageId2}-memory-request`;
-            await persistSystemMessage(buildAppSettingsMemoryRequestSystemMessage({
-              userMessageId: messageId2,
-              requestId,
-              requestedKeys: event.requestedKeys,
-              entryCounts: memoryCountsLoaded ? new Map(event.requestedKeys.map((key) => [key, availableMemories.filter((memory) => `${memory.app_id}-${memory.item_type}` === key).length])) : void 0,
-              createdAt: Math.floor(Date.now() / 1e3)
-            }));
-          };
-          const responseCategoriesFromMemories = (approvedMemories) => {
-            const counts = /* @__PURE__ */ new Map();
-            for (const memory of approvedMemories) {
-              const key = `${memory.app_id}-${memory.item_key}`;
-              const existing = counts.get(key);
-              if (existing) {
-                existing.entryCount += 1;
-              } else {
-                counts.set(key, {
-                  appId: memory.app_id,
-                  itemType: memory.item_key,
-                  entryCount: 1
+              return true;
+            };
+            const isAutoApprovalWithinServerLimits = (request) => {
+              if (!isApprovalWithinServerLimits(request)) return false;
+              return request.maxAutoSubChats === null || request.subChats.length <= request.maxAutoSubChats;
+            };
+            const handleSubChatEvent = async (event) => {
+              params.onSubChatEvent?.(event);
+              if (event.type === "spawn_sub_chats") {
+                if (params.incognito || !chatKeyBytes) return;
+                const rawSubChats = event.payload.sub_chats;
+                if (!Array.isArray(rawSubChats)) return;
+                const metadataPayloads = await buildSubChatEncryptedMetadataPayloads({
+                  parentChatId: chatId,
+                  parentChatKey: chatKeyBytes,
+                  encryptedParentChatKey: encryptedChatKey,
+                  subChats: rawSubChats
                 });
+                for (const metadataPayload of metadataPayloads) {
+                  await ws.sendAsync("encrypted_chat_metadata", metadataPayload);
+                }
+                return;
               }
-            }
-            return [...counts.values()];
-          };
-          const handleAppSettingsMemoriesRequest = async (event) => {
-            await persistMemoryRequestSystemMessage(event);
-            if (params.autoApproveMemories) {
-              const requested = new Set(event.requestedKeys);
-              const unadvertisedKeys = event.requestedKeys.filter(
-                (key) => !memoryMetadataKeys.includes(key)
+              if (event.type !== "sub_chat_confirmation_required") return;
+              const payload = event.payload;
+              const confirmationChatId = typeof payload.chat_id === "string" ? payload.chat_id : chatId;
+              const taskId = typeof payload.task_id === "string" ? payload.task_id : null;
+              const subChats = Array.isArray(payload.sub_chats) ? payload.sub_chats : [];
+              if (!taskId) return;
+              const request = {
+                chatId: confirmationChatId,
+                taskId,
+                subChats,
+                maxAutoSubChats: numberOrNull(payload.max_auto_sub_chats),
+                maxDirectSubChats: numberOrNull(payload.max_direct_sub_chats),
+                existingSubChats: numberOrNull(payload.existing_sub_chats),
+                remainingSubChats: numberOrNull(payload.remaining_sub_chats)
+              };
+              const withinLimits = isApprovalWithinServerLimits(request);
+              const approved = params.autoApproveSubChats ? isAutoApprovalWithinServerLimits(request) : withinLimits && params.onSubChatApprovalRequest ? await params.onSubChatApprovalRequest(request) : false;
+              await ws.sendAsync(
+                "sub_chat_confirmation",
+                buildSubChatConfirmationPayload({
+                  chatId: request.chatId,
+                  taskId: request.taskId,
+                  approved,
+                  approveCount: approved ? request.subChats.length : void 0
+                })
               );
-              if (unadvertisedKeys.length > 0) {
-                throw new Error(
-                  `Refusing to auto-approve unadvertised memory categories: ${unadvertisedKeys.join(", ")}`
-                );
-              }
-              const approvedMemories = availableMemories.filter((memory) => requested.has(`${memory.app_id}-${memory.item_type}`)).map((memory) => ({
-                app_id: memory.app_id,
-                item_key: memory.item_type,
-                content: memory.data
-              }));
-              const approvedKeys = [
-                ...new Set(approvedMemories.map((memory) => `${memory.app_id}-${memory.item_key}`))
-              ];
-              const categories = responseCategoriesFromMemories(approvedMemories);
-              appSettingsMemoryRequests.push({
-                requestId: event.requestId,
-                requestedKeys: event.requestedKeys,
-                approvedKeys,
-                entryCount: approvedMemories.length
-              });
-              await ws.sendAsync("app_settings_memories_confirmed", {
-                chat_id: event.chatId,
-                app_settings_memories: approvedMemories
+            };
+            const persistSystemMessage = async (systemMessage) => {
+              if (!chatKeyBytes) return;
+              await ws.sendAsync("chat_system_message_added", {
+                chat_id: chatId,
+                message: {
+                  message_id: systemMessage.message_id,
+                  role: "system",
+                  encrypted_content: await encryptWithAesGcmCombined(
+                    systemMessage.content,
+                    chatKeyBytes
+                  ),
+                  created_at: systemMessage.created_at,
+                  user_message_id: systemMessage.user_message_id
+                }
               });
-              await persistSystemMessage(buildAppSettingsMemoryResponseSystemMessage({
+              await ws.waitForMessage(
+                "system_message_confirmed",
+                (payload) => {
+                  const p = payload;
+                  return p.message_id === systemMessage.message_id;
+                },
+                2e4
+              );
+            };
+            const persistMemoryRequestSystemMessage = async (event) => {
+              const requestId = event.requestId ?? `${messageId2}-memory-request`;
+              await persistSystemMessage(buildAppSettingsMemoryRequestSystemMessage({
                 userMessageId: messageId2,
-                messageId: `${messageId2}-memory-response`,
-                action: "included",
-                categories,
+                requestId,
+                requestedKeys: event.requestedKeys,
+                entryCounts: memoryCountsLoaded ? new Map(event.requestedKeys.map((key) => [key, availableMemories.filter((memory) => `${memory.app_id}-${memory.item_type}` === key).length])) : void 0,
                 createdAt: Math.floor(Date.now() / 1e3)
               }));
-              return;
-            }
-            appSettingsMemoryRequests.push({
-              requestId: event.requestId,
-              requestedKeys: event.requestedKeys,
-              approvedKeys: [],
-              entryCount: 0
-            });
-            throw new Error(
-              `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 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 this.persistEncryptedSystemMessage(
-                ws,
-                await buildTaskEventSystemMessage({
-                  chatKey: chatKeyBytes,
-                  userMessageId: messageId2,
-                  event
-                }),
-                chatId
-              );
-              persistedTaskEventIds.add(event.event_id);
-            }
-          };
-          const streamOpts = {
-            waitForPostProcessing: false,
-            onStream: onTurnStream,
-            onSubChatEvent: handleSubChatEvent,
-            onAppSettingsMemoriesRequest: handleAppSettingsMemoriesRequest,
-            projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
-            remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
-          };
-          dispatchHandlersReady();
-          if (!shouldWaitForAi) {
-            ws.close();
-          } else if (params.incognito) {
-            try {
-              const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
-                ...streamOpts,
-                timeoutMs: params.responseTimeoutMs,
-                recoveryTurnId: savedTurnId
-              }));
-              assistantMessageId = resp.messageId;
-              assistant = resp.content;
-              category = resp.category;
-              modelName = resp.modelName;
-              tokenUsage = resp.tokenUsage;
-              promptBudget = resp.promptBudget;
-              taskEvents = resp.taskEvents;
-              pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
-              subChatEvents = resp.subChatEvents;
-              if (resp.status === "waiting_for_user") {
-                await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
-                return {
-                  status: resp.status,
-                  chatId,
-                  messageId: assistantMessageId,
-                  assistant,
-                  category,
-                  modelName,
-                  mateName: category ? MATE_NAMES[category] ?? null : null,
-                  followUpSuggestions,
-                  taskProposals,
-                  taskUpdateProposals,
-                  taskEvents,
-                  pendingTaskUpdateJobs,
-                  subChatEvents,
-                  appSettingsMemoryRequests,
-                  tokenUsage,
-                  promptBudget
-                };
-              }
-            } finally {
-              ws.close();
-            }
-          } else {
-            try {
-              const recoverCurrentTurnOutputs = async () => {
-                if (recoveryDiscovery) {
-                  try {
-                    await recoveryDiscovery;
-                  } catch (error) {
-                    if (!useDeferredContext) throw error;
-                    return;
-                  }
-                }
-                const pages = ws.drainAvailableRecoveryOutputPages();
-                if (pages.length === 0) return;
-                if (!ownerId2) throw new Error("Saved chat recovery output requires the owner identity.");
-                if (pages.some((page) => page.some((output) => output.root_chat_id === chatId || output.target_chat_id === chatId)) && (!chatKeyBytes || !encryptedChatKey)) {
-                  throw new Error("Saved chat recovery output requires the root chat key.");
+            };
+            const responseCategoriesFromMemories = (approvedMemories) => {
+              const counts = /* @__PURE__ */ new Map();
+              for (const memory of approvedMemories) {
+                const key = `${memory.app_id}-${memory.item_key}`;
+                const existing = counts.get(key);
+                if (existing) {
+                  existing.entryCount += 1;
+                } else {
+                  counts.set(key, {
+                    appId: memory.app_id,
+                    itemType: memory.item_key,
+                    entryCount: 1
+                  });
                 }
-                const cache = loadSyncCache(teamId) ?? {
-                  syncedAt: Date.now(),
-                  totalChatCount: 0,
-                  loadedChatCount: 0,
-                  chats: [],
-                  embeds: [],
-                  embedKeys: [],
-                  chatKeyWrappers: []
-                };
-                if (encryptedChatKey) {
-                  const root = cache.chats.find((chat) => String(chat.details.id ?? "") === chatId);
-                  if (root) root.details.encrypted_chat_key = encryptedChatKey;
-                  else cache.chats.push({ details: { id: chatId, encrypted_chat_key: encryptedChatKey }, messages: [] });
+              }
+              return [...counts.values()];
+            };
+            const handleAppSettingsMemoriesRequest = async (event) => {
+              await persistMemoryRequestSystemMessage(event);
+              if (params.autoApproveMemories) {
+                const requested = new Set(event.requestedKeys);
+                const unadvertisedKeys = event.requestedKeys.filter(
+                  (key) => !memoryMetadataKeys.includes(key)
+                );
+                if (unadvertisedKeys.length > 0) {
+                  throw new Error(
+                    `Refusing to auto-approve unadvertised memory categories: ${unadvertisedKeys.join(", ")}`
+                  );
                 }
-                await this.replayCurrentTurnRecoveryOutputPages(ws, ownerId2, pages, cache, teamId, chatId);
-              };
-              const responsePromise = precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
-                ...streamOpts,
-                timeoutMs: params.responseTimeoutMs,
-                recoveryTurnId: savedTurnId
-              });
-              const outcome = await Promise.race([
-                responsePromise.then((response) => ({ kind: "response", response })),
-                ...contextAckRejection ? [contextAckRejection] : [],
-                ...queuedAdmission ? [queuedAdmission.then(
-                  (frame) => ({ kind: "queued", frame }),
-                  () => new Promise(() => {
-                  })
-                )] : [],
-                ...pausedHandoff ? [pausedHandoff.then(
-                  (frame) => ({ kind: "paused", frame }),
-                  () => new Promise(() => {
-                  })
-                )] : []
-              ]);
-              if (outcome.kind === "paused") {
-                void responsePromise.catch(() => {
+                const approvedMemories = availableMemories.filter((memory) => requested.has(`${memory.app_id}-${memory.item_type}`)).map((memory) => ({
+                  app_id: memory.app_id,
+                  item_key: memory.item_type,
+                  content: memory.data
+                }));
+                const approvedKeys = [
+                  ...new Set(approvedMemories.map((memory) => `${memory.app_id}-${memory.item_key}`))
+                ];
+                const categories = responseCategoriesFromMemories(approvedMemories);
+                appSettingsMemoryRequests.push({
+                  requestId: event.requestId,
+                  requestedKeys: event.requestedKeys,
+                  approvedKeys,
+                  entryCount: approvedMemories.length
                 });
-                throw new Error("Message saved, but AI handoff is paused. No assistant run started; check the chat before retrying.");
-              }
-              if (outcome.kind === "queued") {
-                void responsePromise.catch(() => {
+                await ws.sendAsync("app_settings_memories_confirmed", {
+                  chat_id: event.chatId,
+                  app_settings_memories: approvedMemories
                 });
-                const frame = outcome.frame.payload;
-                return {
-                  status: "queued",
-                  chatId,
-                  messageId: null,
+                await persistSystemMessage(buildAppSettingsMemoryResponseSystemMessage({
                   userMessageId: messageId2,
-                  queueMode: frame.queue_mode === "steer" ? "steer" : "follow_up",
-                  queueRevision: typeof frame.queue_revision === "number" ? frame.queue_revision : 1,
-                  assistant: "",
-                  category: null,
-                  modelName: null,
-                  mateName: null,
-                  followUpSuggestions: [],
-                  taskProposals: [],
-                  taskUpdateProposals: [],
-                  taskEvents: [],
-                  pendingTaskUpdateJobs: [],
-                  subChatEvents: [],
-                  appSettingsMemoryRequests: [],
-                  tokenUsage: null,
-                  promptBudget: null
-                };
+                  messageId: `${messageId2}-memory-response`,
+                  action: "included",
+                  categories,
+                  createdAt: Math.floor(Date.now() / 1e3)
+                }));
+                return;
               }
-              const resp = outcome.response;
-              assistantMessageId = resp.messageId;
-              assistant = resp.content;
-              category = resp.category;
-              modelName = resp.modelName;
-              tokenUsage = resp.tokenUsage;
-              promptBudget = resp.promptBudget;
-              followUpSuggestions = resp.followUpSuggestions;
-              suggestedFollowupMessage = resp.suggestedFollowupMessage;
-              taskProposals = resp.taskProposals;
-              taskUpdateProposals = resp.taskUpdateProposals;
-              taskEvents = resp.taskEvents;
-              pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
-              subChatEvents = resp.subChatEvents;
-              if (resp.status === "waiting_for_user") {
-                await persistTaskEventSystemMessages(taskEvents);
-                await recoverCurrentTurnOutputs();
-                return {
-                  status: resp.status,
-                  chatId,
-                  messageId: assistantMessageId,
-                  assistant,
-                  category,
-                  modelName,
-                  mateName: category ? MATE_NAMES[category] ?? null : null,
-                  followUpSuggestions,
-                  taskProposals,
-                  taskUpdateProposals,
-                  taskEvents,
-                  pendingTaskUpdateJobs,
-                  subChatEvents,
-                  appSettingsMemoryRequests,
-                  tokenUsage,
-                  promptBudget
-                };
+              appSettingsMemoryRequests.push({
+                requestId: event.requestId,
+                requestedKeys: event.requestedKeys,
+                approvedKeys: [],
+                entryCount: 0
+              });
+              throw new Error(
+                `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 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 this.persistEncryptedSystemMessage(
+                  ws,
+                  await buildTaskEventSystemMessage({
+                    chatKey: chatKeyBytes,
+                    userMessageId: messageId2,
+                    event
+                  }),
+                  chatId
+                );
+                persistedTaskEventIds.add(event.event_id);
               }
-              if (chatKeyBytes) {
-                if (!resp.recoveryJobId || !savedTurnId || !ownerId2) {
-                  throw new Error("Saved chat completion did not include recoverable terminal identity.");
+            };
+            const streamOpts = {
+              waitForPostProcessing: false,
+              onStream: onTurnStream,
+              onSubChatEvent: handleSubChatEvent,
+              onAppSettingsMemoriesRequest: handleAppSettingsMemoriesRequest,
+              projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
+              remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
+            };
+            dispatchHandlersReady();
+            if (!shouldWaitForAi) {
+              ws.close();
+            } else if (params.incognito) {
+              try {
+                const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
+                  ...streamOpts,
+                  timeoutMs: params.responseTimeoutMs,
+                  recoveryTurnId: savedTurnId
+                }));
+                assistantMessageId = resp.messageId;
+                assistant = resp.content;
+                category = resp.category;
+                modelName = resp.modelName;
+                tokenUsage = resp.tokenUsage;
+                promptBudget = resp.promptBudget;
+                taskEvents = resp.taskEvents;
+                pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
+                subChatEvents = resp.subChatEvents;
+                if (resp.status === "waiting_for_user") {
+                  await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                  return {
+                    status: resp.status,
+                    chatId,
+                    messageId: assistantMessageId,
+                    assistant,
+                    category,
+                    modelName,
+                    mateName: category ? MATE_NAMES[category] ?? null : null,
+                    followUpSuggestions,
+                    taskProposals,
+                    taskUpdateProposals,
+                    taskEvents,
+                    pendingTaskUpdateJobs,
+                    subChatEvents,
+                    appSettingsMemoryRequests,
+                    tokenUsage,
+                    promptBudget
+                  };
                 }
-                const recoveryJobId = resp.recoveryJobId;
-                let claimRetryDeadline = null;
-                let claim;
-                let claimRetryDelayMs = 500;
-                while (true) {
-                  const requestId = randomUUID9();
-                  let matchingLeaseConflict = false;
-                  const stopWatchingErrors = ws.onMessageType("error", (payload) => {
-                    if (payload?.code === "lease_conflict" && payload.job_id === recoveryJobId && payload.request_id === requestId) {
-                      matchingLeaseConflict = true;
-                    }
-                  });
-                  const claimPromise = ws.waitForMessage(
-                    "recovery_job_claimed",
-                    (payload) => {
-                      const received = payload;
-                      return received.job_id === recoveryJobId && (received.request_id === void 0 || received.request_id === requestId);
-                    },
-                    claimRetryDeadline === null ? 2e4 : Math.min(2e4, Math.max(1, claimRetryDeadline - Date.now()))
-                  );
-                  try {
+              } finally {
+                ws.close();
+              }
+            } else {
+              try {
+                const recoverCurrentTurnOutputs = async () => {
+                  if (recoveryDiscovery) {
                     try {
-                      await ws.sendAsync("recovery_job_claim", {
-                        protocol_version: 1,
-                        job_id: recoveryJobId,
-                        request_id: requestId
-                      });
+                      await recoveryDiscovery;
                     } catch (error) {
-                      void claimPromise.catch(() => {
-                      });
-                      throw error;
+                      if (!useDeferredContext) throw error;
+                      return;
                     }
-                    claim = (await claimPromise).payload;
-                    break;
-                  } catch (error) {
-                    if (!(error instanceof WebSocketProtocolError) || error.code !== "lease_conflict" || !matchingLeaseConflict) throw error;
-                    claimRetryDeadline ??= Date.now() + Math.min(
-                      1e4,
-                      Math.max(0, params.responseTimeoutMs ?? 9e4)
-                    );
-                    const remainingMs = claimRetryDeadline - Date.now();
-                    if (remainingMs <= claimRetryDelayMs) throw error;
-                    await new Promise((resolve20) => setTimeout(resolve20, claimRetryDelayMs));
-                    claimRetryDelayMs = Math.min(claimRetryDelayMs * 2, 2e3);
-                  } finally {
-                    stopWatchingErrors();
                   }
+                  const pages = ws.drainAvailableRecoveryOutputPages();
+                  if (pages.length === 0) return;
+                  if (!ownerId2) throw new Error("Saved chat recovery output requires the owner identity.");
+                  if (pages.some((page) => page.some((output) => output.root_chat_id === chatId || output.target_chat_id === chatId)) && (!chatKeyBytes || !encryptedChatKey)) {
+                    throw new Error("Saved chat recovery output requires the root chat key.");
+                  }
+                  const cache = loadSyncCache(teamId) ?? {
+                    syncedAt: Date.now(),
+                    totalChatCount: 0,
+                    loadedChatCount: 0,
+                    chats: [],
+                    embeds: [],
+                    embedKeys: [],
+                    chatKeyWrappers: []
+                  };
+                  if (encryptedChatKey) {
+                    const root = cache.chats.find((chat) => String(chat.details.id ?? "") === chatId);
+                    if (root) root.details.encrypted_chat_key = encryptedChatKey;
+                    else cache.chats.push({ details: { id: chatId, encrypted_chat_key: encryptedChatKey }, messages: [] });
+                  }
+                  await this.replayCurrentTurnRecoveryOutputPages(ws, ownerId2, pages, cache, teamId, chatId);
+                };
+                const responsePromise = precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
+                  ...streamOpts,
+                  timeoutMs: params.responseTimeoutMs,
+                  recoveryTurnId: savedTurnId
+                });
+                const outcome = await Promise.race([
+                  responsePromise.then((response) => ({ kind: "response", response })),
+                  ...contextAckRejection ? [contextAckRejection] : [],
+                  catalogDeliveryFailure,
+                  ...queuedAdmission ? [queuedAdmission.then(
+                    (frame) => ({ kind: "queued", frame }),
+                    () => new Promise(() => {
+                    })
+                  )] : [],
+                  ...pausedHandoff ? [pausedHandoff.then(
+                    (frame) => ({ kind: "paused", frame }),
+                    () => new Promise(() => {
+                    })
+                  )] : []
+                ]);
+                if (outcome.kind === "paused") {
+                  void responsePromise.catch(() => {
+                  });
+                  throw new Error("Message saved, but AI handoff is paused. No assistant run started; check the chat before retrying.");
                 }
-                const leaseToken = typeof claim.lease_token === "string" ? claim.lease_token : null;
-                const leaseGeneration = typeof claim.lease_generation === "number" && Number.isSafeInteger(claim.lease_generation) ? claim.lease_generation : null;
-                const assistantId = typeof claim.assistant_message_id === "string" ? claim.assistant_message_id : null;
-                const keyVersion = typeof claim.chat_key_version === "number" && Number.isSafeInteger(claim.chat_key_version) ? claim.chat_key_version : null;
-                const claimMatchesExpectedTerminal = assistantId && keyVersion === 1 && claim.chat_id === chatId && claim.turn_id === savedTurnId;
-                if (claim.state === "TERMINAL" && claimMatchesExpectedTerminal) {
-                  assistant = resp.content;
-                  category = resp.category;
-                  modelName = resp.modelName;
-                  assistantMessageId = assistantId;
-                  await this.persistStreamedEmbeds({
-                    ws,
-                    embeds: resp.embeds,
-                    chatId,
-                    chatKeyBytes,
-                    fallbackMessageId: assistantId,
-                    ownerId: ownerId2,
-                    teamId
+                if (outcome.kind === "queued") {
+                  void responsePromise.catch(() => {
                   });
-                  clearSyncCache(teamId);
-                  await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                  const frame = outcome.frame.payload;
+                  return {
+                    status: "queued",
+                    chatId,
+                    messageId: null,
+                    userMessageId: messageId2,
+                    queueMode: frame.queue_mode === "steer" ? "steer" : "follow_up",
+                    queueRevision: typeof frame.queue_revision === "number" ? frame.queue_revision : 1,
+                    assistant: "",
+                    category: null,
+                    modelName: null,
+                    mateName: null,
+                    followUpSuggestions: [],
+                    taskProposals: [],
+                    taskUpdateProposals: [],
+                    taskEvents: [],
+                    pendingTaskUpdateJobs: [],
+                    subChatEvents: [],
+                    appSettingsMemoryRequests: [],
+                    tokenUsage: null,
+                    promptBudget: null
+                  };
+                }
+                const resp = outcome.response;
+                assistantMessageId = resp.messageId;
+                assistant = resp.content;
+                category = resp.category;
+                modelName = resp.modelName;
+                tokenUsage = resp.tokenUsage;
+                promptBudget = resp.promptBudget;
+                followUpSuggestions = resp.followUpSuggestions;
+                suggestedFollowupMessage = resp.suggestedFollowupMessage;
+                taskProposals = resp.taskProposals;
+                taskUpdateProposals = resp.taskUpdateProposals;
+                taskEvents = resp.taskEvents;
+                pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
+                subChatEvents = resp.subChatEvents;
+                if (resp.status === "waiting_for_user") {
                   await persistTaskEventSystemMessages(taskEvents);
                   await recoverCurrentTurnOutputs();
-                  await projectFocusCountdown?.flush();
-                  await focusPersistence;
-                  await chatContextEvents?.flush();
-                  if (focusPersistenceError) throw focusPersistenceError;
-                  const mateName2 = category ? MATE_NAMES[category] ?? null : null;
                   return {
-                    status: "completed",
+                    status: resp.status,
                     chatId,
                     messageId: assistantMessageId,
                     assistant,
                     category,
                     modelName,
-                    mateName: mateName2,
+                    mateName: category ? MATE_NAMES[category] ?? null : null,
                     followUpSuggestions,
                     taskProposals,
                     taskUpdateProposals,
@@ -17977,234 +18106,339 @@ var OpenMatesClient = class _OpenMatesClient {
                     promptBudget
                   };
                 }
-                if (claim.state !== "LEASED" || !leaseToken || leaseGeneration === null || leaseGeneration < 1 || !assistantId || keyVersion === null || keyVersion !== 1 || claim.chat_id !== chatId || claim.turn_id !== savedTurnId || typeof claim.sealed_payload !== "string") {
-                  throw new Error("Recovery job claim returned invalid lease or identity data.");
-                }
-                const recoveryKeypair = await deriveChatCompletionRecoveryKeypair(
-                  Buffer.from(chatKeyBytes).toString("base64url"),
-                  chatId,
-                  keyVersion
-                );
-                let envelope;
-                try {
-                  envelope = JSON.parse(claim.sealed_payload);
-                } catch {
-                  throw new Error("Recovery job contained an invalid sealed envelope.");
-                }
-                const plaintext = await openChatCompletionRecoveryEnvelope(
-                  envelope,
-                  {
-                    recoveryPrivateKey: recoveryKeypair.privateKey,
-                    ownerId: ownerId2,
+                if (chatKeyBytes) {
+                  if (!resp.recoveryJobId || !savedTurnId || !ownerId2) {
+                    throw new Error("Saved chat completion did not include recoverable terminal identity.");
+                  }
+                  const recoveryJobId = resp.recoveryJobId;
+                  let claimRetryDeadline = null;
+                  let claim;
+                  let claimRetryDelayMs = 500;
+                  while (true) {
+                    const requestId = randomUUID9();
+                    let matchingLeaseConflict = false;
+                    const stopWatchingErrors = ws.onMessageType("error", (payload) => {
+                      if (payload?.code === "lease_conflict" && payload.job_id === recoveryJobId && payload.request_id === requestId) {
+                        matchingLeaseConflict = true;
+                      }
+                    });
+                    const claimPromise = ws.waitForMessage(
+                      "recovery_job_claimed",
+                      (payload) => {
+                        const received = payload;
+                        return received.job_id === recoveryJobId && (received.request_id === void 0 || received.request_id === requestId);
+                      },
+                      claimRetryDeadline === null ? 2e4 : Math.min(2e4, Math.max(1, claimRetryDeadline - Date.now()))
+                    );
+                    try {
+                      try {
+                        await ws.sendAsync("recovery_job_claim", {
+                          protocol_version: 1,
+                          job_id: recoveryJobId,
+                          request_id: requestId
+                        });
+                      } catch (error) {
+                        void claimPromise.catch(() => {
+                        });
+                        throw error;
+                      }
+                      claim = (await claimPromise).payload;
+                      break;
+                    } catch (error) {
+                      if (!(error instanceof WebSocketProtocolError) || error.code !== "lease_conflict" || !matchingLeaseConflict) throw error;
+                      claimRetryDeadline ??= Date.now() + Math.min(
+                        1e4,
+                        Math.max(0, params.responseTimeoutMs ?? 9e4)
+                      );
+                      const remainingMs = claimRetryDeadline - Date.now();
+                      if (remainingMs <= claimRetryDelayMs) throw error;
+                      await new Promise((resolve20) => setTimeout(resolve20, claimRetryDelayMs));
+                      claimRetryDelayMs = Math.min(claimRetryDelayMs * 2, 2e3);
+                    } finally {
+                      stopWatchingErrors();
+                    }
+                  }
+                  const leaseToken = typeof claim.lease_token === "string" ? claim.lease_token : null;
+                  const leaseGeneration = typeof claim.lease_generation === "number" && Number.isSafeInteger(claim.lease_generation) ? claim.lease_generation : null;
+                  const assistantId = typeof claim.assistant_message_id === "string" ? claim.assistant_message_id : null;
+                  const keyVersion = typeof claim.chat_key_version === "number" && Number.isSafeInteger(claim.chat_key_version) ? claim.chat_key_version : null;
+                  const claimMatchesExpectedTerminal = assistantId && keyVersion === 1 && claim.chat_id === chatId && claim.turn_id === savedTurnId;
+                  if (claim.state === "TERMINAL" && claimMatchesExpectedTerminal) {
+                    assistant = resp.content;
+                    category = resp.category;
+                    modelName = resp.modelName;
+                    assistantMessageId = assistantId;
+                    await this.persistStreamedEmbeds({
+                      ws,
+                      embeds: resp.embeds,
+                      chatId,
+                      chatKeyBytes,
+                      fallbackMessageId: assistantId,
+                      ownerId: ownerId2,
+                      teamId
+                    });
+                    clearSyncCache(teamId);
+                    await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                    await persistTaskEventSystemMessages(taskEvents);
+                    await recoverCurrentTurnOutputs();
+                    await projectFocusCountdown?.flush();
+                    await focusPersistence;
+                    await chatContextEvents?.flush();
+                    if (focusPersistenceError) throw focusPersistenceError;
+                    const mateName2 = category ? MATE_NAMES[category] ?? null : null;
+                    return {
+                      status: "completed",
+                      chatId,
+                      messageId: assistantMessageId,
+                      assistant,
+                      category,
+                      modelName,
+                      mateName: mateName2,
+                      followUpSuggestions,
+                      taskProposals,
+                      taskUpdateProposals,
+                      taskEvents,
+                      pendingTaskUpdateJobs,
+                      subChatEvents,
+                      appSettingsMemoryRequests,
+                      tokenUsage,
+                      promptBudget
+                    };
+                  }
+                  if (claim.state !== "LEASED" || !leaseToken || leaseGeneration === null || leaseGeneration < 1 || !assistantId || keyVersion === null || keyVersion !== 1 || claim.chat_id !== chatId || claim.turn_id !== savedTurnId || typeof claim.sealed_payload !== "string") {
+                    throw new Error("Recovery job claim returned invalid lease or identity data.");
+                  }
+                  const recoveryKeypair = await deriveChatCompletionRecoveryKeypair(
+                    Buffer.from(chatKeyBytes).toString("base64url"),
                     chatId,
-                    turnId: savedTurnId,
-                    jobId: recoveryJobId,
-                    assistantMessageId: assistantId,
                     keyVersion
+                  );
+                  let envelope;
+                  try {
+                    envelope = JSON.parse(claim.sealed_payload);
+                  } catch {
+                    throw new Error("Recovery job contained an invalid sealed envelope.");
                   }
-                );
-                let recovered;
-                try {
-                  recovered = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(plaintext));
-                } catch {
-                  throw new Error("Recovery job plaintext was not valid UTF-8 JSON.");
-                }
-                const expectedRecoveryFields = [
-                  "assistant_message_id",
-                  "category",
-                  "chat_id",
-                  "content",
-                  "job_id",
-                  "key_version",
-                  "model_name",
-                  "turn_id"
-                ];
-                if (Object.keys(recovered).filter((field3) => ![
-                  "thinking_content",
-                  "thinking_signature",
-                  "has_thinking",
-                  "thinking_token_count",
-                  "thinking_duration_seconds"
-                ].includes(field3)).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 = resp.recoveryCreatedAt ?? Math.floor(Date.now() / 1e3);
-                const encryptedAssistantContent = await encryptWithAesGcmCombined(
-                  assistant,
-                  chatKeyBytes
-                );
-                const encryptedSenderName = await encryptWithAesGcmCombined(category ? MATE_NAMES[category] ?? "Assistant" : "Assistant", chatKeyBytes);
-                const encryptedCategory = recovered.category ? await encryptWithAesGcmCombined(recovered.category, chatKeyBytes) : void 0;
-                const encryptedModelName = recovered.model_name ? await encryptWithAesGcmCombined(recovered.model_name, chatKeyBytes) : void 0;
-                const terminalPersistPayload = {
-                  protocol_version: 1,
-                  job_id: recoveryJobId,
-                  lease_token: leaseToken,
-                  lease_generation: leaseGeneration,
-                  encrypted_assistant_message: {
-                    client_message_id: assistantId,
-                    chat_id: chatId,
-                    encrypted_content: encryptedAssistantContent,
-                    ...await this.encryptThinkingFields(recovered, chatKeyBytes),
-                    encrypted_sender_name: encryptedSenderName,
-                    encrypted_category: encryptedCategory,
-                    encrypted_model_name: encryptedModelName,
-                    role: "assistant",
-                    user_message_id: messageId2,
-                    created_at: completedAt,
-                    updated_at: completedAt
+                  const plaintext = await openChatCompletionRecoveryEnvelope(
+                    envelope,
+                    {
+                      recoveryPrivateKey: recoveryKeypair.privateKey,
+                      ownerId: ownerId2,
+                      chatId,
+                      turnId: savedTurnId,
+                      jobId: recoveryJobId,
+                      assistantMessageId: assistantId,
+                      keyVersion
+                    }
+                  );
+                  let recovered;
+                  try {
+                    recovered = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(plaintext));
+                  } catch {
+                    throw new Error("Recovery job plaintext was not valid UTF-8 JSON.");
                   }
-                };
-                const persistTerminalRecovery = async (expectedMessagesV) => {
-                  const persistedPromise = ws.waitForMessage(
-                    "recovery_job_persisted",
-                    (payload) => payload.job_id === recoveryJobId,
-                    2e4
+                  const expectedRecoveryFields = [
+                    "assistant_message_id",
+                    "category",
+                    "chat_id",
+                    "content",
+                    "job_id",
+                    "key_version",
+                    "model_name",
+                    "turn_id"
+                  ];
+                  if (Object.keys(recovered).filter((field3) => ![
+                    "thinking_content",
+                    "thinking_signature",
+                    "has_thinking",
+                    "thinking_token_count",
+                    "thinking_duration_seconds"
+                  ].includes(field3)).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 = resp.recoveryCreatedAt ?? Math.floor(Date.now() / 1e3);
+                  const encryptedAssistantContent = await encryptWithAesGcmCombined(
+                    assistant,
+                    chatKeyBytes
                   );
-                  await ws.sendAsync("recovery_job_persist", {
-                    ...terminalPersistPayload,
-                    expected_messages_v: expectedMessagesV
-                  });
-                  await persistedPromise;
-                };
-                let terminalPersisted = false;
-                try {
-                  await persistTerminalRecovery(terminalExpectedMessagesV);
-                  terminalPersisted = true;
-                } catch (error) {
-                  if (error instanceof WebSocketProtocolError) {
-                    if (error.code === "version_conflict") {
-                      const latestCache = await this.ensureSynced(
-                        true,
-                        [chatId],
-                        { teamId },
-                        false,
-                        void 0,
-                        void 0,
-                        { skipTypedRecoveryOutputReplay: true }
-                      );
-                      const latestChat = latestCache.chats.find(
-                        (chat) => String(chat.details.id ?? "") === chatId
-                      );
-                      const latestMessagesV = typeof latestChat?.details.messages_v === "number" && Number.isSafeInteger(latestChat.details.messages_v) ? latestChat.details.messages_v : null;
-                      if (latestMessagesV !== null && latestMessagesV > terminalExpectedMessagesV) {
-                        await persistTerminalRecovery(latestMessagesV);
-                        terminalExpectedMessagesV = latestMessagesV;
-                        terminalPersisted = true;
-                      }
+                  const encryptedSenderName = await encryptWithAesGcmCombined(category ? MATE_NAMES[category] ?? "Assistant" : "Assistant", chatKeyBytes);
+                  const encryptedCategory = recovered.category ? await encryptWithAesGcmCombined(recovered.category, chatKeyBytes) : void 0;
+                  const encryptedModelName = recovered.model_name ? await encryptWithAesGcmCombined(recovered.model_name, chatKeyBytes) : void 0;
+                  const terminalPersistPayload = {
+                    protocol_version: 1,
+                    job_id: recoveryJobId,
+                    lease_token: leaseToken,
+                    lease_generation: leaseGeneration,
+                    encrypted_assistant_message: {
+                      client_message_id: assistantId,
+                      chat_id: chatId,
+                      encrypted_content: encryptedAssistantContent,
+                      ...await this.encryptThinkingFields(recovered, chatKeyBytes),
+                      encrypted_sender_name: encryptedSenderName,
+                      encrypted_category: encryptedCategory,
+                      encrypted_model_name: encryptedModelName,
+                      role: "assistant",
+                      user_message_id: messageId2,
+                      created_at: completedAt,
+                      updated_at: completedAt
                     }
-                    if (!terminalPersisted) {
-                      throw new Error(`${error.message} (${error.code})`);
+                  };
+                  const persistTerminalRecovery = async (expectedMessagesV) => {
+                    const persistedPromise = ws.waitForMessage(
+                      "recovery_job_persisted",
+                      (payload) => payload.job_id === recoveryJobId,
+                      2e4
+                    );
+                    await ws.sendAsync("recovery_job_persist", {
+                      ...terminalPersistPayload,
+                      expected_messages_v: expectedMessagesV
+                    });
+                    await persistedPromise;
+                  };
+                  let terminalPersisted = false;
+                  try {
+                    await persistTerminalRecovery(terminalExpectedMessagesV);
+                    terminalPersisted = true;
+                  } catch (error) {
+                    if (error instanceof WebSocketProtocolError) {
+                      if (error.code === "version_conflict") {
+                        const latestCache = await this.ensureSynced(
+                          true,
+                          [chatId],
+                          { teamId },
+                          false,
+                          void 0,
+                          void 0,
+                          { skipTypedRecoveryOutputReplay: true }
+                        );
+                        const latestChat = latestCache.chats.find(
+                          (chat) => String(chat.details.id ?? "") === chatId
+                        );
+                        const latestMessagesV = typeof latestChat?.details.messages_v === "number" && Number.isSafeInteger(latestChat.details.messages_v) ? latestChat.details.messages_v : null;
+                        if (latestMessagesV !== null && latestMessagesV > terminalExpectedMessagesV) {
+                          await persistTerminalRecovery(latestMessagesV);
+                          terminalExpectedMessagesV = latestMessagesV;
+                          terminalPersisted = true;
+                        }
+                      }
+                      if (!terminalPersisted) {
+                        throw new Error(`${error.message} (${error.code})`);
+                      }
+                    } else {
+                      throw error;
                     }
-                  } else {
-                    throw error;
                   }
-                }
-                if (!terminalPersisted) {
-                  throw new Error("Encrypted completion recovery did not persist terminal state.");
-                }
-                assistantMessageId = assistantId;
-                await this.persistStreamedEmbeds({
-                  ws,
-                  embeds: resp.embeds,
-                  chatId,
-                  chatKeyBytes,
-                  fallbackMessageId: assistantId,
-                  ownerId: ownerId2,
-                  teamId
-                });
-                if (initialHeaderWork) persistOptionalHeader = () => initialHeaderWork;
-                await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
-                if (taskUpdateJobsEnabled) {
-                  const persistedTaskJobIds = await this.persistPendingTaskUpdateJobs({
+                  if (!terminalPersisted) {
+                    throw new Error("Encrypted completion recovery did not persist terminal state.");
+                  }
+                  assistantMessageId = assistantId;
+                  await this.persistStreamedEmbeds({
                     ws,
-                    jobs: pendingTaskUpdateJobs,
-                    events: taskEvents,
-                    teamId,
-                    activeChatId: chatId,
-                    activeChatKeyBytes: chatKeyBytes,
-                    fallbackUserMessageId: messageId2,
-                    requireActiveTurnEvent: true
+                    embeds: resp.embeds,
+                    chatId,
+                    chatKeyBytes,
+                    fallbackMessageId: assistantId,
+                    ownerId: ownerId2,
+                    teamId
                   });
-                  pendingTaskUpdateJobs = pendingTaskUpdateJobs.filter((job) => !persistedTaskJobIds.has(job.job_id));
-                }
-                await persistTaskEventSystemMessages(taskEvents);
-                await recoverCurrentTurnOutputs();
-                clearSyncCache(teamId);
-                if (optionalMetadata) {
-                  metadataHandoffReady = true;
-                  metadataHandoffSuggestion = resp.suggestedFollowupMessage;
-                }
-              }
-            } finally {
-              try {
-                await projectFocusCountdown?.flush();
-                await focusPersistence;
-                if (projectAuthoringAvailable && assistant && chatContextEvents) {
-                  try {
-                    const history = boundedAuthoringHistory([
-                      ...messageHistoryForRequest ?? [],
-                      { role: "user", content: finalMessage },
-                      { role: "assistant", content: assistant }
-                    ]);
-                    const recommendations = await assessCliProjectAuthoring(this, projectAuthoringAvailable, history);
-                    for (const event of recommendations) chatContextEvents.persist(event);
-                  } catch {
+                  if (initialHeaderWork) persistOptionalHeader = () => initialHeaderWork;
+                  await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                  if (taskUpdateJobsEnabled) {
+                    const persistedTaskJobIds = await this.persistPendingTaskUpdateJobs({
+                      ws,
+                      jobs: pendingTaskUpdateJobs,
+                      events: taskEvents,
+                      teamId,
+                      activeChatId: chatId,
+                      activeChatKeyBytes: chatKeyBytes,
+                      fallbackUserMessageId: messageId2,
+                      requireActiveTurnEvent: true
+                    });
+                    pendingTaskUpdateJobs = pendingTaskUpdateJobs.filter((job) => !persistedTaskJobIds.has(job.job_id));
+                  }
+                  await persistTaskEventSystemMessages(taskEvents);
+                  await recoverCurrentTurnOutputs();
+                  clearSyncCache(teamId);
+                  if (optionalMetadata) {
+                    metadataHandoffReady = true;
+                    metadataHandoffSuggestion = resp.suggestedFollowupMessage;
                   }
                 }
-                await chatContextEvents?.flush();
               } finally {
-                projectFocusCountdown?.();
-                chatContextEvents?.stop();
-                if (!metadataHandoffReady) ws.close();
+                try {
+                  await projectFocusCountdown?.flush();
+                  await focusPersistence;
+                  if (projectAuthoringAvailable && assistant && chatContextEvents) {
+                    try {
+                      const history = boundedAuthoringHistory([
+                        ...messageHistoryForRequest ?? [],
+                        { role: "user", content: finalMessage },
+                        { role: "assistant", content: assistant }
+                      ]);
+                      const recommendations = await assessCliProjectAuthoring(this, projectAuthoringAvailable, history);
+                      for (const event of recommendations) chatContextEvents.persist(event);
+                    } catch {
+                    }
+                  }
+                  await chatContextEvents?.flush();
+                } finally {
+                  projectFocusCountdown?.();
+                  chatContextEvents?.stop();
+                  if (!metadataHandoffReady) ws.close();
+                }
+              }
+              if (focusPersistenceError) throw focusPersistenceError;
+              if (metadataHandoffReady && optionalMetadata) {
+                metadataTransportOwned = optionalMetadata.handOff(metadataHandoffSuggestion, persistOptionalHeader);
+                if (!metadataTransportOwned) ws.close();
               }
             }
-            if (focusPersistenceError) throw focusPersistenceError;
-            if (metadataHandoffReady && optionalMetadata) {
-              metadataTransportOwned = optionalMetadata.handOff(metadataHandoffSuggestion, persistOptionalHeader);
-              if (!metadataTransportOwned) ws.close();
+            const mateName = category ? MATE_NAMES[category] ?? null : null;
+            if (params.interactiveHuman && shouldWaitForAi && !params.incognito) this.rearmSendSocketWhenClosed(ws, teamId);
+            return {
+              status: "completed",
+              chatId,
+              messageId: assistantMessageId,
+              userMessageId: messageId2,
+              assistant,
+              category,
+              modelName,
+              mateName,
+              followUpSuggestions,
+              suggestedFollowupMessage,
+              taskProposals,
+              taskUpdateProposals,
+              taskEvents,
+              pendingTaskUpdateJobs,
+              subChatEvents,
+              appSettingsMemoryRequests,
+              tokenUsage,
+              promptBudget
+            };
+          } finally {
+            stopProjectCatalogResponder();
+            removeContextAckWatcher?.();
+            earlyContextAbort.abort();
+            if (!metadataTransportOwned) {
+              initialHeaderStopped = true;
+              optionalMetadata?.stop();
+              ws.close();
             }
+            if (earlyContext) await earlyContext;
           }
-          const mateName = category ? MATE_NAMES[category] ?? null : null;
-          return {
-            status: "completed",
-            chatId,
-            messageId: assistantMessageId,
-            userMessageId: messageId2,
-            assistant,
-            category,
-            modelName,
-            mateName,
-            followUpSuggestions,
-            suggestedFollowupMessage,
-            taskProposals,
-            taskUpdateProposals,
-            taskEvents,
-            pendingTaskUpdateJobs,
-            subChatEvents,
-            appSettingsMemoryRequests,
-            tokenUsage,
-            promptBudget
-          };
-        } finally {
-          removeContextAckWatcher?.();
-          earlyContextAbort.abort();
-          if (!metadataTransportOwned) {
-            initialHeaderStopped = true;
-            optionalMetadata?.stop();
-            ws.close();
-          }
-          if (earlyContext) await earlyContext;
+        } catch (error) {
+          memorySocket?.ws.close();
+          throw error;
         }
-      } catch (error) {
-        memorySocket?.ws.close();
-        throw error;
+      } finally {
+        historyAbort.abort();
       }
     } finally {
-      historyAbort.abort();
+      this.foregroundSendCount--;
+      this.maybeRearmSendSocket();
     }
   }
   async persistEncryptedSystemMessage(ws, systemMessage, targetChatId) {
@@ -18439,6 +18673,30 @@ var OpenMatesClient = class _OpenMatesClient {
     return handledJobIds;
   }
   async persistStreamedEmbeds(params) {
+    const assertOwner = this.captureRecoveryOwner();
+    const ws = {
+      waitForMessage: (...args) => {
+        assertOwner();
+        const result = params.ws.waitForMessage(...args).then((value) => {
+          assertOwner();
+          return value;
+        });
+        void result.catch(() => {
+        });
+        return result;
+      },
+      sendAsync: async (...args) => {
+        assertOwner();
+        await params.ws.sendAsync(...args);
+        assertOwner();
+      }
+    };
+    const http = { get: async (path2, headers) => {
+      assertOwner();
+      const result = await this.http.get(path2, headers);
+      assertOwner();
+      return result;
+    } };
     const finalized = new Map(
       params.embeds.filter((embed) => {
         const status = embed.status ?? "finished";
@@ -18449,7 +18707,7 @@ var OpenMatesClient = class _OpenMatesClient {
     for (const parent of finalized.values()) {
       for (const childId of parent.embed_ids ?? []) {
         if (finalized.has(childId)) continue;
-        const childResponse = params.ws.waitForMessage(
+        const childResponse = ws.waitForMessage(
           "send_embed_data",
           (payload) => {
             const frame = payload;
@@ -18457,7 +18715,8 @@ var OpenMatesClient = class _OpenMatesClient {
             return nested.embed_id === childId;
           }
         );
-        await params.ws.sendAsync("request_embed", { embed_id: childId });
+        assertOwner();
+        await ws.sendAsync("request_embed", { embed_id: childId });
         const envelope = (await childResponse).payload;
         const child = envelope.payload ?? envelope;
         if (child.parent_embed_id !== parent.embed_id || !child.content || (child.status ?? "finished") !== "finished" || child.chat_id && child.chat_id !== params.chatId && child.chat_id !== computeSHA256(params.chatId)) {
@@ -18471,7 +18730,6 @@ var OpenMatesClient = class _OpenMatesClient {
     }
     const masterKey = this.getMasterKeyBytes();
     const parentKeys = /* @__PURE__ */ new Map();
-    const processed = /* @__PURE__ */ new Set();
     const cachedEmbeds = loadSyncCache();
     const resolveCachedParentKey = async (parentId) => {
       if (!cachedEmbeds) return void 0;
@@ -18489,6 +18747,7 @@ var OpenMatesClient = class _OpenMatesClient {
       ) ?? void 0;
     };
     const persistOne = async (embed, embedKey, isChild) => {
+      assertOwner();
       const now = Math.floor(Date.now() / 1e3);
       const createdAt = normalizeUnixSeconds(embed.createdAt, now);
       const updatedAt = normalizeUnixSeconds(embed.updatedAt, now);
@@ -18528,14 +18787,15 @@ var OpenMatesClient = class _OpenMatesClient {
         }
       ] : [];
       const storeRequestId = randomUUID9();
-      const storeConfirmed = params.ws.waitForMessage(
+      const storeConfirmed = ws.waitForMessage(
         "store_embed_confirmed",
         (payload) => matchesRecoveryEmbedReceipt(payload, storeRequestId, embed.embed_id),
         3e4
       );
       void storeConfirmed.catch(() => {
       });
-      await params.ws.sendAsync("store_embed", {
+      assertOwner();
+      await ws.sendAsync("store_embed", {
         request_id: storeRequestId,
         embed_id: embed.embed_id,
         encrypted_type: encryptedType,
@@ -18566,10 +18826,11 @@ var OpenMatesClient = class _OpenMatesClient {
       let storedHead = true;
       try {
         await storeConfirmed;
+        assertOwner();
       } catch (error) {
         if (!(error instanceof WebSocketProtocolError) || error.code !== "embed_write_denied") throw error;
         const query = params.teamId ? `?team_id=${encodeURIComponent(params.teamId)}` : "";
-        const canonical = await this.http.get(
+        const canonical = await http.get(
           `/v1/embeds/chats/${encodeURIComponent(params.chatId)}/embeds/${encodeURIComponent(embed.embed_id)}${query}`,
           this.getCliRequestHeaders()
         );
@@ -18634,14 +18895,15 @@ var OpenMatesClient = class _OpenMatesClient {
           const expectedEncryptedType = head.encrypted_type;
           const expectedDigest = computeSHA256(expectedCiphertext);
           const requestId = randomUUID9();
-          const confirmed = params.ws.waitForMessage(
+          const confirmed = ws.waitForMessage(
             "store_embed_confirmed",
             (payload) => matchesRecoveryEmbedReceipt(payload, requestId, embed.embed_id),
             3e4
           );
           void confirmed.catch(() => {
           });
-          await params.ws.sendAsync("store_embed", {
+          assertOwner();
+          await ws.sendAsync("store_embed", {
             request_id: requestId,
             embed_id: embed.embed_id,
             chat_id: params.chatId,
@@ -18661,7 +18923,7 @@ var OpenMatesClient = class _OpenMatesClient {
           if (receipt.canonical_source !== "head" || receipt.canonical_digest !== expectedDigest) {
             throw new Error(`Embed ${embed.embed_id} metadata enrichment receipt does not match canonical head.`);
           }
-          const enriched = await this.http.get(
+          const enriched = await http.get(
             `/v1/embeds/chats/${encodeURIComponent(params.chatId)}/embeds/${encodeURIComponent(embed.embed_id)}${query}`,
             this.getCliRequestHeaders()
           );
@@ -18674,7 +18936,7 @@ var OpenMatesClient = class _OpenMatesClient {
       }
       if (storedHead && keys2.length > 0) {
         const keysRequestId = randomUUID9();
-        const keysConfirmed = params.ws.waitForMessage(
+        const keysConfirmed = ws.waitForMessage(
           "store_embed_keys_confirmed",
           (payload) => {
             const p = payload;
@@ -18682,8 +18944,10 @@ var OpenMatesClient = class _OpenMatesClient {
           },
           3e4
         );
-        await params.ws.sendAsync("store_embed_keys", { request_id: keysRequestId, keys: keys2 });
+        assertOwner();
+        await ws.sendAsync("store_embed_keys", { request_id: keysRequestId, keys: keys2 });
         const keysReceipt = (await keysConfirmed).payload;
+        assertOwner();
         if (keysReceipt.failed_count !== 0 || keysReceipt.created_count !== keys2.length) {
           throw new Error(`Embed ${embed.embed_id} key wrappers were not durably stored.`);
         }
@@ -18698,7 +18962,7 @@ var OpenMatesClient = class _OpenMatesClient {
           if (row3.version_number === 1) {
             const query = new URLSearchParams({ capability: "bounded-v1", chat_id: params.chatId });
             if (params.teamId) query.set("team_id", params.teamId);
-            const existing = await this.http.get(
+            const existing = await http.get(
               `/v1/embeds/${encodeURIComponent(embed.embed_id)}/versions/1?${query}`,
               this.getCliRequestHeaders()
             );
@@ -18721,7 +18985,7 @@ var OpenMatesClient = class _OpenMatesClient {
           const encryptedPatch = typeof row3.patch === "string" ? await encryptWithAesGcmCombined(row3.patch, embedKey) : void 0;
           if (!encryptedSnapshot && !encryptedPatch) continue;
           const diffRequestId = randomUUID9();
-          const diffConfirmed = params.ws.waitForMessage(
+          const diffConfirmed = ws.waitForMessage(
             "store_embed_diff_confirmed",
             (payload) => {
               const p = payload;
@@ -18731,7 +18995,8 @@ var OpenMatesClient = class _OpenMatesClient {
           );
           void diffConfirmed.catch(() => {
           });
-          await params.ws.sendAsync("store_embed_diff", {
+          assertOwner();
+          await ws.sendAsync("store_embed_diff", {
             request_id: diffRequestId,
             embed_id: row3.embed_id,
             version_number: row3.version_number,
@@ -18741,6 +19006,7 @@ var OpenMatesClient = class _OpenMatesClient {
             created_at: normalizeUnixSeconds(row3.created_at, now)
           });
           const diffReceipt = (await diffConfirmed).payload;
+          assertOwner();
           const expectedDigest = computeSHA256(JSON.stringify([encryptedSnapshot ?? null, encryptedPatch ?? null]));
           if (diffReceipt.canonical_source !== "version_row" || diffReceipt.canonical_digest !== expectedDigest) {
             throw new Error(`Embed ${embed.embed_id} v${row3.version_number} durable receipt did not match the stored source.`);
@@ -18748,34 +19014,19 @@ var OpenMatesClient = class _OpenMatesClient {
         }
       }
     };
-    let madeProgress = true;
-    while (processed.size < finalized.size && madeProgress) {
-      madeProgress = false;
-      for (const embed of finalized.values()) {
-        if (processed.has(embed.embed_id)) continue;
-        const parentId = embed.parent_embed_id || null;
-        if (parentId && finalized.has(parentId) && !parentKeys.has(parentId)) {
-          continue;
-        }
-        const parentKey = parentId ? parentKeys.get(parentId) ?? await resolveCachedParentKey(parentId) : void 0;
-        if (parentId && !parentKey) continue;
-        const embedKey = parentKey ?? await deriveEmbedKeyFromChatKey(params.chatKeyBytes, embed.embed_id);
-        await persistOne(embed, embedKey, Boolean(parentId));
-        processed.add(embed.embed_id);
-        madeProgress = true;
-      }
-    }
-    for (const embed of finalized.values()) {
-      if (processed.has(embed.embed_id)) continue;
+    await runRecoveryBatch([...finalized.values()], async (embed) => {
+      assertOwner();
       const parentId = embed.parent_embed_id || null;
       const parentKey = parentId ? parentKeys.get(parentId) ?? await resolveCachedParentKey(parentId) : void 0;
+      assertOwner();
       if (parentId && !parentKey) {
         throw new Error(`Cannot persist child embed ${embed.embed_id}: parent embed key ${parentId} is unavailable.`);
       }
       const embedKey = parentKey ?? await deriveEmbedKeyFromChatKey(params.chatKeyBytes, embed.embed_id);
+      assertOwner();
       await persistOne(embed, embedKey, Boolean(parentId));
-      processed.add(embed.embed_id);
-    }
+      assertOwner();
+    }, (embed, dependency) => embed.parent_embed_id === dependency.embed_id);
   }
   async persistPostProcessingMetadata(params) {
     const encryptedFollowUps = params.followUpSuggestions.length > 0 ? await encryptWithAesGcmCombined(
@@ -23103,6 +23354,7 @@ Required: ${schema.required.join(", ")}`
   interactiveViewerAllowed = false;
   interactiveViewerGeneration = 0;
   beginInteractiveViewerSession() {
+    this.cancelSendSocketRearm();
     this.interactiveAdmissionEnabled = true;
     this.interactiveAdmissionOwner = null;
     this.interactiveAdmissionAuth = null;
@@ -23110,6 +23362,7 @@ Required: ${schema.required.join(", ")}`
     this.preparedSendSocketAttemptOwner = null;
   }
   endInteractiveViewerSession() {
+    this.cancelSendSocketRearm();
     this.interactiveAdmissionEnabled = false;
     this.interactiveAdmissionOwner = null;
     this.interactiveAdmissionAuth = null;
@@ -42590,6 +42843,20 @@ async function verifyCaddyCoreRoutes(apiUrl, origin) {
     "Access-Control-Request-Headers": "content-type"
   } });
   if (!embedPreflight.ok || embedPreflight.headers.get("access-control-allow-origin") !== origin || embedPreflight.headers.get("access-control-allow-credentials") !== "true") throw new Error("caddy_embed_reference_cors_failed");
+  let accountKeyPreflight;
+  try {
+    accountKeyPreflight = await request("/v1/account/chat-encryption-key", { method: "OPTIONS", headers: {
+      Origin: origin,
+      "Access-Control-Request-Method": "GET",
+      "Access-Control-Request-Headers": "content-type"
+    } });
+  } catch {
+    throw new Error("caddy_account_chat_key_preflight_failed");
+  }
+  const accountKeyMethods = accountKeyPreflight.headers.get("access-control-allow-methods")?.split(",").map((value) => value.trim().toUpperCase()) ?? [];
+  if (accountKeyPreflight.status !== 200 || accountKeyPreflight.headers.get("access-control-allow-origin") !== origin || accountKeyPreflight.headers.get("access-control-allow-credentials") !== "true" || !accountKeyMethods.includes("GET")) {
+    throw new Error("caddy_account_chat_key_preflight_failed");
+  }
   const availability = await request("/v1/features/availability");
   if (!availability.ok) throw new Error("caddy_availability_route_failed");
   const features = await availability.json();