@jskit-ai/assistant-core 0.2.1 → 0.2.3

package/test/claudeTurn.test.js

@@ -579,6 +579,16 @@ test("a native error result is failure information rather than an assistant answ
   assert.equal(events.some(event => event.type === "message"), false);
 });
 
+test("a turn whose account signed out ends at once with the not-connected message", async () => {
+  const { turn, send } = fixture();
+  await send();
+  // Claude Code's own answer when its credentials were removed under it.
+  await turn.receive({ type: "result", subtype: "success", is_error: true, result: "Not logged in · Please run /login" });
+  assert.equal(turn.read().active, false);
+  assert.equal(turn.read().status, "failed");
+  assert.equal(turn.read().error, "Claude isn't connected. Sign in to Claude, then send your message again.");
+});
+
 function renewalFixture() {
   const input = { clientMessageId: "renewal-operation", prompt: "Approved prompt", timeoutMs: 100 };
   const uuid = claudeNativeMessageId(input.clientMessageId);
@@ -894,6 +904,24 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
     async reopen() { entry = await owner.open(context, { mainId: conversationId }); return entry; } };
 }
 
+test("Claude proves a prompt was not admitted only once no process can still record it", async t => {
+  const f = await publishedClaudeFixture(t);
+  const { inspectPersistentConversationAdmission } = await import("../src/server/conversation/providers/scoped.js");
+  // Temporary chats inspect the same proof through their native read.
+  const persistent = () => inspectPersistentConversationAdmission({ sessionId: "session", context: {},
+    record: { providerConversationId: f.conversationId }, input: { messageId: "held" }, inputFor: (_record, input) => input,
+    operations: { readConversation: (_sessionId, input) => f.owner.read(f.entry, input) } });
+  await f.send("held");
+  // The live process received the prompt but has not recorded it yet.
+  assert.equal((await f.owner.inspectAdmission(f.entry, { messageId: "held" })).admission, "unknown");
+  assert.equal((await f.owner.read(f.entry, { messageId: "held" })).notAdmitted, false);
+  assert.equal((await persistent()).admission, "unknown");
+  await f.owner.stopConversation(f.entry, "Stopped.");
+  assert.equal((await f.owner.inspectAdmission(f.entry, { messageId: "held" })).admission, "not-admitted");
+  assert.equal((await f.owner.read(f.entry, { messageId: "held" })).notAdmitted, true);
+  assert.equal((await persistent()).admission, "not-admitted");
+});
+
 test("Claude status retains active instructions and applies changed guidance once idle", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();
@@ -908,15 +936,50 @@ test("Claude status retains active instructions and applies changed guidance onc
   assert.equal(f.processes.length, 2, "Idle readiness installs the changed instructions");
 });
 
