@jskit-ai/assistant-core 0.2.49 → 0.2.51

package/src/server/conversation/claudePromptDelivery.js

@@ -3,6 +3,15 @@ import { claudeNativeMessageId } from "./claudeHistory.js";
 import { normalizeNullableText } from "./normalize.js";
 import { ignorePromptSending, ignoreReceipt } from "./nativeCommandCallbacks.js";
 
+// The process each recent prompt was written to. Only that process, while it
+// lives, can still record a prompt its history lacks (see promptCanStillArrive).
+function rememberPromptProcess(entry, uuid) {
+  entry.promptProcesses ||= new Map();
+  entry.promptProcesses.delete(uuid);
+  entry.promptProcesses.set(uuid, { process: entry.process, executionId: entry.executionId });
+  if (entry.promptProcesses.size > 64) entry.promptProcesses.delete(entry.promptProcesses.keys().next().value);
+}
+
 /**
  * Delivers an authored input to an entry's Claude process: duplicate checks,
  * preparation, steering, the new turn, and the native and persisted receipts.
@@ -78,6 +87,9 @@ export function createClaudePromptDelivery({
     if (input.signal?.aborted) {
       throw Object.assign(createError("The goal command was stopped before delivery.", { code: "conversation_claude_command_stopped" }), { delivery: "not-sent" });
     }
+    // The turn this input is for. A Stop or the next turn that replaces it while
+    // the input is prepared leaves the input unsent and that turn untouched.
+    let lease;
     if (steering) {
       if (command) {
         await command.beforeDispatch({ threadId: entry.id });
@@ -85,7 +97,7 @@ export function createClaudePromptDelivery({
       }
       // A mid-turn message is never an interrupt: Claude Code queues it and
       // reads it after the running tool call. Only explicit Stop interrupts.
-      try { await entry.nativeTurn.prepareSteering(); }
+      try { lease = await entry.nativeTurn.prepareSteering(); }
       catch (error) {
         if (!command) await entry.nativeTurn.stopProcess(error.message);
         // This precedes the input's pipe write: a refused steer is definitely not sent.
@@ -100,7 +112,7 @@ export function createClaudePromptDelivery({
     }
     if (!steering) {
       entry.renewal = renewal;
-      entry.nativeTurn.begin({ id: uuid, maxOutputCharacters: command ? command.maximumOutput : entry.profile?.limits.maxOutputCharacters });
+      lease = entry.nativeTurn.begin({ id: uuid, maxOutputCharacters: command ? command.maximumOutput : entry.profile?.limits.maxOutputCharacters });
       entry.observationError = "";
       entry.turn = { id: uuid, active: true, state: "starting", startedAt: new Date().toISOString(), updatedAt: new Date().toISOString(), error: "" };
       if (!command) entry.completion = Promise.withResolvers();
@@ -135,6 +147,9 @@ export function createClaudePromptDelivery({
         if (admission) conversationTurn = await admission;
         deliveryTiming?.("receipt-written");
       }
+      // A Stop or the next turn while the host saved this admission has already
+      // refused it: the turn's state now belongs to what replaced it.
+      if (!entry.nativeTurn.holds(lease)) return;
       if (!command) {
         await entry.nativeTurn.updateState("active");
         deliveryTiming?.("state-active");
@@ -170,10 +185,16 @@ export function createClaudePromptDelivery({
       if (input.signal?.aborted) {
         throw Object.assign(createError("The goal command was stopped before delivery.", { code: "conversation_claude_command_stopped" }), { delivery: "not-sent" });
       }
+      if (!entry.nativeTurn.holds(lease)) {
+        throw Object.assign(createError("A Stop or another message replaced this message's turn before it was sent.",
+          { code: "conversation_claude_turn_superseded" }), { delivery: "not-sent" });
+      }
+      rememberPromptProcess(entry, uuid);
       await entry.nativeTurn.send(command ? entry.process.client : native.client, command ? preparation.message(entry, input) : prompt,
         { messageId: uuid, accept, steer: steering, ...(command ? { timeoutMs: command.timeoutMs } : {}) });
     } catch (error) {
-      if (!command) await entry.nativeTurn.stopProcess(error.message);
+      // Only this input's own turn is cleaned up; one that replaced it is not.
+      if (!command && entry.nativeTurn.holds(lease)) await entry.nativeTurn.stopProcess(error.message);
       throw error;
     }
     return deliveryResult();

package/src/server/conversation/claudeTurn.js

@@ -19,6 +19,23 @@ function nativeWorkSettled(entry) {
   return !entry.sending && !entry.process && !entry.executionId && !entry.command && !entry.stopPending;
 }
 
+// Whether Claude can still record a prompt its history lacks. A send or stop in
+// progress can, and so can the process the prompt was written to while that
+// process lives or its exit is unproven: a prompt written to a process since
+// proved stopped never arrives, even once another process runs. This server
+// records each prompt's process just before writing it (the latest 64; Claude
+// reads its input in order), so a prompt without a record was written, if at
+// all, by an earlier server: only that server's execution, while its exit is
+// unproven, can still record it.
+function promptCanStillArrive(entry, uuid) {
+  if (nativeWorkSettled(entry)) return false;
+  if (entry.sending || entry.stopPending) return true;
+  const written = entry.promptProcesses?.get(uuid);
+  if (!written) return Boolean(entry.executionId) && !runsNativeWork(entry);
+  return Boolean(written.process && written.process === entry.process ||
+    written.executionId && written.executionId === entry.executionId);
+}
+
 // Work this server is running: a send, command or stop in progress, a live
 // process, or a startup still lending cleanup. A restored execution with none
 // of these belongs to an earlier server; no Claude process outlives the
@@ -542,7 +559,7 @@ export function createClaudeConversationOwner({
     return { ...entry.nativeTurn.readResult(), ok: true,
       messages: [...messages.values()].map(message => ({ ...message,
         ...(message.userId ? { requestMessageId: requestIds.get(message.userId) || "" } : {}) })), text: current.text || history.text,
-      admitted, notAdmitted: !admitted && Boolean(input.messageId) && nativeWorkSettled(entry) };
+      admitted, notAdmitted: !admitted && Boolean(input.messageId) && !promptCanStillArrive(entry, claudeNativeMessageId(input.messageId)) };
   }
 
   async function inspectAdmission(entry, input) {
@@ -550,7 +567,7 @@ export function createClaudeConversationOwner({
     const history = await readHistory(entry);
     const turnId = claudeNativeMessageId(input.messageId);
     const accepted = history.userIds.includes(turnId);
-    const admission = accepted ? "accepted" : nativeWorkSettled(entry) ? "not-admitted" : "unknown";
+    const admission = accepted ? "accepted" : promptCanStillArrive(entry, turnId) ? "unknown" : "not-admitted";
     return { ok: true, admission, messageId: input.messageId,
       threadId: entry.id, turnId: accepted ? turnId : "" };
   }
@@ -682,6 +699,7 @@ export function createClaudeConversationOwner({
     readFinalAssistantResult,
     readHistory,
     nativeWorkSettled,
+    promptCanStillArrive,
     ensureReady,
     ensureProcess,
     readContextUsage,

package/src/server/conversation/conversationDelivery.js

@@ -6,6 +6,14 @@ import { createConversationChangeover, conversationNativeMessages } from "./cont
 import { deliveryFailure, failure, stateErrorFields } from "./conversationRefusals.js";
 import { pendingSuccessor, retainedSegments, submittedMessage } from "./conversationReads.js";
 
+// An engine's receipt for an attempted message: accepted, proved never
+// admitted, or unknown. A proved non-admission settles the attempt; dropping it
+// would leave that one message to refuse every later one as unconfirmed.
+function nativeAdmission(observation) {
+  if (observation.accepted) return "accepted";
+  return observation.notAdmitted === true || observation.admission === "not-admitted" ? "not-admitted" : "unknown";
+}
+
 /** @typedef {import("./conversationEntries.js").ConversationEntry} ConversationEntry */
 /** @typedef {import("./conversationSending.js").ConversationRequest} ConversationRequest */
 
