@jskit-ai/assistant-core 0.1.212 → 0.1.214

package/src/server/conversation/openCodeRuntime.js

@@ -181,6 +181,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   let sharedProcessStop = null;
   let failedStartup = null;
   let closed = false;
+  let connectionChanging = false;
+
+  function requireConnectionAvailable() {
+    if (connectionChanging) throw Object.assign(new Error("OpenCode is changing a connection. Retry after the connection change finishes."), {
+      code: "assistant_opencode_connection_changing", statusCode: 409
+    });
+  }
   const bindingScopes = new Map();
   let registryPath = "";
   let bindingWrite = Promise.resolve();
@@ -230,7 +237,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   }
 
   async function ensure(selected, start) {
+    requireConnectionAvailable();
     await sharedProcessStop;
+    requireConnectionAvailable();
     if (failedStartup) await stop("opencode-startup-cleanup");
     if (sharedProcess) {
       const currentConnection = sharedProcess.connections.get(selected?.modelProviderId);
@@ -243,6 +252,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
           await sharedProcess.server.client.health({ signal: AbortSignal.timeout(1_000) });
           return sharedProcess;
         } catch {
+          requireConnectionAvailable();
           await stop("opencode-health-check-failed");
         }
       } else {
@@ -320,6 +330,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   }
 
   async function acquire(key, prepare, onFailure = async () => {}) {
+    requireConnectionAvailable();
     const pending = processStarts.get(key);
     if (pending) return pending;
     const start = Promise.resolve().then(async () => {
@@ -442,6 +453,33 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       closed = true;
     }
     const application = preparation.release;
+    if (typeof input.publish === "function") {
+      requireConnectionAvailable();
+      connectionChanging = true;
+      try {
+        await Promise.all([...processStarts.values()].map(start => start.catch(() => null)));
+        await sharedProcessStart?.catch(() => null);
+        await application.assertConnectionChange?.();
+        const targets = [...processes.values()];
+        const providerId = text(input.modelProviderId);
+        if (!providerId || targets.some(target => text(target.modelProviderId) !== providerId || !application.ownsTarget(target))) {
+          throw Object.assign(new Error("Close other OpenCode chats and Colleague conversations, then retry this connection change. The saved connection has not changed."), {
+            code: "assistant_opencode_connection_in_use", statusCode: 409
+          });
+        }
+        const results = [];
+        for (const target of targets) {
+          const proof = await releaseProcessTarget(target, { retainSharedProcess: true }, application);
+          if (proof?.exited === false || proof?.ok === false) throw new Error("OpenCode could not stop the selected conversation. Retry the connection change.");
+          results.push(proof);
+        }
+        if (sharedProcess || failedStartup) results.push(await stop("opencode-connection-changed"));
+        await input.publish();
+        return { closed: results.length, ok: true };
+      } finally {
+        connectionChanging = false;
+      }
+    }
     await Promise.all([...processStarts.entries()]
       .filter(([key]) => key.includes("\0"))
       .map(([, start]) => start.catch(() => null)));
@@ -908,13 +946,17 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
 
   async function writeConversationProjection(sessionId, messages = null, {
     inputMessageId = "",
-    streaming = false
+    streaming = false,
+    captureFinalAssistantResult = false
   } = {}, projection) {
     let failure = "";
+    let finalAssistantResult = null;
     let providerApiFailure = false;
     const rows = (inputMessageId
       ? openCodeRowsForInput(messages, inputMessageId)
       : openCodeMessageRows(messages)).filter((message) => message?.type === "assistant");
+    const finalNativeMessage = captureFinalAssistantResult && !streaming
+      ? openCodeLastAssistantResult(rows, { readError: projection.readError }).message : null;
     for (const [index, message] of rows.entries()) {
       failure ||= projection.readError(message);
       providerApiFailure ||= openCodeProviderApiFailure(message.error);
@@ -967,9 +1009,31 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         });
         projection.store.completeConversationStreamMessage(sessionId, messageId);
         await projection.publishTurn(turn);
+        if (message === finalNativeMessage && !projection.readError(message) &&
+            (message.time?.completed || message.finish) && turn) {
+          finalAssistantResult = { inputMessageId: text(inputMessageId), itemId: text(message.id),
+            text: assistantText, conversationTurn: turn };
+        }
       }
     }