-test("Claude active status still rejects account replacement", async t => {
+test("Claude active status keeps a running turn across an account change; idle admission applies it", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();
+  const running = f.entry.process;
   f.behavior.account = "account-b";
+  const state = await f.owner.ensureReady(f.entry);
+  assert.equal(state.turn.active, true);
+  assert.equal(f.entry.process, running, "the running turn keeps its process");
+  await f.frame({ type: "result", subtype: "success", result: "Done" });
+  // Once idle, the existing account guard applies.
   await assert.rejects(f.owner.ensureReady(f.entry), { code: "claude_account_changed" });
   assert.equal(f.entry.process, null);
 });
 
-test("Claude account change stops running processes without reopening saved conversations", async t => {
+test("Claude account change stops and waits on nothing; a running turn keeps its process", async t => {
+  const f = await publishedClaudeFixture(t);
+  f.context.sessionId = "session-a";
+  await f.send();
+  const running = f.entry.process;
+  const touched = [];
+  const application = {
+    readContext: async () => { touched.push("read-context"); throw new Error("A saved conversation was reopened"); },
+    terminals: { close: async sessionId => { touched.push(`close-terminals:${sessionId}`); return { ok: true, closed: 0 }; } }
+  };
+  // Cancelled account reads are still settling; the change must not wait for them.
+  const reads = Promise.withResolvers();
+  let invalidated = 0;
+  let returned = false;
+  const change = f.owner.invalidateRuntimes({ provider: "claude", reason: "claude-auth-change" }, application,
+    { queries: { invalidate: () => { invalidated++; return reads.promise; } }, failure: error => { throw error; } });
+  void change.then(() => { returned = true; });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(returned, true, "the change returned without waiting for the cancelled account reads");
+  reads.resolve();
+  assert.deepEqual(await change, { ok: true, closed: 0 });
+  assert.equal(invalidated, 1, "the account's cached reads were dropped");
+  assert.deepEqual(touched, [], "no terminal closed and no saved conversation reopened");
+  assert.equal(f.entry.process, running, "the running process was not stopped");
+  assert.equal(f.entry.turn.active, true, "the running turn continues");
+  await f.frame({ type: "result", subtype: "success", result: "Done" });
+  assert.equal(f.entry.turn.state, "completed", "the turn finishes normally");
+});
+
+test("Claude server shutdown stops running processes without reopening saved conversations", async t => {
   const f = await publishedClaudeFixture(t);
   f.context.sessionId = "session-a";
   await f.send();
@@ -926,7 +989,7 @@ test("Claude account change stops running processes without reopening saved conv
     readContext: async () => { throw new Error("A saved conversation was reopened"); },
     terminals: { close: async sessionId => { closedTerminals.push(sessionId); return { ok: true, closed: 0 }; } }
   };
-  const result = await f.owner.invalidateRuntimes({ provider: "claude", reason: "claude-auth-change" }, application,
+  const result = await f.owner.invalidateRuntimes({ reason: "server-shutdown" }, application,
     { queries: { invalidate: async () => {} }, failure: error => { throw error; } });
   assert.equal(result.ok, true);
   assert.equal(f.entry.process, null, "the running process stopped");
@@ -1853,6 +1916,97 @@ test("consecutive steers queue together without waiting for or sending an interr
   assert.deepEqual(events.filter(event => event.type === "diagnostic" && event.stage === "steering_queued").length, 2);
 });
 
+// Claude Code reads a queued message only when the running tool call returns. A
+// foreground wait (`until …; do sleep 20; done`) held a person's question for ten
+// minutes, so a waiting steer moves foreground work to the background instead.
+function steeringFixture() {
+  const f = fixture();
+  const requests = [];
+  f.client.interrupt = async () => assert.fail("Steering never interrupts");
+  f.client.request = async request => { requests.push(request); return {}; };
+  // Claude Code acknowledges streamed input as queued; the replay comes when it reads it.
+  f.client.send = async (_message, { messageId }) => {
+    await f.turn.receive({ type: "command_lifecycle", command_uuid: messageId, state: "queued" });
+  };
+  async function read(id) {
+    const uuid = claudeNativeMessageId(id);
+    await f.turn.receive({ type: "command_lifecycle", command_uuid: uuid, state: "started" });
+    await f.turn.receive({ type: "user", uuid });
+  }
+  return { ...f, requests, read };
+}
+
+test("a steer queued behind a running command asks Claude to background it, never to interrupt it", async () => {
+  const { turn, send, read, requests, events } = steeringFixture();
+  await send();
+  await read("first");
+  await turn.receive({ type: "assistant", uuid: "wait-call", message: { id: "wait-api", stop_reason: "tool_use",
+    content: [{ type: "tool_use", id: "wait", name: "Bash", input: { command: "until grep -q done out; do sleep 20; done" } }] } });
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "wait-task" });
+  assert.deepEqual(requests, [], "A first message and its commands stay in the foreground");
+  await turn.prepareSteering();
+  await send("question", { steer: true });
+  await delay(0);
+  assert.deepEqual(requests, [{ subtype: "background_tasks" }]);
+  assert.equal(events.filter(event => event.type === "diagnostic" && event.stage === "steering_backgrounded").length, 1);
+  await turn.receive({ type: "user", uuid: "wait-result", message: { content: [{ type: "tool_result", tool_use_id: "wait",
+    content: "Command was manually backgrounded by user with ID: wait-task." }] } });
+  await read("question");
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "later-task" });
+  await delay(0);
+  assert.equal(requests.length, 1, "A message Claude has read no longer moves work");
+  turn.stop();
+});
+
+test("a steer still waiting when Claude starts another command backgrounds that command too", async () => {
+  const { turn, send, read, requests } = steeringFixture();
+  await send();
+  await read("first");
+  // The person writes while Claude is choosing its next tool: nothing runs yet.
+  await turn.prepareSteering();
+  await send("question", { steer: true });
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "new-wait" });
+  await delay(0);
+  assert.deepEqual(requests, [{ subtype: "background_tasks" }, { subtype: "background_tasks" }]);
+  await read("question");
+  turn.stop();
+});
+
+test("a steer during Claude's follow-up to a finished background task moves that follow-up's command", async () => {
+  const { turn, send, read, requests } = steeringFixture();
+  await send();
+  await read("first");
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "verify" });
+  await turn.receive({ type: "result", subtype: "success", result: "Verification runs in the background." });
+  await turn.receive({ type: "command_lifecycle", command_uuid: claudeNativeMessageId("first"), state: "completed" });
+  assert.deepEqual([turn.read().phase, turn.read().pendingCommands], ["background", 0]);
+  // Claude reads the task notification and starts waiting in the foreground.
+  await turn.receive({ type: "system", subtype: "task_notification", task_id: "verify", status: "completed" });
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "follow-up-wait" });
+  assert.deepEqual(requests, []);
+  await turn.prepareSteering();
+  await send("question", { steer: true });
+  await delay(0);
+  assert.deepEqual(requests, [{ subtype: "background_tasks" }]);
+  await read("question");
+  turn.stop();
+});
+
+test("a refused background request leaves the steer delivered and reports it", async () => {
+  const { turn, send, read, requests, client, events } = steeringFixture();
+  await send();
+  await read("first");
+  client.request = async request => { requests.push(request); throw new Error("Unsupported control request: background_tasks"); };
+  await turn.prepareSteering();
+  await send("question", { steer: true });
+  await delay(0);
+  assert.deepEqual(requests, [{ subtype: "background_tasks" }]);
+  assert.equal(turn.read().pendingCommands, 2, "The steer stays delivered and queued for Claude");
+  const failed = events.find(event => event.type === "diagnostic" && event.stage === "steering_background_failed");
+  assert.equal(failed?.error, "Unsupported control request: background_tasks");
+  turn.stop();
+});
+
 test("folded internal command preserves the original published answer owner", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();
@@ -2287,6 +2441,41 @@ for (const action of ["steer", "set", "resume"]) test(`Claude ${action} queues a
   assert.equal(f.entry.nativeTurn.read().active, false, "The main response settles the completed worker's turn");
 });
 
+for (const action of ["steer", "set", "resume"]) test(`Claude ${action} moves a running command to the background so Claude reads it at once`, async t => {
+  const f = await publishedClaudeFixture(t);
+  if (action === "resume") await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish checks", messageId: "first" });
+  else await f.send("first");
+  await f.frame({ type: "assistant", uuid: "wait-call", message: { id: "wait-api", stop_reason: "tool_use",
+    content: [{ type: "tool_use", id: "wait", name: "Bash", input: { command: "until grep -q done out; do sleep 20; done" } }] } });
+  const native = f.entry.process;
+  const requests = [];
+  native.client.request = async request => { requests.push(request); return {}; };
+  native.client.interrupt = async () => assert.fail("A steer must not send Stop");
+  const send = native.client.send;
+  const queued = Promise.withResolvers();
+  // Claude Code 2.1.308 acknowledges the input as queued while the wait loop runs.
+  native.client.send = async (message, input) => {
+    await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
+    queued.resolve({ message, input });
+  };
+  const goal = action === "steer" ? null : (await f.owner.readGoal(f.entry)).goal;
+  const delivering = action === "steer" ? f.send("next") : f.owner.updateGoal(f.entry, { action, objective: "Finish checks",
+    messageId: "next", ...(action === "resume" ? { threadId: f.conversationId, createdAt: goal.createdAt } : {}) });
+  const { message, input } = await queued.promise;
+  await delay(0);
+  assert.deepEqual(requests, [{ subtype: "background_tasks" }]);
+  assert.equal(f.processes.length, 1, "The running process and its command are kept");
+  // The wait loop returns as backgrounded; Claude then reads the queued input.
+  await f.frame({ type: "user", uuid: "wait-result", message: { content: [{ type: "tool_result", tool_use_id: "wait",
+    content: "Command was manually backgrounded by user with ID: wait-task." }] } });
+  await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "started" });
+  await send(message, input);
+  await delivering;
+  await f.frame({ type: "system", subtype: "task_started", task_id: "wait-task" });
+  await delay(0);
+  assert.equal(requests.length, 1, "Once Claude reads the input, later commands stay in the foreground");
+});
+
 test("Claude context inspection reuses the native owner and reports the selected model's current usage", async t => {
   const f = await publishedClaudeFixture(t);
   const requests = [];

package/test/codexAccountChange.test.js

@@ -0,0 +1,261 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { mkdir, mkdtemp, rm, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { CodexAppServerAgentProvider, ensureCodexAppServerThread } from "../src/server/conversation/codexProvider.js";
+import { writeCodexAppServerMetadata } from "../src/server/conversation/codexProcess.js";
+import { createCodexAppServerProviderOwner, codexAppServerOwnedRuntimeKey, releaseSupersededCodexRuntime } from "../src/server/conversation/codexProviderOwner.js";
+import { createCodexProviderSelection } from "../src/server/conversation/codexProviderSelection.js";
+import { createCodexRuntimeLifecycle } from "../src/server/conversation/codexRuntimeLifecycle.js";
+
+// A native runtime whose loaded threads report the given status. Codex reads
+// its credentials once, so the account change must leave a running turn alone.
+function nativeRuntime({ threads, goals = {} }) {
+  const requests = [];
+  const provider = {
+    stale: false,
+    stopped: 0,
+    closed: 0,
+    client: {
+      isOpen: () => true,
+      async request(method, params) {
+        requests.push(method === "thread/goal/set" ? `${method}:${params.status}` : method);
+        if (method === "thread/loaded/list") return { data: Object.keys(threads) };
+        if (method === "thread/read") return { thread: { id: params.threadId, status: { type: threads[params.threadId] } } };
+        if (method === "thread/goal/get") return { goal: goals[params.threadId] || null };
+        if (method === "thread/goal/set") {
+          goals[params.threadId] = { ...goals[params.threadId], status: params.status };
+          return { goal: goals[params.threadId] };
+        }
+        throw new Error(`Unexpected ${method}`);
+      }
+    },
+    markStale() { this.stale = true; },
+    stopOptions: [],
+    async stopRuntime(options) { this.stopped += 1; this.stopOptions.push(options); return { stopped: true, processExitVerified: true }; },
+    close() { this.closed += 1; }
+  };
+  return { provider, requests, threads, goals };
+}
+
+function ownerWith(t, runtimes, options = {}) {
+  const root = path.join(os.tmpdir(), `jskit-codex-account-change-${randomUUID()}`);
+  const owner = createCodexAppServerProviderOwner({ runtimeRoot: root, ...options });
+  const keys = {};
+  for (const [name, runtime] of Object.entries(runtimes)) {
+    const providerOptions = { runtimeDir: path.join(root, name) };
+    owner.createProvider({ providerKey: name, providerOptions, preserveProcessExitProof: true, create: () => runtime.provider });
+    owner.rememberOwnedRuntime({ provider: runtime.provider, providerKey: name, providerOptions });
+    keys[name] = codexAppServerOwnedRuntimeKey(name, providerOptions);
+  }
+  t.after(() => owner.beginShutdown());
+  return { owner, keys, root };
+}
+
+test("an account change stops an idle Codex runtime at once and leaves a running turn on its runtime", async t => {
+  const idle = nativeRuntime({ threads: { "idle-thread": "idle" } });
+  const busy = nativeRuntime({ threads: { "busy-thread": "active" }, goals: { "busy-thread": { status: "active" } } });
+  const { owner, keys } = ownerWith(t, { idle, busy });
+
+  const result = await owner.invalidateRuntimes({
+    deferBusy: true, includeOwned: true, requireVerifiedExit: true, stopOwnedRuntimes: true
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(idle.provider.stopped, 1, "An idle runtime stops at once");
+  assert.equal(busy.provider.stopped, 0, "A running turn is never stopped by an account change");
+  assert.equal(busy.provider.stale, true);
+  assert.deepEqual(result.deferred.map(({ runtimeKey, threadIds, pausedGoals }) => ({ runtimeKey, threadIds, pausedGoals })),
+    [{ runtimeKey: keys.busy, threadIds: ["busy-thread"], pausedGoals: ["busy-thread"] }]);
+  assert.ok(busy.requests.includes("thread/goal/set:paused"), "An active goal is paused so the old runtime starts no further turn");
+  assert.equal(owner.providers.get("busy"), busy.provider);
+
+  assert.equal((await owner.retireStaleRuntime(keys.busy)).busy, true, "It keeps running while its turn runs");
+  assert.equal(busy.provider.stopped, 0);
+
+  busy.threads["busy-thread"] = "idle";
+  const retired = await owner.retireStaleRuntime(keys.busy);
+  assert.equal(retired.stopped, true);
+  assert.equal(busy.provider.stopped, 1, "The stale runtime stops through the verified stop once idle");
+  assert.equal(owner.providers.get("busy"), undefined);
+  assert.equal(await owner.retireStaleRuntime(keys.busy), null);
+});
+
+test("a session's next Codex runtime starts only after its finished stale runtime stopped", async t => {
+  const old = nativeRuntime({ threads: { "thread-1": "active" } });
+  const current = { client: null, close() {} };
+  const { owner, root } = ownerWith(t, { old }, { providerFactory: () => current });
+  await owner.invalidateRuntimes({ deferBusy: true, includeOwned: true, requireVerifiedExit: true, stopOwnedRuntimes: true });
+  assert.equal(old.provider.stale, true);
+  old.threads["thread-1"] = "idle";
+
+  const provider = await owner.providerForSession({
+    providerKey: "current",
+    providerOptions: { runtimeDir: path.join(root, "current") },
+    assertAdmission() {},
+    keyFields: () => ({ sessionId: "s1", executionMode: "", executionRoot: "/work", runtimeInstanceId: "", workdir: "/work" }),
+    prepare: async () => ({ parameters: {}, runInContext: operation => operation(), controls: { available: false, subscribe: () => () => {} } })
+  });
+
+  assert.equal(provider, current);
+  assert.equal(old.provider.stopped, 1, "The previous account's runtime stops before the thread loads in the new one");
+  assert.equal(owner.providers.get("old"), undefined);
+});
+
+test("a stale Codex runtime is retired after its turn completes and its paused goal continues", async () => {
+  const subscribers = new Set();
+  const provider = { subscribe(callback) { subscribers.add(callback); return () => subscribers.delete(callback); } };
+  const stale = { runtimeKey: "runtime:/old", providerKeys: ["old-key"], threadIds: ["thread-1"], pausedGoals: ["thread-1"] };
+  const calls = [];
+  let busy = true;
+  const notificationTask = Promise.withResolvers();
+  const lifecycle = createCodexRuntimeLifecycle({
+    pendingWork: { notificationTasks: new Map([["turn", notificationTask.promise]]), resultFinalizations: new Map() },
+    observer: { eventSubscriptions: new Map() },
+    providerSessions: {
+      managed: new Map([["old-key", { sessionId: "session-1", threadId: "thread-1", projectContext: "project-a" }]]),
+      owner: {
+        providers: new Map([["old-key", provider]]),
+        async invalidateRuntimes(input) {
+          calls.push(`invalidate:${input.deferBusy}`);
+          return { deferred: [stale], failed: [], providerCount: 1, results: [], stopped: 0 };
+        },
+        async retireStaleRuntime(runtimeKey) {
+          calls.push(`retire:${runtimeKey}:${busy ? "busy" : "idle"}`);
+          return busy ? { ...stale, busy: true } : { ...stale, stopped: true };
+        }
+      }
+    },
+    helperLifecycle: {},
+    captureContext: () => null,
+    runInContext: (context, operation) => { calls.push(`context:${context}`); return operation(); },
+    continueGoalAfterAccountChange: async (sessionId, { threadId }) => calls.push(`continue:${sessionId}:${threadId}`),
+    debugLog() {},
+    debugError: error => error
+  });
+
+  await lifecycle.invalidateRuntimes({ includeOwned: true, reason: "codex-connected" }, { enabled: true });
+  assert.deepEqual(calls, ["invalidate:true"], "The account change returns without waiting for the running turn");
+
+  busy = false;
+  notificationTask.resolve();
+  for (const callback of subscribers) callback({ method: "turn/completed", params: { threadId: "thread-1" } });
+  await new Promise(resolve => setTimeout(resolve, 20));
+  assert.deepEqual(calls.slice(-3), ["retire:runtime:/old:idle", "context:project-a", "continue:session-1:thread-1"]);
+  assert.equal(subscribers.size, 0, "A retired runtime leaves no observer behind");
+});
+
+test("a stale Codex provider keeps its runtime and the current account through an auth generation change", async t => {
+  const stops = [];
+  const marked = [];
+  const provider = new CodexAppServerAgentProvider({ runtimeDir: "/tmp/old" }, {
+    credentials: {
+      async assertCurrent() { throw Object.assign(new Error("Codex authentication changed."), { code: "auth_generation_changed" }); },
+      async markInvalid(input) { marked.push(input); },
+      reconnectError: () => new Error("reconnect")
+    },
+    runtime: {
+      async ensure() { throw new Error("A stale provider must not restart its runtime"); },
+      async stop() { stops.push("stop"); return { processExitVerified: true }; }
+    },
+    parameters: {}
+  });
+  t.after(() => provider.close());
+  provider.runtime = { runtimeDir: "/tmp/old", authStateSignature: "v1:old" };
+  let rejected = false;
+  provider.client = { isOpen: () => true, close() {}, async request() {
+    if (rejected) throw new Error("unexpected status 401 Unauthorized: Incorrect API key provided");
+    return { turn: { id: "turn-1" } };
+  } };
+  provider.markStale();
+
+  assert.equal((await provider.steerTurn("thread-1", "turn-1", "more")).id, "turn-1");
+  assert.deepEqual(stops, [], "A steer on the running turn keeps its runtime after the account changed");
+  rejected = true;
+  await assert.rejects(provider.steerTurn("thread-1", "turn-1", "more"), /401/u);
+  assert.deepEqual(stops, [], "The running turn's runtime is not stopped");
+  assert.deepEqual(marked, [], "The previous account's rejection never marks the current account");
+
+  provider.client = null;
+  await assert.rejects(provider.ensureAvailable(), error => error.code === "codex_account_changed");
+  assert.deepEqual(stops, []);
+});
+
+test("a stale Codex provider serves its running turn and not the session's next message", async () => {
+  const stale = { stale: true, isAvailable: () => true };
+  const ensured = [];
+  let active = true;
+  const selection = createCodexProviderSelection({
+    providerSessions: {
+      managed: new Map([["old-key", { sessionId: "s1", threadId: "thread-1", workdir: "/work", providerOptions: { old: true } }]]),
+      keyFields: () => ({ sessionId: "s1", executionRoot: "/work", workdir: "/work" }),
+      owner: {
+        providers: new Map([["old-key", stale]]),
+        async ensureSession(connection) { ensured.push(connection.providerOptions); return stale; }
+      },
+      context: (sessionId, providerOptions) => ({ sessionId, providerOptions, providerKey: "old-key" })
+    },
+    turnState: () => ({ active, threadId: "thread-1" }),
+    helperLifecycle: null,
+    helperOwnershipError: null,
+    modelCatalogCacheMs: 1,
+    errorPrefix: ""
+  });
+  const session = { sessionId: "s1" };
+
+  assert.equal((await selection.ensureCodexAppServerProviderForActiveTurn(session, { workdir: "/work" }))?.provider, stale);
+  assert.equal(selection.managedProviderKeyForThread("s1", "/work", "thread-1", { turnActive: true }), "old-key");
+  active = false;
+  const context = selection.codexAppServerMessageContext("s1", {
+    managedIdentity: () => ({ workdir: "/work" }),
+    providerOptions: async () => ({ current: true })
+  });
+  assert.equal((await context.acquireProvider(session)).reused, false, "A new message goes to the current account's provider");
+  assert.deepEqual(ensured.at(-1), { current: true });
+  assert.equal(selection.managedProviderKeyForThread("s1", "/work", "thread-1"), null);
+});
+
+async function runtimeDirectory(root, name, processState) {
+  const runtimeDir = path.join(root, `codex-app-server-${name}`);
+  await mkdir(runtimeDir, { recursive: true });
+  await writeCodexAppServerMetadata(runtimeDir, {
+    runtimeDir, processState, pid: 4242,
+    ...(processState === "stopped" ? { processExitVerifiedAt: new Date().toISOString() } : {})
+  });
+  return runtimeDir;
+}
+const exists = target => stat(target).then(() => true, () => false);
+
+test("recording a session's runtime for a new sign-in removes the previous sign-in's stopped runtime directory", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "jskit-codex-superseded-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const stopped = await runtimeDirectory(root, "stopped", "stopped");
+  const running = await runtimeDirectory(root, "running", "running");
+  const bind = superseded => ensureCodexAppServerThread({
+    observeThread: async () => {},
+    provider: { ensureRuntime: async () => ({ runtimeDir: path.join(root, "codex-app-server-current") }),
+      startThread: async () => ({ id: "thread-1" }) },
+    settings: async () => ({ threadSettings: {}, threadStartSettings: {} }),
+    identity: { read: () => "", write: async () => ({ supersededRuntimeDir: superseded }) },
+    workdir: "/work"
+  });
+
+  await bind(running);
+  assert.equal(await exists(running), true, "A runtime that has not verifiably stopped keeps its directory");
+  await bind(stopped);
+  assert.equal(await exists(stopped), false, "The previous sign-in's stopped runtime directory goes");
+});
+
+test("a stale Codex runtime its session no longer records keeps no exit proof when it stops", async t => {
+  const busy = nativeRuntime({ threads: { "thread-1": "active" } });
+  const { owner, keys, root } = ownerWith(t, { busy });
+  await owner.invalidateRuntimes({ deferBusy: true, includeOwned: true, requireVerifiedExit: true, stopOwnedRuntimes: true });
+
+  assert.deepEqual(await releaseSupersededCodexRuntime(path.join(root, "busy")), { deferred: true, removed: false });
+  busy.threads["thread-1"] = "idle";
+  assert.equal((await owner.retireStaleRuntime(keys.busy)).stopped, true);
+  assert.deepEqual(busy.provider.stopOptions, [{ preserveProcessExitProof: false }],
+    "Its verified stop removes the directory instead of keeping the proof");
+});

package/test/codexConversationsCheckpoint.test.js

@@ -22,6 +22,9 @@ function persistentConversationFixture() {
     async checkpoint(_sessionId, input) { checkpoints.push(input); },
     conversationPreparation: { async context() { return { result: { provider } }; } },
     namespace: (sessionId) => sessionId,
+    // The provider owner still holds the provider observing the conversation;
+    // a running turn holds it through the owner.
+    providerSessions: { owner: { providers: new Map([["provider", provider]]), holdProvider: () => () => {} } },
     turnOutcomes
   });
   const state = commands.observeCodexConversation("session", "thread", provider);

package/test/codexEvents.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { codexAppServerProviderThreadAssistantSegments } from "../src/server/conversation/codexEvents.js";
+import { codexAppServerNotificationError, codexAppServerProviderThreadAssistantSegments, codexAppServerProviderTurnError } from "../src/server/conversation/codexEvents.js";
 
 test("phase-less Codex progress before tools does not become a final answer", () => {
   const items = [
@@ -38,3 +38,25 @@ test("explicit Codex finals remain independent across goal continuation and hook
     { itemId: "answer-2", text: "Second result." }
   ]);
 });
+
+// A running app-server keeps the credentials it started with (Codex 0.163,
+// local mock): once they are rejected after a sign-out or account switch, its
+// turns end with these native errors, which say nothing about reconnecting.
+test("a Codex turn whose OpenAI sign-in is gone asks the person to sign in again", () => {
+  const signedOut = "Codex (OpenAI) isn't connected. Sign in to Codex, then send your message again.";
+  for (const message of [
+    "Your access token could not be refreshed because you have since logged out or signed in to another account. Please sign in again.",
+    "unexpected status 401 Unauthorized: Incorrect API key provided, url: https://api.openai.com/v1/responses",
+    "unexpected status 401 Unauthorized: unauthorized, url: https://chatgpt.com/backend-api/codex/responses"
+  ]) {
+    assert.equal(codexAppServerNotificationError({ method: "error", params: { error: { message } } }), signedOut);
+    assert.equal(codexAppServerNotificationError({ method: "turn/completed",
+      params: { turn: { status: "failed", error: { message } } } }), signedOut);
+    assert.equal(codexAppServerProviderTurnError({ status: "failed", error: { message } }), signedOut);
+  }
+  // Another provider's rejected key and other failures keep their own text.
+  for (const message of ["unexpected status 401 Unauthorized: invalid key, url: https://api.deepseek.com/v1/responses",
+    "stream disconnected before completion: stream closed before response.completed"]) {
+    assert.equal(codexAppServerNotificationError({ method: "error", params: { error: { message } } }), message);
+  }
+});

package/test/codexHomeStorage.test.js

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import {
+  codexDisabledProcessFeatureArguments,
+  codexHomeDisposablePaths
+} from "../src/server/hosts/codexConfiguration.js";
+
+async function home(t, entries) {
+  const root = await mkdtemp(path.join(tmpdir(), "jskit-codex-home-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const codexHome = path.join(root, ".codex");
+  for (const entry of entries) {
+    const target = path.join(codexHome, entry);
+    if (entry.endsWith("/")) await mkdir(target, { recursive: true });
+    else { await mkdir(path.dirname(target), { recursive: true }); await writeFile(target, "x"); }
+  }
+  return { root, codexHome };
+}
+
+const kept = ["auth.json", "config.toml", "models.json", "state_5.sqlite", "goals_1.sqlite", "memories_1.sqlite",
+  "queue_1.sqlite", "thread_history_1.sqlite", "sessions/2026/10/rollout.jsonl", "plugins/cache/installed/",
+  ".tmp/marketplaces/", ".tmp/rollout-maintenance.lock", "cache/unrelated/"];
+const pluginAndApp = [".tmp/plugins/", ".tmp/plugins.sha", ".tmp/plugins.sync.lock", ".tmp/plugins-clone-a1/",
+  ".tmp/plugins-backup-b2/", ".tmp/git-c3/", ".tmp/bundled-marketplaces/", "cache/remote_plugin_catalog/",
+  "cache/codex_apps_tools/", "cache/codex_apps_server_info/", "cache/codex_app_directory/", "cache/bundled_plugin_exclusions/"];
+
+test("Codex processes are launched with plugin and app background work and the shared background server off", () => {
+  assert.deepEqual(codexDisabledProcessFeatureArguments(), ["-c", "features.plugins=false", "-c", "features.apps=false",
+    "-c", "features.daemon_auto_start=false"]);
+});
+
+test("a used home loses only plugin and app caches; a retired home also loses its runtime-only data", async (t) => {
+  const { codexHome } = await home(t, [...kept, ...pluginAndApp, "logs_2.sqlite", "logs_2.sqlite-wal", "logs_2.sqlite-shm", "tmp/arg0/"]);
+  const strip = (entry) => path.join(codexHome, entry.replace(/\/$/u, ""));
+  assert.deepEqual(await codexHomeDisposablePaths(codexHome), pluginAndApp.map(strip).sort());
+  assert.deepEqual(await codexHomeDisposablePaths(codexHome, { retired: true }),
+    [".tmp", "cache", "logs_2.sqlite", "logs_2.sqlite-shm", "logs_2.sqlite-wal", "tmp"].map(strip).sort());
+});
+
+test("missing, linked and relative homes list nothing they do not own", async (t) => {
+  const { root, codexHome } = await home(t, ["cache/remote_plugin_catalog/"]);
+  assert.deepEqual(await codexHomeDisposablePaths(path.join(root, "missing")), []);
+  const linked = path.join(root, "linked");
+  await symlink(codexHome, linked);
+  assert.deepEqual(await codexHomeDisposablePaths(linked), []);
+  assert.deepEqual(await codexHomeDisposablePaths(linked, { retired: true }), []);
+  const elsewhere = path.join(root, "elsewhere");
+  await mkdir(path.join(elsewhere, ".tmp/plugins"), { recursive: true });
+  await rm(path.join(codexHome, "cache"), { recursive: true });
+  await symlink(path.join(elsewhere, ".tmp"), path.join(codexHome, ".tmp"));
+  assert.deepEqual(await codexHomeDisposablePaths(codexHome), [], "a linked .tmp is not followed");
+  assert.deepEqual(await codexHomeDisposablePaths(codexHome, { retired: true }), [path.join(codexHome, ".tmp")]);
+  await assert.rejects(codexHomeDisposablePaths(".codex"), /absolute Codex home/u);
+});

package/test/codexInteractiveArguments.test.js

@@ -18,6 +18,15 @@ test("remote Codex resume keeps server-owned permissions and the selected native
   ]);
 });
 
+test("a local Codex terminal starts with plugin and app background work off and leaves no background server; a remote one uses its server's", () => {
+  const local = codexInteractiveArguments({ ...options, threadId: "local-thread" });
+  // The terminal's Codex would otherwise start a shared app-server daemon that outlives it.
+  assert.deepEqual(local.slice(0, 9), ["codex", "-c", "check_for_update_on_startup=false",
+    "-c", "features.plugins=false", "-c", "features.apps=false", "-c", "features.daemon_auto_start=false"]);
+  const remote = codexInteractiveArguments({ ...options, remoteEndpoint: "unix:///runtime/codex.sock" });
+  assert.equal(remote.some((value) => value.startsWith("features.")), false);
+});
+
 test("local Codex and new remote threads retain their explicit permission selection", () => {
   for (const input of [{}, { threadId: "local-thread" }, { remoteEndpoint: "unix:///runtime/codex.sock" }]) {
     const args = codexInteractiveArguments({ ...options, ...input });