@jskit-ai/assistant-core 0.2.1 → 0.2.3

package/test/messageDelivery.browser.test.js

@@ -107,7 +107,7 @@ test("the shared element renders delayed sends and supplies retry, edit and canc
 });
 
 
-test("chronological messages and application Cancel work on phone and desktop", {
+test("chronological messages and Cancel during a delivery check work on phone and desktop", {
   skip: process.env.JSKIT_ASSISTANT_CORE_BROWSER_INTEGRATION !== "1", timeout: 90_000
 }, async () => {
   const vite = await startViteFixture({ fixtureRoot: fileURLToPath(new URL("../fixtures/responsive-assistant", import.meta.url)) });
@@ -125,7 +125,23 @@ test("chronological messages and application Cancel work on phone and desktop",
       }
       await expect(page.getByRole("button", { name: "Retry delivery check" })).toBeVisible();
       await page.screenshot({ path: `/tmp/sas-chat-recovery-${width}.png` });
-      await page.getByRole("button", { name: "Cancel", exact: true }).click();
+      // Cancel stays enabled while Checking… runs. The message stays, shown as
+      // Cancelling…, until the server agrees, and stays when it is unreachable.
+      await page.getByRole("button", { name: "Start delivery check" }).click();
+      await expect(page.getByRole("button", { name: "Retry delivery check" })).toHaveText("Checking…");
+      await expect(page.getByRole("button", { name: "Retry delivery check" })).toBeDisabled();
+      const cancel = page.getByRole("button", { name: "Cancel", exact: true });
+      await expect(cancel).toBeEnabled();
+      await cancel.click();
+      await expect(page.getByRole("status").filter({ hasText: "Cancelling…" })).toBeVisible();
+      await expect(rows).toHaveCount(5);
+      await page.getByRole("button", { name: "Server unreachable" }).click();
+      await expect(page.getByText("Couldn't reach the server — Cancel again", { exact: true })).toBeVisible();
+      await expect(page.getByText("Discard failed attempt", { exact: true })).toBeVisible();
+      await expect(cancel).toBeEnabled();
+      await cancel.click();
+      await expect(page.getByRole("status").filter({ hasText: "Cancelling…" })).toBeVisible();
+      await page.getByRole("button", { name: "Server agrees to cancel" }).click();
       await expect(rows).toHaveCount(4);
       await expect(page.getByText("Discard failed attempt", { exact: true })).toHaveCount(0);
       assert.deepEqual(errors, []);

package/test/messageDelivery.test.js

@@ -72,6 +72,8 @@ test("cancel and edit affect failed messages and preserve a newer draft", async
   assert.equal(delivery.edit("one", "New draft"), null);
   await delivery.send({ message: "Second" }, { messageId: "two" });
   assert.equal(delivery.cancel("two"), true);
+  assert.equal(delivery.find("two").cancelling, true, "Cancel waits for the server before removing it");
+  delivery.remove("two");
   assert.deepEqual(delivery.state.messages, []);
 });
 
@@ -343,7 +345,6 @@ test("unconfirmed delivery preserves its authored payload for inspection without
   assert.equal(turn.optimistic.status, "uncertain");
   assert.equal(turn.user.attachments[0].name, "Original");
   assert.deepEqual(turn.system.delivery, { messageId: "one", error: "Connection closed.", checking: false });
-  assert.equal(delivery.cancel("one"), false);
   assert.equal(delivery.edit("one", "New draft"), null);
   assert.equal(delivery.resend("one"), false);
   assert.equal(await delivery.send({ message: "Hello" }, { messageId: "one" }), false);
@@ -355,6 +356,38 @@ test("unconfirmed delivery preserves its authored payload for inspection without
   assert.equal(delivery.turns()[0].system, undefined);
 });
 
+test("Cancel keeps a pending, uncertain or failed message, shown as cancelling, until the server agrees", async () => {
+  const delivery = createAssistantMessageDelivery();
+  await delivery.send({ message: "Refused" }, { messageId: "failed", deliver: async () => ({ ok: false, error: "Refused." }) });
+  await assert.rejects(delivery.send({ message: "Lost" }, { messageId: "uncertain", uncertainOnError: true,
+    deliver: async () => { throw new Error("Internal server error."); } }), /Internal server error/);
+  const held = Promise.withResolvers();
+  const inFlight = delivery.send({ message: "In flight" }, { messageId: "pending", deliver: () => held.promise });
+  assert.deepEqual(delivery.state.messages.map(message => message.status), ["failed", "uncertain", "pending"]);
+  for (const messageId of ["failed", "uncertain", "pending"]) assert.equal(delivery.cancel(messageId), true);
+  assert.deepEqual(delivery.turns().map(turn => [turn.optimistic.id, turn.optimistic.cancelling]),
+    [["failed", true], ["uncertain", true], ["pending", true]], "Nothing leaves on the client's own authority");
+  assert.equal(delivery.cancel("uncertain"), false, "A second press waits for the same answer");
+  assert.equal(delivery.edit("failed", ""), null, "A cancelling message is not edited");
+  assert.equal(await delivery.send({ message: "Refused" }, { messageId: "failed" }), false, "nor sent again");
+  let queuedDeliveries = 0;
+  const queued = delivery.send({ message: "Queued" }, { messageId: "queued", queue: true, deliver: async () => { queuedDeliveries += 1; } });
+  assert.equal(delivery.cancel("queued"), true);
+  held.resolve({ ok: false, error: "Late failure." });
+  await inFlight;
+  assert.equal(await queued, false);
+  assert.equal(queuedDeliveries, 0, "A message cancelled while queued is never delivered");
+  assert.equal(delivery.find("pending").cancelling, true, "A late answer leaves the cancel in progress");
+  // The server could not be reached: the message stays, with Cancel again.
+  delivery.cancelFailed("uncertain");
+  assert.deepEqual(delivery.turns().find(turn => turn.optimistic.id === "uncertain").optimistic,
+    { error: "Internal server error.", id: "uncertain", status: "uncertain", cancelError: "Couldn't reach the server — Cancel again" });
+  assert.equal(delivery.cancel("uncertain"), true, "Cancel again");
+  // The server agreed: only then does the caller remove each message.
+  for (const messageId of ["failed", "uncertain", "pending", "queued"]) delivery.remove(messageId);
+  assert.deepEqual(delivery.turns(), []);
+});
+
 test("reconnect restores one uncertain request and ends its HTTP wait without dispatching again", async () => {
   const request = Promise.withResolvers();
   const receipts = ref([]);

package/test/openCodeClient.test.js

@@ -32,6 +32,37 @@ test("OpenCode directory readiness uses the same authenticated directory as nati
   assert.equal(requests[1].signal, stopSignal);
 });
 
+test("OpenCode clients record the directories the server has loaded and reload one directory at a time", async () => {
+  const requests = [];
+  let duringDispose = null;
+  const root = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:4096", defaultDirectory: "/work/server",
+    fetchImpl: async (url, init) => {
+      const pathname = new URL(url).pathname;
+      requests.push([init.method, pathname, init.headers["x-opencode-directory"] || ""]);
+      if (pathname === "/instance/dispose") await duringDispose?.();
+      return jsonResponse(pathname === "/path" ? { directory: "/work/selected" } : true);
+    } });
+  const selected = root.forDirectory("/work/selected/");
+  const other = root.forDirectory("/work/other");
+  await root.health();
+  assert.deepEqual(root.instanceDirectories(), [], "Global routes load no directory.");
+  await selected.prepareDirectory();
+  await root.sessionStatus("ses_one");
+  await other.prepareDirectory();
+  assert.deepEqual(root.instanceDirectories(), ["/work/selected", "/work/server", "/work/other"]);
+  await selected.disposeInstance();
+  assert.deepEqual(requests.at(-1), ["POST", "/instance/dispose", "/work/selected/"]);
+  assert.deepEqual(other.instanceDirectories(), ["/work/server", "/work/other"]);
+  // A request that reaches the directory during disposal keeps it recorded.
+  duringDispose = () => other.prepareDirectory();
+  await other.disposeInstance();
+  assert.deepEqual(root.instanceDirectories(), ["/work/server", "/work/other"]);
+  duringDispose = null;
+  await root.disposeInstance();
+  assert.deepEqual(requests.at(-1), ["POST", "/instance/dispose", ""]);
+  assert.deepEqual(root.instanceDirectories(), ["/work/other"]);
+});
+
 test("OpenCode directory readiness rejects cancellation and missing native confirmation", async () => {
   const client = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:4096",
     fetchImpl: async () => jsonResponse({ healthy: true }) });

package/test/openCodeConnectionChange.test.js

@@ -0,0 +1,166 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
+import { createOpenCodeSharedRuntime, openCodeServerForDirectory } from "../src/server/conversation/openCodeRuntime.js";
+
+// One shared server whose native directories record what OpenCode is asked to do.
+function sharedServer() {
+  const calls = [], rows = new Map(), loaded = new Set();
+  const client = (directory = "/work/server") => ({
+    async health() { return { healthy: true }; },
+    async authenticateApiKey(providerId, key) { calls.push(["key", providerId, key]); },
+    async removeAuthentication(providerId) { calls.push(["remove", providerId]); },
+    async disposeInstance() { calls.push(["reload", directory]); loaded.delete(directory); },
+    instanceDirectories: () => [...loaded],
+    forDirectory(next) { loaded.add(next); return client(next); },
+    async prompt(conversationId, input) {
+      calls.push(["prompt", directory, conversationId]);
+      rows.set(conversationId, [{ id: input.id, type: "user", time: { created: 1 } },
+        { id: `${input.id}:answer`, type: "assistant", text: "Done.", time: { created: 2, completed: 3 } }]);
+      return { id: input.id };
+    },
+    async messages(conversationId) { return rows.get(conversationId) || []; },
+    async sessionStatus() { return { type: "idle" }; },
+    async interrupt() { return true; }
+  });
+  const stops = [];
+  const server = { client: client(), async stop() { stops.push(server); return { exited: true }; } };
+  return { server, calls, rows, stops };
+}
+
+const deepseek = (fingerprint, apiKey) => ({ modelProviderId: "deepseek", canonicalUrl: "", endpointCode: "native", fingerprint, apiKey });
+
+async function startedRuntime(saved) {
+  const runtime = createOpenCodeSharedRuntime();
+  const native = sharedServer();
+  const shared = await runtime.ensure(saved[0], async () => ({ server: native.server, connections: [...saved] }), async () => saved);
+  return { runtime, native, shared };
+}
+
+// A main-conversation turn in flight until its answer arrives.
+function runningTurn(t, runtime, shared, workdir, { failure = "", completeResult = async (_turn, { failure: value }) => value } = {}) {
+  const target = { key: workdir, workdir, upstreamSessionId: `${workdir}:thread`, abortController: new AbortController(),
+    server: openCodeServerForDirectory(shared.server, workdir) };
+  const turn = { id: "input", inputMessageId: "input", threadId: target.upstreamSessionId, active: true, state: "active",
+    eventStartedAt: 1, abortController: new AbortController() };
+  let observedFailure = null;
+  const monitor = runtime.beginMonitor(workdir, target, turn, {
+    observe: () => ({ readFailure: () => observedFailure, close: async () => {} }),
+    finalResponse: { agent: "agent", model: { providerID: "deepseek", id: "model" }, recoveryMessageId: "recovery", readError: () => "" },
+    projectMessages: async () => ({ failure: "", providerApiFailure: false, finalAssistantResult: null }),
+    writeRun: async () => {},
+    completeResult,
+    onRetired() {}
+  });
+  t.after(async () => { turn.abortController.abort(); await monitor.catch(() => null); });
+  return {
+    target, turn, monitor,
+    answer(native) {
+      native.rows.set(target.upstreamSessionId, [{ id: "input", type: "user", time: { created: 1 } },
+        { id: "answer", type: "assistant", text: "Done.", time: { created: 2, completed: 3 } }]);
+    },
+    fail(native) {
+      native.rows.set(target.upstreamSessionId, [{ id: "input", type: "user", time: { created: 1 } }]);
+      observedFailure = Object.assign(new Error(failure), { name: "UnknownError" });
+    }
+  };
+}
+
+function temporaryTurn(runtime, target, conversationId) {
+  return runtime.runConversationTurn(target, conversationId, { active: false },
+    { id: `${conversationId}:input`, agent: "agent", model: { providerID: "deepseek", id: "model" }, prompt: { text: "Hello" } }, {
+      observe: () => ({ waitUntilReady: async () => {}, readFailure: () => null, close: async () => {} }),
+      completion: { projectResult: value => value, readError: () => "" },
+      onCompletion() {}
+    });
+}
+
+test("an OpenCode connection change leaves running work alone and reloads idle directories at once", { timeout: 15_000 }, async t => {
+  const saved = [deepseek("old", "old-key"), { ...deepseek("zai-account", "zai-key"), modelProviderId: "zai" }];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const running = runningTurn(t, runtime, shared, "/work/busy");
+  // Another provider's retained conversation, which once refused the change.
+  const peer = await runtime.acquire("peer", async () => ({ key: "peer", workdir: "/work/idle", modelProviderId: "zai",
+    abortController: new AbortController(), server: openCodeServerForDirectory(shared.server, "/work/idle") }));
+  saved[0] = deepseek("new", "new-key");
+  let published = false;
+  const changed = await runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } },
+    { release: {}, connections: async () => saved });
+  await delay(10);
+  assert.deepEqual(changed, { closed: 0, ok: true });
+  assert.equal(published, true);
+  assert.deepEqual(native.calls, [["key", "deepseek", "new-key"], ["reload", "/work/idle"]]);
+  assert.deepEqual(native.stops, []);
+  assert.equal(runtime.current, shared);
+  assert.equal(running.turn.active, true);
+  assert.equal(running.target.abortController.signal.aborted, false);
+  assert.equal(runtime.processes.get("peer"), peer);
+  assert.equal(peer.abortController.signal.aborted, false);
+  running.answer(native);
+  assert.equal((await running.monitor).state, "completed");
+  await delay(10);
+  assert.deepEqual(native.calls.slice(2), [["reload", "/work/busy"]], "The busy directory reloads once its turn ends.");
+});
+
+test("new work in a directory with a turn in flight starts after that turn ends and the directory reloads", { timeout: 15_000 }, async t => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const running = runningTurn(t, runtime, shared, "/work/busy");
+  saved[0] = deepseek("new", "new-key");
+  await runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() {} }, { release: {}, connections: async () => saved });
+  const target = { workdir: "/work/busy", abortController: new AbortController(),
+    server: openCodeServerForDirectory(shared.server, "/work/busy") };
+  const elsewhere = { workdir: "/work/other", abortController: new AbortController(),
+    server: openCodeServerForDirectory(shared.server, "/work/other") };
+  const waiting = temporaryTurn(runtime, target, "temporary");
+  assert.equal((await temporaryTurn(runtime, elsewhere, "unrelated")).status, "inProgress",
+    "Another directory's new work does not wait.");
+  await delay(30);
+  assert.equal(native.calls.some(([kind, , id]) => kind === "prompt" && id === "temporary"), false);
+  running.answer(native);
+  await running.monitor;
+  assert.equal((await waiting).status, "inProgress");
+  const order = native.calls.map(call => call.join(" "));
+  assert.ok(order.indexOf("reload /work/busy") < order.indexOf("prompt /work/busy temporary"), order.join("\n"));
+});
+
+test("a stale preparation cannot restore an older key, and a saved change reaches the server at the next use", async () => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const start = async () => assert.fail("A changed key does not start another server.");
+  saved[0] = deepseek("new", "new-key");
+  assert.equal(await runtime.ensure(saved[0], start, async () => saved), shared);
+  assert.equal(await runtime.ensure(deepseek("old", "old-key"), start, async () => saved), shared);
+  assert.deepEqual(native.calls, [["key", "deepseek", "new-key"]]);
+  assert.deepEqual(native.stops, []);
+});
+
+test("Disconnect removes the key, and a turn whose connection is gone ends with a reconnect message", { timeout: 15_000 }, async t => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const outcomes = [];
+  const running = runningTurn(t, runtime, shared, "/work/busy", {
+    failure: "Model not found: deepseek/model. Did you mean: model?",
+    async completeResult(_turn, outcome) { outcomes.push(outcome); return outcome.failure; }
+  });
+  saved.length = 0;
+  await runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() {} }, { release: {}, connections: async () => saved });
+  assert.deepEqual(native.calls, [["remove", "deepseek"]]);
+  running.fail(native);
+  const result = await running.monitor;
+  assert.equal(result.state, "failed");
+  assert.equal(result.error, "deepseek isn't connected. Connect it again, then send your message again.");
+  assert.equal(outcomes[0].credentialFailure, true);
+});
+
+test("an open native terminal still refuses the change before anything is published", async () => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native } = await startedRuntime(saved);
+  let published = false;
+  saved[0] = deepseek("new", "new-key");
+  await assert.rejects(runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } }, {
+    release: { assertConnectionChange() { throw new Error("Close OpenCode native terminals."); } }, connections: async () => saved
+  }), /Close OpenCode native terminals/u);
+  assert.equal(published, false);
+  assert.deepEqual(native.calls, []);
+});

