@jskit-ai/assistant-core 0.2.7 → 0.2.9

package/src/server/conversation/codexThreadStatus.js

@@ -1,44 +1,29 @@
-import {
-  codexAppServerTurnStatusIsActive,
-  codexAppServerTurnStatusIsComplete,
-  codexAppServerTurnStatusIsSuccessfulComplete,
-  codexAppServerTurnStatusIsProviderFailure,
-  codexAppServerThreadStatus,
-  codexAppServerReadThreadStatus,
-  normalizeCodexRunText,
-  codexAppServerAgentRun,
-  codexAppServerTurnCanReceiveProviderCompletion,
-  codexAppServerTurnCanAdoptSuccessor,
-  codexAppServerErrorMessage
-} from "./codexTurnState.js";
-import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
-import {
-  codexAppServerStatusFromValue,
-  codexAppServerThreadRawValue,
-  codexAppServerThreadTurnId,
-  codexAppServerThreadError
-} from "./codexEvents.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, 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";
 
-// Native thread snapshot reconciliation; it holds no state of its own.
+/**
+ * Native thread snapshot reconciliation; it holds no state of its own.
+ * @param {object} dependencies
+ * @param {import("./codexRunJournal.js").CodexRunJournal} dependencies.journal
+ * @param {import("./codexResultSettlement.js").CodexResultSettlement} dependencies.settlement
+ * @param {import("./codexTurnRecovery.js").CodexTurnRecovery} dependencies.recovery
+ * @param {import("./codexOutput.js").CodexAppServerOutput} dependencies.output
+ * @param {import("./codexTurn.js").CodexCreateRuntime} dependencies.createRuntime
+ * @param {import("./codexTurn.js").CodexTurnStateReader} dependencies.turnState
+ * @param {import("./codexTurn.js").CodexTurnOutcomes} dependencies.turnOutcomes
+ * @param {import("./codexTurn.js").CodexDebugLog} dependencies.debugLog
+ * @param {import("./codexTurn.js").CodexDebugError} dependencies.debugError
+ */
 export function createCodexThreadStatus({ journal, settlement, recovery, output, createRuntime, turnState, turnOutcomes, debugLog, debugError }) {
-  const { turnResultWasProcessed: codexAppServerTurnResultWasProcessed } = journal;
-  const {
-    finalizeAssistantResult: finalizeCodexAppServerAssistantResult,
-    adoptSuccessorTurn: adoptCodexAppServerSuccessorTurn
-  } = settlement;
-  const {
-    stopTurnWithProviderFailure: stopCodexAppServerTurnWithProviderFailure,
-    markProviderTurnActive: markCodexAppServerProviderTurnActive,
-    completeTurn: completeCodexAppServerTurn
-  } = recovery;
-  const { reconcileObservedTurnItems: reconcileCodexAppServerObservedTurnItems } = output;
 
   function codexAppServerReadyTurnFailureMessage(reason = "", error = "") {
-    const detail = normalizeCodexRunText(error);
+    const detail = normalizeText(error);
     if (detail) {
       return detail;
     }
-    switch (normalizeCodexRunText(reason)) {
+    switch (normalizeText(reason)) {
       case "thread_replaced":
         return "Codex app-server resumed a different thread before this turn completed.";
       case "provider_unreadable":
@@ -61,9 +46,9 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
     threadId = "",
     turnId = ""
   } = {}) {
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
-    const normalizedThreadId = normalizeCodexRunText(threadId) || normalizeCodexRunText(turn.threadId);
-    const normalizedTurnId = normalizeCodexRunText(turnId) || normalizeCodexRunText(turn.turnId);
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedThreadId = normalizeText(threadId) || normalizeText(turn.threadId);
+    const normalizedTurnId = normalizeText(turnId) || normalizeText(turn.turnId);
     if (!normalizedSessionId || !normalizedThreadId) {
       return {
         ok: false,
@@ -71,7 +56,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
         reason: "missing_tracked_turn"
       };
     }
-    return stopCodexAppServerTurnWithProviderFailure(
+    return recovery.stopTurnWithProviderFailure(
       normalizedSessionId,
       normalizedThreadId,
       normalizedTurnId,
@@ -89,8 +74,8 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
     requireTrackedTurn = false,
     source = ""
   } = {}) {
-    const normalizedSessionId = normalizeCodexRunText(sessionId);
-    const normalizedThreadId = normalizeCodexRunText(threadId);
+    const normalizedSessionId = normalizeText(sessionId);
+    const normalizedThreadId = normalizeText(threadId);
     const runtime = normalizedSessionId
       ? await createRuntime()
       : null;
@@ -107,7 +92,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
       trackedTurn.threadId
       ? trackedTurn
       : null;
-    const statusThreadId = normalizeCodexRunText(trackedProviderTurn?.threadId) || normalizedThreadId;
+    const statusThreadId = normalizeText(trackedProviderTurn?.threadId) || normalizedThreadId;
     const shouldFailUnconfirmed = failUnconfirmedTrackedTurn && trackedProviderTurn;
     if (!normalizedSessionId || !normalizedThreadId) {
       return {
@@ -123,13 +108,13 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
     }
     if (
       trackedProviderTurn?.state === "finalizing" &&
-      codexAppServerTurnResultWasProcessed(
+      journal.turnResultWasProcessed(
         session,
         trackedProviderTurn.threadId,
         trackedProviderTurn.turnId
       )
     ) {
-      await finalizeCodexAppServerAssistantResult(
+      await settlement.finalizeAssistantResult(
         normalizedSessionId,
         trackedProviderTurn.threadId,
         trackedProviderTurn.turnId,
@@ -148,7 +133,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
       debugLog("appServerThread.reconcile.trackedThreadReplaced", {
         currentThreadId: normalizedThreadId,
         sessionId: normalizedSessionId,
-        source: normalizeCodexRunText(source),
+        source: normalizeText(source),
         trackedThreadId: statusThreadId,
         trackedTurnId: trackedProviderTurn.turnId
       });
@@ -157,7 +142,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
       });
     }
 
-    if (typeof provider?.readThreadStatus !== "function") {
+    if (!provider) {
       if (shouldFailUnconfirmed) {
         return failCodexAppServerTrackedReadyTurn(normalizedSessionId, trackedProviderTurn, {
           reason: "provider_unreadable"
@@ -179,7 +164,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
         debugLog("appServerThread.reconcile.readFailed", {
           error: debugError(error),
           sessionId: normalizedSessionId,
-          source: normalizeCodexRunText(source),
+          source: normalizeText(source),
           threadId: statusThreadId,
           turnId: trackedProviderTurn.turnId
         });
@@ -220,9 +205,9 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
       turnId &&
       codexAppServerTurnCanAdoptSuccessor(trackedProviderTurn, statusThreadId, turnId)
     ) {
-      const adoption = await adoptCodexAppServerSuccessorTurn(normalizedSessionId, {
+      const adoption = await settlement.adoptSuccessorTurn(normalizedSessionId, {
         previousTurnId: trackedProviderTurn.turnId,
-        source: normalizeCodexRunText(source) || "thread_status",
+        source: normalizeText(source) || "thread_status",
         status: "inProgress",
         threadId: statusThreadId,
         turnId
@@ -246,7 +231,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
         debugLog("appServerThread.reconcile.activeWithoutTurn", {
           sessionId: normalizedSessionId,
           status,
-          source: normalizeCodexRunText(source),
+          source: normalizeText(source),
           threadId: statusThreadId,
           trackedTurnId: trackedProviderTurn?.turnId || ""
         });
@@ -255,16 +240,16 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
           status
         };
       }
-      await markCodexAppServerProviderTurnActive(normalizedSessionId, {
+      await recovery.markProviderTurnActive(normalizedSessionId, {
         observedRun: codexAppServerTurnStatusIsActive(codexAppServerStatusFromValue(
           codexAppServerThreadRawValue(thread).status || thread.status
         )) ? codexAppServerAgentRun(session) : null,
-        source: normalizeCodexRunText(source) || "thread_status",
+        source: normalizeText(source) || "thread_status",
         status,
         threadId: statusThreadId,
         turnId
       });
-      await reconcileCodexAppServerObservedTurnItems(
+      await output.reconcileObservedTurnItems(
         normalizedSessionId,
         statusThreadId,
         thread?.observedTurn,
@@ -283,10 +268,10 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
     ) {
       const currentSession = await runtime.getSession(normalizedSessionId);
       const currentTurn = turnState(currentSession);
-      if (!currentTurn.active && normalizeCodexRunText(currentTurn.turnId) !== turnId) {
-        await markCodexAppServerProviderTurnActive(normalizedSessionId, {
+      if (!currentTurn.active && normalizeText(currentTurn.turnId) !== turnId) {
+        await recovery.markProviderTurnActive(normalizedSessionId, {
           inputSource: "terminal",
-          source: normalizeCodexRunText(source) || "thread_snapshot",
+          source: normalizeText(source) || "thread_snapshot",
           status: "inProgress",
           threadId: statusThreadId,
           turnId
@@ -298,7 +283,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
         statusThreadId,
         turnId
       )) {
-        await reconcileCodexAppServerObservedTurnItems(
+        await output.reconcileObservedTurnItems(
           normalizedSessionId,
           statusThreadId,
           thread.observedTurn,
@@ -306,7 +291,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
         );
       }
     }
-    const completedTurnId = turnId || normalizeCodexRunText(trackedProviderTurn?.turnId);
+    const completedTurnId = turnId || normalizeText(trackedProviderTurn?.turnId);
     if (!completedTurnId) {
       return {
         ok: true,
@@ -314,13 +299,13 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
       };
     }
     if (codexAppServerTurnStatusIsProviderFailure(status)) {
-      await stopCodexAppServerTurnWithProviderFailure(normalizedSessionId, statusThreadId, completedTurnId, {
+      await recovery.stopTurnWithProviderFailure(normalizedSessionId, statusThreadId, completedTurnId, {
         error: codexAppServerThreadError(thread),
         provider,
         status
       });
     } else if (codexAppServerTurnStatusIsSuccessfulComplete(status)) {
-      await completeCodexAppServerTurn(normalizedSessionId, statusThreadId, completedTurnId, {
+      await recovery.completeTurn(normalizedSessionId, statusThreadId, completedTurnId, {
         status,
         verifyInactive: false
       });
@@ -346,9 +331,10 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
     });
   }
 
-
-  return {
+  return Object.freeze({
     reconcileThreadStatus: reconcileCodexAppServerThreadStatus,
     reconcileLoadedThreadStatus: reconcileCodexAppServerLoadedThreadStatus
-  };
+  });
 }
+
+/** @typedef {ReturnType<typeof createCodexThreadStatus>} CodexThreadStatus */

package/src/server/conversation/codexTurn.js

@@ -2,6 +2,7 @@ import { createCodexSessionReconciliation } from "./codexSessionReconciliation.j
 import { createCodexRuntimeLifecycle } from "./codexRuntimeLifecycle.js";
 import { createCodexSessionCleanup } from "./codexSessionCleanup.js";
 import { createCodexMessageCommands } from "./codexMessageCommands.js";
+import { createCodexPromptDispatch } from "./codexPromptDispatch.js";
 import { createCodexTurnControl } from "./codexTurnControl.js";
 import { createCodexObservationControl } from "./codexObservationControl.js";
 import { createCodexThreadReadiness } from "./codexThreadReadiness.js";
@@ -16,14 +17,10 @@ import { createCodexProviderSelection } from "./codexProviderSelection.js";
 import { createCodexAppServerMessageDelivery } from "./codexMessageDelivery.js";
 import { createCodexConversationCommands } from "./codexConversations.js";
 import { createCodexAppServerOutput } from "./codexOutput.js";
-import {
-  normalizeCodexRunText,
-  normalizeCodexAppServerRunState,
-  codexAppServerTurnStateFromAgentRun,
-  codexAppServerTurnState
-} from "./codexTurnState.js";
+import { normalizeCodexAppServerRunState, codexAppServerTurnStateFromAgentRun, codexAppServerTurnState } from "./codexTurnState.js";
 
 import { createCodexAppServerNotificationQueue } from "./codexNotificationQueue.js";
+import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 export {
   CODEX_APP_SERVER_RUN_STATE,
   normalizeCodexAppServerRunState,
@@ -68,50 +65,158 @@ import {
 } from "./codexHelperExecution.js";
 export { sendPreparedCodexAppServerHelperTurn } from "./codexHelperExecution.js";
 import { createCodexHelperThreadLifecycle } from "./codexHelperThreads.js";
-export { codexAppServerThreadIsMissing } from "./codexProvider.js";
+export { codexAppServerThreadIsMissing } from "./codexProviderThreads.js";
+
+/** @typedef {(sessionId: string) => string} CodexSessionNamespace */
+/** @typedef {(event: string, details?: object) => void} CodexDebugLog */
+/** @typedef {(error: unknown) => string} CodexDebugError */
+/** @typedef {() => Promise<any>} CodexCreateRuntime */
+/** @typedef {() => Promise<any>} CodexCreateStore */
+/** @typedef {(sessionId: string, event: object) => Promise<unknown>} CodexPublish */
+/** @typedef {(session: object) => ReturnType<typeof codexAppServerTurnState>} CodexTurnStateReader */
+/** @typedef {(run: object) => ReturnType<typeof codexAppServerTurnStateFromAgentRun>} CodexAgentRunTurnStateReader */
+/** @typedef {() => unknown} CodexCaptureContext */
+/** @typedef {(context: unknown, operation: () => any) => any} CodexRunInContext */
+/** @typedef {typeof CODEX_TURN_OUTCOMES} CodexTurnOutcomes */
+/** @typedef {(runtime: any, session: object, options: object) => Promise<any>} CodexAdmissionRecovery */
+/** @typedef {(sessionId: string, input: object) => Promise<unknown>} CodexCheckpoint */
+
+/**
+ * The application hooks that add metadata to the turns a run writes.
+ * @typedef {object} CodexMessageMetadataHooks
+ * @property {(actorContext: unknown) => unknown} actor Metadata for the person who sent a message.
+ * @property {(store: any, sessionId: string, metadata: object) => unknown} delivered Metadata of a delivered message.
+ * @property {(store: any, sessionId: string) => unknown} terminal Metadata of a turn written after the run stopped.
+ */
+
+/**
+ * The managed provider sessions of an application that owns its provider processes.
+ * @typedef {object} CodexProviderSessions
+ * @property {import("./codexProviderOwner.js").CodexAppServerProviderOwner} owner
+ * @property {Map<string, any>} [managed]
+ * @property {Function} [context]
+ * @property {Function} [keyFields]
+ * @property {Function} [connectionPolicy]
+ * @property {Function} [outputContext]
+ * @property {Function} [assertOpen]
+ */
+
+const CODEX_TURN_OUTCOMES = Object.freeze({
+  PROVIDER_FAILURE: "provider_failure",
+  RESPONSE_DELIVERY_FAILURE: "response_delivery_failure",
+  SERVICE_RESTART: "service_restart",
+  USER_CANCELLED: "user_cancelled",
+  CONTROL_RECONFIGURATION: "control_reconfiguration",
+  INTERRUPTED: "interrupted"
+});
+
+function ignoreDebugLog() {}
+
+async function answerNothing() {
+  return null;
+}
+
+function captureNoContext() {
+  return null;
+}
+
+function addNoMessageMetadata() {
+  return null;
+}
+
+function keepDeliveredMessageMetadata(_store, _sessionId, metadata) {
+  return metadata;
+}
 
+function codexResultDeliveryFailureMessage({ error = "" } = {}) {
+  const detail = normalizeText(error);
+  if (!detail) return "Codex app-server finished this turn, but the assistant result text was not received.";
+  const punctuation = [".", "!", "?"].some(character => detail.endsWith(character)) ? "" : ".";
+  return "Codex completed, but its response could not be processed: " + detail + punctuation;
+}
+
+function runInNoContext(_context, operation) {
+  return operation();
+}
+
+/**
+ * Builds the run owner of one application's Codex turns: messages, turns, recovery, output, conversations and
+ * goals over one session store. Every hook without a value does nothing.
+ * @param {object} options
+ * @param {CodexSessionNamespace} [options.namespace]
+ * @param {(state: unknown) => string} [options.normalizeRunState]
+ * @param {CodexDebugLog} [options.debugLog]
+ * @param {CodexDebugError} [options.debugError]
+ * @param {CodexCreateRuntime} options.createRuntime
+ * @param {CodexCreateStore} options.createStore
+ * @param {CodexPublish} [options.publish]
+ * @param {(input: { sessionId: string, runtime: any, session: object }) => Promise<any>} [options.acquireProvider]
+ * @param {CodexProviderSessions} [options.providerSessions] Absent when the provider is acquired per call.
+ * @param {{ message: string, code?: string, retryable?: boolean }} [options.serverClosingError]
+ * @param {object} [options.helperThreads] The helper thread ledger options, when the application runs helpers.
+ * @param {number} [options.modelCatalogCacheMs]
+ * @param {object} [options.conversationPreparation] Absent when the application starts no scoped conversations.
+ * @param {string} [options.sessionIdRequiredError]
+ * @param {string} [options.turnAlreadyRunningError]
+ * @param {string} [options.messageIdPrefix]
+ * @param {object} [options.idlePublishPayload]
+ * @param {CodexCheckpoint} [options.checkpoint]
+ * @param {Partial<CodexMessageMetadataHooks>} [options.messageMetadata]
+ * @param {boolean} [options.persistCommentary]
+ * @param {string} [options.deliveryStateMetadataKey]
+ * @param {(session: object) => boolean} [options.hasRuntime]
+ * @param {CodexAdmissionRecovery} [options.recoverAdmission]
+ * @param {(session: object, run: object) => boolean} [options.admissionTaskFinished]
+ * @param {(...details: any[]) => Promise<unknown>} [options.outcomeNotice]
+ * @param {(details: { error?: string }) => string} [options.resultDeliveryFailureMessage]
+ * @param {string} [options.orphanedPromptMessage]
+ * @param {(kind: string, details: object) => Promise<unknown>} [options.onNotificationSignal]
+ * @param {CodexCaptureContext} [options.captureContext]
+ * @param {CodexRunInContext} [options.runInContext]
+ * @param {(sessionId: string, input: { threadId: string }) => Promise<unknown>} [options.continueGoalAfterAccountChange]
+ *   Resumes a goal an account change paused, once the previous account's runtime has stopped. Without it the goal
+ *   stays paused for the person to resume.
+ * @param {import("./codexNotificationQueue.js").CodexAppServerNotificationQueue} [options.notificationQueue]
+ * @param {number} [options.activeReconcileMs]
+ * @param {number} [options.finalizingGraceMs]
+ * @param {boolean} [options.finalizingGraceAfterHistoryRead]
+ * @param {number} [options.failureDetailGraceMs]
+ * @param {string} [options.steerFailedCode]
+ * @param {string} [options.interruptFailedCode]
+ * @param {string} [options.errorPrefix]
+ */
 export function createCodexAppServerRunOwner({
-  namespace = normalizeCodexRunText,
+  namespace = normalizeText,
   normalizeRunState = normalizeCodexAppServerRunState,
-  debugLog = () => {},
-  debugError = error => normalizeCodexRunText(error?.message || error),
+  debugLog = ignoreDebugLog,
+  debugError = error => normalizeText(error?.message || error),
   createRuntime,
   createStore,
-  publish = async () => null,
-  acquireProvider = async () => null,
-  providerSessions = null,
-  serverClosingError = null,
+  publish = answerNothing,
+  acquireProvider = answerNothing,
+  providerSessions,
+  serverClosingError,
   helperThreads = null,
   modelCatalogCacheMs = 30_000,
-  conversationPreparation = null,
-  storeReadError = "The session store does not support agent-run reads.",
+  conversationPreparation,
   sessionIdRequiredError = "A session ID is required.",
-  turnClaimsUnsupportedError = "The session runtime does not support Codex turn claims.",
   turnAlreadyRunningError = "Codex is already working on this session.",
   messageIdPrefix = "codex:",
-  idlePublishPayload = null,
-  checkpoint = async () => null,
+  idlePublishPayload,
+  checkpoint = answerNothing,
   messageMetadata = {},
   persistCommentary = true,
   deliveryStateMetadataKey = "assistant_delivery",
   hasRuntime = () => true,
-  recoverAdmission = null,
+  recoverAdmission,
   admissionTaskFinished = () => false,
-  outcomeNotice = async () => null,
-  resultDeliveryFailureMessage = ({ error = "" } = {}) => {
-    const detail = normalizeCodexRunText(error);
-    if (!detail) return "Codex app-server finished this turn, but the assistant result text was not received.";
-    const punctuation = [".", "!", "?"].some(character => detail.endsWith(character)) ? "" : ".";
-    return "Codex completed, but its response could not be processed: " + detail + punctuation;
-  },
+  outcomeNotice = answerNothing,
+  resultDeliveryFailureMessage = codexResultDeliveryFailureMessage,
   orphanedPromptMessage = "The application restarted before Codex confirmed the message. Your message is safe; retry it.",
-  onNotificationSignal = async () => null,
-  captureContext = () => null,
-  runInContext = (_context, operation) => operation(),
-  // Resumes a goal an account change paused, once the previous account's
-  // runtime has stopped: `(sessionId, { threadId })`. Without it the goal stays
-  // paused for the person to resume.
-  continueGoalAfterAccountChange = null,
+  onNotificationSignal = answerNothing,
+  captureContext = captureNoContext,
+  runInContext = runInNoContext,
+  continueGoalAfterAccountChange,
   notificationQueue = null,
   activeReconcileMs = 2000,
   finalizingGraceMs = 10000,
@@ -120,7 +225,7 @@ export function createCodexAppServerRunOwner({
   steerFailedCode = "codex_turn_steer_failed",
   interruptFailedCode = "codex_turn_interrupt_failed",
   errorPrefix = ""
-} = {}) {
+}) {
   if (typeof persistCommentary !== "boolean") throw new TypeError("Invalid Codex commentary persistence policy.");
   if (!Number.isSafeInteger(finalizingGraceMs) || finalizingGraceMs < 1) {
     throw new TypeError("Invalid Codex finalizing grace.");
@@ -135,14 +240,13 @@ export function createCodexAppServerRunOwner({
     providerSessions = { ...providerSessions, managed: providerSessions.managed || new Map() };
   }
   const liveProgressMaxLength = 320;
-  const turnOutcomes = {
-    PROVIDER_FAILURE: "provider_failure",
-    RESPONSE_DELIVERY_FAILURE: "response_delivery_failure",
-    SERVICE_RESTART: "service_restart",
-    USER_CANCELLED: "user_cancelled",
-    CONTROL_RECONFIGURATION: "control_reconfiguration",
-    INTERRUPTED: "interrupted"
-  };
+  const turnOutcomes = CODEX_TURN_OUTCOMES;
+  /** @type {CodexMessageMetadataHooks} */
+  const messageMetadataHooks = Object.freeze({
+    actor: messageMetadata.actor || addNoMessageMetadata,
+    delivered: messageMetadata.delivered || keepDeliveredMessageMetadata,
+    terminal: messageMetadata.terminal || addNoMessageMetadata
+  });
   const snapshotRecoveryItemLimit = 25;
   const helperOwnershipError = createCodexHelperOwnershipError({ errorPrefix });
   const helperLifecycle = helperThreads ? createCodexHelperThreadLifecycle({
@@ -154,9 +258,9 @@ export function createCodexAppServerRunOwner({
     namespace, runInContext,
     isClosing: () => runOwner.runtimeLifecycle?.closing === true,
     reportError: (error, context) => debugLog("appServerNotification.error", {
-      error: debugError(error), method: normalizeCodexRunText(context.method),
-      sessionId: normalizeCodexRunText(context.sessionId),
-      threadId: normalizeCodexRunText(context.threadId), turnId: normalizeCodexRunText(context.turnId)
+      error: debugError(error), method: normalizeText(context.method),
+      sessionId: normalizeText(context.sessionId),
+      threadId: normalizeText(context.threadId), turnId: normalizeText(context.turnId)
     })
   });
   const codexAppServerPromptDeliveries = new Set();
@@ -193,8 +297,7 @@ export function createCodexAppServerRunOwner({
     debugError,
     liveProgressMaxLength,
     persistCommentary,
-    storeReadError,
-    messageMetadata,
+    messageMetadata: messageMetadataHooks,
     snapshotRecoveryItemLimit
   });
 
@@ -209,7 +312,6 @@ export function createCodexAppServerRunOwner({
     output: codexAppServerOutput,
     messageIdPrefix,
     sessionIdRequiredError,
-    turnClaimsUnsupportedError,
     turnAlreadyRunningError,
     errorPrefix,
     idlePublishPayload,
@@ -217,6 +319,7 @@ export function createCodexAppServerRunOwner({
     admissionTaskFinished,
     orphanedPromptMessage
   });
+  const admissionRecovery = recoverAdmission || codexRunJournal.recoverAbandonedPromptClaim;
 
   const codexResultSettlement = createCodexResultSettlement({
     journal: codexRunJournal,
@@ -248,7 +351,7 @@ export function createCodexAppServerRunOwner({
     failureDetailGraceMs,
     notificationQueue: codexAppServerNotificationQueue,
     hasRuntime,
-    recoverAdmission,
+    recoverAdmission: admissionRecovery,
     turnOutcomes,
     outcomeNotice,
     resultDeliveryFailureMessage
@@ -269,7 +372,7 @@ export function createCodexAppServerRunOwner({
   const codexMessageDelivery = createCodexAppServerMessageDelivery({
     namespace,
     publish,
-    messageMetadata,
+    messageMetadata: messageMetadataHooks,
     createStore,
     turnStateFromAgentRun,
     deliveryStateMetadataKey,
@@ -349,6 +452,18 @@ export function createCodexAppServerRunOwner({
     turnState
   });
 
+  const codexPromptDispatch = createCodexPromptDispatch({
+    output: codexAppServerOutput,
+    journal: codexRunJournal,
+    recovery: codexTurnRecovery,
+    threadStatus: codexThreadStatus,
+    delivery: codexMessageDelivery,
+    debugError,
+    debugLog,
+    steerFailedCode,
+    turnState
+  });
+
   const codexMessageCommands = createCodexMessageCommands({
     output: codexAppServerOutput,
     journal: codexRunJournal,
@@ -357,16 +472,17 @@ export function createCodexAppServerRunOwner({
     selection: codexProviderSelection,
     observer: codexNotificationObserver,
     delivery: codexMessageDelivery,
+    promptDispatch: codexPromptDispatch,
     promptDeliveries: codexAppServerPromptDeliveries,
     createRuntime,
     debugError,
     debugLog,
     errorPrefix,
     messageIdPrefix,
-    messageMetadata,
+    messageMetadata: messageMetadataHooks,
     namespace,
     providerSessions,
-    recoverAdmission,
+    recoverAdmission: admissionRecovery,
     steerFailedCode,
     turnAlreadyRunningError,
     turnState
@@ -495,8 +611,8 @@ export function createCodexAppServerRunOwner({
     recoverObservationLoss: codexObservationControl.recoverObservationLoss,
     runRenewalHandover: codexRenewalCommands.runCodexAppServerRenewalHandover,
     runRenewalSeed: codexRenewalCommands.runCodexAppServerRenewalSeed,
-    startTurn: codexMessageCommands.startTurn,
-    steerTurn: codexMessageCommands.steerTurn,
+    startTurn: codexPromptDispatch.startTurn,
+    steerTurn: codexPromptDispatch.steerTurn,
     prepareGoalContext: codexGoalCommands.prepareCodexAppServerGoalContext,
     validateGoalInput: codexGoalCommands.validateCodexAppServerGoalInput,
     updateGoal: codexGoalCommands.updateCodexAppServerGoal,