@jskit-ai/assistant-core 0.1.205 → 0.1.206

package/src/server/conversation/codexProvider.js

@@ -1279,6 +1279,10 @@ export class CodexAppServerAgentProvider {
       prepareHistory: (params, client, context) => this.withHistoryAdapter(params, client, context),
       threadParameters: codexAppServerThreadRequestParams,
       verifyEnvironment: (...args) => this.#verifyThreadEnvironment(...args),
+      recordInterruption: (threadId, turnId) => {
+        const key = JSON.stringify([threadId, turnId]);
+        this.interruptedTurns.set(key, this.interruptedTurns.get(key) || "control_reconfiguration");
+      },
       onRecoveryFailure: (id) => {
         const probe = this.threadControlProbes.get(id);
         if (probe && !probe.verified) {
@@ -1292,7 +1296,7 @@ export class CodexAppServerAgentProvider {
     });
     this.threadControlProbes = new Map();
     this.commandExecutions = new Map();
-    this.interruptedTurns = new Set();
+    this.interruptedTurns = new Map();
     this.commandStopFailure = null;
   }
 
@@ -2574,16 +2578,22 @@ export class CodexAppServerAgentProvider {
     };
   }
 
-  async interruptTurn(threadId = "", turnId = "") {
+  interruptionOutcome(threadId = "", turnId = "") {
+    const key = JSON.stringify([normalizeAgentText(threadId), normalizeAgentText(turnId)]);
+    return this.interruptedTurns.get(key) || "";
+  }
+
+  async interruptTurn(threadId = "", turnId = "", { outcome = "" } = {}) {
     const client = await this.activeClient();
     return this.runRequest(
-      () => this.#interruptTurn(client, normalizeAgentText(threadId), normalizeAgentText(turnId)),
+      () => this.#interruptTurn(client, normalizeAgentText(threadId), normalizeAgentText(turnId), undefined, outcome),
       "codex-app-server-turn-interrupt"
     );
   }
 
-  async #interruptTurn(client, threadId, turnId, signal) {
-    this.interruptedTurns.add(JSON.stringify([threadId, turnId]));
+  async #interruptTurn(client, threadId, turnId, signal, outcome = "") {
+    const key = JSON.stringify([threadId, turnId]);
+    this.interruptedTurns.set(key, outcome || this.interruptedTurns.get(key) || "");
     const result = await client.request("turn/interrupt", { threadId, turnId }, { signal });
     await Promise.all([...this.commandExecutions.values()]
       .filter((command) => command.threadId === threadId && command.turnId === turnId)

package/src/server/conversation/codexProviderOwner.js

@@ -8,7 +8,7 @@ import { codexAppServerProjectHookTrustConfig } from "./codexConfiguration.js";
 // inspect the complete inventory by native runtime identity.
 const codexAppServerProviders = new Map();
 const codexAppServerOwnedRuntimes = new Map();
-let codexAppServerProviderLifecycle = Promise.resolve();
+const codexAppServerRuntimeLifecycles = new Map();
 const normalizeText = value => String(value || "").trim();
 
 export function codexAppServerOwnedRuntimeKey(providerKey = "", providerOptions = {}) {
@@ -18,6 +18,18 @@ export function codexAppServerOwnedRuntimeKey(providerKey = "", providerOptions
     : `provider:${normalizeText(providerKey)}`;
 }
 
+function withRuntimeLifecycle(runtimeKey, operation) {
+  const previous = codexAppServerRuntimeLifecycles.get(runtimeKey) || Promise.resolve();
+  const run = previous.catch(() => null).then(operation);
+  const tail = run.catch(() => null).finally(() => {
+    if (codexAppServerRuntimeLifecycles.get(runtimeKey) === tail) {
+      codexAppServerRuntimeLifecycles.delete(runtimeKey);
+    }
+  });
+  codexAppServerRuntimeLifecycles.set(runtimeKey, tail);
+  return run;
+}
+
 export function codexAppServerRuntimeStopWasVerified(result = {}) {
   return result?.stopped === true ||
     result?.processExitVerified === true ||
@@ -57,6 +69,7 @@ export function createCodexAppServerProviderOwner({
   const records = new Map();
   const lifecycleTasks = new Set();
   const runtimeAcquisitions = new Set();
+  let codexAppServerProviderLifecycle = Promise.resolve();
   let closing = false;
   let runtimeLifecycle = null;
   let codexAppServerChatModelCatalog = null;
@@ -99,8 +112,12 @@ export function createCodexAppServerProviderOwner({
     return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
   }
 
-  function withLifecycle(operation) {
-    const run = codexAppServerProviderLifecycle.catch(() => null).then(operation);
+  function withLifecycle(operation, providerKey = "", providerOptions = null) {
+    const run = codexAppServerProviderLifecycle.catch(() => null).then(() => {
+      if (!providerKey && !providerOptions) return operation();
+      const options = providerOptions || records.get(normalizeText(providerKey))?.providerOptions;
+      return withRuntimeLifecycle(codexAppServerOwnedRuntimeKey(providerKey, options), operation);
+    });
     const tracked = run.catch(() => null).finally(() => {
       lifecycleTasks.delete(tracked);
     });
@@ -259,12 +276,12 @@ export function createCodexAppServerProviderOwner({
   async function ensureSession(context, mainThreadId = "") {
     const sessionId = context.sessionId;
     const providerOptions = context.providerOptions;
-    let provider = await withLifecycle(() => providerForSession(context));
+    const providerKey = context.providerKey;
+    let provider = await withLifecycle(() => providerForSession(context), providerKey, providerOptions);
     if (provider.observationFailure) {
       await provider.failObservation(provider.observationFailure);
-      provider = await withLifecycle(() => providerForSession(context));
+      provider = await withLifecycle(() => providerForSession(context), providerKey, providerOptions);
     }
-    const providerKey = context.providerKey;
     if (mainThreadId) {
       const fields = context.keyFields(providerKey);
       context.runOwner.runtimeLifecycle.rememberManagedSession(providerKey, {
@@ -425,7 +442,8 @@ export function createCodexAppServerProviderOwner({
 
   function stopCachedProvider(providerKey = "", options = {}) {
     return withLifecycle(
-      () => stopCachedProviderUnlocked(providerKey, options)
+      () => stopCachedProviderUnlocked(providerKey, options),
+      normalizeText(providerKey)
     );
   }
 
@@ -496,47 +514,50 @@ export function createCodexAppServerProviderOwner({
       assertOpen();
       signal?.throwIfAborted();
       const providerOptions = await prepareProviderOptions();
-      const existing = codexAppServerOwnedRuntimes.get(
-        codexAppServerOwnedRuntimeKey("", providerOptions)
-      );
-      const provider = existing?.provider || providerFactory(providerOptions);
-      let runtime = null;
-      let catalog = null;
-      let identity = "";
-      try {
-        identity = JSON.stringify(await provider.currentRuntimeInfo());
-        signal?.throwIfAborted();
-        if (codexAppServerChatModelCatalog?.identity === identity &&
-            codexAppServerChatModelCatalog.expiresAt > Date.now()) {
-          return codexAppServerChatModelCatalog.value;
-        }
-        if (!existing?.provider) {
-          runtime = await acquireRuntime({
-            operation: () => provider.ensureRuntime(),
-            provider,
-            providerOptions
-          });
-        }
-        catalog = await provider.listModels({ includeHidden: false, limit: 100 }, { signal });
-      } finally {
-        if (!existing?.provider) {
-          try {
-            if ((runtime || provider.runtime)?.reused === false) {
-              await stopOwnedRuntime({ provider, resources });
-            } else {
-              forgetOwnedRuntime(provider);
+      return withRuntimeLifecycle(codexAppServerOwnedRuntimeKey("", providerOptions), async () => {
+        const existing = codexAppServerOwnedRuntimes.get(
+          codexAppServerOwnedRuntimeKey("", providerOptions)
+        );
+        const provider = existing?.provider || providerFactory(providerOptions);
+        let runtime = null;
+        let catalog = null;
+        let identity = "";
+        try {
+          assertOpen();
+          identity = JSON.stringify(await provider.currentRuntimeInfo());
+          signal?.throwIfAborted();
+          if (codexAppServerChatModelCatalog?.identity === identity &&
+              codexAppServerChatModelCatalog.expiresAt > Date.now()) {
+            return codexAppServerChatModelCatalog.value;
+          }
+          if (!existing?.provider) {
+            runtime = await acquireRuntime({
+              operation: () => provider.ensureRuntime(),
+              provider,
+              providerOptions
+            });
+          }
+          catalog = await provider.listModels({ includeHidden: false, limit: 100 }, { signal });
+        } finally {
+          if (!existing?.provider) {
+            try {
+              if ((runtime || provider.runtime)?.reused === false) {
+                await stopOwnedRuntime({ provider, resources });
+              } else {
+                forgetOwnedRuntime(provider);
+              }
+            } finally {
+              provider.close();
             }
-          } finally {
-            provider.close();
           }
         }
-      }
-      codexAppServerChatModelCatalog = {
-        expiresAt: Date.now() + cacheMs,
-        identity,
-        value: catalog
-      };
-      return catalog;
+        codexAppServerChatModelCatalog = {
+          expiresAt: Date.now() + cacheMs,
+          identity,
+          value: catalog
+        };
+        return catalog;
+      });
     });
   }
 
@@ -939,8 +960,10 @@ export function createCodexAppServerProviderOwner({
     return withLifecycle(async () => {
       const prepared = preparation.read();
       if (Object.hasOwn(prepared, "value")) return prepared.value;
-      const evidence = await releasePersistedRuntimeProof(prepared.runtimeOptions, prepared);
-      return prepared.complete(evidence);
+      return withRuntimeLifecycle(codexAppServerOwnedRuntimeKey("", prepared.runtimeOptions), async () => {
+        const evidence = await releasePersistedRuntimeProof(prepared.runtimeOptions, prepared);
+        return prepared.complete(evidence);
+      });
     });
   }
 

package/src/server/conversation/codexProviderSelection.js

@@ -196,8 +196,11 @@ export function createCodexProviderSelection({
       restoration.projectRuntimeRoot, restoration.context
     ));
     const providerOptions = await preparation.providerOptions;
-    const provider = await providerSessions.owner.withLifecycle(() =>
-      providerSessions.owner.providerForSession(providerSessions.context(sessionId, providerOptions))
+    const context = providerSessions.context(sessionId, providerOptions);
+    const provider = await providerSessions.owner.withLifecycle(
+      () => providerSessions.owner.providerForSession(context),
+      context.providerKey,
+      providerOptions
     );
     return readCodexAppServerAccountIdentity(provider, helperOwnershipError);
   }

package/src/server/conversation/codexRuntimeLifecycle.js

@@ -50,7 +50,8 @@ export function createCodexRuntimeLifecycle({
 
   function retireAndCloseCodexAppServerProvider(providerKey = "", options = {}) {
     return providerSessions.owner.withLifecycle(
-      () => retireAndCloseCodexAppServerProviderUnlocked(providerKey, options)
+      () => retireAndCloseCodexAppServerProviderUnlocked(providerKey, options),
+      normalizeText(providerKey)
     );
   }
 

package/src/server/conversation/codexTurn.js

@@ -118,7 +118,14 @@ export function createCodexAppServerRunOwner({
     providerSessions = { ...providerSessions, managed: providerSessions.managed || new Map() };
   }
   const liveProgressMaxLength = 320;
-  const turnOutcomes = { PROVIDER_FAILURE: "provider_failure", RESPONSE_DELIVERY_FAILURE: "response_delivery_failure", SERVICE_RESTART: "service_restart", USER_CANCELLED: "user_cancelled" };
+  const turnOutcomes = {
+    PROVIDER_FAILURE: "provider_failure",
+    RESPONSE_DELIVERY_FAILURE: "response_delivery_failure",
+    SERVICE_RESTART: "service_restart",
+    USER_CANCELLED: "user_cancelled",
+    CONTROL_RECONFIGURATION: "control_reconfiguration",
+    INTERRUPTED: "interrupted"
+  };
   const finalizingGraceMs = 10000;
   const snapshotRecoveryItemLimit = 25;
   const helperOwnershipError = createCodexHelperOwnershipError({ errorPrefix });
@@ -398,6 +405,7 @@ export function createCodexAppServerRunOwner({
     codexAppServerConversationContext,
     codexAppServerEphemeralScopeContext,
     createCodexAppServerConversation,
+    runDetachedCodexAppServerConversation,
     startCodexAppServerConversationTurn,
     readCodexAppServerConversation,
     waitForCodexAppServerConversationTurn,
@@ -580,6 +588,7 @@ export function createCodexAppServerRunOwner({
     observeConversation: observeCodexConversation,
     readPersistentConversation: readPersistentCodexConversation,
     createConversation: createCodexAppServerConversation,
+    runDetachedConversation: runDetachedCodexAppServerConversation,
     steerConversationTurn: steerCodexAppServerConversationTurn,
     startConversationTurn: startCodexAppServerConversationTurn,
     acquireDetachedThread: acquireCodexAppServerDetachedThread,

package/src/server/conversation/codexTurnControl.js

@@ -185,7 +185,7 @@ export function createCodexTurnControl({
         return { value: codexAppServerFrozenTurnInterruptResponse({ threadId, turnId }) };
       }
       try {
-        result = await provider.interruptTurn(threadId, turnId);
+        result = await provider.interruptTurn(threadId, turnId, { outcome: turnOutcomes.USER_CANCELLED });
       } catch (error) {
         if (error?.code === `${provider?.errorPrefix ?? errorPrefix}codex_command_stop_unconfirmed`) throw error;
         requestError = error;

package/src/server/conversation/codexTurnRecovery.js

@@ -812,11 +812,14 @@ export function createCodexTurnRecovery({
     );
   }
 
-  function codexAppServerStoppedTurnMessage(status = "", error = "") {
+  function codexAppServerStoppedTurnMessage(status = "", error = "", outcome = "") {
     const normalizedStatus = normalizeCodexRunText(status);
-    const base = normalizedStatus === "interrupted"
-      ? "Codex app-server was interrupted before completing this turn."
-      : "Codex app-server failed before completing this turn.";
+    let base = "Codex app-server failed before completing this turn.";
+    if (normalizedStatus === "interrupted") {
+      base = outcome === turnOutcomes.CONTROL_RECONFIGURATION
+        ? "Codex app-server was interrupted while its controls were restored."
+        : "Codex app-server was interrupted before completing this turn.";
+    }
     const normalizedError = normalizeCodexRunText(error);
     return normalizedError ? `${base} ${normalizedError}` : base;
   }
@@ -824,7 +827,7 @@ export function createCodexTurnRecovery({
   async function stopCodexAppServerTurnWithProviderFailure(sessionId = "", threadId = "", turnId = "", {
     error = "",
     ok = false,
-    outcome = turnOutcomes.PROVIDER_FAILURE,
+    outcome = "",
     provider = null,
     status = "failed",
     usageLimitExceeded = false,
@@ -834,6 +837,16 @@ export function createCodexTurnRecovery({
     const normalizedThreadId = normalizeCodexRunText(threadId);
     const normalizedTurnId = normalizeCodexRunText(turnId);
     const normalizedStatus = normalizeCodexRunText(status) || "failed";
+    let resolvedOutcome = normalizeCodexRunText(outcome);
+    if (!resolvedOutcome) {
+      if (normalizedStatus === "interrupted") {
+        const recorded = provider?.interruptionOutcome?.(normalizedThreadId, normalizedTurnId);
+        resolvedOutcome = [turnOutcomes.USER_CANCELLED, turnOutcomes.CONTROL_RECONFIGURATION].includes(recorded)
+          ? recorded : turnOutcomes.INTERRUPTED;
+      } else {
+        resolvedOutcome = turnOutcomes.PROVIDER_FAILURE;
+      }
+    }
     const runtime = await createRuntime();
     const session = await runtime.getSession(normalizedSessionId);
     const turn = turnState(session);
@@ -875,13 +888,13 @@ export function createCodexTurnRecovery({
         status: "inProgress"
       };
     }
-    const message = codexAppServerStoppedTurnMessage(normalizedStatus, error);
+    const message = codexAppServerStoppedTurnMessage(normalizedStatus, error, resolvedOutcome);
     await outcomeNotice(
       runtime,
       normalizedSessionId,
       normalizedThreadId,
       normalizedTurnId,
-      outcome,
+      resolvedOutcome,
       error,
       { usageLimitExceeded }
     );
@@ -890,7 +903,7 @@ export function createCodexTurnRecovery({
       status: normalizedStatus,
       threadId: normalizedThreadId,
       turnId: normalizedTurnId,
-      turnOutcome: outcome
+      turnOutcome: resolvedOutcome
     });
     cleanupCodexAppServerUntrackedTurn(normalizedThreadId, normalizedTurnId);
     return {

package/src/server/conversation/openCodeRuntime.js

@@ -994,7 +994,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       currentTurn.state = "interrupted";
       await application.writeRun(currentTurn, "interrupted", currentTurn.observationError);
     }
-    const currentMonitor = monitors.get(key);
+    let currentMonitor = monitors.get(key);
     let currentThreadId = input.threadId;
     const ownershipMatchesTurn = Boolean(
       currentMonitor &&
@@ -1030,6 +1030,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     let target = null;
     let admission = null;
     let dispatchTurn = null;
+    let dispatchMonitor = null;
+    let previousInputMessageId = null;
+    let previousAdmission;
     try {
       const preparation = await application.prepare({ overwrite: !currentMonitor, threadId: currentThreadId });
       const preparedTarget = preparation.process ? await acquirePrepared(preparation.process) : preparation.target;
@@ -1039,15 +1042,33 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         startingTurn.threadId = currentThreadId;
       }
       const prompt = await application.prompt();
+      // Preparation can outlive the preceding turn's final projection. Do not
+      // attach a new input to a monitor that has already claimed retirement.
+      currentMonitor = monitors.get(key);
+      if (currentMonitor && !turns.get(key)?.active) {
+        await currentMonitor;
+        currentMonitor = monitors.get(key);
+      }
+      admission = Promise.withResolvers();
+      // The observer may be between polls when dispatch or persistence fails.
+      // Keep the raw promise rejectable without an unhandled rejection.
+      void admission.promise.catch(() => {});
       let eventReady = null;
-      if (!currentMonitor) {
-        admission = Promise.withResolvers();
+      if (currentMonitor) {
+        dispatchTurn = turns.get(key);
+        previousInputMessageId = dispatchTurn.inputMessageId;
+        previousAdmission = dispatchTurn.admission;
+        dispatchTurn.admission = admission;
+        dispatchTurn.inputMessageId = providerMessageId;
+        dispatchTurn.updatedAt = new Date().toISOString();
+        dispatchMonitor = currentMonitor;
+      } else {
         eventReady = Promise.withResolvers();
-        beginMessageMonitor(key, target, { id: providerMessageId, eventStartedAt, startedAt }, {
+        dispatchMonitor = beginMessageMonitor(key, target, { id: providerMessageId, eventStartedAt, startedAt }, {
           ...options, admission, eventReady
         }, application.monitor);
+        dispatchTurn = turns.get(key);
       }
-      dispatchTurn = turns.get(key);
       admitted = await dispatchOpenCodeTurn(null, null, dispatchTurn, {
         get agent() { return prompt.agent; },
         delivery: currentMonitor ? "steer" : "queue",
@@ -1070,11 +1091,23 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         authorizeAttachments: prompt.authorizeAttachments
       });
     } catch (error) {
-      if (error?.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 408) {
-        await input.onPromptRejected?.();
+      const rejected = error?.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 408;
+      const retainPreviousInput = previousInputMessageId !== null &&
+        (dispatchTurn?.promptAttempted !== true || rejected);
+      if (retainPreviousInput) {
+        if (dispatchTurn.admission === admission && dispatchTurn.inputMessageId === providerMessageId) {
+          dispatchTurn.inputMessageId = previousInputMessageId;
+          dispatchTurn.admission = previousAdmission;
+        }
+        admission.resolve();
+      } else {
+        // Attempted unknown admission must retain the new input and use the
+        // same observer's original Stop/error recovery, never roll back to A.
+        admission?.reject(error);
+        dispatchTurn?.abortController?.abort(error);
       }
-      admission?.reject(error);
-      if (admission) await monitors.get(key);
+      if (rejected) await input.onPromptRejected?.();
+      if (admission && !retainPreviousInput) await dispatchMonitor;
       if (startingTurn && !admission && !monitors.has(key)) {
         startingTurn.active = false;
         startingTurn.error = text(error?.message) || "OpenCode prompt delivery failed.";
@@ -1089,26 +1122,21 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       return { failure: { error, attempted: dispatchTurn?.promptAttempted === true, threadId: currentThreadId,
         turn: openCodeTurnSnapshot(turns.get(key) || startingTurn, currentThreadId) } };
     }
+    if (dispatchTurn.admission === admission && dispatchTurn.inputMessageId === providerMessageId) {
+      dispatchTurn.inputMessageId = text(admitted.id);
+      dispatchTurn.updatedAt = new Date().toISOString();
+    }
     let conversationTurn;
     try {
       conversationTurn = await application.commit(admitted);
     } catch (error) {
-      admission?.reject(error);
+      admission.reject(error);
+      dispatchTurn.abortController.abort(error);
+      // Preserve the persistence error while joining the original recovery.
+      await dispatchMonitor.catch(() => null);
       throw error;
     }
-    const activeMonitor = monitors.get(key);
-    if (activeMonitor) {
-      const activeTurn = turns.get(key);
-      activeTurn.inputMessageId = text(admitted.id);
-      activeTurn.updatedAt = new Date().toISOString();
-    } else {
-      beginMessageMonitor(key, target, {
-        ...admitted,
-        eventStartedAt,
-        startedAt
-      }, options, application.monitor);
-    }
-    admission?.resolve();
+    admission.resolve();
     const turn = openCodeTurnSnapshot(turns.get(key), target.upstreamSessionId);
     return {
       conversationTurn,
@@ -1218,47 +1246,60 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         signal.throwIfAborted();
         turn.state = "active";
         await writeRun(turn, "active");
-        const completion = await waitForOpenCodeFinalResponse(
-          target.server.client,
-          target.upstreamSessionId,
-          turn,
-          {
-            ...finalResponse,
-            // Preserve the reasoning-only completion before the native recovery
-            // input replaces the projection boundary. Replayed writes are no-ops.
-            beforeRecovery: async completion => {
-              await projectMessages(completion.messages, { inputMessageId: turn.inputMessageId });
-              await finalResponse.beforeRecovery?.(completion);
-            },
-            onMessages: async (messages, inputMessageId) => {
-              const latest = openCodeLastAssistantResult(messages, { readError: finalResponse.readError }).message;
-              const phase = latest?.summary === true && Number(latest.time?.created) >= turn.eventStartedAt &&
-                !latest.time?.completed && !latest.finish && !latest.error ? "compacting" : "";
-              if (turn.active && !signal.aborted && text(turn.phase) !== phase) {
-                turn.phase = phase;
-                turn.updatedAt = new Date().toISOString();
-                await writeRun(turn, turn.state);
-              }
-              return projectMessages(messages, { inputMessageId, streaming: true });
-            },
-            readFailure: events.readFailure,
-            signal
+        for (;;) {
+          const completion = await waitForOpenCodeFinalResponse(
+            target.server.client,
+            target.upstreamSessionId,
+            turn,
+            {
+              ...finalResponse,
+              // Preserve the reasoning-only completion before the native recovery
+              // input replaces the projection boundary. Replayed writes are no-ops.
+              beforeRecovery: async completion => {
+                await projectMessages(completion.messages, { inputMessageId: completion.inputMessageId });
+                await finalResponse.beforeRecovery?.(completion);
+              },
+              onMessages: async (messages, inputMessageId) => {
+                const latest = openCodeLastAssistantResult(messages, { readError: finalResponse.readError }).message;
+                const phase = latest?.summary === true && Number(latest.time?.created) >= turn.eventStartedAt &&
+                  !latest.time?.completed && !latest.finish && !latest.error ? "compacting" : "";
+                if (turn.active && !signal.aborted && text(turn.phase) !== phase) {
+                  turn.phase = phase;
+                  turn.updatedAt = new Date().toISOString();
+                  await writeRun(turn, turn.state);
+                }
+                return projectMessages(messages, { inputMessageId, streaming: true });
+              },
+              readFailure: events.readFailure,
+              signal
+            }
+          );
+          const admission = turn.admission;
+          await admission?.promise;
+          signal.throwIfAborted();
+          if (admission !== turn.admission || completion.inputMessageId !== text(turn.inputMessageId)) {
+            continue;
           }
-        );
-        const projection = await projectMessages(completion.messages, {
-          inputMessageId: turn.inputMessageId
-        });
-        signal.throwIfAborted();
-        failure = projection.failure || text(events.readFailure()?.message);
-        providerApiFailure = projection.providerApiFailure || openCodeProviderApiFailure(events.readFailure());
-        if (!failure && !turn.interruptRequested && !text(completion.result?.text)) {
-          failure = "OpenCode finished without a user-facing final response. Please send your message again.";
-          finalState = "failed";
-        } else if (failure) {
-          credentialFailure = openCodeCredentialFailure(failure);
-          finalState = "failed";
-        } else if (turn.interruptRequested) {
-          finalState = "interrupted";
+          const projection = await projectMessages(completion.messages, {
+            inputMessageId: completion.inputMessageId
+          });
+          await turn.admission?.promise;
+          signal.throwIfAborted();
+          if (admission !== turn.admission || completion.inputMessageId !== text(turn.inputMessageId)) {
+            continue;
+          }
+          failure = projection.failure || text(events.readFailure()?.message);
+          providerApiFailure = projection.providerApiFailure || openCodeProviderApiFailure(events.readFailure());
+          if (!failure && !turn.interruptRequested && !text(completion.result?.text)) {
+            failure = "OpenCode finished without a user-facing final response. Please send your message again.";
+            finalState = "failed";
+          } else if (failure) {
+            credentialFailure = openCodeCredentialFailure(failure);
+            finalState = "failed";
+          } else if (turn.interruptRequested) {
+            finalState = "interrupted";
+          }
+          break;
         }
       } catch (error) {
         if (turn.interruptAcknowledged) {
@@ -1287,11 +1328,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
           }
         }
       } finally {
+        // Claim retirement before awaited cleanup/checkpointing. A new Send
+        // joins this monitor's cleanup instead of steering an unobserved turn.
+        turn.active = finalState === "active";
         await events.close();
         if (credentialFailure || finalState === "failed") {
           failure = await completeResult(turn, { credentialFailure, providerApiFailure, finalState, failure });
         }
-        turn.active = finalState === "active";
         turn.error = failure;
         turn.state = finalState;
         turn.updatedAt = new Date().toISOString();