@jskit-ai/assistant-core 0.1.239 → 0.1.241

package/test/codexTurn.test.js

@@ -7,8 +7,10 @@ import test from "node:test";
 import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";
 import { createConversationStreams } from "../src/server/conversation/streams.js";
-import { sendCodexAppServerPrompt, CodexAppServerAgentProvider } from "../src/server/conversation/codexProvider.js";
+import { sendCodexAppServerPrompt, CodexAppServerAgentProvider, codexAppServerDeliveredTurn } from "../src/server/conversation/codexProvider.js";
 import { createCodexHelperThreadLedgerOwner } from "../src/server/conversation/codexHelperThreadLedger.js";
+import { createCodexSessionReconciliation } from "../src/server/conversation/codexSessionReconciliation.js";
+import { createCodexSessionCleanup } from "../src/server/conversation/codexSessionCleanup.js";
 import {
   waitForCodexAppServerTurn,
   createCodexAppServerRunOwner,
@@ -432,6 +434,120 @@ test("native phase changes require the current exact turn and retain its active
   assert.equal(f.writes.length, 1);
 });
 
+test("a settling write for a predecessor turn cannot end the active successor run", async () => {
+  for (const state of ["active", "finalizing", "starting"]) {
+    const f = runFixture({ state, providerTurnId: "successor" });
+    const owner = createCodexAppServerRunOwner();
+    const successor = f.read();
+    for (const runState of [CODEX_APP_SERVER_RUN_STATE.COMPLETED, CODEX_APP_SERVER_RUN_STATE.FAILED,
+      CODEX_APP_SERVER_RUN_STATE.INTERRUPTED]) {
+      const result = await owner.writeAgentRun(f.runtime, "session-1", { runState, status: runState,
+        threadId: "thread-1", turnId: "turn-1", error: "Predecessor outcome." });
+      assert.equal(result.wrote, false);
+      assert.equal(result.stale.currentTurnId, "successor");
+      assert.equal(result.stale.patchTurnId, "turn-1");
+    }
+    assert.deepEqual(f.read(), successor);
+    assert.deepEqual(f.writes, []);
+    const settled = await owner.writeAgentRun(f.runtime, "session-1", { runState: CODEX_APP_SERVER_RUN_STATE.COMPLETED,
+      status: "completed", threadId: "thread-1", turnId: "successor" });
+    assert.equal(settled.wrote, true, "The successor's own outcome still settles it");
+  }
+});
+
+test("startup unsubscribe skips session records without an identity instead of inventing one", async () => {
+  const prepared = [];
+  const reconciliation = createCodexSessionReconciliation({
+    providerSessions: { owner: { async unsubscribeSessionThread(_key, sessionId) {
+      return { ok: true, sessionId, status: "unsubscribed" };
+    } } },
+    namespace: sessionId => `project:${sessionId}`,
+    debugLog() {}, debugError: error => error
+  });
+  const result = await reconciliation.unsubscribeSessions([{ title: "no identity" }, { id: "session-1" },
+    "session-1", { sessionId: "session-2" }], {
+    enabled: true,
+    async session(sessionId) { prepared.push(sessionId); return { threadId: `thread-${sessionId}` }; }
+  });
+  assert.deepEqual(prepared, ["session-1", "session-2"]);
+  assert.equal(JSON.stringify(result).includes("[object Object]"), false);
+});
+
+test("session cleanup owns its single-flight closures and restricted record without consumer state", async () => {
+  const sessionClosures = new Map();
+  const releases = [];
+  const held = [];
+  const cleanupOwner = createCodexSessionCleanup({
+    namespace: id => `project:${id}`,
+    runOwner: {},
+    sessionClosures,
+    providerSessions: { owner: {
+      async drainThreadEnvironmentTasks() {},
+      async releaseSession(sessionKey) {
+        const gate = Promise.withResolvers();
+        held.push(gate);
+        await gate.promise;
+        releases.push(sessionKey);
+        return { exitFailure: null };
+      }
+    } },
+    helperLifecycle: { assertRestored() {}, async restoreThreads() {}, assertRetired() {}, async retireAll() {} },
+    journal: { clearSessionRecoveryTimers() {} },
+    conversations: { async closeCodexAppServerConversations() {} },
+    debugLog() {}, debugError: error => error
+  });
+  const reads = [];
+  const publicChecks = [];
+  const cleanup = (label, restricted = false) => ({
+    sessionKey: "project:session-1",
+    restricted,
+    async assertPublicAccess() { publicChecks.push(label); },
+    async read() {
+      reads.push(label);
+      return { helpers: {}, projectRuntimeRoot: "", session: {}, async complete() {} };
+    }
+  });
+  const flush = () => new Promise(resolve => setImmediate(resolve));
+
+  const first = cleanupOwner.closeSession("session-1", cleanup("public"));
+  const joined = cleanupOwner.closeSession("session-1", cleanup("joined"));
+  assert.equal(sessionClosures.size, 1, "One closure per session key");
+  const restricted = cleanupOwner.closeSession("session-1", cleanup("restricted", true));
+  await flush();
+  held.shift().resolve();
+  await Promise.all([first, joined]);
+  await flush();
+  assert.deepEqual(reads, ["public", "restricted"], "A restricted close waits for the public one, then runs its own");
+  const publicAfterRestricted = cleanupOwner.closeSession("session-1", cleanup("late-public"));
+  await flush();
+  assert.deepEqual(publicChecks, ["late-public"], "Joining a restricted close proves public access first");
+  held.shift().resolve();
+  await Promise.all([restricted, publicAfterRestricted]);
+  assert.deepEqual(reads, ["public", "restricted"]);
+  assert.deepEqual(releases, ["project:session-1", "project:session-1"]);
+  assert.equal(sessionClosures.size, 0);
+});
+
+test("the run owner's session closures are the ones its runtime lifecycle drains", async () => {
+  const draining = Promise.withResolvers();
+  const owner = createCodexAppServerRunOwner({ providerSessions: { owner: { drainThreadEnvironmentTasks: () => draining.promise } } });
+  const closing = owner.closeSession("session-1", { sessionKey: "project:session-1",
+    async read() { throw new Error("Controlled preparation stop"); } });
+  assert.ok(owner.runtimeLifecycle.sessionClosures.get("project:session-1") instanceof Promise);
+  draining.resolve();
+  await assert.rejects(closing, /Controlled preparation stop/);
+  assert.equal(owner.runtimeLifecycle.sessionClosures.size, 0);
+});
+
+test("the run owner exposes only operations its consumers use, not facet recovery state", () => {
+  const owner = createCodexAppServerRunOwner();
+  for (const internal of ["completedTurns", "automaticHookThreads", "conversationTurnStarts", "reasoningPersistQueues",
+    "threadReconciliations", "reasoningTurns", "finalAssistantResults", "mirroredTerminalItems", "clearActiveTimer",
+    "clearFinalizingTimer", "adoptSuccessorTurn", "markTurnActive", "markTurnFinalizing", "checkManagedConnection"]) {
+    assert.equal(Object.hasOwn(owner, internal), false, internal);
+  }
+});
+
 test("original pending ownership and terminal outer identity are preserved without weakening run-state errors", () => {
   const run = { inputSource: "chat", pendingUserMessageClientIds: [0, false, " first ", "second"] };
   assert.deepEqual(codexAppServerPendingUserMessageOwnership(run, "first"), { clientId: "first", inputSource: "chat" });
@@ -978,9 +1094,9 @@ test("original settlement clears the same recovery timers and skips stale idle c
   t.after(() => timers.forEach(clearTimeout));
   owner.activeTimers.set(`project:${sessionId}`, timer());
   owner.activeTimers.set("project:other", timer());
-  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, turnId), timer());
-  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, "older"), timer());
-  owner.finalizingTimers.set(owner.resultFinalizationKey("other", threadId, turnId), timer());
+  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, turnId), { timer: timer() });
+  owner.finalizingTimers.set(owner.resultFinalizationKey(sessionId, threadId, "older"), { timer: timer() });
+  owner.finalizingTimers.set(owner.resultFinalizationKey("other", threadId, turnId), { timer: timer() });
   f.run = { ...f.run, state: "interrupted", providerStatus: "interrupted" };
   const result = await owner.markTurnIdle(sessionId, { threadId, turnId, status: "completed" });
   assert.equal(result.processed, false);
