@jskit-ai/assistant-core 0.1.204 → 0.1.206

package/test/claudeTurn.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
 import { createClaudeConversationTurn, claudeNativeMessageId, runClaudeRenewalTurn,
   waitForClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
 
@@ -80,6 +81,13 @@ test("lost acknowledgement stays uncertain and stop rejects pending admission",
   assert.equal(turn.read().text, "");
 });
 
+test("storage failure rejects admission and a slow acknowledged write is not a native timeout", async () => {
+  const { turn, send } = fixture();
+  await send("slow", { timeoutMs: 5, accept: async () => delay(15) });
+  await assert.rejects(send("failed", { accept: async () => { throw new Error("Storage offline"); } }), /Storage offline/);
+  turn.stop();
+});
+
 test("native session identity and helper output bounds are enforced without truncating answers", async () => {
   const { turn, send } = fixture();
   await assert.rejects(turn.receive({ type: "user", session_id: "another-session" }), /different conversation id/);
@@ -92,6 +100,16 @@ test("native session identity and helper output bounds are enforced without trun
   turn.stop();
 });
 
+test("a native error result is failure information rather than an assistant answer", async () => {
+  const { turn, send, events } = fixture();
+  await send();
+  await turn.receive({ type: "result", subtype: "error_during_execution", is_error: true, result: "The model connection failed." });
+  assert.equal(turn.read().status, "failed");
+  assert.equal(turn.read().error, "The model connection failed.");
+  assert.equal(turn.read().text, "");
+  assert.equal(events.some(event => event.type === "message"), false);
+});
+
 function renewalFixture() {
   const input = { clientMessageId: "renewal-operation", prompt: "Approved prompt", timeoutMs: 100 };
   const uuid = claudeNativeMessageId(input.clientMessageId);

package/test/codexConversationSession.test.js

@@ -2126,3 +2126,321 @@ test("Codex goal controls reject local attachments before native work", async t
   assert.equal((await f.conversation.read()).conversationLog.length, 0);
   await assert.rejects(readFile(path.join(f.directory, "trace.jsonl")), { code: "ENOENT" });
 });
+
+
+for (const change of ["model", "effort"]) test(`Codex honors a consumer's fresh native policy for ${change} changes without retiring its shared peer`, async t => {
+  const f = await fixture(t);
+  const binding = (id = "conversation") => f.storage.read(id, async tx => (await tx.readMetadata()).runtime.binding);
+  const peer = await f.first.open({ id: "peer", configuration });
+  await peer.send({ messageId: "peer-first", text: "Peer history" });
+  await peer.wait();
+  const peerBinding = await binding("peer");
+  await f.conversation.send(input);
+  const original = await f.conversation.wait();
+  const previous = await binding();
+  const beforeSelection = await f.trace();
+  const oldHistory = JSON.parse(await readFile(path.join(f.directory, "history.json"), "utf8")).threads.find(thread => thread.id === previous.threadId);
+  const selected = { ...configuration, [change]: change === "model" ? "another-model" : "low" };
+  const request = { operationId: `fresh-${change}`, expectedSegmentId: original.segmentId,
+    engine: "codex", configuration: selected, retireNative: true };
+  const receipt = await f.conversation.select(request);
+  assert.notEqual(receipt.segmentId, original.segmentId);
+  const inert = await binding();
+  assert.equal(inert.threadId, "");
+  assert.equal(inert.configRoot, previous.configRoot);
+  assert.equal(inert.workdir, previous.workdir);
+  const predecessor = await f.storage.read("conversation", async tx => (await tx.readMetadata()).runtime.predecessors.find(segment => segment.segmentId === original.segmentId));
+  assert.equal(predecessor.binding.threadId, previous.threadId);
+  const selectedTrace = await f.trace();
+  assert.deepEqual(selectedTrace.filter(row => row.args || ["thread/start", "turn/start"].includes(row.method)),
+    beforeSelection.filter(row => row.args || ["thread/start", "turn/start"].includes(row.method)),
+    "Selecting inspects readiness without creating a thread, process or inference");
+  const retained = await f.conversation.read();
+  assert.equal(retained.id, original.id);
+  assert.deepEqual(retained.conversationLog, original.conversationLog);
+  assert.equal((await f.conversation.select(request)).duplicate, true);
+  await f.conversation.send({ messageId: "changed", text: "Continue after the change" });
+  assert.equal((await f.conversation.wait()).conversationLog.at(-1).metadata.runtime.status, "complete");
+  const fresh = await binding();
+  assert.ok(fresh.threadId);
+  assert.notEqual(fresh.threadId, previous.threadId);
+  assert.equal(fresh.accountIdentity, previous.accountIdentity);
+  assert.deepEqual(JSON.parse(await readFile(path.join(f.directory, "history.json"), "utf8")).threads.find(thread => thread.id === previous.threadId), oldHistory);
+  let trace = await f.trace();
+  assert.equal(trace.filter(row => row.args).length, 1, "A peer retains the original shared account service");
+  assert.equal(trace.filter(row => row.method === "thread/start").length, 3);
+  const calls = trace.filter(row => row.method === "turn/start");
+  assert.equal(calls.length, 3);
+  assert.equal(calls[2].params.threadId, fresh.threadId);
+  assert.equal(calls[2].params.model, selected.model);
+  assert.equal(calls[2].params.effort, selected.effort);
+  const handedHistory = JSON.parse(calls[2].params.input[0].text.split("\n").find(line => line.startsWith('{"messages":')));
+  assert.deepEqual(handedHistory.messages.map(({ role, text }) => [role, text]), [["user", "Hello"], ["assistant", "Answer: Hello"]]);
+  assert.deepEqual(handedHistory.removedMessageIds, []);
+  assert.equal(calls[2].params.input[0].text.split("User's message:\n")[1], "Continue after the change");
+  assert.match(calls[2].params.input[0].text, /Hello/);
+  assert.match(calls[2].params.input[0].text, /Answer: Hello/);
+  assert.match(calls[2].params.input[0].text, /Continue after the change/);
+  assert.doesNotMatch(calls[2].params.input[0].text, /Peer history/);
+  await peer.send({ messageId: "peer-next", text: "Peer continues" });
+  assert.equal((await peer.wait()).conversationLog.length, 2);
+  assert.equal((await binding("peer")).threadId, peerBinding.threadId);
+  trace = await f.trace();
+  assert.equal(trace.filter(row => row.args).length, 1);
+  assert.equal(trace.filter(row => row.method === "turn/start").at(-1).params.input[0].text, "Peer continues");
+  await f.first.close();
+  const resumed = await f.runtime().open({ id: "conversation" });
+  assert.equal((await resumed.select(request)).duplicate, true);
+  assert.equal((await resumed.send(input)).duplicate, true);
+  assert.equal((await binding()).threadId, fresh.threadId);
+  await resumed.send({ messageId: "after-restart", text: "Continue after restart" });
+  assert.equal((await resumed.wait()).conversationLog.length, 3);
+  trace = await f.trace();
+  assert.equal(trace.filter(row => row.args).length, 2);
+  assert.equal(trace.filter(row => row.method === "thread/start").length, 3);
+  assert.equal(trace.filter(row => row.method === "thread/resume").at(-1).params.threadId, fresh.threadId);
+  assert.equal(trace.filter(row => row.method === "turn/start").at(-1).params.input[0].text, "Continue after restart");
+  const returned = await resumed.select({ operationId: `restore-${change}`, expectedSegmentId: (await resumed.read()).segmentId,
+    engine: "codex", configuration, retireNative: true });
+  assert.notEqual(returned.segmentId, original.segmentId, "The consumer policy cannot restore an older retained segment");
+  assert.notEqual(returned.segmentId, receipt.segmentId);
+  await resumed.send({ messageId: "returned", text: "Back to the original settings" });
+  assert.equal((await resumed.wait()).conversationLog.length, 4);
+  const restored = await binding();
+  assert.notEqual(restored.threadId, previous.threadId);
+  assert.notEqual(restored.threadId, fresh.threadId);
+  assert.equal(restored.accountIdentity, previous.accountIdentity);
+  const restoredPrompt = (await f.trace()).filter(row => row.method === "turn/start").at(-1).params.input[0].text;
+  assert.match(restoredPrompt, /Hello/);
+  assert.match(restoredPrompt, /Continue after the change/);
+  assert.match(restoredPrompt, /Continue after restart/);
+});
+
+test("held lifecycle catalogue work does not block another owner's runtime stop or acquisition", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-"));
+  const first = createCodexAppServerProviderOwner({ runtimeRoot: path.join(root, "a") });
+  const other = createCodexAppServerProviderOwner({ runtimeRoot: path.join(root, "b") });
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  const firstOptions = { runtimeDir: path.join(root, "a", "runtime") };
+  const stopOptions = { runtimeDir: path.join(root, "b", "stop") };
+  const acquireOptions = { runtimeDir: path.join(root, "b", "acquire") };
+  t.after(async () => {
+    for (const owner of [first, other]) await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const firstProvider = first.createProvider({ providerKey: "a", providerOptions: firstOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: firstOptions.runtimeDir }; },
+    async listModels() { entered.resolve(); await release.promise; events.push("a-catalogue-finished"); return { data: [] }; },
+    async stopRuntime() { events.push("a-stop"); return { stopped: true }; },
+    close() {}
+  }) });
+  await first.acquireRuntime({ providerKey: "a", providerOptions: firstOptions, provider: firstProvider, operation: async () => {} });
+  other.createProvider({ providerKey: "b-stop", providerOptions: stopOptions, create: () => ({
+    async stopRuntime() { events.push("b-stop"); return { stopped: true }; }, close() {}
+  }) });
+  const acquiredProvider = other.createProvider({ providerKey: "b-acquire", providerOptions: acquireOptions, create: () => ({
+    async ensureRuntime() { events.push("b-acquire"); return {}; },
+    async stopRuntime() { return { stopped: true }; }, close() {}
+  }) });
+  const catalogue = first.readModelCatalog({ prepareProviderOptions: async () => firstOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } });
+  await entered.promise;
+  const stopping = other.stopCachedProvider("b-stop", { requireStopped: true });
+  const acquiring = other.ensureSession({ sessionId: "b", providerKey: "b-acquire", providerOptions: acquireOptions,
+    assertAdmission() {} });
+  let deadline;
+  try {
+    const [stopped, acquired] = await Promise.race([
+      Promise.all([stopping, acquiring]),
+      new Promise((_, reject) => { deadline = setTimeout(() => reject(new Error("An unrelated runtime waited for the held catalogue.")), 2000); })
+    ]);
+    assert.equal(stopped.stopped, true);
+    assert.equal(acquired, acquiredProvider);
+    assert.deepEqual(events, ["b-stop", "b-acquire"]);
+    assert.equal(first.providers.get("a"), firstProvider);
+  } finally {
+    clearTimeout(deadline);
+    release.resolve();
+    await Promise.allSettled([catalogue, stopping, acquiring]);
+  }
+});
+
+test("held lifecycle catalogue work preserves same-runtime peer ordering and the final participant stop", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-peer-"));
+  const first = createCodexAppServerProviderOwner({ runtimeRoot: root });
+  const peer = createCodexAppServerProviderOwner({ runtimeRoot: root });
+  const providerOptions = { runtimeDir: path.join(root, "runtime") };
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  t.after(async () => {
+    for (const owner of [first, peer]) await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const provider = first.createProvider({ providerKey: "first", providerOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: providerOptions.runtimeDir }; },
+    async listModels() { entered.resolve(); await release.promise; events.push("catalogue"); return { data: [] }; },
+    async stopRuntime() { events.push("first-stop"); return { stopped: true }; }, close() {}
+  }) });
+  await first.acquireRuntime({ providerKey: "first", providerOptions, provider, operation: async () => {} });
+  peer.createProvider({ providerKey: "peer", providerOptions, create: () => ({
+    async stopRuntime() { events.push("peer-stop"); return { stopped: true }; },
+    close() { events.push("peer-close"); }
+  }) });
+  const catalogue = first.readModelCatalog({ prepareProviderOptions: async () => providerOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } });
+  await entered.promise;
+  let finished = false;
+  const stopping = peer.stopCachedProvider("peer", { requireStopped: true }).then(value => { finished = true; return value; });
+  try {
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(finished, false);
+    assert.deepEqual(events, []);
+  } finally {
+    release.resolve();
+    await catalogue;
+  }
+  const stopped = await stopping;
+  assert.equal(stopped.sharedProcessRetained, true);
+  assert.equal(stopped.stopped, false);
+  assert.equal(first.providers.get("first"), provider);
+  assert.equal(peer.providers.get("peer"), undefined);
+  assert.deepEqual(events, ["catalogue", "peer-close"]);
+  assert.equal((await first.stopCachedProvider("first", { requireStopped: true })).stopped, true);
+  assert.deepEqual(events, ["catalogue", "peer-close", "first-stop"]);
+});
+
+test("held lifecycle catalogue work preserves one owner's FIFO across different runtimes", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-fifo-"));
+  const owner = createCodexAppServerProviderOwner({ runtimeRoot: root });
+  const providerOptions = { runtimeDir: path.join(root, "catalogue") };
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  t.after(async () => {
+    await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const provider = owner.createProvider({ providerKey: "catalogue", providerOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: providerOptions.runtimeDir }; },
+    async listModels() { entered.resolve(); await release.promise; events.push("catalogue"); return { data: [] }; },
+    async stopRuntime() { return { stopped: true }; }, close() {}
+  }) });
+  await owner.acquireRuntime({ providerKey: "catalogue", providerOptions, provider, operation: async () => {} });
+  owner.createProvider({ providerKey: "other", providerOptions: { runtimeDir: path.join(root, "other") }, create: () => ({
+    async stopRuntime() { events.push("other-stop"); return { stopped: true }; }, close() {}
+  }) });
+  const catalogue = owner.readModelCatalog({ prepareProviderOptions: async () => providerOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } });
+  await entered.promise;
+  let finished = false;
+  const stopping = owner.stopCachedProvider("other", { requireStopped: true }).then(value => { finished = true; return value; });
+  try {
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(finished, false);
+    assert.deepEqual(events, []);
+  } finally {
+    release.resolve();
+    await catalogue;
+  }
+  assert.equal((await stopping).stopped, true);
+  assert.deepEqual(events, ["catalogue", "other-stop"]);
+});
+
+test("held lifecycle catalogue preparation remains tracked through shutdown before its runtime key is known", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-shutdown-"));
+  let closing = false;
+  const owner = createCodexAppServerProviderOwner({ runtimeRoot: root,
+    assertOpen() { if (closing) throw new Error("The application is shutting down."); } });
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const events = [];
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const catalogue = owner.readModelCatalog({
+    async prepareProviderOptions() { entered.resolve(); await release.promise; return { runtimeDir: path.join(root, "runtime") }; },
+    providerFactory() {
+      return {
+        async currentRuntimeInfo() { return {}; },
+        async ensureRuntime() { events.push("acquire"); return { reused: false }; },
+        async listModels() { events.push("catalogue"); return { data: [] }; },
+        close() { events.push("close"); }
+      };
+    }
+  });
+  await entered.promise;
+  assert.equal(owner.lifecycleTasks.size, 1);
+  closing = true;
+  owner.beginShutdown();
+  let drained = false;
+  const draining = Promise.allSettled([...owner.lifecycleTasks]).then(() => { drained = true; });
+  try {
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(drained, false);
+    assert.deepEqual(events, []);
+  } finally {
+    release.resolve();
+  }
+  await assert.rejects(catalogue, /application is shutting down/);
+  await draining;
+  assert.equal(drained, true);
+  assert.equal(owner.lifecycleTasks.size, 0);
+  assert.deepEqual(events, ["close"]);
+});
+
+test("held lifecycle catalogue rejection preserves a newer same-runtime tail and later owner work", async t => {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-lifecycle-rejection-"));
+  const owners = [0, 1, 2].map(() => createCodexAppServerProviderOwner({ runtimeRoot: root }));
+  const providerOptions = { runtimeDir: path.join(root, "runtime") };
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const nextEntered = Promise.withResolvers();
+  const nextRelease = Promise.withResolvers();
+  const failure = new Error("Catalogue unavailable.");
+  const catalogue = { data: [{ id: "model" }] };
+  let calls = 0;
+  t.after(async () => {
+    for (const owner of owners) await owner.invalidateRuntimes({ includeOwned: true, stopOwnedRuntimes: true });
+    await rm(root, { recursive: true, force: true });
+  });
+  const provider = owners[0].createProvider({ providerKey: "catalogue", providerOptions, create: () => ({
+    async currentRuntimeInfo() { return { runtimeDir: providerOptions.runtimeDir }; },
+    async listModels() {
+      calls += 1;
+      if (calls === 1) { entered.resolve(); await release.promise; throw failure; }
+      if (calls === 2) { nextEntered.resolve(); await nextRelease.promise; }
+      return catalogue;
+    },
+    async stopRuntime() { return { stopped: true }; }, close() {}
+  }) });
+  await owners[0].acquireRuntime({ providerKey: "catalogue", providerOptions, provider, operation: async () => {} });
+  const options = { prepareProviderOptions: async () => providerOptions,
+    providerFactory() { throw new Error("The existing provider must be reused."); } };
+  const failed = assert.rejects(owners[0].readModelCatalog(options), error => error === failure);
+  await entered.promise;
+  const next = owners[1].readModelCatalog(options);
+  let last;
+  try {
+    release.resolve();
+    await failed;
+    await nextEntered.promise;
+    let finished = false;
+    last = owners[2].readModelCatalog(options).then(value => { finished = true; return value; });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.equal(finished, false);
+    assert.equal(calls, 2, "The rejected task cannot remove the newer runtime tail.");
+    nextRelease.resolve();
+    assert.equal(await next, catalogue);
+    assert.equal(await last, catalogue);
+    assert.equal(calls, 3);
+    assert.equal(await owners[0].readModelCatalog(options), catalogue);
+    assert.equal(calls, 4, "The original owner's queue also continues after rejection.");
+    await Promise.all(owners.flatMap(owner => [...owner.lifecycleTasks]));
+    assert.deepEqual(owners.map(owner => owner.lifecycleTasks.size), [0, 0, 0]);
+  } finally {
+    release.resolve();
+    nextRelease.resolve();
+    await Promise.allSettled([failed, next, last]);
+  }
+});

