@jskit-ai/assistant-core 0.2.1 → 0.2.3

package/src/server/conversation/openCodeRuntime.js

@@ -169,7 +169,7 @@ export async function ensureOpenCodeSession(target, { selection, model, workdir
 
 // The production provider's users and pending acquisitions share this owner.
 // Hosts supply authorized startup inputs and their own publication/cleanup work.
-export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
+export function createOpenCodeSharedRuntime({ onStop = () => {}, scope, storageIdleMs = 60_000 } = {}) {
   if (scope !== undefined && !path.isAbsolute(scope)) throw new TypeError("OpenCode runtime scopes require an absolute directory.");
   if (scope && sharedRuntimes.has(scope)) return sharedRuntimes.get(scope);
   const processes = new Map();
@@ -183,13 +183,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   let sharedProcessStop = null;
   let failedStartup = null;
   let closed = false;
-  let connectionChanging = false;
-
-  function requireConnectionAvailable() {
-    if (connectionChanging) throw Object.assign(new Error("OpenCode is changing a connection. Retry after the connection change finishes."), {
-      code: "assistant_opencode_connection_changing", statusCode: 409
-    });
-  }
+  let connectionUpdate = Promise.resolve();
+  let storageReads = 0;
+  let storageIdle = null;
   const bindingScopes = new Map();
   let registryPath = "";
   let bindingWrite = Promise.resolve();
@@ -238,28 +234,161 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     }
   }
 
-  async function ensure(selected, start) {
-    requireConnectionAvailable();
+  // A credential change reaches a native directory when OpenCode reloads that
+  // directory's instance. An idle directory reloads at once; one with a turn in
+  // flight reloads when its last turn there ends. New work in a directory waits
+  // for its reload, so it never starts on credentials the server no longer holds.
+  function directoryState(shared, workdir) {
+    const directory = path.resolve(workdir);
+    let state = shared.directories.get(directory);
+    if (!state) {
+      state = { directory, generation: shared.generation, turns: 0, reload: null, idle: null };
+      shared.directories.set(directory, state);
+    }
+    return state;
+  }
+
+  function directoryCurrent(workdir) {
+    const state = sharedProcess && text(workdir) ? sharedProcess.directories.get(path.resolve(workdir)) : null;
+    return !state || (!state.reload && state.generation === sharedProcess.generation);
+  }
+
+  function reloadDirectory(shared, state) {
+    if (state.reload || state.generation === shared.generation) return state.reload;
+    state.reload = (async () => {
+      try {
+        while (state.generation < shared.generation) {
+          const generation = shared.generation;
+          await shared.server.client.forDirectory(state.directory).disposeInstance();
+          state.generation = generation;
+        }
+      } finally {
+        state.reload = null;
+      }
+    })();
+    return state.reload;
+  }
+
+  async function waitForDirectory(workdir) {
+    const shared = sharedProcess;
+    const state = directoryState(shared, workdir);
+    try {
+      if (state.reload || !state.turns) await reloadDirectory(shared, state);
+      else await (state.idle ||= Promise.withResolvers()).promise;
+    } catch (error) {
+      if (sharedProcess !== shared) return;
+      throw Object.assign(new Error("OpenCode could not load the changed AI connection for this work. Send your message again."), {
+        cause: error, code: "assistant_opencode_connection_reload_failed", details: {}, statusCode: 503
+      });
+    }
+  }
+
+  async function currentDirectory(workdir) {
+    while (!directoryCurrent(workdir)) await waitForDirectory(workdir);
+  }
+
+  // Holds a directory's credentials for a turn in flight there.
+  function holdDirectory(workdir) {
+    const shared = sharedProcess;
+    if (!shared || !text(workdir)) return () => {};
+    const state = directoryState(shared, workdir);
+    state.turns += 1;
+    let held = true;
+    return () => {
+      if (!held) return;
+      held = false;
+      state.turns -= 1;
+      if (state.turns) return;
+      state.idle?.resolve();
+      state.idle = null;
+      if (sharedProcess === shared) reloadDirectory(shared, state)?.catch(() => {});
+    };
+  }
+
+  async function admitDirectory(workdir) {
+    while (!directoryCurrent(workdir)) await waitForDirectory(workdir);
+    return holdDirectory(workdir);
+  }
+
+  function reloadChangedCredentials(shared) {
+    for (const directory of shared.server.client.instanceDirectories?.() || []) directoryState(shared, directory);
+    shared.generation += 1;
+    for (const state of shared.directories.values()) {
+      if (!state.turns) reloadDirectory(shared, state)?.catch(() => {});
+    }
+  }
+
+  function connectionRecord(connection) {
+    return { canonicalUrl: connection.canonicalUrl, endpointCode: connection.endpointCode, fingerprint: connection.fingerprint };
+  }
+
+  function sameConnection(recorded, connection) {
+    return recorded?.canonicalUrl === connection.canonicalUrl && recorded.fingerprint === connection.fingerprint &&
+      recorded.endpointCode === connection.endpointCode;
+  }
+
+  // A key changes in place; a provider route belongs to the server's configuration.
+  function inPlaceConnection(recorded, connection) {
+    return Boolean(connection?.apiKey) && (recorded
+      ? recorded.canonicalUrl === connection.canonicalUrl && recorded.endpointCode === connection.endpointCode
+      : !text(connection.canonicalUrl));
+  }
+
+  // The running server takes the host's saved connections without stopping its
+  // turns. Reading them inside this queue applies the newest saved state last.
+  function updateConnections(readConnections) {
+    const update = connectionUpdate.then(async () => {
+      const shared = sharedProcess;
+      if (!shared) return;
+      shared.connectionsCurrent = false;
+      let changed = false;
+      try {
+        const saved = new Map((await readConnections()).map(connection => [connection.modelProviderId, connection]));
+        for (const [providerId, connection] of saved) {
+          const recorded = shared.connections.get(providerId);
+          if (sameConnection(recorded, connection) || !inPlaceConnection(recorded, connection)) continue;
+          await shared.server.client.authenticateApiKey(providerId, connection.apiKey);
+          shared.connections.set(providerId, connectionRecord(connection));
+          changed = true;
+        }
+        for (const providerId of [...shared.connections.keys()]) {
+          if (saved.has(providerId)) continue;
+          await shared.server.client.removeAuthentication(providerId);
+          shared.connections.delete(providerId);
+          changed = true;
+        }
+        shared.connectionsCurrent = true;
+      } finally {
+        if (changed) reloadChangedCredentials(shared);
+      }
+    });
+    connectionUpdate = update.catch(() => {});
+    return update;
+  }
+
+  // `readConnections` returns the host's saved connections. Without it, a changed
+  // account needs a new server.
+  async function ensure(selected, start, readConnections = null) {
     await sharedProcessStop;
-    requireConnectionAvailable();
     if (failedStartup) await stop("opencode-startup-cleanup");
     if (sharedProcess) {
-      const currentConnection = sharedProcess.connections.get(selected?.modelProviderId);
-      if (!selected || (
-        currentConnection?.canonicalUrl === selected.canonicalUrl &&
-        currentConnection?.fingerprint === selected.fingerprint &&
-        currentConnection?.endpointCode === selected.endpointCode
-      )) {
+      const recorded = sharedProcess.connections.get(selected?.modelProviderId);
+      const current = !selected || sameConnection(recorded, selected);
+      if (current || (readConnections && inPlaceConnection(recorded, selected))) {
         const probe = AbortSignal.timeout(1_000);
+        let healthy = false;
         try {
           await sharedProcess.server.client.health({ signal: probe });
-          return sharedProcess;
+          healthy = true;
         } catch (error) {
           // A slow probe is not proof that the shared server stopped working.
           if (probe.aborted) throw error;
-          requireConnectionAvailable();
           await stop("opencode-health-check-failed");
         }
+        if (healthy && sharedProcess) {
+          if (readConnections && (!current || !sharedProcess.connectionsCurrent)) await updateConnections(readConnections);
+          return sharedProcess;
+        }
       } else {
         await stop("opencode-connection-changed");
       }
@@ -267,13 +396,14 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     if (sharedProcessStart) return sharedProcessStart;
     sharedProcessStart = Promise.resolve().then(async () => {
       const { connections, server } = await start();
-      sharedProcess = {
-        connections: new Map(connections.map(connection => [
-          connection.modelProviderId,
-          { canonicalUrl: connection.canonicalUrl, endpointCode: connection.endpointCode, fingerprint: connection.fingerprint }
-        ])),
-        server
+      const started = {
+        connections: new Map(connections.map(connection => [connection.modelProviderId, connectionRecord(connection)])),
+        connectionsCurrent: true, directories: new Map(), generation: 0, server
       };
+      sharedProcess = started;
+      // An unexpected exit retires the server's leftovers at once.
+      void server.unexpectedExit?.then(() => sharedProcess === started ? stop("opencode-server-exited") : null)
+        .catch(() => {});
       for (const target of processes.values()) {
         target.server = openCodeServerForDirectory(server, target.workdir);
         target.upstream = null;
@@ -291,6 +421,29 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     }
   }
 
+  // Native storage inventory and retirement borrow the shared server; they are
+  // not users that keep it running. A short idle after the last read lets one
+  // maintenance pass share it, then it stops unless a conversation uses it.
+  async function withStorageProcess(start, operation, failure = error => { throw error; }) {
+    clearTimeout(storageIdle);
+    storageIdle = null;
+    storageReads += 1;
+    try {
+      return await operation(await ensure(null, start).catch(failure));
+    } finally {
+      storageReads -= 1;
+      if (storageReads === 0 && !closed) {
+        storageIdle = setTimeout(() => {
+          storageIdle = null;
+          if (storageReads === 0 && processes.size === 0 && processStarts.size === 0) {
+            stop("opencode-storage-read-finished").catch(() => null);
+          }
+        }, storageIdleMs);
+        storageIdle.unref?.();
+      }
+    }
+  }
+
   function targetFor(key, prepared) {
     const current = processes.get(key);
     const nativeId = prepared.upstreamSessionId;
@@ -335,7 +488,6 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   }
 
   async function acquire(key, prepare, onFailure = async () => {}) {
-    requireConnectionAvailable();
     const pending = processStarts.get(key);
     if (pending) return pending;
     const start = Promise.resolve().then(async () => {
@@ -346,7 +498,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       if (processStarts.get(key) === start) processStarts.delete(key);
       if (!processes.has(key)) {
         await onFailure();
-        if (processes.size === 0 && processStarts.size === 0 && !failedStartup) {
+        if (processes.size === 0 && processStarts.size === 0 && storageReads === 0 && !failedStartup) {
           await stop("opencode-session-start-failed").catch(() => null);
         }
       }
@@ -365,7 +517,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       processes.delete(target.key);
       await onRemoved?.();
     }
-    return !retainSharedProcess && processes.size === 0 && processStarts.size === 0
+    return !retainSharedProcess && processes.size === 0 && processStarts.size === 0 && storageReads === 0
       ? stop()
       : { exited: true, sharedProcessRetained: true };
   }
@@ -444,7 +596,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       application.ownsTarget(target) && (!projectContextRoot || target.projectContextRoot === path.resolve(projectContextRoot))
     ));
     const results = await Promise.all(targets.map((target) => releaseProcessTarget(target, {}, application)));
-    if (processes.size === 0 && (sharedProcess || failedStartup)) {
+    if (processes.size === 0 && storageReads === 0 && (sharedProcess || failedStartup)) {
       results.push(await stop(text(input.reason) || "opencode-project-close").catch(application.failure));
     }
     return {
@@ -456,34 +608,23 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   async function invalidateRuntimes(input = {}, preparation) {
     if (text(input.reason) === "server-shutdown") {
       closed = true;
+      clearTimeout(storageIdle);
+      storageIdle = null;
     }
     const application = preparation.release;
     if (typeof input.publish === "function") {
-      requireConnectionAvailable();
-      connectionChanging = true;
-      try {
-        await Promise.all([...processStarts.values()].map(start => start.catch(() => null)));
-        await sharedProcessStart?.catch(() => null);
-        await application.assertConnectionChange?.();
-        const targets = [...processes.values()];
-        const providerId = text(input.modelProviderId);
-        if (!providerId || targets.some(target => text(target.modelProviderId) !== providerId || !application.ownsTarget(target))) {
-          throw Object.assign(new Error("Close the other OpenCode conversations that use this connection, then retry this connection change. The saved connection has not changed."), {
-            code: "assistant_opencode_connection_in_use", statusCode: 409
-          });
-        }
-        const results = [];
-        for (const target of targets) {
-          const proof = await releaseProcessTarget(target, { retainSharedProcess: true }, application);
-          if (proof?.exited === false || proof?.ok === false) throw new Error("OpenCode could not stop the selected conversation. Retry the connection change.");
-          results.push(proof);
-        }
-        if (sharedProcess || failedStartup) results.push(await stop("opencode-connection-changed"));
-        await input.publish();
-        return { closed: results.length, ok: true };
-      } finally {
-        connectionChanging = false;
+      if (typeof preparation.connections !== "function") {
+        throw new TypeError("OpenCode connection changes require the host's saved connections.");
       }
+      // Running turns, retained conversations and the shared server continue.
+      // The server takes the saved connections at once, and each directory
+      // reloads them as soon as it has no turn in flight.
+      await application.assertConnectionChange?.();
+      await input.publish();
+      const update = () => updateConnections(preparation.connections).catch(() => null);
+      void sharedProcessStart?.then(update, () => null);
+      await update();
+      return { closed: 0, ok: true };
     }
     await Promise.all([...processStarts.entries()]
       .filter(([key]) => key.includes("\0"))
@@ -532,7 +673,8 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     return acquire(prepared.key, async () => {
       const configured = await prepared.configure();
       const shared = await ensure(prepared.connection,
-        async () => startPreparedProcess(await configured.prepareServer())).catch(prepared.failure);
+        async () => startPreparedProcess(await configured.prepareServer()),
+        async () => (await configured.prepareServer()).connections).catch(prepared.failure);
       configured.target.server = shared.server;
       return targetFor(prepared.key, configured.target);
     }, prepared.onFailure).catch(prepared.failure);
@@ -545,13 +687,18 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
 
   async function runPreparedRenewalTurn(preparation) {
     const acquired = await acquirePrepared(await preparation.process());
-    const target = await ensureOpenCodeSession(acquired, preparation.session());
-    const turn = preparation.turn(target);
-    const result = await runOpenCodeConversationTurn(target.server.client, target.upstreamSessionId, turn.input, {
-      ...turn.options,
-      ...(turn.release ? { close: () => releaseProcessTarget(target, {}, turn.release) } : {})
-    });
-    return turn.completeResult(result);
+    const releaseDirectory = await admitDirectory(acquired.workdir);
+    try {
+      const target = await ensureOpenCodeSession(acquired, preparation.session());
+      const turn = preparation.turn(target);
+      const result = await runOpenCodeConversationTurn(target.server.client, target.upstreamSessionId, turn.input, {
+        ...turn.options,
+        ...(turn.release ? { close: () => releaseProcessTarget(target, {}, turn.release) } : {})
+      });
+      return turn.completeResult(result);
+    } finally {
+      releaseDirectory();
+    }
   }
 
   async function createPreparedConversation(prepared) {
@@ -569,6 +716,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       throw selection.profileChanged();
     }
     if (!conversationId && !selection.createIfMissing) throw selection.identityRequired();
+    if (!previous?.active) await currentDirectory(target.workdir);
     const selected = await selectConversation(prepared.key, target, conversationId, selection.input, selection.registration);
     return { ...selected, executionProfile: prepared.executionProfile, target };
   }
@@ -613,7 +761,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     });
     if (!result.deleted) return result;
     const cleanup = prepared.cleanupAfterDelete;
-    const providerExit = cleanup ? await closeSession(cleanup.sessionId, cleanup.options, cleanup.application) : null;
+    let providerExit = null;
+    if (cleanup) {
+      providerExit = await closeSession(cleanup.sessionId, cleanup.options, cleanup.application);
+      // The result carries the deleted scope's exit proof. Only renewal releases
+      // a kept proof, and a scope is never renewed, so none is kept.
+      processExitProofs.delete(cleanup.sessionId);
+    }
     return { conversationId, deleted: true, ok: providerExit?.ok !== false,
       ...(providerExit ? { providerExit } : {}) };
   }
@@ -810,12 +964,15 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         deliveryMode: "steer"
       };
     }
+    // A new native turn starts only on its directory's current credentials.
+    while (!tracked.active && !directoryCurrent(target.workdir)) await waitForDirectory(target.workdir);
     if (tracked.active) {
       throw Object.assign(new Error("This conversation is still working."), {
         code: "assistant_opencode_conversation_busy", details: {}, statusCode: 409
       });
     }
     tracked.active = true;
+    const releaseDirectory = holdDirectory(target.workdir);
     tracked.error = null;
     tracked.interrupted = false;
     const turnAbort = new AbortController();
@@ -842,10 +999,14 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         beforeDispatch: options.beforeDispatch
       });
     } catch (error) {
-      await events.close();
-      tracked.error = error;
-      if (tracked.promptAttempted) await stopUnobservedSession(observedTarget, conversationId);
-      tracked.active = false;
+      try {
+        await events.close();
+        tracked.error = error;
+        if (tracked.promptAttempted) await stopUnobservedSession(observedTarget, conversationId);
+        tracked.active = false;
+      } finally {
+        releaseDirectory();
+      }
       throw error;
     }
     tracked.inputMessageId = text(admitted.id);
@@ -872,6 +1033,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       }
       return result;
     })();
