@jskit-ai/assistant-core 0.2.1 → 0.2.3

package/test/codexTemporaryProviderRelease.test.js

@@ -0,0 +1,180 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
+import { createCodexConversationCommands } from "../src/server/conversation/codexConversations.js";
+import { createCodexSessionCleanup } from "../src/server/conversation/codexSessionCleanup.js";
+
+// A Codex app-server runs only while it is used: reading a conversation's
+// history or status, or stopping it, borrows the process; a running Temporary
+// turn or goal holds it; and closing a project stops every one of its own.
+
+async function eventually(check, message) {
+  const deadline = Date.now() + 2_000;
+  while (!check()) {
+    if (Date.now() > deadline) assert.fail(message);
+    await new Promise(resolve => setTimeout(resolve, 5));
+  }
+}
+
+function settle(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// One native process per runtime directory, as the real app-server has per
+// account and runtime scope. Each provider connection reports its own thread.
+function codexFixture(t, { idleMs = 20 } = {}) {
+  const runtimes = new Map();
+  const listeners = new Set();
+  const runtimeFor = runtimeDir => {
+    if (!runtimes.has(runtimeDir)) runtimes.set(runtimeDir, { running: false, starts: 0, stops: 0 });
+    return runtimes.get(runtimeDir);
+  };
+  const owner = createCodexAppServerProviderOwner({ transientIdleMs: idleMs, providerFactory: ({ runtimeDir }) => {
+    const runtime = runtimeFor(runtimeDir);
+    return {
+      observationFailure: null,
+      isHelperProvider: () => false,
+      isAvailable: () => runtime.running,
+      async ensureAvailable() {
+        if (!runtime.running) { runtime.running = true; runtime.starts += 1; }
+        return { ok: true };
+      },
+      async stopRuntime() { runtime.running = false; runtime.stops += 1; return { stopped: true }; },
+      close() {},
+      subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+      async readThreadStatus(threadId) { return { raw: { id: threadId, historyMode: "paginated", status: "idle" } }; },
+      async listThreadTurns() { return { data: [{ id: "turn-1", status: "completed", items: [] }] }; },
+      async readGoal() { return { goal: null }; },
+      async resumeThread() { return {}; },
+      async sendTurn() { return { id: "turn-2", status: "inProgress" }; },
+      async stopThreadForObservationLoss() {}
+    };
+  } });
+  t.after(() => owner.beginShutdown());
+  const sessionKey = sessionId => `codex:project-a:${sessionId}`;
+  const connection = (sessionId, keyPrefix = "codex:project-a:") => ({
+    sessionId, providerKey: `provider:${sessionId}`, providerOptions: { runtimeDir: `/tmp/jskit-codex-release-${sessionId}` },
+    keyFields: key => ({ sessionId: key.slice("provider:".length) }), assertAdmission() {}, closing: false,
+    runOwner: { runtimeLifecycle: { rememberManagedSession() {}, managedThreadId: () => "" } },
+    async prepare() {
+      return { parameters: { runtimeDir: `/tmp/jskit-codex-release-${sessionId}` }, owner: { sessionKey: `${keyPrefix}${sessionId}` },
+        resources: null, controls: { available: false, subscribe: () => () => {} }, runInContext: operation => operation() };
+    }
+  });
+  const commands = createCodexConversationCommands({
+    async checkpoint() {},
+    codexAppServerConversationMessageId: (...parts) => parts.join(":"),
+    codexAppServerStreamMessage: () => ({}),
+    conversationPreparation: {
+      async context() {
+        return { context: { session: {} }, helperTurn: false, projectRuntimeRoot: "/runtime", managedIdentity: {},
+          providerOptions: {}, project: provider => ({ provider, workdir: "/work", agentSettings: {} }) };
+      },
+      admissionError: () => null,
+      failure(error) { return { ok: false, error: error.message }; },
+      response: text => ({ text }),
+      execution() {
+        return { executionProfile: null, threadPreparation: { settings: () => ({}) }, authorized: { turnSettings: {} },
+          readOnly: false, onEvent: null, actorMetadata: {}, projectResult: result => result };
+      },
+      isolation: { assertCompatibility() {} }
+    },
+    ensureCodexAppServerProviderForActiveTurn: async () => null,
+    errorPrefix: "",
+    helperLifecycle: { async assertOrdinaryThreadAvailable() {}, inspectControl: () => undefined },
+    namespace: sessionId => sessionKey(sessionId),
+    providerSessions: { owner },
+    ensureSessionProvider: sessionId => owner.ensureSession(connection(sessionId)),
+    borrowSessionProvider: sessionId => owner.borrowSession(connection(sessionId)),
+    turnOutcomes: { USER_CANCELLED: "cancelled" }
+  });
+  const emit = notification => [...listeners].forEach(listener => listener(notification));
+  return { owner, commands, connection, emit, runtime: runtimeFor("/tmp/jskit-codex-release-session-1"), runtimeFor };
+}
+
+test("reading a Temporary chat's history leaves no Codex app-server running", async t => {
+  const f = codexFixture(t);
+  const read = await f.commands.readCodexAppServerConversation("session-1", { conversationId: "chat-1", persistent: true });
+  assert.equal(read.ok, true);
+  assert.equal(read.status, "completed");
+  assert.equal(f.runtime.running, true, "the read itself uses the process");
+  await eventually(() => !f.runtime.running, "an unused history read kept Codex running");
+  assert.equal(f.runtime.stops, 1);
+  assert.deepEqual([...f.owner.providers.keys()], []);
+});
+
+test("consecutive Temporary chat reads share one Codex process and the last releases it", async t => {
+  const f = codexFixture(t, { idleMs: 40 });
+  for (let read = 0; read < 3; read += 1) {
+    await f.commands.readCodexAppServerConversation("session-1", { conversationId: "chat-1", persistent: true });
+  }
+  assert.equal(f.runtime.starts, 1);
+  await eventually(() => !f.runtime.running, "the last read did not release Codex");
+  assert.equal(f.runtime.stops, 1);
+});
+
+test("stopping an idle Temporary chat leaves no Codex app-server running", async t => {
+  const f = codexFixture(t);
+  const stopped = await f.commands.stopCodexAppServerConversation("session-1", { conversationId: "chat-1", persistent: true });
+  assert.equal(stopped.status, "interrupted");
+  await eventually(() => !f.runtime.running, "a Stop of idle work kept Codex running");
+  assert.deepEqual([...f.owner.providers.keys()], []);
+});
+
+test("a running Temporary turn keeps Codex; it stops a short idle after the turn ends", async t => {
+  const f = codexFixture(t);
+  const started = await f.commands.startCodexAppServerConversationTurn("session-1", {
+    conversationId: "chat-1", persistent: true, message: "Explain this file", messageId: "message-1"
+  });
+  assert.equal(started.status, "inProgress");
+  // A history read while the turn runs must not release its process either.
+  await f.commands.readCodexAppServerConversation("session-1", { conversationId: "chat-1", persistent: true });
+  f.emit({ method: "turn/started", params: { threadId: "chat-1", turn: { id: "turn-2", status: "inProgress" } } });
+  await settle(80);
+  assert.equal(f.runtime.running, true, "the running turn's process was stopped");
+  assert.equal(f.runtime.stops, 0);
+  f.emit({ method: "turn/completed", params: { threadId: "chat-1", turn: { id: "turn-2", status: "completed" } } });
+  await eventually(() => !f.runtime.running, "the finished turn kept Codex running");
+  assert.equal(f.runtime.stops, 1);
+});
+
+test("an active Temporary goal keeps Codex between its turns until the goal ends", async t => {
+  const f = codexFixture(t);
+  await f.commands.startCodexAppServerConversationTurn("session-1", {
+    conversationId: "chat-1", persistent: true, message: "Finish the migration", messageId: "message-1"
+  });
+  f.emit({ method: "thread/goal/updated", params: { threadId: "chat-1", goal: { status: "active" } } });
+  f.emit({ method: "turn/completed", params: { threadId: "chat-1", turn: { id: "turn-2", status: "completed" } } });
+  await settle(80);
+  assert.equal(f.runtime.running, true, "the goal's process was stopped between its turns");
+  f.emit({ method: "thread/goal/updated", params: { threadId: "chat-1", goal: { status: "complete" } } });
+  await eventually(() => !f.runtime.running, "the finished goal kept Codex running");
+});
+
+test("closing a project stops a Codex app-server its Temporary chat read, and only that project's", async t => {
+  const f = codexFixture(t, { idleMs: 60_000 });
+  await f.commands.readCodexAppServerConversation("session-1", { conversationId: "chat-1", persistent: true });
+  // Another project's session keeps its own conversation.
+  const other = f.runtimeFor("/tmp/jskit-codex-release-session-9");
+  await f.owner.ensureSession(f.connection("session-9", "codex:project-b:"));
+  assert.equal(f.runtime.running, true);
+  assert.equal(other.running, true);
+  const cleanup = createCodexSessionCleanup({
+    namespace: sessionId => `codex:project-a:${sessionId}`,
+    runOwner: {},
+    providerSessions: { owner: f.owner, managed: new Map(), keyFields: key => ({ sessionId: key.slice("provider:".length) }) },
+    sessionClosures: new Map(),
+    helperLifecycle: { async restoreThreads() { return { ok: true, failed: [] }; }, records: () => [] },
+    journal: { clearSessionRecoveryTimers() {} },
+    conversations: f.commands,
+    debugLog() {},
+    debugError: error => error?.message
+  });
+  const closed = await cleanup.closeProject({ projectContextRoot: "/project-a" }, {
+    helpers: Promise.resolve({ projectRuntimeRoot: "/runtime", context: {} })
+  });
+  assert.equal(closed.ok, true);
+  assert.equal(f.runtime.running, false, "project close left the Temporary chat's Codex running");
+  assert.equal(other.running, true, "another project's Codex was stopped");
+  assert.deepEqual([...f.owner.providers.keys()], ["provider:session-9"]);
+});

package/test/codexTurn.test.js

@@ -491,7 +491,7 @@ test("session cleanup owns its single-flight closures and restricted record with
         return { exitFailure: null };
       }
     } },
