@jskit-ai/assistant-core 0.2.4 → 0.2.6

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.4",
-    "@jskit-ai/http-runtime": "0.2.1",
-    "@jskit-ai/kernel": "0.2.1",
+    "@jskit-ai/assistant-core": "0.2.6",
+    "@jskit-ai/http-runtime": "0.2.3",
+    "@jskit-ai/kernel": "0.2.3",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.1",
-    "@jskit-ai/connectors-catalog": "0.2.1"
+    "@jskit-ai/connectors-core": "0.2.3",
+    "@jskit-ai/connectors-catalog": "0.2.3"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -48,8 +48,8 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/resource-core": "0.1.192",
-    "@jskit-ai/resource-crud-core": "0.1.192",
+    "@jskit-ai/resource-core": "0.1.194",
+    "@jskit-ai/resource-crud-core": "0.1.194",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -58,8 +58,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.1",
-    "@jskit-ai/kernel": "0.2.1",
+    "@jskit-ai/http-runtime": "0.2.3",
+    "@jskit-ai/kernel": "0.2.3",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/client/conversation/AssistantTranscript.vue

@@ -180,7 +180,7 @@
             </div>
             <slot name="user-message-actions" :message="entry.message" :turn="entry.turn" />
             <div
-              v-if="entry.delivery || entry.turn.optimistic?.status === 'failed' || entry.turn.optimistic?.cancelling || entry.turn.optimistic?.cancelError"
+              v-if="entry.delivery || entry.turn.optimistic?.status === 'failed' || cancelRequested(entry.turn)"
               class="assistant-transcript__optimistic-failure"
             >
               <span role="status">{{ entry.turn.optimistic?.cancelling ? t('jskit.assistant.delivery.cancelling')
@@ -188,7 +188,7 @@
                   : entry.delivery ? entry.delivery.delivery.error || t('jskit.assistant.delivery.unconfirmedShort') : t('jskit.assistant.transcript.failed', { error: entry.turn.optimistic.error || t('jskit.assistant.delivery.notSent') }) }}</span>
               <div v-if="!entry.turn.preview" class="assistant-transcript__optimistic-actions">
                 <v-btn
-                  v-if="!entry.turn.optimistic?.cancelling && !entry.turn.optimistic?.cancelError && (entry.delivery || entry.turn.optimistic?.status === 'failed')"
+                  v-if="!cancelRequested(entry.turn) && (entry.delivery || entry.turn.optimistic?.status === 'failed')"
                   class="assistant-transcript__delivery-action"
                   color="error"
                   size="x-small"
@@ -202,7 +202,7 @@
                   {{ entry.delivery?.delivery.checking ? t('jskit.assistant.delivery.checking') : t('jskit.assistant.delivery.retry') }}
                 </v-btn>
                 <v-btn
-                  v-if="!entry.delivery || cancellableDelivery || entry.turn.optimistic?.cancelling || entry.turn.optimistic?.cancelError"
+                  v-if="!entry.delivery || cancellableDelivery || cancelRequested(entry.turn)"
                   class="assistant-transcript__delivery-action"
                   size="x-small"
                   type="button"
@@ -212,7 +212,7 @@
                   {{ t("jskit.assistant.transcript.cancel") }}
                 </v-btn>
                 <v-btn
-                  v-if="!entry.delivery && entry.turn.optimistic?.status === 'failed' && !entry.turn.optimistic.cancelling && !entry.turn.optimistic.cancelError"
+                  v-if="!entry.delivery && entry.turn.optimistic?.status === 'failed' && !cancelRequested(entry.turn)"
                   class="assistant-transcript__delivery-action"
                   size="x-small"
                   type="button"
@@ -660,6 +660,12 @@ function handleLongTextLinkClick(payload) {
   emit("link-click", payload);
 }
 
+// Cancel was pressed and the server has not yet agreed: it is in progress or
+// could not reach the server.
+function cancelRequested(turn = {}) {
+  return Boolean(turn.optimistic?.cancelling || turn.optimistic?.cancelError);
+}
+
 function userMessageCollapsible(message = null) {
   return Array.isArray(message?.previewBlocks);
 }

package/src/server/conversation/claudeTurn.js

