@jskit-ai/assistant-core 0.2.6 → 0.2.8

package/src/server/conversation/codexHelperThreadRecovery.js

@@ -1,44 +1,37 @@
-import { deleteCodexAppServerThread, codexAppServerRuntimeStopWasVerified } from "./codexProvider.js";
-import { directoryExists } from "./codexProviderOwner.js";
-import { CODEX_HELPER_THREAD_LIFECYCLES } from "./codexHelperThreadLedger.js";
-import { normalizeCodexRunText as normalizeText } from "./codexTurnState.js";
+import { deleteCodexAppServerThread } from "./codexProviderThreads.js";
+import { codexAppServerRuntimeStopWasVerified, directoryExists } from "./codexRuntimeInventory.js";
+import { CODEX_HELPER_THREAD_LIFECYCLES } from "./codexHelperThreadRecord.js";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 
-// Recovery operations of the same Helper lifecycle. All maps and record mutations
-// belong to the supplied lifecycle; this module creates no owner or registry.
+/**
+ * Recovery operations of the same helper lifecycle. All maps and record mutations belong to the supplied lifecycle;
+ * this module creates no owner or registry.
+ * @param {import("./codexHelperThreads.js").CodexHelperThreadLifecycle} lifecycle
+ * @param {object} dependencies
+ * @param {import("./codexProviderOwner.js").CodexAppServerProviderOwner} dependencies.providerOwner
+ * @param {string} dependencies.applicationName
+ * @param {string} dependencies.errorPrefix
+ */
 export function createCodexHelperThreadRecovery(lifecycle, {
   providerOwner,
   applicationName,
   errorPrefix
 }) {
   const codexAppServerProviders = providerOwner.providers;
-  const {
-    threads: codexAppServerHelperThreads,
-    mutations: codexAppServerHelperThreadMutations,
-    restores: codexAppServerHelperThreadRestores,
-    key: codexAppServerHelperThreadKey,
-    ledger: codexAppServerHelperThreadLedger,
-    providerFingerprint: codexAppServerProviderKeyFingerprint,
-    attach: attachCodexAppServerHelperThread,
-    remove: removeCodexAppServerHelperThread,
-    retire: retireCodexAppServerHelperThread,
-    ownershipError: codexAppServerHelperOwnershipError,
-    ownershipMatches: codexAppServerHelperThreadOwnershipMatches,
-    failure: codexAppServerHelperFailure
-  } = lifecycle;
 
   async function restoreCodexAppServerHelperThread(record = {}, context = {}) {
     const { ledger = null } = context;
-    const key = codexAppServerHelperThreadKey(record);
-    const pendingMutation = codexAppServerHelperThreadMutations.get(key);
+    const key = lifecycle.key(record);
+    const pendingMutation = lifecycle.mutations.get(key);
     if (pendingMutation) {
       await pendingMutation.catch(() => null);
     }
-    const existing = codexAppServerHelperThreads.get(key);
+    const existing = lifecycle.threads.get(key);
     if (existing && (
       existing.ownershipId !== record.ownershipId ||
       existing.revision < record.revision
     )) {
-      throw codexAppServerHelperOwnershipError(
+      throw lifecycle.ownershipError(
         "Persisted Codex helper ownership changed while the controller was running.",
         { sessionId: record.sessionId, threadId: record.threadId }
       );
@@ -48,12 +41,12 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       if (!context.retiring) {
         return { record: existing, retiredThreadId: "" };
       }
-      await retireCodexAppServerHelperThread(existing);
+      await lifecycle.retire(existing);
       return { record: null, retiredThreadId: existing.threadId };
     }
     if (!await directoryExists(record.identity.runtime.runtimeDir)) {
       if (existing) {
-        await retireCodexAppServerHelperThread(existing);
+        await lifecycle.retire(existing);
       } else {
         await ledger.remove(record);
       }
@@ -62,7 +55,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
     const prepared = await context.prepareProvider();
     const { providerOptions, providerKey } = prepared;
     const contextChanged = !existing &&
-      codexAppServerProviderKeyFingerprint(providerKey) !== record.identity.providerKeyFingerprint;
+      lifecycle.providerFingerprint(providerKey) !== record.identity.providerKeyFingerprint;
     if (contextChanged) {
       const staleProvider = providerOwner.createNativeProvider({
         ...providerOptions,
@@ -73,7 +66,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
         const accountChanged = record.identity.runtime.accountIdentitySignature !==
           normalizeText(currentRuntime.accountIdentitySignature);
         if (accountChanged && !cleanupRequired) {
-          throw codexAppServerHelperOwnershipError(
+          throw lifecycle.ownershipError(
             "Reconnect the original Codex account to resume or delete this helper thread.",
             { retryable: false, sessionId: record.sessionId, threadId: record.threadId }
           );
@@ -87,21 +80,21 @@ export function createCodexHelperThreadRecovery(lifecycle, {
             ? stopped?.ownershipSuperseded === true || stopped?.processExitVerified === true
             : codexAppServerRuntimeStopWasVerified(stopped);
           if (!retired) {
-            throw codexAppServerHelperOwnershipError(
+            throw lifecycle.ownershipError(
               "The earlier Codex runtime could not be verified as retired; its cleanup record has been preserved.",
               { sessionId: record.sessionId, threadId: record.threadId }
             );
           }
           await ledger.remove(record);
-          codexAppServerHelperThreads.delete(key);
+          lifecycle.threads.delete(key);
           return { record: null, retiredThreadId: record.threadId };
         }
       } finally {
-        staleProvider.close?.();
+        staleProvider.close();
       }
     }
     if (existing) {
-      await retireCodexAppServerHelperThread(existing);
+      await lifecycle.retire(existing);
       return { record: null, retiredThreadId: existing.threadId };
     }
     let provider = codexAppServerProviders.get(providerKey);
@@ -113,17 +106,8 @@ export function createCodexHelperThreadRecovery(lifecycle, {
         create: (onObservationLost) => providerOwner.createNativeProvider({ ...providerOptions, onObservationLost })
       });
     }
-    if (typeof provider.currentRuntimeInfo !== "function") {
-      throw codexAppServerHelperOwnershipError(
-        "The Codex provider cannot prove persisted runtime ownership.",
-        {
-          sessionId: record.sessionId,
-          threadId: record.threadId
-        }
-      );
-    }
     const expectedRuntime = await provider.currentRuntimeInfo();
-    if (!codexAppServerHelperThreadOwnershipMatches(record, {
+    if (!lifecycle.ownershipMatches(record, {
       providerKey,
       runtime: expectedRuntime
     }, {
@@ -131,7 +115,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       requireAccount: !cleanupRequired,
       requireEndpoint: false
     })) {
-      throw codexAppServerHelperOwnershipError(
+      throw lifecycle.ownershipError(
         "The current Codex runtime/auth identity does not match persisted helper ownership.",
         {
           retryable: record.identity.runtime.accountIdentitySignature === normalizeText(expectedRuntime.accountIdentitySignature),
@@ -141,14 +125,14 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       );
     }
     await providerOwner.acquireRuntime({
-      operation: () => provider.ensureAvailable?.(),
+      operation: () => provider.ensureAvailable(),
       provider,
       providerKey,
       providerOptions
     });
     const currentRuntime = await provider.currentRuntimeInfo();
-    const currentServer = provider.currentServerInfo?.();
-    if (!codexAppServerHelperThreadOwnershipMatches(record, {
+    const currentServer = provider.currentServerInfo();
+    if (!lifecycle.ownershipMatches(record, {
       providerKey,
       runtime: currentRuntime,
       server: currentServer
@@ -157,7 +141,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       requireEndpoint: true,
       requireServer: !cleanupRequired
     })) {
-      throw codexAppServerHelperOwnershipError(
+      throw lifecycle.ownershipError(
         "The connected Codex server identity does not match persisted helper ownership.",
         {
           sessionId: record.sessionId,
@@ -167,7 +151,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
     }
     const currentLedger = await ledger.readAll();
     if (currentLedger.failures.length > 0) {
-      throw codexAppServerHelperOwnershipError(
+      throw lifecycle.ownershipError(
         "Persisted Codex helper ownership could not be revalidated before restore.",
         {
           failed: currentLedger.failures,
@@ -177,7 +161,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       );
     }
     const currentDurable = currentLedger.records.find((candidate) => (
-      codexAppServerHelperThreadKey(candidate) === key
+      lifecycle.key(candidate) === key
     ));
     if (!currentDurable) {
       return { record: null, retiredThreadId: record.threadId };
@@ -186,7 +170,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       currentDurable.ownershipId !== record.ownershipId ||
       currentDurable.revision !== record.revision
     ) {
-      throw codexAppServerHelperOwnershipError(
+      throw lifecycle.ownershipError(
         "Persisted Codex helper ownership changed before it could be restored.",
         {
           sessionId: record.sessionId,
@@ -194,7 +178,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
         }
       );
     }
-    const attached = attachCodexAppServerHelperThread({
+    const attached = lifecycle.attach({
       durable: currentDurable,
       ledger,
       provider
@@ -203,25 +187,25 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       attached.lifecycle !== CODEX_HELPER_THREAD_LIFECYCLES.READY ||
       context.retiring
     ) {
-      await retireCodexAppServerHelperThread(attached);
+      await lifecycle.retire(attached);
       return { record: null, retiredThreadId: attached.threadId };
     }
     return { record: attached, retiredThreadId: "" };
   }
 
   async function restoreCodexAppServerHelperThreads(projectRuntimeRoot = "", context = {}) {
-    const previous = codexAppServerHelperThreadRestores.get(projectRuntimeRoot) || Promise.resolve();
+    const previous = lifecycle.restores.get(projectRuntimeRoot) || Promise.resolve();
     // Every failure, including an unreadable ledger or a refused host notice,
     // is reported in the result. Callers that require restoration assert it;
     // cleanup and reconciliation continue with the records that did restore.
     const restore = previous.catch(() => null).then(async () => {
-      const ledger = codexAppServerHelperThreadLedger(projectRuntimeRoot);
+      const ledger = lifecycle.ledger(projectRuntimeRoot);
       const failed = [];
       let listed = { failures: [], records: [] };
       try {
         listed = await ledger.readAll();
       } catch (error) {
-        failed.push(codexAppServerHelperFailure({ projectRuntimeRoot }, error));
+        failed.push(lifecycle.failure({ projectRuntimeRoot }, error));
       }
       failed.push(...listed.failures.map((failure) => ({
         ...failure,
@@ -244,13 +228,13 @@ export function createCodexHelperThreadRecovery(lifecycle, {
             retiredBySession.set(record.sessionId, retired);
           }
         } catch (error) {
-          failed.push(codexAppServerHelperFailure(record, error));
+          failed.push(lifecycle.failure(record, error));
         }
       }
       try {
         await context.publish({ records, failed, retiredBySession, normalizedSessionId });
       } catch (error) {
-        failed.push(codexAppServerHelperFailure({ projectRuntimeRoot }, error));
+        failed.push(lifecycle.failure({ projectRuntimeRoot }, error));
       }
       return {
         failed,
@@ -260,12 +244,12 @@ export function createCodexHelperThreadRecovery(lifecycle, {
         retiredThreadIds: [...new Set(retiredThreadIds)]
       };
     });
-    codexAppServerHelperThreadRestores.set(projectRuntimeRoot, restore);
+    lifecycle.restores.set(projectRuntimeRoot, restore);
     try {
       return await restore;
     } finally {
-      if (codexAppServerHelperThreadRestores.get(projectRuntimeRoot) === restore) {
-        codexAppServerHelperThreadRestores.delete(projectRuntimeRoot);
+      if (lifecycle.restores.get(projectRuntimeRoot) === restore) {
+        lifecycle.restores.delete(projectRuntimeRoot);
       }
     }
   }
@@ -275,10 +259,10 @@ export function createCodexHelperThreadRecovery(lifecycle, {
     projectRuntimeRoot = "",
     prepareProvider
   } = {}) {
-    const ledger = codexAppServerHelperThreadLedger(projectRuntimeRoot);
+    const ledger = lifecycle.ledger(projectRuntimeRoot);
     const listed = await ledger.readAll();
     if (listed.failures.length > 0) {
-      throw codexAppServerHelperOwnershipError(
+      throw lifecycle.ownershipError(
         `${applicationName} cannot inventory helper threads while durable ownership is malformed.`,
         { failed: listed.failures, sessionId }
       );
@@ -296,11 +280,11 @@ export function createCodexHelperThreadRecovery(lifecycle, {
         ) {
           continue;
         }
-        const record = codexAppServerHelperThreads.get(
-          codexAppServerHelperThreadKey(durable)
+        const record = lifecycle.threads.get(
+          lifecycle.key(durable)
         );
         if (!record || record.ownershipId !== durable.ownershipId) {
-          throw codexAppServerHelperOwnershipError(
+          throw lifecycle.ownershipError(
             `${applicationName} cannot retire missing helper ownership without its verified controller record.`,
             { sessionId, threadId: durable.threadId }
           );
@@ -312,7 +296,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
           continue;
         }
         try {
-          await removeCodexAppServerHelperThread(record);
+          await lifecycle.remove(record);
         } catch (error) {
           if (error?.code === `${errorPrefix}codex_helper_thread_unavailable`) {
             continue;
@@ -343,15 +327,9 @@ export function createCodexHelperThreadRecovery(lifecycle, {
       };
     }
     provider ||= await providerOwner.ensureSession(prepared.sessionContext);
-    if (typeof provider.listHelperThreads !== "function") {
-      throw codexAppServerHelperOwnershipError(
-        "The Codex helper provider cannot authoritatively inventory its threads.",
-        { sessionId }
-      );
-    }
     const inventory = await provider.listHelperThreads();
     if (!Array.isArray(inventory?.threadIds)) {
-      throw codexAppServerHelperOwnershipError(
+      throw lifecycle.ownershipError(
         "The Codex helper provider returned an invalid thread inventory.",
         { sessionId }
       );
@@ -366,7 +344,7 @@ export function createCodexHelperThreadRecovery(lifecycle, {
         await deleteCodexAppServerThread({ provider, threadId });
       } catch (error) {
         if (error?.code !== "codex_helper_thread_delete_unconfirmed") throw error;
-        throw codexAppServerHelperOwnershipError(
+        throw lifecycle.ownershipError(
           "Codex did not confirm deletion of an unowned helper thread.",
           { sessionId, threadId }
         );
@@ -386,9 +364,9 @@ export function createCodexHelperThreadRecovery(lifecycle, {
     };
   }
 
-  return {
+  return Object.freeze({
     restoreThread: restoreCodexAppServerHelperThread,
     restoreThreads: restoreCodexAppServerHelperThreads,
     reconcileRuntimeUnlocked: reconcileCodexAppServerHelperRuntimeUnlocked
-  };
+  });
 }

package/src/server/conversation/codexHelperThreads.js

@@ -1,28 +1,86 @@
+import { AppError } from "@jskit-ai/kernel/server/runtime/errors";
 import crypto from "node:crypto";
-import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
+import { isRecord, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { createCodexHelperOwnershipError, prepareDetachedCodexHelperThread } from "./codexHelperExecution.js";
-import { deleteCodexAppServerHelperThread } from "./codexProvider.js";
-import { directoryExists } from "./codexProviderOwner.js";
+import { deleteCodexAppServerHelperThread } from "./codexProviderThreads.js";
+import { directoryExists } from "./codexRuntimeInventory.js";
 import { createCodexHelperThreadRecovery } from "./codexHelperThreadRecovery.js";
-import { codexAppServerErrorMessage as errorMessage, normalizeCodexRunText as normalizeText } from "./codexTurnState.js";
+import { codexAppServerErrorMessage as errorMessage } from "./codexTurnState.js";
 import {
   CODEX_HELPER_THREAD_LEDGER_SCHEMA_VERSION,
   CODEX_HELPER_THREAD_LIFECYCLES
-} from "./codexHelperThreadLedger.js";
+} from "./codexHelperThreadRecord.js";
 
 const CODEX_APP_SERVER_PROVIDER_ID = "codex_app_server";
 
-// Internal facet of the original run owner. Public supplies policy and authorized
-// scope inputs; native ownership, pending work and retirement have one owner.
+function codexAppServerHelperThreadKey({
+  projectRuntimeRoot = "",
+  sessionId = "",
+  threadId = ""
+} = {}) {
+  return [
+    normalizeText(projectRuntimeRoot),
+    normalizeText(sessionId),
+    normalizeText(threadId)
+  ].join("\u001f");
+}
+
+function codexAppServerProviderKeyFingerprint(providerKey = "") {
+  return `sha256:${crypto.createHash("sha256")
+    .update(normalizeText(providerKey))
+    .digest("hex")}`;
+}
+
+function codexAppServerRuntimeIdentityMatches(expected = {}, actual = {}, {
+  requireAccount = true,
+  requireEndpoint = true
+} = {}) {
+  return (!requireAccount || expected.accountIdentitySignature === normalizeText(actual.accountIdentitySignature)) &&
+    (!requireEndpoint || expected.endpoint === normalizeText(actual.endpoint)) &&
+    expected.executionMode === normalizeText(actual.executionMode) &&
+    expected.executionContextHash === normalizeText(actual.executionContextHash) &&
+    expected.provider === normalizeText(actual.provider) &&
+    expected.runtimeDir === normalizeText(actual.runtimeDir) &&
+    expected.runtimesHash === normalizeText(actual.runtimesHash) &&
+    expected.terminalEnvHash === normalizeText(actual.terminalEnvHash) &&
+    expected.toolHomeSource === normalizeText(actual.toolHomeSource) &&
+    expected.transport === normalizeText(actual.transport);
+}
+
+function codexAppServerHelperThreadOwnershipMatches(record = {}, {
+  providerKey = "",
+  runtime = {},
+  server = null
+} = {}, options = {}) {
+  return record.identity?.providerId === normalizeText(record.executionProfile?.providerId) &&
+    record.identity?.providerKeyFingerprint === codexAppServerProviderKeyFingerprint(providerKey) &&
+    record.identity?.transportId === CODEX_APP_SERVER_PROVIDER_ID &&
+    codexAppServerRuntimeIdentityMatches(record.identity?.runtime, runtime, options) &&
+    (
+      options.requireServer !== true ||
+      record.identity?.server?.userAgent === normalizeText(server?.userAgent)
+    );
+}
+
+function ignoreHelperThreadRetired() {}
+
+/**
+ * Internal facet of the run owner. The application supplies policy and authorized scope inputs; native ownership,
+ * pending work and retirement have one owner.
+ * @param {object} dependencies
+ * @param {import("./codexProviderOwner.js").CodexAppServerProviderOwner} dependencies.providerOwner
+ * @param {ReturnType<typeof import("./codexHelperThreadLedger.js").createCodexHelperThreadLedgerOwner>} dependencies.ledgerOwner
+ * @param {string} [dependencies.applicationName]
+ * @param {string} [dependencies.errorPrefix]
+ */
 export function createCodexHelperThreadLifecycle({
   providerOwner,
   ledgerOwner,
   applicationName = "Application",
   errorPrefix = ""
-} = {}) {
+}) {
   const codexAppServerProviders = providerOwner.providers;
   const {
-    createCodexHelperThreadLedger: codexHelperThreadLedgerFactory,
     defineCodexHelperThreadRecord
   } = ledgerOwner;
   const codexAppServerHelperThreads = new Map();
@@ -33,18 +91,6 @@ export function createCodexHelperThreadLifecycle({
   const codexAppServerHelperTurnStarts = new Map();
   const codexAppServerHelperThreadRestores = new Map();
 
-  function codexAppServerHelperThreadKey({
-    projectRuntimeRoot = "",
-    sessionId = "",
-    threadId = ""
-  } = {}) {
-    return [
-      normalizeText(projectRuntimeRoot),
-      normalizeText(sessionId),
-      normalizeText(threadId)
-    ].join("\u001f");
-  }
-
   async function withCodexAppServerHelperProjectOperation(
     projectRuntimeRoot = "",
     operation
@@ -68,13 +114,10 @@ export function createCodexHelperThreadLifecycle({
   }
 
   function codexAppServerHelperThreadUnavailableError(threadId = "") {
-    const error = new Error(
-      "This low-cost assistant thread is no longer available. Start the background task again instead of reusing another assistant conversation."
+    const error = new AppError(409,
+      "This low-cost assistant thread is no longer available. Start the background task again instead of reusing another assistant conversation.",
+      { code: `${errorPrefix}codex_helper_thread_unavailable`, messageCode: "assistant.codex.helperThreadUnavailable" }
     );
-    error.code = `${errorPrefix}codex_helper_thread_unavailable`;
-    error.statusCode = 409;
-    error.messageCode = "assistant.codex.helperThreadUnavailable";
-    error.messageParams = {};
     error.threadId = normalizeText(threadId);
     return error;
   }
@@ -148,7 +191,7 @@ export function createCodexHelperThreadLifecycle({
     const normalizedProjectRuntimeRoot = normalizeText(projectRuntimeRoot);
     let ledger = codexAppServerHelperThreadLedgers.get(normalizedProjectRuntimeRoot);
     if (!ledger) {
-      ledger = codexHelperThreadLedgerFactory({
+      ledger = ledgerOwner.createCodexHelperThreadLedger({
         projectRuntimeRoot: normalizedProjectRuntimeRoot
       });
       codexAppServerHelperThreadLedgers.set(normalizedProjectRuntimeRoot, ledger);
@@ -165,20 +208,11 @@ export function createCodexHelperThreadLifecycle({
     return "";
   }
 
-  function codexAppServerProviderKeyFingerprint(providerKey = "") {
-    return `sha256:${crypto.createHash("sha256")
-      .update(normalizeText(providerKey))
-      .digest("hex")}`;
-  }
-
   async function codexAppServerHelperThreadIdentity({
     executionProfile = null,
     provider = null
   } = {}) {
-    if (
-      typeof provider?.currentRuntimeInfo !== "function" ||
-      typeof provider?.currentServerInfo !== "function"
-    ) {
+    if (!provider) {
       throw new Error("Codex provider cannot prove durable helper thread ownership.");
     }
     const runtime = await provider.currentRuntimeInfo();
@@ -209,7 +243,7 @@ export function createCodexHelperThreadLifecycle({
       ...durable,
       durable,
       ledger,
-      onRetired,
+      onRetired: onRetired || ignoreHelperThreadRetired,
       provider
     });
     codexAppServerHelperThreads.set(key, record);
@@ -313,7 +347,7 @@ export function createCodexHelperThreadLifecycle({
     }
     codexAppServerHelperThreadCleanups.delete(key);
     codexAppServerHelperThreads.delete(key);
-    record.onRetired?.({ threadId: record.threadId });
+    record.onRetired({ threadId: record.threadId });
     return true;
   }
 
@@ -351,22 +385,23 @@ export function createCodexHelperThreadLifecycle({
   }
 
   function codexAppServerHelperThreadCleanupError(record = {}, error = null, interruptError = null) {
-    const failure = new Error(
-      `${applicationName} could not retire a low-cost assistant thread. Retry cleanup before shutting down its Codex provider.`
+    const failure = new AppError(503,
+      `${applicationName} could not retire a low-cost assistant thread. Retry cleanup before shutting down its Codex provider.`,
+      {
+        code: `${errorPrefix}codex_helper_thread_cleanup_failed`,
+        details: {
+          cleanupError: errorMessage(error, "Codex helper thread deletion failed."),
+          ...(interruptError
+            ? { interruptError: errorMessage(interruptError, "Codex helper turn interruption failed.") }
+            : {}),
+          retryable: true,
+          sessionId: normalizeText(record.sessionId),
+          threadId: normalizeText(record.threadId),
+          turnId: normalizeText(record.turnId)
+        }
+      }
     );
-    failure.code = `${errorPrefix}codex_helper_thread_cleanup_failed`;
-    failure.statusCode = 503;
     failure.retryable = true;
-    failure.details = {
-      cleanupError: errorMessage(error, "Codex helper thread deletion failed."),
-      ...(interruptError
-        ? { interruptError: errorMessage(interruptError, "Codex helper turn interruption failed.") }
-        : {}),
-      retryable: true,
-      sessionId: normalizeText(record.sessionId),
-      threadId: normalizeText(record.threadId),
-      turnId: normalizeText(record.turnId)
-    };
     return failure;
   }
 
@@ -473,52 +508,16 @@ export function createCodexHelperThreadLifecycle({
     if (result.ok !== false) {
       return result;
     }
-    const failure = new Error(
-      `${applicationName} could not retire every low-cost assistant thread. Retry cleanup before shutting down Codex.`
+    const failure = new AppError(503,
+      `${applicationName} could not retire every low-cost assistant thread. Retry cleanup before shutting down Codex.`,
+      { code: `${errorPrefix}codex_helper_thread_cleanup_failed`, details: { failed: result.failed, retryable: true } }
     );
-    failure.code = `${errorPrefix}codex_helper_thread_cleanup_failed`;
-    failure.statusCode = 503;
     failure.retryable = true;
-    failure.details = {
-      failed: result.failed,
-      retryable: true
-    };
     throw failure;
   }
 
   const codexAppServerHelperOwnershipError = createCodexHelperOwnershipError({ applicationName, errorPrefix });
 
-  function codexAppServerRuntimeIdentityMatches(expected = {}, actual = {}, {
-    requireAccount = true,
-    requireEndpoint = true
-  } = {}) {
-    return (!requireAccount || expected.accountIdentitySignature === normalizeText(actual.accountIdentitySignature)) &&
-      (!requireEndpoint || expected.endpoint === normalizeText(actual.endpoint)) &&
-      expected.executionMode === normalizeText(actual.executionMode) &&
-      expected.executionContextHash === normalizeText(actual.executionContextHash) &&
-      expected.provider === normalizeText(actual.provider) &&
-      expected.runtimeDir === normalizeText(actual.runtimeDir) &&
-      expected.runtimesHash === normalizeText(actual.runtimesHash) &&
-      expected.terminalEnvHash === normalizeText(actual.terminalEnvHash) &&
-      expected.toolHomeSource === normalizeText(actual.toolHomeSource) &&
-      expected.transport === normalizeText(actual.transport);
-  }
-
-  function codexAppServerHelperThreadOwnershipMatches(record = {}, {
-    providerKey = "",
-    runtime = {},
-    server = null
-  } = {}, options = {}) {
-    return record.identity?.providerId === normalizeText(record.executionProfile?.providerId) &&
-      record.identity?.providerKeyFingerprint === codexAppServerProviderKeyFingerprint(providerKey) &&
-      record.identity?.transportId === CODEX_APP_SERVER_PROVIDER_ID &&
-      codexAppServerRuntimeIdentityMatches(record.identity?.runtime, runtime, options) &&
-      (
-        options.requireServer !== true ||
-        record.identity?.server?.userAgent === normalizeText(server?.userAgent)
-      );
-  }
-
   function codexAppServerHelperFailure(record = null, error = null) {
     return {
       code: normalizeText(error?.code) || `${errorPrefix}codex_helper_ownership_blocked`,
@@ -646,3 +645,5 @@ export function createCodexHelperThreadLifecycle({
   });
   return Object.freeze(lifecycle);
 }
+
+/** @typedef {ReturnType<typeof createCodexHelperThreadLifecycle>} CodexHelperThreadLifecycle */