-    helperLifecycle: { assertRestored() {}, async restoreThreads() {}, assertRetired() {}, async retireAll() {} },
+    helperLifecycle: { async restoreThreads() { return { failed: [], ok: true }; }, assertRetired() {}, async retireAll() {} },
     journal: { clearSessionRecoveryTimers() {} },
     conversations: { async closeCodexAppServerConversations() {} },
     debugLog() {}, debugError: error => error
@@ -3201,6 +3201,57 @@ test("native changeover retries retain original application data including its a
   }
 });
 
+test("native changeover treats a proven not-admitted attempt as not sent", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const original = { messageId: "lost-request", message: "Prepared prompt", displayMessage: "Original words.",
+    displayAttachments: [], attachmentIds: [], seen: {}, attempted: true, threadId: "thread" };
+  for (const inspectFirst of [true, false]) {
+    let value = { lastEngine: "codex", engines: { codex: { seen: {}, pending: structuredClone(original) } } };
+    let admission = "unknown";
+    const sent = [];
+    const changeover = () => createConversationChangeover({
+      state: { async read() { return structuredClone(value); }, async write(next) { value = structuredClone(next); } },
+      transcript: { async hasMessage() { return false; } },
+      agent: { async inspectMessageAdmission() { return { admission }; },
+        async sendMessage(input) { sent.push(input.message); return { ok: true, delivered: true }; } }
+    });
+    const inspect = () => changeover().send({ engineId: "codex", messages: [], input: { messageId: original.messageId }, inspectOnly: true });
+    assert.equal((await inspect()).code, "conversation_changeover_delivery_unconfirmed", "An unknown receipt is never resent");
+    admission = "not-admitted";
+    if (inspectFirst) {
+      const receipt = await inspect();
+      assert.equal(receipt.notSent, true);
+      assert.equal(receipt.messageId, original.messageId);
+      assert.equal(value.engines.codex.pending.attempted, false);
+      assert.deepEqual(sent, [], "Inspection never sends");
+    }
+    const delivered = await changeover().send({ engineId: "codex", messages: [],
+      input: { messageId: original.messageId, message: "Original words." } });
+    assert.equal(delivered.delivered, true);
+    assert.deepEqual(sent, ["Prepared prompt"], "The proven unsent attempt is sent once, with its original prompt");
+  }
+});
+
+test("Cancel discards an unconfirmed native attempt so the next message is neither blocked nor replayed", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  let value = { lastEngine: "codex", engines: { codex: { seen: {}, pending: { messageId: "cancelled-request", message: "Prepared prompt",
+    displayMessage: "Original words.", displayAttachments: [], attachmentIds: [], seen: {}, attempted: true, threadId: "thread" } } } };
+  const sent = [];
+  const changeover = createConversationChangeover({
+    state: { async read() { return structuredClone(value); }, async write(next) { value = structuredClone(next); } },
+    transcript: { async hasMessage() { return false; } },
+    agent: { async inspectMessageAdmission() { return { admission: "unknown" }; },
+      async sendMessage(input) { sent.push(input.messageId); return { ok: true, delivered: true }; } }
+  });
+  assert.equal((await changeover.send({ engineId: "codex", messages: [], input: { messageId: "next", message: "Next." } })).code,
+    "conversation_changeover_delivery_unconfirmed", "An unknown attempt blocks the next message until it is resolved");
+  assert.equal(await changeover.discard({ messageId: "other-request" }), false);
+  assert.equal(await changeover.discard({ messageId: "cancelled-request" }), true);
+  assert.equal(value.engines.codex.pending, undefined);
+  assert.equal((await changeover.send({ engineId: "codex", messages: [], input: { messageId: "next", message: "Next." } })).delivered, true);
+  assert.deepEqual(sent, ["next"], "The cancelled attempt is never replayed");
+});
+
 test("initial native seed limits preserve generic history, full returning corrections and delivery ownership", async () => {
   const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
   const attachment = { attachmentId: "retained-file", name: "retained.txt" };

package/test/conversationNativeStorage.test.js

@@ -1,6 +1,12 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { nativeConversationStoragePolicy } from "../src/server/conversation/nativeStorage.js";
+import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
+import { createCodexConversationDriver } from "../src/server/conversation/providers/codexDriver.js";
+import { createOpenCodeSharedRuntime, openCodeServerForDirectory } from "../src/server/conversation/openCodeRuntime.js";
+import { createOpenCodeConversationDriver } from "../src/server/conversation/providers/opencodeDriver.js";
 
 test("native storage policy distinguishes locked deletion from host writer exclusion", () => {
   assert.equal(nativeConversationStoragePolicy("codex").requiresWriterExclusion, false);
@@ -23,3 +29,281 @@ test("native writer recognition handles executables and node entry points withou
   assert.ok(opencode.matchesProcess({ executable: "/usr/bin/bun", commandLine: "bun\0/tools/opencode\0serve\0" }));
   assert.equal(opencode.matchesProcess({ executable: "/tools/opencode-helper", commandLine: "node\0/notes/opencode.txt\0" }), false);
 });
+
+async function eventually(check, message) {
+  const deadline = Date.now() + 2_000;
+  while (!check()) {
+    if (Date.now() > deadline) assert.fail(message);
+    await new Promise(resolve => setTimeout(resolve, 5));
+  }
+}
+
+// One shared native process with independent provider connections, as the
+// real Codex app-server has per account and runtime scope.
+function codexStorageFixture(t, { idleMs = 20, listModelsMs = 0 } = {}) {
+  // Owned runtimes and sharing are process-wide, so each fixture has its own.
+  const runtimeDir = `/tmp/jskit-codex-storage-runtime-${randomUUID()}`;
+  const runtime = { running: false, starts: 0, stops: 0, reads: [] };
+  const owner = createCodexAppServerProviderOwner({ transientIdleMs: idleMs, providerFactory: () => ({
+    isHelperProvider: () => false,
+    isAvailable: () => runtime.running,
+    async currentRuntimeInfo() { return { runtimeDir }; },
+    async listModels() {
+      runtime.reads.push("catalogue");
+      await new Promise(resolve => setTimeout(resolve, listModelsMs));
+      return { running: runtime.running, data: [{ id: "gpt" }] };
+    },
+    async readGoal() { runtime.reads.push("goal"); return { goal: null }; },
+    async readPlanUsage() { runtime.reads.push("usage"); return { status: "available", windows: [] }; },
+    async ensureAvailable() {
+      if (!runtime.running) { runtime.running = true; runtime.starts += 1; }
+      return { ok: true, runtime: { runtimeDir } };
+    },
+    async listNativeThreadsForCwd(cwd) { return [`thread-in-${path.basename(cwd)}`]; },
+    async stopRuntime() { runtime.running = false; runtime.stops += 1; return { stopped: true }; },
+    close() {}
+  }) });
+  t.after(() => owner.beginShutdown());
+  const context = sessionId => ({
+    sessionId, providerKey: `provider:${sessionId}`, providerOptions: { runtimeDir },
+    keyFields: key => ({ sessionId: key }), assertAdmission() {}, closing: false,
+    runOwner: { runtimeLifecycle: { rememberManagedSession() {}, managedThreadId: () => "" } },
+    async prepare() {
+      return { parameters: { runtimeDir }, owner: { sessionKey: sessionId }, resources: null,
+        controls: { available: false, subscribe: () => () => {} }, runInContext: operation => operation() };
+    }
+  });
+  const driver = createCodexConversationDriver({ host: {} });
+  const list = sessionId => driver.listConversationStorage({
+    sessionId, context: {},
+    binding: { engineId: "codex", modelProviderId: "openai", workdir: `/archived/${sessionId}` },
+    native: { providerOwner: owner, errorPrefix: "", preparation: {
+      async storage(id) { return { providerContext: context(id), toolHomeSource: "/home/person" }; }
+    } }
+  });
+  return { owner, runtime, context, list };
+}
+
+test("a native storage listing leaves no Codex runtime or provider running", async t => {
+  const { owner, runtime, list } = codexStorageFixture(t);
+  assert.deepEqual((await list("archived-1")).map(row => row.conversationId), ["thread-in-archived-1"]);
+  assert.equal(runtime.running, true, "the listing itself uses the shared process");
+  await eventually(() => !runtime.running, "an unused storage listing kept Codex running");
+  assert.equal(runtime.stops, 1);
+  assert.deepEqual([...owner.providers.keys()], []);
+});
+
+test("consecutive native storage reads share one Codex process and stop it after the last", async t => {
+  const { owner, runtime, list } = codexStorageFixture(t, { idleMs: 40 });
+  await list("archived-1");
+  await list("archived-2");
+  await list("archived-1");
+  assert.equal(runtime.starts, 1);
+  await eventually(() => runtime.stops === 1 && owner.providers.get("provider:archived-2") === undefined,
+    "the last storage read did not release Codex");
+  assert.equal(runtime.running, false);
+  assert.deepEqual([...owner.providers.keys()], []);
+});
+
+test("native storage reads never stop a Codex process a conversation still uses", async t => {
+  const { owner, runtime, context, list } = codexStorageFixture(t);
+  const conversation = await owner.ensureSession(context("open-session"));
+  await list("archived-1");
+  // A conversation that claims a provider a storage read created keeps it too.
+  await list("claimed-session");
+  await owner.ensureSession(context("claimed-session"));
+  await eventually(() => owner.providers.get("provider:archived-1") === undefined, "the storage provider was not released");
+  await new Promise(resolve => setTimeout(resolve, 60));
+  assert.equal(runtime.running, true);
+  assert.equal(runtime.stops, 0);
+  assert.equal(owner.providers.get("provider:open-session"), conversation);
+  assert.ok(owner.providers.get("provider:claimed-session"));
+});
+
+// One shared `opencode serve`, as OpenCode runs per runtime scope.
+function openCodeStorageFixture({ idleMs = 20 } = {}) {
+  const owner = createOpenCodeSharedRuntime({ storageIdleMs: idleMs });
+  const server = { running: false, starts: 0, stops: 0 };
+  const connection = { modelProviderId: "provider", canonicalUrl: "https://provider.invalid", fingerprint: "account", endpointCode: "api" };
+  const create = async () => {
+    server.running = true;
+    server.starts += 1;
+    return {
+      client: {
+        async health() { return { healthy: true }; },
+        async listConversationsForDirectory(directory) { return [{ id: `conversation-in-${path.basename(directory)}` }]; },
+        forDirectory(directory) { return { ...this, directory }; }
+      },
+      async stop() {
+        server.running = false;
+        server.stops += 1;
+        return { exited: true };
+      }
+    };
+  };
+  const native = { owner, preparation: { storage: () => ({
+    process: async () => ({ create, options: {}, connections: [connection] }),
+    failure: error => { throw error; }
+  }) } };
+  const driver = createOpenCodeConversationDriver({ connections: { resolve() {} }, host: { workdir: "/tmp" } });
+  const list = archived => driver.listConversationStorage({ native, context: {},
+    binding: { engineId: "opencode", modelProviderId: "provider", workdir: `/work/${archived}` } });
+  const conversation = key => owner.acquire(key, async () => {
+    const shared = await owner.ensure(connection, async () => ({ server: await create(), connections: [connection] }));
+    return { key, workdir: `/work/${key}`, abortController: new AbortController(),
+      server: openCodeServerForDirectory(shared.server, `/work/${key}`) };
+  });
+  return { owner, server, list, conversation };
+}
+
+test("an OpenCode storage listing leaves no OpenCode server running", async () => {
+  const { server, list } = openCodeStorageFixture();
+  assert.deepEqual((await list("archived-1")).map(row => row.conversationId), ["conversation-in-archived-1"]);
+  assert.equal(server.running, true, "the listing itself uses the shared server");
+  await eventually(() => !server.running, "an unused storage listing kept opencode serve running");
+  assert.equal(server.stops, 1);
+});
+
+test("consecutive OpenCode storage reads share one server and stop it after the last", async () => {
+  const { server, list } = openCodeStorageFixture({ idleMs: 40 });
+  await list("archived-1");
+  await list("archived-2");
+  assert.equal(server.starts, 1);
+  await eventually(() => server.stops === 1, "the last storage read did not stop opencode serve");
+  assert.equal(server.running, false);
+});
+
+test("OpenCode storage reads never stop a server a conversation still uses", async () => {
+  const { owner, server, list, conversation } = openCodeStorageFixture();
+  const open = await conversation("open-session");
+  await list("archived-1");
+  await new Promise(resolve => setTimeout(resolve, 60));
+  assert.equal(server.running, true);
+  assert.equal(server.stops, 0);
+  await owner.release(open);
+  assert.equal(server.running, false);
+  assert.equal(server.starts, 1);
+});
+
+test("a catalogue read on a storage-started Codex process finishes before its release stops it", async t => {
+  const { owner, runtime, list } = codexStorageFixture(t, { listModelsMs: 60 });
+  await list("archived-1");
+  // The release timer fires during this read; the shared lifecycle holds it back.
+  const catalogue = await owner.readModelCatalog({
+    prepareProviderOptions: async () => ({ runtimeDir: owner.ownedRuntimes.values().next().value.runtimeDir }),
+    providerFactory: () => assert.fail("The running storage process should serve the catalogue.")
+  });
+  assert.equal(catalogue.running, true, "the release stopped Codex during the catalogue read");
+  await eventually(() => !runtime.running, "the storage process was not released after the catalogue read");
+  assert.equal(runtime.starts, 1);
+  assert.equal(runtime.stops, 1);
+});
+
+test("goal and plan-usage reads never use a provider a storage read borrowed", async t => {
+  const { owner, runtime, list } = codexStorageFixture(t, { idleMs: 200 });
+  await list("archived-1");
+  assert.deepEqual(await owner.readSessionGoal("archived-1", "thread-1"), { status: "unavailable", goal: null });
+  assert.deepEqual(await owner.readPlanUsage("archived-1"), { status: "unavailable", windows: [] });
+  assert.deepEqual(runtime.reads, []);
+});
+
+test("real use that reaches a storage-created provider directly keeps it", async t => {
+  const { owner, runtime, context, list } = codexStorageFixture(t);
+  for (const use of [
+    // Helper account checks read the provider without ensureSession.
+    id => owner.withLifecycle(() => owner.providerForSession(context(id))),
+    id => owner.acquireRuntime({ providerKey: `provider:${id}`, provider: owner.providers.get(`provider:${id}`),
+      providerOptions: context(id).providerOptions, operation: async () => {} }),
+    id => owner.createProvider({ providerKey: `provider:${id}`, providerOptions: context(id).providerOptions })
+  ]) {
+    const id = `archived-${randomUUID()}`;
+    await list(id);
+    const provider = owner.providers.get(`provider:${id}`);
+    await use(id);
+    await new Promise(resolve => setTimeout(resolve, 60));
+    assert.equal(owner.providers.get(`provider:${id}`), provider);
+  }
+  assert.equal(runtime.running, true);
+  assert.equal(runtime.stops, 0);
+});
+
+test("a storage read on a managed main thread's key leaves it to that thread", async t => {
+  const { owner, runtime, context, list } = codexStorageFixture(t);
+  const managed = context("archived-1");
+  managed.runOwner.runtimeLifecycle.managedThreadId = () => "main-thread";
+  await owner.withTransientSession(managed, async () => {});
+  await new Promise(resolve => setTimeout(resolve, 60));
+  assert.ok(owner.providers.get("provider:archived-1"));
+  assert.equal(runtime.stops, 0);
+  await list("archived-2");
+  await eventually(() => owner.providers.get("provider:archived-2") === undefined, "the borrowed provider was not released");
+  assert.equal(runtime.running, true, "a managed main thread still shares the process");
+});
+
+test("a conversation that starts after an OpenCode storage read keeps the server", async () => {
+  const { owner, server, list, conversation } = openCodeStorageFixture({ idleMs: 40 });
+  await list("archived-1");
+  const open = await conversation("open-session");
+  await new Promise(resolve => setTimeout(resolve, 80));
+  assert.equal(server.running, true, "the storage release stopped a server a conversation uses");
+  assert.equal(server.starts, 1);
+  await owner.release(open);
+  assert.equal(server.running, false);
+});
+
+// The inventory keeps only thread ids. Long first prompts in each thread/list
+// preview are not retained, so they cannot make a valid inventory fail.
+function codexThreadListing(pages) {
+  const requests = [];
+  const client = {
+    async request(method, params) {
+      assert.equal(method, "thread/list");
+      requests.push(params);
+      const index = params.cursor ? Number(params.cursor) : 0;
+      const archived = params.archived === true;
+      const data = archived ? [] : pages[index] || [];
+      const nextCursor = !archived && index + 1 < pages.length ? String(index + 1) : null;
+      return { data, nextCursor };
+    }
+  };
+  const inventory = { activeClient: async () => client, runRequest: (operation) => operation(), errorPrefix: "vibe64_" };
+  return { inventory, requests };
+}
+
+function nativeThread(id, { cwd = "/source", previewBytes = 0 } = {}) {
+  return { id, cwd, preview: "p".repeat(previewBytes), status: { type: "notLoaded" } };
+}
+
+test("Codex native existence checks a home whose thread previews exceed any byte budget", async () => {
+  const pages = [
+    Array.from({ length: 100 }, (_, index) => nativeThread(`thread-${index}`, { previewBytes: 30 * 1024 })),
+    [nativeThread("wanted", { previewBytes: 70 * 1024 })]
+  ];
+  const { inventory } = codexThreadListing(pages);
+  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "wanted"), true);
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "missing"), false);
+});
+
+test("Codex native existence searches more threads than an inventory retains", async () => {
+  const pages = Array.from({ length: 12 }, (_, page) =>
+    Array.from({ length: 100 }, (_, index) => nativeThread(`thread-${page}-${index}`)));
+  const { inventory, requests } = codexThreadListing(pages);
+  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "thread-3-7"), true);
+  assert.equal(requests.length, 4, "the search stops at the page that lists the thread");
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "thread-12-0"), false);
+});
+
+test("a refused Codex inventory entry names the check and the thread", async () => {
+  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
+  const outside = codexThreadListing([[nativeThread("thread-a"), nativeThread("thread-b", { cwd: "/elsewhere" })]]);
+  await assert.rejects(CodexAppServerAgentProvider.prototype.listNativeThreadsForCwd.call(outside.inventory, "/source"), (error) => {
+    assert.equal(error.code, "vibe64_codex_retirement_inventory_invalid");
+    assert.match(error.message, /thread thread-b .*outside the requested directory/u);
+    return true;
+  });
+  const unnamed = codexThreadListing([[{ cwd: "/source" }]]);
+  await assert.rejects(CodexAppServerAgentProvider.prototype.listNativeThreadsForCwd.call(unnamed.inventory, "/source"),
+    /listed a thread without an id/u);
+});

