@jskit-ai/assistant-core 0.1.224 → 0.1.226

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.224",
+    "@jskit-ai/assistant-core": "0.1.226",
     "@jskit-ai/http-runtime": "0.1.242",
     "@jskit-ai/kernel": "0.1.244",
     "@mdi/js": "^7.4.47",

package/fixtures/responsive-assistant/DeliveryFixture.vue

@@ -26,8 +26,9 @@ const delivery = createAssistantMessageDelivery({ deliver(payload) {
 } });
 function accept() {
   const payload = requests.value.at(-1);
-  turns.value = [...turns.value, { turnId: payload.messageId, user: { messageId: payload.messageId, text: payload.message },
-    assistant: { text: "Accepted once." } }];
+  const at = new Date().toISOString();
+  turns.value = [...turns.value, { turnId: payload.messageId, user: { messageId: payload.messageId, text: payload.message, at },
+    assistant: { text: "Accepted once.", at } }];
   pendingRequest.resolve({ ok: true });
 }
 if (recoveryFixture) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.224",
+  "version": "0.1.226",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"

package/src/client/conversation/AssistantTranscript.vue

@@ -608,16 +608,18 @@ const displayEntries = computed(() => {
       }, key);
       if (!displayed) continue;
       candidates.push({ key, role, turn: { ...turn, turnId }, message: displayed,
+        sortAt: turn.optimistic && turn.optimistic.id === message.messageId ? NaN : Date.parse(message.at),
         delivery: role === "user" ? userDelivery : null });
     }
   }
   // Native streaming turns and saved authored turns can arrive independently.
