@jskit-ai/assistant-core 0.2.2 → 0.2.4

package/test/codexTemporaryProviderRelease.test.js

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

package/test/codexTurn.test.js

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

package/test/conversationNativeStorage.test.js

@@ -250,3 +250,60 @@ test("a conversation that starts after an OpenCode storage read keeps the server
   await owner.release(open);
   assert.equal(server.running, false);
 });
+
+// The inventory keeps only thread ids. Long first prompts in each thread/list
+// preview are not retained, so they cannot make a valid inventory fail.
+function codexThreadListing(pages) {
+  const requests = [];
+  const client = {
+    async request(method, params) {
+      assert.equal(method, "thread/list");
+      requests.push(params);
+      const index = params.cursor ? Number(params.cursor) : 0;
+      const archived = params.archived === true;
+      const data = archived ? [] : pages[index] || [];
+      const nextCursor = !archived && index + 1 < pages.length ? String(index + 1) : null;
+      return { data, nextCursor };
+    }
+  };
+  const inventory = { activeClient: async () => client, runRequest: (operation) => operation(), errorPrefix: "vibe64_" };
+  return { inventory, requests };
+}
+
+function nativeThread(id, { cwd = "/source", previewBytes = 0 } = {}) {
+  return { id, cwd, preview: "p".repeat(previewBytes), status: { type: "notLoaded" } };
+}
+
+test("Codex native existence checks a home whose thread previews exceed any byte budget", async () => {
+  const pages = [
+    Array.from({ length: 100 }, (_, index) => nativeThread(`thread-${index}`, { previewBytes: 30 * 1024 })),
+    [nativeThread("wanted", { previewBytes: 70 * 1024 })]
+  ];
+  const { inventory } = codexThreadListing(pages);
+  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "wanted"), true);
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "missing"), false);
+});
+
+test("Codex native existence searches more threads than an inventory retains", async () => {
+  const pages = Array.from({ length: 12 }, (_, page) =>
+    Array.from({ length: 100 }, (_, index) => nativeThread(`thread-${page}-${index}`)));
+  const { inventory, requests } = codexThreadListing(pages);
+  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "thread-3-7"), true);
+  assert.equal(requests.length, 4, "the search stops at the page that lists the thread");
+  assert.equal(await CodexAppServerAgentProvider.prototype.nativeThreadExists.call(inventory, "thread-12-0"), false);
+});
+
+test("a refused Codex inventory entry names the check and the thread", async () => {
+  const { CodexAppServerAgentProvider } = await import("../src/server/conversation/codexProvider.js");
+  const outside = codexThreadListing([[nativeThread("thread-a"), nativeThread("thread-b", { cwd: "/elsewhere" })]]);
+  await assert.rejects(CodexAppServerAgentProvider.prototype.listNativeThreadsForCwd.call(outside.inventory, "/source"), (error) => {
+    assert.equal(error.code, "vibe64_codex_retirement_inventory_invalid");
+    assert.match(error.message, /thread thread-b .*outside the requested directory/u);
+    return true;
+  });
+  const unnamed = codexThreadListing([[{ cwd: "/source" }]]);
+  await assert.rejects(CodexAppServerAgentProvider.prototype.listNativeThreadsForCwd.call(unnamed.inventory, "/source"),
+    /listed a thread without an id/u);
+});

package/test/conversationRuntime.test.js

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

package/test/conversationSession.test.js

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

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