-    return { failure, providerApiFailure };
+    return { failure, providerApiFailure, ...(captureFinalAssistantResult ? { finalAssistantResult } : {}) };
+  }
+
+  // Evidence belongs to the exact retained native turn. This read never creates,
+  // observes, resumes or projects a native conversation.
+  function readFinalAssistantResult(key, threadId = "", turnId = "") {
+    const turn = turns.get(key);
+    const result = turn?.finalAssistantResult;
+    const target = turn?.finalAssistantResultTarget;
+    if (!target || processes.get(key) !== target || target.abortController.signal.aborted ||
+        !turn.finalAssistantResultProcess || sharedProcess !== turn.finalAssistantResultProcess ||
+        target.upstreamSessionId !== turn.threadId) return null;
+    if (!text(threadId) || !text(turnId) || !result || turn.active || turn.state !== "completed" ||
+        turn.error || turn.observationError || turn.interruptRequested || turn.interruptAcknowledged ||
+        turn.threadId !== text(threadId) || turn.id !== text(turnId) ||
+        result.threadId !== text(threadId) || result.turnId !== text(turnId) ||
+        result.inputMessageId !== text(turn.inputMessageId) || !result.conversationTurn) return null;
+    return structuredClone(result);
   }
 
   async function sendMessage(key, input, options, application) {
@@ -1037,6 +1101,8 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     let dispatchMonitor = null;
     let previousInputMessageId = null;
     let previousAdmission;
+    let recoveryReceipt = null;
+    let recoveryObservationError = null;
     try {
       const preparation = await application.prepare({ overwrite: !currentMonitor, threadId: currentThreadId });
       const preparedTarget = preparation.process ? await acquirePrepared(preparation.process) : preparation.target;
@@ -1053,6 +1119,24 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         await currentMonitor;
         currentMonitor = monitors.get(key);
       }
+      const recoveryTurn = currentMonitor ? turns.get(key) : null;
+      if (recoveryTurn?.recoveryAdmission) {
+        try {
+          recoveryReceipt = await recoveryTurn.recoveryAdmission.promise;
+          currentMonitor = monitors.get(key);
+          if (currentMonitor && !turns.get(key)?.active) {
+            await currentMonitor;
+            currentMonitor = monitors.get(key);
+          }
+          // Stop must not turn a waiting, undispatched input into a fresh turn.
+          recoveryTurn.abortController.signal.throwIfAborted();
+          target.abortController.signal.throwIfAborted();
+        } catch (error) {
+          // This is R's failure, not a rejected or attempted native B input.
+          return { failure: { error, attempted: false, threadId: currentThreadId,
+            turn: openCodeTurnSnapshot(turns.get(key), currentThreadId) } };
+        }
+      }
       admission = Promise.withResolvers();
       // The observer may be between polls when dispatch or persistence fails.
       // Keep the raw promise rejectable without an unhandled rejection.
@@ -1140,7 +1224,44 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       await dispatchMonitor.catch(() => null);
       throw error;
     }