-  // Only dated entries participate; undated notices retain their original slot.
-  const dated = candidates.filter(entry => Number.isFinite(Date.parse(entry.message.at)))
-    .sort((a, b) => Date.parse(a.message.at) - Date.parse(b.message.at))[Symbol.iterator]();
+  // Local queued timestamps can precede an earlier message's native admission.
+  // Keep their supplied positions, along with undated notices.
+  const dated = candidates.filter(entry => Number.isFinite(entry.sortAt))
+    .sort((a, b) => a.sortAt - b.sortAt)[Symbol.iterator]();
   const entries = [];
   for (const candidate of candidates) {
-    const entry = Number.isFinite(Date.parse(candidate.message.at)) ? dated.next().value : candidate;
+    const entry = Number.isFinite(candidate.sortAt) ? dated.next().value : candidate;
     const previous = entries.at(-1);
     if (entry.role === "thinking" && previous?.role === "thinking") previous.messages.push({ ...entry.message, key: entry.key });
     else entries.push({ ...entry, ...(entry.role === "thinking" ? { messages: [{ ...entry.message, key: entry.key }] } : {}) });

package/src/server/conversation/agentRun.js

@@ -63,6 +63,18 @@ export function conversationAgentRunEvent(previous, normalizedRunId, {
   return record;
 }
 
+/** Explicit offline copy only: the destination has no inherited execution. */
+export function prepareCopiedConversationAgentRun(run, { at }) {
+  const active = runStateIsActive(run.state);
+  if (!active && run.providerGoalStatus !== "active") return structuredClone(run);
+  return conversationAgentRunEvent(run, run.id, {
+    event: { at, kind: "development-copy", message: "Copied into a stopped development environment." },
+    patch: { state: active ? "interrupted" : run.state, providerPhase: "",
+      ...(active ? { providerStatus: "interrupted", pendingUserMessageClientIds: [], finishedAt: at } : {}),
+      ...(run.providerGoalStatus === "active" ? { providerGoalStatus: "paused" } : {}) }
+  });
+}
+
 /** The original native run occupies its bound conversation segment. Reading a
  * binding without a run never constructs historical ownership or writes state.
  */

package/src/server/conversation/claudeProcess.js

@@ -180,13 +180,15 @@ export async function stopClaudeCodeProcess({ process: native, executionId, stop
   return { ...proof, exited: true };
 }
 
-export async function bindClaudeConversationAccount(entry, { identity, providerId, stop, save }) {
+export async function bindClaudeConversationAccount(entry, { identity, providerId, allowAccountChange = false, stop, save }) {
   entry.accountIdentities ||= {};
   if (!nativeAiProvider(providerId) && entry.accountIdentities[providerId] && entry.accountIdentities[providerId] !== identity) {
     await stop(entry, "The signed-in Claude account changed.");
-    throw Object.assign(new Error("This conversation belongs to another Claude account. Reconnect that account or start a new session."), {
-      code: "claude_account_changed"
-    });
+    if (!allowAccountChange) {
+      throw Object.assign(new Error("This conversation belongs to another Claude account. Reconnect that account or start a new session."), {
+        code: "claude_account_changed"
+      });
+    }
   }
   if (entry.accountIdentity !== identity) {
     entry.accountIdentity = identity;

package/src/server/conversation/claudeTurn.js

@@ -126,8 +126,8 @@ export function createClaudeConversationGoals({ conversationId, readHistory, rea
       if (!objective || objective.length > 4000 || /^(clear|stop|off|reset|none|cancel)$/iu.test(objective)) {
         throw goalError("Enter a goal condition of up to 4,000 characters.");
       }
-      if (readState().active || (action === "set" && goal && goal.status !== "complete")) {
-        throw goalError("Stop the current turn and cancel the existing goal before setting another.");
+      if (action === "set" && goal && goal.status !== "complete") {
+        throw goalError("Cancel the existing goal before setting another.");
       }
       await sendGoal({ message: `/goal ${objective}` });
     } else throw goalError("Unknown Claude goal action.");
@@ -264,7 +264,7 @@ export function createClaudeConversationOwner({
     const providerId = account.providerId;
     if (entry.accountIdentity !== identity) entry.nativeTurn.invalidateFinalAssistantResult();
     try {
-      await bindClaudeConversationAccount(entry, { identity, providerId,
+      await bindClaudeConversationAccount(entry, { identity, providerId, allowAccountChange: account.allowAccountChange === true,
         stop: (entry, reason) => entry.nativeTurn.stopProcess(reason, { preparing: true }), save: saveAccount });
     } catch (failure) {
       if (failure.code !== "claude_account_changed") throw failure;
@@ -1434,6 +1434,11 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       // A completed main loop can still own background work. There is no
       // generation left to interrupt or second terminal result to wait for.
       if (outcome && inFlight.size === 0) {
+        // The next input owns completion now. A task finishing during host
+        // preparation must not settle this turn using the previous result.
+        outcome = null;
+        acceptedInput = null;
+        clearFinalAssistantResult();
         await publish({ type: "diagnostic", stage: "steering_background_only", backgroundTasks: tasks.size });
         return;
       }

package/src/server/conversation/index.js

@@ -3,13 +3,13 @@ export { conversationMessageIdentity, conversationMessageVersion, conversationHi
 export { createMemoryConversationStorage } from "./memoryStorage.js";
 export { createConversationStorage, createReentrantConversationStorage,
   createConversationOperationLease, beginConversationOperation, finishConversationOperation } from "./storage.js";
-export { conversationAgentRunRecord, conversationAgentRunEvent } from "./agentRun.js";
+export { conversationAgentRunRecord, conversationAgentRunEvent, prepareCopiedConversationAgentRun } from "./agentRun.js";
 export { createFileConversationStorage } from "./fileStorage.js";
 export { createConversationStreams } from "./streams.js";
 export { createConversationSystemPrompt } from "./systemPrompt.js";
 export { createConversationRuntime } from "./runtime.js";
 export { normalizeConversationConfiguration } from "./configuration.js";
-export { upgradeConversationRuntimeState } from "./runtimeStateUpgrade.js";
+export { upgradeConversationRuntimeState, prepareConversationRuntimeCopy } from "./runtimeStateUpgrade.js";
 export { createConversationHookBridge } from "./hookBridge.js";
 export { nativeConversationStoragePolicy } from "./nativeStorage.js";
 export { createConversationProcessIdentity } from "./localExecution.js";

package/src/server/conversation/openCodeRuntime.js

@@ -248,10 +248,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         currentConnection?.fingerprint === selected.fingerprint &&
         currentConnection?.endpointCode === selected.endpointCode
       )) {
+        const probe = AbortSignal.timeout(1_000);
         try {
-          await sharedProcess.server.client.health({ signal: AbortSignal.timeout(1_000) });
+          await sharedProcess.server.client.health({ signal: probe });
           return sharedProcess;
-        } catch {
+        } 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");
         }
@@ -1567,12 +1570,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       const observedProcess = sharedProcess;
       const observedServer = target.server;
       let healthy = false;
+      const probe = AbortSignal.timeout(1_000);
       try {
-        await target.server.client.health({ signal: AbortSignal.timeout(1_000) });
+        await target.server.client.health({ signal: probe });
         healthy = true;
         ready = Boolean(await target.server.client.readSession(target.upstreamSessionId));
       } catch (error) {
-        if (healthy && error?.statusCode !== 404) {
+        if ((!healthy && probe.aborted) || (healthy && error?.statusCode !== 404)) {
           throw error;
         }
         if (!healthy) {

package/src/server/conversation/runtimeStateUpgrade.js

@@ -1,4 +1,5 @@
 import { isAbsolute } from "node:path";
+import { prepareCopiedConversationAgentRun } from "./agentRun.js";
 
 const engines = new Set(["api", "claude", "codex", "opencode"]);
 const object = value => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -198,3 +199,44 @@ export function upgradeConversationRuntimeState({ metadata, conversationLog, ret
   runtime.lastEngine = lastEngine;
   return { metadata: { ...metadata, runtime }, changed: true, warnings };
 }
+
+/** Explicit destination-only operation. The caller first stops all copied
+ * processes and pauses native goals through their owners; this makes their
+ * saved projections inert without opening a provider or replaying requests.
+ */
+export async function prepareConversationRuntimeCopy(transaction, { at }) {
+  if (typeof at !== "string" || !Number.isFinite(Date.parse(at))) throw new TypeError("A copy timestamp is required.");
+  const metadata = structuredClone(await transaction.readMetadata());
+  const turns = await Promise.all((await transaction.listTurnIds()).map(id => transaction.readTurn(id)));
+  const runtime = metadata.runtime;
+  if (runtime) {
+    if (runtime.version !== 3) invalid("Upgrade the parent conversation before copying its runtime state.");
+    upgradeConversationRuntimeState({ metadata, conversationLog: turns });
+    if (runtime.replacement) invalid("Finish the parent conversation changeover before copying it.");
+    for (const segment of [...runtime.predecessors, runtime]) {
+      if (segment.binding) {
+        // Native history identity and paths remain valid in the identical guest
+        // layout; process handles belong exclusively to the original machine.
+        if (Object.hasOwn(segment.binding, "executionId")) segment.binding.executionId = "";
+        if (Object.hasOwn(segment.binding, "processDirectory")) segment.binding.processDirectory = "";
+        if (segment.binding.codexAppServerRun) {
+          segment.binding.codexAppServerRun = prepareCopiedConversationAgentRun(segment.binding.codexAppServerRun, { at });
+        }
+      }
+      if (segment.nativeTurn) {
+        if (segment.nativeTurn.active) Object.assign(segment.nativeTurn, {
+          active: false, state: "interrupted", status: "interrupted", runState: "interrupted", phase: "", completedAt: at, updatedAt: at
+        });
+        if (segment.nativeTurn.goalStatus === "active") segment.nativeTurn.goalStatus = "paused";
+      }
+      if (segment.request) segment.request.error = "Copied pending input was not replayed. Check its delivery before submitting again.";
+    }
+    await transaction.writeMetadata(metadata);
+  }
+  for (const turn of turns) {
+    if (turn.metadata?.runtime?.status === "running") {
+      await transaction.updateTurnMetadata(turn.turnId, { runtime: { ...turn.metadata.runtime,
+        status: "interrupted", error: "Copied into a stopped development environment. This request was not replayed." } });
+    }
+  }
+}

package/test/claudeConversationSession.test.js

@@ -1059,6 +1059,25 @@ test("Claude native goal commands use ordinary admission, pause retains the goal
   await assert.rejects(f.conversation.updateGoal({ ...start, messageId: "budget", tokenBudget: 100 }), /token budget/u);
 });
 
+test("Claude accepts a goal during an active turn through the existing steering path", async t => {
+  const f = await fixture(t);
+  await f.conversation.send({ messageId: "working", text: "wait" });
+  const { segmentId } = await f.conversation.read();
+  assert.equal(await f.conversation.readGoal(), null);
+  const command = { action: "set", objective: "Finish the current work", messageId: "working-goal", expectedSegmentId: segmentId };
+  assert.equal((await f.conversation.updateGoal(command)).status, "accepted");
+  const goal = await f.conversation.readGoal();
+  assert.equal(goal.objective, command.objective);
+  assert.equal(goal.status, "active");
+  assert.equal((await f.conversation.updateGoal(command)).duplicate, true);
+  await assert.rejects(f.conversation.updateGoal({ ...command, messageId: "another-goal", objective: "Replace it" }), /cancel the existing goal/i);
+  const trace = await f.trace();
+  assert.equal(trace.filter(row => row.args?.includes("--print")).length, 1);
+  assert.deepEqual(trace.filter(row => row.frame?.type === "user").map(row => row.frame.message.content),
+    ["wait", "/goal Finish the current work"]);
+  assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 1);
+});
+
 test("Claude rejects reserved goals and waits for ordinary Send to deliver a replacement briefing", async t => {
   const f = await fixture(t);
   let state = await f.conversation.read();

package/test/claudeTurn.test.js

@@ -135,6 +135,21 @@ test("interruption does not claim process exit or complete work on a control ack
   assert.equal(turn.read().text, "Resumed");
 });
 
+test("Claude steering survives background completion while the follow-up is being prepared", async () => {
+  const { turn, send, client, events } = fixture();
+  await send();
+  await turn.receive({ type: "system", subtype: "task_started", task_id: "build", task_type: "local_bash" });
+  await turn.receive({ type: "result", subtype: "success", result: "Build started" });
+  client.interrupt = () => assert.fail("The generation has already completed");
+  await turn.interruptGeneration(client);
+  await turn.receive({ type: "system", subtype: "task_notification", task_id: "build", status: "completed" });
+  assert.equal(events.some(event => event.type === "settled"), false, "The reserved steering input still needs admission");
+  await send("follow-up");
+  await turn.receive({ type: "result", subtype: "success", result: "Revised answer" });
+  assert.equal(turn.read().status, "completed");
+  assert.equal(turn.read().text, "Revised answer");
+});
+
 test("lost acknowledgement stays uncertain and stop rejects pending admission", async () => {
   const { turn, client, send } = fixture();
   client.send = async () => {};

package/test/conversationRuntimeStateUpgrade.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { upgradeConversationRuntimeState } from "../src/server/conversation/runtimeStateUpgrade.js";
+import { upgradeConversationRuntimeState, prepareConversationRuntimeCopy } from "../src/server/conversation/runtimeStateUpgrade.js";
+import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
+import { codexAppServerTurnStateFromAgentRun } from "../src/server/conversation/codexTurnState.js";
 
 const configuration = { systemPrompt: "Retained instructions", model: "saved-model" };
 const request = { messageId: "uncertain", text: "Authored text", origin: "user", attachments: [{ attachmentId: "file" }],
@@ -19,6 +21,72 @@ const record = (engine = "claude", extra = {}) => ({
     messages: [{ role: "user", text: "Accepted before model selection", messageId: "old-message" }] }]
 });
 
+test("a stopped development copy preserves native identity, history and uncertain input without retaining active execution", async () => {
+  const at = "2026-10-15T00:00:00.000Z";
+  for (const engine of ["api", "codex", "claude", "opencode"]) {
+    const value = record(engine, { version: 3, lastEngine: engine,
+      ...(engine === "api" ? {} : { request: { ...request, inspectionOnly: true,
+        threadId: engine === "codex" ? "saved-thread" : engine === "claude" ? "saved-conversation" : "saved-session" } }),
+      nativeTurn: { active: true, state: "active", phase: "working", goalStatus: "active" } });
+    if (value.metadata.runtime.binding) Object.assign(value.metadata.runtime.binding = { ...value.metadata.runtime.binding }, {
+      executionId: "parent-process", processDirectory: "/parent/process" });
+    if (engine === "codex") value.metadata.runtime.binding.codexAppServerRun = {
+      id: "codex_app_server", state: "active", providerThreadId: "saved-thread", providerTurnId: "native-turn",
+      providerStatus: "inProgress", providerGoalStatus: "active", pendingUserMessageClientIds: ["pending"], events: []
+    };
+    const before = structuredClone(value);
+    const storage = createMemoryConversationStorage();
+    await storage.write("copy", async transaction => {
+      await transaction.writeMetadata(value.metadata);
+      await transaction.appendMessage("turn", { role: "user", text: "Existing question", messageId: "authored", at,
+        turnMetadata: { runtime: { engine, segmentId: `${engine}-segment`, status: "running" } } });
+    });
+    await storage.write("copy", transaction => prepareConversationRuntimeCopy(transaction, { at }));
+    const copied = await storage.read("copy", async transaction => ({
+      metadata: await transaction.readMetadata(), turn: await transaction.readTurn("turn")
+    }));
+    const saved = copied.metadata.runtime;
+    assert.deepEqual(value, before, "The parent input is never mutated");
+    assert.equal(saved.segmentId, before.metadata.runtime.segmentId);
+    assert.deepEqual(saved.configuration, configuration);
+    assert.equal(saved.nativeTurn.active, false);
+    assert.equal(saved.nativeTurn.goalStatus, "paused");
+    assert.equal(copied.turn.metadata.runtime.status, "interrupted");
+    assert.equal(copied.turn.messages[0].text, "Existing question");
+    if (engine !== "api") {
+      assert.equal(saved.binding.executionId, "");
+      assert.equal(saved.binding.processDirectory, "");
+      assert.equal(saved.request.text, request.text);
+      assert.equal(saved.request.inspectionOnly, true);
+      assert.deepEqual(saved.request.attachments, request.attachments);
+      assert.match(saved.request.error, /not replayed/);
+    }
+    if (engine === "codex") {
+      assert.equal(saved.binding.threadId, "saved-thread");
+      const turn = codexAppServerTurnStateFromAgentRun(saved.binding.codexAppServerRun);
+      assert.equal(turn.active, false);
+      assert.equal(turn.goalStatus, "paused");
+      assert.equal(turn.turnId, "native-turn");
+      assert.deepEqual(saved.binding.codexAppServerRun.pendingUserMessageClientIds, []);
+    }
+    await storage.write("copy", transaction => prepareConversationRuntimeCopy(transaction, { at }));
+    assert.deepEqual(await storage.read("copy", transaction => transaction.readMetadata()), copied.metadata);
+  }
+});
+
+test("development copy rejects incomplete changeover and older runtime before writing", async () => {
+  for (const metadata of [record().metadata, record("claude", {
+    version: 3, lastEngine: "claude", replacement: { ...segment("claude"), request: { operationId: "pending" } }
+  }).metadata]) {
+    let wrote = false;
+    await assert.rejects(prepareConversationRuntimeCopy({
+      readMetadata: async () => metadata, listTurnIds: async () => [],
+      writeMetadata: async () => { wrote = true; }
+    }, { at: "2026-10-15T00:00:00Z" }), /Upgrade the parent|Finish the parent/);
+    assert.equal(wrote, false);
+  }
+});
+
 test("offline conversion preserves exact native bindings and authored requests without inventing a prompt", () => {
   const value = record("claude", { predecessors: [segment("codex", { request: structuredClone(request) })] });
   const before = structuredClone(value);

package/test/messageDelivery.browser.test.js

@@ -54,6 +54,21 @@ test("the shared element renders delayed sends and supplies retry, edit and canc
       await expect(input).toHaveValue("Retain this.");
       await expect(page.getByText("Cancel this question.", { exact: true })).toHaveCount(0);
       await page.goto(`${vite.baseURL}/?delivery=1&queue=1`);
+      await send("Admit this first.");
+      await send("Keep this queued second.");
+      const userRows = page.locator(".assistant-transcript__message--user");
+      await expect(userRows.nth(0)).toContainText("Admit this first.");
+      await expect(userRows.nth(1)).toContainText("Keep this queued second.");
+      await page.getByRole("button", { name: "Accept request" }).click();
+      await expect(page.getByText("Pending", { exact: true })).toHaveCount(1);
+      await expect(userRows.nth(0)).toContainText("Admit this first.");
+      await expect(userRows.nth(1)).toContainText("Keep this queued second.");
+      await expect.poll(async () => JSON.parse(await page.locator("[data-requests]").textContent()).length).toBe(2);
+      await page.getByRole("button", { name: "Accept request" }).click();
+      await expect(page.getByText("Pending", { exact: true })).toHaveCount(0);
+      await expect(userRows.nth(0)).toContainText("Admit this first.");
+      await expect(userRows.nth(1)).toContainText("Keep this queued second.");
+      await page.goto(`${vite.baseURL}/?delivery=1&queue=1`);
       await send("First steer.");
       await send("Second steer.");
       await send("Third steer.");

package/test/openCodeRuntime.test.js

@@ -3,6 +3,7 @@ import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
 import { createOpenCodeSharedRuntime, ensureOpenCodeSession, openCodeServerForDirectory, readOpenCodeEnvironments } from "../src/server/conversation/openCodeRuntime.js";
 import { createOpenCodeServerClient } from "../src/server/conversation/openCodeClient.js";
 
@@ -13,7 +14,7 @@ function fixture(options = {}) {
   const start = async selected => {
     const server = {
       client: {
-        async health() { return { healthy: true }; },
+        async health(input) { return options.health ? options.health(input) : { healthy: true }; },
         async interrupt(id) { return options.interrupt ? options.interrupt(id) : true; },
         async sessionStatus() { return { type: "idle" }; },
         forDirectory(directory) { return { ...this, directory }; }
@@ -252,6 +253,75 @@ test("a pending OpenCode session start retains the shared server while another s
   assert.equal(f.stops.length, 1);
 });
 
+test("a timed-out shared health probe preserves active conversations and allows retry", async () => {
+  let slow = false;
+  const f = fixture({ health: async ({ signal }) => {
+    if (slow) await delay(5_000, undefined, { signal });
+    return { healthy: true };
+  } });
+  const main = await f.acquire("main");
+  const helper = await f.acquire("helper");
+  const turn = { active: true, id: "turn", threadId: "main-thread" };
+  const temporary = { active: true, target: helper, conversationId: "helper-thread" };
+  f.runtime.turns.set(main.key, turn);
+  f.runtime.temporaryConversations.set("helper-thread", temporary);
+  const shared = f.runtime.current;
+  slow = true;
+  await assert.rejects(f.acquire("next"), { name: "AbortError" });
+  assert.equal(f.runtime.current, shared);
+  assert.equal(f.stops.length, 0);
+  assert.equal(f.starts.length, 1);
+  assert.equal(main.abortController.signal.aborted, false);
+  assert.equal(helper.abortController.signal.aborted, false);
+  assert.equal(f.runtime.turns.get(main.key), turn);
+  assert.equal(f.runtime.temporaryConversations.get("helper-thread"), temporary);
+  assert.equal(turn.active, true);
+  assert.equal(temporary.active, true);
+  assert.equal(f.runtime.processStarts.size, 0);
+  slow = false;
+  await f.acquire("next");
+  assert.equal(f.starts.length, 1);
+});
+
+test("a timed-out readiness probe does not classify the shared process as unhealthy", async () => {
+  let slow = false;
+  const f = fixture({ health: async ({ signal }) => {
+    if (slow) await delay(5_000, undefined, { signal });
+    return { healthy: true };
+  } });
+  const target = await f.acquire("main");
+  const selection = { modelProviderId: "provider", modelId: "model", catalogRevision: "catalog" };
+  Object.assign(target, { upstream: { id: "thread" }, upstreamSessionId: "thread", selection,
+    upstreamSelection: selection, canonicalUrl: f.connection.canonicalUrl,
+    connectionFingerprint: f.connection.fingerprint, endpointCode: f.connection.endpointCode });
+  target.server.client.readSession = async () => ({ id: "thread" });
+  const input = { selection, workdir: target.workdir, connection: f.connection,
+    refresh: async () => target, changed: () => new Error("Changed") };
+  slow = true;
+  await assert.rejects(f.runtime.inspectSessionReadiness(target, input), { name: "AbortError" });
+  assert.equal(f.stops.length, 0);
+  assert.equal(target.abortController.signal.aborted, false);
+  slow = false;
+  assert.deepEqual(await f.runtime.inspectSessionReadiness(target, input), {
+    ready: true, unhealthyProcess: null, missingUpstream: false
+  });
+});
+
+test("a refused shared health connection still replaces the stopped server", async () => {
+  let refused = false;
+  const f = fixture({ health: async () => {
+    if (refused) throw new TypeError("fetch failed", { cause: { code: "ECONNREFUSED" } });
+    return { healthy: true };
+  } });
+  await f.acquire("first");
+  const original = f.runtime.current;
+  refused = true;
+  await f.acquire("next");
+  assert.equal(f.stops.length, 1);
+  assert.equal(f.starts.length, 2);
+  assert.notEqual(f.runtime.current, original);
+});
+
 test("OpenCode failed acquisition cleans application state once before stopping an unused server", async () => {
   const f = fixture();
   const ready = Promise.withResolvers();