package/test/conversationRuntime.test.js

@@ -9,6 +9,7 @@ import { createCodexConversationAdapter } from "../src/server/conversation/provi
 import { createOpenCodeConversationAdapter } from "../src/server/conversation/providers/opencode.js";
 import { readPersistentConversation } from "../src/server/conversation/providers/scoped.js";
 import { createConversationTranscript, createMemoryConversationStorage } from "../src/server/conversation/index.js";
+import { createAiConnectionResolver } from "../../connectors-catalog/src/server/ai.js";
 
 test("scoped reads retain each request's output when an accepted steer interrupts the earlier reply", async () => {
   const transcript = createConversationTranscript({ storage: createMemoryConversationStorage() });
@@ -707,3 +708,68 @@ test("a user Pause during the final goal read prevents automatic settings recove
   assert.equal(f.requests.some(r => r.method === "thread/goal/set" && r.input.status === "active"), false);
   f.runtime.close();
 });
+
+const logicalConversation = namespace => ({
+  sessionId: "session", namespace, engine: "claude",
+  read: async () => ({ engine: "claude", conversationLog: [], status: "ready" }),
+  readStream: async () => ({ messages: [] }),
+  commands: { send: async () => ({ status: "accepted" }), cancel: async () => ({ ok: true }),
+    select: async () => ({ ok: true }), inspectDelivery: async () => ({ status: "unknown" }) }
+});
+
+test("a deleted logical conversation retires its open entry without opening another", async () => {
+  const opened = [];
+  const runtime = createConversationRuntime({ authorize: () => true,
+    host: { conversation: ({ context }) => { opened.push(context.chat); return logicalConversation(`temporary-${context.chat}`); } } });
+  try {
+    const handle = await runtime.open({ id: "session", context: { chat: "one" } });
+    await handle.subscribe(() => {});
+    assert.deepEqual(await runtime.retireOpenConversation({ namespace: "temporary-one", sessionId: "session" }), { retired: true });
+    await assert.rejects(handle.read(), { code: "conversation_closed" });
+    await assert.rejects(handle.subscribe(() => {}), { code: "conversation_closed" });
+    assert.deepEqual(await runtime.retireOpenConversation({ namespace: "temporary-one", sessionId: "session" }), { retired: false },
+      "an absent entry is already retired; nothing is opened to retire it");
+    assert.deepEqual(await runtime.retireOpenConversation({ namespace: "temporary-two", sessionId: "session" }), { retired: false });
+    assert.deepEqual(opened, ["one"]);
+    const reopened = await runtime.open({ id: "session", context: { chat: "one" } });
+    assert.equal((await reopened.read()).status, "ready", "a later open starts a fresh entry");
+  } finally {
+    await runtime.close();
+  }
+});
+
+test("retiring a logical conversation keeps the live stream of the conversation that shares its id", { timeout: 15_000 }, async () => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  const frame = (content, finish = false) => new TextEncoder().encode(`data: ${JSON.stringify({ choices: [{ index: 0,
+    delta: content ? { content } : {}, ...(finish ? { finish_reason: "stop" } : {}) }] })}\n\n`);
+  const streamed = Promise.withResolvers();
+  const context = { applicationId: "test-app", subjectId: "owner" };
+  const connections = createAiConnectionResolver({ authorize: actor => actor, configuration: { schemaVersion: 1, registrations: {}, integrations: {
+    assistant: { provider: "ai", accountMode: "shared", scopes: [], authentication: { method: "none" }, settings: { model: "opencode/mimo-v2.5-free" } }
+  } } });
+  const runtime = createConversationRuntime({ storage: createMemoryConversationStorage(), connections, authorize: () => true,
+    fetch: () => new Response(source.readable, { headers: { "content-type": "text/event-stream" } }),
+    host: { conversation: ({ context }) => context.chat ? logicalConversation(`temporary-${context.chat}`) : null } });
+  let finished = false;
+  try {
+    const main = await runtime.open({ id: "session", context, configuration: { systemPrompt: "Give concise answers.", integrationId: "assistant" } });
+    const chat = await runtime.open({ id: "session", context: { ...context, chat: "one" } });
+    await chat.subscribe(() => {});
+    await main.subscribe(event => { if (event.type === "message") streamed.resolve(); });
+    assert.equal((await main.send({ messageId: "main-message", text: "Hello" })).status, "accepted");
+    await writer.write(frame("Main words"));
+    await streamed.promise;
+    assert.deepEqual(await runtime.retireOpenConversation({ namespace: "temporary-one", sessionId: "session" }), { retired: true });
+    assert.deepEqual((await main.read()).streaming.messages.map(({ text }) => text), ["Main words"],
+      "a logical conversation owns no runtime stream, so retiring it leaves the same-id conversation's live reply");
+    await writer.write(frame(" and more"));
+    await writer.write(frame("", true));
+    await writer.close();
+    finished = true;
+    assert.equal((await main.wait()).conversationLog[0].assistant.text, "Main words and more");
+  } finally {
+    if (!finished) await writer.abort(new Error("The test ended before the reply.")).catch(() => {});
+    await runtime.close();
+  }
+});

