@jskit-ai/assistant-core 0.1.239 → 0.1.241

package/src/server/conversation/codexRunJournal.js

@@ -9,14 +9,15 @@ import {
   codexAppServerAgentRunPatch,
   codexAppServerRunIdentityForPatch,
   codexAppServerRunPatchIsStaleAfterTerminalState,
+  codexAppServerRunPatchSettlesOtherActiveTurn,
   CODEX_APP_SERVER_AGENT_RUN_ID,
   CODEX_AGENT_PROVIDER,
   CODEX_APP_SERVER_RUN_STATE,
-  CODEX_APP_SERVER_ACTIVE_RUN_STATES,
-  codexAppServerRunInputSource
+  codexAppServerRunInputSource,
+  codexAppServerTurnStateFromAgentRun
 } from "./codexTurnState.js";
 import crypto from "node:crypto";
-import { isPlainObject } from "./normalize.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 const CODEX_APP_SERVER_PROMPT_CLAIM_GRACE_MS = 15000;
 
@@ -207,12 +208,18 @@ export function createCodexRunJournal({
         currentTurn.threadId === runPatch.providerThreadId &&
         currentTurn.turnId === runPatch.providerTurnId &&
         runPatch.state === CODEX_APP_SERVER_RUN_STATE.ACTIVE;
+      const observationLostBlocks = currentTurn.status === "observation_lost" && status !== "observation_lost";
+      const phaseTargetsOtherTurn = phase !== undefined && (!normalizeCodexRunText(turnId) ||
+        !codexAppServerTurnCanReceiveProviderActivity(currentTurn, threadId, turnId));
+      const observationExpired = Boolean(observedRun) && !canRecoverStoppedTurn;
+      const terminalAlreadyRecorded = !canRecoverStoppedTurn && runPatchIsStaleAfterTerminalState(currentTurn, runPatch);
+      const settlesOtherActiveTurn = codexAppServerRunPatchSettlesOtherActiveTurn(currentTurn, runPatch);
       if (
-        (currentTurn.status === "observation_lost" && status !== "observation_lost") ||
-        (phase !== undefined && (!normalizeCodexRunText(turnId) ||
-          !codexAppServerTurnCanReceiveProviderActivity(currentTurn, threadId, turnId))) ||
-        (observedRun && !canRecoverStoppedTurn) ||
-        (!canRecoverStoppedTurn && runPatchIsStaleAfterTerminalState(currentTurn, runPatch))
+        observationLostBlocks ||
+        phaseTargetsOtherTurn ||
+        observationExpired ||
+        terminalAlreadyRecorded ||
+        settlesOtherActiveTurn
       ) {
         stale = {
           currentState: currentTurn.state,
@@ -260,9 +267,9 @@ export function createCodexRunJournal({
 
   function clearCodexAppServerFinalizingTimer(sessionId = "", threadId = "", turnId = "") {
     const key = codexAppServerResultFinalizationKey(sessionId, threadId, turnId);
-    const timer = codexAppServerFinalizingTimers.get(key);
-    if (timer) {
-      clearTimeout(timer);
+    const entry = codexAppServerFinalizingTimers.get(key);
+    if (entry) {
+      clearTimeout(entry.timer);
       codexAppServerFinalizingTimers.delete(key);
     }
   }
@@ -271,9 +278,9 @@ export function createCodexRunJournal({
     const normalizedSessionId = normalizeCodexRunText(sessionId);
     clearCodexAppServerActiveTimer(normalizedSessionId);
     const finalizingKeyPrefix = `${namespace(normalizedSessionId)}:`;
-    for (const [key, timer] of codexAppServerFinalizingTimers.entries()) {
+    for (const [key, entry] of codexAppServerFinalizingTimers.entries()) {
       if (key.startsWith(finalizingKeyPrefix)) {
-        clearTimeout(timer);
+        clearTimeout(entry.timer);
         codexAppServerFinalizingTimers.delete(key);
       }
     }
@@ -291,34 +298,10 @@ export function createCodexRunJournal({
   }
 
   function codexAppServerAgentRunRealtimePayload(runPatch = {}) {
-    const runState = normalizeRunState(runPatch.state);
-    const active = codexAppServerRunStateIsActive(runState);
-    const state = runState === CODEX_APP_SERVER_RUN_STATE.FINALIZING
-      ? "finalizing"
-      : runState === CODEX_APP_SERVER_RUN_STATE.STARTING
-        ? "starting"
-        : active
-          ? "active"
-          : "idle";
-    const turn = {
-      active,
-      completedAt: normalizeCodexRunText(runPatch.finishedAt),
-      error: normalizeCodexRunText(runPatch.error),
-      inputSource: normalizeCodexRunText(runPatch.inputSource),
-      outerTurnId: normalizeCodexRunText(runPatch.outerTurnId),
-      phase: active && runPatch.providerStatus !== "observation_lost" ? normalizeCodexRunText(runPatch.providerPhase) : "",
-      runId: CODEX_APP_SERVER_AGENT_RUN_ID,
-      runState,
-      startedAt: normalizeCodexRunText(runPatch.startedAt),
-      state,
-      status: normalizeCodexRunText(runPatch.providerStatus || runState),
-      threadId: normalizeCodexRunText(runPatch.providerThreadId),
-      turnId: normalizeCodexRunText(runPatch.providerTurnId),
-      updatedAt: normalizeCodexRunText(runPatch.updatedAt)
-    };
+    const turn = codexAppServerTurnStateFromAgentRun({ ...runPatch, id: CODEX_APP_SERVER_AGENT_RUN_ID }, normalizeRunState);
     return {
       agentRun: {
-        active,
+        active: turn.active,
         id: CODEX_APP_SERVER_AGENT_RUN_ID,
         inputSource: turn.inputSource,
         outerTurnId: turn.outerTurnId,
@@ -327,7 +310,7 @@ export function createCodexRunJournal({
         providerStatus: turn.status,
         providerThreadId: turn.threadId,
         providerTurnId: turn.turnId,
-        state: runState,
+        state: turn.runState,
         updatedAt: turn.updatedAt
       },
       agentSession: {
@@ -390,7 +373,7 @@ export function createCodexRunJournal({
       payload: {
         ...codexAppServerAgentRunRealtimePayload(runPatch),
         ...(conversationStream ? { conversationStream } : {}),
-        ...(isPlainObject(publishPayload) ? publishPayload : {})
+        ...(isRecord(publishPayload) ? publishPayload : {})
       },
       reason: publishReason || "codex-app-server-turn-state",
       session: updatedSession
@@ -584,7 +567,6 @@ export function createCodexRunJournal({
       nowMs - runUpdatedMs >= CODEX_APP_SERVER_PROMPT_CLAIM_GRACE_MS
     );
     return (
-      (run.active === true || CODEX_APP_SERVER_ACTIVE_RUN_STATES.has(normalizeRunState(run.state))) &&
       normalizeCodexRunText(run.state) === CODEX_APP_SERVER_RUN_STATE.STARTING &&
       !normalizeCodexRunText(run.providerThreadId) &&
       !normalizeCodexRunText(run.providerTurnId) &&

package/src/server/conversation/codexRuntimeLifecycle.js

@@ -1,9 +1,13 @@
 import { normalizeCodexRunText as normalizeText } from "./codexTurnState.js";
 
-// The original shared runtime shutdown and wellbeing lifecycle. This facet
-// uses the run/provider owners' existing collections; it does not own servers.
+// Shutdown, wellbeing timers and managed-session records for shared Codex
+// runtimes. It works on the run/provider owners' collections; it owns no servers.
+// `pendingWork` names the run owner's in-flight task collections that shutdown
+// drains; `observer` owns the event subscriptions a released provider ends.
 export function createCodexRuntimeLifecycle({
-  runOwner,
+  pendingWork,
+  observer,
+  checkManagedConnection,
   providerSessions,
   helperLifecycle,
   captureContext,
@@ -58,16 +62,16 @@ export function createCodexRuntimeLifecycle({
   function codexAppServerProviderResources(providerKey) {
     const normalizedProviderKey = normalizeText(providerKey);
     return {
-      retire: runOwner.helperThreads.retireProvider,
-      reconcileRetirement: runOwner.helperThreads.reconcileProviderRetirement,
+      retire: helperLifecycle.retireProvider,
+      reconcileRetirement: helperLifecycle.reconcileProviderRetirement,
       release(provider) {
-        runOwner.helperThreads.assertProviderReleased(provider);
+        helperLifecycle.assertProviderReleased(provider);
         stopCodexAppServerWellbeing(normalizedProviderKey);
         providerSessions.managed.delete(normalizedProviderKey);
         const subscriptionPrefix = `${normalizedProviderKey}:`;
-        for (const key of [...runOwner.eventSubscriptions.keys()]) {
+        for (const key of [...observer.eventSubscriptions.keys()]) {
           if (key.startsWith(subscriptionPrefix)) {
-            runOwner.unsubscribeEventSubscription(key);
+            observer.unsubscribeEventSubscription(key);
           }
         }
       }
@@ -156,21 +160,21 @@ export function createCodexRuntimeLifecycle({
   async function drainCodexAppServerControllerTasks() {
     while (true) {
       const pending = new Set([
-        ...runOwner.conversationTurnStarts.values(),
+        ...pendingWork.conversationTurnStarts.values(),
         ...helperLifecycle.projectOperations.values(),
         ...helperLifecycle.cleanups.values(),
         ...helperLifecycle.mutations.values(),
         ...helperLifecycle.restores.values(),
         ...helperLifecycle.turnStarts.values(),
-        ...runOwner.messageDeliveries.values(),
-        ...runOwner.reasoningPersistQueues.values(),
-        ...runOwner.resultFinalizations.values(),
+        ...pendingWork.messageDeliveries.values(),
+        ...pendingWork.reasoningPersistQueues.values(),
+        ...pendingWork.resultFinalizations.values(),
         ...providerSessions.owner.lifecycleTasks,
         ...providerSessions.owner.runtimeAcquisitions,
         ...codexAppServerReconcileTasks,
         ...codexAppServerSessionClosures.values(),
-        ...runOwner.threadReconciliations.values(),
-        ...runOwner.notificationQueue.tasks.values()
+        ...pendingWork.threadReconciliations.values(),
+        ...pendingWork.notificationTasks.values()
       ]);
       if (pending.size === 0) {
         return;
@@ -194,7 +198,7 @@ export function createCodexRuntimeLifecycle({
           return;
         }
         await runInContext(current.projectContext, async () => {
-          await runOwner.checkManagedConnection(normalizedProviderKey);
+          await checkManagedConnection(normalizedProviderKey);
         });
       })()
         .catch((error) => {

package/src/server/conversation/codexSessionCleanup.js

@@ -1,22 +1,23 @@
 import { normalizeCodexRunText } from "./codexTurnState.js";
 
 // Cleanup of the existing run/provider/Helper owners. The application keeps
-// its authority and storage projections; all native coordination stays here.
-export function createCodexSessionCleanup({ namespace, runOwner, providerSessions, helperLifecycle, journal,
-  conversations, debugLog, debugError }) {
+// its authority and storage projections; all native coordination stays here:
+// one closure per session key (shared with the runtime lifecycle, which drains
+// them on shutdown) and the private record of which closures are restricted.
+export function createCodexSessionCleanup({ namespace, runOwner, providerSessions, sessionClosures, helperLifecycle,
+  journal, conversations, debugLog, debugError }) {
   const providerOwner = providerSessions?.owner;
+  const restrictedClosures = new WeakSet();
 
   async function closeSession(sessionId, cleanup) {
     const normalizedSessionId = normalizeCodexRunText(sessionId);
     const sessionKey = cleanup.sessionKey;
-    const pendingClosures = cleanup.pending;
-    const restrictedClosures = cleanup.restrictedPending;
-    let pending = pendingClosures.get(sessionKey);
+    let pending = sessionClosures.get(sessionKey);
     while (pending) {
       const pendingIsRestricted = restrictedClosures.has(pending);
       if (cleanup.restricted && !pendingIsRestricted) {
         await pending.catch(() => null);
-        pending = pendingClosures.get(sessionKey);
+        pending = sessionClosures.get(sessionKey);
         continue;
       }
       if (!cleanup.restricted && pendingIsRestricted) {
@@ -58,15 +59,15 @@ export function createCodexSessionCleanup({ namespace, runOwner, providerSession
       });
       await prepared.complete(exitFailure);
     })();
-    pendingClosures.set(sessionKey, closing);
+    sessionClosures.set(sessionKey, closing);
     if (cleanup.restricted) {
       restrictedClosures.add(closing);
     }
     try {
       return await closing;
     } finally {
-      if (pendingClosures.get(sessionKey) === closing) {
-        pendingClosures.delete(sessionKey);
+      if (sessionClosures.get(sessionKey) === closing) {
+        sessionClosures.delete(sessionKey);
       }
     }
   }

package/src/server/conversation/codexSessionReconciliation.js

@@ -1,10 +1,10 @@
 import { normalizeCodexRunText as normalizeText, codexAppServerErrorMessage as errorMessage } from "./codexTurnState.js";
-import { isPlainObject as isRecord } from "./normalize.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 
 // Original batch restoration, prune and startup unsubscribe. The run owner's
 // existing lifecycle and per-thread readiness retain all state and coordination.
 export function createCodexSessionReconciliation({
-  runOwner, providerSessions, helperLifecycle, lifecycle, createRuntime,
+  readiness, recoverSessionObservationLoss, providerSessions, helperLifecycle, lifecycle, createRuntime,
   namespace, turnState, sessionIdRequiredError, debugLog, debugError
 }) {
   async function pruneCodexAppServerManagedSessions({
@@ -72,7 +72,7 @@ export function createCodexSessionReconciliation({
     const failed = [];
     const seenSessionIds = new Set();
     for (const session of Array.isArray(sessions) ? sessions : []) {
-      const sessionId = normalizeText(session?.sessionId || session?.id || session);
+      const sessionId = codexAppServerReconcileSessionId(session);
       if (!sessionId || seenSessionIds.has(sessionId)) {
         continue;
       }
@@ -131,7 +131,7 @@ export function createCodexSessionReconciliation({
     if (prepared.result) return prepared.result;
     const { context } = prepared;
     if (turnState(context.session).status === "observation_lost") {
-      const recovered = await prepared.recover(runOwner.recoverSessionObservationLoss);
+      const recovered = await prepared.recover(recoverSessionObservationLoss);
       const turn = turnState(recovered);
       return prepared.stopped({
         ok: !turn.active,
@@ -140,7 +140,7 @@ export function createCodexSessionReconciliation({
         threadId: turn.threadId
       }, recovered);
     }
-    return runOwner.reconcileThread(normalizedSessionId, context, prepared.thread);
+    return readiness.reconcileThread(normalizedSessionId, context, prepared.thread);
   }
 
   async function reconcileCodexAppServerThreads(sessions = [], {
@@ -227,7 +227,7 @@ export function createCodexSessionReconciliation({
       }
     }
     if (reconcileGeneration === lifecycle.reconcileGeneration) {
-      await runOwner.waitForThreadReconciliations({
+      await readiness.waitForThreadReconciliations({
         keepProviderKeys,
         projectContextRoot
       });

package/src/server/conversation/codexThreadReadiness.js

@@ -7,8 +7,8 @@ import {
 import { codexAppServerThreadIsMissing, ensureCodexAppServerThread } from "./codexProvider.js";
 import { codexAppServerThreadRawValue, codexAppServerThreadTurnId } from "./codexEvents.js";
 
-// Original native readiness, loaded-thread restoration and reconciliation drain.
-// One Map retains the original run-owner lifetime and is shared with shutdown.
+// Native thread readiness, loaded-thread restoration and reconciliation drain.
+// Its one Map lives as long as the run owner and is shared with shutdown.
 export function createCodexThreadReadiness({
   providerSessions,
   selection,
@@ -23,7 +23,9 @@ export function createCodexThreadReadiness({
   const {
     ensureCodexAppServerProviderForActiveTurn,
     codexAppServerSessionObserverOptions,
-    rememberCodexAppServerPreparedThread
+    sessionConnection,
+    ensureSessionProvider,
+    rememberManagedSession
   } = selection;
   const {
     eventSubscriptionKey: codexAppServerEventSubscriptionKey,
@@ -47,10 +49,8 @@ export function createCodexThreadReadiness({
     if (!providerOptions) {
       providerOptions = await preparation.providerOptions(session);
     }
-    const provider = activeProvider?.provider || await providerSessions.owner.ensureSession(
-      providerSessions.context(normalizeCodexRunText(sessionId), providerOptions),
-      preparation.threadId(session)
-    );
+    const provider = activeProvider?.provider ||
+      await ensureSessionProvider(sessionId, providerOptions, preparation.threadId(session));
     const { currentSession: preparedSession, thread } = await preparation.gate(async currentSession => {
       const thread = await ensureCodexAppServerThread({
         ...preparation.preparation(currentSession),
@@ -63,7 +63,9 @@ export function createCodexThreadReadiness({
     });
     subscribeCodexAppServerEvents(sessionId, provider, thread.threadId,
       codexAppServerSessionObserverOptions(sessionId, providerOptions));
-    rememberCodexAppServerPreparedThread(sessionId, providerOptions, context, thread);
+    rememberManagedSession(sessionId, providerOptions, {
+      executionRoot: context.executionRoot, workdir: context.workdir, threadId: thread.threadId
+    });
     await reconcileCodexAppServerThreadStatus(sessionId, provider, thread.threadId, {
       failUnconfirmedTrackedTurn: true,
       observeLatestTurn: true,
@@ -87,14 +89,9 @@ export function createCodexThreadReadiness({
     const threadId = preparation.threadId(session);
     if (!threadId) {
       const providerOptions = await preparation.providerOptions(session);
-      const providerKey = providerSessions.context(normalizedSessionId, providerOptions).providerKey;
-      await providerSessions.owner.ensureSession(providerSessions.context(normalizedSessionId, providerOptions));
-      providerSessions.context(normalizedSessionId, providerOptions).runOwner.runtimeLifecycle.rememberManagedSession(providerKey, {
-        providerOptions,
-        sessionId: normalizedSessionId,
-        executionRoot,
-        workdir
-      });
+      const { providerKey } = sessionConnection(normalizedSessionId, providerOptions);
+      await ensureSessionProvider(normalizedSessionId, providerOptions);
+      rememberManagedSession(normalizedSessionId, providerOptions, { executionRoot, workdir });
       return {
         ok: true,
         providerKey,
@@ -105,32 +102,23 @@ export function createCodexThreadReadiness({
     }
     const activeProvider = await ensureCodexAppServerProviderForActiveTurn(session, preparation.managedIdentity);
     const providerOptions = activeProvider?.providerOptions || await preparation.providerOptions(session);
-    const providerKey = activeProvider?.providerKey || providerSessions.context(normalizedSessionId, providerOptions).providerKey;
+    const providerKey = activeProvider?.providerKey || sessionConnection(normalizedSessionId, providerOptions).providerKey;
     const existing = codexAppServerThreadReconciliations.get(providerKey);
     if (existing) {
       return existing;
     }
     const reconciliation = (async () => {
-      const provider = activeProvider?.provider || await providerSessions.owner.ensureSession(
-        providerSessions.context(normalizedSessionId, providerOptions), threadId
-      );
+      const provider = activeProvider?.provider ||
+        await ensureSessionProvider(normalizedSessionId, providerOptions, threadId);
       try {
         const restored = await restoreCodexAppServerLoadedThread(normalizedSessionId, {
           runtime, provider, providerKey, threadId,
-          subscriptionOptions: {
-            get providerKey() { return providerSessions.context(normalizeCodexRunText(normalizedSessionId), providerOptions).providerKey; }
-          },
+          subscriptionOptions: codexAppServerSessionObserverOptions(normalizedSessionId, providerOptions),
           get resumeOptions() {
             return preparation.resumeOptions;
           },
           remember() {
-            providerSessions.context(normalizedSessionId, providerOptions).runOwner.runtimeLifecycle.rememberManagedSession(providerKey, {
-              providerOptions,
-              sessionId: normalizedSessionId,
-              executionRoot,
-              threadId,
-              workdir
-            });
+            rememberManagedSession(normalizedSessionId, providerOptions, { executionRoot, threadId, workdir });
           },
           ready() { return preparation.ready(); }
         });
@@ -207,9 +195,7 @@ export function createCodexThreadReadiness({
     return maintainCodexAppServerManagedConnection(sessionId, {
       provider, providerKey: normalizedProviderKey, threadId, reconnect,
       get workdir() { return managed.workdir; },
-      subscriptionOptions: {
-        get providerKey() { return providerSessions.context(normalizeCodexRunText(sessionId), managed.providerOptions || {}).providerKey; }
-      }
+      subscriptionOptions: codexAppServerSessionObserverOptions(sessionId, managed.providerOptions || {})
     }, current);
   }
 

package/src/server/conversation/codexThreadStatus.js

@@ -11,7 +11,7 @@ import {
   codexAppServerTurnCanAdoptSuccessor,
   codexAppServerErrorMessage
 } from "./codexTurnState.js";
-import { isPlainObject } from "./normalize.js";
+import { isRecord } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   codexAppServerStatusFromValue,
   codexAppServerThreadRawValue,
@@ -19,7 +19,7 @@ import {
   codexAppServerThreadError
 } from "./codexEvents.js";
 
-// Original native snapshot reconciliation; existing owners retain all state.
+// Native thread snapshot reconciliation; it holds no state of its own.
 export function createCodexThreadStatus({ journal, settlement, recovery, output, createRuntime, turnState, turnOutcomes, debugLog, debugError }) {
   const { turnResultWasProcessed: codexAppServerTurnResultWasProcessed } = journal;
   const {
@@ -278,7 +278,7 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
     }
     if (
       codexAppServerTurnStatusIsComplete(status) &&
-      isPlainObject(thread?.observedTurn) &&
+      isRecord(thread?.observedTurn) &&
       turnId
     ) {
       const currentSession = await runtime.getSession(normalizedSessionId);