package/test/openCodeProcess.test.js

@@ -3,7 +3,9 @@ import { access, mkdtemp, rm } 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 { createOpenCodeServerProcess, openCodeProcessEnvironment } from "../src/server/conversation/openCodeProcess.js";
+import { createOpenCodeSharedRuntime } from "../src/server/conversation/openCodeRuntime.js";
 
 async function fixture(t, options = {}) {
   const workdir = await mkdtemp(path.join(os.tmpdir(), "jskit-opencode-process-"));
@@ -41,6 +43,8 @@ test("the shared OpenCode server authenticates selected accounts and drains its
   ] });
   assert.deepEqual(native.modelProviderIds, ["first", "second"]);
   assert.deepEqual(f.requests.map(({ url }) => url.pathname), ["/global/health", "/auth/first", "/auth/second"]);
+  // Requests without a directory reach the server's working directory, which a credential change reloads.
+  assert.deepEqual(native.client.instanceDirectories(), [f.config.workdir]);
   assert.notEqual(native.environment.OPENCODE_SERVER_PASSWORD, "obsolete-password");
   assert.equal(native.executionId, "owned-process");
   assert.deepEqual(native.attachArguments({ conversationId: "ses_one", directory: f.config.workdir }),
@@ -51,6 +55,22 @@ test("the shared OpenCode server authenticates selected accounts and drains its
   await assert.rejects(access(f.config.privateRoot), { code: "ENOENT" });
 });
 
