@jskit-ai/assistant-core 0.2.20 → 0.2.21

package/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 
+- A delivered Codex turn is held as not yet started only until Codex reports it: a `turn/started` that arrives before the `turn/start` answer counts, and a thread read listing exactly that turn as completed or failed settles a turn whose notifications were missed, so its answer is no longer kept waiting for a notification that never comes.
 - The API driver's state note, which carries the current time, follows the conversation as its last message instead of ending the system prompt, so the provider's prompt cache keeps the whole history from one turn to the next instead of charging it uncached on each turn's first model call (`@jskit-ai/agent` `runLoop`).
 - Assistant failures that reach a person translate: 63 more undotted codes render from `jskit.errors.<code>`, and 98 sentences that share a code with others, or are sent without one, carry a `messageCode` (`assistant.claude.*`, `assistant.codex.*`, `assistant.opencode.*`, `assistant.conversation.*`, `assistant.turn.*`). The English messages are unchanged.
 - The OpenCode version mismatch, Claude control-request timeout and unreadable saved Claude conversation errors carry `params` for their catalog English.

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.20",
+    "@jskit-ai/assistant-core": "0.2.21",
     "@jskit-ai/http-runtime": "0.2.9",
     "@jskit-ai/kernel": "0.2.9",
     "@mdi/js": "^7.4.47",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"

