@jskit-ai/assistant-core 0.1.213 → 0.1.214

package/src/server/conversation/openCodeRuntime.js

@@ -181,6 +181,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   let sharedProcessStop = null;
   let failedStartup = null;
   let closed = false;
+  let connectionChanging = false;
+
+  function requireConnectionAvailable() {
+    if (connectionChanging) throw Object.assign(new Error("OpenCode is changing a connection. Retry after the connection change finishes."), {
+      code: "assistant_opencode_connection_changing", statusCode: 409
+    });
+  }
   const bindingScopes = new Map();
   let registryPath = "";
   let bindingWrite = Promise.resolve();
@@ -230,7 +237,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   }
 
   async function ensure(selected, start) {
+    requireConnectionAvailable();
     await sharedProcessStop;
+    requireConnectionAvailable();
     if (failedStartup) await stop("opencode-startup-cleanup");
     if (sharedProcess) {
       const currentConnection = sharedProcess.connections.get(selected?.modelProviderId);
@@ -243,6 +252,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
           await sharedProcess.server.client.health({ signal: AbortSignal.timeout(1_000) });
           return sharedProcess;
         } catch {
+          requireConnectionAvailable();
           await stop("opencode-health-check-failed");
         }
       } else {
@@ -320,6 +330,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   }
 
   async function acquire(key, prepare, onFailure = async () => {}) {
+    requireConnectionAvailable();
     const pending = processStarts.get(key);
     if (pending) return pending;
     const start = Promise.resolve().then(async () => {
@@ -442,6 +453,33 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       closed = true;
     }
     const application = preparation.release;
+    if (typeof input.publish === "function") {
+      requireConnectionAvailable();
+      connectionChanging = true;
+      try {
+        await Promise.all([...processStarts.values()].map(start => start.catch(() => null)));
+        await sharedProcessStart?.catch(() => null);
+        await application.assertConnectionChange?.();
+        const targets = [...processes.values()];
+        const providerId = text(input.modelProviderId);
+        if (!providerId || targets.some(target => text(target.modelProviderId) !== providerId || !application.ownsTarget(target))) {
+          throw Object.assign(new Error("Close other OpenCode chats and Colleague conversations, then retry this connection change. The saved connection has not changed."), {
+            code: "assistant_opencode_connection_in_use", statusCode: 409
+          });
+        }
+        const results = [];
+        for (const target of targets) {
+          const proof = await releaseProcessTarget(target, { retainSharedProcess: true }, application);
+          if (proof?.exited === false || proof?.ok === false) throw new Error("OpenCode could not stop the selected conversation. Retry the connection change.");
+          results.push(proof);
+        }
+        if (sharedProcess || failedStartup) results.push(await stop("opencode-connection-changed"));
+        await input.publish();
+        return { closed: results.length, ok: true };
+      } finally {
+        connectionChanging = false;
+      }
+    }
     await Promise.all([...processStarts.entries()]
       .filter(([key]) => key.includes("\0"))
       .map(([, start]) => start.catch(() => null)));
@@ -1063,6 +1101,8 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     let dispatchMonitor = null;
     let previousInputMessageId = null;
     let previousAdmission;
+    let recoveryReceipt = null;
+    let recoveryObservationError = null;
     try {
       const preparation = await application.prepare({ overwrite: !currentMonitor, threadId: currentThreadId });
       const preparedTarget = preparation.process ? await acquirePrepared(preparation.process) : preparation.target;
@@ -1079,6 +1119,24 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         await currentMonitor;
         currentMonitor = monitors.get(key);
       }
+      const recoveryTurn = currentMonitor ? turns.get(key) : null;
+      if (recoveryTurn?.recoveryAdmission) {
+        try {
+          recoveryReceipt = await recoveryTurn.recoveryAdmission.promise;
+          currentMonitor = monitors.get(key);
+          if (currentMonitor && !turns.get(key)?.active) {
+            await currentMonitor;
+            currentMonitor = monitors.get(key);
+          }
+          // Stop must not turn a waiting, undispatched input into a fresh turn.
+          recoveryTurn.abortController.signal.throwIfAborted();
+          target.abortController.signal.throwIfAborted();
+        } catch (error) {
+          // This is R's failure, not a rejected or attempted native B input.
+          return { failure: { error, attempted: false, threadId: currentThreadId,
+            turn: openCodeTurnSnapshot(turns.get(key), currentThreadId) } };
+        }
+      }
       admission = Promise.withResolvers();
       // The observer may be between polls when dispatch or persistence fails.
       // Keep the raw promise rejectable without an unhandled rejection.
@@ -1166,7 +1224,44 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       await dispatchMonitor.catch(() => null);
       throw error;
     }
-    admission.resolve();
+    if (recoveryReceipt) {
+      const receiptAbort = new AbortController();
+      // The original monitor can fail and retire without aborting its turn.
+      // Its settlement also ends this read; it never creates a successor turn.
+      void dispatchMonitor.then(() => receiptAbort.abort(new Error(
+        dispatchTurn.observationError || dispatchTurn.error || "OpenCode observation ended before input custody was confirmed."
+      )), error => receiptAbort.abort(error));
+      try {
+        const observation = await inspectOpenCodeMessageAdmission(target.server.client, currentThreadId,
+          text(admitted.id), { wait: true, signal: AbortSignal.any([
+            target.abortController.signal, dispatchTurn.abortController.signal, receiptAbort.signal
+          ]) });
+        const message = openCodeMessageRows(observation.messages).find(message =>
+          message.type === "user" && text(message.id) === text(admitted.id));
+        const created = message?.time?.created;
+        const recoveryCreated = recoveryReceipt.time?.created;
+        // Match the native latest-user order, including its ID tie-breaker.
+        if (!Number.isFinite(created) || !Number.isFinite(recoveryCreated) ||
+            !(created > recoveryCreated || (created === recoveryCreated && message.id > recoveryReceipt.id))) {
+          throw Object.assign(new Error(
+            "OpenCode could not confirm that the new input follows its final-answer recovery. The admitted message was not resent."
+          ), { code: "assistant_opencode_observation_lost", details: {}, statusCode: 503 });
+        }
+      } catch (error) {
+        recoveryObservationError = error;
+      } finally {
+        receiptAbort.abort();
+      }
+    }
+    if (recoveryObservationError) {
+      // Native B was dispatched: keep its authored receipt even when observing
+      // its place in native history failed, and use the original cleanup owner.
+      admission.reject(recoveryObservationError);
+      dispatchTurn.abortController.abort(recoveryObservationError);
+      await dispatchMonitor.catch(() => null);
+    } else {
+      admission.resolve();
+    }
     const turn = openCodeTurnSnapshot(turns.get(key), target.upstreamSessionId);
     return {
       conversationTurn,
@@ -1227,30 +1322,43 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   }
 
   function beginMessageMonitor(key, target, admitted, options, projection) {
-    target = { ...target };
-    const existing = monitors.get(key);
-    if (existing) {
-      return existing;
-    }
-    const metadata = projection.prepare(admitted, options);
-    const eventStartedAt = Number(admitted.eventStartedAt) || Date.now();
-    const startedAt = text(admitted.startedAt) || new Date(eventStartedAt).toISOString();
-    const turn = {
-      abortController: new AbortController(),
-      admission: options.admission,
-      active: true,
-      error: "",
-      eventStartedAt,
-      id: text(admitted.id),
-      inputMessageId: text(admitted.id),
-      startedAt,
-      state: options.admission ? "starting" : "active",
-      ...metadata.fields,
-      threadId: target.upstreamSessionId,
-      updatedAt: startedAt
+    const start = () => {
+      target = { ...target };
+      const existing = monitors.get(key);
+      if (existing) {
+        return existing;
+      }
+      const metadata = projection.prepare(admitted, options);
+      const eventStartedAt = Number(admitted.eventStartedAt) || Date.now();
+      const startedAt = text(admitted.startedAt) || new Date(eventStartedAt).toISOString();
+      const turn = {
+        abortController: new AbortController(),
+        admission: options.admission,
+        active: true,
+        error: "",
+        eventStartedAt,
+        id: text(admitted.id),
+        inputMessageId: text(admitted.id),
+        startedAt,
+        state: options.admission ? "starting" : "active",
+        ...metadata.fields,
+        threadId: target.upstreamSessionId,
+        updatedAt: startedAt
+      };
+      const monitor = beginMonitor(key, target, turn, projection.create(target, turn, metadata, options));
+      void monitor.catch(error => projection.onError(error));
+      return monitor;
     };
-    const monitor = beginMonitor(key, target, turn, projection.create(target, turn, metadata, options));
-    void monitor.catch(error => projection.onError(error));
+    if (typeof projection.runInContext !== "function") return start();
+    let monitor, startFailure;
+    // Context entry invokes this callback synchronously. Do not return the
+    // monitor to an async scope wrapper: retain its identity and error owner.
+    const scope = projection.runInContext(() => {
+      try { monitor = start(); }
+      catch (error) { startFailure = { error }; }
+    });
+    void Promise.resolve(scope).catch(error => projection.onError(error));
+    if (startFailure) throw startFailure.error;
     return monitor;
   }
 

package/src/server/conversation/openCodeTurn.js

@@ -135,18 +135,31 @@ export function openCodeMessageError(message = {}) {
 }
 
 export async function inspectOpenCodeMessageAdmission(client, conversationId, inputMessageId, {
-  signal = AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS)
+  signal = AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS), wait = false, readFailure = () => null
 } = {}) {
-  try {
-    // Do not create a missing native session or submit another prompt. Absence
-    // from bounded history is uncertainty, not proof of non-admission.
-    const messages = await client.messages(conversationId, { limit: 100, order: "desc" }, { signal });
-    const accepted = openCodeMessageRows(messages).some((message) =>
-      message.type === "user" && text(message.id) === inputMessageId);
-    return { accepted, messages };
-  } catch {
-    return null;
-  }
+  do {
+    if (wait) signal.throwIfAborted();
+    try {
+      // Do not create a missing native session or submit another prompt. Absence
+      // from bounded history is uncertainty, not proof of non-admission.
+      const readSignal = wait
+        ? AbortSignal.any([signal, AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS)])
+        : signal;
+      const messages = await client.messages(conversationId, { limit: 100, order: "desc" }, { signal: readSignal });
+      if (wait) signal.throwIfAborted();
+      const accepted = openCodeMessageRows(messages).some((message) =>
+        message.type === "user" && text(message.id) === inputMessageId);
+      if (accepted || !wait) return { accepted, messages };
+    } catch {
+      if (!wait) return null;
+      signal.throwIfAborted();
+    }
+    const failure = readFailure();
+    if (failure && (await client.sessionStatus(conversationId, { signal: AbortSignal.any([
+      signal, AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS)
+    ]) })).type === "idle") throw failure;
+    await delay(250, undefined, { signal });
+  } while (wait);
 }
 
 export async function steerOpenCodeTurn(client, conversationId, turn, input, { signal } = {}) {
@@ -381,19 +394,47 @@ export async function waitForOpenCodeFinalResponse(client, conversationId, turn,
     if (admission !== turn.admission || completion.inputMessageId !== text(turn.inputMessageId)) {
       continue;
     }
-    const admitted = await client.prompt(conversationId, {
-      agent,
-      delivery: "queue",
-      id: recoveryMessageId,
-      model,
-      prompt: {
-        text: "Your previous response ended without a user-facing final answer. Do not call tools or repeat your reasoning. Return the concise final answer to the user's latest request now."
-      },
-      resume: true
-    }, { signal: options.signal });
-    if (admission === turn.admission && completion.inputMessageId === text(turn.inputMessageId)) {
-      turn.inputMessageId = text(admitted?.id) || recoveryMessageId;
-      turn.updatedAt = new Date().toISOString();
+    // The async native prompt ACK does not acknowledge user-row creation.
+    // A later authored input joins this exact receipt before its own dispatch.
+    const recoveryAdmission = Promise.withResolvers();
+    void recoveryAdmission.promise.catch(() => {});
+    turn.recoveryAdmission = recoveryAdmission;
+    const receiptAbort = new AbortController();
+    const receiptSignal = AbortSignal.any([...(options.signal ? [options.signal] : []), receiptAbort.signal]);
+    const receipt = inspectOpenCodeMessageAdmission(client, conversationId, recoveryMessageId, {
+      signal: receiptSignal, wait: true, readFailure: options.readFailure
+    }).then(observation => {
+      const message = openCodeMessageRows(observation.messages).find(message =>
+        message.type === "user" && text(message.id) === recoveryMessageId);
+      recoveryAdmission.resolve(message);
+      return message;
+    }, error => {
+      recoveryAdmission.reject(error);
+      throw error;
+    });
+    void receipt.catch(() => {});
+    try {
+      const admitted = await client.prompt(conversationId, {
+        agent,
+        delivery: "queue",
+        id: recoveryMessageId,
+        model,
+        prompt: {
+          text: "Your previous response ended without a user-facing final answer. Do not call tools or repeat your reasoning. Return the concise final answer to the user's latest request now."
+        },
+        resume: true
+      }, { signal: options.signal });
+      await receipt;
+      options.signal?.throwIfAborted();
+      if (admission === turn.admission && completion.inputMessageId === text(turn.inputMessageId)) {
+        turn.inputMessageId = text(admitted?.id) || recoveryMessageId;
+        turn.updatedAt = new Date().toISOString();
+      }
+    } catch (error) {
+      recoveryAdmission.reject(error);
+      throw error;
+    } finally {
+      receiptAbort.abort();
     }
     return waitForCompletion();
   }

package/src/server/conversation/providers/api.js

@@ -16,10 +16,14 @@ export function createApiConversationDriver({ connections, apiClientFactory, fet
   if (!apiClientFactory && typeof connections?.resolve !== "function") throw new TypeError("API conversations require an authorized AI connection resolver.");
   const maximumOutput = limits.maxOutputCharacters ?? 64_000;
   const maximumHistory = limits.maxHistoryCharacters ?? 256_000;
+  const maximumToolProgress = limits.maxApiToolProgressCharacters;
   const preserveWhitespace = apiClientFactory?.preserveWhitespace !== false;
   for (const limit of [maximumOutput, maximumHistory]) {
     if (!Number.isSafeInteger(limit) || limit < 1) throw new TypeError("Invalid API conversation limit.");
   }
+  if (maximumToolProgress !== undefined && (!Number.isSafeInteger(maximumToolProgress) || maximumToolProgress < 1)) {
+    throw new TypeError("Invalid API application tool progress limit.");
+  }
   const driver = Object.freeze({
     admissionBeforeDispatch: true,
     attachmentTypes: ["text", "image", "file"],
@@ -102,6 +106,9 @@ export function createApiConversationDriver({ connections, apiClientFactory, fet
           } else if (finishReason !== "stop") {
             throw new Error("The model stream ended without confirming a completed answer.");
           }
+          if (calls.length && maximumToolProgress !== undefined && text.length > maximumToolProgress) {
+            throw new Error("Application tool progress text exceeds the configured API limit.");
+          }
           if (text.trim() && (calls.length || isAssistantProgressOnlyText(text))) {
             responseIsCommentary = true;
             await onMessage({ id, outputId: id, role: "commentary", text, complete: true });

package/src/server/conversation/providers/claudeDriver.js

@@ -2,10 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { realpath } from "node:fs/promises";
-import { bindClaudeConversationAccount, claudeFlagSettings, claudeModelConfiguration, readClaudeCodeAuthStatus } from "../claudeProcess.js";
+import { bindClaudeConversationAccount, claudeConnectionIdentity, claudeFlagSettings, claudeModelConfiguration, readClaudeCodeAuthStatus } from "../claudeProcess.js";
 import { nativeAiModel, nativeAiProvider } from "../../../shared/nativeProviders.js";
 import { requireClaudeSessionId, listClaudeConversationStorage } from "../claudeHistory.js";
 import { createClaudeConversationOwner, claudeNativeMessageId } from "../claudeTurn.js";
+import { CLAUDE_APPLICATION_TOOL_SERVER } from "../claudeTools.js";
 import { createLocalConversationExecution } from "../localExecution.js";
 import { validateConversationConfiguration, validateConnectionModel } from "../configuration.js";
 
@@ -145,6 +146,20 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
         }
         const current = entry.command;
         if (!current) return;
+        if (event.type === "provider-event" && typeof current.onNativeToolUse === "function" && event.event.type === "assistant") {
+          const prefix = `mcp__${CLAUDE_APPLICATION_TOOL_SERVER}__`;
+          for (const block of event.event.message?.content || []) {
+            if (block.type !== "tool_use" || block.name === "StructuredOutput") continue;
+            if (typeof block.name !== "string" || block.name.length > 256 + prefix.length) continue;
+            if (entry.command !== current || current.entry !== entry || !current.admitted || current.signal.aborted) {
+              throw new Error("The native Claude tool observation has no current admitted command.");
+            }
+            const name = block.name.startsWith(prefix) ? block.name.slice(prefix.length) : block.name;
+            if (!name || name.length > 256) continue;
+            await current.onNativeToolUse({ messageId: current.messageId, threadId: entry.id, name });
+          }
+          return;
+        }
         if (event.type === "message") await current.onMessage({ ...event.message, transient: !event.message.complete });
         else if (event.type === "message-complete") await current.onEvent(event);
         else if ((event.type === "admitted" && current.goal) || event.type === "settled") {
@@ -155,7 +170,8 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
     return standalone;
   }
 
-  async function bindAccount(entry, configuration, context, signal = AbortSignal.timeout(30_000)) {
+  async function bindAccount(entry, configuration, context, signal = AbortSignal.timeout(30_000), requireBound = false, receiptBinding) {
+    const accountBinding = requireBound ? receiptBinding : entry.context.binding;
     let selected;
     let providerId;
     let identity;
@@ -163,6 +179,9 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       const connection = await connections.resolve({ context, integrationId: configuration.integrationId });
       signal.throwIfAborted();
       providerId = connection.providerId;
+      if (requireBound && !accountBinding?.connectionIdentities?.[providerId]) {
+        throw new Error("The completed Claude response has no saved provider account fingerprint.");
+      }
       const provider = nativeAiProvider(providerId);
       const model = nativeAiModel(connection.model, providerId);
       if (providerId !== "anthropic" && (!provider || !model)) throw new Error("This exact provider/model is not supported by the Claude integration. Choose a supported model without renaming it.");
@@ -171,8 +190,11 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       selected = claudeModelConfiguration({ providerId, model: connection.model }, {
         apiKey: connection.apiKey, baseUrl: provider?.claudeBaseUrl || connection.baseURL || "https://api.anthropic.com"
       });
-      identity = hash([configRoot, providerId, selected.env.ANTHROPIC_BASE_URL, connection.apiKey]);
+      identity = claudeConnectionIdentity(configRoot, providerId, selected.env.ANTHROPIC_BASE_URL, connection.apiKey);
     } else {
+      if (requireBound && !accountBinding?.accountIdentity) {
+        throw new Error("The completed Claude response has no saved native account fingerprint.");
+      }
       identity = await accountIdentity(signal);
       selected = claudeModelConfiguration({ providerId: "anthropic", model: configuration.model || "default" });
       // Returning to the native host clears connection overrides, while
@@ -180,7 +202,14 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       for (const name of Object.keys(selected.env)) if (Object.hasOwn(env, name)) selected.env[name] = env[name];
     }
     signal.throwIfAborted();
-    const previous = providerId ? entry.context.binding.connectionIdentities?.[providerId] : entry.context.binding.accountIdentity;
+    const previous = providerId ? accountBinding.connectionIdentities?.[providerId] : accountBinding.accountIdentity;
+    const cached = providerId ? entry.context.binding.connectionIdentities?.[providerId] : entry.context.binding.accountIdentity;
+    if (requireBound && previous !== cached) {
+      throw new Error("The completed Claude response no longer matches its saved account fingerprint.");
+    }
+    if (requireBound && identity !== previous) {
+      throw new Error("The completed Claude response belongs to a different account or provider connection.");
+    }
     await bindClaudeConversationAccount({ accountIdentity: previous,
       accountIdentities: { [providerId || "anthropic"]: previous }
     }, { identity, providerId: providerId || "anthropic",
@@ -294,11 +323,17 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       let entry;
       if (!supplied) {
         requireClaudeSessionId(binding?.conversationId);
-        if (binding.workdir !== await realpath(workdir) || binding.configRoot !== configRoot) {
+        const scopeWorkdir = await realpath(workdir);
+        // Original scoped conversations keep native history in the credential
+        // home. Both paths must still come from the current authorized host.
+        const nativeWorkdir = Object.hasOwn(binding, "scopeWorkdir")
+          ? await realpath(env.HOME || homedir()) : scopeWorkdir;
+        if (binding.workdir !== nativeWorkdir || binding.configRoot !== configRoot ||
+          (Object.hasOwn(binding, "scopeWorkdir") && binding.scopeWorkdir !== scopeWorkdir)) {
           throw new Error("This Claude conversation belongs to another working directory or credential home. Restore its original host configuration.");
         }
         owner = standaloneOwner();
-        const context = { key: binding.workdir, workdir: binding.workdir, binding, reportFailure,
+        const context = { key: scopeWorkdir, workdir: binding.workdir, binding, reportFailure,
           async updateBinding(patch) {
             const next = { ...context.binding, ...patch };
             await writeBinding(next);
@@ -385,13 +420,23 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
             ...(input.action !== "set" ? { createdAt: goal?.createdAt, objective: goal?.objective } : {}) }, { interrupt, send });
           return claudeGoalValue(await entry.goals.read(), entry.id);
         },
-        async inspectAdmission({ context, representation, ...input }) {
+        async inspectAdmission({ context, representation, verifyAccount = false, ...input }) {
           if (scoped) return unsupported();
           if (supplied) {
             await acquire(context);
             const result = await owner.inspectAdmission(await acquire(context), input);
             return representation === "native" ? result : { accepted: result.admission === "accepted" };
           }
+          if (verifyAccount === true) {
+            const binding = input.receiptBinding;
+            if (input.threadId !== entry.id || binding?.conversationId !== entry.id ||
+                binding.workdir !== entry.context.binding.workdir || binding.configRoot !== configRoot ||
+                Object.hasOwn(binding, "scopeWorkdir") !== Object.hasOwn(entry.context.binding, "scopeWorkdir") ||
+                binding.scopeWorkdir !== entry.context.binding.scopeWorkdir) {
+              throw new Error("The completed Claude response belongs to a different native conversation or host scope.");
+            }
+            await bindAccount(entry, input.configuration, context, AbortSignal.timeout(30_000), true, binding);
+          }
           const history = await owner.readHistory(entry);
           const nativeId = claudeNativeMessageId(input.messageId);
           return { accepted: history.userIds.includes(nativeId),

package/src/server/conversation/providers/codex.js

@@ -10,6 +10,7 @@ export function createCodexConversationAdapter(host) {
   const instructionPrompts = new Map();
   const tasks = new Map();
   const goalChanges = new Map();
+  const threadGenerations = new Map();
   let contextGeneration = 0;
 
   function instructionEnvironment(params, environment) {
@@ -38,6 +39,7 @@ export function createCodexConversationAdapter(host) {
   // Detaching alone is insufficient when another subscriber retains it: prove
   // the effective managed environment before recording a new binding.
   async function withThreadContext(threadId, params, operation) {
+    const threadGeneration = threadGenerations.get(threadId) || 0;
     const previous = tasks.get(threadId) || Promise.resolve();
     const task = previous.catch(() => null).then(() => host.runRequest(async () => {
       const client = await host.client();
@@ -48,10 +50,11 @@ export function createCodexConversationAdapter(host) {
       params = await prepareInstructions(retainInstalledInstructions
         ? { ...params, systemPrompt: undefined, developerInstructions: bound.params.developerInstructions }
         : params, threadId);
-      const signal = AbortSignal.timeout(host.timeoutMs || 10_000);
+      let signal = AbortSignal.timeout(host.timeoutMs || 10_000);
+      const controlDeadline = performance.now() + (host.timeoutMs || 10_000);
       const assertRecoveryOpen = () => {
         signal.throwIfAborted();
-        if (generation !== contextGeneration) {
+        if (generation !== contextGeneration || threadGeneration !== (threadGenerations.get(threadId) || 0)) {
           throw new Error("The assistant connection closed during recovery.");
         }
       };
@@ -65,6 +68,7 @@ export function createCodexConversationAdapter(host) {
         if (bound && params.developerInstructions != null && instructionPrompts.get(threadId) !== params.developerInstructions) {
           throw new Error("Start a new ephemeral conversation to change its instructions.");
         }
+        assertRecoveryOpen();
         return operation(threadParameters({ ...bound?.params, ...params }, {}));
       }
       let environment = instructionEnvironment(params, fixedPolicy?.set || await host.prepareEnvironment(
@@ -138,7 +142,15 @@ export function createCodexConversationAdapter(host) {
       if (retainInstalledInstructions && (!bindingMatches || nativeStatus !== "active")) {
         // An active healthy turn keeps its installed prompt. Real control
         // recovery and the next idle admission still read current instructions.
+        assertRecoveryOpen();
+        const remainingControlMs = Math.floor(controlDeadline - performance.now());
+        if (remainingControlMs <= 0) {
+          throw new DOMException("The operation was aborted due to timeout", "TimeoutError");
+        }
+        // Instruction composition preceded the control clock originally. Only
+        // this deferred host read is excluded; spent native time is retained.
         params = await prepareInstructions(requestedParams, threadId);
+        signal = AbortSignal.timeout(remainingControlMs);
         environment = instructionEnvironment(params, environment);
         requestParams = { ...requestParams,
           ...(Object.hasOwn(params, "developerInstructions") ? { developerInstructions: params.developerInstructions } : {}),
@@ -157,6 +169,7 @@ export function createCodexConversationAdapter(host) {
         goal.createdAt === original.createdAt && goal.objective === original.objective;
       const log = (event, fields = {}) => host.log?.(event, fields, { threadId, environment });
       try {
+        assertRecoveryOpen();
         if (instructionOnly) {
           // A native goal can start work while the host reads its prompt.
           nativeStatus = await readStatus();
@@ -282,6 +295,10 @@ export function createCodexConversationAdapter(host) {
       bindings.set(id, binding);
       if (binding.params.developerInstructions != null) instructionPrompts.set(id, binding.params.developerInstructions);
     },
+    invalidateThread(id) {
+      threadGenerations.set(id, (threadGenerations.get(id) || 0) + 1);
+      bindings.delete(id);
+    },
     goalChanged: (id) => goalChanges.set(id, (goalChanges.get(id) || 0) + 1),
     get bindingCount() { return bindings.size; },
     get threadEnvironments() { return bindings; },