openmates 0.27.0-alpha.57 → 0.27.0-alpha.59

package/dist/{chunk-EHETUQZT.js → chunk-ACLJYOK7.js}

@@ -2395,8 +2395,13 @@ async function parseGenericImportBuffer(payload, sourceName = "generic-transcrip
 }
 
 // src/http.ts
+import { AsyncLocalStorage } from "async_hooks";
 var DEFAULT_JSON_REQUEST_TIMEOUT_MS = 18e4;
 var JSON_REQUEST_TIMEOUT_ENV = "OPENMATES_CLI_HTTP_TIMEOUT_MS";
+var requestAbortScope = new AsyncLocalStorage();
+function withHttpAbortSignal(signal, operation) {
+  return requestAbortScope.run(signal, operation);
+}
 var OpenMatesHttpClient = class {
   apiUrl;
   cookies;
@@ -2505,7 +2510,12 @@ var OpenMatesHttpClient = class {
     if (body !== void 0) {
       requestHeaders["Content-Type"] = "application/json";
     }
+    const scopedSignal = requestAbortScope.getStore();
+    scopedSignal?.throwIfAborted();
     const controller = new AbortController();
+    const onScopedAbort = () => controller.abort(scopedSignal?.reason);
+    scopedSignal?.addEventListener("abort", onScopedAbort, { once: true });
+    if (scopedSignal?.aborted) onScopedAbort();
     const timeout = setTimeout(() => controller.abort(), getJsonRequestTimeoutMs());
     try {
       let response;
@@ -2517,19 +2527,23 @@ var OpenMatesHttpClient = class {
           signal: controller.signal
         });
       } catch (error) {
+        if (scopedSignal?.aborted) throw new Error(`HTTP ${method} ${path2} cancelled`);
         if (controller.signal.aborted) {
           throw new Error(`HTTP ${method} ${path2} timed out after ${getJsonRequestTimeoutMs()}ms`);
         }
         throw error;
       }
       await this.captureCookies(response, path2, sessionId, sentToken);
+      scopedSignal?.throwIfAborted();
       let data = {};
       try {
         data = await response.json();
       } catch {
+        if (scopedSignal?.aborted) throw new Error(`HTTP ${method} ${path2} cancelled`);
         if (controller.signal.aborted) throw new Error(`HTTP ${method} ${path2} timed out`);
         data = {};
       }
+      scopedSignal?.throwIfAborted();
       return {
         ok: response.ok,
         status: response.status,
@@ -2538,6 +2552,7 @@ var OpenMatesHttpClient = class {
       };
     } finally {
       clearTimeout(timeout);
+      scopedSignal?.removeEventListener("abort", onScopedAbort);
     }
   }
   formatCookieHeader() {
@@ -13203,6 +13218,20 @@ var OpenMatesClient = class _OpenMatesClient {
     if (!current2()) throw new Error("Chat workspace changed");
     return result;
   }
+  chatActivitySocket = null;
+  /** Warm the active chat scope over the TUI's existing authenticated activity socket. */
+  warmChatMetadata() {
+    const activity = this.chatActivitySocket;
+    if (!activity || !activity.ownerCurrent()) return;
+    const teamId = this.getActiveTeamId();
+    const scope2 = teamId ?? "personal";
+    if (activity.lastWarmupScope === scope2) return;
+    try {
+      activity.ws.send("chat_metadata_warmup", teamId ? { team_id: teamId } : {});
+      activity.lastWarmupScope = scope2;
+    } catch {
+    }
+  }
   /** Observe lifecycle metadata without claiming or collecting AI responses. */
   async observeChatActivity(onChange) {
     const session = this.requireSession();
@@ -13231,6 +13260,7 @@ var OpenMatesClient = class _OpenMatesClient {
       removeHandlers = [];
       const active = socket;
       socket = null;
+      if (this.chatActivitySocket?.ws === active) this.chatActivitySocket = null;
       active?.close();
     };
     const scheduleReconnect = () => {
@@ -13256,6 +13286,8 @@ var OpenMatesClient = class _OpenMatesClient {
         return;
       }
       socket = opened;
+      this.chatActivitySocket = { ws: opened, ownerCurrent, lastWarmupScope: null };
+      this.warmChatMetadata();
       removeHandlers = types.map((type) => opened.onMessageType(type, () => {
         if (!ownerCurrent()) {
           stop();
@@ -13269,6 +13301,7 @@ var OpenMatesClient = class _OpenMatesClient {
       removeHandlers.push(opened.onClose(() => {
         if (socket !== opened) return;
         socket = null;
+        if (this.chatActivitySocket?.ws === opened) this.chatActivitySocket = null;
         removeHandlers.forEach((remove) => remove());
         removeHandlers = [];
         scheduleReconnect();
@@ -15510,6 +15543,7 @@ var OpenMatesClient = class _OpenMatesClient {
     params.onPrivacyPrepared?.(finalMessage);
     const explicitTasksAppSkill = messageExplicitlyRequestsTasksAppSkill(finalMessage);
     const taskUpdateJobsEnabled = params.taskUpdateJobs !== false && !explicitTasksAppSkill;
+    const authSocketStartedAt = Date.now();
     const { ws, ownerId: ownerId2 } = await this.openWsClient({
       taskUpdateJobs: taskUpdateJobsEnabled,
       projectFileJobs: !params.incognito,
@@ -15520,994 +15554,937 @@ var OpenMatesClient = class _OpenMatesClient {
       ws.close();
       throw new Error("Authenticated user identity is required for saved chat recovery.");
     }
-    if (!params.incognito) {
-      try {
-        await ws.waitForRecoveryOutputDiscovery();
-      } catch (error) {
-        ws.close();
-        throw error;
-      }
-    }
-    const messageId = 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);
+    const authSocketMs = Date.now() - authSocketStartedAt;
+    let contextSession;
+    try {
+      contextSession = this.requireSession();
+    } catch (error) {
+      ws.close();
+      throw error;
     }
-    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,
-      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) {
-      const masterKey = this.getMasterKeyBytes();
-      const wrappingKey = await this.getChatWrappingKey(teamId, masterKey);
-      chatSlugLookupKey = wrappingKey;
-      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 = 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 decryptBytesWithAesGcm(encKey, wrappingKey);
-            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 {
+      apiUrl: contextApiUrl,
+      hashedEmail: contextHashedEmail,
+      sessionId: contextSessionId,
+      createdAt: contextSessionCreatedAt,
+      masterKeyExportedB64: contextMasterKey,
+      activeTeamId: contextActiveTeamId
+    } = contextSession;
+    const contextScope = { teamId, personal: !teamId };
+    const contextStartedAt = Date.now();
+    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, params.jevContext, finalMessage)).then(
+      (value) => ({ ok: true, value, elapsedMs: Date.now() - contextStartedAt }),
+      (error) => ({ ok: false, error, elapsedMs: Date.now() - contextStartedAt })
+    ) : null;
+    try {
+      if (!params.incognito) {
+        try {
+          ws.send("chat_metadata_warmup", teamId ? { team_id: teamId } : {});
+        } catch {
+        }
+        try {
+          const recoveryStartedAt = Date.now();
+          await ws.waitForRecoveryOutputDiscovery();
+          recoveryMs = Date.now() - recoveryStartedAt;
+        } catch (error) {
+          ws.close();
+          throw error;
+        }
+      }
+      const messageId = 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,
+        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) {
+        const masterKey = this.getMasterKeyBytes();
+        const wrappingKey = await this.getChatWrappingKey(teamId, masterKey);
+        chatSlugLookupKey = wrappingKey;
+        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 = 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 decryptBytesWithAesGcm(encKey, wrappingKey);
+              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.`);
-        }
-      }
-    }
-    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 === messageId && typeof frame.project_id === "string")
-        projectAuthoringAvailable = { chat_id: chatId, project_id: frame.project_id, user_message_id: messageId };
-    });
-    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 === messageId && typeof frame.project_id === "string")
+          projectAuthoringAvailable = { chat_id: chatId, project_id: frame.project_id, user_message_id: messageId };
       });
-    });
-    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: messageId,
-        chat_id: chatId,
-        role: "user",
-        sender_name: "User",
-        status: "sent",
-        content: finalMessage,
-        created_at: createdAt,
-        chat_has_title: Boolean(params.chatId)
+      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");
       }
-    };
-    if (!params.incognito) Object.assign(
-      messagePayload,
-      await prepareCliJevContext(this, chatId, { teamId, personal: !teamId }, params.jevContext, finalMessage)
-    );
-    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: messageId,
+      const messagePayload = {
         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.");
+        ...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: messageId,
+          chat_id: chatId,
+          role: "user",
+          sender_name: "User",
+          status: "sent",
+          content: finalMessage,
+          created_at: createdAt,
+          chat_has_title: Boolean(params.chatId)
+        }
+      };
+      if (!params.incognito) {
+        const serialContextStartedAt = Date.now();
+        const prepared = earlyContext ? await earlyContext : { ok: true, value: await prepareCliJevContext(this, chatId, contextScope, params.jevContext, finalMessage), elapsedMs: Date.now() - serialContextStartedAt };
+        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] auth_ws_ms=${authSocketMs} recovery_ms=${recoveryMs} context_ms=${prepared.elapsedMs}`);
+        }
+        Object.assign(messagePayload, prepared.value);
+      }
+      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 (!chatKeyBytes) {
-        throw new Error("Saved chat key is required to encrypt every prepared embed.");
+      if (isNewChat && encryptedChatKey) {
+        messagePayload.encrypted_chat_key = encryptedChatKey;
       }
-      if (new Set(params.preparedEmbeds.map((embed) => embed.embedId)).size !== params.preparedEmbeds.length) {
-        throw new Error("Prepared message embed IDs must be unique.");
+      if (memoryMetadataKeys.length > 0) {
+        messagePayload.app_settings_memories_metadata = memoryMetadataKeys;
       }
-      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 (connectedAccountDirectory) {
+        messagePayload.connected_account_directory = connectedAccountDirectory;
       }
-      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 (connectedAccountTokenRefs.length > 0) {
+        messagePayload.connected_account_token_refs = connectedAccountTokenRefs;
       }
-      const masterKey = this.getMasterKeyBytes();
-      for (const embed of params.preparedEmbeds) {
-        if (canonicalReady.has(embed.embedId)) continue;
-        const encrypted = await encryptEmbed(
-          embed,
-          masterKey,
-          chatKeyBytes,
-          chatId,
-          messageId,
-          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);
+      if (params.benchmarkMetadata) {
+        messagePayload.benchmark_metadata = params.benchmarkMetadata;
       }
-    }
-    if (!params.incognito && encryptedEmbeds.length > 0) {
-      if (!ownerId2) throw new Error("Authenticated owner identity is required for encrypted message embeds.");
-      assertCompleteEncryptedEmbedBundle(encryptedEmbeds, { chatId, messageId, ownerId: ownerId2 });
-    }
-    if (encryptedEmbeds.length > 0) {
-      messagePayload.encrypted_embeds = encryptedEmbeds;
-    }
-    let dispatchHandlersReady = () => {
-    };
-    const handlersReady = new Promise((resolve20) => {
-      dispatchHandlersReady = resolve20;
-    });
-    let precollectedResponse = params.precollectResponse && params.incognito && shouldWaitForAi ? ws.collectAiResponse(messageId, chatId, { onStream: params.onStream, timeoutMs: params.responseTimeoutMs }) : null;
-    if (!params.incognito && chatKeyBytes && encryptedChatKey) {
-      const protocolVersion = 1;
-      const chatKeyVersion = 1;
-      const turnId = randomUUID9();
-      savedTurnId = turnId;
-      terminalExpectedMessagesV = baselineMessagesV + 1;
-      const recoveryKeypair = await deriveChatCompletionRecoveryKeypair(
-        Buffer.from(chatKeyBytes).toString("base64url"),
-        chatId,
-        chatKeyVersion
-      );
-      const encryptedContent = await encryptWithAesGcmCombined(
-        finalMessage,
-        chatKeyBytes
-      );
-      const encryptedUserMessage = {
-        client_message_id: messageId,
-        chat_id: chatId,
-        encrypted_content: encryptedContent,
-        role: "user",
-        created_at: createdAt,
-        updated_at: createdAt
-      };
-      encryptedUserMessage.encrypted_sender_name = await encryptWithAesGcmCombined(
-        teamSenderName,
-        chatKeyBytes
-      );
-      if (piiMappings.length > 0) {
-        encryptedUserMessage.encrypted_pii_mappings = await encryptWithAesGcmCombined(
-          JSON.stringify(piiMappings),
-          chatKeyBytes
+      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: messageId,
+          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)
         );
       }
-      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: messageId };
-        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,
+            messageId,
+            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: messageId,
-        chat_key_version: chatKeyVersion,
-        encrypted_chat_key: encryptedChatKey,
-        recovery_public_key: recoveryKeypair.publicKey,
-        expected_messages_v: baselineMessagesV,
-        encrypted_user_message: encryptedUserMessage,
-        inference_request: preflightInferenceRequest
+      if (!params.incognito && encryptedEmbeds.length > 0) {
+        if (!ownerId2) throw new Error("Authenticated owner identity is required for encrypted message embeds.");
+        assertCompleteEncryptedEmbedBundle(encryptedEmbeds, { chatId, messageId, 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 precollectedResponse = params.precollectResponse && params.incognito && shouldWaitForAi ? ws.collectAiResponse(messageId, chatId, { onStream: params.onStream, timeoutMs: params.responseTimeoutMs }) : null;
+      if (!params.incognito && chatKeyBytes && encryptedChatKey) {
+        const protocolVersion = 1;
+        const chatKeyVersion = 1;
+        const turnId = randomUUID9();
+        savedTurnId = turnId;
+        terminalExpectedMessagesV = baselineMessagesV + 1;
+        const recoveryKeypair = await deriveChatCompletionRecoveryKeypair(
+          Buffer.from(chatKeyBytes).toString("base64url"),
+          chatId,
+          chatKeyVersion
+        );
+        const encryptedContent = await encryptWithAesGcmCombined(
+          finalMessage,
+          chatKeyBytes
+        );
+        const encryptedUserMessage = {
+          client_message_id: messageId,
+          chat_id: chatId,
+          encrypted_content: encryptedContent,
+          role: "user",
           created_at: createdAt,
           updated_at: createdAt
         };
-      }
-      let ackPayload;
-      try {
+        encryptedUserMessage.encrypted_sender_name = await encryptWithAesGcmCombined(
+          teamSenderName,
+          chatKeyBytes
+        );
+        if (piiMappings.length > 0) {
+          encryptedUserMessage.encrypted_pii_mappings = await encryptWithAesGcmCombined(
+            JSON.stringify(piiMappings),
+            chatKeyBytes
+          );
+        }
+        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,
-            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: messageId };
+          delete messagePayload.message_history;
+          messagePayload.message = teamMessageEnvelope;
+          if (shouldWaitForAi) {
+            messagePayload.team_ai_invocation = { history: teamInferenceHistory };
+            preflightInferenceRequest = {
+              ...messagePayload,
+              message_history: teamInferenceHistory
+            };
+          }
         }
-        if (params.projectId) {
-          await prepareCliProjectFocusForPreflight({
-            ws,
-            chatId,
-            teamId,
-            isNewChat,
-            encryptedChatKey,
-            createdAt,
-            activateFocus: () => activateCliProjectFocus(this, params.projectId, chatId, teamId)
+        const preflightPayload = {
+          protocol_version: protocolVersion,
+          chat_id: chatId,
+          ...teamId ? { team_id: teamId } : {},
+          turn_id: turnId,
+          message_id: messageId,
+          chat_key_version: chatKeyVersion,
+          encrypted_chat_key: encryptedChatKey,
+          recovery_public_key: recoveryKeypair.publicKey,
+          expected_messages_v: baselineMessagesV,
+          encrypted_user_message: encryptedUserMessage,
+          inference_request: preflightInferenceRequest
+        };
+        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
           });
-          const focusedContext = await prepareCliJevContext(
-            this,
-            chatId,
-            { teamId, personal: !teamId },
-            params.jevContext,
-            finalMessage
-          );
-          Object.assign(messagePayload, focusedContext);
-          Object.assign(preflightInferenceRequest, focusedContext);
+          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
+          };
         }
-        const preflightAck = ws.waitForMessage(
-          "chat_turn_preflight_ack",
-          (payload) => payload.turn_id === turnId
-        );
+        let ackPayload;
         try {
-          await ws.sendAsync("chat_turn_preflight", preflightPayload);
+          if (teamId) {
+            await stageCliTeamNotificationPreview(ws, {
+              teamId,
+              chatId,
+              messageId,
+              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
+            );
+            Object.assign(messagePayload, focusedContext);
+            Object.assign(preflightInferenceRequest, focusedContext);
+          }
+          const preflightAck = ws.waitForMessage(
+            "chat_turn_preflight_ack",
+            (payload) => payload.turn_id === turnId
+          );
+          try {
+            await ws.sendAsync("chat_turn_preflight", preflightPayload);
+          } catch (error) {
+            void preflightAck.catch(() => {
+            });
+            throw error;
+          }
+          ackPayload = (await preflightAck).payload;
         } catch (error) {
-          void preflightAck.catch(() => {
-          });
+          ws.close();
           throw error;
         }
-        ackPayload = (await preflightAck).payload;
-      } catch (error) {
-        ws.close();
-        throw error;
-      }
-      if (typeof ackPayload.preflight_id !== "string" || !ackPayload.preflight_id) {
-        ws.close();
-        throw new Error("Encrypted chat preflight acknowledgement omitted preflight_id.");
+        if (typeof ackPayload.preflight_id !== "string" || !ackPayload.preflight_id) {
+          ws.close();
+          throw new Error("Encrypted chat preflight acknowledgement omitted preflight_id.");
+        }
+        Object.assign(messagePayload, {
+          protocol_version: protocolVersion,
+          preflight_id: ackPayload.preflight_id
+        });
+        if (typeof ackPayload.committed_messages_v === "number" && Number.isSafeInteger(ackPayload.committed_messages_v)) {
+          terminalExpectedMessagesV = ackPayload.committed_messages_v;
+        }
       }
-      Object.assign(messagePayload, {
-        protocol_version: protocolVersion,
-        preflight_id: ackPayload.preflight_id
-      });
-      if (typeof ackPayload.committed_messages_v === "number" && Number.isSafeInteger(ackPayload.committed_messages_v)) {
-        terminalExpectedMessagesV = ackPayload.committed_messages_v;
+      if (!params.incognito && shouldWaitForAi) {
+        precollectedResponse = ws.collectAiResponse(messageId, chatId, {
+          onStream: params.onStream,
+          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)
+        });
       }
-    }
-    if (!params.incognito && shouldWaitForAi) {
-      precollectedResponse = ws.collectAiResponse(messageId, chatId, {
-        onStream: params.onStream,
-        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 === messageId;
+      }, params.responseTimeoutMs ?? 9e4) : null;
+      if (queuedAdmission) void queuedAdmission.catch(() => {
       });
-    }
-    const queuedAdmission = !params.incognito && shouldWaitForAi ? ws.waitForMessage("message_queued", (payload) => {
-      const event = payload;
-      return event.chat_id === chatId && event.user_message_id === messageId;
-    }, 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 === messageId || 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 === messageId;
-      },
-      params.responseTimeoutMs ?? DEFAULT_CHAT_MESSAGE_CONFIRMATION_TIMEOUT_MS
-    );
-    let confirmedPayload;
-    try {
-      await ws.sendAsync("chat_message_added", messagePayload);
-      confirmedPayload = (await confirmed).payload;
-    } catch (error) {
-      dispatchHandlersReady();
-      void confirmed.catch(() => {
+      const pausedHandoff = !params.incognito && shouldWaitForAi ? ws.waitForMessage("queued_handoff_paused", (payload) => {
+        const event = payload;
+        return event.chat_id === chatId && (event.message_id === messageId || event.message_id === void 0);
+      }, params.responseTimeoutMs ?? 9e4) : null;
+      if (pausedHandoff) void pausedHandoff.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 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;
+      const confirmed = ws.waitForMessage(
+        "chat_message_confirmed",
+        (payload) => {
+          const eventPayload = payload;
+          return eventPayload.chat_id === chatId && eventPayload.message_id === messageId;
+        },
+        params.responseTimeoutMs ?? DEFAULT_CHAT_MESSAGE_CONFIRMATION_TIMEOUT_MS
+      );
+      let confirmedPayload;
+      try {
+        await ws.sendAsync("chat_message_added", messagePayload);
+        confirmedPayload = (await confirmed).payload;
+      } catch (error) {
+        dispatchHandlersReady();
+        void confirmed.catch(() => {
+        });
+        if (precollectedResponse) void precollectedResponse.catch(() => {
+        });
+        ws.close();
+        throw error;
       }
-      if (request.maxDirectSubChats !== null && request.existingSubChats !== null && request.existingSubChats + count > request.maxDirectSubChats) {
-        return false;
+      if (!params.incognito && typeof confirmedPayload.new_messages_v === "number" && Number.isSafeInteger(confirmedPayload.new_messages_v)) {
+        terminalExpectedMessagesV = confirmedPayload.new_messages_v;
       }
-      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;
+      if (!params.incognito && (!teamId || shouldWaitForAi)) {
+        clearSyncCache(teamId);
       }
-      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
+      let assistant = "";
+      let assistantMessageId = null;
+      let category = null;
+      let modelName = null;
+      let tokenUsage = null;
+      let promptBudget = null;
+      let followUpSuggestions = [];
+      let taskProposals = [];
+      let taskUpdateProposals = [];
+      let taskEvents = [];
+      let pendingTaskUpdateJobs = [];
+      let subChatEvents = [];
+      const appSettingsMemoryRequests = [];
+      const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+      const isApprovalWithinServerLimits = (request) => {
+        const count = request.subChats.length;
+        if (count === 0) return false;
+        if (request.remainingSubChats !== null && count > request.remainingSubChats) {
+          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 ?? `${messageId}-memory-request`;
-      await persistSystemMessage(buildAppSettingsMemoryRequestSystemMessage({
-        userMessageId: messageId,
-        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
+        if (request.maxDirectSubChats !== null && request.existingSubChats !== null && request.existingSubChats + count > request.maxDirectSubChats) {
+          return false;
+        }
+        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 ?? `${messageId}-memory-request`;
+        await persistSystemMessage(buildAppSettingsMemoryRequestSystemMessage({
           userMessageId: messageId,
-          messageId: `${messageId}-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: messageId,
-            event
-          }),
-          chatId
-        );
-        persistedTaskEventIds.add(event.event_id);
-      }
-    };
-    const streamOpts = {
-      onStream: params.onStream,
-      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(messageId, 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 () => {
-          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(messageId, chatId, {
-          ...streamOpts,
-          timeoutMs: params.responseTimeoutMs,
-          recoveryTurnId: savedTurnId
-        });
-        const outcome = await Promise.race([
-          responsePromise.then((response) => ({ kind: "response", response })),
-          ...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: messageId,
-            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: `${messageId}-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;
-        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: messageId,
+              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 = {
+        onStream: params.onStream,
+        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(messageId, 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 {
-              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();
+        } finally {
+          ws.close();
+        }
+      } else {
+        try {
+          const recoverCurrentTurnOutputs = async () => {
+            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(messageId, chatId, {
+            ...streamOpts,
+            timeoutMs: params.responseTimeoutMs,
+            recoveryTurnId: savedTurnId
+          });
+          const outcome = await Promise.race([
+            responsePromise.then((response) => ({ kind: "response", response })),
+            ...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
+          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: messageId,
+              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;
+          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,
@@ -16519,223 +16496,326 @@ 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
+              });
+              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).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,
-              encrypted_sender_name: encryptedSenderName,
-              encrypted_category: encryptedCategory,
-              encrypted_model_name: encryptedModelName,
-              role: "assistant",
-              user_message_id: messageId,
-              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).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 });
-                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,
+                encrypted_sender_name: encryptedSenderName,
+                encrypted_category: encryptedCategory,
+                encrypted_model_name: encryptedModelName,
+                role: "assistant",
+                user_message_id: messageId,
+                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 });
+                  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
-          });
-          if (isNewChat && (resp.generatedTitle || resp.generatedIcon)) {
-            const metadataStored = 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_chat_key: encryptedChatKey,
-              ...resp.generatedTitle ? { encrypted_title: await encryptWithAesGcmCombined(resp.generatedTitle, chatKeyBytes) } : {},
-              ...category ? { encrypted_chat_category: await encryptWithAesGcmCombined(category, chatKeyBytes) } : {},
-              ...resp.generatedIcon ? { encrypted_icon: await encryptWithAesGcmCombined(resp.generatedIcon, chatKeyBytes) } : {},
-              versions: { messages_v: terminalExpectedMessagesV + 1 }
+            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
             });
-            await metadataStored;
-          }
-          await this.persistPostProcessingMetadata({
-            ws,
-            chatId,
-            teamId,
-            chatKeyBytes,
-            followUpSuggestions: resp.followUpSuggestions,
-            newChatSuggestions: resp.newChatSuggestions,
-            chatSummary: resp.chatSummary,
-            chatTags: resp.chatTags,
-            updatedChatTitle: resp.updatedChatTitle,
-            sourceTitleVersion: resp.sourceTitleVersion,
-            sourceMetadataVersion: resp.sourceMetadataVersion,
-            encryptedChatKey
-          });
-          await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
-          if (taskUpdateJobsEnabled) {
-            const persistedTaskJobIds = await this.persistPendingTaskUpdateJobs({
+            if (isNewChat && (resp.generatedTitle || resp.generatedIcon)) {
+              const metadataStored = 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_chat_key: encryptedChatKey,
+                ...resp.generatedTitle ? { encrypted_title: await encryptWithAesGcmCombined(resp.generatedTitle, chatKeyBytes) } : {},
+                ...category ? { encrypted_chat_category: await encryptWithAesGcmCombined(category, chatKeyBytes) } : {},
+                ...resp.generatedIcon ? { encrypted_icon: await encryptWithAesGcmCombined(resp.generatedIcon, chatKeyBytes) } : {},
+                versions: { messages_v: terminalExpectedMessagesV + 1 }
+              });
+              await metadataStored;
+            }
+            await this.persistPostProcessingMetadata({
               ws,
-              jobs: pendingTaskUpdateJobs,
-              events: taskEvents,
+              chatId,
               teamId,
-              activeChatId: chatId,
-              activeChatKeyBytes: chatKeyBytes,
-              fallbackUserMessageId: messageId,
-              requireActiveTurnEvent: true
+              chatKeyBytes,
+              followUpSuggestions: resp.followUpSuggestions,
+              newChatSuggestions: resp.newChatSuggestions,
+              chatSummary: resp.chatSummary,
+              chatTags: resp.chatTags,
+              updatedChatTitle: resp.updatedChatTitle,
+              sourceTitleVersion: resp.sourceTitleVersion,
+              sourceMetadataVersion: resp.sourceMetadataVersion,
+              encryptedChatKey
             });
-            pendingTaskUpdateJobs = pendingTaskUpdateJobs.filter((job) => !persistedTaskJobIds.has(job.job_id));
-          }
-          await persistTaskEventSystemMessages(taskEvents);
-          await recoverCurrentTurnOutputs();
-          clearSyncCache(teamId);
-        }
-      } 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 {
+            await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+            if (taskUpdateJobsEnabled) {
+              const persistedTaskJobIds = await this.persistPendingTaskUpdateJobs({
+                ws,
+                jobs: pendingTaskUpdateJobs,
+                events: taskEvents,
+                teamId,
+                activeChatId: chatId,
+                activeChatKeyBytes: chatKeyBytes,
+                fallbackUserMessageId: messageId,
+                requireActiveTurnEvent: true
+              });
+              pendingTaskUpdateJobs = pendingTaskUpdateJobs.filter((job) => !persistedTaskJobIds.has(job.job_id));
             }
+            await persistTaskEventSystemMessages(taskEvents);
+            await recoverCurrentTurnOutputs();
+            clearSyncCache(teamId);
           }
-          await chatContextEvents?.flush();
         } finally {
-          projectFocusCountdown?.();
-          chatContextEvents?.stop();
-          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();
+            ws.close();
+          }
         }
+        if (focusPersistenceError) throw focusPersistenceError;
       }
-      if (focusPersistenceError) throw focusPersistenceError;
+      const mateName = category ? MATE_NAMES[category] ?? null : null;
+      return {
+        status: "completed",
+        chatId,
+        messageId: assistantMessageId,
+        userMessageId: messageId,
+        assistant,
+        category,
+        modelName,
+        mateName,
+        followUpSuggestions,
+        taskProposals,
+        taskUpdateProposals,
+        taskEvents,
+        pendingTaskUpdateJobs,
+        subChatEvents,
+        appSettingsMemoryRequests,
+        tokenUsage,
+        promptBudget
+      };
+    } finally {
+      earlyContextAbort.abort();
+      ws.close();
+      if (earlyContext) await earlyContext;
     }
-    const mateName = category ? MATE_NAMES[category] ?? null : null;
-    return {
-      status: "completed",
-      chatId,
-      messageId: assistantMessageId,
-      userMessageId: messageId,
-      assistant,
-      category,
-      modelName,
-      mateName,
-      followUpSuggestions,
-      taskProposals,
-      taskUpdateProposals,
-      taskEvents,
-      pendingTaskUpdateJobs,
-      subChatEvents,
-      appSettingsMemoryRequests,
-      tokenUsage,
-      promptBudget
-    };
   }
   async persistEncryptedSystemMessage(ws, systemMessage, targetChatId) {
     await ws.sendAsync("chat_system_message_added", {
@@ -104687,6 +104767,9 @@ async function runTui(client2, terminal = new TuiTerminal(), startupServices) {
   let lastFrameOwner = null;
   let closed = false;
   let stopActivity;
+  let workspaceReady = false;
+  let activityOwner = null;
+  let activityEpoch = 0;
   let activityTimer;
   let refreshingActivity = false;
   let identityScope = "";
@@ -104745,6 +104828,35 @@ async function runTui(client2, terminal = new TuiTerminal(), startupServices) {
       hydrateExamples(state);
     }
   };
+  const syncActivityObserver = () => {
+    if (!workspaceReady || closed) return;
+    const session = state.signedIn && client2.hasSession() && typeof client2.getSession === "function" ? client2.getSession() : null;
+    const owner2 = session ? JSON.stringify([
+      session.apiUrl,
+      session.hashedEmail,
+      session.sessionId,
+      session.createdAt,
+      session.masterKeyExportedB64
+    ]) : null;
+    if (owner2 === activityOwner) return;
+    activityOwner = owner2;
+    const epoch = ++activityEpoch;
+    stopActivity?.();
+    stopActivity = void 0;
+    if (!owner2 || typeof client2.observeChatActivity !== "function") return;
+    void client2.observeChatActivity(() => {
+      if (closed || activityEpoch !== epoch || activityOwner !== owner2) return;
+      teamChatRefresh?.request();
+      clearTimeout(activityTimer);
+      activityTimer = setTimeout(() => {
+        void refreshActivity();
+      }, 300);
+    }).then((stop) => {
+      if (closed || activityEpoch !== epoch || activityOwner !== owner2) stop();
+      else stopActivity = stop;
+    }).catch(() => {
+    });
+  };
   const render = () => {
     if (closed) return;
     syncSessionView();
@@ -104784,6 +104896,8 @@ async function runTui(client2, terminal = new TuiTerminal(), startupServices) {
     }
     workspaceScope = nextScope;
     state.activeTeamId = teamId;
+    syncActivityObserver();
+    if (workspaceReady && state.signedIn && typeof client2.warmChatMetadata === "function") client2.warmChatMetadata();
     if (teamId && state.signedIn && nextScope) {
       if (nextScope !== identityScope) {
         identityScope = nextScope;
@@ -104825,6 +104939,7 @@ async function runTui(client2, terminal = new TuiTerminal(), startupServices) {
   const stopHomeSync = startHomeSync(state, client2, render, () => closed);
   const finish = (result2) => {
     closed = true;
+    activityEpoch++;
     state.homeAbortController?.abort();
     Object.values(state.chatContextAuthoringControls).forEach((control) => control.stop());
     stopHomeSync();
@@ -104852,22 +104967,11 @@ async function runTui(client2, terminal = new TuiTerminal(), startupServices) {
     services: startupServices,
     updated: () => finish({ action: "restart" }),
     ready: () => {
+      workspaceReady = true;
+      syncActivityObserver();
       void loadHomeData(state, client2, render);
       void refreshActivity();
       warmTuiWorkspaceLists(client2);
-      if (state.signedIn && typeof client2.observeChatActivity === "function") {
-        void client2.observeChatActivity(() => {
-          teamChatRefresh?.request();
-          clearTimeout(activityTimer);
-          activityTimer = setTimeout(() => {
-            void refreshActivity();
-          }, 300);
-        }).then((stop) => {
-          if (closed) stop();
-          else stopActivity = stop;
-        }).catch(() => {
-        });
-      }
     }
   });
   terminal.enter();