openmates 0.27.0-alpha.78 → 0.27.0-alpha.79

package/dist/{chunk-XTVACTH6.js → chunk-RIVIWS3I.js}

@@ -6372,10 +6372,10 @@ function approvedCurrentPlan(plan) {
 function linkedOpenTask(task, chatId, planId) {
   return Boolean(task && task.primary_chat_id === chatId && task.plan_id === planId && OPEN_LINKED_TASK_STATES.has(task.status) && Number.isSafeInteger(task.version) && Number(task.version) >= 1);
 }
-async function collectAcceptedCliPlanContext(client2, chatId, options, ownedTaskRecords = []) {
+async function collectAcceptedCliPlanContext(client2, chatId, options, ownedTaskRecords = [], plansRead) {
   const candidates = /* @__PURE__ */ new Map();
   try {
-    const plans = await client2.listUserPlans({ ...options, chatId, activeOnly: false });
+    const plans = await (plansRead ?? client2.listUserPlans({ ...options, chatId, activeOnly: false }));
     for (const plan of plans.filter((plan2) => plan2.primary_chat_id === chatId && approvedCurrentPlan(plan2)).sort((a, b) => Number(b.updated_at ?? 0) - Number(a.updated_at ?? 0) || a.plan_id.localeCompare(b.plan_id))) candidates.set(plan.plan_id, []);
   } catch {
   }
@@ -6421,11 +6421,36 @@ async function collectAcceptedCliPlanContext(client2, chatId, options, ownedTask
   }
   return null;
 }
-async function collectRelatedCliTaskContext(client2, chatId, options, records, nowSeconds3 = Date.now() / 1e3) {
+function taskContextOwner(client2) {
+  if (typeof client2.getSession !== "function") return () => {
+  };
+  const identity3 = () => {
+    const session = client2.getSession();
+    return createHash9("sha256").update(JSON.stringify([
+      session.apiUrl,
+      session.hashedEmail,
+      session.sessionId,
+      session.createdAt,
+      session.masterKeyExportedB64,
+      session.activeTeamId
+    ])).digest("hex");
+  };
+  const owner2 = identity3();
+  return () => {
+    try {
+      if (identity3() === owner2) return;
+    } catch {
+    }
+    throw new Error("Task context workspace changed");
+  };
+}
+async function collectRelatedCliTaskContext(client2, chatId, options, records, nowSeconds3 = Date.now() / 1e3, requiredIds = /* @__PURE__ */ new Set()) {
+  const assertTaskOwner = taskContextOwner(client2);
   const owned = records.filter((record10) => typeof record10.task_id === "string" && record10.task_id.length > 0 && record10.task_id.length <= 128 && Number.isSafeInteger(record10.version) && Number(record10.version) >= 1);
   const linked = owned.filter((record10) => record10.primary_chat_id === chatId && OPEN_LINKED_TASK_STATES.has(record10.status)).sort((a, b) => a.task_id.localeCompare(b.task_id));
   const dependencies = /* @__PURE__ */ new Set();
-  if (typeof client2.getTaskDependencies === "function") await Promise.all(linked.slice(0, 4).map(async (task) => {
+  const dependencySeeds = [...new Map([...linked, ...owned.filter((task) => requiredIds.has(task.task_id))].map((task) => [task.task_id, task])).values()].slice(0, 4);
+  if (typeof client2.getTaskDependencies === "function") await Promise.all(dependencySeeds.map(async (task) => {
     try {
       const result = await client2.getTaskDependencies(task.task_id, options);
       const ref = `task:${task.task_id}`;
@@ -6436,10 +6461,23 @@ async function collectRelatedCliTaskContext(client2, chatId, options, records, n
     } catch {
     }
   }));
+  assertTaskOwner();
+  const presentIds = new Set(owned.map((task) => task.task_id));
+  if (typeof client2.getUserTask === "function") {
+    await Promise.all([...dependencies].filter((id) => !presentIds.has(id)).sort().slice(0, 24).map(async (id) => {
+      try {
+        const row3 = await client2.getUserTask(id, options);
+        assertTaskOwner();
+        if (row3?.task_id === id && Number.isSafeInteger(row3.version) && Number(row3.version) >= 1) owned.push(row3);
+      } catch {
+      }
+    }));
+  }
+  assertTaskOwner();
   const changedAt = (record10) => Number(record10.updated_at ?? record10.created_at ?? 0);
   const priority = (record10) => {
     if (record10.primary_chat_id === chatId && OPEN_LINKED_TASK_STATES.has(record10.status)) return 0;
-    if (dependencies.has(record10.task_id)) return 1;
+    if (dependencies.has(record10.task_id) || requiredIds.has(record10.task_id)) return 1;
     if (record10.status === "in_progress") return 2;
     if (["blocked", "done"].includes(record10.status) && changedAt(record10) >= nowSeconds3 - 1800) return 3;
     return 4;
@@ -6462,9 +6500,12 @@ async function collectRelatedCliTaskContext(client2, chatId, options, records, n
     } catch {
     }
   }
+  assertTaskOwner();
   return candidates;
 }
 async function prepareCliJevContext(client2, chatId, options, supplied = {}, text8, discovery = {}) {
+  const assertTaskOwner = taskContextOwner(client2);
+  const plansRead = discovery.sdkMintedChatId ? Promise.resolve([]) : typeof client2.listUserPlans === "function" ? client2.listUserPlans({ ...options, chatId, activeOnly: false }).catch(() => []) : Promise.resolve([]);
   let candidates = [];
   let active = {};
   let tasks = [];
@@ -6485,18 +6526,39 @@ async function prepareCliJevContext(client2, chatId, options, supplied = {}, tex
       discovery.onProjectRoutingError?.(error);
     }),
     (async () => {
-      const records = await client2.listUserTasks({ ...options, limit: 500 });
-      ownedTaskRecords = records;
-      tasks = await collectRelatedCliTaskContext(client2, chatId, options, records);
+      const taskClient = client2;
+      const [directory, linked] = await Promise.all([
+        taskClient.listUserTaskDiscoveryPage?.(options).catch(() => []) ?? Promise.resolve([]),
+        discovery.sdkMintedChatId ? Promise.resolve([]) : client2.listUserTasks({ ...options, chatId, limit: 100 }).catch(() => [])
+      ]);
+      assertTaskOwner();
+      const records = /* @__PURE__ */ new Map();
+      for (const record10 of [...directory.slice(0, 100), ...linked]) records.set(record10.task_id, record10);
+      const requiredIds = new Set([
+        ...(supplied.related_task_candidates ?? []).map((row3) => row3.task_id)
+      ].filter((id) => typeof id === "string" && id.length > 0 && id.length <= 128).slice(0, 24));
+      if (typeof client2.getUserTask === "function") await Promise.all([...requiredIds].filter((id) => !records.has(id)).map(async (id) => {
+        try {
+          const record10 = await client2.getUserTask(id, options);
+          assertTaskOwner();
+          if (record10?.task_id === id) records.set(id, record10);
+        } catch {
+        }
+      }));
+      assertTaskOwner();
+      ownedTaskRecords = [...records.values()];
+      tasks = await collectRelatedCliTaskContext(client2, chatId, options, ownedTaskRecords, Date.now() / 1e3, requiredIds);
     })().catch(() => {
     })
   ]);
-  const acceptedPlan = discovery.sdkMintedChatId ? null : await collectAcceptedCliPlanContext(client2, chatId, options, ownedTaskRecords).catch(() => null);
+  assertTaskOwner();
+  const acceptedPlan = discovery.sdkMintedChatId ? null : await collectAcceptedCliPlanContext(client2, chatId, options, ownedTaskRecords, plansRead).catch(() => null);
+  assertTaskOwner();
   const catalog = await catalogReady;
   discovery.onRouting?.({
     accepted_plan_context: acceptedPlan,
     project_focus_candidates: (discovery.verifiedProjectCandidates ?? supplied.project_focus_candidates ?? candidates).slice(0, 40),
-    related_task_candidates: (supplied.related_task_candidates ?? tasks).slice(0, 24),
+    related_task_candidates: tasks.slice(0, 24),
     project_focus_catalog: catalog.slice(0, 20)
   });
   await activeReady;
@@ -6518,10 +6580,11 @@ async function prepareCliJevContext(client2, chatId, options, supplied = {}, tex
     documentIds.add(identity3);
     customDocuments.push(rule);
   }
+  assertTaskOwner();
   return {
     accepted_plan_context: acceptedPlan,
     project_focus_candidates: (discovery.verifiedProjectCandidates ?? supplied.project_focus_candidates ?? candidates).slice(0, 40),
-    related_task_candidates: (supplied.related_task_candidates ?? tasks).slice(0, 24),
+    related_task_candidates: tasks.slice(0, 24),
     custom_memory_documents: customDocuments,
     project_focus_catalog: current2 ? (supplied.project_focus_catalog ?? loaded.project_focus_catalog ?? []).slice(0, 20) : [],
     project_focus_documents: current2 ? (supplied.project_focus_documents ?? loaded.project_focus_documents ?? []).slice(0, 20) : [],
@@ -11254,6 +11317,7 @@ var OpenMatesClient = class _OpenMatesClient {
   ownTeamDisplayNames = /* @__PURE__ */ new Map();
   pendingWhoAmIAuthHandoff = null;
   personalMemoryAuthHandoff = null;
+  scopedChatHistory = /* @__PURE__ */ new WeakMap();
   personalMemoryReadInFlight = null;
   interactiveAdmissionEnabled = false;
   interactiveAdmissionOwner = null;
@@ -14541,8 +14605,11 @@ var OpenMatesClient = class _OpenMatesClient {
     const accountCurrent = this.captureTeamAccountOwner().isCurrent;
     const teamId = this.resolveTeamContext(options);
     const masterKey = Buffer.from(this.getMasterKeyBytes());
-    const localCache = options.preferCache ? loadSyncCache(teamId) : null;
-    let cache = localCache ?? (options.preferCache ? {
+    if (options.freshChatOnly && !CANONICAL_UUID_PATTERN.test(query)) {
+      throw new Error("Fresh scoped history requires a full chat UUID.");
+    }
+    const localCache = options.preferCache || options.freshChatOnly ? loadSyncCache(teamId) : null;
+    let cache = localCache ?? (options.preferCache || options.freshChatOnly ? {
       syncedAt: 0,
       totalChatCount: 0,
       loadedChatCount: 0,
@@ -14560,7 +14627,28 @@ var OpenMatesClient = class _OpenMatesClient {
     const wrappingKey = localTeamKey ? base64ToBytes(localTeamKey) : await this.getChatWrappingKey(teamId, masterKey);
     let found;
     let fetchedMetadata = false;
-    try {
+    if (options.freshChatOnly) {
+      const response = await this.http.post(
+        this.appendTeamQuery("/v1/chats/metadata/batch", { teamId }),
+        { chat_ids: [query] },
+        this.getCliRequestHeaders()
+      );
+      current2();
+      options.signal?.throwIfAborted();
+      if (!response.ok) throw new Error(`Chat metadata failed with HTTP ${response.status}`);
+      const details = response.data.chats.find((chat) => String(chat.id ?? "") === query);
+      if (!details) throw new Error(`Chat '${query}' not found.`);
+      found = { details, messages: [] };
+      fetchedMetadata = true;
+      cache = {
+        ...cache,
+        chats: [...cache.chats.filter((chat) => String(chat.details.id ?? "") !== query), found],
+        chatKeyWrappers: [
+          ...cache.chatKeyWrappers ?? [],
+          ...Array.isArray(details.chat_key_wrappers) ? details.chat_key_wrappers : []
+        ]
+      };
+    } else try {
       found = await this.resolveCachedChatForQuery(query, cache, wrappingKey, teamId);
     } catch (error) {
       if (!options.preferCache || !(error instanceof Error) || !/^Chat '.*' not found\./.test(error.message)) throw error;
@@ -14582,7 +14670,7 @@ var OpenMatesClient = class _OpenMatesClient {
       ] };
     }
     const foundChatId = String(found.details.id ?? "");
-    if (!options.preferCache && foundChatId && getClientMessagesVersionForSync(found) === 0) {
+    if (!options.preferCache && !options.freshChatOnly && foundChatId && getClientMessagesVersionForSync(found) === 0) {
       cache = await this.ensureSynced(true, [foundChatId], options, true);
       found = cache.chats.find((c) => String(c.details.id ?? "") === foundChatId) ?? found;
     }
@@ -14668,7 +14756,11 @@ var OpenMatesClient = class _OpenMatesClient {
     const messages = coalesceMemoryRequestMessages(decoded);
     current2();
     if (options.preferCache && rawMessages !== found.messages) persistMessages(rawMessages);
-    return { chat: chatItem, messages, ...historyIncomplete ? { historyIncomplete: true } : {} };
+    const result = { chat: chatItem, messages, ...historyIncomplete ? { historyIncomplete: true } : {} };
+    if (options.freshChatOnly) {
+      this.scopedChatHistory.set(result, { ...cache, chats: cache.chats.map((chat) => chat === found ? { ...found, messages: rawMessages } : chat) });
+    }
+    return result;
   }
   /** Warm the latest recent windows in the background; only ciphertext reaches disk. */
   async cacheRecentChatMessages(options = {}) {
@@ -16176,15 +16268,10 @@ var OpenMatesClient = class _OpenMatesClient {
   async replayCurrentTurnRecoveryOutputPages(ws, ownerId2, pages, cache, teamId, chatId) {
     const isActive = (output) => output.root_chat_id === chatId || output.target_chat_id === chatId;
     const active = pages.map((page) => page.filter(isActive));
-    const unrelated = pages.map((page) => page.filter((output) => !isActive(output)));
     if (active.some((page) => page.length > 0)) {
       await this.replayRecoveryOutputPages(ws, ownerId2, active, cache, teamId);
       clearSyncCache(teamId);
     }
-    if (unrelated.some((page) => page.length > 0)) {
-      await this.replayRecoveryOutputPages(ws, ownerId2, unrelated, cache, teamId, () => {
-      });
-    }
   }
   async sendMessage(params) {
     const preWsStartedAt = performance.now();
@@ -16224,1579 +16311,1506 @@ var OpenMatesClient = class _OpenMatesClient {
     } else {
       chatId = params.chatId;
     }
-    let finalMessage = params.message;
-    if (hasRememberMessageReference(finalMessage)) {
-      const rememberedHistory = (params.messageHistory ?? []).map((message) => ({ id: message.message_id, content: message.content })).filter((message) => Boolean(message.id) && typeof message.content === "string");
-      finalMessage = rewriteRememberMessageReferences(finalMessage, rememberedHistory);
-    }
-    if (params.chatId && !params.incognito && hasRememberMessageReference(finalMessage)) {
-      const { messages } = await this.getChatMessages(chatId, { personal: !teamId, teamId });
-      finalMessage = rewriteRememberMessageReferences(finalMessage, messages);
-    }
-    const shouldWaitForAi = shouldWaitForTeamAi(finalMessage, teamId);
-    const explicitTasksAppSkill = messageExplicitlyRequestsTasksAppSkill(finalMessage);
-    const taskUpdateJobsEnabled = params.taskUpdateJobs !== false && !explicitTasksAppSkill;
-    const sendSocketOptions = {
-      taskUpdateJobs: taskUpdateJobsEnabled,
-      projectFileJobs: !params.incognito,
-      remoteCommandJobs: !params.incognito,
-      interactiveHuman: params.interactiveHuman === true && this.interactiveViewerAllowed && process.stdin.isTTY === true && process.stdout.isTTY === true
+    const historyAbort = new AbortController();
+    let savedPrivacyHistoryRead = null;
+    let historySnapshotOwner = null;
+    const readSavedPrivacyHistory = () => {
+      if (!savedPrivacyHistoryRead) {
+        savedPrivacyHistoryRead = withHttpAbortSignal(historyAbort.signal, () => this.getChatMessages(
+          chatId,
+          { personal: !teamId, teamId, freshChatOnly: true, signal: historyAbort.signal }
+        )).then((history) => {
+          historySnapshotOwner = this.preparedChatOwner(this.requireSession(), teamId);
+          return history;
+        });
+        void savedPrivacyHistoryRead.catch(() => {
+        });
+      }
+      return savedPrivacyHistoryRead;
     };
-    const independentKeyOwner = this.preparedChatOwner(this.requireSession(), teamId);
-    const independentNewChatKey = !params.incognito && !params.chatId ? (async () => {
-      if (ownsPreparedId && this.preparedChatKey?.chatId === chatId) {
-        const prepared = await this.preparedChatKey.value;
-        if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(prepared.wrappingKey)).digest("hex");
-        return prepared;
+    const joinSavedPrivacyHistory = async () => {
+      const history = await readSavedPrivacyHistory();
+      if (!historySnapshotOwner || !this.preparedChatOwnerCurrent(historySnapshotOwner, teamId)) {
+        throw new Error("Chat workspace changed during history preparation.");
       }
-      const wrappingKey = await this.getChatWrappingKey(teamId, this.getMasterKeyBytes());
-      if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(wrappingKey)).digest("hex");
-      const key = new Uint8Array(randomBytes4(32));
-      return { key, wrappingKey, encryptedKey: await encryptBytesWithAesGcm(key, wrappingKey) };
-    })() : null;
-    void independentNewChatKey?.catch(() => {
-    });
-    const independentRecoveryKeypair = independentNewChatKey?.then((prepared) => deriveChatCompletionRecoveryKeypair(
-      Buffer.from(prepared.key).toString("base64url"),
-      chatId,
-      1
-    ));
-    void independentRecoveryKeypair?.catch(() => {
-    });
-    const privacyTurnId = params.incognito ? null : randomUUID9();
-    let conditionalPrivacyReceipt = null;
-    let compiledPrivacy;
-    let memorySocket = null;
-    let socketSnapshotAttempted = false;
-    let socketSnapshotResultRows = null;
-    let socketProjectCandidateRows = null;
-    let verifiedProjectCandidates = null;
-    let deferredProjectDirectory = false;
-    let usePersonalRoutingDirectory = false;
-    let projectCandidatesReadyFromSendStartMs = null;
-    let socketMemoryReceipt = null;
-    const socketMemoryOptionsKey = () => JSON.stringify([
-      this.sendSocketOptionsKey(sendSocketOptions),
-      params.projectId ?? null,
-      params.teamId ?? null,
-      params.personal === true,
-      params.incognito === true,
-      params.autoApproveMemories === true,
-      params.piiDetection !== false,
-      params.learningMode?.enabled ?? null,
-      params.learningMode?.ageGroup ?? null
-    ]);
-    const memoryStartedAt = performance.now();
-    let availableMemories = params.memorySnapshot ?? [];
-    let memoryCountsLoaded = false;
-    let memoryMetadataKeys = [];
-    if (!params.incognito) {
-      try {
-        if (!teamId) {
-          try {
-            socketSnapshotAttempted = true;
-            memorySocket = (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient(sendSocketOptions);
-            const ownerKey = JSON.stringify([
-              this.sendSocketOwnerKey(this.requireSession(), teamId),
-              authCookieFingerprint(this.http.getCookieMap())
-            ]);
-            const conditionalSupported = await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v2");
-            const combinedSupported = conditionalSupported || await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v1");
-            const supported = combinedSupported || await memorySocket.ws.waitForServerCapability("personal_memory_snapshot_v1");
-            if (supported) {
-              const deferProjectDirectory = sdkMintedChatId && !teamId && !params.incognito && !params.projectId && shouldWaitForAi && memorySocket.ws.supportsServerCapability("personal_memory_snapshot_v1") && memorySocket.ws.supportsServerCapability("chat_turn_admit_v1") && memorySocket.ws.supportsServerCapability("chat_turn_context_v1");
-              deferredProjectDirectory = deferProjectDirectory;
-              usePersonalRoutingDirectory = deferProjectDirectory && memorySocket.ws.supportsServerCapability("personal_project_routing_directory_v1");
-              traceSendTiming("snapshot_request");
-              const privacyOwnerKey = this.preparedPrivacyOwnerKey(null);
-              const preferencesKey = JSON.stringify(await readPrivacyPreferences());
-              const preparedBundle = conditionalSupported ? this.preparedPrivacy.get(privacyOwnerKey, preferencesKey) : null;
-              const conditional = conditionalSupported ? await memorySocket.ws.requestPersonalSendContextSnapshotV2({
-                request_id: randomUUID9(),
-                purpose: "send",
-                turn_id: privacyTurnId,
-                ...preparedBundle ? { known_generation: preparedBundle.generation } : {}
-              }) : null;
-              const combined = !conditional && combinedSupported && !deferProjectDirectory ? await memorySocket.ws.requestPersonalSendContextSnapshot(randomUUID9()) : null;
-              const snapshot2 = conditional ? conditional.personal_memories ?? null : combined?.personal_memories ?? await memorySocket.ws.requestPersonalMemorySnapshot(randomUUID9());
-              traceSendTiming("snapshot_ready");
-              if (conditional || combined) {
-                socketProjectCandidateRows = (conditional ?? combined).project_candidates;
-                verifiedProjectCandidates = await decodePersonalProjectCandidates(this, (conditional ?? combined).project_candidates);
-                projectCandidatesReadyFromSendStartMs = Math.round(performance.now() - preWsStartedAt);
-              }
-              if (conditional?.unchanged) {
-                if (!preparedBundle || conditional.privacy_generation !== preparedBundle.generation) throw new Error("Unchanged privacy snapshot has no matching prepared bundle.");
-                availableMemories = preparedBundle.memories;
-                compiledPrivacy = preparedBundle.privacy;
-                socketSnapshotResultRows = [];
-              } else {
-                if (!snapshot2) throw new Error("Full Personal privacy snapshot is required.");
-                socketSnapshotResultRows = snapshot2.memories;
-                availableMemories = await this.listMemoriesUnshared({ personal: true }, snapshot2);
+      return history;
+    };
+    try {
+      let finalMessage = params.message;
+      if (hasRememberMessageReference(finalMessage)) {
+        const rememberedHistory = (params.messageHistory ?? []).map((message) => ({ id: message.message_id, content: message.content })).filter((message) => Boolean(message.id) && typeof message.content === "string");
+        finalMessage = rewriteRememberMessageReferences(finalMessage, rememberedHistory);
+      }
+      if (params.chatId && !params.incognito && hasRememberMessageReference(finalMessage)) {
+        const { messages } = await joinSavedPrivacyHistory();
+        finalMessage = rewriteRememberMessageReferences(finalMessage, messages);
+      }
+      const shouldWaitForAi = shouldWaitForTeamAi(finalMessage, teamId);
+      const explicitTasksAppSkill = messageExplicitlyRequestsTasksAppSkill(finalMessage);
+      const taskUpdateJobsEnabled = params.taskUpdateJobs !== false && !explicitTasksAppSkill;
+      const sendSocketOptions = {
+        taskUpdateJobs: taskUpdateJobsEnabled,
+        projectFileJobs: !params.incognito,
+        remoteCommandJobs: !params.incognito,
+        interactiveHuman: params.interactiveHuman === true && this.interactiveViewerAllowed && process.stdin.isTTY === true && process.stdout.isTTY === true
+      };
+      const independentKeyOwner = this.preparedChatOwner(this.requireSession(), teamId);
+      const independentNewChatKey = !params.incognito && !params.chatId ? (async () => {
+        if (ownsPreparedId && this.preparedChatKey?.chatId === chatId) {
+          const prepared = await this.preparedChatKey.value;
+          if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(prepared.wrappingKey)).digest("hex");
+          return prepared;
+        }
+        const wrappingKey = await this.getChatWrappingKey(teamId, this.getMasterKeyBytes());
+        if (teamId) independentKeyOwner.teamKeyFingerprint = createHash14("sha256").update(bytesToBase64(wrappingKey)).digest("hex");
+        const key = new Uint8Array(randomBytes4(32));
+        return { key, wrappingKey, encryptedKey: await encryptBytesWithAesGcm(key, wrappingKey) };
+      })() : null;
+      void independentNewChatKey?.catch(() => {
+      });
+      const independentRecoveryKeypair = independentNewChatKey?.then((prepared) => deriveChatCompletionRecoveryKeypair(
+        Buffer.from(prepared.key).toString("base64url"),
+        chatId,
+        1
+      ));
+      void independentRecoveryKeypair?.catch(() => {
+      });
+      const privacyTurnId = params.incognito ? null : randomUUID9();
+      let conditionalPrivacyReceipt = null;
+      let compiledPrivacy;
+      let memorySocket = null;
+      let socketSnapshotAttempted = false;
+      let socketSnapshotResultRows = null;
+      let socketProjectCandidateRows = null;
+      let verifiedProjectCandidates = null;
+      let deferredProjectDirectory = false;
+      let usePersonalRoutingDirectory = false;
+      let projectCandidatesReadyFromSendStartMs = null;
+      let socketMemoryReceipt = null;
+      const socketMemoryOptionsKey = () => JSON.stringify([
+        this.sendSocketOptionsKey(sendSocketOptions),
+        params.projectId ?? null,
+        params.teamId ?? null,
+        params.personal === true,
+        params.incognito === true,
+        params.autoApproveMemories === true,
+        params.piiDetection !== false,
+        params.learningMode?.enabled ?? null,
+        params.learningMode?.ageGroup ?? null
+      ]);
+      if (!params.incognito && params.chatId) readSavedPrivacyHistory();
+      const memoryStartedAt = performance.now();
+      let availableMemories = params.memorySnapshot ?? [];
+      let memoryCountsLoaded = false;
+      let memoryMetadataKeys = [];
+      if (!params.incognito) {
+        try {
+          if (!teamId) {
+            try {
+              socketSnapshotAttempted = true;
+              memorySocket = (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient(sendSocketOptions);
+              const ownerKey = JSON.stringify([
+                this.sendSocketOwnerKey(this.requireSession(), teamId),
+                authCookieFingerprint(this.http.getCookieMap())
+              ]);
+              const conditionalSupported = await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v2");
+              const combinedSupported = conditionalSupported || await memorySocket.ws.waitForServerCapability("personal_send_context_snapshot_v1");
+              const supported = combinedSupported || await memorySocket.ws.waitForServerCapability("personal_memory_snapshot_v1");
+              if (supported) {
+                const deferProjectDirectory = sdkMintedChatId && !teamId && !params.incognito && !params.projectId && shouldWaitForAi && memorySocket.ws.supportsServerCapability("personal_memory_snapshot_v1") && memorySocket.ws.supportsServerCapability("chat_turn_admit_v1") && memorySocket.ws.supportsServerCapability("chat_turn_context_v1");
+                deferredProjectDirectory = deferProjectDirectory;
+                usePersonalRoutingDirectory = deferProjectDirectory && memorySocket.ws.supportsServerCapability("personal_project_routing_directory_v1");
+                traceSendTiming("snapshot_request");
+                const privacyOwnerKey = this.preparedPrivacyOwnerKey(null);
+                const preferencesKey = JSON.stringify(await readPrivacyPreferences());
+                const preparedBundle = conditionalSupported ? this.preparedPrivacy.get(privacyOwnerKey, preferencesKey) : null;
+                const conditional = conditionalSupported ? await memorySocket.ws.requestPersonalSendContextSnapshotV2({
+                  request_id: randomUUID9(),
+                  purpose: "send",
+                  turn_id: privacyTurnId,
+                  ...preparedBundle ? { known_generation: preparedBundle.generation } : {}
+                }) : null;
+                const combined = !conditional && combinedSupported && !deferProjectDirectory ? await memorySocket.ws.requestPersonalSendContextSnapshot(randomUUID9()) : null;
+                const snapshot2 = conditional ? conditional.personal_memories ?? null : combined?.personal_memories ?? await memorySocket.ws.requestPersonalMemorySnapshot(randomUUID9());
+                traceSendTiming("snapshot_ready");
+                if (conditional || combined) {
+                  socketProjectCandidateRows = (conditional ?? combined).project_candidates;
+                  verifiedProjectCandidates = await decodePersonalProjectCandidates(this, (conditional ?? combined).project_candidates);
+                  projectCandidatesReadyFromSendStartMs = Math.round(performance.now() - preWsStartedAt);
+                }
+                if (conditional?.unchanged) {
+                  if (!preparedBundle || conditional.privacy_generation !== preparedBundle.generation) throw new Error("Unchanged privacy snapshot has no matching prepared bundle.");
+                  availableMemories = preparedBundle.memories;
+                  compiledPrivacy = preparedBundle.privacy;
+                  socketSnapshotResultRows = [];
+                } else {
+                  if (!snapshot2) throw new Error("Full Personal privacy snapshot is required.");
+                  socketSnapshotResultRows = snapshot2.memories;
+                  availableMemories = await this.listMemoriesUnshared({ personal: true }, snapshot2);
+                  if (conditional) {
+                    this.preparedPrivacy.set(privacyOwnerKey, preferencesKey, conditional.privacy_generation, availableMemories);
+                    compiledPrivacy = this.preparedPrivacy.get(privacyOwnerKey, preferencesKey)?.privacy;
+                  }
+                }
                 if (conditional) {
-                  this.preparedPrivacy.set(privacyOwnerKey, preferencesKey, conditional.privacy_generation, availableMemories);
-                  compiledPrivacy = this.preparedPrivacy.get(privacyOwnerKey, preferencesKey)?.privacy;
+                  if (!conditional.receipt_id || conditional.turn_id !== privacyTurnId) throw new Error("Conditional privacy snapshot has no valid send receipt.");
+                  conditionalPrivacyReceipt = {
+                    receiptId: conditional.receipt_id,
+                    generation: conditional.privacy_generation,
+                    preferencesKey,
+                    epoch: this.preparedPrivacyEpoch
+                  };
                 }
-              }
-              if (conditional) {
-                if (!conditional.receipt_id || conditional.turn_id !== privacyTurnId) throw new Error("Conditional privacy snapshot has no valid send receipt.");
-                conditionalPrivacyReceipt = {
-                  receiptId: conditional.receipt_id,
-                  generation: conditional.privacy_generation,
-                  preferencesKey,
-                  epoch: this.preparedPrivacyEpoch
+                traceSendTiming("memory_decrypt_ready");
+                if (!memorySocket.ws.isOpen() || JSON.stringify([
+                  this.sendSocketOwnerKey(this.requireSession(), teamId),
+                  authCookieFingerprint(this.http.getCookieMap())
+                ]) !== ownerKey) {
+                  throw new Error("Personal Memory snapshot owner or socket changed during preparation.");
+                }
+                socketMemoryReceipt = {
+                  ws: memorySocket.ws,
+                  snapshot: availableMemories,
+                  resultRows: socketSnapshotResultRows,
+                  projectRows: socketProjectCandidateRows,
+                  candidates: verifiedProjectCandidates,
+                  ownerKey,
+                  optionsKey: socketMemoryOptionsKey(),
+                  used: false
                 };
+              } else {
+                memorySocket.ws.close();
+                memorySocket = null;
+                socketSnapshotAttempted = false;
               }
-              traceSendTiming("memory_decrypt_ready");
-              if (!memorySocket.ws.isOpen() || JSON.stringify([
-                this.sendSocketOwnerKey(this.requireSession(), teamId),
-                authCookieFingerprint(this.http.getCookieMap())
-              ]) !== ownerKey) {
-                throw new Error("Personal Memory snapshot owner or socket changed during preparation.");
-              }
-              socketMemoryReceipt = {
-                ws: memorySocket.ws,
-                snapshot: availableMemories,
-                resultRows: socketSnapshotResultRows,
-                projectRows: socketProjectCandidateRows,
-                candidates: verifiedProjectCandidates,
-                ownerKey,
-                optionsKey: socketMemoryOptionsKey(),
-                used: false
-              };
-            } else {
-              memorySocket.ws.close();
+            } catch (error) {
+              memorySocket?.ws.close();
               memorySocket = null;
-              socketSnapshotAttempted = false;
+              throw error;
             }
-          } catch (error) {
-            memorySocket?.ws.close();
-            memorySocket = null;
-            throw error;
           }
-        }
-        if (!socketMemoryReceipt) availableMemories = teamId && params.memorySnapshot ? params.memorySnapshot : await this.listMemoriesUnshared({ teamId }, void 0, !teamId);
-        memoryCountsLoaded = true;
-        memoryMetadataKeys = [
-          ...new Set(
-            availableMemories.filter((memory) => memory.app_id && memory.item_type).map((memory) => `${memory.app_id}-${memory.item_type}`)
-          )
-        ];
-      } catch (error) {
-        if (socketSnapshotAttempted || !teamId) throw error;
-        if (params.autoApproveMemories) {
-          const message = error instanceof Error ? error.message : String(error);
-          throw new Error(`Failed to load memories for auto-approval: ${message}`);
+          if (!socketMemoryReceipt) availableMemories = teamId && params.memorySnapshot ? params.memorySnapshot : await this.listMemoriesUnshared({ teamId }, void 0, !teamId);
+          memoryCountsLoaded = true;
+          memoryMetadataKeys = [
+            ...new Set(
+              availableMemories.filter((memory) => memory.app_id && memory.item_type).map((memory) => `${memory.app_id}-${memory.item_type}`)
+            )
+          ];
+        } catch (error) {
+          if (socketSnapshotAttempted || !teamId) throw error;
+          if (params.autoApproveMemories) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load memories for auto-approval: ${message}`);
+          }
         }
       }
-    }
-    try {
-      const snapshotAuthHandoff = this.personalMemoryAuthHandoff?.snapshot.deref() === availableMemories ? this.personalMemoryAuthHandoff.auth : null;
-      this.personalMemoryAuthHandoff = null;
-      this.pendingWhoAmIAuthHandoff = null;
-      const personalSendAuthHandoff = !teamId && !params.incognito ? snapshotAuthHandoff : null;
-      const memoryPrepMs = Math.round(performance.now() - memoryStartedAt);
-      const privacyStartedAt = performance.now();
-      traceSendTiming("privacy_begin");
-      const savedPrivacyHistory = !params.incognito && params.chatId ? await this.getChatMessages(chatId, teamId ? { teamId } : { personal: true }) : null;
-      let piiMappings = [...savedPrivacyHistory?.messages.flatMap((message) => (message.piiMappings ?? []).map((mapping) => ({ ...mapping, type: mapping.type ?? "OTHER" }))) ?? [], ...params.piiMappings ?? []];
       try {
-        if (params.piiDetection !== false) {
-          const prepared = await prepareCliMessagePrivacy(finalMessage, availableMemories, piiMappings, { kind: "message" }, params.onPrivacyProgress, compiledPrivacy);
-          finalMessage = prepared.message;
-          piiMappings = prepared.mappings;
-          for (const embed of params.preparedEmbeds ?? []) {
-            if (!["code-code", "docs-doc", "sheets-sheet"].includes(embed.type)) continue;
-            const decoded = toonDecode(embed.content);
-            for (const field3 of ["code", "html", "table", "text"]) if (typeof decoded[field3] === "string") {
-              const value = await prepareCliMessagePrivacy(decoded[field3], availableMemories, piiMappings, { kind: "document" }, params.onPrivacyProgress, compiledPrivacy);
-              decoded[field3] = value.message;
-              piiMappings = value.mappings;
-            }
-            embed.content = toonEncodeContent(decoded);
-            const content = decoded.code ?? decoded.table ?? decoded.html ?? decoded.text;
-            if (typeof content === "string") {
-              embed.contentHash = createHash14("sha256").update(content).digest("hex");
-              embed.textLengthChars = content.length;
+        const snapshotAuthHandoff = this.personalMemoryAuthHandoff?.snapshot.deref() === availableMemories ? this.personalMemoryAuthHandoff.auth : null;
+        this.personalMemoryAuthHandoff = null;
+        this.pendingWhoAmIAuthHandoff = null;
+        const personalSendAuthHandoff = !teamId && !params.incognito ? snapshotAuthHandoff : null;
+        const memoryPrepMs = Math.round(performance.now() - memoryStartedAt);
+        const privacyStartedAt = performance.now();
+        traceSendTiming("privacy_begin");
+        const savedPrivacyHistory = !params.incognito && params.chatId ? await joinSavedPrivacyHistory() : null;
+        let piiMappings = [...savedPrivacyHistory?.messages.flatMap((message) => (message.piiMappings ?? []).map((mapping) => ({ ...mapping, type: mapping.type ?? "OTHER" }))) ?? [], ...params.piiMappings ?? []];
+        try {
+          if (params.piiDetection !== false) {
+            const prepared = await prepareCliMessagePrivacy(finalMessage, availableMemories, piiMappings, { kind: "message" }, params.onPrivacyProgress, compiledPrivacy);
+            finalMessage = prepared.message;
+            piiMappings = prepared.mappings;
+            for (const embed of params.preparedEmbeds ?? []) {
+              if (!["code-code", "docs-doc", "sheets-sheet"].includes(embed.type)) continue;
+              const decoded = toonDecode(embed.content);
+              for (const field3 of ["code", "html", "table", "text"]) if (typeof decoded[field3] === "string") {
+                const value = await prepareCliMessagePrivacy(decoded[field3], availableMemories, piiMappings, { kind: "document" }, params.onPrivacyProgress, compiledPrivacy);
+                decoded[field3] = value.message;
+                piiMappings = value.mappings;
+              }
+              embed.content = toonEncodeContent(decoded);
+              const content = decoded.code ?? decoded.table ?? decoded.html ?? decoded.text;
+              if (typeof content === "string") {
+                embed.contentHash = createHash14("sha256").update(content).digest("hex");
+                embed.textLengthChars = content.length;
+              }
             }
           }
+          params.onPrivacyPrepared?.(finalMessage);
+        } catch (error) {
+          memorySocket?.ws.close();
+          throw error;
         }
-        params.onPrivacyPrepared?.(finalMessage);
-      } catch (error) {
-        memorySocket?.ws.close();
-        throw error;
-      }
-      const privacyPrepMs = Math.round(performance.now() - privacyStartedAt);
-      traceSendTiming("privacy_ready");
-      const preWsMs = Math.round(performance.now() - preWsStartedAt);
-      const contextSession = this.requireSession();
-      const {
-        apiUrl: contextApiUrl,
-        hashedEmail: contextHashedEmail,
-        sessionId: contextSessionId,
-        createdAt: contextSessionCreatedAt,
-        masterKeyExportedB64: contextMasterKey,
-        activeTeamId: contextActiveTeamId
-      } = contextSession;
-      const contextScope = { teamId, personal: !teamId };
-      const suppliedContext = deferredProjectDirectory ? { ...params.jevContext, project_focus_candidates: void 0 } : params.jevContext;
-      const contextStartedAt = Date.now();
-      let publishRouting;
-      const routingContext = new Promise((resolve20) => {
-        publishRouting = resolve20;
-      });
-      let publishProjectRouting;
-      let rejectProjectRouting;
-      const projectRoutingContext = new Promise((resolve20, reject) => {
-        publishProjectRouting = resolve20;
-        rejectProjectRouting = reject;
-      });
-      void projectRoutingContext.catch(() => {
-      });
-      const publishProjectRoutingTimed = (context) => {
-        projectCandidatesReadyFromSendStartMs ??= Math.round(performance.now() - preWsStartedAt);
-        publishProjectRouting(deferredProjectDirectory ? { ...context, project_focus_candidates: context.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) } : context);
-      };
-      let recoveryMs = 0;
-      const contextOwnerIsCurrent = () => {
-        const current2 = this.session;
-        return Boolean(current2 && current2.apiUrl === contextApiUrl && current2.hashedEmail === contextHashedEmail && current2.sessionId === contextSessionId && current2.createdAt === contextSessionCreatedAt && current2.masterKeyExportedB64 === contextMasterKey && current2.activeTeamId === contextActiveTeamId);
-      };
-      const earlyContextAbort = new AbortController();
-      const earlyContext = !params.incognito && !params.chatId && !params.projectId ? withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
-        sdkMintedChatId,
-        onRouting: publishRouting,
-        verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
-        usePersonalRoutingDirectory,
-        onProjectRouting: publishProjectRoutingTimed,
-        onProjectRoutingError: rejectProjectRouting
-      })).then(
-        (value) => ({ ok: true, value, elapsedMs: Date.now() - contextStartedAt }),
-        (error) => ({ ok: false, error, elapsedMs: Date.now() - contextStartedAt })
-      ) : null;
-      const authSocketStartedAt = Date.now();
-      let opened;
-      try {
-        opened = memorySocket ?? (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient({ ...sendSocketOptions, personalSendAuthHandoff });
-      } catch (error) {
-        earlyContextAbort.abort();
-        if (earlyContext) await earlyContext;
-        throw error;
-      }
-      const { ws, ownerId: ownerId2 } = opened;
-      const consumeSocketMemoryReceipt = async () => {
-        if (!socketMemoryReceipt) return;
-        const receipt = socketMemoryReceipt;
-        if (receipt.used || receipt.ws !== ws || receipt.snapshot !== availableMemories || receipt.resultRows !== socketSnapshotResultRows || receipt.projectRows !== socketProjectCandidateRows || receipt.candidates !== verifiedProjectCandidates || !ws.isOpen() || receipt.optionsKey !== socketMemoryOptionsKey()) {
-          throw new Error("Personal Memory snapshot socket receipt is invalid.");
-        }
-        await this.withFreshStoredSession(async () => {
-          if (!ws.isOpen() || JSON.stringify([
-            this.sendSocketOwnerKey(this.requireSession(), teamId),
-            authCookieFingerprint(this.http.getCookieMap())
-          ]) !== receipt.ownerKey) {
-            throw new Error("Personal Memory snapshot owner changed before send.");
-          }
+        const privacyPrepMs = Math.round(performance.now() - privacyStartedAt);
+        traceSendTiming("privacy_ready");
+        const preWsMs = Math.round(performance.now() - preWsStartedAt);
+        const contextSession = this.requireSession();
+        const {
+          apiUrl: contextApiUrl,
+          hashedEmail: contextHashedEmail,
+          sessionId: contextSessionId,
+          createdAt: contextSessionCreatedAt,
+          masterKeyExportedB64: contextMasterKey,
+          activeTeamId: contextActiveTeamId
+        } = contextSession;
+        const contextScope = { teamId, personal: !teamId };
+        const suppliedContext = deferredProjectDirectory ? { ...params.jevContext, project_focus_candidates: void 0 } : params.jevContext;
+        const contextStartedAt = Date.now();
+        let publishRouting;
+        const routingContext = new Promise((resolve20) => {
+          publishRouting = resolve20;
+        });
+        let publishProjectRouting;
+        let rejectProjectRouting;
+        const projectRoutingContext = new Promise((resolve20, reject) => {
+          publishProjectRouting = resolve20;
+          rejectProjectRouting = reject;
         });
-        if (conditionalPrivacyReceipt && (conditionalPrivacyReceipt.epoch !== this.preparedPrivacyEpoch || conditionalPrivacyReceipt.preferencesKey !== JSON.stringify(await readPrivacyPreferences()))) {
-          throw new Error("Privacy preferences changed before send; prepare the turn again.");
+        void projectRoutingContext.catch(() => {
+        });
+        const publishProjectRoutingTimed = (context) => {
+          projectCandidatesReadyFromSendStartMs ??= Math.round(performance.now() - preWsStartedAt);
+          publishProjectRouting(deferredProjectDirectory ? { ...context, project_focus_candidates: context.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) } : context);
+        };
+        let recoveryMs = 0;
+        const contextOwnerIsCurrent = () => {
+          const current2 = this.session;
+          return Boolean(current2 && current2.apiUrl === contextApiUrl && current2.hashedEmail === contextHashedEmail && current2.sessionId === contextSessionId && current2.createdAt === contextSessionCreatedAt && current2.masterKeyExportedB64 === contextMasterKey && current2.activeTeamId === contextActiveTeamId);
+        };
+        const earlyContextAbort = new AbortController();
+        const earlyContext = !params.incognito && !params.chatId && !params.projectId ? withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
+          sdkMintedChatId,
+          onRouting: publishRouting,
+          verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
+          usePersonalRoutingDirectory,
+          onProjectRouting: publishProjectRoutingTimed,
+          onProjectRoutingError: rejectProjectRouting
+        })).then(
+          (value) => ({ ok: true, value, elapsedMs: Date.now() - contextStartedAt }),
+          (error) => ({ ok: false, error, elapsedMs: Date.now() - contextStartedAt })
+        ) : null;
+        const authSocketStartedAt = Date.now();
+        let opened;
+        try {
+          opened = memorySocket ?? (sendSocketOptions.interactiveHuman ? await this.takePreparedSendSocket(sendSocketOptions, teamId) : null) ?? await this.openWsClient({ ...sendSocketOptions, personalSendAuthHandoff });
+        } catch (error) {
+          earlyContextAbort.abort();
+          if (earlyContext) await earlyContext;
+          throw error;
         }
-        receipt.used = true;
-      };
-      let metadataTransportOwned = false;
-      let metadataHandoffReady = false;
-      let metadataHandoffSuggestion = null;
-      let initialHeaderWork = null;
-      let initialHeaderNotice = null;
-      let initialAdmissionDurable = false;
-      let initialHeaderStopped = false;
-      let initialTitleScheduled;
-      let initialIconScheduled;
-      let persistOptionalHeader;
-      let optionalMetadata = null;
-      const socketReadyForSendAt = performance.now();
-      let capabilitiesWaitMs = 0;
-      let keyWaitMs = 0;
-      let recoveryKeypairMs = 0;
-      let encryptPayloadMs = 0;
-      if (!params.incognito && !ownerId2) {
-        earlyContextAbort.abort();
-        ws.close();
-        if (earlyContext) await earlyContext;
-        throw new Error("Authenticated user identity is required for saved chat recovery.");
-      }
-      const authSocketMs = Date.now() - authSocketStartedAt;
-      const mayDeferRecovery = !params.incognito && sdkMintedChatId && !teamId && !params.projectId && shouldWaitForAi;
-      let recoveryDiscovery = null;
-      let recoveryDiscoveryError = null;
-      let contextAckRejection = null;
-      let removeContextAckWatcher = null;
-      try {
-        if (!params.incognito) {
-          try {
-            ws.send("chat_metadata_warmup", teamId ? { team_id: teamId } : {});
-          } catch {
+        const { ws, ownerId: ownerId2 } = opened;
+        const consumeSocketMemoryReceipt = async () => {
+          if (!socketMemoryReceipt) return;
+          const receipt = socketMemoryReceipt;
+          if (receipt.used || receipt.ws !== ws || receipt.snapshot !== availableMemories || receipt.resultRows !== socketSnapshotResultRows || receipt.projectRows !== socketProjectCandidateRows || receipt.candidates !== verifiedProjectCandidates || !ws.isOpen() || receipt.optionsKey !== socketMemoryOptionsKey()) {
+            throw new Error("Personal Memory snapshot socket receipt is invalid.");
           }
-          const recoveryStartedAt = Date.now();
-          recoveryDiscovery = ws.waitForRecoveryOutputDiscovery().then(
-            () => {
-              recoveryMs = Date.now() - recoveryStartedAt;
-            },
-            (error) => {
-              recoveryDiscoveryError = error;
-              throw error;
+          await this.withFreshStoredSession(async () => {
+            if (!ws.isOpen() || JSON.stringify([
+              this.sendSocketOwnerKey(this.requireSession(), teamId),
+              authCookieFingerprint(this.http.getCookieMap())
+            ]) !== receipt.ownerKey) {
+              throw new Error("Personal Memory snapshot owner changed before send.");
             }
-          );
-          void recoveryDiscovery.catch(() => {
           });
-          if (mayDeferRecovery) {
-            const capabilitiesWaitStartedAt = performance.now();
-            await Promise.race([ws.waitForServerCapabilities(), recoveryDiscovery]);
-            capabilitiesWaitMs = Math.round(performance.now() - capabilitiesWaitStartedAt);
-          } else await recoveryDiscovery;
-        }
-        const messageId2 = randomUUID9();
-        const wallCreatedAt = Math.floor(Date.now() / 1e3);
-        const createdAt = !teamId && !params.incognito && params.chatId ? nextPersonalUserCreatedAt(wallCreatedAt, savedPrivacyHistory?.messages.map((row3) => row3.createdAt) ?? []) : wallCreatedAt;
-        const isNewChat = !params.chatId;
-        let messageHistoryForRequest = params.messageHistory;
-        if (!params.incognito && !isNewChat && !messageHistoryForRequest) {
-          const { messages } = savedPrivacyHistory;
-          messageHistoryForRequest = buildSavedChatMessageHistory(messages, chatId);
-        }
-        ws.send("set_active_chat", { chat_id: chatId, ...teamId ? { team_id: teamId } : {} });
-        const connectedAccountDirectory = buildConnectedAccountDirectoryPayload(
-          params.connectedAccountDirectory
-        );
-        const connectedAccountTokenRefs = params.connectedAccountTokenRefInputs?.length ? await this.createTurnTokenRefs({
-          chatId,
-          messageId: messageId2,
-          refs: params.connectedAccountTokenRefInputs,
-          teamId
-        }) : [];
-        assertNoConnectedAccountSecretLeak(connectedAccountTokenRefs);
-        let chatKeyBytes = null;
-        let activeFocusId = null;
-        let encryptedChatKey = null;
-        let chatSlugLookupKey = null;
-        let focusPhaseState = {};
-        let baselineMessagesV = 0;
-        let notificationTitle = null;
-        let terminalExpectedMessagesV = 1;
-        let savedTurnId = null;
-        if (!params.incognito) {
-          traceSendTiming("key_begin");
-          const masterKey = this.getMasterKeyBytes();
-          const preparedKey = isNewChat && ownsPreparedId && this.preparedChatKey?.chatId === chatId && this.preparedChatOwnerCurrent(this.preparedChatKey.owner, teamId) ? this.preparedChatKey : null;
-          if (preparedKey) this.preparedChatKey = null;
-          const keyWaitStartedAt = performance.now();
-          const prepared = independentNewChatKey ? await independentNewChatKey : preparedKey ? await preparedKey.value : null;
-          if (prepared && !this.preparedChatOwnerCurrent(independentKeyOwner, teamId)) throw new Error("Chat key preparation owner changed before send.");
-          const wrappingKey = prepared?.wrappingKey ?? await this.getChatWrappingKey(teamId, masterKey);
-          keyWaitMs = Math.round(performance.now() - keyWaitStartedAt);
-          chatSlugLookupKey = wrappingKey;
-          if (isNewChat && prepared) {
-            chatKeyBytes = prepared.key;
-            encryptedChatKey = prepared.encryptedKey;
-          } else if (isNewChat) {
-            chatKeyBytes = globalThis.crypto ? new Uint8Array(globalThis.crypto.getRandomValues(new Uint8Array(32))) : new Uint8Array(
-              (await import("crypto")).webcrypto.getRandomValues(
-                new Uint8Array(32)
-              )
-            );
-            encryptedChatKey = await encryptBytesWithAesGcm(
-              chatKeyBytes,
-              wrappingKey
-            );
-          } else {
-            const cache = 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 (conditionalPrivacyReceipt && (conditionalPrivacyReceipt.epoch !== this.preparedPrivacyEpoch || conditionalPrivacyReceipt.preferencesKey !== JSON.stringify(await readPrivacyPreferences()))) {
+            throw new Error("Privacy preferences changed before send; prepare the turn again.");
+          }
+          receipt.used = true;
+        };
+        let metadataTransportOwned = false;
+        let metadataHandoffReady = false;
+        let metadataHandoffSuggestion = null;
+        let initialHeaderWork = null;
+        let initialHeaderNotice = null;
+        let initialAdmissionDurable = false;
+        let initialHeaderStopped = false;
+        let initialTitleScheduled;
+        let initialIconScheduled;
+        let persistOptionalHeader;
+        let optionalMetadata = null;
+        const socketReadyForSendAt = performance.now();
+        let capabilitiesWaitMs = 0;
+        let keyWaitMs = 0;
+        let recoveryKeypairMs = 0;
+        let encryptPayloadMs = 0;
+        if (!params.incognito && !ownerId2) {
+          earlyContextAbort.abort();
+          ws.close();
+          if (earlyContext) await earlyContext;
+          throw new Error("Authenticated user identity is required for saved chat recovery.");
+        }
+        const authSocketMs = Date.now() - authSocketStartedAt;
+        const mayDeferRecovery = !params.incognito && sdkMintedChatId && !teamId && !params.projectId && shouldWaitForAi;
+        let recoveryDiscovery = null;
+        let recoveryDiscoveryError = null;
+        let contextAckRejection = null;
+        let removeContextAckWatcher = null;
+        try {
+          if (!params.incognito) {
+            try {
+              ws.send("chat_metadata_warmup", teamId ? { team_id: teamId } : {});
+            } catch {
+            }
+            const recoveryStartedAt = Date.now();
+            recoveryDiscovery = ws.waitForRecoveryOutputDiscovery().then(
+              () => {
+                recoveryMs = Date.now() - recoveryStartedAt;
+              },
+              (error) => {
+                recoveryDiscoveryError = error;
+                throw error;
+              }
             );
-            if (chat) {
-              baselineMessagesV = typeof chat.details.messages_v === "number" ? chat.details.messages_v : 0;
-              const encKey = typeof chat.details.encrypted_chat_key === "string" ? chat.details.encrypted_chat_key : null;
-              if (encKey) {
-                chatKeyBytes = await this.resolveChatKey(cache, chat, wrappingKey, teamId);
-                encryptedChatKey = encKey;
-                if (!chatKeyBytes) throw new Error("Could not decrypt the saved chat key.");
-                if (typeof chat.details.encrypted_title === "string") {
-                  try {
-                    notificationTitle = await decryptWithAesGcmCombined(chat.details.encrypted_title, chatKeyBytes);
-                  } catch {
+            void recoveryDiscovery.catch(() => {
+            });
+            if (mayDeferRecovery) {
+              const capabilitiesWaitStartedAt = performance.now();
+              await Promise.race([ws.waitForServerCapabilities(), recoveryDiscovery]);
+              capabilitiesWaitMs = Math.round(performance.now() - capabilitiesWaitStartedAt);
+            } else await recoveryDiscovery;
+          }
+          const messageId2 = randomUUID9();
+          const wallCreatedAt = Math.floor(Date.now() / 1e3);
+          const createdAt = !teamId && !params.incognito && params.chatId ? nextPersonalUserCreatedAt(wallCreatedAt, savedPrivacyHistory?.messages.map((row3) => row3.createdAt) ?? []) : wallCreatedAt;
+          const isNewChat = !params.chatId;
+          let messageHistoryForRequest = params.messageHistory;
+          if (!params.incognito && !isNewChat && !messageHistoryForRequest) {
+            const { messages } = savedPrivacyHistory;
+            messageHistoryForRequest = buildSavedChatMessageHistory(messages, chatId);
+          }
+          ws.send("set_active_chat", { chat_id: chatId, ...teamId ? { team_id: teamId } : {} });
+          const connectedAccountDirectory = buildConnectedAccountDirectoryPayload(
+            params.connectedAccountDirectory
+          );
+          const connectedAccountTokenRefs = params.connectedAccountTokenRefInputs?.length ? await this.createTurnTokenRefs({
+            chatId,
+            messageId: messageId2,
+            refs: params.connectedAccountTokenRefInputs,
+            teamId
+          }) : [];
+          assertNoConnectedAccountSecretLeak(connectedAccountTokenRefs);
+          let chatKeyBytes = null;
+          let activeFocusId = null;
+          let encryptedChatKey = null;
+          let chatSlugLookupKey = null;
+          let focusPhaseState = {};
+          let baselineMessagesV = 0;
+          let notificationTitle = null;
+          let terminalExpectedMessagesV = 1;
+          let savedTurnId = null;
+          if (!params.incognito) {
+            traceSendTiming("key_begin");
+            const masterKey = this.getMasterKeyBytes();
+            const preparedKey = isNewChat && ownsPreparedId && this.preparedChatKey?.chatId === chatId && this.preparedChatOwnerCurrent(this.preparedChatKey.owner, teamId) ? this.preparedChatKey : null;
+            if (preparedKey) this.preparedChatKey = null;
+            const keyWaitStartedAt = performance.now();
+            const prepared = independentNewChatKey ? await independentNewChatKey : preparedKey ? await preparedKey.value : null;
+            if (prepared && !this.preparedChatOwnerCurrent(independentKeyOwner, teamId)) throw new Error("Chat key preparation owner changed before send.");
+            const wrappingKey = prepared?.wrappingKey ?? await this.getChatWrappingKey(teamId, masterKey);
+            keyWaitMs = Math.round(performance.now() - keyWaitStartedAt);
+            chatSlugLookupKey = wrappingKey;
+            if (isNewChat && prepared) {
+              chatKeyBytes = prepared.key;
+              encryptedChatKey = prepared.encryptedKey;
+            } else if (isNewChat) {
+              chatKeyBytes = globalThis.crypto ? new Uint8Array(globalThis.crypto.getRandomValues(new Uint8Array(32))) : new Uint8Array(
+                (await import("crypto")).webcrypto.getRandomValues(
+                  new Uint8Array(32)
+                )
+              );
+              encryptedChatKey = await encryptBytesWithAesGcm(
+                chatKeyBytes,
+                wrappingKey
+              );
+            } else {
+              const cache = (savedPrivacyHistory && this.scopedChatHistory.get(savedPrivacyHistory)) ?? loadSyncCache(teamId) ?? await this.ensureSynced(false, [], { teamId });
+              const chat = cache.chats.find(
+                (c) => String(c.details.id ?? "") === chatId || String(c.details.id ?? "").startsWith(chatId)
+              );
+              if (chat) {
+                baselineMessagesV = typeof chat.details.messages_v === "number" ? chat.details.messages_v : 0;
+                const encKey = typeof chat.details.encrypted_chat_key === "string" ? chat.details.encrypted_chat_key : null;
+                if (encKey) {
+                  chatKeyBytes = await this.resolveChatKey(cache, chat, wrappingKey, teamId);
+                  encryptedChatKey = encKey;
+                  if (!chatKeyBytes) throw new Error("Could not decrypt the saved chat key.");
+                  if (typeof chat.details.encrypted_title === "string") {
+                    try {
+                      notificationTitle = await decryptWithAesGcmCombined(chat.details.encrypted_title, chatKeyBytes);
+                    } catch {
+                    }
                   }
-                }
-                const encryptedPhaseState = chat.details.encrypted_focus_phase_state;
-                if (typeof encryptedPhaseState === "string" && encryptedPhaseState) {
-                  const phaseText = await decryptWithAesGcmCombined(encryptedPhaseState, chatKeyBytes);
-                  if (!phaseText) throw new Error("Could not decrypt focus phase progress. Sync before sending again.");
-                  focusPhaseState = JSON.parse(phaseText);
-                }
-                const encryptedFocusId = chat.details.encrypted_active_focus_id;
-                if (typeof encryptedFocusId === "string" && encryptedFocusId) {
-                  activeFocusId = await decryptWithAesGcmCombined(encryptedFocusId, chatKeyBytes);
-                  if (!activeFocusId) {
-                    throw new Error("Could not decrypt the chat's active focus. Sync before sending again.");
+                  const encryptedPhaseState = chat.details.encrypted_focus_phase_state;
+                  if (typeof encryptedPhaseState === "string" && encryptedPhaseState) {
+                    const phaseText = await decryptWithAesGcmCombined(encryptedPhaseState, chatKeyBytes);
+                    if (!phaseText) throw new Error("Could not decrypt focus phase progress. Sync before sending again.");
+                    focusPhaseState = JSON.parse(phaseText);
+                  }
+                  const encryptedFocusId = chat.details.encrypted_active_focus_id;
+                  if (typeof encryptedFocusId === "string" && encryptedFocusId) {
+                    activeFocusId = await decryptWithAesGcmCombined(encryptedFocusId, chatKeyBytes);
+                    if (!activeFocusId) {
+                      throw new Error("Could not decrypt the chat's active focus. Sync before sending again.");
+                    }
                   }
                 }
               }
+              if (!chatKeyBytes || !encryptedChatKey) {
+                throw new Error(`Encrypted chat key not found for chat '${chatId}'. Sync and try again.`);
+              }
             }
-            if (!chatKeyBytes || !encryptedChatKey) {
-              throw new Error(`Encrypted chat key not found for chat '${chatId}'. Sync and try again.`);
-            }
-          }
-          traceSendTiming("key_ready");
-        }
-        let focusPersistence = Promise.resolve();
-        let focusPersistenceError = null;
-        const chatContextEvents = !params.incognito && chatKeyBytes ? registerChatContextEvents({
-          ws,
-          chatId,
-          chatKey: chatKeyBytes,
-          existingMessageIds: savedPrivacyHistory?.messages.map(canonicalSavedChatMessageId) ?? [],
-          previousRulesSetKey: savedPrivacyHistory?.messages.filter((message) => message.role === "system").map((message) => parseChatContextContent(message.content)).filter((event) => event?.type === "rules_loaded").at(-1)?.set_key,
-          onApplied: params.onChatContextApplied
-        }) : null;
-        let projectAuthoringAvailable = null;
-        if (!params.incognito) ws.onMessageType("project_authoring_available", (value) => {
-          if (!value || typeof value !== "object") return;
-          const frame = value;
-          if (frame.chat_id === chatId && frame.user_message_id === messageId2 && typeof frame.project_id === "string")
-            projectAuthoringAvailable = { chat_id: chatId, project_id: frame.project_id, user_message_id: messageId2 };
-        });
-        const projectFocusCountdown = !params.incognito ? registerProjectFocusCountdown({
-          client: this,
-          ws,
-          chatId,
-          teamId,
-          onPending: params.onProjectFocusPending,
-          onError: (error) => {
-            focusPersistenceError = error;
+            traceSendTiming("key_ready");
           }
-        }) : null;
-        ws.onMessageType("focus_mode_activated", (event) => {
-          if (event.chat_id !== chatId || !event.focus_id || !chatKeyBytes || params.incognito) return;
-          const focusId = event.focus_id;
-          if (!focusId.startsWith("project-")) delete focusPhaseState[focusId];
-          const key = chatKeyBytes;
-          focusPersistence = focusPersistence.then(async () => {
-            const encryptedFocusId = await encryptWithAesGcmCombined(focusId, key);
-            await ws.sendAsync("update_encrypted_active_focus_id", {
-              chat_id: chatId,
-              encrypted_active_focus_id: encryptedFocusId
-            });
-          }).catch((error) => {
-            focusPersistenceError = error;
+          let focusPersistence = Promise.resolve();
+          let focusPersistenceError = null;
+          const chatContextEvents = !params.incognito && chatKeyBytes ? registerChatContextEvents({
+            ws,
+            chatId,
+            chatKey: chatKeyBytes,
+            existingMessageIds: savedPrivacyHistory?.messages.map(canonicalSavedChatMessageId) ?? [],
+            previousRulesSetKey: savedPrivacyHistory?.messages.filter((message) => message.role === "system").map((message) => parseChatContextContent(message.content)).filter((event) => event?.type === "rules_loaded").at(-1)?.set_key,
+            onApplied: params.onChatContextApplied
+          }) : null;
+          let projectAuthoringAvailable = null;
+          if (!params.incognito) ws.onMessageType("project_authoring_available", (value) => {
+            if (!value || typeof value !== "object") return;
+            const frame = value;
+            if (frame.chat_id === chatId && frame.user_message_id === messageId2 && typeof frame.project_id === "string")
+              projectAuthoringAvailable = { chat_id: chatId, project_id: frame.project_id, user_message_id: messageId2 };
           });
-        });
-        ws.onMessageType("focus_phases_updated", (event) => {
-          if (event.chat_id !== chatId || !event.states || !chatKeyBytes || params.incognito) return;
-          const key = chatKeyBytes;
-          const states2 = event.states;
-          focusPersistence = focusPersistence.then(async () => {
-            for (const [focusId, phase] of Object.entries(states2)) {
-              if (phase.schema_version !== 1 || phase.chat_id !== chatId || phase.focus_id !== focusId || !Number.isSafeInteger(phase.version) || phase.version < 0 || !Array.isArray(phase.transitions) || phase.transitions.length > 32) {
-                throw new Error("Invalid focus phase state received");
-              }
-              if (focusPhaseState[focusId]?.run_id === phase.run_id && focusPhaseState[focusId].version > phase.version) states2[focusId] = focusPhaseState[focusId];
+          const projectFocusCountdown = !params.incognito ? registerProjectFocusCountdown({
+            client: this,
+            ws,
+            chatId,
+            teamId,
+            onPending: params.onProjectFocusPending,
+            onError: (error) => {
+              focusPersistenceError = error;
             }
-            focusPhaseState = states2;
-            const encryptedState = await encryptWithAesGcmCombined(JSON.stringify(states2), key);
-            const persisted = ws.waitForMessage(
-              "encrypted_metadata_stored",
-              (payload) => payload.chat_id === chatId,
-              2e4
-            );
-            await ws.sendAsync("encrypted_chat_metadata", {
-              chat_id: chatId,
-              ...teamId ? { team_id: teamId } : {},
-              encrypted_focus_phase_state: encryptedState
-            });
-            await persisted;
-            const eventIds = /* @__PURE__ */ new Set();
-            for (const phase of Object.values(states2)) for (const transition of phase.transitions) {
-              if (transition.chat_id !== chatId || transition.focus_id !== phase.focus_id || !transition.event_id || eventIds.has(transition.event_id)) continue;
-              eventIds.add(transition.event_id);
-              const content = JSON.stringify(transition);
-              await ws.sendAsync("chat_system_message_added", {
+          }) : null;
+          ws.onMessageType("focus_mode_activated", (event) => {
+            if (event.chat_id !== chatId || !event.focus_id || !chatKeyBytes || params.incognito) return;
+            const focusId = event.focus_id;
+            if (!focusId.startsWith("project-")) delete focusPhaseState[focusId];
+            const key = chatKeyBytes;
+            focusPersistence = focusPersistence.then(async () => {
+              const encryptedFocusId = await encryptWithAesGcmCombined(focusId, key);
+              await ws.sendAsync("update_encrypted_active_focus_id", {
                 chat_id: chatId,
-                message: {
-                  message_id: transition.event_id,
-                  role: "system",
-                  status: "synced",
-                  encrypted_content: await encryptWithAesGcmCombined(content, key),
-                  created_at: transition.created_at
-                }
+                encrypted_active_focus_id: encryptedFocusId
               });
-            }
-            clearSyncCache(teamId);
-          }).catch((error) => {
-            focusPersistenceError = error;
+            }).catch((error) => {
+              focusPersistenceError = error;
+            });
           });
-        });
-        const clientCapabilities = taskUpdateJobsEnabled ? ["task_update_jobs"] : [];
-        if (!params.incognito && chatKeyBytes) {
-          registerCliProjectFileExecutor({
-            client: this,
-            ws,
-            chatId,
-            chatKey: chatKeyBytes,
-            piiMappings,
-            memories: availableMemories,
-            requestApproval: params.onProjectWriteApproval,
-            requestReadApproval: params.onProjectReadApproval,
-            onHostedVersionCommitted: params.onHostedVersionCommitted
+          ws.onMessageType("focus_phases_updated", (event) => {
+            if (event.chat_id !== chatId || !event.states || !chatKeyBytes || params.incognito) return;
+            const key = chatKeyBytes;
+            const states2 = event.states;
+            focusPersistence = focusPersistence.then(async () => {
+              for (const [focusId, phase] of Object.entries(states2)) {
+                if (phase.schema_version !== 1 || phase.chat_id !== chatId || phase.focus_id !== focusId || !Number.isSafeInteger(phase.version) || phase.version < 0 || !Array.isArray(phase.transitions) || phase.transitions.length > 32) {
+                  throw new Error("Invalid focus phase state received");
+                }
+                if (focusPhaseState[focusId]?.run_id === phase.run_id && focusPhaseState[focusId].version > phase.version) states2[focusId] = focusPhaseState[focusId];
+              }
+              focusPhaseState = states2;
+              const encryptedState = await encryptWithAesGcmCombined(JSON.stringify(states2), key);
+              const persisted = ws.waitForMessage(
+                "encrypted_metadata_stored",
+                (payload) => payload.chat_id === chatId,
+                2e4
+              );
+              await ws.sendAsync("encrypted_chat_metadata", {
+                chat_id: chatId,
+                ...teamId ? { team_id: teamId } : {},
+                encrypted_focus_phase_state: encryptedState
+              });
+              await persisted;
+              const eventIds = /* @__PURE__ */ new Set();
+              for (const phase of Object.values(states2)) for (const transition of phase.transitions) {
+                if (transition.chat_id !== chatId || transition.focus_id !== phase.focus_id || !transition.event_id || eventIds.has(transition.event_id)) continue;
+                eventIds.add(transition.event_id);
+                const content = JSON.stringify(transition);
+                await ws.sendAsync("chat_system_message_added", {
+                  chat_id: chatId,
+                  message: {
+                    message_id: transition.event_id,
+                    role: "system",
+                    status: "synced",
+                    encrypted_content: await encryptWithAesGcmCombined(content, key),
+                    created_at: transition.created_at
+                  }
+                });
+              }
+              clearSyncCache(teamId);
+            }).catch((error) => {
+              focusPersistenceError = error;
+            });
           });
-          clientCapabilities.push("project_file_jobs");
-          registerRemoteCommandOriginClient({ ws, client: this, chatId, onReview: params.onRemoteCommandReview, onEvent: params.onRemoteCommandEvent });
-          clientCapabilities.push("remote_command_jobs");
-        }
-        const messagePayload = {
-          chat_id: chatId,
-          ...teamId ? { team_id: teamId } : {},
-          client_capabilities: clientCapabilities,
-          // Only decrypted current metadata restores focus; history is never authority.
-          active_focus_id: activeFocusId,
-          focus_phase_state: focusPhaseState,
-          is_incognito: Boolean(params.incognito),
-          message: {
-            message_id: messageId2,
-            chat_id: chatId,
-            role: "user",
-            sender_name: "User",
-            status: "sent",
-            content: finalMessage,
-            created_at: createdAt,
-            chat_has_title: Boolean(params.chatId)
-          }
-        };
-        const useCombinedAdmission = ws.supportsServerCapability?.("chat_turn_admit_v1") === true;
-        const useDeferredContext = useCombinedAdmission && !params.chatId && !params.projectId && !teamId && ws.supportsServerCapability?.("chat_turn_context_v1") === true;
-        const useSelectionDetailsV2 = useDeferredContext && sdkMintedChatId && ws.supportsServerCapability?.("chat_turn_context_selection_details_v2") === true;
-        const contextRequestId = !params.incognito && shouldWaitForAi && useDeferredContext ? randomUUID9() : null;
-        let pendingContext = null;
-        if (!params.incognito && shouldWaitForAi) {
-          if (contextRequestId) {
-            messagePayload.client_context_pending = true;
-            messagePayload.client_context_request_id = contextRequestId;
+          const clientCapabilities = taskUpdateJobsEnabled ? ["task_update_jobs"] : [];
+          if (!params.incognito && chatKeyBytes) {
+            registerCliProjectFileExecutor({
+              client: this,
+              ws,
+              chatId,
+              chatKey: chatKeyBytes,
+              piiMappings,
+              memories: availableMemories,
+              requestApproval: params.onProjectWriteApproval,
+              requestReadApproval: params.onProjectReadApproval,
+              onHostedVersionCommitted: params.onHostedVersionCommitted
+            });
+            clientCapabilities.push("project_file_jobs");
+            registerRemoteCommandOriginClient({ ws, client: this, chatId, onReview: params.onRemoteCommandReview, onEvent: params.onRemoteCommandEvent });
+            clientCapabilities.push("remote_command_jobs");
           }
-          pendingContext = (async () => {
-            const prepared = earlyContext ? await earlyContext : { ok: true, value: await withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
-              sdkMintedChatId,
-              onRouting: publishRouting,
-              verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
-              usePersonalRoutingDirectory,
-              onProjectRouting: publishProjectRoutingTimed,
-              onProjectRoutingError: rejectProjectRouting
-            })), elapsedMs: Date.now() - contextStartedAt };
-            if (!prepared.ok) throw prepared.error;
-            if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-            if (process.env.OPENMATES_DEBUG === "1") {
-              console.error(`[chat preparation] pre_ws_ms=${preWsMs} memory_ms=${memoryPrepMs} privacy_ms=${privacyPrepMs} auth_ws_ms=${authSocketMs} recovery_ms=${recoveryMs} context_ms=${prepared.elapsedMs} project_candidates_ready_from_send_start_ms=${projectCandidatesReadyFromSendStartMs ?? "pending"}`);
+          const messagePayload = {
+            chat_id: chatId,
+            ...teamId ? { team_id: teamId } : {},
+            client_capabilities: clientCapabilities,
+            // Only decrypted current metadata restores focus; history is never authority.
+            active_focus_id: activeFocusId,
+            focus_phase_state: focusPhaseState,
+            is_incognito: Boolean(params.incognito),
+            message: {
+              message_id: messageId2,
+              chat_id: chatId,
+              role: "user",
+              sender_name: "User",
+              status: "sent",
+              content: finalMessage,
+              created_at: createdAt,
+              chat_has_title: Boolean(params.chatId)
             }
-            return deferredProjectDirectory ? { ...prepared.value, project_focus_candidates: prepared.value.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) } : prepared.value;
-          })();
-          void pendingContext.catch(() => {
-          });
-        }
-        if (params.testMockMarker !== void 0) {
-          const { capacityReplayMarker } = await import("./capacityReplayMarker-3NFJNDTZ.js");
-          messagePayload.test_mock_marker = capacityReplayMarker(
-            params.testMockMarker,
-            this.apiUrl,
-            process.env.OPENMATES_CAPACITY_CLIENT_REPLAY === "1"
-          );
-        }
-        if (isNewChat && encryptedChatKey) {
-          messagePayload.encrypted_chat_key = encryptedChatKey;
-        }
-        if (memoryMetadataKeys.length > 0) {
-          messagePayload.app_settings_memories_metadata = memoryMetadataKeys;
-        }
-        if (connectedAccountDirectory) {
-          messagePayload.connected_account_directory = connectedAccountDirectory;
-        }
-        if (connectedAccountTokenRefs.length > 0) {
-          messagePayload.connected_account_token_refs = connectedAccountTokenRefs;
-        }
-        if (params.benchmarkMetadata) {
-          messagePayload.benchmark_metadata = params.benchmarkMetadata;
-        }
-        if (params.learningMode) {
-          messagePayload.learning_mode = {
-            enabled: params.learningMode.enabled,
-            age_group: params.learningMode.ageGroup ?? null
           };
-        }
-        if (params.incognito) {
-          const providedHistory = (params.messageHistory ?? []).map(
-            (historyMessage) => buildInferenceHistoryMessage(historyMessage, historyMessage.chat_id ?? chatId)
-          );
-          messagePayload.message_history = [...providedHistory, {
-            message_id: messageId2,
-            chat_id: chatId,
-            role: "user",
-            sender_name: "User",
-            content: finalMessage,
-            created_at: createdAt
-          }];
-        } else if (messageHistoryForRequest && messageHistoryForRequest.length > 0) {
-          messagePayload.message_history = messageHistoryForRequest.map(
-            (historyMessage) => buildInferenceHistoryMessage(historyMessage, chatId)
-          );
-        }
-        if (params.preparedEmbeds && params.preparedEmbeds.length > 0) {
-          messagePayload.embeds = params.preparedEmbeds.map((embed) => ({
-            embed_id: embed.embedId,
-            type: embed.type,
-            content: embed.content,
-            status: embed.status,
-            text_preview: embed.textPreview
-          }));
-        }
-        const encryptedEmbeds = [...params.encryptedEmbeds ?? []];
-        if (!params.incognito && params.preparedEmbeds && params.preparedEmbeds.length > 0) {
-          if (!ownerId2) {
-            throw new Error("Authenticated user identity is required to encrypt embeds.");
+          const useCombinedAdmission = ws.supportsServerCapability?.("chat_turn_admit_v1") === true;
+          const useDeferredContext = useCombinedAdmission && !params.chatId && !params.projectId && !teamId && ws.supportsServerCapability?.("chat_turn_context_v1") === true;
+          const useSelectionDetailsV2 = useDeferredContext && sdkMintedChatId && ws.supportsServerCapability?.("chat_turn_context_selection_details_v2") === true;
+          const contextRequestId = !params.incognito && shouldWaitForAi && useDeferredContext ? randomUUID9() : null;
+          let pendingContext = null;
+          if (!params.incognito && shouldWaitForAi) {
+            if (contextRequestId) {
+              messagePayload.client_context_pending = true;
+              messagePayload.client_context_request_id = contextRequestId;
+            }
+            pendingContext = (async () => {
+              const prepared = earlyContext ? await earlyContext : { ok: true, value: await withHttpAbortSignal(earlyContextAbort.signal, () => prepareCliJevContext(this, chatId, contextScope, suppliedContext, finalMessage, {
+                sdkMintedChatId,
+                onRouting: publishRouting,
+                verifiedProjectCandidates: verifiedProjectCandidates ?? void 0,
+                usePersonalRoutingDirectory,
+                onProjectRouting: publishProjectRoutingTimed,
+                onProjectRoutingError: rejectProjectRouting
+              })), elapsedMs: Date.now() - contextStartedAt };
+              if (!prepared.ok) throw prepared.error;
+              if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
+              if (process.env.OPENMATES_DEBUG === "1") {
+                console.error(`[chat preparation] pre_ws_ms=${preWsMs} memory_ms=${memoryPrepMs} privacy_ms=${privacyPrepMs} auth_ws_ms=${authSocketMs} recovery_ms=${recoveryMs} context_ms=${prepared.elapsedMs} project_candidates_ready_from_send_start_ms=${projectCandidatesReadyFromSendStartMs ?? "pending"}`);
+              }
+              return deferredProjectDirectory ? { ...prepared.value, project_focus_candidates: prepared.value.project_focus_candidates?.filter((candidate) => candidate.auto_selection === true) } : prepared.value;
+            })();
+            void pendingContext.catch(() => {
+            });
+          }
+          if (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,
-              messageId2,
-              ownerId2
+          if (params.benchmarkMetadata) {
+            messagePayload.benchmark_metadata = params.benchmarkMetadata;
+          }
+          if (params.learningMode) {
+            messagePayload.learning_mode = {
+              enabled: params.learningMode.enabled,
+              age_group: params.learningMode.ageGroup ?? null
+            };
+          }
+          if (params.incognito) {
+            const providedHistory = (params.messageHistory ?? []).map(
+              (historyMessage) => buildInferenceHistoryMessage(historyMessage, historyMessage.chat_id ?? chatId)
+            );
+            messagePayload.message_history = [...providedHistory, {
+              message_id: messageId2,
+              chat_id: chatId,
+              role: "user",
+              sender_name: "User",
+              content: finalMessage,
+              created_at: createdAt
+            }];
+          } else if (messageHistoryForRequest && messageHistoryForRequest.length > 0) {
+            messagePayload.message_history = messageHistoryForRequest.map(
+              (historyMessage) => buildInferenceHistoryMessage(historyMessage, chatId)
             );
-            if (!encrypted?.encrypted_content || !encrypted.encrypted_type || encrypted.embed_keys.length !== 2) {
-              throw new Error(`Prepared message embed ${embed.embedId} is missing required ciphertext or key wrappers.`);
-            }
-            encryptedEmbeds.push(encrypted);
           }
-        }
-        if (!params.incognito && encryptedEmbeds.length > 0) {
-          if (!ownerId2) throw new Error("Authenticated owner identity is required for encrypted message embeds.");
-          assertCompleteEncryptedEmbedBundle(encryptedEmbeds, { chatId, messageId: messageId2, ownerId: ownerId2 });
-        }
-        if (encryptedEmbeds.length > 0) {
-          messagePayload.encrypted_embeds = encryptedEmbeds;
-        }
-        let dispatchHandlersReady = () => {
-        };
-        const handlersReady = new Promise((resolve20) => {
-          dispatchHandlersReady = resolve20;
-        });
-        let admissionPayload = null;
-        let precollectedResponse = params.precollectResponse && params.incognito && shouldWaitForAi ? ws.collectAiResponse(messageId2, chatId, { onStream: params.onStream, timeoutMs: params.responseTimeoutMs }) : null;
-        if (!params.incognito && chatKeyBytes && encryptedChatKey) {
-          traceSendTiming("preflight_begin");
-          const protocolVersion = 1;
-          const chatKeyVersion = 1;
-          const turnId = privacyTurnId;
-          savedTurnId = turnId;
-          terminalExpectedMessagesV = baselineMessagesV + 1;
-          const recoveryKeypairStartedAt = performance.now();
-          const recoveryKeypair = independentRecoveryKeypair ? await independentRecoveryKeypair : await deriveChatCompletionRecoveryKeypair(
-            Buffer.from(chatKeyBytes).toString("base64url"),
-            chatId,
-            chatKeyVersion
-          );
-          recoveryKeypairMs = Math.round(performance.now() - recoveryKeypairStartedAt);
-          const encryptPayloadStartedAt = performance.now();
-          const [encryptedContent, encryptedSenderName, encryptedPiiMappings] = await Promise.all([
-            encryptWithAesGcmCombined(finalMessage, chatKeyBytes),
-            encryptWithAesGcmCombined(teamSenderName, chatKeyBytes),
-            piiMappings.length ? encryptWithAesGcmCombined(JSON.stringify(piiMappings), chatKeyBytes) : null
-          ]);
-          const encryptedUserMessage = {
-            client_message_id: messageId2,
-            chat_id: chatId,
-            encrypted_content: encryptedContent,
-            role: "user",
-            created_at: createdAt,
-            updated_at: createdAt
-          };
-          encryptedUserMessage.encrypted_sender_name = encryptedSenderName;
-          if (encryptedPiiMappings) encryptedUserMessage.encrypted_pii_mappings = encryptedPiiMappings;
-          Object.assign(messagePayload, {
-            turn_id: turnId,
-            recovery_public_key: recoveryKeypair.publicKey,
-            chat_key_version: chatKeyVersion
-          });
-          let preflightInferenceRequest = messagePayload;
-          if (teamId) {
-            const teamInferenceHistory = [
-              ...(messageHistoryForRequest ?? []).map((historyMessage) => ({
-                role: historyMessage.role,
-                content: historyMessage.content,
-                category: historyMessage.category ?? null,
-                sender_name: historyMessage.sender_name ?? historyMessage.role,
-                created_at: historyMessage.created_at
-              })),
-              {
-                role: "user",
-                content: finalMessage,
-                category: null,
-                sender_name: teamSenderName,
-                created_at: createdAt
+          if (params.preparedEmbeds && params.preparedEmbeds.length > 0) {
+            messagePayload.embeds = params.preparedEmbeds.map((embed) => ({
+              embed_id: embed.embedId,
+              type: embed.type,
+              content: embed.content,
+              status: embed.status,
+              text_preview: embed.textPreview
+            }));
+          }
+          const encryptedEmbeds = [...params.encryptedEmbeds ?? []];
+          if (!params.incognito && params.preparedEmbeds && params.preparedEmbeds.length > 0) {
+            if (!ownerId2) {
+              throw new Error("Authenticated user identity is required to encrypt embeds.");
+            }
+            if (!chatKeyBytes) {
+              throw new Error("Saved chat key is required to encrypt every prepared embed.");
+            }
+            if (new Set(params.preparedEmbeds.map((embed) => embed.embedId)).size !== params.preparedEmbeds.length) {
+              throw new Error("Prepared message embed IDs must be unique.");
+            }
+            const preparedIds = params.preparedEmbeds.map((embed) => embed.embedId);
+            if (preparedIds.some((id) => !id || id.length > 128)) {
+              throw new Error("Prepared message embed ID is invalid.");
+            }
+            const canonicalReady = /* @__PURE__ */ new Set();
+            for (let offset = 0; offset < preparedIds.length; offset += 20) {
+              const selectedIds = preparedIds.slice(offset, offset + 20);
+              if (Buffer.byteLength(JSON.stringify({ embed_ids: selectedIds }), "utf8") > 4096) {
+                throw new Error("Message embed availability request exceeds its byte limit.");
               }
-            ];
-            const teamMessageEnvelope = { ...encryptedUserMessage, message_id: messageId2 };
-            delete messagePayload.message_history;
-            messagePayload.message = teamMessageEnvelope;
-            if (shouldWaitForAi) {
-              messagePayload.team_ai_invocation = { history: teamInferenceHistory };
-              preflightInferenceRequest = {
-                ...messagePayload,
-                message_history: teamInferenceHistory
-              };
+              const path2 = this.appendTeamQuery(
+                `/v1/embeds/chats/${encodeURIComponent(chatId)}/references/availability`,
+                { teamId }
+              );
+              const availability = await this.http.post(path2, { embed_ids: selectedIds }, this.getCliRequestHeaders());
+              if (!availability.ok) {
+                throw new Error(`Message embed availability lookup failed with HTTP ${availability.status}.`);
+              }
+              const page = classifyMessageEmbedAvailability(selectedIds, availability.data.results);
+              for (const id of page.ready) canonicalReady.add(id);
+            }
+            const masterKey = this.getMasterKeyBytes();
+            for (const embed of params.preparedEmbeds) {
+              if (canonicalReady.has(embed.embedId)) continue;
+              const encrypted = await encryptEmbed(
+                embed,
+                masterKey,
+                chatKeyBytes,
+                chatId,
+                messageId2,
+                ownerId2
+              );
+              if (!encrypted?.encrypted_content || !encrypted.encrypted_type || encrypted.embed_keys.length !== 2) {
+                throw new Error(`Prepared message embed ${embed.embedId} is missing required ciphertext or key wrappers.`);
+              }
+              encryptedEmbeds.push(encrypted);
             }
           }
-          const preflightPayload = {
-            protocol_version: protocolVersion,
-            chat_id: chatId,
-            ...teamId ? { team_id: teamId } : {},
-            turn_id: turnId,
-            message_id: messageId2,
-            chat_key_version: chatKeyVersion,
-            encrypted_chat_key: encryptedChatKey,
-            recovery_public_key: recoveryKeypair.publicKey,
-            expected_messages_v: baselineMessagesV,
-            encrypted_user_message: encryptedUserMessage,
-            inference_request: preflightInferenceRequest,
-            ...conditionalPrivacyReceipt ? {
-              privacy_receipt_id: conditionalPrivacyReceipt.receiptId,
-              privacy_generation: conditionalPrivacyReceipt.generation
-            } : {}
+          if (!params.incognito && encryptedEmbeds.length > 0) {
+            if (!ownerId2) throw new Error("Authenticated owner identity is required for encrypted message embeds.");
+            assertCompleteEncryptedEmbedBundle(encryptedEmbeds, { chatId, messageId: messageId2, ownerId: ownerId2 });
+          }
+          if (encryptedEmbeds.length > 0) {
+            messagePayload.encrypted_embeds = encryptedEmbeds;
+          }
+          let dispatchHandlersReady = () => {
           };
-          if (isNewChat) {
-            if (!chatSlugLookupKey) {
-              throw new Error("Encrypted chat slug lookup key was not initialized.");
-            }
-            const initialTitle = teamId && !shouldWaitForAi ? teamChatTitleFromMessage(params.message) : "";
-            const slugMetadata = await buildEncryptedObjectSlugMetadata({
-              value: selectNewChatSlugValue({
-                message: finalMessage,
-                chatId,
-                explicitSlug: params.slug
-              }),
-              encryptionKey: chatKeyBytes,
-              lookupKey: chatSlugLookupKey
-            });
-            preflightPayload.encrypted_chat_metadata = {
-              encrypted_title: await encryptWithAesGcmCombined(initialTitle, chatKeyBytes),
-              encrypted_slug: slugMetadata.encrypted_slug,
-              slug_lookup_hash: slugMetadata.slug_lookup_hash,
-              encrypted_chat_key: encryptedChatKey,
+          const handlersReady = new Promise((resolve20) => {
+            dispatchHandlersReady = resolve20;
+          });
+          let admissionPayload = null;
+          let precollectedResponse = params.precollectResponse && params.incognito && shouldWaitForAi ? ws.collectAiResponse(messageId2, chatId, { onStream: params.onStream, timeoutMs: params.responseTimeoutMs }) : null;
+          if (!params.incognito && chatKeyBytes && encryptedChatKey) {
+            traceSendTiming("preflight_begin");
+            const protocolVersion = 1;
+            const chatKeyVersion = 1;
+            const turnId = privacyTurnId;
+            savedTurnId = turnId;
+            terminalExpectedMessagesV = baselineMessagesV + 1;
+            const recoveryKeypairStartedAt = performance.now();
+            const recoveryKeypair = independentRecoveryKeypair ? await independentRecoveryKeypair : await deriveChatCompletionRecoveryKeypair(
+              Buffer.from(chatKeyBytes).toString("base64url"),
+              chatId,
+              chatKeyVersion
+            );
+            recoveryKeypairMs = Math.round(performance.now() - recoveryKeypairStartedAt);
+            const encryptPayloadStartedAt = performance.now();
+            const [encryptedContent, encryptedSenderName, encryptedPiiMappings] = await Promise.all([
+              encryptWithAesGcmCombined(finalMessage, chatKeyBytes),
+              encryptWithAesGcmCombined(teamSenderName, chatKeyBytes),
+              piiMappings.length ? encryptWithAesGcmCombined(JSON.stringify(piiMappings), chatKeyBytes) : null
+            ]);
+            const encryptedUserMessage = {
+              client_message_id: messageId2,
+              chat_id: chatId,
+              encrypted_content: encryptedContent,
+              role: "user",
               created_at: createdAt,
               updated_at: createdAt
             };
-          }
-          encryptPayloadMs = Math.round(performance.now() - encryptPayloadStartedAt);
-          try {
+            encryptedUserMessage.encrypted_sender_name = encryptedSenderName;
+            if (encryptedPiiMappings) encryptedUserMessage.encrypted_pii_mappings = encryptedPiiMappings;
+            Object.assign(messagePayload, {
+              turn_id: turnId,
+              recovery_public_key: recoveryKeypair.publicKey,
+              chat_key_version: chatKeyVersion
+            });
+            let preflightInferenceRequest = messagePayload;
             if (teamId) {
-              await stageCliTeamNotificationPreview(ws, {
-                teamId,
-                chatId,
-                messageId: messageId2,
-                content: finalMessage,
-                title: notificationTitle
+              const teamInferenceHistory = [
+                ...(messageHistoryForRequest ?? []).map((historyMessage) => ({
+                  role: historyMessage.role,
+                  content: historyMessage.content,
+                  category: historyMessage.category ?? null,
+                  sender_name: historyMessage.sender_name ?? historyMessage.role,
+                  created_at: historyMessage.created_at
+                })),
+                {
+                  role: "user",
+                  content: finalMessage,
+                  category: null,
+                  sender_name: teamSenderName,
+                  created_at: createdAt
+                }
+              ];
+              const teamMessageEnvelope = { ...encryptedUserMessage, message_id: messageId2 };
+              delete messagePayload.message_history;
+              messagePayload.message = teamMessageEnvelope;
+              if (shouldWaitForAi) {
+                messagePayload.team_ai_invocation = { history: teamInferenceHistory };
+                preflightInferenceRequest = {
+                  ...messagePayload,
+                  message_history: teamInferenceHistory
+                };
+              }
+            }
+            const preflightPayload = {
+              protocol_version: protocolVersion,
+              chat_id: chatId,
+              ...teamId ? { team_id: teamId } : {},
+              turn_id: turnId,
+              message_id: messageId2,
+              chat_key_version: chatKeyVersion,
+              encrypted_chat_key: encryptedChatKey,
+              recovery_public_key: recoveryKeypair.publicKey,
+              expected_messages_v: baselineMessagesV,
+              encrypted_user_message: encryptedUserMessage,
+              inference_request: preflightInferenceRequest,
+              ...conditionalPrivacyReceipt ? {
+                privacy_receipt_id: conditionalPrivacyReceipt.receiptId,
+                privacy_generation: conditionalPrivacyReceipt.generation
+              } : {}
+            };
+            if (isNewChat) {
+              if (!chatSlugLookupKey) {
+                throw new Error("Encrypted chat slug lookup key was not initialized.");
+              }
+              const initialTitle = teamId && !shouldWaitForAi ? teamChatTitleFromMessage(params.message) : "";
+              const slugMetadata = await buildEncryptedObjectSlugMetadata({
+                value: selectNewChatSlugValue({
+                  message: finalMessage,
+                  chatId,
+                  explicitSlug: params.slug
+                }),
+                encryptionKey: chatKeyBytes,
+                lookupKey: chatSlugLookupKey
               });
+              preflightPayload.encrypted_chat_metadata = {
+                encrypted_title: await encryptWithAesGcmCombined(initialTitle, chatKeyBytes),
+                encrypted_slug: slugMetadata.encrypted_slug,
+                slug_lookup_hash: slugMetadata.slug_lookup_hash,
+                encrypted_chat_key: encryptedChatKey,
+                created_at: createdAt,
+                updated_at: createdAt
+              };
             }
-            if (params.projectId) {
-              await prepareCliProjectFocusForPreflight({
+            encryptPayloadMs = Math.round(performance.now() - encryptPayloadStartedAt);
+            try {
+              if (teamId) {
+                await stageCliTeamNotificationPreview(ws, {
+                  teamId,
+                  chatId,
+                  messageId: messageId2,
+                  content: finalMessage,
+                  title: notificationTitle
+                });
+              }
+              if (params.projectId) {
+                await prepareCliProjectFocusForPreflight({
+                  ws,
+                  chatId,
+                  teamId,
+                  isNewChat,
+                  encryptedChatKey,
+                  createdAt,
+                  activateFocus: () => activateCliProjectFocus(this, params.projectId, chatId, teamId)
+                });
+                const focusedContext = await prepareCliJevContext(
+                  this,
+                  chatId,
+                  { teamId, personal: !teamId },
+                  params.jevContext,
+                  finalMessage
+                );
+                pendingContext = Promise.resolve(focusedContext);
+              }
+              admissionPayload = preflightPayload;
+              traceSendTiming("preflight_ready");
+            } catch (error) {
+              ws.close();
+              throw error;
+            }
+          }
+          const initialHeaderOwner = this.preparedChatOwner(this.requireSession(), teamId);
+          const startInitialHeader = () => {
+            if (!initialAdmissionDurable || !initialHeaderNotice || !chatKeyBytes || !isNewChat || params.incognito || !savedTurnId) return;
+            const notice = { ...initialHeaderNotice }, key = chatKeyBytes, turn = savedTurnId;
+            const titleChanged = !!notice.chatTitle && notice.chatTitle !== initialTitleScheduled;
+            const iconChanged = !!notice.chatIcon && notice.chatIcon !== initialIconScheduled;
+            if (!titleChanged && !iconChanged) return;
+            initialTitleScheduled = notice.chatTitle ?? initialTitleScheduled;
+            initialIconScheduled = notice.chatIcon ?? initialIconScheduled;
+            const current2 = () => !initialHeaderStopped && ws.isOpen() && this.preparedChatOwnerCurrent(initialHeaderOwner, teamId) && this.activeSubmittedChatTurns.get(chatId) === turn;
+            initialHeaderWork = (initialHeaderWork ?? Promise.resolve()).then(async () => {
+              if (!current2()) return;
+              if (titleChanged) await this.persistPostProcessingMetadata({
                 ws,
                 chatId,
                 teamId,
-                isNewChat,
+                chatKeyBytes: key,
                 encryptedChatKey,
-                createdAt,
-                activateFocus: () => activateCliProjectFocus(this, params.projectId, chatId, teamId)
+                followUpSuggestions: [],
+                suggestedFollowupMessage: null,
+                newChatSuggestions: [],
+                chatSummary: null,
+                chatTags: [],
+                updatedChatTitle: notice.chatTitle ?? null,
+                sourceTitleVersion: notice.sourceTitleVersion ?? null,
+                sourceMetadataVersion: notice.sourceMetadataVersion ?? null,
+                unversionedGeneratedTitle: notice.sourceTitleVersion === void 0 && notice.sourceMetadataVersion === void 0,
+                ownerCurrent: current2
               });
-              const focusedContext = await prepareCliJevContext(
-                this,
-                chatId,
-                { teamId, personal: !teamId },
-                params.jevContext,
-                finalMessage
-              );
-              pendingContext = Promise.resolve(focusedContext);
+              if (!current2()) return;
+              if (iconChanged || notice.category) {
+                const [encryptedIcon, encryptedCategory] = await Promise.all([
+                  notice.chatIcon ? encryptWithAesGcmCombined(notice.chatIcon, key) : null,
+                  notice.category ? encryptWithAesGcmCombined(notice.category, key) : null
+                ]);
+                if (!current2()) return;
+                const stored = ws.waitForMessage("encrypted_metadata_stored", (value) => value.chat_id === chatId, 2e4);
+                void stored.catch(() => {
+                });
+                await ws.sendAsync("encrypted_chat_metadata", {
+                  chat_id: chatId,
+                  ...teamId ? { team_id: teamId } : {},
+                  encrypted_chat_key: encryptedChatKey,
+                  ...encryptedIcon ? { encrypted_icon: encryptedIcon } : {},
+                  ...encryptedCategory ? { encrypted_chat_category: encryptedCategory } : {}
+                });
+                await stored;
+              }
+              if (current2()) clearSyncCache(teamId);
+            }).catch(() => {
+            });
+          };
+          const onTurnStream = (event) => {
+            if (isNewChat && event.kind === "typing" && (event.chatTitle || event.chatIcon) && event.chatId === chatId && event.userMessageId === messageId2 && event.turnId === savedTurnId && event.taskId && (!initialHeaderNotice?.taskId || event.taskId === initialHeaderNotice.taskId)) {
+              initialHeaderNotice = { ...initialHeaderNotice, ...event };
+              startInitialHeader();
             }
-            admissionPayload = preflightPayload;
-            traceSendTiming("preflight_ready");
-          } catch (error) {
-            ws.close();
-            throw error;
-          }
-        }
-        const initialHeaderOwner = this.preparedChatOwner(this.requireSession(), teamId);
-        const startInitialHeader = () => {
-          if (!initialAdmissionDurable || !initialHeaderNotice || !chatKeyBytes || !isNewChat || params.incognito || !savedTurnId) return;
-          const notice = { ...initialHeaderNotice }, key = chatKeyBytes, turn = savedTurnId;
-          const titleChanged = !!notice.chatTitle && notice.chatTitle !== initialTitleScheduled;
-          const iconChanged = !!notice.chatIcon && notice.chatIcon !== initialIconScheduled;
-          if (!titleChanged && !iconChanged) return;
-          initialTitleScheduled = notice.chatTitle ?? initialTitleScheduled;
-          initialIconScheduled = notice.chatIcon ?? initialIconScheduled;
-          const current2 = () => !initialHeaderStopped && ws.isOpen() && this.preparedChatOwnerCurrent(initialHeaderOwner, teamId) && this.activeSubmittedChatTurns.get(chatId) === turn;
-          initialHeaderWork = (initialHeaderWork ?? Promise.resolve()).then(async () => {
-            if (!current2()) return;
-            if (titleChanged) await this.persistPostProcessingMetadata({
+            params.onStream?.(event);
+          };
+          if (!params.incognito && chatKeyBytes && savedTurnId) {
+            const key = chatKeyBytes;
+            const ownedTurnId = savedTurnId;
+            this.activeSubmittedChatTurns.set(chatId, ownedTurnId);
+            const owner2 = this.preparedChatOwner(this.requireSession(), teamId);
+            const stopOwned = () => optionalMetadata?.stop();
+            optionalMetadata = observeOwnedTurnMetadata({
               ws,
               chatId,
-              teamId,
-              chatKeyBytes: key,
-              encryptedChatKey,
-              followUpSuggestions: [],
-              suggestedFollowupMessage: null,
-              newChatSuggestions: [],
-              chatSummary: null,
-              chatTags: [],
-              updatedChatTitle: notice.chatTitle ?? null,
-              sourceTitleVersion: notice.sourceTitleVersion ?? null,
-              sourceMetadataVersion: notice.sourceMetadataVersion ?? null,
-              unversionedGeneratedTitle: notice.sourceTitleVersion === void 0 && notice.sourceMetadataVersion === void 0,
-              ownerCurrent: current2
+              turnId: savedTurnId,
+              userMessageId: messageId2,
+              closeAfterMetadata: true,
+              ownerCurrent: () => this.preparedChatOwnerCurrent(owner2, teamId),
+              persist: async (metadata) => {
+                await this.persistPostProcessingMetadata({ ws, teamId, chatKeyBytes: key, encryptedChatKey, ...metadata });
+                clearSyncCache(teamId);
+              },
+              onMetadata: params.onMetadata,
+              onReleased: () => {
+                this.ownedMetadataSubscriptions.delete(stopOwned);
+                if (this.activeSubmittedChatTurns.get(chatId) === ownedTurnId) this.activeSubmittedChatTurns.delete(chatId);
+                if (metadataTransportOwned) ws.close();
+              }
             });
-            if (!current2()) return;
-            if (iconChanged || notice.category) {
-              const [encryptedIcon, encryptedCategory] = await Promise.all([
-                notice.chatIcon ? encryptWithAesGcmCombined(notice.chatIcon, key) : null,
-                notice.category ? encryptWithAesGcmCombined(notice.category, key) : null
-              ]);
-              if (!current2()) return;
-              const stored = ws.waitForMessage("encrypted_metadata_stored", (value) => value.chat_id === chatId, 2e4);
-              void stored.catch(() => {
-              });
-              await ws.sendAsync("encrypted_chat_metadata", {
-                chat_id: chatId,
-                ...teamId ? { team_id: teamId } : {},
-                encrypted_chat_key: encryptedChatKey,
-                ...encryptedIcon ? { encrypted_icon: encryptedIcon } : {},
-                ...encryptedCategory ? { encrypted_chat_category: encryptedCategory } : {}
-              });
-              await stored;
-            }
-            if (current2()) clearSyncCache(teamId);
-          }).catch(() => {
-          });
-        };
-        const onTurnStream = (event) => {
-          if (isNewChat && event.kind === "typing" && (event.chatTitle || event.chatIcon) && event.chatId === chatId && event.userMessageId === messageId2 && event.turnId === savedTurnId && event.taskId && (!initialHeaderNotice?.taskId || event.taskId === initialHeaderNotice.taskId)) {
-            initialHeaderNotice = { ...initialHeaderNotice, ...event };
-            startInitialHeader();
+            while (this.ownedMetadataSubscriptions.size >= 8) this.ownedMetadataSubscriptions.values().next().value?.();
+            this.ownedMetadataSubscriptions.add(stopOwned);
           }
-          params.onStream?.(event);
-        };
-        if (!params.incognito && chatKeyBytes && savedTurnId) {
-          const key = chatKeyBytes;
-          const ownedTurnId = savedTurnId;
-          this.activeSubmittedChatTurns.set(chatId, ownedTurnId);
-          const owner2 = this.preparedChatOwner(this.requireSession(), teamId);
-          const stopOwned = () => optionalMetadata?.stop();
-          optionalMetadata = observeOwnedTurnMetadata({
-            ws,
-            chatId,
-            turnId: savedTurnId,
-            userMessageId: messageId2,
-            closeAfterMetadata: true,
-            ownerCurrent: () => this.preparedChatOwnerCurrent(owner2, teamId),
-            persist: async (metadata) => {
-              await this.persistPostProcessingMetadata({ ws, teamId, chatKeyBytes: key, encryptedChatKey, ...metadata });
-              clearSyncCache(teamId);
-            },
-            onMetadata: params.onMetadata,
-            onReleased: () => {
-              this.ownedMetadataSubscriptions.delete(stopOwned);
-              if (this.activeSubmittedChatTurns.get(chatId) === ownedTurnId) this.activeSubmittedChatTurns.delete(chatId);
-              if (metadataTransportOwned) ws.close();
-            }
+          if (!params.incognito && shouldWaitForAi) {
+            precollectedResponse = ws.collectAiResponse(messageId2, chatId, {
+              waitForPostProcessing: false,
+              onStream: onTurnStream,
+              onSubChatEvent: async (event) => {
+                await handlersReady;
+                await handleSubChatEvent(event);
+              },
+              onAppSettingsMemoriesRequest: async (event) => {
+                await handlersReady;
+                await handleAppSettingsMemoriesRequest(event);
+              },
+              timeoutMs: params.responseTimeoutMs,
+              recoveryTurnId: savedTurnId,
+              projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
+              remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
+            });
+          }
+          const queuedAdmission = !params.incognito && shouldWaitForAi ? ws.waitForMessage("message_queued", (payload) => {
+            const event = payload;
+            return event.chat_id === chatId && event.user_message_id === messageId2;
+          }, params.responseTimeoutMs ?? 9e4) : null;
+          if (queuedAdmission) void queuedAdmission.catch(() => {
           });
-          while (this.ownedMetadataSubscriptions.size >= 8) this.ownedMetadataSubscriptions.values().next().value?.();
-          this.ownedMetadataSubscriptions.add(stopOwned);
-        }
-        if (!params.incognito && shouldWaitForAi) {
-          precollectedResponse = ws.collectAiResponse(messageId2, chatId, {
-            waitForPostProcessing: false,
-            onStream: onTurnStream,
-            onSubChatEvent: async (event) => {
-              await handlersReady;
-              await handleSubChatEvent(event);
-            },
-            onAppSettingsMemoriesRequest: async (event) => {
-              await handlersReady;
-              await handleAppSettingsMemoriesRequest(event);
-            },
-            timeoutMs: params.responseTimeoutMs,
-            recoveryTurnId: savedTurnId,
-            projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
-            remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
+          const pausedHandoff = !params.incognito && shouldWaitForAi ? ws.waitForMessage("queued_handoff_paused", (payload) => {
+            const event = payload;
+            return event.chat_id === chatId && (event.message_id === messageId2 || event.message_id === void 0);
+          }, params.responseTimeoutMs ?? 9e4) : null;
+          if (pausedHandoff) void pausedHandoff.catch(() => {
           });
-        }
-        const queuedAdmission = !params.incognito && shouldWaitForAi ? ws.waitForMessage("message_queued", (payload) => {
-          const event = payload;
-          return event.chat_id === chatId && event.user_message_id === messageId2;
-        }, params.responseTimeoutMs ?? 9e4) : null;
-        if (queuedAdmission) void queuedAdmission.catch(() => {
-        });
-        const pausedHandoff = !params.incognito && shouldWaitForAi ? ws.waitForMessage("queued_handoff_paused", (payload) => {
-          const event = payload;
-          return event.chat_id === chatId && (event.message_id === messageId2 || event.message_id === void 0);
-        }, params.responseTimeoutMs ?? 9e4) : null;
-        if (pausedHandoff) void pausedHandoff.catch(() => {
-        });
-        const confirmed = ws.waitForMessage(
-          "chat_message_confirmed",
-          (payload) => {
-            const eventPayload = payload;
-            return eventPayload.chat_id === chatId && eventPayload.message_id === messageId2;
-          },
-          params.responseTimeoutMs ?? DEFAULT_CHAT_MESSAGE_CONFIRMATION_TIMEOUT_MS
-        );
-        let confirmedPayload;
-        let admissionContinuationPhase = "before_dispatch";
-        let admissionAckObserved = false;
-        let routingFrameSent = false;
-        let detailsFrameSent = false;
-        const admissionContinuationStartedAt = performance.now();
-        try {
-          if (admissionPayload) {
-            if (!useDeferredContext && recoveryDiscovery) await recoveryDiscovery;
-            if (recoveryDiscoveryError) throw recoveryDiscoveryError;
-            if (!contextRequestId && pendingContext) {
-              const context = await pendingContext;
-              Object.assign(messagePayload, context);
-              Object.assign(admissionPayload.inference_request, context);
-            }
-            if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-            const admissionAck = ws.waitForMessage("chat_turn_preflight_ack", (payload) => payload.turn_id === savedTurnId);
-            void admissionAck.catch(() => {
-            });
-            const frameDispatchAt = performance.now();
-            admissionContinuationPhase = "await_ack";
-            await consumeSocketMemoryReceipt();
-            await ws.sendAsync(useCombinedAdmission ? "chat_turn_admit" : "chat_turn_preflight", admissionPayload);
-            traceSendTiming("admission_frame");
-            if (process.env.OPENMATES_DEBUG === "1") {
-              console.error(`[chat admission preparation] sdk_minted=${sdkMintedChatId} defer_recovery=${mayDeferRecovery} combined_admission=${useCombinedAdmission} caps_wait_ms=${capabilitiesWaitMs} key_wait_ms=${keyWaitMs} recovery_keypair_ms=${recoveryKeypairMs} encrypt_payload_ms=${encryptPayloadMs} socket_ready_to_frame_dispatch_ms=${Math.round(frameDispatchAt - socketReadyForSendAt)} frame_dispatch_from_send_start_ms=${Math.round(frameDispatchAt - preWsStartedAt)} wire_send_ms=${Math.round(performance.now() - frameDispatchAt)}`);
-            }
-            const ackPayload = (await admissionAck).payload;
-            traceSendTiming("admission_ack");
-            admissionAckObserved = true;
-            if (typeof ackPayload.preflight_id !== "string" || !ackPayload.preflight_id) {
-              throw new Error("Encrypted chat admission acknowledgement omitted preflight_id.");
-            }
-            if (typeof ackPayload.committed_messages_v === "number" && Number.isSafeInteger(ackPayload.committed_messages_v)) {
-              terminalExpectedMessagesV = ackPayload.committed_messages_v;
-            }
-            initialAdmissionDurable = true;
-            startInitialHeader();
-            if (!useCombinedAdmission) {
-              Object.assign(messagePayload, { protocol_version: admissionPayload.protocol_version, preflight_id: ackPayload.preflight_id });
-              await ws.sendAsync("chat_message_added", messagePayload);
-            }
-            if (pendingContext && contextRequestId) {
-              admissionContinuationPhase = "await_routing";
-              const identity3 = {
-                chat_id: chatId,
-                turn_id: savedTurnId,
-                message_id: messageId2,
-                request_id: contextRequestId,
-                ...teamId ? { team_id: teamId } : {}
-              };
-              let failureNotice = null;
-              const notifyContextFailure = (reason) => {
-                if (failureNotice) return failureNotice;
-                if (!ws.supportsServerCapability("chat_turn_context_failure_v1") || !ws.isOpen() || !contextOwnerIsCurrent() || !savedTurnId) return Promise.resolve();
-                failureNotice = (async () => {
-                  const failureAck = ws.waitForMessage("chat_turn_context_failed_ack", (payload) => {
-                    const event = payload;
-                    return event.chat_id === chatId && event.turn_id === savedTurnId && event.message_id === messageId2 && event.request_id === contextRequestId;
-                  }, 5e3);
-                  void failureAck.catch(() => {
-                  });
-                  await ws.sendAsync("chat_turn_context_failed", { ...identity3, reason });
-                  const status = (await failureAck).payload;
-                  if (status.status !== "accepted" && status.status !== "duplicate") {
-                    throw new Error("Chat context failure receipt was rejected.");
-                  }
-                })();
-                return failureNotice;
-              };
-              let routing;
-              try {
-                routing = useSelectionDetailsV2 ? await projectRoutingContext : deferredProjectDirectory ? (await Promise.all([pendingContext, projectRoutingContext]))[0] : params.projectId ? await pendingContext : await Promise.race([routingContext, pendingContext]);
-              } catch (error) {
-                try {
-                  await notifyContextFailure(useSelectionDetailsV2 ? "project_discovery_failed" : "context_preparation_failed");
-                } catch {
-                }
-                throw error;
+          const confirmed = ws.waitForMessage(
+            "chat_message_confirmed",
+            (payload) => {
+              const eventPayload = payload;
+              return eventPayload.chat_id === chatId && eventPayload.message_id === messageId2;
+            },
+            params.responseTimeoutMs ?? DEFAULT_CHAT_MESSAGE_CONFIRMATION_TIMEOUT_MS
+          );
+          let confirmedPayload;
+          let admissionContinuationPhase = "before_dispatch";
+          let admissionAckObserved = false;
+          let routingFrameSent = false;
+          let detailsFrameSent = false;
+          const admissionContinuationStartedAt = performance.now();
+          try {
+            if (admissionPayload) {
+              if (!useDeferredContext && recoveryDiscovery) await recoveryDiscovery;
+              if (recoveryDiscoveryError) throw recoveryDiscoveryError;
+              if (!contextRequestId && pendingContext) {
+                const context = await pendingContext;
+                Object.assign(messagePayload, context);
+                Object.assign(admissionPayload.inference_request, context);
               }
               if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-              let rejectContextAck;
-              contextAckRejection = new Promise((_resolve, reject) => {
-                rejectContextAck = reject;
-              });
-              void contextAckRejection.catch(() => {
+              const admissionAck = ws.waitForMessage("chat_turn_preflight_ack", (payload) => payload.turn_id === savedTurnId);
+              void admissionAck.catch(() => {
               });
-              let rejectedPhaseSeen = false;
-              const attemptedContextPhases = /* @__PURE__ */ new Set();
-              removeContextAckWatcher = ws.onMessageType("chat_turn_context_ack", (event) => {
-                if (rejectedPhaseSeen || event.chat_id !== chatId || event.turn_id !== savedTurnId || event.message_id !== messageId2 || event.request_id !== contextRequestId || event.phase !== "routing" && event.phase !== "details" || !attemptedContextPhases.has(event.phase)) return;
-                if (event.status === "accepted" || event.status === "duplicate") {
-                  traceSendTiming(event.phase === "routing" ? "routing_ack" : "details_ack");
-                  return;
-                }
-                if (event.status !== "rejected") return;
-                rejectedPhaseSeen = true;
-                if (!contextOwnerIsCurrent()) {
-                  rejectContextAck(new Error("Chat workspace changed while preparing context."));
-                  return;
+              const frameDispatchAt = performance.now();
+              admissionContinuationPhase = "await_ack";
+              await consumeSocketMemoryReceipt();
+              await ws.sendAsync(useCombinedAdmission ? "chat_turn_admit" : "chat_turn_preflight", admissionPayload);
+              traceSendTiming("admission_frame");
+              if (process.env.OPENMATES_DEBUG === "1") {
+                console.error(`[chat admission preparation] sdk_minted=${sdkMintedChatId} defer_recovery=${mayDeferRecovery} combined_admission=${useCombinedAdmission} caps_wait_ms=${capabilitiesWaitMs} key_wait_ms=${keyWaitMs} recovery_keypair_ms=${recoveryKeypairMs} encrypt_payload_ms=${encryptPayloadMs} socket_ready_to_frame_dispatch_ms=${Math.round(frameDispatchAt - socketReadyForSendAt)} frame_dispatch_from_send_start_ms=${Math.round(frameDispatchAt - preWsStartedAt)} wire_send_ms=${Math.round(performance.now() - frameDispatchAt)}`);
+              }
+              const ackPayload = (await admissionAck).payload;
+              traceSendTiming("admission_ack");
+              admissionAckObserved = true;
+              if (typeof ackPayload.preflight_id !== "string" || !ackPayload.preflight_id) {
+                throw new Error("Encrypted chat admission acknowledgement omitted preflight_id.");
+              }
+              if (typeof ackPayload.committed_messages_v === "number" && Number.isSafeInteger(ackPayload.committed_messages_v)) {
+                terminalExpectedMessagesV = ackPayload.committed_messages_v;
+              }
+              initialAdmissionDurable = true;
+              startInitialHeader();
+              if (!useCombinedAdmission) {
+                Object.assign(messagePayload, { protocol_version: admissionPayload.protocol_version, preflight_id: ackPayload.preflight_id });
+                await ws.sendAsync("chat_message_added", messagePayload);
+              }
+              if (pendingContext && contextRequestId) {
+                admissionContinuationPhase = "await_routing";
+                const identity3 = {
+                  chat_id: chatId,
+                  turn_id: savedTurnId,
+                  message_id: messageId2,
+                  request_id: contextRequestId,
+                  ...teamId ? { team_id: teamId } : {}
+                };
+                let failureNotice = null;
+                const notifyContextFailure = (reason) => {
+                  if (failureNotice) return failureNotice;
+                  if (!ws.supportsServerCapability("chat_turn_context_failure_v1") || !ws.isOpen() || !contextOwnerIsCurrent() || !savedTurnId) return Promise.resolve();
+                  failureNotice = (async () => {
+                    const failureAck = ws.waitForMessage("chat_turn_context_failed_ack", (payload) => {
+                      const event = payload;
+                      return event.chat_id === chatId && event.turn_id === savedTurnId && event.message_id === messageId2 && event.request_id === contextRequestId;
+                    }, 5e3);
+                    void failureAck.catch(() => {
+                    });
+                    await ws.sendAsync("chat_turn_context_failed", { ...identity3, reason });
+                    const status = (await failureAck).payload;
+                    if (status.status !== "accepted" && status.status !== "duplicate") {
+                      throw new Error("Chat context failure receipt was rejected.");
+                    }
+                  })();
+                  return failureNotice;
+                };
+                let routing;
+                try {
+                  routing = useSelectionDetailsV2 ? await projectRoutingContext : deferredProjectDirectory ? (await Promise.all([pendingContext, projectRoutingContext]))[0] : params.projectId ? await pendingContext : await Promise.race([routingContext, pendingContext]);
+                } catch (error) {
+                  try {
+                    await notifyContextFailure(useSelectionDetailsV2 ? "project_discovery_failed" : "context_preparation_failed");
+                  } catch {
+                  }
+                  throw error;
                 }
-                void notifyContextFailure("context_preparation_failed").catch(() => {
-                }).then(() => {
-                  rejectContextAck(new Error("Chat context delivery was rejected."));
+                if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
+                let rejectContextAck;
+                contextAckRejection = new Promise((_resolve, reject) => {
+                  rejectContextAck = reject;
                 });
-              });
-              const { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } = routing;
-              traceSendTiming("routing_prepared");
-              attemptedContextPhases.add("routing");
-              await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "routing", context: useSelectionDetailsV2 ? { project_focus_candidates } : { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } });
-              routingFrameSent = true;
-              traceSendTiming("routing_frame");
-              admissionContinuationPhase = "await_details";
-              let context;
-              try {
-                context = await Promise.race([pendingContext, contextAckRejection]);
-              } catch (error) {
+                void contextAckRejection.catch(() => {
+                });
+                let rejectedPhaseSeen = false;
+                const attemptedContextPhases = /* @__PURE__ */ new Set();
+                removeContextAckWatcher = ws.onMessageType("chat_turn_context_ack", (event) => {
+                  if (rejectedPhaseSeen || event.chat_id !== chatId || event.turn_id !== savedTurnId || event.message_id !== messageId2 || event.request_id !== contextRequestId || event.phase !== "routing" && event.phase !== "details" || !attemptedContextPhases.has(event.phase)) return;
+                  if (event.status === "accepted" || event.status === "duplicate") {
+                    traceSendTiming(event.phase === "routing" ? "routing_ack" : "details_ack");
+                    return;
+                  }
+                  if (event.status !== "rejected") return;
+                  rejectedPhaseSeen = true;
+                  if (!contextOwnerIsCurrent()) {
+                    rejectContextAck(new Error("Chat workspace changed while preparing context."));
+                    return;
+                  }
+                  void notifyContextFailure("context_preparation_failed").catch(() => {
+                  }).then(() => {
+                    rejectContextAck(new Error("Chat context delivery was rejected."));
+                  });
+                });
+                const { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } = routing;
+                traceSendTiming("routing_prepared");
+                attemptedContextPhases.add("routing");
+                await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "routing", context: useSelectionDetailsV2 ? { project_focus_candidates } : { project_focus_candidates, related_task_candidates, project_focus_catalog, accepted_plan_context } });
+                routingFrameSent = true;
+                traceSendTiming("routing_frame");
+                admissionContinuationPhase = "await_details";
+                let context;
                 try {
-                  await notifyContextFailure("context_preparation_failed");
-                } catch {
+                  context = await Promise.race([pendingContext, contextAckRejection]);
+                } catch (error) {
+                  try {
+                    await notifyContextFailure("context_preparation_failed");
+                  } catch {
+                  }
+                  throw error;
                 }
-                throw error;
+                if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
+                traceSendTiming("details_prepared");
+                attemptedContextPhases.add("details");
+                await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "details", context: {
+                  custom_memory_documents: context.custom_memory_documents ?? [],
+                  project_focus_documents: context.project_focus_documents ?? [],
+                  project_context_documents: context.project_context_documents ?? [],
+                  ...useSelectionDetailsV2 ? {
+                    related_task_candidates: context.related_task_candidates ?? [],
+                    project_focus_catalog: context.project_focus_catalog ?? [],
+                    accepted_plan_context: context.accepted_plan_context ?? null,
+                    ...connectedAccountDirectory ? { connected_account_directory: connectedAccountDirectory } : {}
+                  } : {}
+                } });
+                detailsFrameSent = true;
+                traceSendTiming("details_frame");
               }
-              if (!contextOwnerIsCurrent()) throw new Error("Chat workspace changed while preparing context.");
-              traceSendTiming("details_prepared");
-              attemptedContextPhases.add("details");
-              await ws.sendAsync("chat_turn_context_ready", { ...identity3, phase: "details", context: {
-                custom_memory_documents: context.custom_memory_documents ?? [],
-                project_focus_documents: context.project_focus_documents ?? [],
-                project_context_documents: context.project_context_documents ?? [],
-                ...useSelectionDetailsV2 ? {
-                  related_task_candidates: context.related_task_candidates ?? [],
-                  project_focus_catalog: context.project_focus_catalog ?? [],
-                  accepted_plan_context: context.accepted_plan_context ?? null,
-                  ...connectedAccountDirectory ? { connected_account_directory: connectedAccountDirectory } : {}
-                } : {}
-              } });
-              detailsFrameSent = true;
-              traceSendTiming("details_frame");
+              admissionContinuationPhase = "await_confirmation";
+            } else {
+              await consumeSocketMemoryReceipt();
+              await ws.sendAsync("chat_message_added", messagePayload);
             }
-            admissionContinuationPhase = "await_confirmation";
-          } else {
-            await consumeSocketMemoryReceipt();
-            await ws.sendAsync("chat_message_added", messagePayload);
-          }
-          confirmedPayload = (await (contextAckRejection ? Promise.race([confirmed, contextAckRejection]) : confirmed)).payload;
-        } catch (error) {
-          if (process.env.OPENMATES_DEBUG === "1" && admissionPayload) {
-            console.error(`[chat admission continuation] phase=${admissionContinuationPhase} ack_observed=${admissionAckObserved} routing_sent=${routingFrameSent} details_sent=${detailsFrameSent} socket_open=${ws.isOpen()} elapsed_ms=${Math.round(performance.now() - admissionContinuationStartedAt)}`);
+            confirmedPayload = (await (contextAckRejection ? Promise.race([confirmed, contextAckRejection]) : confirmed)).payload;
+          } catch (error) {
+            if (process.env.OPENMATES_DEBUG === "1" && admissionPayload) {
+              console.error(`[chat admission continuation] phase=${admissionContinuationPhase} ack_observed=${admissionAckObserved} routing_sent=${routingFrameSent} details_sent=${detailsFrameSent} socket_open=${ws.isOpen()} elapsed_ms=${Math.round(performance.now() - admissionContinuationStartedAt)}`);
+            }
+            dispatchHandlersReady();
+            void confirmed.catch(() => {
+            });
+            if (precollectedResponse) void precollectedResponse.catch(() => {
+            });
+            ws.close();
+            throw error;
           }
-          dispatchHandlersReady();
-          void confirmed.catch(() => {
-          });
-          if (precollectedResponse) void precollectedResponse.catch(() => {
-          });
-          ws.close();
-          throw error;
-        }
-        if (!params.incognito && typeof confirmedPayload.new_messages_v === "number" && Number.isSafeInteger(confirmedPayload.new_messages_v)) {
-          terminalExpectedMessagesV = confirmedPayload.new_messages_v;
-        }
-        if (!params.incognito && (!teamId || shouldWaitForAi)) {
-          clearSyncCache(teamId);
-        }
-        let assistant = "";
-        let assistantMessageId = null;
-        let category = null;
-        let modelName = null;
-        let tokenUsage = null;
-        let promptBudget = null;
-        let followUpSuggestions = [];
-        let suggestedFollowupMessage = null;
-        let taskProposals = [];
-        let taskUpdateProposals = [];
-        let taskEvents = [];
-        let pendingTaskUpdateJobs = [];
-        let subChatEvents = [];
-        const appSettingsMemoryRequests = [];
-        const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-        const isApprovalWithinServerLimits = (request) => {
-          const count = request.subChats.length;
-          if (count === 0) return false;
-          if (request.remainingSubChats !== null && count > request.remainingSubChats) {
-            return false;
+          if (!params.incognito && typeof confirmedPayload.new_messages_v === "number" && Number.isSafeInteger(confirmedPayload.new_messages_v)) {
+            terminalExpectedMessagesV = confirmedPayload.new_messages_v;
           }
-          if (request.maxDirectSubChats !== null && request.existingSubChats !== null && request.existingSubChats + count > request.maxDirectSubChats) {
-            return false;
+          if (!params.incognito && (!teamId || shouldWaitForAi)) {
+            clearSyncCache(teamId);
           }
-          return true;
-        };
-        const isAutoApprovalWithinServerLimits = (request) => {
-          if (!isApprovalWithinServerLimits(request)) return false;
-          return request.maxAutoSubChats === null || request.subChats.length <= request.maxAutoSubChats;
-        };
-        const handleSubChatEvent = async (event) => {
-          params.onSubChatEvent?.(event);
-          if (event.type === "spawn_sub_chats") {
-            if (params.incognito || !chatKeyBytes) return;
-            const rawSubChats = event.payload.sub_chats;
-            if (!Array.isArray(rawSubChats)) return;
-            const metadataPayloads = await buildSubChatEncryptedMetadataPayloads({
-              parentChatId: chatId,
-              parentChatKey: chatKeyBytes,
-              encryptedParentChatKey: encryptedChatKey,
-              subChats: rawSubChats
-            });
-            for (const metadataPayload of metadataPayloads) {
-              await ws.sendAsync("encrypted_chat_metadata", metadataPayload);
+          let assistant = "";
+          let assistantMessageId = null;
+          let category = null;
+          let modelName = null;
+          let tokenUsage = null;
+          let promptBudget = null;
+          let followUpSuggestions = [];
+          let suggestedFollowupMessage = null;
+          let taskProposals = [];
+          let taskUpdateProposals = [];
+          let taskEvents = [];
+          let pendingTaskUpdateJobs = [];
+          let subChatEvents = [];
+          const appSettingsMemoryRequests = [];
+          const numberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+          const isApprovalWithinServerLimits = (request) => {
+            const count = request.subChats.length;
+            if (count === 0) return false;
+            if (request.remainingSubChats !== null && count > request.remainingSubChats) {
+              return false;
             }
-            return;
-          }
-          if (event.type !== "sub_chat_confirmation_required") return;
-          const payload = event.payload;
-          const confirmationChatId = typeof payload.chat_id === "string" ? payload.chat_id : chatId;
-          const taskId = typeof payload.task_id === "string" ? payload.task_id : null;
-          const subChats = Array.isArray(payload.sub_chats) ? payload.sub_chats : [];
-          if (!taskId) return;
-          const request = {
-            chatId: confirmationChatId,
-            taskId,
-            subChats,
-            maxAutoSubChats: numberOrNull(payload.max_auto_sub_chats),
-            maxDirectSubChats: numberOrNull(payload.max_direct_sub_chats),
-            existingSubChats: numberOrNull(payload.existing_sub_chats),
-            remainingSubChats: numberOrNull(payload.remaining_sub_chats)
-          };
-          const withinLimits = isApprovalWithinServerLimits(request);
-          const approved = params.autoApproveSubChats ? isAutoApprovalWithinServerLimits(request) : withinLimits && params.onSubChatApprovalRequest ? await params.onSubChatApprovalRequest(request) : false;
-          await ws.sendAsync(
-            "sub_chat_confirmation",
-            buildSubChatConfirmationPayload({
-              chatId: request.chatId,
-              taskId: request.taskId,
-              approved,
-              approveCount: approved ? request.subChats.length : void 0
-            })
-          );
-        };
-        const persistSystemMessage = async (systemMessage) => {
-          if (!chatKeyBytes) return;
-          await ws.sendAsync("chat_system_message_added", {
-            chat_id: chatId,
-            message: {
-              message_id: systemMessage.message_id,
-              role: "system",
-              encrypted_content: await encryptWithAesGcmCombined(
-                systemMessage.content,
-                chatKeyBytes
-              ),
-              created_at: systemMessage.created_at,
-              user_message_id: systemMessage.user_message_id
+            if (request.maxDirectSubChats !== null && request.existingSubChats !== null && request.existingSubChats + count > request.maxDirectSubChats) {
+              return false;
             }
-          });
-          await ws.waitForMessage(
-            "system_message_confirmed",
-            (payload) => {
-              const p = payload;
-              return p.message_id === systemMessage.message_id;
-            },
-            2e4
-          );
-        };
-        const persistMemoryRequestSystemMessage = async (event) => {
-          const requestId = event.requestId ?? `${messageId2}-memory-request`;
-          await persistSystemMessage(buildAppSettingsMemoryRequestSystemMessage({
-            userMessageId: messageId2,
-            requestId,
-            requestedKeys: event.requestedKeys,
-            entryCounts: memoryCountsLoaded ? new Map(event.requestedKeys.map((key) => [key, availableMemories.filter((memory) => `${memory.app_id}-${memory.item_type}` === key).length])) : void 0,
-            createdAt: Math.floor(Date.now() / 1e3)
-          }));
-        };
-        const responseCategoriesFromMemories = (approvedMemories) => {
-          const counts = /* @__PURE__ */ new Map();
-          for (const memory of approvedMemories) {
-            const key = `${memory.app_id}-${memory.item_key}`;
-            const existing = counts.get(key);
-            if (existing) {
-              existing.entryCount += 1;
-            } else {
-              counts.set(key, {
-                appId: memory.app_id,
-                itemType: memory.item_key,
-                entryCount: 1
+            return true;
+          };
+          const isAutoApprovalWithinServerLimits = (request) => {
+            if (!isApprovalWithinServerLimits(request)) return false;
+            return request.maxAutoSubChats === null || request.subChats.length <= request.maxAutoSubChats;
+          };
+          const handleSubChatEvent = async (event) => {
+            params.onSubChatEvent?.(event);
+            if (event.type === "spawn_sub_chats") {
+              if (params.incognito || !chatKeyBytes) return;
+              const rawSubChats = event.payload.sub_chats;
+              if (!Array.isArray(rawSubChats)) return;
+              const metadataPayloads = await buildSubChatEncryptedMetadataPayloads({
+                parentChatId: chatId,
+                parentChatKey: chatKeyBytes,
+                encryptedParentChatKey: encryptedChatKey,
+                subChats: rawSubChats
               });
+              for (const metadataPayload of metadataPayloads) {
+                await ws.sendAsync("encrypted_chat_metadata", metadataPayload);
+              }
+              return;
             }
-          }
-          return [...counts.values()];
-        };
-        const handleAppSettingsMemoriesRequest = async (event) => {
-          await persistMemoryRequestSystemMessage(event);
-          if (params.autoApproveMemories) {
-            const requested = new Set(event.requestedKeys);
-            const unadvertisedKeys = event.requestedKeys.filter(
-              (key) => !memoryMetadataKeys.includes(key)
-            );
-            if (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
-            });
-            await persistSystemMessage(buildAppSettingsMemoryResponseSystemMessage({
-              userMessageId: messageId2,
-              messageId: `${messageId2}-memory-response`,
-              action: "included",
-              categories,
-              createdAt: Math.floor(Date.now() / 1e3)
-            }));
-            return;
-          }
-          appSettingsMemoryRequests.push({
-            requestId: event.requestId,
-            requestedKeys: event.requestedKeys,
-            approvedKeys: [],
-            entryCount: 0
-          });
-          throw new Error(
-            `The assistant requested memories (${event.requestedKeys.join(", ")}). Rerun with --auto-approve-memories to explicitly approve requested memory categories from the CLI, or continue this chat in the web app to approve or reject the request.`
-          );
-        };
-        const persistedTaskEventIds = /* @__PURE__ */ new Set();
-        const persistTaskEventSystemMessages = async (events) => {
-          if (!chatKeyBytes || events.length === 0) return;
-          for (const event of events) {
-            if (persistedTaskEventIds.has(event.event_id)) continue;
-            await this.persistEncryptedSystemMessage(
-              ws,
-              await buildTaskEventSystemMessage({
-                chatKey: chatKeyBytes,
-                userMessageId: messageId2,
-                event
-              }),
-              chatId
+            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
+              })
             );
-            persistedTaskEventIds.add(event.event_id);
-          }
-        };
-        const streamOpts = {
-          waitForPostProcessing: false,
-          onStream: onTurnStream,
-          onSubChatEvent: handleSubChatEvent,
-          onAppSettingsMemoriesRequest: handleAppSettingsMemoriesRequest,
-          projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
-          remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
-        };
-        dispatchHandlersReady();
-        if (!shouldWaitForAi) {
-          ws.close();
-        } else if (params.incognito) {
-          try {
-            const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
-              ...streamOpts,
-              timeoutMs: params.responseTimeoutMs,
-              recoveryTurnId: savedTurnId
-            }));
-            assistantMessageId = resp.messageId;
-            assistant = resp.content;
-            category = resp.category;
-            modelName = resp.modelName;
-            tokenUsage = resp.tokenUsage;
-            promptBudget = resp.promptBudget;
-            taskEvents = resp.taskEvents;
-            pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
-            subChatEvents = resp.subChatEvents;
-            if (resp.status === "waiting_for_user") {
-              await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
-              return {
-                status: resp.status,
-                chatId,
-                messageId: assistantMessageId,
-                assistant,
-                category,
-                modelName,
-                mateName: category ? MATE_NAMES[category] ?? null : null,
-                followUpSuggestions,
-                taskProposals,
-                taskUpdateProposals,
-                taskEvents,
-                pendingTaskUpdateJobs,
-                subChatEvents,
-                appSettingsMemoryRequests,
-                tokenUsage,
-                promptBudget
-              };
-            }
-          } finally {
-            ws.close();
-          }
-        } else {
-          try {
-            const recoverCurrentTurnOutputs = async () => {
-              if (recoveryDiscovery) {
-                try {
-                  await recoveryDiscovery;
-                } catch (error) {
-                  if (!useDeferredContext) throw error;
-                  return;
-                }
+          };
+          const 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
               }
-              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.");
+            });
+            await ws.waitForMessage(
+              "system_message_confirmed",
+              (payload) => {
+                const p = payload;
+                return p.message_id === systemMessage.message_id;
+              },
+              2e4
+            );
+          };
+          const persistMemoryRequestSystemMessage = async (event) => {
+            const requestId = event.requestId ?? `${messageId2}-memory-request`;
+            await persistSystemMessage(buildAppSettingsMemoryRequestSystemMessage({
+              userMessageId: messageId2,
+              requestId,
+              requestedKeys: event.requestedKeys,
+              entryCounts: memoryCountsLoaded ? new Map(event.requestedKeys.map((key) => [key, availableMemories.filter((memory) => `${memory.app_id}-${memory.item_type}` === key).length])) : void 0,
+              createdAt: Math.floor(Date.now() / 1e3)
+            }));
+          };
+          const responseCategoriesFromMemories = (approvedMemories) => {
+            const counts = /* @__PURE__ */ new Map();
+            for (const memory of approvedMemories) {
+              const key = `${memory.app_id}-${memory.item_key}`;
+              const existing = counts.get(key);
+              if (existing) {
+                existing.entryCount += 1;
+              } else {
+                counts.set(key, {
+                  appId: memory.app_id,
+                  itemType: memory.item_key,
+                  entryCount: 1
+                });
               }
-              const cache = loadSyncCache(teamId) ?? {
-                syncedAt: Date.now(),
-                totalChatCount: 0,
-                loadedChatCount: 0,
-                chats: [],
-                embeds: [],
-                embedKeys: [],
-                chatKeyWrappers: []
-              };
-              if (encryptedChatKey) {
-                const root = cache.chats.find((chat) => String(chat.details.id ?? "") === chatId);
-                if (root) root.details.encrypted_chat_key = encryptedChatKey;
-                else cache.chats.push({ details: { id: chatId, encrypted_chat_key: encryptedChatKey }, messages: [] });
+            }
+            return [...counts.values()];
+          };
+          const handleAppSettingsMemoriesRequest = async (event) => {
+            await persistMemoryRequestSystemMessage(event);
+            if (params.autoApproveMemories) {
+              const requested = new Set(event.requestedKeys);
+              const unadvertisedKeys = event.requestedKeys.filter(
+                (key) => !memoryMetadataKeys.includes(key)
+              );
+              if (unadvertisedKeys.length > 0) {
+                throw new Error(
+                  `Refusing to auto-approve unadvertised memory categories: ${unadvertisedKeys.join(", ")}`
+                );
               }
-              await this.replayCurrentTurnRecoveryOutputPages(ws, ownerId2, pages, cache, teamId, chatId);
-            };
-            const responsePromise = precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
-              ...streamOpts,
-              timeoutMs: params.responseTimeoutMs,
-              recoveryTurnId: savedTurnId
-            });
-            const outcome = await Promise.race([
-              responsePromise.then((response) => ({ kind: "response", response })),
-              ...contextAckRejection ? [contextAckRejection] : [],
-              ...queuedAdmission ? [queuedAdmission.then(
-                (frame) => ({ kind: "queued", frame }),
-                () => new Promise(() => {
-                })
-              )] : [],
-              ...pausedHandoff ? [pausedHandoff.then(
-                (frame) => ({ kind: "paused", frame }),
-                () => new Promise(() => {
-                })
-              )] : []
-            ]);
-            if (outcome.kind === "paused") {
-              void responsePromise.catch(() => {
+              const approvedMemories = availableMemories.filter((memory) => requested.has(`${memory.app_id}-${memory.item_type}`)).map((memory) => ({
+                app_id: memory.app_id,
+                item_key: memory.item_type,
+                content: memory.data
+              }));
+              const approvedKeys = [
+                ...new Set(approvedMemories.map((memory) => `${memory.app_id}-${memory.item_key}`))
+              ];
+              const categories = responseCategoriesFromMemories(approvedMemories);
+              appSettingsMemoryRequests.push({
+                requestId: event.requestId,
+                requestedKeys: event.requestedKeys,
+                approvedKeys,
+                entryCount: approvedMemories.length
               });
-              throw new Error("Message saved, but AI handoff is paused. No assistant run started; check the chat before retrying.");
-            }
-            if (outcome.kind === "queued") {
-              void responsePromise.catch(() => {
+              await ws.sendAsync("app_settings_memories_confirmed", {
+                chat_id: event.chatId,
+                app_settings_memories: approvedMemories
               });
-              const frame = outcome.frame.payload;
-              return {
-                status: "queued",
-                chatId,
-                messageId: null,
+              await persistSystemMessage(buildAppSettingsMemoryResponseSystemMessage({
                 userMessageId: messageId2,
-                queueMode: frame.queue_mode === "steer" ? "steer" : "follow_up",
-                queueRevision: typeof frame.queue_revision === "number" ? frame.queue_revision : 1,
-                assistant: "",
-                category: null,
-                modelName: null,
-                mateName: null,
-                followUpSuggestions: [],
-                taskProposals: [],
-                taskUpdateProposals: [],
-                taskEvents: [],
-                pendingTaskUpdateJobs: [],
-                subChatEvents: [],
-                appSettingsMemoryRequests: [],
-                tokenUsage: null,
-                promptBudget: null
-              };
+                messageId: `${messageId2}-memory-response`,
+                action: "included",
+                categories,
+                createdAt: Math.floor(Date.now() / 1e3)
+              }));
+              return;
             }
-            const resp = outcome.response;
-            assistantMessageId = resp.messageId;
-            assistant = resp.content;
-            category = resp.category;
-            modelName = resp.modelName;
-            tokenUsage = resp.tokenUsage;
-            promptBudget = resp.promptBudget;
-            followUpSuggestions = resp.followUpSuggestions;
-            suggestedFollowupMessage = resp.suggestedFollowupMessage;
-            taskProposals = resp.taskProposals;
-            taskUpdateProposals = resp.taskUpdateProposals;
-            taskEvents = resp.taskEvents;
-            pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
-            subChatEvents = resp.subChatEvents;
-            if (resp.status === "waiting_for_user") {
-              await persistTaskEventSystemMessages(taskEvents);
-              await recoverCurrentTurnOutputs();
-              return {
-                status: resp.status,
-                chatId,
-                messageId: assistantMessageId,
-                assistant,
-                category,
-                modelName,
-                mateName: category ? MATE_NAMES[category] ?? null : null,
-                followUpSuggestions,
-                taskProposals,
-                taskUpdateProposals,
-                taskEvents,
-                pendingTaskUpdateJobs,
-                subChatEvents,
-                appSettingsMemoryRequests,
-                tokenUsage,
-                promptBudget
-              };
+            appSettingsMemoryRequests.push({
+              requestId: event.requestId,
+              requestedKeys: event.requestedKeys,
+              approvedKeys: [],
+              entryCount: 0
+            });
+            throw new Error(
+              `The assistant requested memories (${event.requestedKeys.join(", ")}). Rerun with --auto-approve-memories to explicitly approve requested memory categories from the CLI, or continue this chat in the web app to approve or reject the request.`
+            );
+          };
+          const persistedTaskEventIds = /* @__PURE__ */ new Set();
+          const persistTaskEventSystemMessages = async (events) => {
+            if (!chatKeyBytes || events.length === 0) return;
+            for (const event of events) {
+              if (persistedTaskEventIds.has(event.event_id)) continue;
+              await this.persistEncryptedSystemMessage(
+                ws,
+                await buildTaskEventSystemMessage({
+                  chatKey: chatKeyBytes,
+                  userMessageId: messageId2,
+                  event
+                }),
+                chatId
+              );
+              persistedTaskEventIds.add(event.event_id);
             }
-            if (chatKeyBytes) {
-              if (!resp.recoveryJobId || !savedTurnId || !ownerId2) {
-                throw new Error("Saved chat completion did not include recoverable terminal identity.");
+          };
+          const streamOpts = {
+            waitForPostProcessing: false,
+            onStream: onTurnStream,
+            onSubChatEvent: handleSubChatEvent,
+            onAppSettingsMemoriesRequest: handleAppSettingsMemoriesRequest,
+            projectWriteApprovalInteractive: Boolean(params.onProjectWriteApproval),
+            remoteCommandReviewInteractive: Boolean(params.onRemoteCommandReview)
+          };
+          dispatchHandlersReady();
+          if (!shouldWaitForAi) {
+            ws.close();
+          } else if (params.incognito) {
+            try {
+              const resp = await (precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
+                ...streamOpts,
+                timeoutMs: params.responseTimeoutMs,
+                recoveryTurnId: savedTurnId
+              }));
+              assistantMessageId = resp.messageId;
+              assistant = resp.content;
+              category = resp.category;
+              modelName = resp.modelName;
+              tokenUsage = resp.tokenUsage;
+              promptBudget = resp.promptBudget;
+              taskEvents = resp.taskEvents;
+              pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
+              subChatEvents = resp.subChatEvents;
+              if (resp.status === "waiting_for_user") {
+                await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                return {
+                  status: resp.status,
+                  chatId,
+                  messageId: assistantMessageId,
+                  assistant,
+                  category,
+                  modelName,
+                  mateName: category ? MATE_NAMES[category] ?? null : null,
+                  followUpSuggestions,
+                  taskProposals,
+                  taskUpdateProposals,
+                  taskEvents,
+                  pendingTaskUpdateJobs,
+                  subChatEvents,
+                  appSettingsMemoryRequests,
+                  tokenUsage,
+                  promptBudget
+                };
               }
-              const recoveryJobId = resp.recoveryJobId;
-              let claimRetryDeadline = null;
-              let claim;
-              let claimRetryDelayMs = 500;
-              while (true) {
-                const requestId = randomUUID9();
-                let matchingLeaseConflict = false;
-                const stopWatchingErrors = ws.onMessageType("error", (payload) => {
-                  if (payload?.code === "lease_conflict" && payload.job_id === recoveryJobId && payload.request_id === requestId) {
-                    matchingLeaseConflict = true;
-                  }
-                });
-                const claimPromise = ws.waitForMessage(
-                  "recovery_job_claimed",
-                  (payload) => {
-                    const received = payload;
-                    return received.job_id === recoveryJobId && (received.request_id === void 0 || received.request_id === requestId);
-                  },
-                  claimRetryDeadline === null ? 2e4 : Math.min(2e4, Math.max(1, claimRetryDeadline - Date.now()))
-                );
-                try {
+            } finally {
+              ws.close();
+            }
+          } else {
+            try {
+              const recoverCurrentTurnOutputs = async () => {
+                if (recoveryDiscovery) {
                   try {
-                    await ws.sendAsync("recovery_job_claim", {
-                      protocol_version: 1,
-                      job_id: recoveryJobId,
-                      request_id: requestId
-                    });
+                    await recoveryDiscovery;
                   } catch (error) {
-                    void claimPromise.catch(() => {
-                    });
-                    throw error;
+                    if (!useDeferredContext) throw error;
+                    return;
                   }
-                  claim = (await claimPromise).payload;
-                  break;
-                } catch (error) {
-                  if (!(error instanceof WebSocketProtocolError) || error.code !== "lease_conflict" || !matchingLeaseConflict) throw error;
-                  claimRetryDeadline ??= Date.now() + Math.min(
-                    1e4,
-                    Math.max(0, params.responseTimeoutMs ?? 9e4)
-                  );
-                  const remainingMs = claimRetryDeadline - Date.now();
-                  if (remainingMs <= claimRetryDelayMs) throw error;
-                  await new Promise((resolve20) => setTimeout(resolve20, claimRetryDelayMs));
-                  claimRetryDelayMs = Math.min(claimRetryDelayMs * 2, 2e3);
-                } finally {
-                  stopWatchingErrors();
                 }
+                const pages = ws.drainAvailableRecoveryOutputPages();
+                if (pages.length === 0) return;
+                if (!ownerId2) throw new Error("Saved chat recovery output requires the owner identity.");
+                if (pages.some((page) => page.some((output) => output.root_chat_id === chatId || output.target_chat_id === chatId)) && (!chatKeyBytes || !encryptedChatKey)) {
+                  throw new Error("Saved chat recovery output requires the root chat key.");
+                }
+                const cache = loadSyncCache(teamId) ?? {
+                  syncedAt: Date.now(),
+                  totalChatCount: 0,
+                  loadedChatCount: 0,
+                  chats: [],
+                  embeds: [],
+                  embedKeys: [],
+                  chatKeyWrappers: []
+                };
+                if (encryptedChatKey) {
+                  const root = cache.chats.find((chat) => String(chat.details.id ?? "") === chatId);
+                  if (root) root.details.encrypted_chat_key = encryptedChatKey;
+                  else cache.chats.push({ details: { id: chatId, encrypted_chat_key: encryptedChatKey }, messages: [] });
+                }
+                await this.replayCurrentTurnRecoveryOutputPages(ws, ownerId2, pages, cache, teamId, chatId);
+              };
+              const responsePromise = precollectedResponse ?? ws.collectAiResponse(messageId2, chatId, {
+                ...streamOpts,
+                timeoutMs: params.responseTimeoutMs,
+                recoveryTurnId: savedTurnId
+              });
+              const outcome = await Promise.race([
+                responsePromise.then((response) => ({ kind: "response", response })),
+                ...contextAckRejection ? [contextAckRejection] : [],
+                ...queuedAdmission ? [queuedAdmission.then(
+                  (frame) => ({ kind: "queued", frame }),
+                  () => new Promise(() => {
+                  })
+                )] : [],
+                ...pausedHandoff ? [pausedHandoff.then(
+                  (frame) => ({ kind: "paused", frame }),
+                  () => new Promise(() => {
+                  })
+                )] : []
+              ]);
+              if (outcome.kind === "paused") {
+                void responsePromise.catch(() => {
+                });
+                throw new Error("Message saved, but AI handoff is paused. No assistant run started; check the chat before retrying.");
               }
-              const leaseToken = typeof claim.lease_token === "string" ? claim.lease_token : null;
-              const leaseGeneration = typeof claim.lease_generation === "number" && Number.isSafeInteger(claim.lease_generation) ? claim.lease_generation : null;
-              const assistantId = typeof claim.assistant_message_id === "string" ? claim.assistant_message_id : null;
-              const keyVersion = typeof claim.chat_key_version === "number" && Number.isSafeInteger(claim.chat_key_version) ? claim.chat_key_version : null;
-              const claimMatchesExpectedTerminal = assistantId && keyVersion === 1 && claim.chat_id === chatId && claim.turn_id === savedTurnId;
-              if (claim.state === "TERMINAL" && claimMatchesExpectedTerminal) {
-                assistant = resp.content;
-                category = resp.category;
-                modelName = resp.modelName;
-                assistantMessageId = assistantId;
-                await this.persistStreamedEmbeds({
-                  ws,
-                  embeds: resp.embeds,
-                  chatId,
-                  chatKeyBytes,
-                  fallbackMessageId: assistantId,
-                  ownerId: ownerId2,
-                  teamId
+              if (outcome.kind === "queued") {
+                void responsePromise.catch(() => {
                 });
-                clearSyncCache(teamId);
-                await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                const frame = outcome.frame.payload;
+                return {
+                  status: "queued",
+                  chatId,
+                  messageId: null,
+                  userMessageId: messageId2,
+                  queueMode: frame.queue_mode === "steer" ? "steer" : "follow_up",
+                  queueRevision: typeof frame.queue_revision === "number" ? frame.queue_revision : 1,
+                  assistant: "",
+                  category: null,
+                  modelName: null,
+                  mateName: null,
+                  followUpSuggestions: [],
+                  taskProposals: [],
+                  taskUpdateProposals: [],
+                  taskEvents: [],
+                  pendingTaskUpdateJobs: [],
+                  subChatEvents: [],
+                  appSettingsMemoryRequests: [],
+                  tokenUsage: null,
+                  promptBudget: null
+                };
+              }
+              const resp = outcome.response;
+              assistantMessageId = resp.messageId;
+              assistant = resp.content;
+              category = resp.category;
+              modelName = resp.modelName;
+              tokenUsage = resp.tokenUsage;
+              promptBudget = resp.promptBudget;
+              followUpSuggestions = resp.followUpSuggestions;
+              suggestedFollowupMessage = resp.suggestedFollowupMessage;
+              taskProposals = resp.taskProposals;
+              taskUpdateProposals = resp.taskUpdateProposals;
+              taskEvents = resp.taskEvents;
+              pendingTaskUpdateJobs = taskUpdateJobsEnabled ? resp.pendingTaskUpdateJobs : [];
+              subChatEvents = resp.subChatEvents;
+              if (resp.status === "waiting_for_user") {
                 await persistTaskEventSystemMessages(taskEvents);
                 await recoverCurrentTurnOutputs();
-                await projectFocusCountdown?.flush();
-                await focusPersistence;
-                await chatContextEvents?.flush();
-                if (focusPersistenceError) throw focusPersistenceError;
-                const mateName2 = category ? MATE_NAMES[category] ?? null : null;
                 return {
-                  status: "completed",
+                  status: resp.status,
                   chatId,
                   messageId: assistantMessageId,
                   assistant,
                   category,
                   modelName,
-                  mateName: mateName2,
+                  mateName: category ? MATE_NAMES[category] ?? null : null,
                   followUpSuggestions,
                   taskProposals,
                   taskUpdateProposals,
@@ -17808,231 +17822,333 @@ var OpenMatesClient = class _OpenMatesClient {
                   promptBudget
                 };
               }
-              if (claim.state !== "LEASED" || !leaseToken || leaseGeneration === null || leaseGeneration < 1 || !assistantId || keyVersion === null || keyVersion !== 1 || claim.chat_id !== chatId || claim.turn_id !== savedTurnId || typeof claim.sealed_payload !== "string") {
-                throw new Error("Recovery job claim returned invalid lease or identity data.");
-              }
-              const recoveryKeypair = await deriveChatCompletionRecoveryKeypair(
-                Buffer.from(chatKeyBytes).toString("base64url"),
-                chatId,
-                keyVersion
-              );
-              let envelope;
-              try {
-                envelope = JSON.parse(claim.sealed_payload);
-              } catch {
-                throw new Error("Recovery job contained an invalid sealed envelope.");
-              }
-              const plaintext = await openChatCompletionRecoveryEnvelope(
-                envelope,
-                {
-                  recoveryPrivateKey: recoveryKeypair.privateKey,
-                  ownerId: ownerId2,
+              if (chatKeyBytes) {
+                if (!resp.recoveryJobId || !savedTurnId || !ownerId2) {
+                  throw new Error("Saved chat completion did not include recoverable terminal identity.");
+                }
+                const recoveryJobId = resp.recoveryJobId;
+                let claimRetryDeadline = null;
+                let claim;
+                let claimRetryDelayMs = 500;
+                while (true) {
+                  const requestId = randomUUID9();
+                  let matchingLeaseConflict = false;
+                  const stopWatchingErrors = ws.onMessageType("error", (payload) => {
+                    if (payload?.code === "lease_conflict" && payload.job_id === recoveryJobId && payload.request_id === requestId) {
+                      matchingLeaseConflict = true;
+                    }
+                  });
+                  const claimPromise = ws.waitForMessage(
+                    "recovery_job_claimed",
+                    (payload) => {
+                      const received = payload;
+                      return received.job_id === recoveryJobId && (received.request_id === void 0 || received.request_id === requestId);
+                    },
+                    claimRetryDeadline === null ? 2e4 : Math.min(2e4, Math.max(1, claimRetryDeadline - Date.now()))
+                  );
+                  try {
+                    try {
+                      await ws.sendAsync("recovery_job_claim", {
+                        protocol_version: 1,
+                        job_id: recoveryJobId,
+                        request_id: requestId
+                      });
+                    } catch (error) {
+                      void claimPromise.catch(() => {
+                      });
+                      throw error;
+                    }
+                    claim = (await claimPromise).payload;
+                    break;
+                  } catch (error) {
+                    if (!(error instanceof WebSocketProtocolError) || error.code !== "lease_conflict" || !matchingLeaseConflict) throw error;
+                    claimRetryDeadline ??= Date.now() + Math.min(
+                      1e4,
+                      Math.max(0, params.responseTimeoutMs ?? 9e4)
+                    );
+                    const remainingMs = claimRetryDeadline - Date.now();
+                    if (remainingMs <= claimRetryDelayMs) throw error;
+                    await new Promise((resolve20) => setTimeout(resolve20, claimRetryDelayMs));
+                    claimRetryDelayMs = Math.min(claimRetryDelayMs * 2, 2e3);
+                  } finally {
+                    stopWatchingErrors();
+                  }
+                }
+                const leaseToken = typeof claim.lease_token === "string" ? claim.lease_token : null;
+                const leaseGeneration = typeof claim.lease_generation === "number" && Number.isSafeInteger(claim.lease_generation) ? claim.lease_generation : null;
+                const assistantId = typeof claim.assistant_message_id === "string" ? claim.assistant_message_id : null;
+                const keyVersion = typeof claim.chat_key_version === "number" && Number.isSafeInteger(claim.chat_key_version) ? claim.chat_key_version : null;
+                const claimMatchesExpectedTerminal = assistantId && keyVersion === 1 && claim.chat_id === chatId && claim.turn_id === savedTurnId;
+                if (claim.state === "TERMINAL" && claimMatchesExpectedTerminal) {
+                  assistant = resp.content;
+                  category = resp.category;
+                  modelName = resp.modelName;
+                  assistantMessageId = assistantId;
+                  await this.persistStreamedEmbeds({
+                    ws,
+                    embeds: resp.embeds,
+                    chatId,
+                    chatKeyBytes,
+                    fallbackMessageId: assistantId,
+                    ownerId: ownerId2,
+                    teamId
+                  });
+                  clearSyncCache(teamId);
+                  await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                  await persistTaskEventSystemMessages(taskEvents);
+                  await recoverCurrentTurnOutputs();
+                  await projectFocusCountdown?.flush();
+                  await focusPersistence;
+                  await chatContextEvents?.flush();
+                  if (focusPersistenceError) throw focusPersistenceError;
+                  const mateName2 = category ? MATE_NAMES[category] ?? null : null;
+                  return {
+                    status: "completed",
+                    chatId,
+                    messageId: assistantMessageId,
+                    assistant,
+                    category,
+                    modelName,
+                    mateName: mateName2,
+                    followUpSuggestions,
+                    taskProposals,
+                    taskUpdateProposals,
+                    taskEvents,
+                    pendingTaskUpdateJobs,
+                    subChatEvents,
+                    appSettingsMemoryRequests,
+                    tokenUsage,
+                    promptBudget
+                  };
+                }
+                if (claim.state !== "LEASED" || !leaseToken || leaseGeneration === null || leaseGeneration < 1 || !assistantId || keyVersion === null || keyVersion !== 1 || claim.chat_id !== chatId || claim.turn_id !== savedTurnId || typeof claim.sealed_payload !== "string") {
+                  throw new Error("Recovery job claim returned invalid lease or identity data.");
+                }
+                const recoveryKeypair = await deriveChatCompletionRecoveryKeypair(
+                  Buffer.from(chatKeyBytes).toString("base64url"),
                   chatId,
-                  turnId: savedTurnId,
-                  jobId: recoveryJobId,
-                  assistantMessageId: assistantId,
                   keyVersion
+                );
+                let envelope;
+                try {
+                  envelope = JSON.parse(claim.sealed_payload);
+                } catch {
+                  throw new Error("Recovery job contained an invalid sealed envelope.");
                 }
-              );
-              let recovered;
-              try {
-                recovered = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(plaintext));
-              } catch {
-                throw new Error("Recovery job plaintext was not valid UTF-8 JSON.");
-              }
-              const expectedRecoveryFields = [
-                "assistant_message_id",
-                "category",
-                "chat_id",
-                "content",
-                "job_id",
-                "key_version",
-                "model_name",
-                "turn_id"
-              ];
-              if (Object.keys(recovered).filter((field3) => ![
-                "thinking_content",
-                "thinking_signature",
-                "has_thinking",
-                "thinking_token_count",
-                "thinking_duration_seconds"
-              ].includes(field3)).sort().join(",") !== expectedRecoveryFields.join(",") || recovered.assistant_message_id !== assistantId || recovered.chat_id !== chatId || recovered.turn_id !== savedTurnId || recovered.job_id !== recoveryJobId || recovered.key_version !== keyVersion || typeof recovered.content !== "string" || recovered.category !== null && typeof recovered.category !== "string" || recovered.model_name !== null && typeof recovered.model_name !== "string") {
-                throw new Error("Recovery job plaintext did not match the terminal completion identity.");
-              }
-              assistant = recovered.content;
-              category = recovered.category;
-              modelName = recovered.model_name;
-              const completedAt = resp.recoveryCreatedAt ?? Math.floor(Date.now() / 1e3);
-              const encryptedAssistantContent = await encryptWithAesGcmCombined(
-                assistant,
-                chatKeyBytes
-              );
-              const encryptedSenderName = await encryptWithAesGcmCombined(category ? MATE_NAMES[category] ?? "Assistant" : "Assistant", chatKeyBytes);
-              const encryptedCategory = recovered.category ? await encryptWithAesGcmCombined(recovered.category, chatKeyBytes) : void 0;
-              const encryptedModelName = recovered.model_name ? await encryptWithAesGcmCombined(recovered.model_name, chatKeyBytes) : void 0;
-              const terminalPersistPayload = {
-                protocol_version: 1,
-                job_id: recoveryJobId,
-                lease_token: leaseToken,
-                lease_generation: leaseGeneration,
-                encrypted_assistant_message: {
-                  client_message_id: assistantId,
-                  chat_id: chatId,
-                  encrypted_content: encryptedAssistantContent,
-                  ...await this.encryptThinkingFields(recovered, chatKeyBytes),
-                  encrypted_sender_name: encryptedSenderName,
-                  encrypted_category: encryptedCategory,
-                  encrypted_model_name: encryptedModelName,
-                  role: "assistant",
-                  user_message_id: messageId2,
-                  created_at: completedAt,
-                  updated_at: completedAt
+                const plaintext = await openChatCompletionRecoveryEnvelope(
+                  envelope,
+                  {
+                    recoveryPrivateKey: recoveryKeypair.privateKey,
+                    ownerId: ownerId2,
+                    chatId,
+                    turnId: savedTurnId,
+                    jobId: recoveryJobId,
+                    assistantMessageId: assistantId,
+                    keyVersion
+                  }
+                );
+                let recovered;
+                try {
+                  recovered = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(plaintext));
+                } catch {
+                  throw new Error("Recovery job plaintext was not valid UTF-8 JSON.");
                 }
-              };
-              const persistTerminalRecovery = async (expectedMessagesV) => {
-                const persistedPromise = ws.waitForMessage(
-                  "recovery_job_persisted",
-                  (payload) => payload.job_id === recoveryJobId,
-                  2e4
+                const expectedRecoveryFields = [
+                  "assistant_message_id",
+                  "category",
+                  "chat_id",
+                  "content",
+                  "job_id",
+                  "key_version",
+                  "model_name",
+                  "turn_id"
+                ];
+                if (Object.keys(recovered).filter((field3) => ![
+                  "thinking_content",
+                  "thinking_signature",
+                  "has_thinking",
+                  "thinking_token_count",
+                  "thinking_duration_seconds"
+                ].includes(field3)).sort().join(",") !== expectedRecoveryFields.join(",") || recovered.assistant_message_id !== assistantId || recovered.chat_id !== chatId || recovered.turn_id !== savedTurnId || recovered.job_id !== recoveryJobId || recovered.key_version !== keyVersion || typeof recovered.content !== "string" || recovered.category !== null && typeof recovered.category !== "string" || recovered.model_name !== null && typeof recovered.model_name !== "string") {
+                  throw new Error("Recovery job plaintext did not match the terminal completion identity.");
+                }
+                assistant = recovered.content;
+                category = recovered.category;
+                modelName = recovered.model_name;
+                const completedAt = resp.recoveryCreatedAt ?? Math.floor(Date.now() / 1e3);
+                const encryptedAssistantContent = await encryptWithAesGcmCombined(
+                  assistant,
+                  chatKeyBytes
                 );
-                await ws.sendAsync("recovery_job_persist", {
-                  ...terminalPersistPayload,
-                  expected_messages_v: expectedMessagesV
-                });
-                await persistedPromise;
-              };
-              let terminalPersisted = false;
-              try {
-                await persistTerminalRecovery(terminalExpectedMessagesV);
-                terminalPersisted = true;
-              } catch (error) {
-                if (error instanceof WebSocketProtocolError) {
-                  if (error.code === "version_conflict") {
-                    const latestCache = await this.ensureSynced(
-                      true,
-                      [chatId],
-                      { teamId },
-                      false,
-                      void 0,
-                      void 0,
-                      { skipTypedRecoveryOutputReplay: true }
-                    );
-                    const latestChat = latestCache.chats.find(
-                      (chat) => String(chat.details.id ?? "") === chatId
-                    );
-                    const latestMessagesV = typeof latestChat?.details.messages_v === "number" && Number.isSafeInteger(latestChat.details.messages_v) ? latestChat.details.messages_v : null;
-                    if (latestMessagesV !== null && latestMessagesV > terminalExpectedMessagesV) {
-                      await persistTerminalRecovery(latestMessagesV);
-                      terminalExpectedMessagesV = latestMessagesV;
-                      terminalPersisted = true;
-                    }
+                const encryptedSenderName = await encryptWithAesGcmCombined(category ? MATE_NAMES[category] ?? "Assistant" : "Assistant", chatKeyBytes);
+                const encryptedCategory = recovered.category ? await encryptWithAesGcmCombined(recovered.category, chatKeyBytes) : void 0;
+                const encryptedModelName = recovered.model_name ? await encryptWithAesGcmCombined(recovered.model_name, chatKeyBytes) : void 0;
+                const terminalPersistPayload = {
+                  protocol_version: 1,
+                  job_id: recoveryJobId,
+                  lease_token: leaseToken,
+                  lease_generation: leaseGeneration,
+                  encrypted_assistant_message: {
+                    client_message_id: assistantId,
+                    chat_id: chatId,
+                    encrypted_content: encryptedAssistantContent,
+                    ...await this.encryptThinkingFields(recovered, chatKeyBytes),
+                    encrypted_sender_name: encryptedSenderName,
+                    encrypted_category: encryptedCategory,
+                    encrypted_model_name: encryptedModelName,
+                    role: "assistant",
+                    user_message_id: messageId2,
+                    created_at: completedAt,
+                    updated_at: completedAt
                   }
-                  if (!terminalPersisted) {
-                    throw new Error(`${error.message} (${error.code})`);
+                };
+                const persistTerminalRecovery = async (expectedMessagesV) => {
+                  const persistedPromise = ws.waitForMessage(
+                    "recovery_job_persisted",
+                    (payload) => payload.job_id === recoveryJobId,
+                    2e4
+                  );
+                  await ws.sendAsync("recovery_job_persist", {
+                    ...terminalPersistPayload,
+                    expected_messages_v: expectedMessagesV
+                  });
+                  await persistedPromise;
+                };
+                let terminalPersisted = false;
+                try {
+                  await persistTerminalRecovery(terminalExpectedMessagesV);
+                  terminalPersisted = true;
+                } catch (error) {
+                  if (error instanceof WebSocketProtocolError) {
+                    if (error.code === "version_conflict") {
+                      const latestCache = await this.ensureSynced(
+                        true,
+                        [chatId],
+                        { teamId },
+                        false,
+                        void 0,
+                        void 0,
+                        { skipTypedRecoveryOutputReplay: true }
+                      );
+                      const latestChat = latestCache.chats.find(
+                        (chat) => String(chat.details.id ?? "") === chatId
+                      );
+                      const latestMessagesV = typeof latestChat?.details.messages_v === "number" && Number.isSafeInteger(latestChat.details.messages_v) ? latestChat.details.messages_v : null;
+                      if (latestMessagesV !== null && latestMessagesV > terminalExpectedMessagesV) {
+                        await persistTerminalRecovery(latestMessagesV);
+                        terminalExpectedMessagesV = latestMessagesV;
+                        terminalPersisted = true;
+                      }
+                    }
+                    if (!terminalPersisted) {
+                      throw new Error(`${error.message} (${error.code})`);
+                    }
+                  } else {
+                    throw error;
                   }
-                } else {
-                  throw error;
                 }
-              }
-              if (!terminalPersisted) {
-                throw new Error("Encrypted completion recovery did not persist terminal state.");
-              }
-              assistantMessageId = assistantId;
-              await this.persistStreamedEmbeds({
-                ws,
-                embeds: resp.embeds,
-                chatId,
-                chatKeyBytes,
-                fallbackMessageId: assistantId,
-                ownerId: ownerId2,
-                teamId
-              });
-              if (initialHeaderWork) persistOptionalHeader = () => initialHeaderWork;
-              await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
-              if (taskUpdateJobsEnabled) {
-                const persistedTaskJobIds = await this.persistPendingTaskUpdateJobs({
+                if (!terminalPersisted) {
+                  throw new Error("Encrypted completion recovery did not persist terminal state.");
+                }
+                assistantMessageId = assistantId;
+                await this.persistStreamedEmbeds({
                   ws,
-                  jobs: pendingTaskUpdateJobs,
-                  events: taskEvents,
-                  teamId,
-                  activeChatId: chatId,
-                  activeChatKeyBytes: chatKeyBytes,
-                  fallbackUserMessageId: messageId2,
-                  requireActiveTurnEvent: true
+                  embeds: resp.embeds,
+                  chatId,
+                  chatKeyBytes,
+                  fallbackMessageId: assistantId,
+                  ownerId: ownerId2,
+                  teamId
                 });
-                pendingTaskUpdateJobs = pendingTaskUpdateJobs.filter((job) => !persistedTaskJobIds.has(job.job_id));
-              }
-              await persistTaskEventSystemMessages(taskEvents);
-              await recoverCurrentTurnOutputs();
-              clearSyncCache(teamId);
-              if (optionalMetadata) {
-                metadataHandoffReady = true;
-                metadataHandoffSuggestion = resp.suggestedFollowupMessage;
-              }
-            }
-          } finally {
-            try {
-              await projectFocusCountdown?.flush();
-              await focusPersistence;
-              if (projectAuthoringAvailable && assistant && chatContextEvents) {
-                try {
-                  const history = boundedAuthoringHistory([
-                    ...messageHistoryForRequest ?? [],
-                    { role: "user", content: finalMessage },
-                    { role: "assistant", content: assistant }
-                  ]);
-                  const recommendations = await assessCliProjectAuthoring(this, projectAuthoringAvailable, history);
-                  for (const event of recommendations) chatContextEvents.persist(event);
-                } catch {
+                if (initialHeaderWork) persistOptionalHeader = () => initialHeaderWork;
+                await persistCompressionCheckpoints(ws, chatKeyBytes, resp.compressionCheckpoints);
+                if (taskUpdateJobsEnabled) {
+                  const persistedTaskJobIds = await this.persistPendingTaskUpdateJobs({
+                    ws,
+                    jobs: pendingTaskUpdateJobs,
+                    events: taskEvents,
+                    teamId,
+                    activeChatId: chatId,
+                    activeChatKeyBytes: chatKeyBytes,
+                    fallbackUserMessageId: messageId2,
+                    requireActiveTurnEvent: true
+                  });
+                  pendingTaskUpdateJobs = pendingTaskUpdateJobs.filter((job) => !persistedTaskJobIds.has(job.job_id));
+                }
+                await persistTaskEventSystemMessages(taskEvents);
+                await recoverCurrentTurnOutputs();
+                clearSyncCache(teamId);
+                if (optionalMetadata) {
+                  metadataHandoffReady = true;
+                  metadataHandoffSuggestion = resp.suggestedFollowupMessage;
                 }
               }
-              await chatContextEvents?.flush();
             } finally {
-              projectFocusCountdown?.();
-              chatContextEvents?.stop();
-              if (!metadataHandoffReady) ws.close();
+              try {
+                await projectFocusCountdown?.flush();
+                await focusPersistence;
+                if (projectAuthoringAvailable && assistant && chatContextEvents) {
+                  try {
+                    const history = boundedAuthoringHistory([
+                      ...messageHistoryForRequest ?? [],
+                      { role: "user", content: finalMessage },
+                      { role: "assistant", content: assistant }
+                    ]);
+                    const recommendations = await assessCliProjectAuthoring(this, projectAuthoringAvailable, history);
+                    for (const event of recommendations) chatContextEvents.persist(event);
+                  } catch {
+                  }
+                }
+                await chatContextEvents?.flush();
+              } finally {
+                projectFocusCountdown?.();
+                chatContextEvents?.stop();
+                if (!metadataHandoffReady) ws.close();
+              }
+            }
+            if (focusPersistenceError) throw focusPersistenceError;
+            if (metadataHandoffReady && optionalMetadata) {
+              metadataTransportOwned = optionalMetadata.handOff(metadataHandoffSuggestion, persistOptionalHeader);
+              if (!metadataTransportOwned) ws.close();
             }
           }
-          if (focusPersistenceError) throw focusPersistenceError;
-          if (metadataHandoffReady && optionalMetadata) {
-            metadataTransportOwned = optionalMetadata.handOff(metadataHandoffSuggestion, persistOptionalHeader);
-            if (!metadataTransportOwned) ws.close();
+          const mateName = category ? MATE_NAMES[category] ?? null : null;
+          return {
+            status: "completed",
+            chatId,
+            messageId: assistantMessageId,
+            userMessageId: messageId2,
+            assistant,
+            category,
+            modelName,
+            mateName,
+            followUpSuggestions,
+            suggestedFollowupMessage,
+            taskProposals,
+            taskUpdateProposals,
+            taskEvents,
+            pendingTaskUpdateJobs,
+            subChatEvents,
+            appSettingsMemoryRequests,
+            tokenUsage,
+            promptBudget
+          };
+        } finally {
+          removeContextAckWatcher?.();
+          earlyContextAbort.abort();
+          if (!metadataTransportOwned) {
+            initialHeaderStopped = true;
+            optionalMetadata?.stop();
+            ws.close();
           }
+          if (earlyContext) await earlyContext;
         }
-        const mateName = category ? MATE_NAMES[category] ?? null : null;
-        return {
-          status: "completed",
-          chatId,
-          messageId: assistantMessageId,
-          userMessageId: messageId2,
-          assistant,
-          category,
-          modelName,
-          mateName,
-          followUpSuggestions,
-          suggestedFollowupMessage,
-          taskProposals,
-          taskUpdateProposals,
-          taskEvents,
-          pendingTaskUpdateJobs,
-          subChatEvents,
-          appSettingsMemoryRequests,
-          tokenUsage,
-          promptBudget
-        };
-      } finally {
-        removeContextAckWatcher?.();
-        earlyContextAbort.abort();
-        if (!metadataTransportOwned) {
-          initialHeaderStopped = true;
-          optionalMetadata?.stop();
-          ws.close();
-        }
-        if (earlyContext) await earlyContext;
+      } catch (error) {
+        memorySocket?.ws.close();
+        throw error;
       }
-    } catch (error) {
-      memorySocket?.ws.close();
-      throw error;
+    } finally {
+      historyAbort.abort();
     }
   }
   async persistEncryptedSystemMessage(ws, systemMessage, targetChatId) {
@@ -20337,6 +20453,25 @@ var OpenMatesClient = class _OpenMatesClient {
   // -------------------------------------------------------------------------
   // User tasks
   // -------------------------------------------------------------------------
+  /** One fresh authorized discovery page; never an exhaustive Task inventory. */
+  async listUserTaskDiscoveryPage(options = {}) {
+    const owner2 = this.captureTeamAccountOwner();
+    const activeTeamId = this.getActiveTeamId();
+    const teamId = this.resolveTeamContext(options);
+    const params = new URLSearchParams({ paginate: "true", limit: "100" });
+    if (teamId) params.set("team_id", teamId);
+    const response = await this.http.get(
+      `/v1/user-tasks?${params}`,
+      this.getCliRequestHeaders()
+    );
+    if (!owner2.isCurrent() || this.getActiveTeamId() !== activeTeamId || this.resolveTeamContext(options) !== teamId) throw new Error("Task context workspace changed");
+    if (!response.ok) throw new Error(`Task discovery failed with HTTP ${response.status}`);
+    const rows2 = response.data?.tasks;
+    if (!Array.isArray(rows2) || rows2.length > 100 || rows2.some((row3) => !row3 || typeof row3.task_id !== "string" || !row3.task_id || row3.task_id.length > 128)) {
+      throw new Error("Invalid bounded Task discovery page");
+    }
+    return rows2.filter((row3) => row3.source !== "workflow_run");
+  }
   async listUserTasks(filters = {}, options = {}) {
     const session = this.requireSession();
     const owner2 = [
@@ -22908,6 +23043,7 @@ Required: ${schema.required.join(", ")}`
   }
   interactiveViewerChatId = null;
   interactiveViewerSocket = null;
+  interactiveViewerOpenController = null;
   interactiveViewerAllowed = false;
   interactiveViewerGeneration = 0;
   beginInteractiveViewerSession() {
@@ -22935,8 +23071,10 @@ Required: ${schema.required.join(", ")}`
     this.clearInteractiveChatViewer();
     this.interactiveViewerChatId = chatId;
     const generation = this.interactiveViewerGeneration;
+    const controller = new AbortController();
+    this.interactiveViewerOpenController = controller;
     try {
-      const { ws } = await this.openWsClient({ taskUpdateJobs: false, interactiveHuman: true });
+      const { ws } = await this.openWsClient({ taskUpdateJobs: false, interactiveHuman: true, signal: controller.signal });
       if (!this.interactiveViewerAllowed || this.interactiveViewerGeneration !== generation || this.interactiveViewerChatId !== chatId) {
         ws.close();
         return;
@@ -22958,9 +23096,14 @@ Required: ${schema.required.join(", ")}`
         if (this.interactiveViewerGeneration === generation && this.interactiveViewerChatId === chatId) void this.setInteractiveChatViewer(chatId);
       }, 1e3);
       retry.unref?.();
+    } finally {
+      if (this.interactiveViewerOpenController === controller) this.interactiveViewerOpenController = null;
     }
   }
   clearInteractiveChatViewer() {
+    const controller = this.interactiveViewerOpenController;
+    this.interactiveViewerOpenController = null;
+    controller?.abort();
     this.interactiveViewerGeneration = (this.interactiveViewerGeneration ?? 0) + 1;
     this.interactiveViewerChatId = null;
     const ws = this.interactiveViewerSocket;