@@ -146,13 +154,13 @@ function createConversationDelivery({ storage, transcript, events, entries, read
           if (entry.conversation) {
             observation = await entry.provider.inspectAdmission({ messageId, threadId, context });
             await events.access(context, entry.id, request?.operation || "inspectDelivery", entry);
-            return { admission: observation.accepted ? "accepted" : "unknown" };
+            return { admission: nativeAdmission(observation) };
           }
           const { runtime } = await storage.read(entry.id, transaction => transaction.readMetadata());
           if (!threadId || threadId !== conversationNativeIdentity(runtime) || runtime.request?.messageId !== messageId) return null;
           observation = await entry.provider.inspectAdmission({ ...runtime.request, context, configuration: runtime.configuration });
           await events.access(context, entry.id, request?.operation || "inspectDelivery", entry);
-          return { admission: observation.accepted ? "accepted" : "unknown" };
+          return { admission: nativeAdmission(observation) };
         }
       }
     });

package/src/server/conversation/providers/claudeDriver.js

@@ -508,7 +508,7 @@ export function createClaudeConversationDriver({
         const history = await owner.readHistory(entry);
         const nativeId = claudeNativeMessageId(input.messageId);
         const accepted = history.userIds.includes(nativeId);
-        return { accepted, notAdmitted: !accepted && owner.nativeWorkSettled(entry),
+        return { accepted, notAdmitted: !accepted && !owner.promptCanStillArrive(entry, nativeId),
           messages: history.messages.filter(message => message.userId === nativeId) };
       },
       steer: command => owner.steer(control, command, commandOptions),

package/src/server/conversation/providers/opencodeDriver.js

@@ -273,7 +273,8 @@ export function createOpenCodeConversationDriver({
         async inspectAdmission({ context, representation, ...input }) {
           const acquired = await supplied.acquire(context);
           const result = await supplied.owner.inspectPreparedMessage(await supplied.preparation.inspection(input, acquired.options));
-          return representation === "native" ? result : { accepted: result.admission === "accepted" };
+          return representation === "native" ? result
+            : { accepted: result.admission === "accepted", notAdmitted: result.admission === "not-admitted" };
         },
         async run(command) {
           if (disposed || current) throw Object.assign(new Error("This OpenCode conversation is closed or already working."), {

package/test/claudeConversationSession.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { mkdir, mkdtemp, rename, rm, readFile, writeFile } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, rename, rm, readFile, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { createConversationRuntime, createFileConversationStorage, upgradeConversationRuntimeState } from "../src/server/conversation/index.js";
@@ -818,10 +818,13 @@ test("uncertain native delivery is reconciled from history without a second infe
   const binding = (await f.storage.read("conversation", transaction => transaction.readMetadata())).runtime.binding;
   const historyPath = path.join(f.directory, "claude", "projects", f.directory.replace(/[^a-zA-Z0-9]/gu, "-"), `${binding.conversationId}.jsonl`);
   // A production Send checks the previous receipt first. Keep that receipt
-  // genuinely unavailable while proving the unknown-delivery refusal.
-  await rename(historyPath, `${historyPath}.unavailable`);
+  // genuinely unavailable while proving the unknown-delivery refusal: Claude's
+  // history is there but cannot be read. (An absent history is Claude's proof
+  // that it never recorded the prompt, as for the dropped prompt below.)
+  const { mode } = await stat(historyPath);
+  await chmod(historyPath, 0o000);
   try { await assert.rejects(f.conversation.send(input), { code: "conversation_delivery_uncertain" }); }
-  finally { await rename(`${historyPath}.unavailable`, historyPath); }
+  finally { await chmod(historyPath, mode); }
   const receipt = await f.conversation.inspectDelivery({ messageId: "lost-ack" });
   assert.equal(receipt.status, "accepted");
   assert.equal(receipt.recovered, true);