+    void tracked.completion.then(releaseDirectory, releaseDirectory);
     // Keep a failed admitted turn observable to the client's conversation reads.
     void tracked.completion.catch((error) => {
       if (tracked.abortController === turnAbort) tracked.error = error;
@@ -1108,6 +1270,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     try {
       const preparation = await application.prepare({ overwrite: !currentMonitor, threadId: currentThreadId });
       const preparedTarget = preparation.process ? await acquirePrepared(preparation.process) : preparation.target;
+      if (!monitors.get(key)) await currentDirectory(preparedTarget.workdir);
       target = await ensureOpenCodeSession(preparedTarget, preparation.session);
       currentThreadId = target.upstreamSessionId;
       if (startingTurn) {
@@ -1139,6 +1302,16 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
             turn: openCodeTurnSnapshot(turns.get(key), currentThreadId) } };
         }
       }
+      // A new native turn starts only on its directory's current credentials;
+      // the wait, if any, is for that directory's own running turns.
+      while (!currentMonitor && !directoryCurrent(target.workdir)) {
+        await waitForDirectory(target.workdir);
+        currentMonitor = monitors.get(key);
+        if (currentMonitor && !turns.get(key)?.active) {
+          await currentMonitor;
+          currentMonitor = monitors.get(key);
+        }
+      }
       admission = Promise.withResolvers();
       // The observer may be between polls when dispatch or persistence fails.
       // Keep the raw promise rejectable without an unhandled rejection.