-    admission.resolve();
+    if (recoveryReceipt) {
+      const receiptAbort = new AbortController();
+      // The original monitor can fail and retire without aborting its turn.
+      // Its settlement also ends this read; it never creates a successor turn.
+      void dispatchMonitor.then(() => receiptAbort.abort(new Error(
+        dispatchTurn.observationError || dispatchTurn.error || "OpenCode observation ended before input custody was confirmed."
+      )), error => receiptAbort.abort(error));
+      try {
+        const observation = await inspectOpenCodeMessageAdmission(target.server.client, currentThreadId,
+          text(admitted.id), { wait: true, signal: AbortSignal.any([
+            target.abortController.signal, dispatchTurn.abortController.signal, receiptAbort.signal
+          ]) });
+        const message = openCodeMessageRows(observation.messages).find(message =>
+          message.type === "user" && text(message.id) === text(admitted.id));
+        const created = message?.time?.created;
+        const recoveryCreated = recoveryReceipt.time?.created;
+        // Match the native latest-user order, including its ID tie-breaker.
+        if (!Number.isFinite(created) || !Number.isFinite(recoveryCreated) ||
+            !(created > recoveryCreated || (created === recoveryCreated && message.id > recoveryReceipt.id))) {
+          throw Object.assign(new Error(
+            "OpenCode could not confirm that the new input follows its final-answer recovery. The admitted message was not resent."
+          ), { code: "assistant_opencode_observation_lost", details: {}, statusCode: 503 });
+        }
+      } catch (error) {
+        recoveryObservationError = error;
+      } finally {
+        receiptAbort.abort();
+      }
+    }
+    if (recoveryObservationError) {
+      // Native B was dispatched: keep its authored receipt even when observing
+      // its place in native history failed, and use the original cleanup owner.
+      admission.reject(recoveryObservationError);
+      dispatchTurn.abortController.abort(recoveryObservationError);
+      await dispatchMonitor.catch(() => null);
+    } else {
+      admission.resolve();
+    }
     const turn = openCodeTurnSnapshot(turns.get(key), target.upstreamSessionId);
     return {
       conversationTurn,
@@ -1201,30 +1322,43 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
   }
 
   function beginMessageMonitor(key, target, admitted, options, projection) {
-    target = { ...target };
-    const existing = monitors.get(key);
-    if (existing) {
-      return existing;
-    }
-    const metadata = projection.prepare(admitted, options);
-    const eventStartedAt = Number(admitted.eventStartedAt) || Date.now();
-    const startedAt = text(admitted.startedAt) || new Date(eventStartedAt).toISOString();
-    const turn = {
-      abortController: new AbortController(),
-      admission: options.admission,
-      active: true,
-      error: "",
-      eventStartedAt,
-      id: text(admitted.id),
-      inputMessageId: text(admitted.id),
-      startedAt,
-      state: options.admission ? "starting" : "active",
-      ...metadata.fields,
-      threadId: target.upstreamSessionId,
-      updatedAt: startedAt
+    const start = () => {
+      target = { ...target };
+      const existing = monitors.get(key);
+      if (existing) {
+        return existing;
+      }
+      const metadata = projection.prepare(admitted, options);
+      const eventStartedAt = Number(admitted.eventStartedAt) || Date.now();
+      const startedAt = text(admitted.startedAt) || new Date(eventStartedAt).toISOString();
+      const turn = {
+        abortController: new AbortController(),
+        admission: options.admission,
+        active: true,
+        error: "",
+        eventStartedAt,
+        id: text(admitted.id),
+        inputMessageId: text(admitted.id),
+        startedAt,
+        state: options.admission ? "starting" : "active",
+        ...metadata.fields,
+        threadId: target.upstreamSessionId,
+        updatedAt: startedAt
+      };
+      const monitor = beginMonitor(key, target, turn, projection.create(target, turn, metadata, options));
+      void monitor.catch(error => projection.onError(error));
+      return monitor;
     };
-    const monitor = beginMonitor(key, target, turn, projection.create(target, turn, metadata, options));
-    void monitor.catch(error => projection.onError(error));
+    if (typeof projection.runInContext !== "function") return start();
+    let monitor, startFailure;
+    // Context entry invokes this callback synchronously. Do not return the
+    // monitor to an async scope wrapper: retain its identity and error owner.
+    const scope = projection.runInContext(() => {
+      try { monitor = start(); }
+      catch (error) { startFailure = { error }; }
+    });
+    void Promise.resolve(scope).catch(error => projection.onError(error));
+    if (startFailure) throw startFailure.error;
     return monitor;
   }
 
@@ -1232,6 +1366,15 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     observe, observation, eventReady, readiness, finalResponse,
     writeRun, projectMessages, completeResult, onRetired
   }) {
+    delete turn.finalAssistantResult;
+    delete turn.finalAssistantResultTarget;
+    delete turn.finalAssistantResultProcess;
+    const registeredTarget = processes.get(key);
+    const finalAssistantResultTarget = registeredTarget &&
+      registeredTarget.abortController === target.abortController &&
+      registeredTarget.server === target.server &&
+      registeredTarget.upstreamSessionId === target.upstreamSessionId ? registeredTarget : null;
+    const finalAssistantResultProcess = finalAssistantResultTarget ? sharedProcess : null;
     turns.set(key, turn);
     const signal = AbortSignal.any([target.abortController.signal, turn.abortController.signal]);
     const monitor = Promise.resolve().then(async () => {
@@ -1243,6 +1386,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
       }
       let finalState = "completed";
       let failure = "";
+      let finalAssistantResult = null;
       let credentialFailure = false;
       let providerApiFailure = false;
       try {
@@ -1285,7 +1429,8 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
             continue;
           }
           const projection = await projectMessages(completion.messages, {
-            inputMessageId: completion.inputMessageId
+            inputMessageId: completion.inputMessageId,
+            captureFinalAssistantResult: true
           });
           await turn.admission?.promise;
           signal.throwIfAborted();
@@ -1303,6 +1448,13 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
           } else if (turn.interruptRequested) {
             finalState = "interrupted";
           }
+          const published = projection.finalAssistantResult;
+          if (finalState === "completed" && !failure && published &&
+              published.inputMessageId === completion.inputMessageId &&
+              published.itemId === completion.result?.turnId &&
+              text(published.text) === text(completion.result?.text)) {
+            finalAssistantResult = { ...published, threadId: turn.threadId, turnId: turn.id };
+          }
           break;
         }
       } catch (error) {
@@ -1341,6 +1493,9 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
         }
         turn.error = failure;
         turn.state = finalState;
