@jskit-ai/assistant-core 0.1.239 → 0.1.241

package/test/assistantScroll.browser.test.js

@@ -13,6 +13,19 @@ import {
 const TEST_DIRECTORY = path.dirname(fileURLToPath(import.meta.url));
 const FIXTURE_ROOT = path.resolve(TEST_DIRECTORY, "../fixtures/responsive-assistant");
 const RUN_BROWSER_TEST = process.env.JSKIT_ASSISTANT_CORE_BROWSER_INTEGRATION === "1";
+// Turns use content-visibility estimates. Moving the reader materializes rows
+// near the new position, and Chromium's scroll anchoring then shifts scrollTop
+// to keep the same content in view. Hold a reading position only once that
+// layout has settled, so later checks measure the conversation, not the estimates.
+async function settleReaderAt(body, scrollTop) {
+  await expect.poll(() => body.evaluate(async (element, top) => {
+    element.scrollTop = top;
+    const height = element.scrollHeight;
+    await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+    return element.scrollTop === top && element.scrollHeight === height;
+  }, scrollTop)).toBe(true);
+}
+
 const VIEWPORTS = Object.freeze([
   Object.freeze({ name: "phone", width: 390, height: 844 }),
   Object.freeze({ name: "compact", width: 800, height: 900 }),
@@ -405,6 +418,14 @@ test("upward scrolling loads older history once and preserves retry and selectio
       await expect(page.getByText("Conversation line 70:", { exact: false })).toBeVisible();
       await expect(requests).toHaveText("History requests: 3");
       await external("Exhaust history");
+      // Removing the history control re-anchors the scroller, which would
+      // cancel a keyboard scroll already in flight; press Home once it settles.
+      await expect(page.getByRole("button", { name: "Load older messages", exact: true })).toHaveCount(0);
+      await expect.poll(() => body.evaluate(async element => {
+        const height = element.scrollHeight;
+        await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+        return element.scrollHeight === height;
+      })).toBe(true);
       await expect.poll(async () => {
         await body.focus();
         return body.evaluate(element => document.activeElement === element);
@@ -412,7 +433,6 @@ test("upward scrolling loads older history once and preserves retry and selectio
       await body.press("Home");
       await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(0);
       await expect(requests).toHaveText("History requests: 3");
-      await expect(page.getByRole("button", { name: "Load older messages", exact: true })).toHaveCount(0);
       assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth));
       assert.deepEqual(errors, []);
       await page.close();
@@ -1235,15 +1255,18 @@ test("connection warnings keep avatar controls and Reload reachable without repl
       await body.hover();
       await page.mouse.wheel(0, -1000);
       await expect.poll(() => body.evaluate(element => element.scrollHeight - element.clientHeight - element.scrollTop)).toBeGreaterThan(50);
-      await body.evaluate(element => { element.scrollTop = 420; window.errorAvatarBody = element; });
-      await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+      await settleReaderAt(body, 420);
+      await body.evaluate(element => { window.errorAvatarBody = element; });
       const history = await body.locator(".assistant-transcript__turn").allTextContents();
       let reloads = 0;
       for (const size of ["standard", "large", "hidden"]) {
         await page.getByRole("combobox", { name: "Avatar preference", exact: true }).selectOption(size);
-        // Establish the reading position after changing the fixture-only avatar preference.
-        await body.evaluate(element => { element.scrollTop = 420; });
-        await expect.poll(() => body.evaluate(element => element.scrollTop)).toBe(420);
+        // Establish the reading position after changing the fixture-only avatar
+        // preference. A reader's own wheel detaches the view from the latest
+        // message even if a slow initial bottom scroll resumed following.
+        await body.hover();
+        await page.mouse.wheel(0, -200);
+        await settleReaderAt(body, 420);
         await external("Show update error");
         await expect(conversation).toHaveClass(/assistant-conversation--error/u);
         await expect(avatar).toHaveCSS("position", "absolute");

package/test/assistantSettingsResource.test.js

@@ -1,11 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
+import { resolveSchemaTransportSchemaDefinition } from "@jskit-ai/kernel/shared/validators";
 import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
 import { assistantConfigResource } from "../src/shared/assistantSettingsResource.js";
 
 test("assistant config resource exposes valid output schema", () => {
-  const viewSchema = resolveStructuredSchemaTransportSchema(
+  const viewSchema = resolveSchemaTransportSchemaDefinition(
     assistantConfigResource.operations.view.output,
     {
       context: "assistant config view output",

package/test/claudeConversationSession.test.js

@@ -320,7 +320,13 @@ async function fixture(t, options = {}) {
           attachment: { type: "goal_status", condition, sentinel: true, met: condition === "clear" } });
         if (process.env.TEST_GOAL_LOST_ACK) return;
         emit(frame);
-        if (condition === "clear") emit({ type: "result", subtype: "success", result: "" });
+        if (condition === "clear") {
+          // Claude 2.1.289 saves the clear's local-command receipt and ends it
+          // with a result naming the command and the authored message.
+          record({ type: "system", subtype: "local_command", uuid: frame.uuid + "-clear", parentUuid: frame.uuid,
+            commandRun: { command: "goal", args: "clear" }, content: "<local-command-stdout>Goal cleared: prior goal</local-command-stdout>" });
+          emit({ type: "result", subtype: "success", result: "", local_command: "goal", user_message_uuid: frame.uuid });
+        }
         return;
       }
       emit(frame);
@@ -1167,8 +1173,9 @@ test("Claude native goal commands use ordinary admission, pause retains the goal
   assert.equal(events.filter(event => event.type === "accepted").length, 3);
   assert.equal(events.some(event => event.type === "goal" && event.goal === null), true);
   const trace = await f.trace();
+  // Resume starts a new process, which first suspends the retained paused checker.
   assert.deepEqual(trace.filter(row => row.frame?.type === "user").map(row => row.frame.message.content),
-    ["/goal Tests pass", "/goal Tests pass", "/goal clear"]);
+    ["/goal Tests pass", "/goal clear", "/goal Tests pass", "/goal clear"]);
   const starts = trace.filter(row => row.args?.includes("--print"));
   assert.equal(starts.length, 3);
   assert.equal(starts[1].args.includes("--resume"), true);
@@ -2566,6 +2573,16 @@ async function completedReplyFixture(t, options = {}) {
     prepare: receipt => conversation.prepareCompletedResponse(receipt, { signal: controller.signal }) };
 }
 
+test("delivery inspection of a turn without runtime metadata returns its duplicate receipt", async t => {
+  const f = await completedReplyFixture(t);
+  try {
+    const plain = await f.plain("pre-runtime-turn");
+    assert.equal(plain.metadata?.runtime, undefined);
+    assert.deepEqual(await f.conversation.inspectDelivery({ messageId: "pre-runtime-turn" }),
+      { status: "accepted", messageId: "pre-runtime-turn", turnId: plain.turnId, duplicate: true });
+  } finally { await f.close(); }
+});
+
 test("completed Claude prepared reply atomically publishes one plain final across handles and restart", async t => {
   const f = await completedReplyFixture(t);
   try {
@@ -2813,7 +2830,7 @@ for (const kind of ["tool", "reply"]) test(`completed Claude ${kind} wire preser
     assert.equal(saved.assistant.text, raw);
     const prepared = await f.conversation.prepareCompletedResponse(receipt, { signal: new AbortController().signal });
     assert.equal(prepared.text, raw);
-    const { readAssistantResponseEnvelope } = await import("../src/server/lib/assistantToolLoop.js");
+    const { readAssistantResponseEnvelope } = await import("../src/server/conversation/boundedToolLoop.js");
     const decoded = readAssistantResponseEnvelope(prepared.text);
     assert.deepEqual(decoded, value);
     if (kind === "tool") assert.equal(JSON.parse(decoded.arguments).value, handover);

package/test/claudeTurn.test.js

@@ -1361,7 +1361,7 @@ test("Claude verified native cleanup retains interrupted checkpoint refusal with
 
 // Retain the original supplied-store/native process fixture and drive it through
 // the actual common runtime, including its completion-only admitted receipt.
-async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, representation = "canonical", beforeToolWrite, signal, executeTool = async () => ({}) } = {}) {
+async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, hostDeliveryStages, representation = "canonical", beforeToolWrite, signal, executeTool = async () => ({}) } = {}) {
   const f = await publishedClaudeFixture(t, { canonicalAdmission: true });
   const storage = createMemoryConversationStorage();
   const transcript = createConversationTranscript({ storage });
@@ -1390,7 +1390,7 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, repres
     native: { owner: f.owner, preparation: { cleanup: () => ({ context: f.context, application: {
       readContext: async () => f.context, terminals: { close: async () => ({ ok: true }) }
     } }) } },
-    admission() {}, prepareInput: async input => input,
+    admission() {}, prepareInput: async (input, _context, { deliveryTiming } = {}) => { deliveryTiming?.("host-prepared"); return input; },
     read: async () => ({ threadId: f.conversationId, configuration: { model: "native" },
       turn: f.owner.snapshot(f.entry), delivery }),
     readStream: async () => ({ messages: [] }),
@@ -1404,7 +1404,7 @@ async function suppliedCommonFixture(t, { tools = true, onDeliveryTiming, repres
       admissions.push(admission); return actual;
     } } } : {}) };
   const runtime = createConversationRuntime({ ...(tools ? { actions } : {}), authorize: () => true, onDeliveryTiming,
-    host: { conversation: () => binding } });
+    hostDeliveryStages, host: { conversation: () => binding } });
   t.after(() => runtime.close());
   const conversation = await runtime.open({ id: "lesson", context, representation });
   f.setBeforeState((entry, event) => {
@@ -1511,20 +1511,20 @@ for (const failedSave of [false, true]) test(`Claude goal waits for common final
 
 test("Claude delivery timing separates native acknowledgement from the held canonical receipt", { timeout: 10_000 }, async t => {
   const timings = [];
-  const f = await suppliedCommonFixture(t, { onDeliveryTiming: event => timings.push(event) });
+  const f = await suppliedCommonFixture(t, { onDeliveryTiming: event => timings.push(event), hostDeliveryStages: ["host-prepared"] });
   const writing = Promise.withResolvers();
   const release = Promise.withResolvers();
   f.behavior.beforeAdmit = async () => { writing.resolve(); await release.promise; };
   const sending = f.conversation.send({ messageId: "timed-request", text: "Private message" });
   await writing.promise;
   assert.deepEqual(timings.map(event => event.stage), [
-    "received", "preparation-started", "authorized", "history-read", "state-read", "request-saved", "input-prepared",
-    "provider-started", "duplicate-checked", "native-history-read", "process-ready", "prompt-rendered", "metadata-ready",
+    "received", "preparation-started", "authorized", "history-read", "state-read", "request-saved", "host-prepared",
+    "input-prepared", "provider-started", "duplicate-checked", "native-history-read", "process-ready", "prompt-rendered", "metadata-ready",
     "runtime-ready", "dispatch-started", "native-acknowledged"
   ]);
   release.resolve();
   assert.equal((await sending).status, "accepted");
-  const admitted = timings.map(event => event.stage).slice(16);
+  const admitted = timings.map(event => event.stage).slice(17);
   assert.deepEqual(admitted, ["receipt-written", "state-active", "receipt-persisted", "admission-authorized", "turn-located", "accepted"]);
   await f.frame({ type: "result", subtype: "success", result: "Public answer" });
   await f.conversation.wait();
@@ -2394,6 +2394,26 @@ test("bound Main history budget transfers more than 30 complete messages through
   assert.equal(sent[1], "Prepare the question.");
 });
 
+test("bound Main treats a restart-interrupted attempt with a saved receipt as delivered, not uncertain", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools: false });
+  // The application restarted after native admission saved the authored
+  // message, but before the dispatch returned and cleared its attempt marker.
+  const attempt = { messageId: "admitted-before-restart", message: "Check the Preview.", displayMessage: "Check the Preview.",
+    attempted: true, threadId: f.conversationId, seen: {} };
+  await f.binding.state.write({ lastEngine: "claude", engines: { claude: { seen: {}, pending: attempt } } });
+  const unconfirmed = await f.conversation.read();
+  assert.equal(unconfirmed.status, "unconfirmed", "An attempt without a saved receipt stays uncertain");
+  assert.equal(unconfirmed.pendingRequest.messageId, attempt.messageId);
+  await f.binding.transcript.writeUserMessage({ messageId: attempt.messageId, text: attempt.displayMessage });
+  f.binding.transcript.history = async () => [{ id: "000001/user/", version: "v1", role: "user", engineId: "claude",
+    messageId: attempt.messageId, text: attempt.displayMessage }];
+  const settled = await f.conversation.read();
+  assert.equal(settled.status, "ready", "The saved receipt proves delivery, so Send stays available");
+  assert.equal(settled.pendingRequest, null);
+  await sendCommon(f, "after-restart");
+  assert.equal((await f.binding.state.read()).engines.claude.pending, undefined, "The next delivery settles the old marker");
+});
+
 test("bound Main cannot dispatch or retain a pending prompt when its history budget is unavailable", { timeout: 10_000 }, async t => {
   const f = await suppliedCommonFixture(t, { tools: false, representation: "native" });
   f.binding.transcript.history = async () => [{ id: "earlier", version: "v1", role: "user", text: "Earlier work." }];

package/test/codexClient.test.js

@@ -89,3 +89,23 @@ test("transport failure preserves its error code for pending requests", async ()
   await assert.rejects(result, { code: "assistant_codex_app_server_message_too_large" });
   assert.equal(client.isOpen(), false);
 });
+
+test("outgoing messages over the limit fail with the transport-limit code", async () => {
+  const client = new CodexAppServerJsonRpcClient({ endpoint: "ws://fixture", WebSocketImpl: Socket, maxMessageBytes: 10 });
+  await client.connect();
+  assert.throws(() => client.send({ payload: "x".repeat(20) }), {
+    code: "assistant_codex_app_server_message_too_large",
+    message: "Codex app-server message exceeded the configured transport limit."
+  });
+});
+
+test("message and timeout limits accept only positive integers", () => {
+  for (const invalid of [0, -1, 1.5, "abc", Number.NaN]) {
+    const client = new CodexAppServerJsonRpcClient({ maxMessageBytes: invalid, requestTimeoutMs: invalid });
+    assert.equal(client.maxMessageBytes, Number.POSITIVE_INFINITY);
+    assert.equal(client.requestTimeoutMs, 60_000);
+  }
+  const client = new CodexAppServerJsonRpcClient({ maxMessageBytes: 512, requestTimeoutMs: 25 });
+  assert.equal(client.maxMessageBytes, 512);
+  assert.equal(client.requestTimeoutMs, 25);
+});

package/test/codexConversationSession.test.js

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
 import { createConversationRuntime, createFileConversationStorage } from "../src/server/conversation/index.js";
-import { createCodexConversationStore } from "../src/server/conversation/agentRun.js";
+import { createCodexConversationStore } from "../src/server/conversation/codexConversationStore.js";
 import { createReentrantConversationStorage } from "../src/server/conversation/storage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";
 import { createConversationStreams } from "../src/server/conversation/streams.js";
@@ -1229,7 +1229,9 @@ async function fixture(t, options = {}) {
   t.after(async () => {
     try { for (const runtime of runtimes) await runtime.close(); }
     finally {
-      if (!options.execution) await execution.close();
+      // A supplied execution host is closed here too (its test may close it
+      // again): its native processes must stop before their folder is removed.
+      await execution.close();
       await rm(directory, { recursive: true, force: true });
     }
   });
@@ -3666,7 +3668,7 @@ for (const kind of ["tool", "reply"]) test(`completed Codex ${kind} wire preserv
     assert.equal(run.outerTurnId, receipt.messageId);
     const prepared = await f.conversation.prepareCompletedResponse(receipt, { signal: new AbortController().signal });
     assert.equal(prepared.text, raw);
-    const { readAssistantResponseEnvelope } = await import("../src/server/lib/assistantToolLoop.js");
+    const { readAssistantResponseEnvelope } = await import("../src/server/conversation/boundedToolLoop.js");
     const decoded = readAssistantResponseEnvelope(prepared.text);
     assert.deepEqual(decoded, value);
     if (kind === "tool") assert.equal(JSON.parse(decoded.arguments).value, handover);

package/test/codexConversationsCheckpoint.test.js

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createCodexConversationCommands } from "../src/server/conversation/codexConversations.js";
+
+const turnOutcomes = { USER_CANCELLED: "user_cancelled" };
+
+function persistentConversationFixture() {
+  const checkpoints = [];
+  const listeners = new Set();
+  const emit = (notification) => listeners.forEach((listener) => listener(notification));
+  const completed = (status) => emit({ method: "turn/completed", params: { threadId: "thread", turn: { id: "turn-1", status } } });
+  const provider = {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async readThreadStatus() { return {}; },
+    // Codex reports the interrupted turn while it is stopping.
+    async stopThreadForObservationLoss() { completed("interrupted"); }
+  };
+  const commands = createCodexConversationCommands({
+    async checkpoint(_sessionId, input) { checkpoints.push(input); },
+    conversationPreparation: { async context() { return { result: { provider } }; } },
+    namespace: (sessionId) => sessionId,
+    turnOutcomes
+  });
+  const state = commands.observeCodexConversation("session", "thread", provider);
+  const startTurn = () => emit({ method: "turn/started", params: { threadId: "thread", turn: { id: "turn-1", status: "inProgress" } } });
+  return { checkpoints, commands, completed, startTurn, state };
+}
+
+test("a temporary turn the person stops reaches its checkpoint as user cancelled", async () => {
+  const f = persistentConversationFixture();
+  f.startTurn();
+  await f.commands.stopCodexAppServerConversation("session", { conversationId: "thread", persistent: true });
+  assert.equal(f.checkpoints.length, 1);
+  assert.equal(f.checkpoints[0].turnOutcome, "user_cancelled");
+  assert.equal(f.checkpoints[0].status, "interrupted");
+  // The outcome belongs to the stopped turn only.
+  f.startTurn();
+  f.completed("completed");
+  assert.equal(f.checkpoints[1].turnOutcome, "");
+});
+
+test("closing temporary conversations leaves the turn outcome to its status", async () => {
+  const f = persistentConversationFixture();
+  f.startTurn();
+  await f.commands.closeCodexAppServerConversations("session");
+  assert.equal(f.checkpoints.length, 1);
+  assert.equal(f.checkpoints[0].turnOutcome, "");
+});

package/test/codexModelCatalog.test.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import { prepareCodexModelCatalog } from "../src/server/conversation/codexConfiguration.js";
-import { createCodexAppServerModelCatalogCache, codexAppServerProviderConnectionGeneration } from "../src/server/conversation/codexProvider.js";
+import { createCodexAppServerModelCatalogCache, codexAppServerProviderConnectionGeneration } from "../src/server/conversation/codexModelCatalog.js";
 import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
 
 async function fixture(t, source) {

package/test/codexProviderHome.test.js

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import {
+  codexProviderCatalogPath,
+  codexProviderFileConfiguration,
+  copyCodexProviderHome
+} from "../src/server/conversation/codexConfiguration.js";
+
+const provider = {
+  id: "fixture",
+  label: "Fixture",
+  baseUrl: "https://provider.invalid/v1",
+  webSearch: false,
+  models: [{ id: "fixture-model", defaultThinking: "medium" }]
+};
+
+async function homes(t) {
+  const root = await mkdtemp(path.join(os.tmpdir(), "codex-provider-home-"));
+  t.after(() => rm(root, { force: true, recursive: true }));
+  const sourceHome = path.join(root, "source");
+  const targetHome = path.join(root, "target");
+  await Promise.all([mkdir(sourceHome), mkdir(targetHome)]);
+  return { sourceHome, targetHome };
+}
+
+test("a copied provider home names its own catalogue", async t => {
+  const { sourceHome, targetHome } = await homes(t);
+  await writeFile(path.join(sourceHome, "config.toml"), codexProviderFileConfiguration(provider, "secret", sourceHome));
+  await writeFile(codexProviderCatalogPath(sourceHome), "{\"models\":[]}");
+
+  await copyCodexProviderHome(sourceHome, targetHome);
+
+  assert.equal(
+    await readFile(path.join(targetHome, "config.toml"), "utf8"),
+    codexProviderFileConfiguration(provider, "secret", targetHome)
+  );
+  assert.equal(await readFile(codexProviderCatalogPath(targetHome), "utf8"), "{\"models\":[]}");
+});
+
+test("a provider config that does not name its own catalogue is refused, not copied", async t => {
+  const { sourceHome, targetHome } = await homes(t);
+  const elsewhere = path.join(path.dirname(sourceHome), "elsewhere");
+  await writeFile(path.join(sourceHome, "config.toml"), codexProviderFileConfiguration(provider, "secret", elsewhere));
+  await writeFile(codexProviderCatalogPath(sourceHome), "{}");
+
+  await assert.rejects(copyCodexProviderHome(sourceHome, targetHome), /does not name its own model catalogue/);
+  await assert.rejects(readFile(path.join(targetHome, "config.toml")), { code: "ENOENT" });
+});

package/test/codexProviderSelection.test.js

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createCodexProviderSelection } from "../src/server/conversation/codexProviderSelection.js";
+
+function fixture() {
+  const calls = { contexts: [], ensured: [], remembered: [], acquired: [] };
+  const provider = {
+    ensureRuntime: () => "runtime"
+  };
+  const providerSessions = {
+    managed: new Map(),
+    owner: {
+      providers: new Map(),
+      async ensureSession(connection, threadId) {
+        calls.ensured.push({ sessionId: connection.sessionId, threadId });
+        return provider;
+      },
+      async acquireRuntime(input) {
+        calls.acquired.push(input.providerKey);
+        return input.operation();
+      }
+    },
+    context(sessionId, providerOptions) {
+      calls.contexts.push(sessionId);
+      return {
+        sessionId,
+        providerOptions,
+        providerKey: `key:${sessionId}`,
+        runOwner: {
+          runtimeLifecycle: {
+            rememberManagedSession: (providerKey, record) => calls.remembered.push({ providerKey, ...record })
+          }
+        }
+      };
+    }
+  };
+  const selection = createCodexProviderSelection({
+    providerSessions,
+    turnState: () => ({ active: false }),
+    helperLifecycle: null,
+    helperOwnershipError: null,
+    modelCatalogCacheMs: 1,
+    errorPrefix: ""
+  });
+  return { calls, selection };
+}
+
+test("session providers and managed records use the normalized session id", async () => {
+  const { calls, selection } = fixture();
+  await selection.ensureSessionProvider("  s1 ", { mode: "a" }, "thread-1");
+  selection.rememberManagedSession(" s1 ", { mode: "a" }, { executionRoot: "/root", workdir: "/work", threadId: "thread-1" });
+
+  assert.deepEqual(calls.ensured, [{ sessionId: "s1", threadId: "thread-1" }]);
+  assert.deepEqual(calls.remembered, [{
+    providerKey: "key:s1",
+    providerOptions: { mode: "a" },
+    sessionId: "s1",
+    executionRoot: "/root",
+    threadId: "thread-1",
+    workdir: "/work"
+  }]);
+  assert.equal(selection.codexAppServerSessionObserverOptions(" s1 ", {}).providerKey, "key:s1");
+});
+
+test("the visible terminal runtime acquires the provider key of the normalized session", async () => {
+  const { calls, selection } = fixture();
+  await selection.codexAppServerRuntimeForVisibleTerminal(" s1 ", {}, { workdir: "" }, {}, async () => ({}));
+  assert.deepEqual(calls.ensured, [{ sessionId: "s1", threadId: undefined }]);
+  assert.deepEqual(calls.acquired, ["key:s1"]);
+  assert.ok(calls.contexts.every(sessionId => sessionId === "s1"));
+});