@@ -1364,6 +1537,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     return monitor;
   }
 
+  // A removed connection's models are gone from its reloaded directory.
+  function disconnectedProviderFailure(failure) {
+    const providerId = /\bModel not found: ([^/\s]+)\//u.exec(failure)?.[1];
+    return providerId && sharedProcess && !sharedProcess.connections.has(providerId)
+      ? `${providerId} isn't connected. Connect it again, then send your message again.` : "";
+  }
+
   function beginMonitor(key, target, turn, {
     observe, observation, eventReady, readiness, finalResponse,
     writeRun, projectMessages, completeResult, onRetired
@@ -1378,6 +1558,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       registeredTarget.upstreamSessionId === target.upstreamSessionId ? registeredTarget : null;
     const finalAssistantResultProcess = finalAssistantResultTarget ? sharedProcess : null;
     turns.set(key, turn);
+    const releaseDirectory = holdDirectory(target.workdir);
     const signal = AbortSignal.any([target.abortController.signal, turn.abortController.signal]);
     const monitor = Promise.resolve().then(async () => {
       const events = observation
@@ -1445,7 +1626,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
             failure = "OpenCode finished without a user-facing final response. Please send your message again.";
             finalState = "failed";
           } else if (failure) {
-            credentialFailure = openCodeCredentialFailure(failure);
+            const disconnected = disconnectedProviderFailure(failure);
+            failure = disconnected || failure;
+            credentialFailure = Boolean(disconnected) || openCodeCredentialFailure(failure);
             finalState = "failed";
           } else if (turn.interruptRequested) {
             finalState = "interrupted";
@@ -1465,7 +1648,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         } else {
           const cause = signal.aborted ? signal.reason : error;
           failure = text(cause?.message) || "OpenCode turn failed.";
-          credentialFailure = openCodeCredentialFailure(failure);
+          const disconnected = disconnectedProviderFailure(failure);
+          failure = disconnected || failure;
+          credentialFailure = Boolean(disconnected) || openCodeCredentialFailure(failure);
           providerApiFailure = openCodeProviderApiFailure(cause);
           finalState = target.abortController.signal.aborted
             ? "cancelled"
@@ -1506,6 +1691,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       if (monitors.get(key) === monitor) {
         monitors.delete(key);
       }
+      releaseDirectory();
       onRetired();
     });
     monitors.set(key, monitor);
@@ -1713,6 +1899,8 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
 
   async function ensurePreparedTerminal(preparation) {
     const target = await acquirePreparedTerminal(preparation);
+    // The native terminal starts its own turns there.
+    await currentDirectory(target.workdir);
     return ensureOpenCodeSession(target, preparation.session());
   }
 
@@ -1767,7 +1955,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     get current() { return sharedProcess; },
     get closed() { return closed; },
     get cleanupPending() { return Boolean(failedStartup); },
-    acquire, targetFor, ensure, release, releaseTarget, releaseProcessTarget, closeSession, closeProject,
+    acquire, targetFor, ensure, withStorageProcess, release, releaseTarget, releaseProcessTarget, closeSession, closeProject,
     startPreparedProcess, acquirePrepared, createPreparedConversation, runPreparedRenewalTurn, selectPreparedConversation, existingPreparedConversation,
     runPreparedConversationTurn, readPreparedConversation, waitPreparedConversationTurn, stopPreparedConversation, deletePreparedConversation,
     sendPreparedMessage, inspectPreparedMessage, interruptPreparedTurn,

package/src/server/conversation/providers/claudeDriver.js

@@ -258,13 +258,13 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       return conversation.read(context, representation, nativeResult);
     },
     inspectTemporaryActivity({ native, context }) {
-      return native.owner.hasActiveTemporaryConversation(context, { acquire: native.owner.acquire });
+      return native.owner.hasActiveTemporaryConversation(context);
     },
     releaseRenewalPredecessorProcessExitProof({ native, context }) {
-      return native.owner.closeSession(context, native.application);
+      return native.owner.releaseSession(context, native.application);
     },
     releaseRenewalSuccessorProcessExitProof({ native, context }) {
-      return native.owner.closeSession(context, native.application);
+      return native.owner.releaseSession(context, native.application);
     },
     async generateRenewalHandover({ native, input, context }) {
       const prepared = native.preparation.handover(input, context);
@@ -432,7 +432,8 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
           if (supplied) {
             await acquire(context);
             const result = await owner.inspectAdmission(await acquire(context), input);
-            return representation === "native" ? result : { accepted: result.admission === "accepted" };
+            return representation === "native" ? result
+              : { accepted: result.admission === "accepted", notAdmitted: result.admission === "not-admitted" };
           }
           if (verifyAccount === true) {
             const binding = input.receiptBinding;
@@ -446,7 +447,8 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
           }
           const history = await owner.readHistory(entry);
           const nativeId = claudeNativeMessageId(input.messageId);
-          return { accepted: history.userIds.includes(nativeId),
+          const accepted = history.userIds.includes(nativeId);
+          return { accepted, notAdmitted: !accepted && owner.nativeWorkSettled(entry),
             messages: history.messages.filter(message => message.userId === nativeId) };
         },
         steer: command => owner.steer(control, command, commandOptions),

package/src/server/conversation/providers/codexDriver.js

@@ -126,10 +126,11 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       runtime: createCodexAppServerRuntime({ credentials, execution: processExecution, configuration }) };
   }
 