package/test/conversationSession.test.js

@@ -735,7 +735,7 @@ test("renewal proof cleanup preserves OpenCode failure, consumption and retry th
   assert.deepEqual(calls, ["proof-id"]);
 });
 
-test("Claude renewal proof routes use the original close owner and preserve retry after shutdown", async t => {
+test("Claude renewal proof routes release only retained work and preserve retry after shutdown", async t => {
   const nativeContext = { sessionId: "renewal-one", key: "renewal-scope" };
   const calls = [];
   const failure = new Error("Terminal cleanup is unconfirmed.");
@@ -744,11 +744,7 @@ test("Claude renewal proof routes use the original close owner and preserve retr
     configRoot: "/unused-native-config",
     preparation: { context() { assert.fail("No saved native conversations exist."); } },
     process: { create() { assert.fail("Proof release must not start a process."); } },
-    store: { readSessionConversations(current) {
-      assert.equal(current, nativeContext);
-      calls.push("restore");
-      return { context: current, ids: [] };
-    } }
+    store: { readSessionConversations() { assert.fail("Proof release must not reopen saved conversations."); } }
   });
   const application = {
     readContext(current) { assert.equal(current, nativeContext); calls.push("context"); return current; },
@@ -777,7 +773,7 @@ test("Claude renewal proof routes use the original close owner and preserve retr
       ok: true, closed: 1, processExitProof: { exited: true, scopeEmpty: true }, processExitProofs: []
     });
   }
-  assert.deepEqual(calls, Array(3).fill(["context", "restore", "terminal"]).flat());
+  assert.deepEqual(calls, Array(3).fill(["context", "terminal"]).flat());
   assert.equal(owner.closingSessions.size, 0);
   assert.equal(owner.entries.size, 0);
 });
@@ -929,7 +925,7 @@ test("native activity uses the configured inventory without opening Main, includ
     const acquire = () => assert.fail("The native activity owner controls receipt restoration.");
     const inspect = (...args) => {
       calls.push("inspect");
-      if (engine === "claude") assert.deepEqual(args, [preparedContext, { acquire }]);
+      if (engine === "claude") assert.deepEqual(args, [preparedContext]);
       else assert.deepEqual(args, [id]);
       return true;
     };