@jskit-ai/assistant-core 0.1.240 → 0.1.241

package/test/claudeConversationSession.test.js

@@ -2573,6 +2573,16 @@ async function completedReplyFixture(t, options = {}) {
     prepare: receipt => conversation.prepareCompletedResponse(receipt, { signal: controller.signal }) };
 }
 
+test("delivery inspection of a turn without runtime metadata returns its duplicate receipt", async t => {
+  const f = await completedReplyFixture(t);
+  try {
+    const plain = await f.plain("pre-runtime-turn");
+    assert.equal(plain.metadata?.runtime, undefined);
+    assert.deepEqual(await f.conversation.inspectDelivery({ messageId: "pre-runtime-turn" }),
+      { status: "accepted", messageId: "pre-runtime-turn", turnId: plain.turnId, duplicate: true });
+  } finally { await f.close(); }
+});
+
 test("completed Claude prepared reply atomically publishes one plain final across handles and restart", async t => {
   const f = await completedReplyFixture(t);
   try {
@@ -2820,7 +2830,7 @@ for (const kind of ["tool", "reply"]) test(`completed Claude ${kind} wire preser
     assert.equal(saved.assistant.text, raw);
     const prepared = await f.conversation.prepareCompletedResponse(receipt, { signal: new AbortController().signal });
     assert.equal(prepared.text, raw);
-    const { readAssistantResponseEnvelope } = await import("../src/server/lib/assistantToolLoop.js");
+    const { readAssistantResponseEnvelope } = await import("../src/server/conversation/boundedToolLoop.js");
     const decoded = readAssistantResponseEnvelope(prepared.text);
     assert.deepEqual(decoded, value);
     if (kind === "tool") assert.equal(JSON.parse(decoded.arguments).value, handover);

package/test/claudeTurn.test.js

@@ -1361,7 +1361,7 @@ test("Claude verified native cleanup retains interrupted checkpoint refusal with
 
 // Retain the original supplied-store/native process fixture and drive it through
 // the actual common runtime, including its completion-only admitted receipt.
-async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, representation = "canonical", beforeToolWrite, signal, executeTool = async () => ({}) } = {}) {
+async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, hostDeliveryStages, representation = "canonical", beforeToolWrite, signal, executeTool = async () => ({}) } = {}) {
   const f = await publishedClaudeFixture(t, { canonicalAdmission: true });
   const storage = createMemoryConversationStorage();
   const transcript = createConversationTranscript({ storage });
@@ -1390,7 +1390,7 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, repres
     native: { owner: f.owner, preparation: { cleanup: () => ({ context: f.context, application: {
       readContext: async () => f.context, terminals: { close: async () => ({ ok: true }) }
     } }) } },
-    admission() {}, prepareInput: async input => input,
+    admission() {}, prepareInput: async (input, _context, { deliveryTiming } = {}) => { deliveryTiming?.("host-prepared"); return input; },
     read: async () => ({ threadId: f.conversationId, configuration: { model: "native" },
       turn: f.owner.snapshot(f.entry), delivery }),
     readStream: async () => ({ messages: [] }),
@@ -1404,7 +1404,7 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, repres
       admissions.push(admission); return actual;
     } } } : {}) };
   const runtime = createConversationRuntime({ ...(tools ? { actions } : {}), authorize: () => true, onDeliveryTiming,
-    host: { conversation: () => binding } });
+    hostDeliveryStages, host: { conversation: () => binding } });
   t.after(() => runtime.close());
   const conversation = await runtime.open({ id: "lesson", context, representation });
   f.setBeforeState((entry, event) => {
@@ -1511,20 +1511,20 @@ for (const failedSave of [false, true]) test(`Claude goal waits for common final
 
 test("Claude delivery timing separates native acknowledgement from the held canonical receipt", { timeout: 10_000 }, async t => {
   const timings = [];
-  const f = await suppliedCommonFixture(t, { onDeliveryTiming: event => timings.push(event) });
+  const f = await suppliedCommonFixture(t, { onDeliveryTiming: event => timings.push(event), hostDeliveryStages: ["host-prepared"] });
   const writing = Promise.withResolvers();
   const release = Promise.withResolvers();
   f.behavior.beforeAdmit = async () => { writing.resolve(); await release.promise; };
   const sending = f.conversation.send({ messageId: "timed-request", text: "Private message" });
   await writing.promise;
   assert.deepEqual(timings.map(event => event.stage), [
-    "received", "preparation-started", "authorized", "history-read", "state-read", "request-saved", "input-prepared",
-    "provider-started", "duplicate-checked", "native-history-read", "process-ready", "prompt-rendered", "metadata-ready",
+    "received", "preparation-started", "authorized", "history-read", "state-read", "request-saved", "host-prepared",
+    "input-prepared", "provider-started", "duplicate-checked", "native-history-read", "process-ready", "prompt-rendered", "metadata-ready",
     "runtime-ready", "dispatch-started", "native-acknowledged"
   ]);
   release.resolve();
   assert.equal((await sending).status, "accepted");
-  const admitted = timings.map(event => event.stage).slice(16);
+  const admitted = timings.map(event => event.stage).slice(17);
   assert.deepEqual(admitted, ["receipt-written", "state-active", "receipt-persisted", "admission-authorized", "turn-located", "accepted"]);
   await f.frame({ type: "result", subtype: "success", result: "Public answer" });
   await f.conversation.wait();
@@ -2394,6 +2394,26 @@ test("bound Main history budget transfers more than 30 complete messages through
   assert.equal(sent[1], "Prepare the question.");
 });
 
+test("bound Main treats a restart-interrupted attempt with a saved receipt as delivered, not uncertain", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  // The application restarted after native admission saved the authored
+  // message, but before the dispatch returned and cleared its attempt marker.
+  const attempt = { messageId: "admitted-before-restart", message: "Check the Preview.", displayMessage: "Check the Preview.",
+    attempted: true, threadId: f.conversationId, seen: {} };
+  await f.binding.state.write({ lastEngine: "claude", engines: { claude: { seen: {}, pending: attempt } } });
+  const unconfirmed = await f.conversation.read();
+  assert.equal(unconfirmed.status, "unconfirmed", "An attempt without a saved receipt stays uncertain");
+  assert.equal(unconfirmed.pendingRequest.messageId, attempt.messageId);
+  await f.binding.transcript.writeUserMessage({ messageId: attempt.messageId, text: attempt.displayMessage });
+  f.binding.transcript.history = async () => [{ id: "000001/user/", version: "v1", role: "user", engineId: "claude",
+    messageId: attempt.messageId, text: attempt.displayMessage }];
+  const settled = await f.conversation.read();
+  assert.equal(settled.status, "ready", "The saved receipt proves delivery, so Send stays available");
+  assert.equal(settled.pendingRequest, null);
+  await sendCommon(f, "after-restart");
+  assert.equal((await f.binding.state.read()).engines.claude.pending, undefined, "The next delivery settles the old marker");
+});
+
 test("bound Main cannot dispatch or retain a pending prompt when its history budget is unavailable", { timeout: 10_000 }, async t => {
   const f = await suppliedCommonFixture(t, { tools: false, representation: "native" });
   f.binding.transcript.history = async () => [{ id: "earlier", version: "v1", role: "user", text: "Earlier work." }];

package/test/codexClient.test.js

@@ -89,3 +89,23 @@ test("transport failure preserves its error code for pending requests", async ()
   await assert.rejects(result, { code: "assistant_codex_app_server_message_too_large" });
   assert.equal(client.isOpen(), false);
 });
+
+test("outgoing messages over the limit fail with the transport-limit code", async () => {
+  const client = new CodexAppServerJsonRpcClient({ endpoint: "ws://fixture", WebSocketImpl: Socket, maxMessageBytes: 10 });
+  await client.connect();
+  assert.throws(() => client.send({ payload: "x".repeat(20) }), {
+    code: "assistant_codex_app_server_message_too_large",
+    message: "Codex app-server message exceeded the configured transport limit."
+  });
+});
+
+test("message and timeout limits accept only positive integers", () => {
+  for (const invalid of [0, -1, 1.5, "abc", Number.NaN]) {
+    const client = new CodexAppServerJsonRpcClient({ maxMessageBytes: invalid, requestTimeoutMs: invalid });
+    assert.equal(client.maxMessageBytes, Number.POSITIVE_INFINITY);
+    assert.equal(client.requestTimeoutMs, 60_000);
+  }
+  const client = new CodexAppServerJsonRpcClient({ maxMessageBytes: 512, requestTimeoutMs: 25 });
+  assert.equal(client.maxMessageBytes, 512);
+  assert.equal(client.requestTimeoutMs, 25);
+});

package/test/codexConversationSession.test.js

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { createConversationRuntime, createFileConversationStorage } from "../src/server/conversation/index.js";
-import { createCodexConversationStore } from "../src/server/conversation/agentRun.js";
+import { createCodexConversationStore } from "../src/server/conversation/codexConversationStore.js";
 import { createReentrantConversationStorage } from "../src/server/conversation/storage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";
 import { createConversationStreams } from "../src/server/conversation/streams.js";
@@ -3668,7 +3668,7 @@ for (const kind of ["tool", "reply"]) test(`completed Codex ${kind} wire preserv
     assert.equal(run.outerTurnId, receipt.messageId);
     const prepared = await f.conversation.prepareCompletedResponse(receipt, { signal: new AbortController().signal });
     assert.equal(prepared.text, raw);
-    const { readAssistantResponseEnvelope } = await import("../src/server/lib/assistantToolLoop.js");
+    const { readAssistantResponseEnvelope } = await import("../src/server/conversation/boundedToolLoop.js");
     const decoded = readAssistantResponseEnvelope(prepared.text);
     assert.deepEqual(decoded, value);
     if (kind === "tool") assert.equal(JSON.parse(decoded.arguments).value, handover);

package/test/codexConversationsCheckpoint.test.js

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createCodexConversationCommands } from "../src/server/conversation/codexConversations.js";
+
+const turnOutcomes = { USER_CANCELLED: "user_cancelled" };
+
+function persistentConversationFixture() {
+  const checkpoints = [];
+  const listeners = new Set();
+  const emit = (notification) => listeners.forEach((listener) => listener(notification));
+  const completed = (status) => emit({ method: "turn/completed", params: { threadId: "thread", turn: { id: "turn-1", status } } });
+  const provider = {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async readThreadStatus() { return {}; },
+    // Codex reports the interrupted turn while it is stopping.
+    async stopThreadForObservationLoss() { completed("interrupted"); }
+  };
+  const commands = createCodexConversationCommands({
+    async checkpoint(_sessionId, input) { checkpoints.push(input); },
+    conversationPreparation: { async context() { return { result: { provider } }; } },
+    namespace: (sessionId) => sessionId,
+    turnOutcomes
+  });
+  const state = commands.observeCodexConversation("session", "thread", provider);
+  const startTurn = () => emit({ method: "turn/started", params: { threadId: "thread", turn: { id: "turn-1", status: "inProgress" } } });
+  return { checkpoints, commands, completed, startTurn, state };
+}
+
+test("a temporary turn the person stops reaches its checkpoint as user cancelled", async () => {
+  const f = persistentConversationFixture();
+  f.startTurn();
+  await f.commands.stopCodexAppServerConversation("session", { conversationId: "thread", persistent: true });
+  assert.equal(f.checkpoints.length, 1);
+  assert.equal(f.checkpoints[0].turnOutcome, "user_cancelled");
+  assert.equal(f.checkpoints[0].status, "interrupted");
+  // The outcome belongs to the stopped turn only.
+  f.startTurn();
+  f.completed("completed");
+  assert.equal(f.checkpoints[1].turnOutcome, "");
+});
+
+test("closing temporary conversations leaves the turn outcome to its status", async () => {
+  const f = persistentConversationFixture();
+  f.startTurn();
+  await f.commands.closeCodexAppServerConversations("session");
+  assert.equal(f.checkpoints.length, 1);
+  assert.equal(f.checkpoints[0].turnOutcome, "");
+});

package/test/codexModelCatalog.test.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import { prepareCodexModelCatalog } from "../src/server/conversation/codexConfiguration.js";
-import { createCodexAppServerModelCatalogCache, codexAppServerProviderConnectionGeneration } from "../src/server/conversation/codexProvider.js";
+import { createCodexAppServerModelCatalogCache, codexAppServerProviderConnectionGeneration } from "../src/server/conversation/codexModelCatalog.js";
 import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
 
 async function fixture(t, source) {

package/test/codexProviderHome.test.js

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  codexProviderCatalogPath,
+  codexProviderFileConfiguration,
+  copyCodexProviderHome
+} from "../src/server/conversation/codexConfiguration.js";
+
+const provider = {
+  id: "fixture",
+  label: "Fixture",
+  baseUrl: "https://provider.invalid/v1",
+  webSearch: false,
+  models: [{ id: "fixture-model", defaultThinking: "medium" }]
+};
+
+async function homes(t) {
+  const root = await mkdtemp(path.join(os.tmpdir(), "codex-provider-home-"));
+  t.after(() => rm(root, { force: true, recursive: true }));
+  const sourceHome = path.join(root, "source");
+  const targetHome = path.join(root, "target");
+  await Promise.all([mkdir(sourceHome), mkdir(targetHome)]);
+  return { sourceHome, targetHome };
+}
+
+test("a copied provider home names its own catalogue", async t => {
+  const { sourceHome, targetHome } = await homes(t);
+  await writeFile(path.join(sourceHome, "config.toml"), codexProviderFileConfiguration(provider, "secret", sourceHome));
+  await writeFile(codexProviderCatalogPath(sourceHome), "{\"models\":[]}");
+
+  await copyCodexProviderHome(sourceHome, targetHome);
+
+  assert.equal(
+    await readFile(path.join(targetHome, "config.toml"), "utf8"),
+    codexProviderFileConfiguration(provider, "secret", targetHome)
+  );
+  assert.equal(await readFile(codexProviderCatalogPath(targetHome), "utf8"), "{\"models\":[]}");
+});
+
+test("a provider config that does not name its own catalogue is refused, not copied", async t => {
+  const { sourceHome, targetHome } = await homes(t);
+  const elsewhere = path.join(path.dirname(sourceHome), "elsewhere");
+  await writeFile(path.join(sourceHome, "config.toml"), codexProviderFileConfiguration(provider, "secret", elsewhere));
+  await writeFile(codexProviderCatalogPath(sourceHome), "{}");
+
+  await assert.rejects(copyCodexProviderHome(sourceHome, targetHome), /does not name its own model catalogue/);
+  await assert.rejects(readFile(path.join(targetHome, "config.toml")), { code: "ENOENT" });
+});

package/test/codexProviderSelection.test.js

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createCodexProviderSelection } from "../src/server/conversation/codexProviderSelection.js";
+
+function fixture() {
+  const calls = { contexts: [], ensured: [], remembered: [], acquired: [] };
+  const provider = {
+    ensureRuntime: () => "runtime"
+  };
+  const providerSessions = {
+    managed: new Map(),
+    owner: {
+      providers: new Map(),
+      async ensureSession(connection, threadId) {
+        calls.ensured.push({ sessionId: connection.sessionId, threadId });
+        return provider;
+      },
+      async acquireRuntime(input) {
+        calls.acquired.push(input.providerKey);
+        return input.operation();
+      }
+    },
+    context(sessionId, providerOptions) {
+      calls.contexts.push(sessionId);
+      return {
+        sessionId,
+        providerOptions,
+        providerKey: `key:${sessionId}`,
+        runOwner: {
+          runtimeLifecycle: {
+            rememberManagedSession: (providerKey, record) => calls.remembered.push({ providerKey, ...record })
+          }
+        }
+      };
+    }
+  };
+  const selection = createCodexProviderSelection({
+    providerSessions,
+    turnState: () => ({ active: false }),
+    helperLifecycle: null,
+    helperOwnershipError: null,
+    modelCatalogCacheMs: 1,
+    errorPrefix: ""
+  });
+  return { calls, selection };
+}
+
+test("session providers and managed records use the normalized session id", async () => {
+  const { calls, selection } = fixture();
+  await selection.ensureSessionProvider("  s1 ", { mode: "a" }, "thread-1");
+  selection.rememberManagedSession(" s1 ", { mode: "a" }, { executionRoot: "/root", workdir: "/work", threadId: "thread-1" });
+
+  assert.deepEqual(calls.ensured, [{ sessionId: "s1", threadId: "thread-1" }]);
+  assert.deepEqual(calls.remembered, [{
+    providerKey: "key:s1",
+    providerOptions: { mode: "a" },
+    sessionId: "s1",
+    executionRoot: "/root",
+    threadId: "thread-1",
+    workdir: "/work"
+  }]);
+  assert.equal(selection.codexAppServerSessionObserverOptions(" s1 ", {}).providerKey, "key:s1");
+});
+
+test("the visible terminal runtime acquires the provider key of the normalized session", async () => {
+  const { calls, selection } = fixture();
+  await selection.codexAppServerRuntimeForVisibleTerminal(" s1 ", {}, { workdir: "" }, {}, async () => ({}));
+  assert.deepEqual(calls.ensured, [{ sessionId: "s1", threadId: undefined }]);
+  assert.deepEqual(calls.acquired, ["key:s1"]);
+  assert.ok(calls.contexts.every(sessionId => sessionId === "s1"));
+});

package/test/codexTurn.test.js

@@ -7,8 +7,10 @@ import test from "node:test";
 import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";
 import { createConversationStreams } from "../src/server/conversation/streams.js";
-import { sendCodexAppServerPrompt, CodexAppServerAgentProvider } from "../src/server/conversation/codexProvider.js";
+import { sendCodexAppServerPrompt, CodexAppServerAgentProvider, codexAppServerDeliveredTurn } from "../src/server/conversation/codexProvider.js";
 import { createCodexHelperThreadLedgerOwner } from "../src/server/conversation/codexHelperThreadLedger.js";
+import { createCodexSessionReconciliation } from "../src/server/conversation/codexSessionReconciliation.js";
+import { createCodexSessionCleanup } from "../src/server/conversation/codexSessionCleanup.js";
 import {
   waitForCodexAppServerTurn,
   createCodexAppServerRunOwner,
@@ -432,6 +434,120 @@ test("native phase changes require the current exact turn and retain its active
   assert.equal(f.writes.length, 1);
 });
 
+test("a settling write for a predecessor turn cannot end the active successor run", async () => {
+  for (const state of ["active", "finalizing", "starting"]) {
+    const f = runFixture({ state, providerTurnId: "successor" });
+    const owner = createCodexAppServerRunOwner();
+    const successor = f.read();
+    for (const runState of [CODEX_APP_SERVER_RUN_STATE.COMPLETED, CODEX_APP_SERVER_RUN_STATE.FAILED,
+      CODEX_APP_SERVER_RUN_STATE.INTERRUPTED]) {
+      const result = await owner.writeAgentRun(f.runtime, "session-1", { runState, status: runState,
+        threadId: "thread-1", turnId: "turn-1", error: "Predecessor outcome." });
+      assert.equal(result.wrote, false);
+      assert.equal(result.stale.currentTurnId, "successor");
+      assert.equal(result.stale.patchTurnId, "turn-1");
+    }
+    assert.deepEqual(f.read(), successor);
+    assert.deepEqual(f.writes, []);
+    const settled = await owner.writeAgentRun(f.runtime, "session-1", { runState: CODEX_APP_SERVER_RUN_STATE.COMPLETED,
+      status: "completed", threadId: "thread-1", turnId: "successor" });
+    assert.equal(settled.wrote, true, "The successor's own outcome still settles it");
+  }
+});
+
+test("startup unsubscribe skips session records without an identity instead of inventing one", async () => {
+  const prepared = [];
+  const reconciliation = createCodexSessionReconciliation({
+    providerSessions: { owner: { async unsubscribeSessionThread(_key, sessionId) {
+      return { ok: true, sessionId, status: "unsubscribed" };
+    } } },
+    namespace: sessionId => `project:${sessionId}`,
+    debugLog() {}, debugError: error => error
+  });
+  const result = await reconciliation.unsubscribeSessions([{ title: "no identity" }, { id: "session-1" },
+    "session-1", { sessionId: "session-2" }], {
+    enabled: true,
+    async session(sessionId) { prepared.push(sessionId); return { threadId: `thread-${sessionId}` }; }
+  });
+  assert.deepEqual(prepared, ["session-1", "session-2"]);
+  assert.equal(JSON.stringify(result).includes("[object Object]"), false);
+});
+
+test("session cleanup owns its single-flight closures and restricted record without consumer state", async () => {
+  const sessionClosures = new Map();
+  const releases = [];
+  const held = [];
+  const cleanupOwner = createCodexSessionCleanup({
+    namespace: id => `project:${id}`,
+    runOwner: {},
+    sessionClosures,
+    providerSessions: { owner: {
+      async drainThreadEnvironmentTasks() {},
+      async releaseSession(sessionKey) {
+        const gate = Promise.withResolvers();
+        held.push(gate);
+        await gate.promise;
+        releases.push(sessionKey);
+        return { exitFailure: null };
+      }
+    } },
+    helperLifecycle: { assertRestored() {}, async restoreThreads() {}, assertRetired() {}, async retireAll() {} },
+    journal: { clearSessionRecoveryTimers() {} },
+    conversations: { async closeCodexAppServerConversations() {} },
+    debugLog() {}, debugError: error => error
+  });
+  const reads = [];
+  const publicChecks = [];
+  const cleanup = (label, restricted = false) => ({
+    sessionKey: "project:session-1",
+    restricted,
+    async assertPublicAccess() { publicChecks.push(label); },
+    async read() {
+      reads.push(label);
+      return { helpers: {}, projectRuntimeRoot: "", session: {}, async complete() {} };
+    }
+  });
+  const flush = () => new Promise(resolve => setImmediate(resolve));
+
+  const first = cleanupOwner.closeSession("session-1", cleanup("public"));
+  const joined = cleanupOwner.closeSession("session-1", cleanup("joined"));
+  assert.equal(sessionClosures.size, 1, "One closure per session key");
+  const restricted = cleanupOwner.closeSession("session-1", cleanup("restricted", true));
+  await flush();
+  held.shift().resolve();
+  await Promise.all([first, joined]);
+  await flush();
+  assert.deepEqual(reads, ["public", "restricted"], "A restricted close waits for the public one, then runs its own");
+  const publicAfterRestricted = cleanupOwner.closeSession("session-1", cleanup("late-public"));
+  await flush();
+  assert.deepEqual(publicChecks, ["late-public"], "Joining a restricted close proves public access first");
+  held.shift().resolve();
+  await Promise.all([restricted, publicAfterRestricted]);
+  assert.deepEqual(reads, ["public", "restricted"]);
+  assert.deepEqual(releases, ["project:session-1", "project:session-1"]);
+  assert.equal(sessionClosures.size, 0);
+});
+
+test("the run owner's session closures are the ones its runtime lifecycle drains", async () => {
+  const draining = Promise.withResolvers();
+  const owner = createCodexAppServerRunOwner({ providerSessions: { owner: { drainThreadEnvironmentTasks: () => draining.promise } } });
+  const closing = owner.closeSession("session-1", { sessionKey: "project:session-1",
+    async read() { throw new Error("Controlled preparation stop"); } });
+  assert.ok(owner.runtimeLifecycle.sessionClosures.get("project:session-1") instanceof Promise);
+  draining.resolve();
+  await assert.rejects(closing, /Controlled preparation stop/);
+  assert.equal(owner.runtimeLifecycle.sessionClosures.size, 0);
+});
+
+test("the run owner exposes only operations its consumers use, not facet recovery state", () => {
+  const owner = createCodexAppServerRunOwner();
+  for (const internal of ["completedTurns", "automaticHookThreads", "conversationTurnStarts", "reasoningPersistQueues",
+    "threadReconciliations", "reasoningTurns", "finalAssistantResults", "mirroredTerminalItems", "clearActiveTimer",
+    "clearFinalizingTimer", "adoptSuccessorTurn", "markTurnActive", "markTurnFinalizing", "checkManagedConnection"]) {
+    assert.equal(Object.hasOwn(owner, internal), false, internal);
+  }
+});
+
 test("original pending ownership and terminal outer identity are preserved without weakening run-state errors", () => {
   const run = { inputSource: "chat", pendingUserMessageClientIds: [0, false, " first ", "second"] };
   assert.deepEqual(codexAppServerPendingUserMessageOwnership(run, "first"), { clientId: "first", inputSource: "chat" });
@@ -978,9 +1094,9 @@ test("original settlement clears the same recovery timers and skips stale idle c
   t.after(() => timers.forEach(clearTimeout));
   owner.activeTimers.set(`project:${sessionId}`, timer());
   owner.activeTimers.set("project:other", timer());
-  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, turnId), timer());
-  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, "older"), timer());
-  owner.finalizingTimers.set(owner.resultFinalizationKey("other", threadId, turnId), timer());
+  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, turnId), { timer: timer() });
+  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, "older"), { timer: timer() });
+  owner.finalizingTimers.set(owner.resultFinalizationKey("other", threadId, turnId), { timer: timer() });
   f.run = { ...f.run, state: "interrupted", providerStatus: "interrupted" };
   const result = await owner.markTurnIdle(sessionId, { threadId, turnId, status: "completed" });
   assert.equal(result.processed, false);
@@ -2373,6 +2489,72 @@ for (const [status, cause, explicit, expected] of [
   });
 }
 
+test("a native stop outcome rereads the run after its history read and leaves an adopted successor running", async () => {
+  const notices = [];
+  const checkpoints = [];
+  const f = await receiptFixture({
+    outcomeNotice(_runtime, sessionId, threadId, turnId, outcome) { notices.push({ sessionId, threadId, turnId, outcome }); },
+    checkpoint(sessionId, value) { checkpoints.push({ sessionId, ...value }); }
+  });
+  f.history = [turn(f.turnId, "interrupted")];
+  const reading = Promise.withResolvers(); const release = Promise.withResolvers();
+  const list = f.provider.listThreadTurns;
+  f.provider.listThreadTurns = async (...args) => {
+    const snapshot = await list(...args);
+    reading.resolve(); await release.promise;
+    return snapshot;
+  };
+  try {
+    const pending = f.owner.stopTurnWithProviderFailure(f.sessionId, f.threadId, f.turnId, {
+      status: "interrupted", provider: f.provider, verifyInactive: false
+    });
+    await reading.promise;
+    f.run = { ...f.run, providerTurnId: "successor", state: "active", providerStatus: "inProgress" };
+    const successorRun = structuredClone(f.run);
+    release.resolve();
+    assert.equal((await pending).reason, "stale_turn_state");
+    assert.deepEqual(f.run, successorRun);
+    assert.deepEqual(notices, []);
+    assert.deepEqual(checkpoints, []);
+  } finally {
+    f.owner.clearSessionRecoveryTimers(f.sessionId);
+  }
+});
+
+test("a delivered native turn reads its identity, status and provider error from the one sendTurn shape", async () => {
+  const provider = new CodexAppServerAgentProvider({}, { credentials: { assertCurrent() {} } });
+  const responses = [
+    { turn: { id: "turn-failed", status: "failed", error: { message: "You've hit your usage limit." } } },
+    { turnId: "turn-flat", status: "failed", error: "Flat provider failure." },
+    { turn: { id: "turn-running", status: "inProgress" } }
+  ];
+  provider.client = { isOpen: () => true, close() {}, async request(method) {
+    assert.equal(method, "turn/start");
+    return responses.shift();
+  } };
+  try {
+    const delivered = [];
+    for (let index = 0; index < 3; index += 1) {
+      delivered.push(codexAppServerDeliveredTurn(await sendCodexAppServerPrompt({ provider, prompt: "Go", threadId: "thread-1" })));
+    }
+    assert.deepEqual(delivered, [
+      { turnId: "turn-failed", status: "failed", error: "You've hit your usage limit." },
+      { turnId: "turn-flat", status: "failed", error: "Flat provider failure." },
+      { turnId: "turn-running", status: "inProgress", error: "" }
+    ]);
+  } finally {
+    provider.close();
+  }
+});
+
+test("a host provider that returns its raw turn unnormalized still delivers its status and error", async () => {
+  const provider = { async sendTurn() {
+    return { id: "t", raw: { status: "failed", error: { message: "boom" } } };
+  } };
+  const delivered = codexAppServerDeliveredTurn(await sendCodexAppServerPrompt({ provider, prompt: "Go", threadId: "thread-1" }));
+  assert.deepEqual(delivered, { turnId: "t", status: "failed", error: "boom" });
+});
+
 test("user Stop records its exact cause before queued native completion while the interrupt reply is held", async () => {
   const notices = [];
   const f = await receiptFixture({ outcomeNotice(_runtime, sessionId, threadId, turnId, outcome) {
@@ -2595,7 +2777,7 @@ for (const change of ["concurrent", "cleanup", "successor"]) {
     t.mock.timers.tick(20);
     await reading.promise;
     assert.equal(owner.finalizingTimers.size, 1, "Firing does not discard the first post-read clock");
-    const expiry = [...owner.finalizingTimers.values()][0].finalizingRecovery;
+    const expiry = [...owner.finalizingTimers.values()][0].recovery;
     assert.ok(expiry instanceof Promise);
     let pending;
     if (change === "concurrent") pending = owner.completeTurn(sessionId, threadId, turnId, { verifyInactive: false });
@@ -2612,6 +2794,40 @@ for (const change of ["concurrent", "cleanup", "successor"]) {
   });
 }
 
+test("native delivery failure rereads the run after its last history read and cannot settle an adopted successor", async t => {
+  t.mock.timers.enable({ apis: ["Date"], now: Date.parse("2026-10-07T00:00:00Z") });
+  const f = await settlementFixture();
+  const { sessionId, threadId, turnId } = f;
+  const owner = createCodexAppServerRunOwner({ finalizingGraceMs: 500,
+    createRuntime: async () => ({ store: f.store, getSession: async () => ({ sessionId, agentRuns: [structuredClone(f.run)] }) }),
+    createStore: async () => f.store, acquireProvider: async () => f.provider,
+    checkpoint: async (id, input) => { f.checkpoints.push({ sessionId: id, ...input }); }
+  });
+  t.after(() => owner.clearSessionRecoveryTimers(sessionId));
+  f.run = { ...f.run, state: "finalizing", providerStatus: "completed", finishedAt: new Date().toISOString() };
+  f.history = [turn(turnId, "completed")];
+  t.mock.timers.tick(501);
+  const reading = Promise.withResolvers(); const release = Promise.withResolvers();
+  const list = f.provider.listThreadTurns;
+  let reads = 0;
+  f.provider.listThreadTurns = async (...args) => {
+    const snapshot = await list(...args);
+    reads += 1;
+    if (reads === 2) { reading.resolve(); await release.promise; }
+    return snapshot;
+  };
+  const pending = owner.completeTurn(sessionId, threadId, turnId, { verifyInactive: false });
+  await reading.promise;
+  f.run = { ...f.run, providerTurnId: "successor", state: "active", providerStatus: "inProgress" };
+  const successorRun = structuredClone(f.run);
+  release.resolve();
+  const result = await pending;
+  assert.equal(result.reason, "stale_turn_state");
+  assert.deepEqual(f.run, successorRun, "The predecessor's delivery failure cannot settle the successor");
+  assert.deepEqual(f.checkpoints, []);
+  assert.deepEqual(await f.replies(), []);
+});
+
 
 test("native after-history grace retries a rejected expiry read without granting another interval", async t => {
   t.mock.timers.enable({ apis: ["Date"], now: Date.parse("2026-10-07T00:00:00Z") });
@@ -2643,7 +2859,7 @@ test("native after-history grace retries a rejected expiry read without granting
   t.mock.timers.tick(20);
   await failedRead.promise;
   const timer = [...owner.finalizingTimers.values()][0];
-  const expiry = timer.finalizingRecovery;
+  const expiry = timer.recovery;
   const rejected = assert.rejects(expiry, /Controlled transient session read failure/);
   release.resolve();
   await rejected;

package/test/conversationAgentRun.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { conversationAgentRunEvent, conversationAgentRunRecord, createCodexConversationRunStore, createCodexConversationStore } from "../src/server/conversation/agentRun.js";
+import { conversationAgentRunEvent, conversationAgentRunRecord } from "../src/server/conversation/agentRun.js";
+import { createCodexConversationRunStore, createCodexConversationStore } from "../src/server/conversation/codexConversationStore.js";
 import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
 import { createReentrantConversationStorage } from "../src/server/conversation/storage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";