@jskit-ai/assistant-core 0.1.214 → 0.1.216

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.214",
-    "@jskit-ai/http-runtime": "0.1.234",
-    "@jskit-ai/kernel": "0.1.236",
+    "@jskit-ai/assistant-core": "0.1.216",
+    "@jskit-ai/http-runtime": "0.1.236",
+    "@jskit-ai/kernel": "0.1.238",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.1.53",
-    "@jskit-ai/connectors-catalog": "0.1.53"
+    "@jskit-ai/connectors-core": "0.1.55",
+    "@jskit-ai/connectors-catalog": "0.1.55"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.214",
+  "version": "0.1.216",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -47,8 +47,8 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/resource-core": "0.1.178",
-    "@jskit-ai/resource-crud-core": "0.1.178",
+    "@jskit-ai/resource-core": "0.1.180",
+    "@jskit-ai/resource-crud-core": "0.1.180",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -57,8 +57,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.234",
-    "@jskit-ai/kernel": "0.1.236",
+    "@jskit-ai/http-runtime": "0.1.236",
+    "@jskit-ai/kernel": "0.1.238",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/client/conversation/AssistantTranscript.vue

@@ -139,7 +139,8 @@
             class="assistant-transcript__message assistant-transcript__message--user"
             :class="{
               'assistant-transcript__message--pending': entry.turn.optimistic?.status === 'pending',
-              'assistant-transcript__message--failed': entry.turn.optimistic?.status === 'failed'
+              'assistant-transcript__message--failed': entry.turn.optimistic?.status === 'failed',
+              'assistant-transcript__message--unconfirmed': Boolean(entry.delivery)
             }"
           >
             <div
@@ -175,6 +176,12 @@
               <time v-if="entry.message.displayAt">{{ entry.message.displayAt }}</time>
               <span v-if="entry.turn.optimistic?.status === 'pending'" role="status">Pending</span>
             </div>
+            <div v-if="entry.delivery" class="assistant-transcript__unconfirmed-delivery">
+              <AssistantConversationStatus
+                :message="{ ...entry.delivery, text: 'Delivery unconfirmed' }"
+                @check-delivery="emit('check-delivery', $event)"
+              />
+            </div>
             <slot name="user-message-actions" :message="entry.message" :turn="entry.turn" />
             <div
               v-if="entry.turn.optimistic?.status === 'failed'"