-  async function nativeStorageProvider({ sessionId, native, binding, context }) {
+  // Storage work borrows the shared process; it is not a user that keeps it running.
+  async function withNativeStorageProvider({ sessionId, native, binding, context }, operation) {
     const prepared = await native.preparation.storage(sessionId, binding, context);
-    return { provider: await native.providerOwner.ensureSession(prepared.providerContext),
-      toolHomeSource: prepared.toolHomeSource };
+    return native.providerOwner.withTransientSession(prepared.providerContext,
+      provider => operation(provider, prepared.toolHomeSource));
   }
 
   async function disposeNative({ sessionId, namespace, native, options }) {
@@ -160,17 +161,17 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
     deleteDetachedConversation({ sessionId, native, input, context }) {
       return native.runOwner.deleteDetachedThread(sessionId, input, context);
     },
-    async listConversationStorage(prepared) {
-      const { provider } = await nativeStorageProvider(prepared);
+    listConversationStorage(prepared) {
       const { binding } = prepared;
-      return (await provider.listNativeThreadsForCwd(binding.workdir)).map((conversationId) => ({ ...binding, conversationId }));
+      return withNativeStorageProvider(prepared, async provider =>
+        (await provider.listNativeThreadsForCwd(binding.workdir)).map((conversationId) => ({ ...binding, conversationId })));
     },
-    async retireConversationHistory(prepared) {
-      const { provider, toolHomeSource } = await nativeStorageProvider(prepared);
-      return retireCodexConversationHistory(provider, prepared.binding, {
-        toolHomeSource, beforeDelete: prepared.context.beforeDelete, signal: prepared.context.signal,
-        errorPrefix: prepared.native.errorPrefix
-      });
+    retireConversationHistory(prepared) {
+      return withNativeStorageProvider(prepared, (provider, toolHomeSource) =>
+        retireCodexConversationHistory(provider, prepared.binding, {
+          toolHomeSource, beforeDelete: prepared.context.beforeDelete, signal: prepared.context.signal,
+          errorPrefix: prepared.native.errorPrefix
+        }));
     },
     invalidateRuntimes({ native, input }) {
       return native.runOwner.invalidateRuntimes(input, native.preparation);
@@ -217,10 +218,16 @@ export function createCodexConversationDriver({ connections, host = {}, limits =
       return native.runOwner.ensureSessionReadiness(sessionId, await native.preparation.readiness());
     },
     async updateConversationSettings({ sessionId, native, context, input }) {
-      const acquired = await native.runOwner.conversationContext(sessionId, { conversationId: input.threadId }, context);
-      if (acquired.ok === false) return acquired;
-      await acquired.provider.updateThreadSettings(input.threadId, { model: input.model, effort: input.effort });
-      return { ok: true };
+      // Changing a thread's settings is not a use that keeps Codex running.
+      const borrow = { release() {} };
+      try {
+        const acquired = await native.runOwner.conversationContext(sessionId, { conversationId: input.threadId }, context, borrow);
+        if (acquired.ok === false) return acquired;
+        await acquired.provider.updateThreadSettings(input.threadId, { model: input.model, effort: input.effort });
+        return { ok: true };
+      } finally {
+        borrow.release();
+      }
     },
     async createConversation({ sessionId, native, input, context }) {
       return native.runOwner.createConversation(sessionId, input, context);