+test("the shared owner stops a server that exits without being stopped at once", async t => {
+  const f = await fixture(t);
+  const reasons = [];
+  const runtime = createOpenCodeSharedRuntime({ onStop: ({ reason }) => reasons.push(reason) });
+  // The host wires no failure callback: the owner watches the exit itself.
+  const shared = await runtime.ensure(null, async () => ({ server: await createOpenCodeServerProcess(f.config), connections: [] }));
+  assert.equal(runtime.current, shared);
+  f.exited.resolve({ code: 1 });
+  for (let attempt = 0; attempt < 50 && f.stops.length === 0; attempt += 1) await delay(10);
+  await delay(20);
+  assert.deepEqual(f.stops, ["owned-process"]);
+  assert.deepEqual(reasons, ["opencode-server-exited"]);
+  assert.equal(runtime.current, null);
+  await assert.rejects(access(f.config.privateRoot), { code: "ENOENT" });
+});
+
 test("version mismatch preserves startup evidence and the owned identity if cleanup is unconfirmed", async t => {
   let confirmed = false;
   let failure;
@@ -97,6 +117,22 @@ test("an unexpected native exit reports failure after readiness", async t => {
   await native.stop();
 });
 
+test("an OpenCode server that exits before readiness says why", async t => {
+  const f = await fixture(t);
+  f.config.execution.start = async request => {
+    f.starts.push(request);
+    return { id: "owned-process", pid: 123, running: false, exited: Promise.resolve({ code: 1 }),
+      readLogs: () => ({ stdout: "", stderr: `INFO starting\n\u001b[31mError: Unexpected token in ${"x".repeat(600)}\u001b[0m\n\n` }) };
+  };
+  await assert.rejects(createOpenCodeServerProcess(f.config), error => {
+    assert.equal(error.code, "assistant_opencode_start_failed");
+    assert.match(error.message, /^OpenCode exited before its server became ready: Error: Unexpected token in x+…$/u);
+    assert.ok(error.message.length < 400, "the reason is one bounded line");
+    assert.match(error.details.stderr, /INFO starting/u);
+    return true;
+  });
+});
+
 test("failed host startup retains its execution identity until cleanup is proven", async t => {
   const f = await fixture(t, { stop: () => ({ scopeEmpty: false }) });
   const bindings = [];

package/test/openCodeRuntime.test.js

@@ -224,6 +224,31 @@ test("an acquired OpenCode process without a main conversation can close without
   assert.equal(f.stops.length, 1);
 });
 
+test("deleting a scoped OpenCode conversation returns its scope's exit proof and keeps none", async () => {
+  const f = fixture();
+  const target = await f.acquire("ephemeral\0reasoning_1");
+  target.sessionId = "reasoning_1";
+  const deleted = [];
+  target.server = { ...target.server, client: { ...target.server.client, async deleteSession(id) { deleted.push(id); } } };
+  const application = {
+    closeTerminals: async () => ({ ok: true, closed: 0 }),
+    beforeRelease: async () => {},
+    onRemoved: async () => {},
+    afterRelease: async () => {},
+    failure: error => { throw error; }
+  };
+  const result = await f.runtime.deletePreparedConversation({
+    key: "ephemeral\0reasoning_1", conversationId: "native-1", persistent: false, scoped: true,
+    process: () => assert.fail("deleting must not start OpenCode"), onRemoved: async () => {},
+    cleanupAfterDelete: { sessionId: "reasoning_1", options: {}, application }
+  }, { persistent: false });
+  assert.deepEqual(deleted, ["native-1"]);
+  assert.equal(result.deleted, true);
+  assert.equal(result.providerExit.processExitProof.exited, true);
+  // A scope is never renewed, so nothing would ever release a kept proof.
+  assert.equal(f.runtime.releaseProcessExitProof("reasoning_1").processExitProof, null);
+});
+
 test("an active OpenCode turn with missing native identity still fails instead of claiming Stop", async () => {
   const runtime = createOpenCodeSharedRuntime();
   const client = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:1",
@@ -762,81 +787,3 @@ test("original message monitor clone retains only its registered target's final
   assert.equal(modelPrompts, 0);
   assert.deepEqual(errors, []);
 });
-
-test("credential publication refuses another provider and unowned consumers before stopping or writing", async () => {
-  for (const unowned of [false, true]) {
-    const { runtime, acquire, stops } = fixture();
-    const selected = await acquire("selected"); selected.modelProviderId = "deepseek";
-    const peer = await acquire("peer"); peer.modelProviderId = unowned ? "deepseek" : "zai";
-    let published = false;
-    const effects = [];
-    await assert.rejects(runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } }, {
-      release: { ownsTarget: target => !unowned || target !== peer,
-        beforeRelease: async target => effects.push(target.key), onRemoved: async () => {}, failure: error => { throw error; } }
-    }), { code: "assistant_opencode_connection_in_use", message: /^Close the other OpenCode conversations that use this connection, then retry/u });
-    assert.equal(published, false);
-    assert.deepEqual(effects, []);
-    assert.deepEqual(stops, []);
-    assert.equal(runtime.processes.get("peer"), peer);
-    assert.equal(peer.abortController.signal.aborted, false);
-    assert.equal(selected.abortController.signal.aborted, false);
-  }
-});
-
-test("credential publication fences new acquisition and ensure across native cleanup and private publication", async () => {
-  const { runtime, acquire, connection, starts, stops } = fixture();
-  const selected = await acquire("selected"); selected.modelProviderId = "deepseek";
-  const publishing = Promise.withResolvers(), finish = Promise.withResolvers();
-  let saved = "old";
-  const changed = runtime.invalidateRuntimes({ modelProviderId: "deepseek", async publish() {
-    assert.equal(stops.length, 1); publishing.resolve(); await finish.promise; saved = "new";
-  } }, { release: { ownsTarget: () => true, beforeRelease: async () => {}, onRemoved: async () => {}, failure: error => { throw error; } } });
-  await publishing.promise;
-  assert.equal(saved, "old");
-  await assert.rejects(acquire("late"), { code: "assistant_opencode_connection_changing" });
-  await assert.rejects(runtime.ensure(connection, async () => { throw new Error("must not start"); }), { code: "assistant_opencode_connection_changing" });
-  assert.equal(starts.length, 1);
-  finish.resolve();
-  assert.equal((await changed).ok, true);
-  assert.equal(saved, "new");
-  await acquire("retry");
-  assert.equal(starts.length, 2);
-});
-
-test("credential barrier drains admitted acquisitions and refuses a late peer without native effects", async () => {
-  const { runtime, stops } = fixture();
-  const started = Promise.withResolvers(), finish = Promise.withResolvers();
-  const pending = runtime.acquire("late-peer", async () => {
-    started.resolve(); await finish.promise;
-    return { key: "late-peer", modelProviderId: "zai", abortController: new AbortController() };
-  });
-  await started.promise;
-  let published = false;
-  const changed = runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } }, {
-    release: { ownsTarget: () => true, beforeRelease: async () => { throw new Error("must not release"); } }
-  });
-  const rejected = assert.rejects(changed, { code: "assistant_opencode_connection_in_use" });
-  finish.resolve(); await pending; await rejected;
-  assert.equal(published, false);
-  assert.deepEqual(stops, []);
-});
-
-test("unconfirmed terminal and failed verified stop keep the prior credential and permit safe retry", async () => {
-  let terminalOpen = true, stopFails = true, published = false;
-  const { runtime, acquire, stops } = fixture({ stop: async () => ({ exited: !stopFails }) });
-  const target = await acquire("selected"); target.modelProviderId = "deepseek";
-  const input = { modelProviderId: "deepseek", publish() { published = true; } };
-  const preparation = { release: { ownsTarget: () => true,
-    assertConnectionChange() { if (terminalOpen) throw new Error("close terminal"); },
-    beforeRelease: async () => {}, onRemoved: async () => {}, failure: error => { throw error; } } };
-  await assert.rejects(runtime.invalidateRuntimes(input, preparation), /close terminal/);
-  assert.equal(target.abortController.signal.aborted, false);
-  assert.equal(stops.length, 0);
-  terminalOpen = false;
-  await assert.rejects(runtime.invalidateRuntimes(input, preparation), { code: "assistant_opencode_stop_unverified" });
-  assert.equal(published, false);
-  stopFails = false;
-  assert.equal((await runtime.invalidateRuntimes(input, preparation)).ok, true);
-  assert.equal(published, true);
-  assert.equal(stops.length, 2);
-});