package/test/codexTurn.test.js

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 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 } from "../src/server/conversation/codexProvider.js";
+import { sendCodexAppServerPrompt, CodexAppServerAgentProvider } from "../src/server/conversation/codexProvider.js";
+import { createCodexHelperThreadLedgerOwner } from "../src/server/conversation/codexHelperThreadLedger.js";
 import {
   waitForCodexAppServerTurn,
   createCodexAppServerRunOwner,
@@ -60,6 +63,119 @@ function fixture(turns = []) {
   return { provider, listeners, operations };
 }
 
+// Joining fixture for the original detached coordinator. Native observation is
+// the same provider/watcher fixture above; the host only prepares its policy.
+async function detachedFixture(t, { refused = false, unavailable = null, contextError = null, dispatchError = null } = {}) {
+  const f = fixture([turn("turn-1", "completed", "Original detached answer.")]);
+  const stateRoot = await mkdtemp(join(tmpdir(), "codex-detached-"));
+  t.after(() => rm(stateRoot, { recursive: true, force: true }));
+  const runtime = { stateRoot };
+  const session = { sessionId: "session-1" };
+  const threadSettings = { model: "selected-model", cwd: "/authorized/workdir" };
+  const turnSettings = { model: "selected-model", effort: "high", cwd: "/authorized/workdir" };
+  f.events = [];
+  f.releases = 0;
+  Object.assign(f.provider, {
+    async resumeThread(id, settings) {
+      assert.equal(id, "thread-1");
+      assert.equal(settings, threadSettings);
+      f.operations.push("resume");
+      return { id };
+    },
+    async startThread(settings) {
+      assert.deepEqual(settings, { ...threadSettings, ephemeral: true });
+      f.operations.push("create");
+      return { response: { thread: { id: "thread-1" } } };
+    },
+    async sendTurn(id, input, settings) {
+      assert.equal(id, "thread-1");
+      assert.deepEqual(input, ["Original prompt"]);
+      assert.deepEqual(settings, turnSettings);
+      f.operations.push("dispatch");
+      if (dispatchError) throw dispatchError;
+      return turn("turn-1", "completed");
+    }
+  });
+  const conversationPreparation = {
+    detached(id) {
+      assert.equal(id, "session-1");
+      f.operations.push("admission");
+      return {
+        admission: refused ? { ok: false, code: "original_closing" } : { ok: true, release() { f.releases++; f.operations.push("release"); } },
+        get result() { f.operations.push("input"); return unavailable; },
+        get prompt() { return "Original prompt"; },
+        execution(context) {
+          assert.equal(context.provider, f.provider);
+          return { threadPreparation: { settings: () => threadSettings }, authorized: { turnSettings },
+            failure(error, status) { assert.equal(status, ""); return error; } };
+        }
+      };
+    },
+    context(id, input, options) {
+      f.operations.push("context");
+      assert.equal(id, "session-1");
+      assert.equal(options, f.options);
+      if (contextError) throw contextError;
+      return { context: { session }, helperTurn: false, projectRuntimeRoot: stateRoot, providerOptions: {},
+        project: provider => ({ provider, runtime, session, workdir: "/authorized/workdir", ok: true }) };
+    },
+    admissionError() { return null; },
+    failure(error) { return { ok: false, error: error.message, code: error.code }; }
+  };
+  f.options = { runtime, session, onEvent(event) {
+    f.events.push(event);
+    f.operations.push(`event:${event.type}`);
+    return f.onEvent?.(event);
+  } };
+  f.owner = createCodexAppServerRunOwner({ conversationPreparation,
+    helperThreads: { ledgerOwner: createCodexHelperThreadLedgerOwner({ executionProfile: value => structuredClone(value) }) },
+    providerSessions: { owner: { providers: new Map(), ensureSession: async () => f.provider }, context: () => ({}) }
+  });
+  return f;
+}
+
+test("original detached run coordinator joins ordinary create/resume, events and native completion without awaiting observers", async t => {
+  for (const resume of [false, true]) await t.test(resume ? "resume" : "create", { timeout: 2_000 }, async t => {
+    const f = await detachedFixture(t);
+    const neverAwaited = Promise.withResolvers();
+    f.onEvent = () => neverAwaited.promise;
+    const result = await f.owner.runDetachedConversation("session-1", {
+      prompt: "Original prompt", ...(resume ? { codexSessionId: "thread-1" } : { ephemeral: true })
+    }, f.options);
+    assert.deepEqual(result, { ok: true, text: "Original detached answer.", threadId: "thread-1", turnId: "turn-1" });
+    assert.deepEqual(f.events, [
+      { type: "thread", threadId: "thread-1" },
+      { type: "turn", status: "completed", threadId: "thread-1", turnId: "turn-1" },
+      { type: "completed", status: "completed", text: "Original detached answer.", threadId: "thread-1", turnId: "turn-1" }
+    ]);
+    assert.deepEqual(f.operations, ["admission", "input", "context", resume ? "resume" : "create",
+      "event:thread", "subscribe", "dispatch", "event:turn", "read", "unsubscribe", "event:completed", "release"]);
+    assert.equal(f.releases, 1);
+    assert.equal(f.listeners.size, 0);
+    assert.equal(f.owner.conversations.size, 0, "Detached execution does not retain a Main/scoped conversation.");
+  });
+});
+
+test("original detached admission/result boundary releases every early or dispatched failure", async t => {
+  const failure = Object.assign(new Error("Original native failure"), { code: "original_native_failure" });
+  for (const scenario of ["refused", "disabled", "empty", "context", "thread-event", "dispatch"]) await t.test(scenario, async t => {
+    const unavailable = scenario === "disabled" ? { ok: false, code: "original_disabled" }
+      : scenario === "empty" ? { ok: false, code: "original_empty" } : null;
+    const f = await detachedFixture(t, { refused: scenario === "refused", unavailable,
+      contextError: scenario === "context" ? failure : null, dispatchError: scenario === "dispatch" ? failure : null });
+    if (scenario === "thread-event") f.onEvent = () => { throw failure; };
+    const result = await f.owner.runDetachedConversation("session-1", { prompt: "Original prompt", ephemeral: true }, f.options);
+    assert.deepEqual(result, scenario === "refused" ? { ok: false, code: "original_closing" }
+      : unavailable || { ok: false, error: failure.message, code: failure.code });
+    assert.equal(f.releases, scenario === "refused" ? 0 : 1);
+    assert.equal(f.listeners.size, 0);
+    assert.equal(f.owner.conversations.size, 0);
+    if (["refused", "disabled", "empty"].includes(scenario)) assert.equal(f.operations.includes("context"), false);
+    if (scenario !== "dispatch") assert.equal(f.operations.includes("dispatch"), false);
+    if (scenario === "dispatch") assert.equal(f.operations.includes("unsubscribe"), true);
+  });
+});
+
 test("an already completed exact turn returns its saved answer without subscribing or rereading", async () => {
   const f = fixture();
   const result = await waitForCodexAppServerTurn(f.provider, " thread-1 ", turn("turn-1", "completed", "Approved handover."));
@@ -2156,3 +2272,88 @@ test("original live observation completion preserves a changed main run and read
     assert.equal(f.publications.some(event => event.reason === "codex-observation-stopped"), false);
   }
 });
+
+for (const [status, cause, explicit, expected] of [
+  ["interrupted", "", "", "interrupted"],
+  ["interrupted", "control_reconfiguration", "", "control_reconfiguration"],
+  ["interrupted", "user_cancelled", "", "user_cancelled"],
+  ["failed", "control_reconfiguration", "", "provider_failure"],
+  ["interrupted", "control_reconfiguration", "service_restart", "service_restart"]
+]) {
+  test(`native ${status} preserves ${expected} outcome without inferring its cause`, 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 }); }
+    });
+    const provider = new CodexAppServerAgentProvider({}, { credentials: { assertCurrent() {} } });
+    provider.client = { isOpen: () => true, close() {}, async request(method, input) {
+      assert.equal(method, "turn/interrupt");
+      assert.deepEqual(input, { threadId: f.threadId, turnId: f.turnId });
+      assert.equal(provider.interruptionOutcome(f.threadId, f.turnId), cause, "Cause precedes the actual native request");
+      return {};
+    } };
+    try {
+      if (cause) await provider.interruptTurn(f.threadId, f.turnId, { outcome: cause });
+      f.provider.interruptionOutcome = provider.interruptionOutcome.bind(provider);
+      assert.equal(provider.interruptionOutcome("another-thread", f.turnId), "");
+      assert.equal(provider.interruptionOutcome(f.threadId, "another-turn"), "");
+      const result = await f.owner.stopTurnWithProviderFailure(f.sessionId, f.threadId, f.turnId, {
+        status, provider: f.provider, verifyInactive: false, ...(explicit ? { outcome: explicit } : {})
+      });
+      assert.equal(result.status, status);
+      if (expected === "control_reconfiguration") assert.match(result.error, /while its controls were restored/u);
+      if (status === "interrupted") assert.doesNotMatch(result.error, /provider failed|app-server failed/u);
+      assert.deepEqual(notices, [{ sessionId: f.sessionId, threadId: f.threadId, turnId: f.turnId, outcome: expected }]);
+      assert.deepEqual(checkpoints, [{ sessionId: f.sessionId, status, turnOutcome: expected, threadId: f.threadId, turnId: f.turnId }]);
+      assert.equal(f.run.providerStatus, status);
+      assert.equal(f.run.providerThreadId, f.threadId);
+      assert.equal(f.run.providerTurnId, f.turnId);
+    } finally {
+      provider.close();
+      assert.equal(provider.interruptionOutcome(f.threadId, f.turnId), "");
+      f.owner.clearSessionRecoveryTimers(f.sessionId);
+    }
+  });
+}
+
+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) {
+    notices.push({ sessionId, threadId, turnId, outcome });
+  } });
+  const issued = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const provider = new CodexAppServerAgentProvider({}, { credentials: { assertCurrent() {} } });
+  provider.client = { isOpen: () => true, close() {}, async request(method, input) {
+    assert.equal(method, "turn/interrupt");
+    assert.deepEqual(input, { threadId: f.threadId, turnId: f.turnId });
+    assert.equal(provider.interruptionOutcome(f.threadId, f.turnId), "user_cancelled");
+    f.run.providerStatus = "interrupted";
+    f.emit({ method: "turn/completed", params: { threadId: f.threadId, turn: { id: f.turnId, status: "interrupted" } } });
+    issued.resolve();
+    await release.promise;
+    return {};
+  } };
+  f.provider.interruptTurn = provider.interruptTurn.bind(provider);
+  f.provider.interruptionOutcome = provider.interruptionOutcome.bind(provider);
+  f.observe();
+  const stopped = f.owner.interruptTurn(f.sessionId, {}, controlContext(f));
+  stopped.catch(() => {});
+  try {
+    await issued.promise;
+    await f.drain();
+    assert.deepEqual(notices, [{ sessionId: f.sessionId, threadId: f.threadId, turnId: f.turnId, outcome: "user_cancelled" }],
+      "The queued completion cannot write a provider-failure or unknown-interruption notice first");
+    assert.equal(f.run.state, "interrupted");
+    assert.equal(f.run.providerThreadId, f.threadId);
+    assert.equal(f.run.providerTurnId, f.turnId);
+  } finally {
+    release.resolve();
+    await stopped;
+    provider.close();
+    f.owner.clearSessionRecoveryTimers(f.sessionId);
+  }
+  assert.equal(notices.length, 1);
+});