@@ -584,8 +591,11 @@ const displayEntries = computed(() => {
   const entries = [];
   for (const [index, turn] of props.turns.entries()) {
     const turnId = String(turn.turnId || index + 1);
+    // A delivery notice belongs to its exact user message, not the previous reply.
+    const userDelivery = turn.user && turn.system?.delivery && turn.system.delivery.messageId === turn.user.messageId
+      ? turn.system : null;
     const messages = [
-      turn.system && { ...turn.system, role: "system" },
+      turn.system && !userDelivery && { ...turn.system, role: "system" },
       turn.user && { ...turn.user, role: "user" },
       ...conversationAgentMessages(turn)
     ].filter(Boolean);
@@ -604,6 +614,7 @@ const displayEntries = computed(() => {
       } else {
         entries.push({
           key, role, turn: { ...turn, turnId }, message: displayed,
+          delivery: role === "user" ? userDelivery : null,
           ...(role === "thinking" ? { messages: [{ ...displayed, key }] } : {})
         });
       }
@@ -1431,6 +1442,26 @@ watch(() => props.visible, (visible) => {
   margin-top: -0.15rem;
 }
 
+.assistant-transcript__message--user.assistant-transcript__message--unconfirmed {
+  background: rgba(var(--v-theme-warning), 0.08);
+  border: 1px solid rgba(var(--v-theme-warning), 0.6);
+}
+
+.assistant-transcript__unconfirmed-delivery {
+  border-top: 1px solid rgba(var(--v-theme-warning), 0.4);
+  font-size: 0.875rem;
+  padding-top: 0.65rem;
+}
+
+.assistant-transcript__unconfirmed-delivery :deep(p:first-child) {
+  font-weight: 700;
+  margin-bottom: 0.4rem;
+}
+
+.assistant-transcript__unconfirmed-delivery :deep(p) {
+  overflow-wrap: anywhere;
+}
+
 .assistant-transcript__optimistic-failure {
   align-items: center;
   color: rgba(var(--v-theme-error), 0.92);

package/src/client/conversation/messageDelivery.js

@@ -111,6 +111,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     const ownerPendingSends = pendingSends;
     const current = () => pendingSends === ownerPendingSends && isCurrent();
     const predecessor = deliveryTail;
+    const knownUncertain = new Set(state.messages.filter(entry => entry.status === "uncertain").map(entry => entry.id));
     const settled = Promise.withResolvers();
     deliveryTail = settled.promise;
     ownerPendingSends.set(messageId, settled);
@@ -132,7 +133,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     try {
       if (predecessor) await predecessor;
       if (!current()) return false;
-      if (uncertainOnError && state.messages.some(entry => entry.id !== messageId && entry.status === "uncertain")) {
+      if (uncertainOnError && state.messages.some(entry => entry.id !== messageId && entry.status === "uncertain" && !knownUncertain.has(entry.id))) {
         fail(messageId, "Check the previous message's delivery before sending again.");
         return false;
       }

package/src/client/conversation/useAssistantSuggestions.js

@@ -3,7 +3,7 @@ import { computed, onScopeDispose, ref, toValue, unref, watch } from "vue";
 /** Suggestion requests use an application-supplied agent; credentials stay on its server. */
 export function useAssistantSuggestions({
   active = true, requestKey = "", draft = "", configuration = {},
-  generate, onSelect = () => false, debounceMs = 750
+  generate, onSelect = () => false, debounceMs = 750, minIntervalMs = 0
 } = {}) {
   const items = ref([]);
   const loading = ref(false);
@@ -18,6 +18,7 @@ export function useAssistantSuggestions({
   const visible = computed(() => eligible.value && (loading.value || items.value.length > 0));
   let timer;
   let request;
+  let lastStartedAt = -Infinity;
 
   function cancel() {
     clearTimeout(timer);
@@ -43,6 +44,7 @@ export function useAssistantSuggestions({
     const run = unref(generate);
     loading.value = true;
     timer = setTimeout(async () => {
+      lastStartedAt = Date.now();
       try {
         const result = await run(input);
         if (request !== controller) return;
@@ -58,7 +60,8 @@ export function useAssistantSuggestions({
           loading.value = false;
         }
       }
-    }, Math.max(0, Number(toValue(debounceMs)) || 0));
+    }, Math.max(0, Number(toValue(debounceMs)) || 0,
+      lastStartedAt + Math.max(0, Number(toValue(minIntervalMs)) || 0) - Date.now()));
   }, { immediate: true, flush: "sync" });
 
   function currentSuggestion(value) {
@@ -80,7 +83,6 @@ export function useAssistantSuggestions({
   }
   function focus() {
     if (toValue(active) === false || composerFocused.value) return;
-    dismissedKey.value = null;
     composerFocused.value = true;
   }
   function blur() {

package/src/server/conversation/claudeTurn.js

@@ -467,7 +467,14 @@ export function createClaudeConversationOwner({
       if (!command) await entry.nativeTurn.updateState("active");
       if (applicationCommand && conversationTurn) {
         const value = deliveryResult();
-        applicationCommand.active.delivery = { value, completion: entry.completion?.promise };
+        const active = applicationCommand.active;
+        const previousCompletion = active.completion;
+        if (active.finishIfCurrent) {
+          active.completion = Promise.withResolvers();
+          active.completion.promise.catch(() => {});
+        }
+        active.delivery = { value, completion: active.finishIfCurrent ? active.completion.promise : entry.completion?.promise };
+        if (active.finishIfCurrent) previousCompletion.resolve();
         // The original canonical admission and publication precede Core's same
         // accepted-request gate; native tools cannot race an unaccepted user.
         await applicationCommand.accept({ nativeResult: { value }, conversationTurn, nativeTurnId: entry.turn?.id });
@@ -721,13 +728,13 @@ export function createClaudeConversationOwner({
     command.signal.throwIfAborted();
     const entry = await acquire(command.context);
     const active = control.current;
-    const applicationCommand = active?.tools ? { active, accept: command.accept } : null;
+    const applicationCommand = active && (active.tools || active.finishIfCurrent) ? { active, accept: command.accept } : null;
     if (applicationCommand) {
       if (entry.disposed || entry.command && entry.command !== active) throw new Error("This Claude conversation is closed or already working.");
       if (active.entry && active.entry !== entry) throw new Error("Claude's application tools belong to another native conversation.");
       active.entry = entry;
       entry.command = active;
-      entry.toolSchemas = active.tools.schemas;
+      entry.toolSchemas = active.tools?.schemas || [];
     }
     const value = await send(entry, { ...command.input.nativeMessage, onPromptSending: command.beforeDispatch }, { applicationCommand });
     const completion = value.conversationTurn ? entry.completion?.promise : null;
@@ -753,7 +760,7 @@ export function createClaudeConversationOwner({
     completion.promise.catch(() => {});
     const active = { completion, onMessage, onEvent, onNativeToolUse, signal, tools, admitted: false, nativeTools: new Map(),
       messageId: input.messageId, goal: input.goal, nativeToolCount: 0, toolWork: new Set(), maximumToolCalls,
-      context, failure: Promise.withResolvers() };
+      context, finishIfCurrent: command.finishIfCurrent, failure: Promise.withResolvers() };
     let failure;
     active.failure.promise.catch(error => { failure = error; });
     control.current = active;
@@ -810,6 +817,10 @@ export function createClaudeConversationOwner({
           catch (error) { problem = error; }
         }
         if (command.finishIfCurrent && !await command.finishIfCurrent(() => active.delivery === settling)) continue;
+        if (!problem && typeof result === "function") {
+          try { result = await result(); }
+          catch (error) { problem = error; }
+        }
         problem = dispatchFailure || failure || problem;
         if (!problem && settling?.completion && (binding ? result.status !== "completed" : !result.ok)) {
           problem = Object.assign(new Error(result.error || (binding ? "Claude interrupted this answer." : `Claude turn ${result.status}.`)), { status: result.status });
@@ -832,7 +843,7 @@ export function createClaudeConversationOwner({
       }
     } else {
       await cancellation?.catch(() => {});
-      if (tools && active.entry) {
+      if (active.entry) {
         try {
           if (problem || signal.aborted) await active.entry.nativeTurn.stopProcess(problem?.message || "Work stopped.");
         } catch (error) {
@@ -927,6 +938,11 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       messages: current.messages, error: entry.turn?.error || "", status };
   }
 
+  function resolveCompletion(result) {
+    entry.completion?.resolve(result);
+    if (entry.command?.finishIfCurrent) entry.command.completion.resolve(result);
+  }
+
   async function updateState(state, message = "") {
     if (!entry.turn) return;
     const active = ["starting", "active", "finalizing"].includes(state);
@@ -985,12 +1001,12 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
           setState("interrupted", error.message);
           await onEvent({ type: "save" });
           await onEvent({ type: "state", state: "interrupted", active: false, message: error.message });
-          entry.completion?.resolve(readResult());
+          resolveCompletion(readResult());
           if (entry.startupCleanup === startup) entry.startupCleanup = null;
           throw error;
         }
       } else await onEvent({ type: "save" });
-      entry.completion?.resolve(readResult());
+      resolveCompletion(readResult());
       if (entry.startupCleanup === startup) entry.startupCleanup = null;
       return entry.exitProof;
     };
@@ -1000,9 +1016,32 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     return entry.stopPending;
   }
 
-  async function publishEntryEvent(event) {
+  async function publishEntryEvent(event, deferred = false) {
     if (entry.stopping) return;
     const binding = Boolean(process.releaseExecution);
+    const command = entry.command;
+    if (event.type === "settled" && !binding && !deferred && command?.finishIfCurrent) {
+      const delivery = command.delivery;
+      const completion = entry.completion;
+      const owner = acceptedInput;
+      // Release the native queue before the common run joins reserved steering.
+      // That same accepted delivery then performs the original retained checkpoint.
+      command.completion.resolve(async () => {
+        if (entry.command !== command || command.delivery !== delivery || entry.completion !== completion ||
+            command.signal.aborted || !currentReceiptOwner(owner)) {
+          clearFinalAssistantResult();
+          throw failure("Claude's completion belongs to a retired native input.");
+        }
+        try {
+          await publishEntryEvent(event, true);
+          return readResult();
+        } catch (error) {
+          clearFinalAssistantResult();
+          throw error;
+        }
+      });
+      return;
+    }
     if (event.type === "admitted") {
       if (event.userEcho) entry.sent = true;
       if (!binding) await onEvent({ type: "save" });
@@ -1022,7 +1061,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     }
     if (event.type === "settled") {
       if (event.source === "result") await onEvent({ type: "provider-update", change: "goal" });
-      entry.completion?.resolve(binding ? event : readResult());
+      resolveCompletion(binding ? event : readResult());
     }
     return published;
   }

package/test/claudeTurn.test.js

@@ -275,6 +275,9 @@ import { createClaudeConversationOwner } from "../src/server/conversation/claude
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { createConversationRuntime, createMemoryConversationStorage, createConversationTranscript } from "../src/server/conversation/index.js";
+import { createActionCatalogue } from "@jskit-ai/kernel/server/actions";
+import { createSchema } from "json-rest-schema";
 
 // Exercise the original supplied-store Send/process/event owner, without the
 // standalone execution-release capability or application-tool branch.
@@ -292,9 +295,12 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
       select() {}, read: (_context, id) => saved.get(id),
       async save(entry) { saved.set(entry.id, JSON.stringify({ turnId: entry.turn?.id,
         state: entry.turn?.state, accountIdentity: entry.accountIdentity })); },
-      async hasMessage() { return false; }
+      async hasMessage() { return false; },
+      readSessionConversations: () => ({ ids: [...saved.keys()], context })
     },
     preparation: {
+      context: async () => context,
+      entry: () => ({ options: { mainId: conversationId }, check() {} }),
       check() {}, account: () => ({ identity: behavior.account, providerId }),
       async configuration() { return { systemPrompt: "Retained host instructions", settings: {}, model: providerId === "deepseek" ? "deepseek-flash" : "sonnet" }; },
       async message(_entry, _input, { message }) { return message; }
@@ -321,10 +327,12 @@ async function publishedClaudeFixture(t, { publication = true, providerId = "ant
       if (event.type === "before-state") await beforeState?.(entry, event);
       if (event.type === "admit-message" && canonicalAdmission) {
         await behavior.beforeAdmit?.();
+        if (behavior.admit) return behavior.admit(event);
         return { turnId: `authored-${event.messageId}`, messages: [{ role: "user", messageId: event.messageId, text: event.message }] };
       }
       if (event.type === "message" && event.message.complete && event.message.role === "assistant") {
         await behavior.beforePublish?.();
+        if (behavior.publish) return behavior.publish(event.message);
         const turn = { id: `host-${messages.length}`, messages: [{ messageId: event.message.id,
           outputId: event.message.outputId || event.message.id, role: "assistant", text: event.message.text }] };
         messages.push(turn);
@@ -735,3 +743,199 @@ test("Claude verified native cleanup retains interrupted checkpoint refusal with
   assert.equal(f.entry.turn.active, false, "Original supplied store retained the truthful interruption");
   assert.equal(f.entry.turn.state, "interrupted");
 });
+
+// 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 } = {}) {
+  const f = await publishedClaudeFixture(t, { canonicalAdmission: true });
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  const context = { actor: { id: "owner" }, surface: "app" };
+  const admissions = [];
+  const checkpoints = [];
+  const actions = createActionCatalogue();
+  actions.register({ contributorId: "lesson", domain: "lesson", actions: [{
+    id: "lesson.inspect", version: 1, kind: "query", channels: ["automation"], surfaces: ["app"],
+    permission: { require: "authenticated" }, idempotency: "none",
+    input: { schema: createSchema({}), mode: "replace" },
+    output: { schema: createSchema({}), mode: "replace" }, execute: async () => ({})
+  }] });
+  let delivery;
+  f.behavior.admit = event => transcript.writeConversationUserMessage("lesson", {
+    messageId: event.messageId, text: event.message
+  });
+  f.behavior.publish = message => storage.write("lesson", async transaction => {
+    const turnId = await transaction.nextTurnId();
+    await transaction.appendMessage(turnId, { ...message, role: "assistant", messageId: message.id });
+    const turn = await transaction.readTurn(turnId);
+    f.messages.push(turn);
+    return turn;
+  });
+  const binding = { sessionId: "lesson", namespace: f.context.key, engine: "claude", runtime: { store: {} },
+    native: { owner: f.owner, preparation: { cleanup: () => ({ context: f.context, application: {
+      readContext: async () => f.context, terminals: { close: async () => ({ ok: true }) }
+    } }) } },
+    admission() {}, prepareInput: async input => input,
+    read: async () => ({ threadId: f.conversationId, configuration: { model: "native" },
+      turn: f.owner.snapshot(f.entry), delivery }),
+    readStream: async () => ({ messages: [] }),
+    state: { read: async () => delivery, write: async value => { delivery = structuredClone(value); } },
+    transcript: { history: async () => [], readConversationLog: () => transcript.readConversationLog("lesson"),
+      hasMessage: id => transcript.conversationMessageIdExists("lesson", id),
+      writeUserMessage: input => transcript.writeConversationUserMessage("lesson", input) },
+    ...(tools ? { applicationTools: { storage, prepareContext(actual, admission) {
+      admissions.push(admission); return actual;
+    } } } : {}) };
+  const runtime = createConversationRuntime({ ...(tools ? { actions } : {}), authorize: () => true,
+    host: { conversation: () => binding } });
+  t.after(() => runtime.close());
+  const conversation = await runtime.open({ id: "lesson", context });
+  f.setBeforeState((entry, event) => {
+    if (event.state !== "completed") return;
+    assert.equal(entry.turn.active, true, "Retained checkpoint still precedes saved idle state");
+    assert.equal(entry.nativeTurn.read().active, false);
+    const final = f.final();
+    assert.ok(final, "The original canonical FINAL is available at the checkpoint");
+    const admission = admissions.at(-1);
+    if (tools) admission.assertCompletionCurrent();
+    checkpoints.push({ final, admission });
+  });
+  async function loadContract(id = "contract") {
+    await f.frame({ type: "assistant", uuid: `tool-${id}`, message: { content: [
+      { type: "tool_use", id, name: "mcp__application__assistant_action_contract",
+        input: { actionId: "lesson.inspect", version: 1 } }
+    ] } });
+    return f.entry.process.options.onControlRequest({ subtype: "mcp_message", server_name: "application",
+      message: { jsonrpc: "2.0", id, method: "tools/call", params: { name: "assistant_action_contract",
+        arguments: { actionId: "lesson.inspect", version: 1 }, _meta: { "claudecode/toolUseId": id } } }
+    }, { signal: new AbortController().signal });
+  }
+  return { ...f, get entry() { return f.entry; }, runtime, conversation, binding, admissions, checkpoints, loadContract, testSignal: t.signal };
+}
+
+async function sendCommon(f, messageId) {
+  const receipt = await f.conversation.send({ messageId, text: "Prepare the question." });
+  while (!f.entry.command?.admitted) {
+    f.testSignal.throwIfAborted();
+    await new Promise(resolve => setImmediate(resolve));
+  }
+  return receipt;
+}
+
+for (const tools of [true, false]) test(`Claude supplied common runtime checkpoints after its completion fence with tools=${tools}`, { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t, { tools });
+  const receipt = await sendCommon(f, "common-question");
+  assert.equal(receipt.status, "accepted");
+  assert.equal(typeof f.entry.command.finishIfCurrent, "function");
+  if (tools) {
+    await f.loadContract();
+    assert.throws(() => f.admissions.at(-1).assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+  } else assert.equal(f.entry.command.tools, undefined);
+  await f.frame({ type: "result", subtype: "success", result: "Where would you try the application?", uuid: "question-final" });
+  await f.conversation.wait();
+  assert.equal(f.checkpoints.length, 1);
+  assert.notEqual(f.checkpoints[0].final.conversationTurn.turnId, receipt.turnId,
+    "The true native FINAL keeps its separate original carrier");
+  assert.equal(f.entry.turn.state, "completed");
+  assert.equal(f.entry.command, null);
+  if (tools) f.admissions.at(-1).assertCompletionCurrent();
+});
+
+test("Claude supplied common completion joins accepted steering and checkpoints only its own final", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t);
+  await sendCommon(f, "common-first");
+  await f.loadContract("first-contract");
+  const first = f.admissions.at(-1);
+  const legacyCompletion = f.entry.completion.promise;
+  const receipt = await f.conversation.send({ messageId: "common-successor", text: "Use this new question.", steer: true });
+  assert.equal(receipt.status, "accepted");
+  assert.equal(f.entry.completion.promise, legacyCompletion, "Original same-turn steering retains the direct wait owner");
+  while (f.entry.command.messageId !== "common-successor") {
+    f.testSignal.throwIfAborted();
+    await new Promise(resolve => setImmediate(resolve));
+  }
+  await f.loadContract("successor-contract");
+  assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+  await f.frame({ type: "result", subtype: "success", result: "The successor question", uuid: "successor-final" });
+  await f.conversation.wait();
+  assert.equal((await legacyCompletion).status, "completed");
+  assert.equal(f.checkpoints.length, 1);
+  assert.equal(f.checkpoints[0].final.inputMessageId, claudeNativeMessageId("common-successor"));
+  assert.equal(f.checkpoints[0].admission.messageId, "common-successor");
+  assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+});
+
+test("Claude supplied completion retains the original waiter when a reserved successor is rejected before dispatch", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t);
+  await sendCommon(f, "unreplaced-first");
+  await f.loadContract();
+  const first = f.admissions.at(-1);
+  const legacyCompletion = f.entry.completion.promise;
+  const preparing = Promise.withResolvers();
+  const held = Promise.withResolvers();
+  f.binding.prepareInput = async () => { preparing.resolve(); await held.promise; };
+  const steering = f.conversation.send({ messageId: "never-dispatched-successor", text: "Rejected before native work.", steer: true });
+  void steering.catch(() => {});
+  await preparing.promise;
+  await f.frame({ type: "result", subtype: "success", result: "The still-current question", uuid: "unreplaced-final" });
+  assert.equal(f.checkpoints.length, 0);
+  held.reject(new Error("The host rejected preparation before dispatch."));
+  await assert.rejects(steering, /host rejected preparation/);
+  await f.conversation.wait();
+  assert.equal((await legacyCompletion).status, "completed");
+  assert.equal(f.checkpoints.length, 1);
+  assert.equal(f.checkpoints[0].final.inputMessageId, claudeNativeMessageId("unreplaced-first"));
+  first.assertCompletionCurrent();
+});
+
+for (const cancelled of [false, true]) test(`Claude supplied native settlement releases its queue while reserved steering waits, cancelled=${cancelled}`, { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t);
+  await sendCommon(f, "reserved-first");
+  await f.loadContract();
+  const first = f.admissions.at(-1);
+  const preparing = Promise.withResolvers();
+  const held = Promise.withResolvers();
+  f.binding.prepareInput = async input => { preparing.resolve(); await held.promise; return input; };
+  const steering = f.conversation.send({ messageId: "reserved-successor", text: "A reserved new instruction.", steer: true });
+  void steering.catch(() => {});
+  await preparing.promise;
+  const legacyCompletion = f.entry.completion.promise;
+  let cancellation;
+  try {
+    await f.frame({ type: "result", subtype: "success", result: "The prior question", uuid: "reserved-final" });
+    assert.equal(f.entry.nativeTurn.read().active, false);
+    assert.equal(f.entry.turn.active, true);
+    assert.equal(f.checkpoints.length, 0, "Native queue does not await the reserved common admission");
+    assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
+    if (cancelled) cancellation = f.conversation.cancel();
+  } finally { held.resolve(); }
+  await cancellation;
+  await assert.rejects(steering);
+  assert.equal((await legacyCompletion).status, "interrupted", "Legacy wait keeps its original settlement and cleanup result");
+  await f.conversation.wait();
+  assert.equal(f.checkpoints.length, 0);
+  assert.equal(f.final(), null, "Rejected steering or Stop cannot revive the prior FINAL");
+  assert.equal(f.entry.process, null);
+  assert.equal(f.entry.command, null);
+  assert.throws(() => first.assertCompletionCurrent());
+});
+
+test("Claude supplied common checkpoint failure preserves original refusal and native cleanup", { timeout: 10_000 }, async t => {
+  const f = await suppliedCommonFixture(t);
+  await sendCommon(f, "refused-common-question");
+  await f.loadContract();
+  const refusal = new Error("The original lesson checkpoint refused this completion.");
+  f.setBeforeState((entry, event) => {
+    if (event.state !== "completed") return;
+    assert.equal(entry.turn.active, true);
+    f.admissions.at(-1).assertCompletionCurrent();
+    throw refusal;
+  });
+  await f.frame({ type: "result", subtype: "success", result: "Never delivered", uuid: "refused-final" });
+  const state = await f.conversation.wait();
+  assert.equal(state.error, refusal.message);
+  assert.equal(f.final(), null);
+  assert.equal(f.entry.process, null);
+  assert.equal(f.entry.command, null);
+  assert.equal(f.entry.turn.active, false);
+});

package/test/messageDelivery.test.js

@@ -397,3 +397,18 @@ test("restored application requests retain their origin and attachment-only user
   assert.equal(delivery.turns()[0].user.text, "");
   assert.deepEqual(delivery.turns()[0].user.attachments, [{ attachmentId: "image" }]);
 });
+
+test("a deliberate new message can follow known uncertainty without resending the old request", async () => {
+  const sent = [];
+  const delivery = createAssistantMessageDelivery({ deliver: async payload => {
+    sent.push(payload);
+    if (payload.messageId === "old") throw new Error("Lost receipt");
+    return { ok: true };
+  } });
+  await assert.rejects(delivery.send({ message: "Old request" }, { messageId: "old", uncertainOnError: true }));
+  assert.equal(await delivery.send({ message: "Old request" }, { messageId: "old", uncertainOnError: true }), false);
+  assert.deepEqual(await delivery.send({ message: "A new request" }, { messageId: "new", uncertainOnError: true }), { ok: true });
+  assert.deepEqual(sent.map(message => message.messageId), ["old", "new"]);
+  assert.equal(delivery.find("old").status, "uncertain");
+  assert.equal(delivery.find("new").status, "accepted");
+});

package/test/suggestions.test.js

@@ -87,7 +87,7 @@ test("suggestion previews preserve a draft and stale selections cannot submit",
   state.focus();
   t.mock.timers.tick(750);
   await flush();
-  assert.equal(state.visible.value, true);
+  assert.equal(state.visible.value, false, "Refocusing does not regenerate dismissed suggestions");
   draft.value = "Keep my text";
   assert.equal(state.preview.value, "");
   assert.equal(state.select(suggestion("Next step")), false);
@@ -112,3 +112,36 @@ test("a failing suggestion agent leaves the composer independent and stops retry
   t.mock.timers.tick(60_000);
   assert.equal(requests, 1);
 });
+
+
+test("suggestions wait five seconds and coalesce edited drafts through a thirty-second cooldown", async t => {
+  t.mock.timers.enable({ apis: ["setTimeout", "Date"], now: 1_000 });
+  const scope = effectScope();
+  t.after(() => scope.stop());
+  const draft = ref("First");
+  const active = ref(true);
+  const calls = [];
+  const state = scope.run(() => useAssistantSuggestions({ draft, active, debounceMs: 5_000, minIntervalMs: 30_000,
+    generate: async input => { calls.push({ draft: input.draft, at: Date.now() }); return [suggestion(input.draft)]; }
+  }));
+  t.mock.timers.tick(4_999);
+  state.focus(); state.blur(); state.focus();
+  assert.equal(calls.length, 0);
+  t.mock.timers.tick(1);
+  await flush();
+  draft.value = "Second";
+  t.mock.timers.tick(15_000);
+  draft.value = "Newest";
+  state.focus();
+  t.mock.timers.tick(14_999);
+  assert.equal(calls.length, 1);
+  t.mock.timers.tick(1);
+  await flush();
+  assert.deepEqual(calls, [{ draft: "First", at: 6_000 }, { draft: "Newest", at: 36_000 }]);
+  t.mock.timers.tick(90_000);
+  assert.equal(calls.length, 2, "Cooldown does not poll when the input is unchanged");
+  draft.value = "Cancelled before dispatch";
+  active.value = false;
+  t.mock.timers.tick(30_000);
+  assert.equal(calls.length, 2);
+});