@@ -841,10 +841,10 @@ export function createClaudeConversationOwner({
     return closeRetained(await application.readContext(context), application, { recover: false, forget: true });
   }
 
-  async function closeRetained(ctx, application, { recover, forget: forgetEntries }) {
+  async function closeRetained(ctx, application, { recover: recoverCustody, forget: forgetEntries }) {
     closingSessions.add(ctx.key);
     try {
-      if (recover) await recoverSavedCustody(ctx);
+      if (recoverCustody) await recoverSavedCustody(ctx);
       const proofs = await drain(ctx.key);
       const terminal = await application.terminals.close(ctx.sessionId);
       // A forgotten entry is drained: everything it held is in its saved record.

package/src/server/conversation/codexConversations.js

@@ -29,9 +29,14 @@ export function createCodexConversationCommands({
 
   // Reads and Temporary chat commands borrow their provider instead of claiming
   // it: the operation returns its borrow when it finishes, and an unused
-  // provider stops a short idle later.
-  function providerBorrow() {
-    return { release() {} };
+  // provider stops a short idle later. Without `borrowing`, it claims one.
+  async function withProviderBorrow(borrowing, operation) {
+    const borrow = borrowing ? { release() {} } : null;
+    try {
+      return await operation(borrow);
+    } finally {
+      borrow?.release();
+    }
   }
 
   // A persistent conversation holds its borrowed provider only while it
@@ -325,22 +330,17 @@ export function createCodexConversationCommands({
   }
 
   async function createCodexAppServerConversation(sessionId, input = {}, options = {}) {
-    return codexAppServerConversationResult(async () => {
-      const borrow = input.persistent === true ? providerBorrow() : null;
-      try {
-        const context = await codexAppServerConversationContext(sessionId, input, options, borrow);
-        if (context.ok === false) return context;
-        const execution = conversationPreparation.execution(sessionId, input, options, context, null, "create");
-        return await createPreparedCodexAppServerConversation(sessionId, input, {
-          provider: context.provider,
-          executionProfile: execution.executionProfile,
-          helperIsolation: conversationPreparation.isolation,
-          threadPreparation: () => execution.threadPreparation
-        });
-      } finally {
-        borrow?.release();
-      }
-    });
+    return codexAppServerConversationResult(() => withProviderBorrow(input.persistent === true, async (borrow) => {
+      const context = await codexAppServerConversationContext(sessionId, input, options, borrow);
+      if (context.ok === false) return context;
+      const execution = conversationPreparation.execution(sessionId, input, options, context, null, "create");
+      return createPreparedCodexAppServerConversation(sessionId, input, {
+        provider: context.provider,
+        executionProfile: execution.executionProfile,
+        helperIsolation: conversationPreparation.isolation,
+        threadPreparation: () => execution.threadPreparation
+      });
+    }));
   }
 
   async function runDetachedCodexAppServerConversation(sessionId, input = {}, options = {}) {
@@ -443,8 +443,7 @@ export function createCodexConversationCommands({
           ok: false
         };
       }
-      const borrow = input.persistent === true ? providerBorrow() : null;
-      try {
+      return withProviderBorrow(input.persistent === true, async (borrow) => {
         const context = await codexAppServerConversationContext(sessionId, input, options, borrow);
         if (context.ok === false) return context;
         // A persistent turn is observed on the provider it runs on, which its
@@ -462,7 +461,7 @@ export function createCodexConversationCommands({
         }
         // Do not evaluate native preparation until the original duplicate/active
         // checks and Helper isolation capability checks have run.
-        return await startPreparedCodexAppServerConversationTurn(sessionId, input, {
+        return startPreparedCodexAppServerConversationTurn(sessionId, input, {
           executionProfile: execution.executionProfile,
           helperIsolation: conversationPreparation.isolation,
           prepareTurn: execution.prepareTurn,
@@ -478,9 +477,7 @@ export function createCodexConversationCommands({
           conversationState,
           threadPreparation: () => execution.threadPreparation
         });
-      } finally {
-        borrow?.release();
-      }
+      });
     }));
   }
 
@@ -514,13 +511,12 @@ export function createCodexConversationCommands({
         }
       }
       // Reading history or status is not a use that keeps Codex running.
-      const borrow = providerBorrow();
-      try {
+      return withProviderBorrow(true, async (borrow) => {
         const context = await codexAppServerConversationContext(sessionId, input, options, borrow);
         if (context.ok === false) {
           return context;
         }
-        if (input.persistent) return await readPreparedPersistentCodexConversation(sessionId, input, context);
+        if (input.persistent) return readPreparedPersistentCodexConversation(sessionId, input, context);
         const thread = await context.provider.readThread(conversationId);
         const runId = normalizeCodexRunText(input.runId) || codexAppServerThreadTurnId(thread);
         const status = codexAppServerThreadStatus(thread);
@@ -537,9 +533,7 @@ export function createCodexConversationCommands({
           status,
           ...conversationPreparation.response(text)
         };
-      } finally {
-        borrow.release();
-      }
+      });
     });
   }
 
@@ -563,8 +557,7 @@ export function createCodexConversationCommands({
         const result = await scoped.completion;
         return { ...result, conversationId, ok: true, runId };
       }
-      const borrow = input.persistent === true ? providerBorrow() : null;
-      try {
+      return withProviderBorrow(input.persistent === true, async (borrow) => {
         const context = await codexAppServerConversationContext(sessionId, input, {
           assistantScope
         }, borrow);
@@ -576,22 +569,25 @@ export function createCodexConversationCommands({
           onEvent
         });
         return { ...result, ...conversationPreparation.response(result.rawText) };
-      } finally {
-        borrow?.release();
-      }
+      });
     });
   }
 
+  // A conversation whose provider lost its observation stops through that failure.
+  async function stopThroughObservationFailure(state) {
+    await state.provider.failObservation(state.provider.observationFailure);
+    if (codexAppServerConversationTurnIsActive(state.status)) {
+      throw new Error("Codex's stop is not yet confirmed.");
+    }
+  }
+
   async function stopCodexAppServerConversation(sessionId, input = {}, options = {}, {
     turnOutcome = turnOutcomes.USER_CANCELLED
   } = {}) {
     const conversationId = normalizeCodexRunText(input.conversationId);
     const conversationState = codexAppServerConversation(sessionId, conversationId);
     if (conversationState?.provider.observationFailure) {
-      await conversationState.provider.failObservation(conversationState.provider.observationFailure);
-      if (codexAppServerConversationTurnIsActive(conversationState.status)) {
-        throw new Error("Codex's stop is not yet confirmed.");
-      }
+      await stopThroughObservationFailure(conversationState);
       return { conversationId, ok: true, runId: conversationState.runId, status: "interrupted" };
     }
     if (input.ephemeral === true && !conversationState) {
@@ -604,19 +600,16 @@ export function createCodexConversationCommands({
       };
     }
     if (input.persistent) {
-      const borrow = providerBorrow();
-      try {
+      return withProviderBorrow(true, async (borrow) => {
         const context = await codexAppServerConversationContext(sessionId, input, options, borrow);
         if (context.ok === false) return context;
-        return await stopPersistentCodexConversation({
+        return stopPersistentCodexConversation({
           conversationId,
           conversationState,
           provider: context.provider,
           turnOutcome
         });
-      } finally {
-        borrow.release();
-      }
+      });
     }
     const result = await interruptDetachedCodexAppServerConversationTurn(sessionId, {
       agentSettings: input.agentSettings,
@@ -701,10 +694,7 @@ export function createCodexConversationCommands({
   async function stopObservedCodexConversation(state) {
     const { provider } = state;
     if (provider.observationFailure) {
-      await provider.failObservation(provider.observationFailure);
-      if (codexAppServerConversationTurnIsActive(state.status)) {
-        throw new Error("Codex's stop is not yet confirmed.");
-      }
+      await stopThroughObservationFailure(state);
       return;
     }
     // A provider its owner has since closed observes nothing left to stop here:
@@ -759,7 +749,7 @@ export function createCodexConversationCommands({
       if (prepared.result) return prepared.result;
       const { admission, threadId, turnId } = prepared;
       // Stopping or deleting a thread is cleanup, not a use that keeps Codex running.
-      const borrow = providerBorrow();
+      const borrow = { release() {} };
       try {
         let context = null;
         try {

package/src/server/conversation/codexProvider.js

@@ -567,6 +567,18 @@ function codexAppServerThreadInventoryError(errorCode, label, detail) {
   return error;
 }
 
+// Why a listed inventory entry is refused, or "" for a valid thread.
+function codexAppServerThreadInventoryRefusal(entry, threadId, { cwd, verifyCwd }) {
+  if (!isRecord(entry)) return "listed an entry that is not a thread";
+  if (!threadId) return "listed a thread without an id";
+  if (threadId.length > CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH) {
+    return `listed a thread id longer than ${CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH} characters`;
+  }
+  if (codexAppServerTextHasControlCharacters(threadId)) return "listed a thread id with control characters";
+  if (verifyCwd && normalizeAgentText(entry.cwd) !== cwd) return `listed thread ${threadId} outside the requested directory`;
+  return "";
+}
+
 async function listBoundedCodexAppServerThreadIds({
   ancestorThreadId = "",
   archived = false,
@@ -618,13 +630,7 @@ async function listBoundedCodexAppServerThreadIds({
     }
     for (const entry of response.data) {
       const threadId = isRecord(entry) ? normalizeAgentText(entry.id) : "";
-      const refusal = !isRecord(entry) ? "listed an entry that is not a thread"
-        : !threadId ? "listed a thread without an id"
-          : threadId.length > CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH
-            ? `listed a thread id longer than ${CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH} characters`
-            : codexAppServerTextHasControlCharacters(threadId) ? "listed a thread id with control characters"
-              : verifyCwd && normalizeAgentText(entry.cwd) !== cwd
-                ? `listed thread ${threadId} outside the requested directory` : "";
+      const refusal = codexAppServerThreadInventoryRefusal(entry, threadId, { cwd, verifyCwd });
       if (refusal) {
         throw codexAppServerThreadInventoryError(errorCode, label, refusal);
       }

package/src/server/conversation/codexProviderOwner.js

@@ -50,8 +50,7 @@ export function releaseSupersededCodexRuntime(runtimeDir = "") {
       stale.superseded = true;
       return { deferred: true, removed: false };
     }
-    if (codexAppServerOwnedRuntimes.has(runtimeKey) || [...providerRecords()].some(record =>
-      codexAppServerOwnedRuntimeKey(record.providerKey, record.providerOptions) === runtimeKey)) {
+    if (codexAppServerOwnedRuntimes.has(runtimeKey) || runtimePeers(runtimeKey).length) {
       return { removed: false };
     }
     const metadata = await readCodexAppServerMetadata(runtimeDir);
@@ -83,6 +82,12 @@ function* providerRecords() {
   for (const records of codexAppServerProviders.values()) yield* records.values();
 }
 
+// Every owner's provider records on one native runtime.
+function runtimePeers(runtimeKey) {
+  return [...providerRecords()].filter(record =>
+    codexAppServerOwnedRuntimeKey(record.providerKey, record.providerOptions) === runtimeKey);
+}
+
 function nativeRequest(client, method, params) {
   return client.request(method, params, { signal: AbortSignal.timeout(5_000) });
 }
@@ -482,8 +487,7 @@ export function createCodexAppServerProviderOwner({
       // Another stop (a session close or idle release) ended a stale runtime.
       const runtimeKey = codexAppServerOwnedRuntimeKey(providerKey, record.providerOptions);
       const stale = codexAppServerStaleRuntimes.get(runtimeKey);
-      if (stale && !stale.retiring && ![...providerRecords()].some(peer =>
-        codexAppServerOwnedRuntimeKey(peer.providerKey, peer.providerOptions) === runtimeKey)) {
+      if (stale && !stale.retiring && !runtimePeers(runtimeKey).length) {
         codexAppServerStaleRuntimes.delete(runtimeKey);
       }
     }
@@ -824,18 +828,20 @@ export function createCodexAppServerProviderOwner({
 
   // A runtime with a running turn keeps the credentials it started with until
   // that turn ends. Its active goals are paused so it starts no further turn;
-  // retireStaleRuntime stops it once it is idle.
+  // retireStaleRuntime stops it once it is idle. Any other runtime returns
+  // null and stops at once, like an idle one.
   async function deferBusyRuntime(runtimeKey, peers) {
     let running;
     try {
       running = await runningNativeThreads(peers);
     } catch (error) {
-      // An unreadable runtime cannot show a running turn: it stops as before.
+      // An unreadable runtime cannot show a running turn.
       debugLog("appServerRuntime.staleInspection.error", { error: debugError(error), runtimeKey });
       return null;
     }
-    if (!running.length) return null;
-    const client = peers.find(record => record.provider.client?.isOpen?.()).provider.client;
+    // Nor can one whose control connection closed while it was read.
+    const client = peers.find(record => record.provider.client?.isOpen?.())?.provider.client;
+    if (!running.length || !client) return null;
     const pausedGoals = [];
     for (const threadId of running) {
       try {
@@ -864,8 +870,7 @@ export function createCodexAppServerProviderOwner({
     if (!stale) return Promise.resolve(null);
     if (stale.retiring) return stale.retiring;
     const retiring = withRuntimeLifecycle(runtimeKey, async () => {
-      const peers = [...providerRecords()].filter(record =>
-        codexAppServerOwnedRuntimeKey(record.providerKey, record.providerOptions) === runtimeKey);
+      const peers = runtimePeers(runtimeKey);
       const running = await runningNativeThreads(peers).catch(() => []);
       // A Temporary turn or goal holding a borrowed provider also keeps it.
       if (running.length || peers.some(peer => peer.scope.isHeld?.(peer.providerKey))) {

package/src/server/conversation/openCodeRuntime.js

@@ -1537,11 +1537,14 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope, storageI
     return monitor;
   }
 
-  // A removed connection's models are gone from its reloaded directory.
-  function disconnectedProviderFailure(failure) {
+  // A turn's failure and whether it is a credential failure. A removed
+  // connection's models are gone from its reloaded directory.
+  function turnFailure(failure) {
     const providerId = /\bModel not found: ([^/\s]+)\//u.exec(failure)?.[1];
-    return providerId && sharedProcess && !sharedProcess.connections.has(providerId)
-      ? `${providerId} isn't connected. Connect it again, then send your message again.` : "";
+    if (providerId && sharedProcess && !sharedProcess.connections.has(providerId)) {
+      return { failure: `${providerId} isn't connected. Connect it again, then send your message again.`, credentialFailure: true };
+    }
+    return { failure, credentialFailure: openCodeCredentialFailure(failure) };
   }
 
   function beginMonitor(key, target, turn, {
@@ -1626,9 +1629,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope, storageI
             failure = "OpenCode finished without a user-facing final response. Please send your message again.";
             finalState = "failed";
           } else if (failure) {
-            const disconnected = disconnectedProviderFailure(failure);
-            failure = disconnected || failure;
-            credentialFailure = Boolean(disconnected) || openCodeCredentialFailure(failure);
+            ({ failure, credentialFailure } = turnFailure(failure));
             finalState = "failed";
           } else if (turn.interruptRequested) {
             finalState = "interrupted";
@@ -1647,10 +1648,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope, storageI
           finalState = "interrupted";
         } else {
           const cause = signal.aborted ? signal.reason : error;
-          failure = text(cause?.message) || "OpenCode turn failed.";
-          const disconnected = disconnectedProviderFailure(failure);
-          failure = disconnected || failure;
-          credentialFailure = Boolean(disconnected) || openCodeCredentialFailure(failure);
+          ({ failure, credentialFailure } = turnFailure(text(cause?.message) || "OpenCode turn failed."));
           providerApiFailure = openCodeProviderApiFailure(cause);
           finalState = target.abortController.signal.aborted
             ? "cancelled"

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

@@ -341,6 +341,12 @@ export async function preparePersistentConversationChangeover(options) {
   await createConversationChangeover(continuity).remember({ engineId, messages });
 }
 
+// The receipt of a message proven never to have reached its conversation.
+export function notSentDeliveryReceipt(messageId) {
+  return { status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message.",
+    messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
+}
+
 export async function inspectPersistentConversationDelivery(options) {
   const { sessionId, input, context, store, operations, prepare, receipts } = options;
   let turns = await store.readConversationLog(sessionId);
@@ -354,9 +360,7 @@ export async function inspectPersistentConversationDelivery(options) {
       inspectMessageAdmission: request => inspectMessageAdmission(sessionId, request, context),
       sendMessage() { throw new Error("Receipt inspection cannot submit another native prompt."); }
     } }).send({ engineId, messages, input: { messageId: input.messageId }, turnMetadata, inspectOnly: true });
-    if (result?.notSent) return { status: "not-sent", messageId: input.messageId,
-      error: "This message was not sent. Review it before sending a new message.",
-      messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
+    if (result?.notSent) return notSentDeliveryReceipt(input.messageId);
     accepted = result?.delivered === true;
   } else if (!accepted) {
     if (row && row.user?.receipt !== false) return { status: "accepted", messageId: input.messageId, turnId: row.turnId, duplicate: true };

package/src/server/conversation/runtime.js

@@ -3,7 +3,7 @@ import { createConversationDeliveryTiming, normalizeConversationDeliveryHostStag
 import { normalizeConversationConfiguration } from "./configuration.js";
 import { runScopedConversationTurn, readPersistentConversation, projectStoredPersistentConversation, startPersistentConversationTurn,
   inspectPersistentConversationAdmission, preparePersistentConversationChangeover,
-  inspectPersistentConversationDelivery, stopPersistentConversation, deletePersistentConversation } from "./providers/scoped.js";
+  inspectPersistentConversationDelivery, notSentDeliveryReceipt, stopPersistentConversation, deletePersistentConversation } from "./providers/scoped.js";
 import { isDeepStrictEqual } from "node:util";
 import { randomUUID } from "node:crypto";
 import { createConversationTranscript, isCompletedEnvelopeTurn } from "./transcript.js";
@@ -1927,11 +1927,6 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
     return { saved: true };
   }
 
-  function notSentReceipt(messageId) {
-    return { status: "not-sent", messageId, error: "This message was not sent. Review it before sending a new message.",
-      messageCode: "assistant.conversation.messageNotSent", messageParams: {} };
-  }
-
   async function recoverDelivery(entry, context, messageId, { observation: suppliedObservation, allowActive = false } = {}) {
     await access(context, entry.id, "inspectDelivery", entry);
     if (entry.active && !allowActive) throw failure("Wait for the current submission before checking delivery.", "conversation_busy", 409, { messageCode: "assistant.conversation.waitForSubmission" });
@@ -1960,7 +1955,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       ["codex", "claude", "opencode"].includes(segment.engine) && segment.request.attempted === false && !segment.request.inspectionOnly &&
       isDeepStrictEqual(segment.request, savedRequests[0].request))) {
       await access(context, entry.id, "inspectDelivery", entry);
-      return notSentReceipt(messageId);
+      return notSentDeliveryReceipt(messageId);
     }
     const request = existing ? submittedMessage(existing) : metadata.runtime.request;
     if (!request || request.messageId !== messageId || !entry.provider.inspectAdmission) return receipt || { status: "unknown", messageId };
@@ -1978,7 +1973,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         current.runtime.request.attempted = false;
         await transaction.writeMetadata(current);
       });
-      return notSentReceipt(messageId);
+      return notSentDeliveryReceipt(messageId);
     }
     if (!observation.accepted) return { ...(receipt || { status: "unknown", messageId }),
       ...(observation.recoveryLimitation ? { recoveryLimitation: observation.recoveryLimitation } : {}) };
@@ -2097,7 +2092,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
         });
         const delivered = await sender.send({ engineId: entry.engine,
           messages: await entry.conversation.transcript.history(), input: { messageId }, inspectOnly: true });
-        if (delivered?.notSent) return notSentReceipt(messageId);
+        if (delivered?.notSent) return notSentDeliveryReceipt(messageId);
         if (!delivered?.delivered) throw deliveryFailure(delivered);
       }
       const row = (await readTranscript(entry)).find(turn => submittedMessage(turn)?.messageId === messageId);
@@ -2109,7 +2104,7 @@ export function createConversationRuntime({ engine: defaultEngine = "api", defau
       // Native-only acceptance is evidence of delivery, not permission to
       // manufacture an authored row or use a native turn ID as its receipt.
       if (observation.accepted) return { status: "accepted", messageId, duplicate: true };
-      return observation.notAdmitted && !entry.active ? notSentReceipt(messageId) : { status: "unknown", messageId };
+      return observation.notAdmitted && !entry.active ? notSentDeliveryReceipt(messageId) : { status: "unknown", messageId };
     }
     const result = await recoverDelivery(entry, context, messageId);
     if (result.status !== "accepted" || entry.engine === "api") return result;

package/test/assistantScroll.browser.test.js

@@ -75,6 +75,29 @@ async function pressScrollKey(body, key, target) {
   await body.evaluate(element => element.keyScrolled);
 }
 
+function fromBottom(body) {
+  return body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop);
+}
+
+async function appendReply(page, body) {
+  const replies = page.getByText("New reply.", { exact: false });
+  const count = await replies.count();
+  await page.getByRole("button", { name: "Append reply", exact: true }).evaluate(element => element.click());
+  await expect(replies).toHaveCount(count + 1);
+  await settleLayout(body);
+}
+
+// Opens the whole conversation history with the reader at the latest message.
+async function openAtLatest(page, baseURL) {
+  await page.goto(`${baseURL}/?controls=1&history=1`);
+  const body = page.locator(".assistant-transcript__body");
+  await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
+  await page.getByRole("button", { name: "Exhaust history", exact: true }).evaluate(element => element.click());
+  await settleLayout(body);
+  expect(await fromBottom(body)).toBeLessThanOrEqual(1);
+  return body;
+}
+
 const VIEWPORTS = Object.freeze([
   Object.freeze({ name: "phone", width: 390, height: 844 }),
   Object.freeze({ name: "compact", width: 800, height: 900 }),
@@ -497,20 +520,7 @@ test("a reader's own upward scrolling leaves the latest message from its first f
       const page = await browser.newPage({ viewport: { width, height: 900 }, hasTouch: touch, isMobile: touch });
       const errors = [];
       page.on("pageerror", error => errors.push(error.message));
-      await page.goto(`${vite.baseURL}/?controls=1&history=1`);
-      const body = page.locator(".assistant-transcript__body");
-      const fromBottom = () => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop);
-      const appendReply = async () => {
-        const replies = page.getByText("New reply.", { exact: false });
-        const count = await replies.count();
-        await page.getByRole("button", { name: "Append reply", exact: true }).evaluate(element => element.click());
-        await expect(replies).toHaveCount(count + 1);
-        await settleLayout(body);
-      };
-      await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
-      await page.getByRole("button", { name: "Exhaust history", exact: true }).evaluate(element => element.click());
-      await settleLayout(body);
-      expect(await fromBottom()).toBeLessThanOrEqual(1);
+      const body = await openAtLatest(page, vite.baseURL);
       await expect.poll(async () => {
         await body.focus();
         return body.evaluate(element => document.activeElement === element);
@@ -532,29 +542,29 @@ test("a reader's own upward scrolling leaves the latest message from its first f
         await body.hover();
         await page.mouse.wheel(0, -20);
       }
-      await expect.poll(fromBottom).toBeGreaterThan(1);
+      await expect.poll(() => fromBottom(body)).toBeGreaterThan(1);
       await settleLayout(body);
-      await appendReply();
-      expect(await fromBottom()).toBeGreaterThan(1);
+      await appendReply(page, body);
+      expect(await fromBottom(body)).toBeGreaterThan(1);
 
       // Returning to the end resumes following new replies.
       await pressScrollKey(body, "End", "end");
-      await appendReply();
-      expect(await fromBottom()).toBeLessThanOrEqual(1);
+      await appendReply(page, body);
+      expect(await fromBottom(body)).toBeLessThanOrEqual(1);
 
       // The first frame of an upward keyboard scroll lands inside the follow
       // threshold; the rest of it (a fling or smooth scroll) moves the reader
       // into history without further input events.
       await pressScrollKey(body, "ArrowUp", -10);
-      const firstFrame = await fromBottom();
+      const firstFrame = await fromBottom(body);
       assert.ok(firstFrame > 1 && firstFrame <= 48, `first frame ${firstFrame}px from the end`);
       await body.evaluate(element => { element.scrollTop = Math.round(element.scrollTop / 2); });
       await settleLayout(body);
-      await appendReply();
-      expect(await fromBottom()).toBeGreaterThan(1_000);
+      await appendReply(page, body);
+      expect(await fromBottom(body)).toBeGreaterThan(1_000);
       await pressScrollKey(body, "End", "end");
-      await appendReply();
-      expect(await fromBottom()).toBeLessThanOrEqual(1);
+      await appendReply(page, body);
+      expect(await fromBottom(body)).toBeLessThanOrEqual(1);
 
       // The scroll event of the transcript's own follow scroll can arrive after
       // the key press, before the reader has moved; it must not cancel the
@@ -563,7 +573,7 @@ test("a reader's own upward scrolling leaves the latest message from its first f
         element.addEventListener("keydown", () => element.dispatchEvent(new Event("scroll")), { once: true });
       });
       await pressScrollKey(body, "Home", "top");
-      await appendReply();
+      await appendReply(page, body);
       expect(await body.evaluate(element => element.scrollTop)).toBe(0);
       assert.deepEqual(errors, []);
       await page.close();
@@ -584,25 +594,12 @@ test("a reader moved away from the end without a scroll direction stays there",
     const page = await browser.newPage({ viewport: { width: 1365, height: 900 } });
     const errors = [];
     page.on("pageerror", error => errors.push(error.message));
-    await page.goto(`${vite.baseURL}/?controls=1&history=1`);
-    const body = page.locator(".assistant-transcript__body");
-    const fromBottom = () => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop);
+    const body = await openAtLatest(page, vite.baseURL);
     // Move the reader and wait until the transcript has handled the scroll.
     const moveReader = target => body.evaluate((element, by) => new Promise(resolve => {
       element.addEventListener("scroll", () => resolve(), { once: true });
       element.scrollTop = by === "end" ? element.scrollHeight : element.scrollTop + by;
     }), target);
-    const appendReply = async () => {
-      const replies = page.getByText("New reply.", { exact: false });
-      const count = await replies.count();
-      await page.getByRole("button", { name: "Append reply", exact: true }).evaluate(element => element.click());
-      await expect(replies).toHaveCount(count + 1);
-      await settleLayout(body);
-    };
-    await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
-    await page.getByRole("button", { name: "Exhaust history", exact: true }).evaluate(element => element.click());
-    await settleLayout(body);
-    expect(await fromBottom()).toBeLessThanOrEqual(1);
 
     // A scrollbar drag starts on the scroller itself and carries no scroll
     // direction; its frames, the first inside the follow threshold, then move
@@ -611,13 +608,13 @@ test("a reader moved away from the end without a scroll direction stays there",
     await body.evaluate(element => element.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true })));
     await moveReader(-10);
     await moveReader(-300);
-    await appendReply();
-    expect(await fromBottom()).toBeGreaterThan(300);
+    await appendReply(page, body);
+    expect(await fromBottom(body)).toBeGreaterThan(300);
 
     // Returning to the end resumes following new replies.
     await moveReader("end");
-    await appendReply();
-    expect(await fromBottom()).toBeLessThanOrEqual(1);
+    await appendReply(page, body);
+    expect(await fromBottom(body)).toBeLessThanOrEqual(1);
     assert.deepEqual(errors, []);
   } finally {
     await browser.close();

package/test/claudeProcess.test.js

@@ -32,6 +32,15 @@ test("native command construction preserves tool-free constraints without granti
 // Account queries whose credentials are not the subject read them from nowhere.
 const ABSENT_CLAUDE_CONFIG = join(tmpdir(), "jskit-absent-claude-config");
 
+// Date.now reads `clock.now` until the test ends.
+function fakeClock(t, now = Date.now()) {
+  const realNow = Date.now;
+  const clock = { now };
+  Date.now = () => clock.now;
+  t.after(() => { Date.now = realNow; });
+  return clock;
+}
+
 async function fixture(t, body) {
   const directory = await mkdtemp(join(tmpdir(), "jskit-claude-process-"));
   t.after(() => rm(directory, { recursive: true, force: true }));
@@ -216,10 +225,7 @@ test("a Claude status answer holds until the credentials change, even across its
 }, async (t) => {
   const home = await mkdtemp(path.join(os.tmpdir(), "claude-auth-status-"));
   t.after(() => rm(home, { recursive: true, force: true }));
-  const realNow = Date.now;
-  let now = realNow();
-  Date.now = () => now;
-  t.after(() => { Date.now = realNow; });
+  const clock = fakeClock(t);
   const configRoot = path.join(home, ".claude");
   await mkdir(configRoot);
   const credentials = path.join(configRoot, ".credentials.json");
@@ -234,7 +240,7 @@ test("a Claude status answer holds until the credentials change, even across its
     return result;
   } };
   assert.equal((await readClaudeCodeAuthStatus(input)).email, "owner@example.test");
-  now += 10 * 60_000;
+  clock.now += 10 * 60_000;
   assert.equal((await readClaudeCodeAuthStatus(input)).email, "owner@example.test");
   assert.equal(calls, 1, "the answer is not read again on a timer or after the run's own rewrite");
   // Sign-out removes the credentials: Claude is asked again at once.
@@ -246,11 +252,11 @@ test("a Claude status answer holds until the credentials change, even across its
   await writeFile(credentials, "signed-in-again");
   result = { ok: false, exitCode: 1, timedOut: true, error: "Command timed out." };
   assert.equal((await readClaudeCodeAuthStatus(input)).error, "Command timed out.");
-  now += 29_000;
+  clock.now += 29_000;
   assert.equal((await readClaudeCodeAuthStatus(input)).error, "Command timed out.");
   assert.equal(calls, 3);
   // A read that ran and failed is reported, and asked again next time.
-  now += 2_000;
+  clock.now += 2_000;
   result = { ok: false, exitCode: 2, error: "Claude Code crashed." };
   assert.equal((await readClaudeCodeAuthStatus(input)).error, "Claude Code crashed.");
   result = signedIn;
@@ -261,18 +267,15 @@ test("a Claude status answer holds until the credentials change, even across its
 test("an unfinished Claude status read is reported without probing again at once", {
   skip: process.platform === "darwin"
 }, async (t) => {
-  const realNow = Date.now;
-  let now = realNow();
-  Date.now = () => now;
-  t.after(() => { Date.now = realNow; });
+  const clock = fakeClock(t);
   let calls = 0;
   let result = { ok: false, exitCode: 1, retryable: true, error: "Memory-pressure spike." };
   const input = { env: {}, credentialHome: { home: "/home/fixture-busy" }, commandRunner: async () => { calls += 1; return result; } };
   assert.equal((await readClaudeCodeAuthStatus(input)).error, "Memory-pressure spike.");
-  now += 29_000;
+  clock.now += 29_000;
   assert.equal((await readClaudeCodeAuthStatus(input)).error, "Memory-pressure spike.");
   assert.equal(calls, 1);
-  now += 2_000;
+  clock.now += 2_000;
   result = { ok: true, stdout: JSON.stringify({ loggedIn: true, email: "owner@example.test" }) };
   assert.equal((await readClaudeCodeAuthStatus(input)).loggedIn, true);
   assert.equal(calls, 2);
@@ -623,10 +626,7 @@ test("Claude plan usage shows only an answer from the usage endpoint as current"
 });
 
 test("Claude plan usage asks a temporary Claude when a live process cannot prove its answer", async (t) => {
-  const realNow = Date.now;
-  let now = Date.parse("2026-10-29T03:00:00Z");
-  Date.now = () => now;
-  t.after(() => { Date.now = realNow; });
+  const clock = fakeClock(t, Date.parse("2026-10-29T03:00:00Z"));
   const resets_at = "2026-11-04T05:00:00Z";
   const starts = [];
   let stops = 0;
@@ -652,17 +652,17 @@ test("Claude plan usage asks a temporary Claude when a live process cannot prove
   assert.equal(first.windows[0].remainingPercent, 77);
   assert.deepEqual(starts, ["usage"]);
   for (let poll = 1; poll <= 4; poll++) {
-    now += 60_000;
+    clock.now += 60_000;
     assert.equal((await queries.readPlanUsage({})).windows[0].remainingPercent, 77);
   }
   assert.equal(liveReads, 5);
   assert.deepEqual(starts, ["usage"], "a fallback started Claude inside the idle interval");
-  now += 61_000;
+  clock.now += 61_000;
   await queries.readPlanUsage({});
   assert.deepEqual(starts, ["usage", "usage"]);
   assert.equal(stops, starts.length, "a temporary usage process outlived its read");
   // A refused fallback keeps the last verified reading rather than failing the read.
-  now += 301_000;
+  clock.now += 301_000;
   startRefused = true;
   const kept = await queries.readPlanUsage({});
   assert.equal(kept.windows[0].remainingPercent, 77);
@@ -670,10 +670,7 @@ test("Claude plan usage asks a temporary Claude when a live process cannot prove
 });
 
 test("Claude plan usage starts one temporary Claude per idle interval and marks an old reading stale", async (t) => {
-  const realNow = Date.now;
-  let now = Date.parse("2026-10-29T03:00:00Z");
-  Date.now = () => now;
-  t.after(() => { Date.now = realNow; });
+  const clock = fakeClock(t, Date.parse("2026-10-29T03:00:00Z"));
   const starts = [];
   let stops = 0;
   let answer = { rate_limits_available: true, rate_limits: {
@@ -690,16 +687,16 @@ test("Claude plan usage starts one temporary Claude per idle interval and marks
   assert.equal(first.windows[0].remainingPercent, 77);
   // Pages polling every minute share the account's reading.
   for (let poll = 1; poll <= 4; poll++) {
-    now += 60_000;
+    clock.now += 60_000;
     assert.equal((await queries.readPlanUsage({})).status, "available");
   }
   assert.deepEqual(starts, ["usage"]);
-  now += 61_000;
+  clock.now += 61_000;
   answer = { rate_limits_available: true, rate_limits: { seven_day: { utilization: 7, resets_at: "2026-11-04T05:00:00Z" } } };
   const unverified = await queries.readPlanUsage({});
   assert.deepEqual(starts, ["usage", "usage"]);
   assert.equal(unverified.windows[0].remainingPercent, 77);
-  now += 120_000;
+  clock.now += 120_000;
   const stale = await queries.readPlanUsage({});
   assert.equal(stale.status, "stale");
   assert.equal(stale.windows[0].remainingPercent, 77);
@@ -711,10 +708,7 @@ test("Claude plan usage starts one temporary Claude per idle interval and marks
 });
 
 test("Claude plan usage starts one temporary Claude per account for every owner polling it", async (t) => {
-  const realNow = Date.now;
-  let now = Date.parse("2026-10-29T03:00:00Z");
-  Date.now = () => now;
-  t.after(() => { Date.now = realNow; });
+  const clock = fakeClock(t, Date.parse("2026-10-29T03:00:00Z"));
   const starts = [];
   let stops = 0;
   // Three account-query owners in one server process, none with a live conversation.
@@ -736,7 +730,7 @@ test("Claude plan usage starts one temporary Claude per account for every owner
   assert.equal(concurrent[0].windows[0].remainingPercent, 77);
   // An hour of every owner polling once a minute.
   for (let minute = 1; minute < 60; minute++) {
-    now += 60_000;
+    clock.now += 60_000;
     for (const queries of owners) assert.equal((await queries.readPlanUsage(account)).status, "available");
   }
   assert.equal(starts.length, 12, "the account started more than one temporary Claude per idle interval");
@@ -747,10 +741,7 @@ test("Claude plan usage starts one temporary Claude per account for every owner
 });
 
 test("Claude plan usage reuses another owner's live reading instead of starting a temporary Claude", async (t) => {
-  const realNow = Date.now;
-  let now = Date.parse("2026-10-29T03:00:00Z");
-  Date.now = () => now;
-  t.after(() => { Date.now = realNow; });
+  const clock = fakeClock(t, Date.parse("2026-10-29T03:00:00Z"));
   const account = "plan-usage-live-in-another-owner";
   const answer = { rate_limits_available: true, rate_limits: {
     seven_day: { utilization: 23, resets_at: "2026-11-04T05:00:00Z" }, limits: [] } };
@@ -769,13 +760,13 @@ test("Claude plan usage reuses another owner's live reading instead of starting
   // Only the idle owner's page stays open: the account's verified reading serves it
   // until that reading is an idle interval old.
   for (let minute = 1; minute <= 4; minute++) {
-    now += 60_000;
+    clock.now += 60_000;
     const reading = await idle.readPlanUsage({});
     assert.equal(reading.checkedAt, live.checkedAt);
     assert.equal(reading.status, "available");
   }
   assert.deepEqual(starts, [], "a temporary Claude started while the account had a recent verified reading");
-  now += 60_000;
+  clock.now += 60_000;
   await idle.readPlanUsage({});
   assert.deepEqual(starts, ["usage"]);
 });
@@ -794,10 +785,7 @@ test("Claude model list starts a Claude only after its account, credentials or C
   const command = join(root, "claude");
   await replace(credentials, "signed in");
   await replace(command, "2.1.1");
-  const realNow = Date.now;
-  let now = realNow();
-  Date.now = () => now;
-  t.after(() => { Date.now = realNow; });
+  const clock = fakeClock(t);
   let account = "account";
   const starts = [];
   const queries = createClaudeAccountQueries({ accountIdentity: async () => account, configRoot,
@@ -811,7 +799,7 @@ test("Claude model list starts a Claude only after its account, credentials or C
   const model = async () => (await queries.readCatalogue({})).models[0].value;
   // Reconnects, tab returns and closed sessions ask about four times an hour.
   const askForADay = async (expected) => {
-    for (let read = 0; read < 96; read++, now += 15 * 60_000) assert.equal(await model(), expected);
+    for (let read = 0; read < 96; read++, clock.now += 15 * 60_000) assert.equal(await model(), expected);
   };
   await askForADay("read-1");
   assert.deepEqual(starts, ["catalogue"]);

package/test/codexAccountChange.test.js

@@ -40,6 +40,9 @@ function nativeRuntime({ threads, goals = {} }) {
   return { provider, requests, threads, goals };
 }
 
+// The invalidation the runtime lifecycle requests for an account change.
+const ACCOUNT_CHANGE = Object.freeze({ deferBusy: true, includeOwned: true, requireVerifiedExit: true, stopOwnedRuntimes: true });
+
 function ownerWith(t, runtimes, options = {}) {
   const root = path.join(os.tmpdir(), `jskit-codex-account-change-${randomUUID()}`);
   const owner = createCodexAppServerProviderOwner({ runtimeRoot: root, ...options });
@@ -59,9 +62,7 @@ test("an account change stops an idle Codex runtime at once and leaves a running
   const busy = nativeRuntime({ threads: { "busy-thread": "active" }, goals: { "busy-thread": { status: "active" } } });
   const { owner, keys } = ownerWith(t, { idle, busy });
 
-  const result = await owner.invalidateRuntimes({
-    deferBusy: true, includeOwned: true, requireVerifiedExit: true, stopOwnedRuntimes: true
-  });
+  const result = await owner.invalidateRuntimes(ACCOUNT_CHANGE);
 
   assert.equal(result.ok, true);
   assert.equal(idle.provider.stopped, 1, "An idle runtime stops at once");
@@ -83,11 +84,36 @@ test("an account change stops an idle Codex runtime at once and leaves a running
   assert.equal(await owner.retireStaleRuntime(keys.busy), null);
 });
 
+test("an account change stops a Codex runtime whose control connection closed while its turns were read", async t => {
+  const closing = nativeRuntime({ threads: { "busy-thread": "active" }, goals: { "busy-thread": { status: "active" } } });
+  let open = true;
+  const read = closing.provider.client.request;
+  closing.provider.client = {
+    isOpen: () => open,
+    async request(method, params) {
+      const response = await read(method, params);
+      if (method === "thread/read") open = false;
+      return response;
+    }
+  };
+  const idle = nativeRuntime({ threads: { "idle-thread": "idle" } });
+  const { owner } = ownerWith(t, { closing, idle });
+
+  const result = await owner.invalidateRuntimes(ACCOUNT_CHANGE);
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.deferred, [], "A closed connection leaves no running turn to keep");
+  assert.equal(closing.provider.stale, false);
+  assert.equal(closing.requests.some(request => request.startsWith("thread/goal/")), false);
+  assert.equal(closing.provider.stopped, 1, "It takes the verified stop of a runtime with no running turn");
+  assert.equal(idle.provider.stopped, 1, "The other runtimes still change account");
+});
+
 test("a session's next Codex runtime starts only after its finished stale runtime stopped", async t => {
   const old = nativeRuntime({ threads: { "thread-1": "active" } });
   const current = { client: null, close() {} };
   const { owner, root } = ownerWith(t, { old }, { providerFactory: () => current });
-  await owner.invalidateRuntimes({ deferBusy: true, includeOwned: true, requireVerifiedExit: true, stopOwnedRuntimes: true });
+  await owner.invalidateRuntimes(ACCOUNT_CHANGE);
   assert.equal(old.provider.stale, true);
   old.threads["thread-1"] = "idle";
 
@@ -251,7 +277,7 @@ test("recording a session's runtime for a new sign-in removes the previous sign-
 test("a stale Codex runtime its session no longer records keeps no exit proof when it stops", async t => {
   const busy = nativeRuntime({ threads: { "thread-1": "active" } });
   const { owner, keys, root } = ownerWith(t, { busy });
-  await owner.invalidateRuntimes({ deferBusy: true, includeOwned: true, requireVerifiedExit: true, stopOwnedRuntimes: true });
+  await owner.invalidateRuntimes(ACCOUNT_CHANGE);
 
   assert.deepEqual(await releaseSupersededCodexRuntime(path.join(root, "busy")), { deferred: true, removed: false });
   busy.threads["thread-1"] = "idle";

package/test/codexLifecycleIsolation.test.js

@@ -21,7 +21,8 @@ import {
 // account was removed, or a project ledger that cannot be read, must not keep
 // a closing session or project running, and close never reopens to stop.
 
-function savedHelperRecord(root, overrides = {}) {
+// Restoration retires a record whose `runtimeDir` is gone.
+function savedHelperRecord(root, { runtimeDir = path.join(root, "codex-runtime"), ...overrides } = {}) {
   const now = new Date().toISOString();
   return defineCodexHelperThreadRecord({
     createdAt: now,
@@ -36,7 +37,7 @@ function savedHelperRecord(root, overrides = {}) {
         executionMode: "interactive",
         executionContextHash: "c".repeat(12),
         provider: "codex_app_server",
-        runtimeDir: path.join(root, "codex-runtime"),
+        runtimeDir,
         runtimesHash: "d".repeat(12),
         terminalEnvHash: "e".repeat(12),
         toolHomeSource: "",
@@ -146,8 +147,7 @@ test("closing a Codex project stops providers past an unrestorable record and re
   await mkdir(path.join(root, "codex-runtime"), { recursive: true });
   await ledger.write(savedHelperRecord(root));
   await ledger.write(savedHelperRecord(root, { ownershipId: "ownership-2", sessionId: "session-2", threadId: "thread-2",
-    identity: { ...savedHelperRecord(root).identity, runtime: { ...savedHelperRecord(root).identity.runtime,
-      runtimeDir: path.join(root, "removed-runtime") } },
+    runtimeDir: path.join(root, "removed-runtime"),
     workdir: path.join(root, "sessions", "active", "session-2", "source") }));
   const events = [];
   const cleanup = createCodexSessionCleanup({
@@ -195,8 +195,7 @@ test("Helper restoration reports an unreadable ledger and a refused notice inste
   await rm(ledger.root, { force: true });
 
   await mkdir(path.join(root, "codex-runtime"), { recursive: true });
-  await ledger.write(savedHelperRecord(root, { identity: { ...savedHelperRecord(root).identity,
-    runtime: { ...savedHelperRecord(root).identity.runtime, runtimeDir: path.join(root, "removed-runtime") } } }));
+  await ledger.write(savedHelperRecord(root, { runtimeDir: path.join(root, "removed-runtime") }));
   const refused = await helperLifecycle.restoreThreads(root, {
     async prepareRecord(record, recordLedger) { return { ledger: recordLedger, retiring: true }; },
     async publish() {
@@ -245,7 +244,6 @@ function conversationCommands({ context = async () => ({ result: { ok: false, co
     helperLifecycle: { inspectControl: () => undefined },
     namespace: (sessionId) => `codex:${String(sessionId || "").trim()}`,
     providerSessions,
-    sessionConnection: (sessionId) => ({ providerKey: `codex-helper:${sessionId}`, runtimeHost: { stop: "prepared" } }),
     ensureSessionProvider,
     turnOutcomes: { USER_CANCELLED: "cancelled" }
   });
@@ -386,8 +384,7 @@ test("an account-change invalidation stops runtimes without reopening saved Help
 
 test("reconciliation keeps every session and prune retires past one failed provider", async (t) => {
   const { root, helperLifecycle, ledger } = await withProjectLedger(t);
-  await ledger.write(savedHelperRecord(root, { identity: { ...savedHelperRecord(root).identity,
-    runtime: { ...savedHelperRecord(root).identity.runtime, runtimeDir: path.join(root, "removed-runtime") } } }));
+  await ledger.write(savedHelperRecord(root, { runtimeDir: path.join(root, "removed-runtime") }));
   const retired = [];
   const managed = new Map([
     ["provider-a", { sessionId: "stale-a", projectContext: { targetRoot: "/project" } }],

package/test/codexTemporaryProviderRelease.test.js

@@ -1,25 +1,15 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
 import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
 import { createCodexConversationCommands } from "../src/server/conversation/codexConversations.js";
 import { createCodexSessionCleanup } from "../src/server/conversation/codexSessionCleanup.js";
+import { eventually } from "./fixtures/eventually.js";
 
 // A Codex app-server runs only while it is used: reading a conversation's
 // history or status, or stopping it, borrows the process; a running Temporary
 // turn or goal holds it; and closing a project stops every one of its own.
 
-async function eventually(check, message) {
-  const deadline = Date.now() + 2_000;
-  while (!check()) {
-    if (Date.now() > deadline) assert.fail(message);
-    await new Promise(resolve => setTimeout(resolve, 5));
-  }
-}
-
-function settle(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
 // One native process per runtime directory, as the real app-server has per
 // account and runtime scope. Each provider connection reports its own thread.
 function codexFixture(t, { idleMs = 20 } = {}) {
@@ -130,7 +120,7 @@ test("a running Temporary turn keeps Codex; it stops a short idle after the turn
   // A history read while the turn runs must not release its process either.
   await f.commands.readCodexAppServerConversation("session-1", { conversationId: "chat-1", persistent: true });
   f.emit({ method: "turn/started", params: { threadId: "chat-1", turn: { id: "turn-2", status: "inProgress" } } });
-  await settle(80);
+  await delay(80);
   assert.equal(f.runtime.running, true, "the running turn's process was stopped");
   assert.equal(f.runtime.stops, 0);
   f.emit({ method: "turn/completed", params: { threadId: "chat-1", turn: { id: "turn-2", status: "completed" } } });
@@ -145,7 +135,7 @@ test("an active Temporary goal keeps Codex between its turns until the goal ends
   });
   f.emit({ method: "thread/goal/updated", params: { threadId: "chat-1", goal: { status: "active" } } });
   f.emit({ method: "turn/completed", params: { threadId: "chat-1", turn: { id: "turn-2", status: "completed" } } });
-  await settle(80);
+  await delay(80);
   assert.equal(f.runtime.running, true, "the goal's process was stopped between its turns");
   f.emit({ method: "thread/goal/updated", params: { threadId: "chat-1", goal: { status: "complete" } } });
   await eventually(() => !f.runtime.running, "the finished goal kept Codex running");

package/test/conversationNativeStorage.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { nativeConversationStoragePolicy } from "../src/server/conversation/nativeStorage.js";
@@ -7,6 +8,7 @@ import { createCodexAppServerProviderOwner } from "../src/server/conversation/co
 import { createCodexConversationDriver } from "../src/server/conversation/providers/codexDriver.js";
 import { createOpenCodeSharedRuntime, openCodeServerForDirectory } from "../src/server/conversation/openCodeRuntime.js";
 import { createOpenCodeConversationDriver } from "../src/server/conversation/providers/opencodeDriver.js";
+import { eventually } from "./fixtures/eventually.js";
 
 test("native storage policy distinguishes locked deletion from host writer exclusion", () => {
   assert.equal(nativeConversationStoragePolicy("codex").requiresWriterExclusion, false);
@@ -30,14 +32,6 @@ test("native writer recognition handles executables and node entry points withou
   assert.equal(opencode.matchesProcess({ executable: "/tools/opencode-helper", commandLine: "node\0/notes/opencode.txt\0" }), false);
 });
 
-async function eventually(check, message) {
-  const deadline = Date.now() + 2_000;
-  while (!check()) {
-    if (Date.now() > deadline) assert.fail(message);
-    await new Promise(resolve => setTimeout(resolve, 5));
-  }
-}
-
 // One shared native process with independent provider connections, as the
 // real Codex app-server has per account and runtime scope.
 function codexStorageFixture(t, { idleMs = 20, listModelsMs = 0 } = {}) {
@@ -50,7 +44,7 @@ function codexStorageFixture(t, { idleMs = 20, listModelsMs = 0 } = {}) {
     async currentRuntimeInfo() { return { runtimeDir }; },
     async listModels() {
       runtime.reads.push("catalogue");
-      await new Promise(resolve => setTimeout(resolve, listModelsMs));
+      await delay(listModelsMs);
       return { running: runtime.running, data: [{ id: "gpt" }] };
     },
     async readGoal() { runtime.reads.push("goal"); return { goal: null }; },
@@ -113,7 +107,7 @@ test("native storage reads never stop a Codex process a conversation still uses"
   await list("claimed-session");
   await owner.ensureSession(context("claimed-session"));
   await eventually(() => owner.providers.get("provider:archived-1") === undefined, "the storage provider was not released");
-  await new Promise(resolve => setTimeout(resolve, 60));
+  await delay(60);
   assert.equal(runtime.running, true);
   assert.equal(runtime.stops, 0);
   assert.equal(owner.providers.get("provider:open-session"), conversation);
@@ -177,7 +171,7 @@ test("OpenCode storage reads never stop a server a conversation still uses", asy
   const { owner, server, list, conversation } = openCodeStorageFixture();
   const open = await conversation("open-session");
   await list("archived-1");
-  await new Promise(resolve => setTimeout(resolve, 60));
+  await delay(60);
   assert.equal(server.running, true);
   assert.equal(server.stops, 0);
   await owner.release(open);
@@ -220,7 +214,7 @@ test("real use that reaches a storage-created provider directly keeps it", async
     await list(id);
     const provider = owner.providers.get(`provider:${id}`);
     await use(id);
-    await new Promise(resolve => setTimeout(resolve, 60));
+    await delay(60);
     assert.equal(owner.providers.get(`provider:${id}`), provider);
   }
   assert.equal(runtime.running, true);
@@ -232,7 +226,7 @@ test("a storage read on a managed main thread's key leaves it to that thread", a
   const managed = context("archived-1");
   managed.runOwner.runtimeLifecycle.managedThreadId = () => "main-thread";
   await owner.withTransientSession(managed, async () => {});
-  await new Promise(resolve => setTimeout(resolve, 60));
+  await delay(60);
   assert.ok(owner.providers.get("provider:archived-1"));
   assert.equal(runtime.stops, 0);
   await list("archived-2");
@@ -244,7 +238,7 @@ test("a conversation that starts after an OpenCode storage read keeps the server
   const { owner, server, list, conversation } = openCodeStorageFixture({ idleMs: 40 });
   await list("archived-1");
   const open = await conversation("open-session");
-  await new Promise(resolve => setTimeout(resolve, 80));
+  await delay(80);
   assert.equal(server.running, true, "the storage release stopped a server a conversation uses");
   assert.equal(server.starts, 1);
   await owner.release(open);

package/test/fixtures/eventually.js

@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import { setTimeout as delay } from "node:timers/promises";
+
+// Polls `check` until it holds, failing with `message` after two seconds.
+export async function eventually(check, message) {
+  const deadline = Date.now() + 2_000;
+  while (!check()) {
+    if (Date.now() > deadline) assert.fail(message);
+    await delay(5);
+  }
+}