@@ -2373,6 +2489,72 @@ for (const [status, cause, explicit, expected] of [
   });
 }
 
+test("a native stop outcome rereads the run after its history read and leaves an adopted successor running", async () => {
+  const notices = [];
+  const checkpoints = [];
+  const f = await receiptFixture({
+    outcomeNotice(_runtime, sessionId, threadId, turnId, outcome) { notices.push({ sessionId, threadId, turnId, outcome }); },
+    checkpoint(sessionId, value) { checkpoints.push({ sessionId, ...value }); }
+  });
+  f.history = [turn(f.turnId, "interrupted")];
+  const reading = Promise.withResolvers(); const release = Promise.withResolvers();
+  const list = f.provider.listThreadTurns;
+  f.provider.listThreadTurns = async (...args) => {
+    const snapshot = await list(...args);
+    reading.resolve(); await release.promise;
+    return snapshot;
+  };
+  try {
+    const pending = f.owner.stopTurnWithProviderFailure(f.sessionId, f.threadId, f.turnId, {
+      status: "interrupted", provider: f.provider, verifyInactive: false
+    });
+    await reading.promise;
+    f.run = { ...f.run, providerTurnId: "successor", state: "active", providerStatus: "inProgress" };
+    const successorRun = structuredClone(f.run);
+    release.resolve();
+    assert.equal((await pending).reason, "stale_turn_state");
+    assert.deepEqual(f.run, successorRun);
+    assert.deepEqual(notices, []);
+    assert.deepEqual(checkpoints, []);
+  } finally {
+    f.owner.clearSessionRecoveryTimers(f.sessionId);
+  }
+});
+
+test("a delivered native turn reads its identity, status and provider error from the one sendTurn shape", async () => {
+  const provider = new CodexAppServerAgentProvider({}, { credentials: { assertCurrent() {} } });
+  const responses = [
+    { turn: { id: "turn-failed", status: "failed", error: { message: "You've hit your usage limit." } } },
+    { turnId: "turn-flat", status: "failed", error: "Flat provider failure." },
+    { turn: { id: "turn-running", status: "inProgress" } }
+  ];
+  provider.client = { isOpen: () => true, close() {}, async request(method) {
+    assert.equal(method, "turn/start");
+    return responses.shift();
+  } };
+  try {
+    const delivered = [];
+    for (let index = 0; index < 3; index += 1) {
+      delivered.push(codexAppServerDeliveredTurn(await sendCodexAppServerPrompt({ provider, prompt: "Go", threadId: "thread-1" })));
+    }
+    assert.deepEqual(delivered, [
+      { turnId: "turn-failed", status: "failed", error: "You've hit your usage limit." },
+      { turnId: "turn-flat", status: "failed", error: "Flat provider failure." },
+      { turnId: "turn-running", status: "inProgress", error: "" }
+    ]);
+  } finally {
+    provider.close();
+  }
+});
+
+test("a host provider that returns its raw turn unnormalized still delivers its status and error", async () => {
+  const provider = { async sendTurn() {
+    return { id: "t", raw: { status: "failed", error: { message: "boom" } } };
+  } };
+  const delivered = codexAppServerDeliveredTurn(await sendCodexAppServerPrompt({ provider, prompt: "Go", threadId: "thread-1" }));
+  assert.deepEqual(delivered, { turnId: "t", status: "failed", error: "boom" });
+});
+
 test("user Stop records its exact cause before queued native completion while the interrupt reply is held", async () => {
   const notices = [];
   const f = await receiptFixture({ outcomeNotice(_runtime, sessionId, threadId, turnId, outcome) {
@@ -2595,7 +2777,7 @@ for (const change of ["concurrent", "cleanup", "successor"]) {
     t.mock.timers.tick(20);
     await reading.promise;
     assert.equal(owner.finalizingTimers.size, 1, "Firing does not discard the first post-read clock");
-    const expiry = [...owner.finalizingTimers.values()][0].finalizingRecovery;
+    const expiry = [...owner.finalizingTimers.values()][0].recovery;
     assert.ok(expiry instanceof Promise);
     let pending;
     if (change === "concurrent") pending = owner.completeTurn(sessionId, threadId, turnId, { verifyInactive: false });
@@ -2612,6 +2794,40 @@ for (const change of ["concurrent", "cleanup", "successor"]) {
   });
 }
 
+test("native delivery failure rereads the run after its last history read and cannot settle an adopted successor", async t => {
+  t.mock.timers.enable({ apis: ["Date"], now: Date.parse("2026-10-07T00:00:00Z") });
+  const f = await settlementFixture();
+  const { sessionId, threadId, turnId } = f;
+  const owner = createCodexAppServerRunOwner({ finalizingGraceMs: 500,
+    createRuntime: async () => ({ store: f.store, getSession: async () => ({ sessionId, agentRuns: [structuredClone(f.run)] }) }),
+    createStore: async () => f.store, acquireProvider: async () => f.provider,
+    checkpoint: async (id, input) => { f.checkpoints.push({ sessionId: id, ...input }); }
+  });
+  t.after(() => owner.clearSessionRecoveryTimers(sessionId));
+  f.run = { ...f.run, state: "finalizing", providerStatus: "completed", finishedAt: new Date().toISOString() };
+  f.history = [turn(turnId, "completed")];
+  t.mock.timers.tick(501);
+  const reading = Promise.withResolvers(); const release = Promise.withResolvers();
+  const list = f.provider.listThreadTurns;
+  let reads = 0;
+  f.provider.listThreadTurns = async (...args) => {
+    const snapshot = await list(...args);
+    reads += 1;
+    if (reads === 2) { reading.resolve(); await release.promise; }
+    return snapshot;
+  };
+  const pending = owner.completeTurn(sessionId, threadId, turnId, { verifyInactive: false });
+  await reading.promise;
+  f.run = { ...f.run, providerTurnId: "successor", state: "active", providerStatus: "inProgress" };
+  const successorRun = structuredClone(f.run);
+  release.resolve();
+  const result = await pending;
+  assert.equal(result.reason, "stale_turn_state");
+  assert.deepEqual(f.run, successorRun, "The predecessor's delivery failure cannot settle the successor");
+  assert.deepEqual(f.checkpoints, []);
+  assert.deepEqual(await f.replies(), []);
+});
+
 
 test("native after-history grace retries a rejected expiry read without granting another interval", async t => {
   t.mock.timers.enable({ apis: ["Date"], now: Date.parse("2026-10-07T00:00:00Z") });
@@ -2643,7 +2859,7 @@ test("native after-history grace retries a rejected expiry read without granting
   t.mock.timers.tick(20);
   await failedRead.promise;
   const timer = [...owner.finalizingTimers.values()][0];
-  const expiry = timer.finalizingRecovery;
+  const expiry = timer.recovery;
   const rejected = assert.rejects(expiry, /Controlled transient session read failure/);
   release.resolve();
   await rejected;

package/test/conversationAgentRun.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { conversationAgentRunEvent, conversationAgentRunRecord, createCodexConversationRunStore, createCodexConversationStore } from "../src/server/conversation/agentRun.js";
+import { conversationAgentRunEvent, conversationAgentRunRecord } from "../src/server/conversation/agentRun.js";
+import { createCodexConversationRunStore, createCodexConversationStore } from "../src/server/conversation/codexConversationStore.js";
 import { createMemoryConversationStorage } from "../src/server/conversation/memoryStorage.js";
 import { createReentrantConversationStorage } from "../src/server/conversation/storage.js";
 import { createConversationTranscript } from "../src/server/conversation/transcript.js";

package/test/conversationAttachments.test.js

@@ -3,8 +3,11 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 import { codexLocalImageInput, codexTurnInput } from "../src/server/conversation/codexProvider.js";
-import { createConversationAttachmentReader } from "../src/server/conversation/attachments.js";
-import { conversationAttachmentManifest, prepareConversationAttachmentMessage } from "../src/shared/conversation/attachments.js";
+import { conversationAttachmentIds, createConversationAttachmentReader } from "../src/server/conversation/attachments.js";
+import { attachmentIdsField } from "../src/shared/index.js";
+import { ASSISTANT_ATTACHMENT_MAX_ITEMS as CLIENT_ATTACHMENT_MAX_ITEMS } from "../src/client/conversation/useAssistantAttachments.js";
+import { ASSISTANT_ATTACHMENT_ID_MAX_LENGTH, ASSISTANT_ATTACHMENT_MAX_ITEMS, conversationAttachmentManifest,
+  prepareConversationAttachmentMessage } from "../src/shared/conversation/attachments.js";
 
 const image = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aN7sAAAAASUVORK5CYII=", "base64");
 const receipt = { attachmentId: "picture", fileName: "picture.png", size: image.length };
@@ -253,3 +256,25 @@ test("attachment validation displays the application's configured binary or deci
     }
   }
 });
+
+test("one attachment-ID limit governs the schema field, the server check, continuity batches and the composer", async () => {
+  assert.equal(attachmentIdsField.maxItems, ASSISTANT_ATTACHMENT_MAX_ITEMS);
+  assert.equal(attachmentIdsField.items.maxLength, ASSISTANT_ATTACHMENT_ID_MAX_LENGTH);
+  assert.equal(CLIENT_ATTACHMENT_MAX_ITEMS, ASSISTANT_ATTACHMENT_MAX_ITEMS);
+  const ids = Array.from({ length: ASSISTANT_ATTACHMENT_MAX_ITEMS }, (_, index) => `file-${index}`);
+  assert.deepEqual(conversationAttachmentIds(ids), ids);
+  assert.throws(() => conversationAttachmentIds([...ids, "one-too-many"]), { code: "conversation_invalid_attachments" });
+  assert.deepEqual(conversationAttachmentIds(["x".repeat(ASSISTANT_ATTACHMENT_ID_MAX_LENGTH)]).length, 1);
+  assert.throws(() => conversationAttachmentIds(["x".repeat(ASSISTANT_ATTACHMENT_ID_MAX_LENGTH + 1)]), { code: "conversation_invalid_attachments" });
+  const batches = [];
+  const reader = createConversationAttachmentReader({ context, conversationId: "one", signal: new AbortController().signal,
+    authorize: async () => {}, types: ["text"], maximumBytes: 1024 * 1024,
+    attachments: { resolve: ({ attachmentIds }) => {
+      batches.push(attachmentIds.length);
+      return { attachments: attachmentIds.map(attachmentId => ({ attachmentId, fileName: `${attachmentId}.txt`, size: 1 })),
+        content: [{ type: "text", text: "x" }] };
+    } } });
+  const continued = await reader([...ids, "one-more"].map(attachmentId => ({ attachmentId })));
+  assert.deepEqual(batches, [ASSISTANT_ATTACHMENT_MAX_ITEMS, 1]);
+  assert.equal(continued.attachments.length, ASSISTANT_ATTACHMENT_MAX_ITEMS + 1);
+});

package/test/conversationDeliveryTiming.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createConversationDeliveryTiming } from "../src/server/conversation/deliveryTiming.js";
+import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 
 test("native engines share bounded, content-free timing and independent message identities", () => {
   for (const engine of ["codex", "claude", "opencode"]) {
@@ -48,3 +49,23 @@ test("diagnostic failures and unfinished asynchronous observers never block deli
   await Promise.resolve();
   pending.resolve();
 });
+
+test("host preparation stages are reported only when the host declares them", () => {
+  const events = [];
+  const report = event => events.push(event.stage);
+  const plain = createConversationDeliveryTiming({ engine: "claude", conversationId: "chat", messageId: "one", report });
+  plain("received"); plain("host-step");
+  assert.deepEqual(events, ["received"]);
+  const declared = createConversationDeliveryTiming({ engine: "claude", conversationId: "chat", messageId: "two", report,
+    hostStages: ["host-step"] });
+  declared("host-step"); declared("other-step");
+  assert.deepEqual(events, ["received", "host-step"]);
+});
+
+test("conversation runtimes reject malformed host delivery stage names", () => {
+  for (const hostDeliveryStages of ["host-step", ["Host"], ["host step"], [7], ["-step"]]) {
+    assert.throws(() => createConversationRuntime({ authorize: () => true, hostDeliveryStages }),
+      { name: "TypeError", message: "Host delivery stages must be lowercase hyphenated names." });
+  }
+  createConversationRuntime({ authorize: () => true, storage: createMemoryConversationStorage(), hostDeliveryStages: ["git-step"] });
+});

package/test/conversationNormalize.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { normalizeNullableText } from "../src/server/conversation/normalize.js";
+
+test("conversation text normalization blanks only null and undefined", () => {
+  assert.equal(normalizeNullableText(null), "");
+  assert.equal(normalizeNullableText(undefined), "");
+  assert.equal(normalizeNullableText(0), "0");
+  assert.equal(normalizeNullableText(false), "false");
+  assert.equal(normalizeNullableText("  id  "), "id");
+});

package/test/fixtures/nestedListQuestionMessage.md

@@ -0,0 +1,37 @@
+Here's how I'd run a final sweep in three steps: I do a systematic pass on my own first, then a short session with you for the parts that need you, then I tidy up.
+
+**Step 1: I sweep on my own (no need for you)**
+- **Click everything.** I go through every visible control and compare it against the specs: every button, the + menu, every right-click menu (bots, messages, sections, Library items), every keyboard shortcut on the shortcuts sheet, and every settings row. Anything with no spec is a gap.
+- **Gather the "unverified" lists.** Every spec has one, and I'll merge them all into a single gap list. Each item gets labelled as one of three kinds:
+  - **I can observe it now:** for example, editing and deleting pages, or a bot made from a template.
+  - **Needs you:** real accounts, audio, a second account, payment, your phone, links that open in a browser.
+  - **Can't be observed at all.**
+- **Output:** one gap list, saved to your Session Dropzone, with every item marked done, observable, needs you, or impossible.
+
+**Step 2: a session with you, for the "needs you" items and things only you know about**
+- **You drive the reference over VNC**, using it as you normally would: your knowledge of features, the test Google account, the phone app, links opening in your browser.
+- **I record the screen** at a low frame rate while you work, and capture stills when you tell me something interesting is happening. Just tell me what you did in plain words ("now I'm connecting Gmail", "this is the share link in my browser").
+- **Things outside the reference machine:** put screenshots in the Session Dropzone, for example from the mobile app, the help pages, or emails it sends. I'll file them.
+- **What I need from you:**
+  - which features you know or suspect exist that I haven't covered (I'll ask about specific suspects from my list)
+  - the test Google account, so I can see the real connected states
+  - your call on anything that sends real data or costs money
+
+**Step 3: I tidy up**
+- **For mercbot:**
+  - Newly discovered areas go to mercbot as additions to the feature map.
+  - Each one gets a spec, sent when you or mercbot ask for it. The phase-2 rules allow that.
+- **For you:** a final coverage summary.
+
+**One thing to keep in mind:** you'll see more of the original than mercbot ever should. During this phase, keep sending findings through me rather than straight to mercbot.
+
+[1] Shall I start Step 1 (the solo sweep and gap list) now?
+Possible answers:
+- Yes, start now
+- Wait until I'm ready to do Step 2 as well
+
+[2] For Step 2, how would you like to work?
+Possible answers:
+- I drive over VNC while you record
+- I'll put screenshots in the Dropzone
+- A mix of both

package/test/frameworkActions.test.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { readdir } from "node:fs/promises";
 import { createActionCatalogue } from "@jskit-ai/kernel/server/actions";
-import { resolveStructuredSchemaTransportSchema } from "@jskit-ai/kernel/shared/validators";
+import { resolveSchemaTransportSchemaDefinition } from "@jskit-ai/kernel/shared/validators";
 import { returnJsonApiData } from "@jskit-ai/http-runtime/shared";
 import { createServiceToolCatalog } from "../src/server/lib/serviceToolCatalog.js";
 import { createAssistantActions } from "../../assistant-runtime/src/server/actions.js";
@@ -95,7 +95,7 @@ test("every account, workspace, console and assistant automation action has a co
     direct++;
     assert.ok(assistant.description, spec.id);
     assert.equal(typeof assistant.transformResult, "function", spec.id);
-    assert.ok(resolveStructuredSchemaTransportSchema(assistant.output), spec.id);
+    assert.ok(resolveSchemaTransportSchemaDefinition(assistant.output), spec.id);
     assert.ok(fixtures[spec.id], `Add execution coverage for ${spec.id}`);
   }
   assert.equal(direct, 22);

package/test/longTextBlocks.test.js

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { parseLongTextReviewBlocks } from "../src/shared/conversation/longTextBlocks.js";
+import { parseNumberedQuestionPrompt } from "../src/shared/conversation/numberedQuestionSugar.js";
+
+const message = readFileSync(new URL("./fixtures/nestedListQuestionMessage.md", import.meta.url), "utf8");
+
+function outline(blocks = []) {
+  return blocks.map((block) => {
+    if (block.type !== "ul" && block.type !== "ol") {
+      return `${block.type}: ${block.text.slice(0, 40)}`;
+    }
+    return {
+      [block.type]: block.items.map((item) => (
+        item.blocks ? { [item.text.slice(0, 40)]: outline(item.blocks) } : item.text.slice(0, 40)
+      ))
+    };
+  });
+}
+
+test("a question message keeps its intro paragraphs and nested lists apart from the question cards", () => {
+  const prompt = parseNumberedQuestionPrompt(message);
+  assert.deepEqual(prompt.questions.map((question) => [question.label, question.choices.length]), [
+    ["Shall I start Step 1 (the solo sweep and gap list) now?", 2],
+    ["For Step 2, how would you like to work?", 3]
+  ]);
+  assert.equal(prompt.outro, "");
+
+  assert.deepEqual(outline(parseLongTextReviewBlocks(prompt.intro)), [
+    "paragraph: Here's how I'd run a final sweep in thre",
+    "paragraph: **Step 1: I sweep on my own (no need for",
+    {
+      ul: [
+        "**Click everything.** I go through every",
+        {
+          "**Gather the \"unverified\" lists.** Every": [
+            { ul: ["**I can observe it now:** for example, e", "**Needs you:** real accounts, audio, a s", "**Can't be observed at all.**"] }
+          ]
+        },
+        "**Output:** one gap list, saved to your "
+      ]
+    },
+    "paragraph: **Step 2: a session with you, for the \"n",
+    {
+      ul: [
+        "**You drive the reference over VNC**, us",
+        "**I record the screen** at a low frame r",
+        "**Things outside the reference machine:*",
+        {
+          "**What I need from you:**": [
+            { ul: ["which features you know or suspect exist", "the test Google account, so I can see th", "your call on anything that sends real da"] }
+          ]
+        }
+      ]
+    },
+    "paragraph: **Step 3: I tidy up**",
+    {
+      ul: [
+        {
+          "**For mercbot:**": [
+            { ul: ["Newly discovered areas go to mercbot as ", "Each one gets a spec, sent when you or m"] }
+          ]
+        },
+        "**For you:** a final coverage summary."
+      ]
+    },
+    "paragraph: **One thing to keep in mind:** you'll se"
+  ]);
+});
+
+test("nested lists follow item content indentation and return to the parent level", () => {
+  assert.deepEqual(parseLongTextReviewBlocks([
+    "1. First",
+    "   - child a",
+    "\t- child b",
+    "      1) grandchild",
+    "2. Second",
+    "  - too shallow for the ordered item, so a sibling list item"
+  ].join("\n")), [
+    {
+      items: [
+        {
+          blocks: [{
+            items: [
+              { text: "child a" },
+              { blocks: [{ items: [{ text: "grandchild" }], type: "ol" }], text: "child b" }
+            ],
+            type: "ul"
+          }],
+          text: "First"
+        },
+        { text: "Second" }
+      ],
+      type: "ol"
+    },
+    {
+      items: [{ text: "too shallow for the ordered item, so a sibling list item" }],
+      type: "ul"
+    }
+  ]);
+});

package/test/messageDelivery.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { nextTick, ref } from "vue";
-import { createAssistantMessageDelivery, unmatchedOptimisticMessages } from "../src/client/conversation/messageDelivery.js";
+import { createAssistantMessageDelivery, draftWithRestoredMessage, unmatchedOptimisticMessages } from "../src/client/conversation/messageDelivery.js";
 import { normalizeConversationTurn } from "../src/shared/conversation/patches.js";
 
 test("proven no-admission releases only the exact uncertain message without accepting or losing its payload", async () => {
@@ -429,3 +429,9 @@ test("a deliberate new message can follow known uncertainty without resending th
   assert.equal(delivery.find("old").status, "uncertain");
   assert.equal(delivery.find("new").status, "accepted");
 });
+
+test("a restored message leads the draft once", () => {
+  assert.equal(draftWithRestoredMessage("First", ""), "First");
+  assert.equal(draftWithRestoredMessage("First", "New draft"), "First\n\nNew draft");
+  assert.equal(draftWithRestoredMessage("First", "First\n\nNew draft"), "First\n\nNew draft");
+});

package/test/openCodeClient.test.js

@@ -699,3 +699,23 @@ test("stopped native WAL inspection reads newest committed OpenCode rows without
   }), /Native storage changed during inspection/u);
   await assert.rejects(lstat(path.dirname(snapshot)), { code: "ENOENT" });
 });
+
+test("OpenCode message reads continue with older native pages through the before cursor", async () => {
+  const requests = [];
+  const client = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:4096", password: "private",
+    fetchImpl: async (url) => {
+      requests.push(new URL(url).search);
+      const older = new URL(url).searchParams.get("before");
+      return new Response(JSON.stringify([{ info: { id: older ? "msg_old" : "msg_new", role: "user" }, parts: [] }]), {
+        headers: older ? {} : { "x-next-cursor": "opaque+/=" }
+      });
+    }
+  }).forDirectory("/work/selected");
+  const newest = await client.messages("ses_paged", { limit: 1 });
+  assert.equal(newest.nextCursor, "opaque+/=");
+  assert.equal(newest.data[0].id, "msg_new");
+  const older = await client.messages("ses_paged", { limit: 1, before: newest.nextCursor });
+  assert.equal(older.data[0].id, "msg_old");
+  assert.equal("nextCursor" in older, false);
+  assert.deepEqual(requests, ["?limit=1", `?limit=1&before=${encodeURIComponent("opaque+/=")}`]);
+});

package/test/openCodeRuntime.test.js

@@ -773,7 +773,7 @@ test("credential publication refuses another provider and unowned consumers befo
     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" });
+    }), { 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, []);