package/src/server/conversation/codexNotificationObserver.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerTurnKey, CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_AGENT_PROVIDER, CODEX_APP_SERVER_RUN_STATE } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_AGENT_PROVIDER, CODEX_APP_SERVER_RUN_STATE } from "./codexTurnState.js";
 import { codexAppServerProviderConnectionGeneration } from "./codexModelCatalog.js";
 import {
   codexAppServerAssistantItemText,
@@ -239,8 +239,8 @@ export function createCodexNotificationObserver({
         threadId: normalizedThreadId,
         turnId: codexAppServerNotificationTurnId(notification)
       };
-      // Anything Codex reports about a turn means it has started that turn.
-      journal.unstartedTurns.delete(codexAppServerTurnKey(normalizedThreadId, notificationContext.turnId));
+      // Anything Codex reports about a turn means it has started that turn, even before its answer to turn/start.
+      journal.noteTurnReported(normalizedThreadId, notificationContext.turnId);
       if (method === "thread/tokenUsage/updated") {
         notificationQueue.run(notificationContext, async () => {
           const store = await createStore(normalizedSessionId);

package/src/server/conversation/codexPromptDispatch.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerErrorMessage, codexAppServerSteerFailure, codexAppServerMessageRequiresNewTurn, codexAppServerMessageDeferred, codexAppServerTurnKey } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerErrorMessage, codexAppServerSteerFailure, codexAppServerMessageRequiresNewTurn, codexAppServerMessageDeferred } from "./codexTurnState.js";
 import { codexAppServerRequestIsInvalid } from "./codexProviderThreads.js";
 import { codexLocalImageInput, codexAppServerDeliveredTurn, sendCodexAppServerPrompt } from "./codexProviderTurns.js";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
@@ -74,9 +74,9 @@ export function createCodexPromptDispatch({
     if (!deliveredTurnId) {
       throw new Error("Codex app-server accepted the prompt without returning a turn id.");
     }
-    // Codex answers turn/start before it starts the turn; its notifications about the turn say when it has.
+    // Codex usually answers turn/start before it starts the turn; its notifications about the turn say when it has.
     if (!codexAppServerTurnStatusIsComplete(deliveredTurnStatus)) {
-      journal.unstartedTurns.add(codexAppServerTurnKey(threadId, deliveredTurnId));
+      journal.markTurnUnstarted(threadId, deliveredTurnId);
     }
     delivery.pendingUserMessage(promptSessionId, clientUserMessageId)?.onNativeReceipt();
     await recovery.markTurnActive(sessionId, {

package/src/server/conversation/codexResultSettlement.js

@@ -1,4 +1,4 @@
-import { CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_APP_SERVER_RESULT_PROCESSED_EVENT, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerProcessedResultEvent, codexAppServerTurnAwaitsProviderIdentity, codexAppServerTurnCanAdoptSuccessor, codexAppServerAgentRun, CODEX_APP_SERVER_RUN_STATE, codexAppServerTurnKey } from "./codexTurnState.js";
+import { CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_APP_SERVER_RESULT_PROCESSED_EVENT, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerProcessedResultEvent, codexAppServerTurnAwaitsProviderIdentity, codexAppServerTurnCanAdoptSuccessor, codexAppServerAgentRun, CODEX_APP_SERVER_RUN_STATE } from "./codexTurnState.js";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
 /**
@@ -325,10 +325,7 @@ export function createCodexResultSettlement({ journal, output, createRuntime, pu
       normalizedThreadId,
       previousTurnId
     );
-    journal.completedTurns.add(codexAppServerTurnKey(
-      normalizedThreadId,
-      previousTurnId
-    ));
+    journal.markTurnCompleted(normalizedThreadId, previousTurnId);
     const previousResultKey = output.resultFinalizationKey(
       normalizedSessionId,
       normalizedThreadId,

package/src/server/conversation/codexRunJournal.js

@@ -3,6 +3,7 @@ import crypto from "node:crypto";
 import { isRecord, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
 const CODEX_APP_SERVER_PROMPT_CLAIM_GRACE_MS = 15000;
+const CODEX_APP_SERVER_REPORTED_TURN_LIMIT = 256;
 const CODEX_APP_SERVER_STOPPED_BY_SHUTDOWN_EVENT = "codex-app-server-stopped-by-shutdown";
 
 /**
@@ -46,6 +47,55 @@ function codexAppServerDateValueMs(value = "") {
   return Number.isFinite(parsed) ? parsed : 0;
 }
 
+/**
+ * Which turns Codex accepted with turn/start but has not reported yet: until it reports one, its thread still reads
+ * idle, so an idle read cannot settle it. Codex's turn/started can also arrive before its answer to turn/start, so the
+ * turns it reported most recently are remembered and never marked as not started. Only a turn whose answer is still on
+ * its way needs that, so the newest few are enough.
+ * @param {Set<string>} completedTurns the journal's settled turn keys, which markTurnCompleted adds to
+ */
+function createCodexAppServerTurnStarts(completedTurns) {
+  const unstartedTurns = new Set();
+  // Oldest first.
+  const reportedTurns = new Set();
+
+  /** Codex reported this turn, in a notification or by listing it as finished, so it has started it. */
+  function noteTurnReported(threadId = "", turnId = "") {
+    if (!normalizeText(turnId)) return;
+    const key = codexAppServerTurnKey(threadId, turnId);
+    unstartedTurns.delete(key);
+    reportedTurns.delete(key);
+    reportedTurns.add(key);
+    if (reportedTurns.size > CODEX_APP_SERVER_REPORTED_TURN_LIMIT) {
+      reportedTurns.delete(reportedTurns.values().next().value);
+    }
+  }
+
+  /** A turn Codex accepted waits for its report before an idle read can settle it, unless Codex already reported it. */
+  function markTurnUnstarted(threadId = "", turnId = "") {
+    const key = codexAppServerTurnKey(threadId, turnId);
+    if (!reportedTurns.has(key)) unstartedTurns.add(key);
+  }
+
+  function turnIsUnstarted(threadId = "", turnId = "") {
+    return unstartedTurns.has(codexAppServerTurnKey(threadId, turnId));
+  }
+
+  /** The run owner settled this turn: nothing waits for Codex to start it any more. */
+  function markTurnCompleted(threadId = "", turnId = "") {
+    const key = codexAppServerTurnKey(threadId, turnId);
+    completedTurns.add(key);
+    unstartedTurns.delete(key);
+  }
+
+  return Object.freeze({
+    noteTurnReported,
+    markTurnUnstarted,
+    turnIsUnstarted,
+    markTurnCompleted
+  });
+}
+
 /**
  * Native run claims, guarded journal writes and status retirement. The containing run owner shares these exact Sets
  * and Maps by reference.
@@ -88,8 +138,7 @@ export function createCodexRunJournal({
   isClosing
 }) {
   const codexAppServerCompletedTurns = new Set();
-  // Turns Codex accepted with turn/start but has not yet reported: until it does, its thread still reads idle.
-  const codexAppServerUnstartedTurns = new Set();
+  const turnStarts = createCodexAppServerTurnStarts(codexAppServerCompletedTurns);
   const codexAppServerProcessedTurns = new Set();
   const codexAppServerActiveTimers = new Map();
   const codexAppServerFinalizingTimers = new Map();
@@ -639,7 +688,10 @@ export function createCodexRunJournal({
 
   return Object.freeze({
     completedTurns: codexAppServerCompletedTurns,
-    unstartedTurns: codexAppServerUnstartedTurns,
+    noteTurnReported: turnStarts.noteTurnReported,
+    markTurnUnstarted: turnStarts.markTurnUnstarted,
+    turnIsUnstarted: turnStarts.turnIsUnstarted,
+    markTurnCompleted: turnStarts.markTurnCompleted,
     processedTurns: codexAppServerProcessedTurns,
     activeTimers: codexAppServerActiveTimers,
     finalizingTimers: codexAppServerFinalizingTimers,

package/src/server/conversation/codexThreadStatus.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerTurnCanAdoptSuccessor, codexAppServerErrorMessage, codexAppServerTurnKey } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerObservedTurnFinished, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerTurnCanAdoptSuccessor, codexAppServerErrorMessage } from "./codexTurnState.js";
 import { isRecord, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { codexAppServerStatusFromValue } from "./codexEvents.js";
 import { codexAppServerThreadRawValue, codexAppServerThreadTurnId, codexAppServerThreadError } from "./codexThreadSnapshot.js";
@@ -200,12 +200,16 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
         turnId
       };
     }
+    // Codex lists the tracked turn as finished: it ran, even if its notifications about it were missed.
+    if (trackedProviderTurn && codexAppServerObservedTurnFinished(thread, trackedProviderTurn.turnId)) {
+      journal.noteTurnReported(trackedProviderTurn.threadId, trackedProviderTurn.turnId);
+    }
     // Codex has accepted the tracked turn but not started it. Until it does, its thread reads idle and lists the
     // turn as interrupted, so only Codex's own report about the turn settles it.
     if (
       trackedProviderTurn?.state === "active" &&
       !codexAppServerTurnStatusIsActive(status) &&
-      journal.unstartedTurns.has(codexAppServerTurnKey(trackedProviderTurn.threadId, trackedProviderTurn.turnId))
+      journal.turnIsUnstarted(trackedProviderTurn.threadId, trackedProviderTurn.turnId)
     ) {
       debugLog("appServerThread.reconcile.awaitingProviderStart", {
         sessionId: normalizedSessionId,

package/src/server/conversation/codexTurnEndings.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsActive, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerTurnOwnsActiveGoal, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerTurnAwaitsProviderIdentity, codexAppServerTurnCanReceiveProviderActivity, codexAppServerTurnKey } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerTurnOwnsActiveGoal, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerTurnAwaitsProviderIdentity, codexAppServerTurnCanReceiveProviderActivity } from "./codexTurnState.js";
 import { codexAppServerThreadTurnId } from "./codexThreadSnapshot.js";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
@@ -201,7 +201,7 @@ export function createCodexTurnEndings({
       };
     }
     if (journal.runInputSource(codexAppServerAgentRun(session)) === "terminal") {
-      journal.completedTurns.add(codexAppServerTurnKey(normalizedThreadId, normalizedTurnId));
+      journal.markTurnCompleted(normalizedThreadId, normalizedTurnId);
       output.cleanupUntrackedTurn(normalizedThreadId, normalizedTurnId);
       await journal.markTurnIdle(normalizedSessionId, {
         status: normalizedStatus,
@@ -217,7 +217,7 @@ export function createCodexTurnEndings({
     const alreadyFinalizing = existingTurn.state === "finalizing" &&
       existingTurn.threadId === normalizedThreadId &&
       existingTurn.turnId === normalizedTurnId;
-    journal.completedTurns.add(codexAppServerTurnKey(normalizedThreadId, normalizedTurnId));
+    journal.markTurnCompleted(normalizedThreadId, normalizedTurnId);
     if (!alreadyFinalizing) {
       await journal.markTurnFinalizing(normalizedSessionId, {
         status: normalizedStatus,

package/src/server/conversation/codexTurnRecovery.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerPendingUserMessageOwnership, codexAppServerTurnCanAdoptSuccessor, codexAppServerTurnKey } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerObservedTurnFinished, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerPendingUserMessageOwnership, codexAppServerTurnCanAdoptSuccessor } from "./codexTurnState.js";
 import { codexAppServerProviderTurnForOperation, codexAppServerThreadTurnId, codexAppServerThreadError } from "./codexThreadSnapshot.js";
 import { createCodexTurnActivity } from "./codexTurnActivity.js";
 import { createCodexTurnEndings } from "./codexTurnEndings.js";
@@ -270,16 +270,21 @@ export function createCodexTurnRecovery({
     if (!codexAppServerTurnStatusIsComplete(status)) {
       return currentSession;
     }
-    if (journal.unstartedTurns.has(codexAppServerTurnKey(currentTurn.threadId, currentTurn.turnId))) {
-      // Codex has accepted this turn but not started it, and its thread reads idle until it does.
-      debugLog("appServerTurn.reconcile.awaitingProviderStart", {
-        sessionId,
-        status,
-        threadId: currentTurn.threadId,
-        turnId: currentTurn.turnId
-      });
-      scheduleCodexAppServerActiveRecovery(sessionId);
-      return currentSession;
+    if (journal.turnIsUnstarted(currentTurn.threadId, currentTurn.turnId)) {
+      // Codex may have accepted this turn without starting it: its thread reads idle until it does. Only Codex's own
+      // listing of the turn as finished settles it before a notification about the turn arrives.
+      const observed = await codexAppServerReadThreadStatus(provider, currentTurn.threadId, { observeLatestTurn: true });
+      if (!codexAppServerObservedTurnFinished(observed, currentTurn.turnId)) {
+        debugLog("appServerTurn.reconcile.awaitingProviderStart", {
+          sessionId,
+          status,
+          threadId: currentTurn.threadId,
+          turnId: currentTurn.turnId
+        });
+        scheduleCodexAppServerActiveRecovery(sessionId);
+        return currentSession;
+      }
+      journal.noteTurnReported(currentTurn.threadId, currentTurn.turnId);
     }
     const completedTurnId = providerTurnId || currentTurn.turnId;
     debugLog("appServerTurn.reconcile.complete", {

package/src/server/conversation/codexTurnState.js

@@ -38,6 +38,19 @@ function codexAppServerThreadStatus(thread = {}) {
   return liveStatus;
 }
 
+/**
+ * Whether a thread read lists exactly this turn as finished, completed or failed. Codex lists a turn it has accepted
+ * but not yet started as interrupted, so only these two say that it ran.
+ * @param {Record<string, unknown> | null} thread a read with its latest turn observed
+ * @param {string} turnId
+ */
+function codexAppServerObservedTurnFinished(thread = null, turnId = "") {
+  const observed = isRecord(thread?.observedTurn) ? thread.observedTurn : null;
+  const normalizedTurnId = normalizeNullableText(turnId);
+  if (!observed || !normalizedTurnId || normalizeNullableText(observed.id) !== normalizedTurnId) return false;
+  return ["completed", "failed"].includes(normalizeNullableText(observed.status));
+}
+
 /**
  * Reads a native thread's status, and with observeLatestTurn its latest turn too.
  * @param {import("./codexProvider.js").CodexAppServerAgentProvider | null} provider
@@ -604,4 +617,4 @@ function codexPromptInputFromRequest(input = {}) {
   return codexAppServerMessageText(input);
 }
 
-export { codexAppServerRunInputSource, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerErrorMessage, codexAppServerMessageDeferred, codexPromptInputFromRequest, CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_APP_SERVER_RESULT_PROCESSED_EVENT, CODEX_AGENT_PROVIDER, CODEX_APP_SERVER_ACTIVE_RUN_STATES };
+export { codexAppServerRunInputSource, codexAppServerThreadStatus, codexAppServerObservedTurnFinished, codexAppServerReadThreadStatus, codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerErrorMessage, codexAppServerMessageDeferred, codexPromptInputFromRequest, CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_APP_SERVER_RESULT_PROCESSED_EVENT, CODEX_AGENT_PROVIDER, CODEX_APP_SERVER_ACTIVE_RUN_STATES };

package/test/codexTurn.test.js

@@ -1955,6 +1955,82 @@ for (const read of ["starting watchdog", "status check"]) {
   });
 }
 
+// A turn Codex has accepted and not yet reported; `sendTurn` runs before Codex's answer to turn/start.
+async function unstartedTurnFixture(t, { sendTurn } = {}) {
+  const notices = [];
+  const f = await receiptFixture({
+    finalizingGraceMs: 30,
+    outcomeNotice(_runtime, _sessionId, _threadId, _turnId, outcome) { notices.push(outcome); }
+  });
+  t.after(() => f.owner.clearSessionRecoveryTimers(f.sessionId));
+  const context = dispatchContext(f);
+  f.codexStatus = "idle";
+  f.notices = notices;
+  f.started = { method: "turn/started", params: { threadId: f.threadId, turn: { id: f.turnId, status: "inProgress" } } };
+  f.run = { ...f.run, state: "starting", providerTurnId: "", providerStatus: "", outerTurnId: context.messageId };
+  f.provider.sendTurn = async () => {
+    await sendTurn?.(f);
+    return { id: f.turnId, status: "inProgress" };
+  };
+  f.provider.readThreadStatus = async () => ({ raw: { status: { type: f.codexStatus } } });
+  f.history = [turn(f.turnId, "interrupted")];
+  f.observe();
+  assert.equal((await f.owner.startTurn(f.sessionId, {}, context)).providerFailure, "");
+  assert.equal(f.run.state, "active");
+  // Codex finishes the turn, and its turn/completed notification is lost: only its thread and history say so.
+  f.finish = () => {
+    f.codexStatus = "idle";
+    f.history = [turn(f.turnId, "completed", "The complete reply.")];
+  };
+  return f;
+}
+
+async function assertSettledWithReply(f) {
+  await f.drain();
+  assert.equal(f.run.state, "completed");
+  assert.deepEqual((await f.replies()).map(row => row.assistant.text), ["The complete reply."]);
+  assert.deepEqual(f.notices, []);
+}
+
+// Codex usually answers turn/start before its turn/started notification, but may send turn/started first. Either way
+// Codex has reported the turn, so a thread status check after it finishes settles the turn with its answer.
+for (const order of ["after", "before"]) {
+  test(`a turn Codex reports ${order} its turn/start answer is settled by a later idle status check`, async t => {
+    const f = await unstartedTurnFixture(t, {
+      sendTurn(fixture) { if (order === "before") fixture.emit(fixture.started); }
+    });
+    if (order === "after") f.emit(f.started);
+    await f.drain();
+    assert.equal(f.run.state, "active");
+    f.finish();
+    await f.owner.reconcileThreadStatus(f.sessionId, f.provider, f.threadId, { source: "wellbeing" });
+    await assertSettledWithReply(f);
+  });
+}
+
+// When turn/started is missed, the mark does not outlive Codex's next report about the turn: a later notification
+// naming it, or Codex listing it as completed, settles it like any other turn. No timer is involved.
+for (const report of ["a later notification naming the turn", "the starting watchdog reading it as completed",
+  "a status check reading it as completed"]) {
+  test(`a delivered turn whose turn/started is missed is settled by ${report}`, async t => {
+    const f = await unstartedTurnFixture(t);
+    await f.owner.reconcileThreadStatus(f.sessionId, f.provider, f.threadId, { observeLatestTurn: true, source: "wellbeing" });
+    await f.drain();
+    assert.equal(f.run.state, "active", "Codex's idle thread and interrupted listing before it reports the turn do not end it");
+    f.finish();
+    if (report === "a later notification naming the turn") {
+      f.emit({ method: "item/started", params: { threadId: f.threadId, turnId: f.turnId, item: { id: "thinking", type: "reasoning" } } });
+      await f.drain();
+      await f.owner.reconcileThreadStatus(f.sessionId, f.provider, f.threadId, { source: "wellbeing" });
+    } else if (report === "the starting watchdog reading it as completed") {
+      await f.owner.recoverActiveTurn(f.sessionId, { provider: f.provider, retryOnError: false });
+    } else {
+      await f.owner.reconcileThreadStatus(f.sessionId, f.provider, f.threadId, { observeLatestTurn: true, source: "wellbeing" });
+    }
+    await assertSettledWithReply(f);
+  });
+}
+
 function controlContext(f, overrides = {}) {
   return {
     runtime: f.runtime,