@jskit-ai/assistant-core 0.1.223 → 0.1.225

package/test/conversationRuntime.test.js

@@ -3,7 +3,7 @@ import test from "node:test";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { createConversationHookBridge } from "../src/server/conversation/index.js";
+import { createConversationHookBridge, createConversationRuntime } from "../src/server/conversation/index.js";
 import { createClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
 import { createCodexConversationAdapter } from "../src/server/conversation/providers/codex.js";
 import { createOpenCodeConversationAdapter } from "../src/server/conversation/providers/opencode.js";
@@ -29,6 +29,36 @@ function claudeHost() {
 const claudeInput = { systemPrompt: "Use the calendar tools.", contextIdentity: "calendar/model-one",
   model: "one", settings: { effortLevel: "high" }, liveUpdateIdentity: "calendar-schema" };
 
+test("saved persistent history projects receipts and pages without native observation or writes", async () => {
+  const runtime = createConversationRuntime({ authorize: async () => true, host: { conversation: () => ({}) } });
+  const turn = { turnId: "turn-1", user: { messageId: "user-1", attachments: [] },
+    messages: [{ role: "user", messageId: "user-1", text: "Saved draft", at: "2026-01-01T00:00:00Z" }] };
+  const calls = [];
+  const options = {
+    sessionId: "session-1", record: { conversationId: "chat-1", status: "starting", runId: "run-1", messageId: "user-1" },
+    context: { actor: "owner" }, includeAccess: true, transcriptQuery: { limit: 10 },
+    store: {
+      async readConversationLog(scope) { calls.push(["log", scope]); return [turn]; },
+      async readConversationLogPage(scope, query) { calls.push(["page", scope, query]); return { conversationLog: [turn], pagination: { more: false } }; }
+    },
+    operations: new Proxy({}, { get() { throw new Error("native operation must not run"); } }),
+    receipts: { persisted: () => false },
+    projection: {
+      context: (context) => context,
+      messageMetadata: () => ({}),
+      async snapshot(input) { return { ...input, page: await input.readPage() }; }
+    }
+  };
+  const result = await runtime.projectStoredPersistentConversation(options);
+  assert.equal(result.includeAccess, true);
+  assert.equal(result.response.status, "starting");
+  assert.equal(result.messages[0].receipt, false);
+  assert.equal(result.page.conversationLog[0].user.receipt, false);
+  assert.deepEqual(calls.map(([kind]) => kind), ["log", "page"]);
+  await runtime.close();
+  await assert.rejects(runtime.projectStoredPersistentConversation(options), { code: "conversation_closed" });
+});
+
 test("a standalone Claude consumer reuses, updates and replaces processes without changing native history", async () => {
   const f = claudeHost();
   const input = { ...claudeInput, nativeId: "retained-history" };
@@ -57,6 +87,21 @@ test("Claude rejects active prompt changes without invalidating ordinary steerin
   assert.equal(f.launches.length, 1);
 });
 
+test("Claude applies model and effort changes during work without restarting its process", async () => {
+  const f = claudeHost();
+  await f.runtime.prepare(claudeInput);
+  f.state.active = true;
+  await f.runtime.prepare({ ...claudeInput, contextIdentity: "calendar/model-two", model: "two",
+    settings: { effortLevel: "low" } });
+  assert.equal(f.state.active, true);
+  assert.equal(f.launches.length, 1);
+  assert.deepEqual(f.requests.slice(-2), [
+    { subtype: "apply_flag_settings", settings: { effortLevel: "low" } },
+    { subtype: "set_model", model: "two" }
+  ]);
+  await assert.rejects(f.runtime.prepare({ ...claudeInput, liveUpdateIdentity: "changed-tools" }), /Stop the current/);
+});
+
 test("Claude restarts when only the native instruction mode changes", async () => {
   const f = claudeHost();
   await f.runtime.prepare(claudeInput);
@@ -81,10 +126,14 @@ function codexHost({ readInstructions } = {}) {
   const state = { status: "idle", process: "process-1", prompt: "Calendar instructions", provider: "openai", fail: false,
     environment: { TOOL_ENDPOINT: "current" } };
   const requests = [];
-  const client = { async request(method, input) {
+  const client = { isOpen: () => true, async request(method, input) {
     requests.push({ method, input });
     if (method === "thread/read") return { thread: { historyMode: "paginated", status: state.status, modelProvider: state.provider } };
-    if (method === "thread/goal/get") return { goal: null };
+    if (method === "thread/goal/get") return { goal: state.goal ? { ...state.goal } : null };
+    if (method === "thread/goal/set") {
+      state.goal = { ...state.goal, status: input.status, updatedAt: state.goal.updatedAt + 1 };
+      return { goal: { ...state.goal } };
+    }
     if (method === "thread/turns/list") return { data: [{ id: "active-turn" }] };
     if (method === "turn/interrupt") { state.status = "idle"; return {}; }
     if (method === "thread/inject_items") return {};
@@ -93,7 +142,8 @@ function codexHost({ readInstructions } = {}) {
     if (method === "thread/resume") {
       if (state.fail) throw new Error("resume failed");
       state.status = "idle";
-      return { modelProvider: input.modelProvider || state.provider };
+      state.provider = input.modelProvider || state.provider;
+      return { modelProvider: state.provider };
     }
     throw new Error(`Unexpected native request: ${method}`);
   } };
@@ -104,6 +154,7 @@ function codexHost({ readInstructions } = {}) {
     prepareHistory: async (params) => params,
     threadParameters: (params) => params,
     verifyEnvironment: async () => {},
+    publishGoal: (threadId, goal) => requests.push({ method: "host.goal", input: { threadId, goal } }),
     recordInterruption: (threadId, turnId) => requests.push({ method: "host.recordInterruption", input: { threadId, turnId } }),
     prepareResume: async (id, params) => { requests.push({ method: "host.prepareResume", input: { id } }); return params; }
   });
@@ -503,3 +554,116 @@ test("Codex excludes deferred instruction composition without replenishing spent
     });
   }
 });
+
+
+for (const action of ["continue", "pause", "cancel", "complete", "close", "invalidate", "failure"]) {
+  test(`next-turn Codex provider settings preserve the current turn and ${action}`, async () => {
+    const f = codexHost();
+    const id = "native-history";
+    await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+    f.requests.length = 0;
+    f.state.status = "active";
+    f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Finish the same goal", tokenBudget: 100, tokensUsed: 40 };
+    const applied = [];
+    const update = params => { applied.push(params.model); return { ok: true }; };
+    const first = { modelProvider: "deepseek", model: "first", config: { "model_providers.deepseek": { base_url: "https://example.test" } } };
+    assert.deepEqual(await f.runtime.scheduleSettings(id, first, update), { ok: true, pending: true });
+    const task = f.runtime.threadEnvironmentTasks.get(id);
+    assert.equal(f.state.goal.status, "paused");
+    assert.equal(f.runtime.projectGoal(id, f.state.goal).status, "active", "An internal scheduling hold is not a user Pause");
+    assert.equal(f.requests.some(r => ["turn/interrupt", "thread/resume", "thread/unsubscribe"].includes(r.method)), false);
+    assert.deepEqual(await f.runtime.scheduleSettings(id, { ...first, model: "latest" }, update), { ok: true, pending: true });
+    if (["pause", "cancel"].includes(action)) f.runtime.goalChanged(id);
+    if (action === "pause") f.state.goal = { ...f.state.goal, status: "paused", updatedAt: 3 };
+    if (action === "cancel") f.state.goal = null;
+    if (action === "complete") f.state.goal = { ...f.state.goal, status: "complete", updatedAt: 3 };
+    if (action === "failure") f.state.fail = true;
+    if (action === "close") f.runtime.close();
+    if (action === "invalidate") f.runtime.invalidateThread(id);
+    f.state.status = "idle";
+    if (["close", "invalidate", "failure"].includes(action)) {
+      await assert.rejects(task);
+      assert.deepEqual(applied, []);
+      assert.equal(f.runtime.projectGoal(id, f.state.goal).status, "paused");
+    } else {
+      await task;
+      assert.deepEqual(applied, ["latest"]);
+      assert.equal(f.state.provider, "deepseek");
+      assert.equal(f.state.goal?.status || null, { continue: "active", pause: "paused", cancel: null, complete: "complete" }[action]);
+      if (f.state.goal) for (const [key, value] of Object.entries({ createdAt: 1, objective: "Finish the same goal", tokenBudget: 100, tokensUsed: 40 })) {
+        assert.equal(f.state.goal[key], value);
+      }
+    }
+    assert.equal(f.requests.some(r => r.method === "turn/interrupt"), false);
+    f.runtime.close();
+  });
+}
+
+test("a settings save during Codex reload replaces the older choice before its goal resumes", async () => {
+  const f = codexHost();
+  const id = "native-history";
+  await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+  f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Continue" };
+  const params = { modelProvider: "deepseek", model: "first" };
+  const applied = [];
+  await f.runtime.scheduleSettings(id, params, async selected => {
+    applied.push(selected.model);
+    if (selected.model === "first") {
+      void f.runtime.scheduleSettings(id, { ...params, model: "latest" }, () => assert.fail("The retained owner handles later saves"));
+    }
+    assert.equal(f.state.goal.status, "paused");
+  });
+  assert.deepEqual(applied, ["first", "latest"]);
+  assert.equal(f.state.goal.status, "active");
+  assert.equal(f.requests.filter(r => r.method === "thread/goal/set" && r.input.status === "active").length, 1);
+  f.runtime.close();
+});
+
+test("Codex retains settings saved during goal resume acknowledgement and after completion", async () => {
+  const f = codexHost();
+  const id = "native-history";
+  await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+  f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Continue" };
+  const params = { modelProvider: "deepseek", model: "first" };
+  const applied = [];
+  const update = selected => { applied.push(selected.model); };
+  const request = f.client.request.bind(f.client);
+  let savedDuringResume = false;
+  f.client.request = async (method, input) => {
+    const result = await request(method, input);
+    if (method === "thread/goal/set" && input.status === "active" && !savedDuringResume) {
+      savedDuringResume = true;
+      void f.runtime.scheduleSettings(id, { ...params, model: "during-resume" }, update);
+    }
+    return result;
+  };
+  await f.runtime.scheduleSettings(id, params, update);
+  assert.deepEqual(applied, ["first", "during-resume"]);
+  assert.equal(f.runtime.hasPendingSettings(id), false);
+  await f.runtime.scheduleSettings(id, { ...params, model: "after-completion" }, update);
+  assert.deepEqual(applied, ["first", "during-resume", "after-completion"]);
+  assert.equal(f.state.goal.status, "active");
+  assert.equal(f.requests.some(r => r.method === "turn/interrupt"), false);
+  f.runtime.close();
+});
+
+test("a user Pause during the final goal read prevents automatic settings recovery from resuming it", async () => {
+  const f = codexHost();
+  const id = "native-history";
+  await f.runtime.withThreadContext(id, { modelProvider: "openai" }, () => {});
+  f.state.goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Continue" };
+  const request = f.client.request.bind(f.client);
+  let settingsApplied = false;
+  f.client.request = async (method, input) => {
+    const result = await request(method, input);
+    if (method === "thread/goal/get" && settingsApplied) {
+      f.runtime.goalChanged(id);
+      f.state.goal = { ...f.state.goal, status: "paused", updatedAt: f.state.goal.updatedAt + 1 };
+    }
+    return result;
+  };
+  await f.runtime.scheduleSettings(id, { modelProvider: "deepseek", model: "next" }, () => { settingsApplied = true; });
+  assert.equal(f.state.goal.status, "paused");
+  assert.equal(f.requests.some(r => r.method === "thread/goal/set" && r.input.status === "active"), false);
+  f.runtime.close();
+});

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/conversationSession.test.js

@@ -1236,3 +1236,51 @@ for (const text of ["abc", "abcd"]) {
     if (text.length > 3) assert.match(result.error, /final reply limit/);
   });
 }
+
+test("native settings authorize their scope and reject replaced or closed host preparation", async t => {
+  const context = { actor: { id: "owner" } };
+  const nativeContext = { sessionId: "settings-scope", authorized: true };
+  const input = { threadId: "owned-thread", model: "next-model", effort: "high" };
+  let allowed = false, hostCalls = 0, acquisitions = 0, updates = 0;
+  let scope = "settings-scope", gate;
+  const owner = {
+    async acquire(prepared, threadId) {
+      assert.equal(prepared, nativeContext);
+      assert.equal(threadId, input.threadId);
+      acquisitions += 1;
+      return { process: {} };
+    },
+    async ensureProcess() { updates += 1; }
+  };
+  const runtime = createConversationRuntime({
+    authorize: request => allowed && request.context === context &&
+      request.conversationId === "settings-scope" && request.operation === "configure",
+    host: { async conversation(request) {
+      hostCalls += 1;
+      assert.deepEqual(request, { id: "settings-scope", context, input, operation: "updateSettings" });
+      if (gate) { gate.entered.resolve(); await gate.finished.promise; }
+      return { sessionId: scope, engine: "claude", native: { owner }, context: nativeContext };
+    } }
+  });
+  t.after(() => runtime.close());
+  const request = { id: "settings-scope", context, input,
+    get native() { return assert.fail("The caller cannot select a native owner"); },
+    get engine() { return assert.fail("The caller cannot select an engine"); } };
+  await assert.rejects(runtime.updateNativeConversationSettings(request), { code: "conversation_forbidden" });
+  assert.deepEqual([hostCalls, acquisitions, updates], [0, 0, 0]);
+  allowed = true;
+  scope = "another-scope";
+  await assert.rejects(runtime.updateNativeConversationSettings(request), /authorized host preparation/);
+  assert.deepEqual([acquisitions, updates], [0, 0]);
+  scope = "settings-scope";
+  assert.deepEqual(await runtime.updateNativeConversationSettings(request), { ok: true });
+  assert.deepEqual([acquisitions, updates], [1, 1]);
+  gate = { entered: Promise.withResolvers(), finished: Promise.withResolvers() };
+  const pending = runtime.updateNativeConversationSettings(request);
+  await gate.entered.promise;
+  await runtime.close();
+  gate.finished.resolve();
+  await assert.rejects(pending, { code: "conversation_closed" });
+  await assert.rejects(runtime.updateNativeConversationSettings(request), { code: "conversation_closed" });
+  assert.deepEqual([acquisitions, updates], [1, 1]);
+});

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();