+        turn.finalAssistantResult = finalState === "completed" && !failure ? finalAssistantResult : null;
+        turn.finalAssistantResultTarget = turn.finalAssistantResult ? finalAssistantResultTarget : null;
+        turn.finalAssistantResultProcess = turn.finalAssistantResult ? finalAssistantResultProcess : null;
         turn.updatedAt = new Date().toISOString();
         await writeRun(turn, finalState, failure).catch(() => null);
       }
@@ -1615,7 +1770,7 @@ export function createOpenCodeSharedRuntime({ onStop = () => {}, scope } = {}) {
     ensurePreparedSessionReadiness, inspectSessionReadiness, recoverSessionReadiness, needsObservationRecovery, recoverObservation,
     createConversation, selectConversation, existingConversation, runConversationTurn, readConversation, readPersistentConversation, waitForConversationTurn,
     stopConversation, deleteConversation, sendMessage, hasActiveTemporaryConversation, reconcileSessions, reconcilePreparedSession, recordStoppedObservation, beginMessageMonitor, beginMonitor, writeBindings,
-    writeConversationProjection,
+    writeConversationProjection, readFinalAssistantResult,
     projectConversationMessages: projectOpenCodeConversationMessages,
     readSessionState, startPreparedTerminal, attachTerminal, closeTerminal, allowTerminalAttachments,
     turnSnapshot: openCodeTurnSnapshot, providerApiFailure: openCodeProviderApiFailure

package/src/server/conversation/openCodeTurn.js

@@ -135,18 +135,31 @@ export function openCodeMessageError(message = {}) {
 }
 
 export async function inspectOpenCodeMessageAdmission(client, conversationId, inputMessageId, {
-  signal = AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS)
+  signal = AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS), wait = false, readFailure = () => null
 } = {}) {
-  try {
-    // Do not create a missing native session or submit another prompt. Absence
-    // from bounded history is uncertainty, not proof of non-admission.
-    const messages = await client.messages(conversationId, { limit: 100, order: "desc" }, { signal });
-    const accepted = openCodeMessageRows(messages).some((message) =>
-      message.type === "user" && text(message.id) === inputMessageId);
-    return { accepted, messages };
-  } catch {
-    return null;
-  }
+  do {
+    if (wait) signal.throwIfAborted();
+    try {
+      // Do not create a missing native session or submit another prompt. Absence
+      // from bounded history is uncertainty, not proof of non-admission.
+      const readSignal = wait
+        ? AbortSignal.any([signal, AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS)])
+        : signal;
+      const messages = await client.messages(conversationId, { limit: 100, order: "desc" }, { signal: readSignal });
+      if (wait) signal.throwIfAborted();
+      const accepted = openCodeMessageRows(messages).some((message) =>
+        message.type === "user" && text(message.id) === inputMessageId);
+      if (accepted || !wait) return { accepted, messages };
+    } catch {
+      if (!wait) return null;
+      signal.throwIfAborted();
+    }
+    const failure = readFailure();
+    if (failure && (await client.sessionStatus(conversationId, { signal: AbortSignal.any([
+      signal, AbortSignal.timeout(OPENCODE_INTERRUPT_TIMEOUT_MS)
+    ]) })).type === "idle") throw failure;
+    await delay(250, undefined, { signal });
+  } while (wait);
 }
 
 export async function steerOpenCodeTurn(client, conversationId, turn, input, { signal } = {}) {
@@ -381,19 +394,47 @@ export async function waitForOpenCodeFinalResponse(client, conversationId, turn,
     if (admission !== turn.admission || completion.inputMessageId !== text(turn.inputMessageId)) {
       continue;
     }
-    const admitted = await client.prompt(conversationId, {
-      agent,
-      delivery: "queue",
-      id: recoveryMessageId,
-      model,
-      prompt: {
-        text: "Your previous response ended without a user-facing final answer. Do not call tools or repeat your reasoning. Return the concise final answer to the user's latest request now."
-      },
-      resume: true
-    }, { signal: options.signal });
-    if (admission === turn.admission && completion.inputMessageId === text(turn.inputMessageId)) {
-      turn.inputMessageId = text(admitted?.id) || recoveryMessageId;
-      turn.updatedAt = new Date().toISOString();
+    // The async native prompt ACK does not acknowledge user-row creation.
+    // A later authored input joins this exact receipt before its own dispatch.
+    const recoveryAdmission = Promise.withResolvers();
+    void recoveryAdmission.promise.catch(() => {});
+    turn.recoveryAdmission = recoveryAdmission;
+    const receiptAbort = new AbortController();
+    const receiptSignal = AbortSignal.any([...(options.signal ? [options.signal] : []), receiptAbort.signal]);
+    const receipt = inspectOpenCodeMessageAdmission(client, conversationId, recoveryMessageId, {
+      signal: receiptSignal, wait: true, readFailure: options.readFailure
+    }).then(observation => {
+      const message = openCodeMessageRows(observation.messages).find(message =>
+        message.type === "user" && text(message.id) === recoveryMessageId);
+      recoveryAdmission.resolve(message);
+      return message;
+    }, error => {
+      recoveryAdmission.reject(error);
+      throw error;
+    });
+    void receipt.catch(() => {});
+    try {
+      const admitted = await client.prompt(conversationId, {
+        agent,
+        delivery: "queue",
+        id: recoveryMessageId,
+        model,
+        prompt: {
+          text: "Your previous response ended without a user-facing final answer. Do not call tools or repeat your reasoning. Return the concise final answer to the user's latest request now."
+        },
+        resume: true
+      }, { signal: options.signal });
+      await receipt;
+      options.signal?.throwIfAborted();
+      if (admission === turn.admission && completion.inputMessageId === text(turn.inputMessageId)) {
+        turn.inputMessageId = text(admitted?.id) || recoveryMessageId;
+        turn.updatedAt = new Date().toISOString();
+      }
+    } catch (error) {
+      recoveryAdmission.reject(error);
+      throw error;
+    } finally {
+      receiptAbort.abort();
     }
     return waitForCompletion();
   }

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

@@ -16,10 +16,14 @@ export function createApiConversationDriver({ connections, apiClientFactory, fet
   if (!apiClientFactory && typeof connections?.resolve !== "function") throw new TypeError("API conversations require an authorized AI connection resolver.");
   const maximumOutput = limits.maxOutputCharacters ?? 64_000;
   const maximumHistory = limits.maxHistoryCharacters ?? 256_000;
+  const maximumToolProgress = limits.maxApiToolProgressCharacters;
   const preserveWhitespace = apiClientFactory?.preserveWhitespace !== false;
   for (const limit of [maximumOutput, maximumHistory]) {
     if (!Number.isSafeInteger(limit) || limit < 1) throw new TypeError("Invalid API conversation limit.");
   }
+  if (maximumToolProgress !== undefined && (!Number.isSafeInteger(maximumToolProgress) || maximumToolProgress < 1)) {
+    throw new TypeError("Invalid API application tool progress limit.");
+  }
   const driver = Object.freeze({
     admissionBeforeDispatch: true,
     attachmentTypes: ["text", "image", "file"],
@@ -102,6 +106,9 @@ export function createApiConversationDriver({ connections, apiClientFactory, fet
           } else if (finishReason !== "stop") {
             throw new Error("The model stream ended without confirming a completed answer.");
           }
+          if (calls.length && maximumToolProgress !== undefined && text.length > maximumToolProgress) {
+            throw new Error("Application tool progress text exceeds the configured API limit.");
+          }
           if (text.trim() && (calls.length || isAssistantProgressOnlyText(text))) {
             responseIsCommentary = true;
             await onMessage({ id, outputId: id, role: "commentary", text, complete: true });

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

@@ -2,10 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import path from "node:path";
 import { realpath } from "node:fs/promises";
-import { bindClaudeConversationAccount, claudeFlagSettings, claudeModelConfiguration, readClaudeCodeAuthStatus } from "../claudeProcess.js";
+import { bindClaudeConversationAccount, claudeConnectionIdentity, claudeFlagSettings, claudeModelConfiguration, readClaudeCodeAuthStatus } from "../claudeProcess.js";
 import { nativeAiModel, nativeAiProvider } from "../../../shared/nativeProviders.js";
 import { requireClaudeSessionId, listClaudeConversationStorage } from "../claudeHistory.js";
 import { createClaudeConversationOwner, claudeNativeMessageId } from "../claudeTurn.js";
+import { CLAUDE_APPLICATION_TOOL_SERVER } from "../claudeTools.js";
 import { createLocalConversationExecution } from "../localExecution.js";
 import { validateConversationConfiguration, validateConnectionModel } from "../configuration.js";
 
@@ -145,6 +146,20 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
         }
         const current = entry.command;
         if (!current) return;
+        if (event.type === "provider-event" && typeof current.onNativeToolUse === "function" && event.event.type === "assistant") {
+          const prefix = `mcp__${CLAUDE_APPLICATION_TOOL_SERVER}__`;
+          for (const block of event.event.message?.content || []) {
+            if (block.type !== "tool_use" || block.name === "StructuredOutput") continue;
+            if (typeof block.name !== "string" || block.name.length > 256 + prefix.length) continue;
+            if (entry.command !== current || current.entry !== entry || !current.admitted || current.signal.aborted) {
+              throw new Error("The native Claude tool observation has no current admitted command.");
+            }
+            const name = block.name.startsWith(prefix) ? block.name.slice(prefix.length) : block.name;
+            if (!name || name.length > 256) continue;
+            await current.onNativeToolUse({ messageId: current.messageId, threadId: entry.id, name });
+          }
+          return;
+        }
         if (event.type === "message") await current.onMessage({ ...event.message, transient: !event.message.complete });
         else if (event.type === "message-complete") await current.onEvent(event);
         else if ((event.type === "admitted" && current.goal) || event.type === "settled") {
@@ -155,7 +170,8 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
     return standalone;
   }
 
-  async function bindAccount(entry, configuration, context, signal = AbortSignal.timeout(30_000)) {
+  async function bindAccount(entry, configuration, context, signal = AbortSignal.timeout(30_000), requireBound = false, receiptBinding) {
+    const accountBinding = requireBound ? receiptBinding : entry.context.binding;
     let selected;
     let providerId;
     let identity;
@@ -163,6 +179,9 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       const connection = await connections.resolve({ context, integrationId: configuration.integrationId });
       signal.throwIfAborted();
       providerId = connection.providerId;
+      if (requireBound && !accountBinding?.connectionIdentities?.[providerId]) {
+        throw new Error("The completed Claude response has no saved provider account fingerprint.");
+      }
       const provider = nativeAiProvider(providerId);
       const model = nativeAiModel(connection.model, providerId);
       if (providerId !== "anthropic" && (!provider || !model)) throw new Error("This exact provider/model is not supported by the Claude integration. Choose a supported model without renaming it.");
@@ -171,8 +190,11 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       selected = claudeModelConfiguration({ providerId, model: connection.model }, {
         apiKey: connection.apiKey, baseUrl: provider?.claudeBaseUrl || connection.baseURL || "https://api.anthropic.com"
       });
-      identity = hash([configRoot, providerId, selected.env.ANTHROPIC_BASE_URL, connection.apiKey]);
+      identity = claudeConnectionIdentity(configRoot, providerId, selected.env.ANTHROPIC_BASE_URL, connection.apiKey);
     } else {
+      if (requireBound && !accountBinding?.accountIdentity) {
+        throw new Error("The completed Claude response has no saved native account fingerprint.");
+      }
       identity = await accountIdentity(signal);
       selected = claudeModelConfiguration({ providerId: "anthropic", model: configuration.model || "default" });
       // Returning to the native host clears connection overrides, while
@@ -180,7 +202,14 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       for (const name of Object.keys(selected.env)) if (Object.hasOwn(env, name)) selected.env[name] = env[name];
     }
     signal.throwIfAborted();
-    const previous = providerId ? entry.context.binding.connectionIdentities?.[providerId] : entry.context.binding.accountIdentity;
+    const previous = providerId ? accountBinding.connectionIdentities?.[providerId] : accountBinding.accountIdentity;
+    const cached = providerId ? entry.context.binding.connectionIdentities?.[providerId] : entry.context.binding.accountIdentity;
+    if (requireBound && previous !== cached) {
+      throw new Error("The completed Claude response no longer matches its saved account fingerprint.");
+    }
+    if (requireBound && identity !== previous) {
+      throw new Error("The completed Claude response belongs to a different account or provider connection.");
+    }
     await bindClaudeConversationAccount({ accountIdentity: previous,
       accountIdentities: { [providerId || "anthropic"]: previous }
     }, { identity, providerId: providerId || "anthropic",
@@ -294,11 +323,17 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
       let entry;
       if (!supplied) {
         requireClaudeSessionId(binding?.conversationId);
-        if (binding.workdir !== await realpath(workdir) || binding.configRoot !== configRoot) {
+        const scopeWorkdir = await realpath(workdir);
+        // Original scoped conversations keep native history in the credential
+        // home. Both paths must still come from the current authorized host.
+        const nativeWorkdir = Object.hasOwn(binding, "scopeWorkdir")
+          ? await realpath(env.HOME || homedir()) : scopeWorkdir;
+        if (binding.workdir !== nativeWorkdir || binding.configRoot !== configRoot ||
+          (Object.hasOwn(binding, "scopeWorkdir") && binding.scopeWorkdir !== scopeWorkdir)) {
           throw new Error("This Claude conversation belongs to another working directory or credential home. Restore its original host configuration.");
         }
         owner = standaloneOwner();
-        const context = { key: binding.workdir, workdir: binding.workdir, binding, reportFailure,
+        const context = { key: scopeWorkdir, workdir: binding.workdir, binding, reportFailure,
           async updateBinding(patch) {
             const next = { ...context.binding, ...patch };
             await writeBinding(next);
@@ -385,13 +420,23 @@ export function createClaudeConversationDriver({ connections, host = {}, limits
             ...(input.action !== "set" ? { createdAt: goal?.createdAt, objective: goal?.objective } : {}) }, { interrupt, send });
           return claudeGoalValue(await entry.goals.read(), entry.id);
         },
-        async inspectAdmission({ context, representation, ...input }) {
+        async inspectAdmission({ context, representation, verifyAccount = false, ...input }) {
           if (scoped) return unsupported();
           if (supplied) {
             await acquire(context);
             const result = await owner.inspectAdmission(await acquire(context), input);
             return representation === "native" ? result : { accepted: result.admission === "accepted" };
           }
+          if (verifyAccount === true) {
+            const binding = input.receiptBinding;
+            if (input.threadId !== entry.id || binding?.conversationId !== entry.id ||
+                binding.workdir !== entry.context.binding.workdir || binding.configRoot !== configRoot ||
+                Object.hasOwn(binding, "scopeWorkdir") !== Object.hasOwn(entry.context.binding, "scopeWorkdir") ||
+                binding.scopeWorkdir !== entry.context.binding.scopeWorkdir) {
+              throw new Error("The completed Claude response belongs to a different native conversation or host scope.");
+            }
+            await bindAccount(entry, input.configuration, context, AbortSignal.timeout(30_000), true, binding);
+          }
           const history = await owner.readHistory(entry);
           const nativeId = claudeNativeMessageId(input.messageId);
           return { accepted: history.userIds.includes(nativeId),