package/test/conversationConfiguration.test.js

@@ -172,3 +172,30 @@ test("file-backed pending replacement keeps its admitted configuration across a
   assert.deepEqual((await resumed.read()).configuration, { systemPrompt: "Replacement instructions.", integrationId: "assistant" });
   assert.equal((await resumed.replace(input)).duplicate, true);
 });
+
+
+test("file-backed OpenCode selections keep compatible bindings and reserve a fresh provider binding without inference", async t => {
+  const f = await fixture(t, { file: true });
+  const first = f.runtime();
+  const conversation = await first.open({ id: "open-code", engine: "opencode",
+    configuration: { systemPrompt: "Keep the discussion.", integrationId: "included" } });
+  const initial = await conversation.read();
+  const old = await f.storage.read("open-code", tx => tx.readMetadata());
+  await conversation.select({ operationId: "effort-only", expectedSegmentId: initial.segmentId,
+    engine: "opencode", configuration: { ...initial.configuration, effort: "low" } });
+  assert.deepEqual((await f.storage.read("open-code", tx => tx.readMetadata())).runtime.binding, old.runtime.binding);
+  const selection = { operationId: "connect-flash", expectedSegmentId: initial.segmentId,
+    engine: "opencode", configuration: { ...initial.configuration, integrationId: "flash", effort: "low" } };
+  const selected = await conversation.select(selection);
+  assert.notEqual(selected.segmentId, initial.segmentId);
+  const saved = await f.storage.read("open-code", tx => tx.readMetadata());
+  assert.notEqual(saved.runtime.binding.directory, old.runtime.binding.directory);
+  assert.equal(saved.runtime.binding.sessionId, "");
+  assert.deepEqual(saved.runtime.predecessors.at(-1).binding, old.runtime.binding);
+  await first.close();
+  const reopened = await f.runtime().open({ id: "open-code" });
+  assert.equal((await reopened.select(selection)).duplicate, true);
+  assert.deepEqual(await f.storage.read("open-code", tx => tx.readMetadata()), saved);
+  await assert.rejects(reopened.select({ ...selection, configuration: { ...selection.configuration, integrationId: "different" } }),
+    { code: "conversation_replacement_conflict" });
+});