@jskit-ai/assistant-core 0.1.204 → 0.1.206

package/src/client/conversation/AssistantTranscript.vue

@@ -1,8 +1,9 @@
 <template>
   <section
-    v-if="visible"
+    v-if="visible || retainWhenHidden"
+    v-show="visible"
     class="assistant-transcript"
-    :class="`assistant-transcript--${variant}`"
+    :class="[`assistant-transcript--${variant}`, { 'assistant-transcript--retained': retainWhenHidden, 'assistant-transcript--error': error }]"
     aria-label="Conversation history"
   >
     <v-btn
@@ -39,15 +40,23 @@
 
     <v-alert
       v-if="error"
+      class="assistant-transcript__error"
       density="compact"
       type="warning"
       variant="tonal"
     >
-      {{ error }}
+      <div class="assistant-transcript__error-content">
+        <span>{{ error }}</span>
+        <v-btn
+          v-if="errorReloadable && !reloadable" :disabled="reloading" :min-height="48" size="small"
+          type="button" variant="text" @click="emit('reload')"
+        >
+          Reload chat
+        </v-btn>
+      </div>
     </v-alert>
 
     <div
-      v-else
       ref="bodyElement"
       aria-label="Conversation messages"
       class="assistant-transcript__body"
@@ -136,7 +145,13 @@
             <div
               class="assistant-transcript__user-content"
             >
-              <p v-if="userMessageFormat === 'plain'" class="assistant-transcript__plain-user">{{ userMessageExpanded(entry.turn) ? entry.message.text : userMessagePreviewText(entry.message.text) || entry.message.text }}</p>
+              <v-textarea
+                v-if="entry.turn.preview && previewForTurn(entry.turn)?.actions?.editing"
+                class="assistant-transcript__preview-editor" :model-value="previewForTurn(entry.turn).text" label="Review your message"
+                :disabled="!previewForTurn(entry.turn).actions.canEdit" density="compact" :rows="1" :max-rows="2"
+                auto-grow hide-details @update:model-value="previewForTurn(entry.turn).actions.update(entry.turn.turnId, $event)"
+              />
+              <p v-else-if="userMessageFormat === 'plain'" class="assistant-transcript__plain-user">{{ userMessageExpanded(entry.turn) ? entry.message.text : userMessagePreviewText(entry.message.text) || entry.message.text }}</p>
               <LongTextPreviewBlocks
                 v-else
                 :blocks="userMessageExpanded(entry.turn) ? entry.message.blocks : (entry.message.previewBlocks || entry.message.blocks)"
@@ -160,12 +175,13 @@
               <time v-if="entry.message.displayAt">{{ entry.message.displayAt }}</time>
               <span v-if="entry.turn.optimistic?.status === 'pending'" role="status">Pending</span>
             </div>
+            <slot name="user-message-actions" :message="entry.message" :turn="entry.turn" />
             <div
               v-if="entry.turn.optimistic?.status === 'failed'"
               class="assistant-transcript__optimistic-failure"
             >
               <span role="status">Failed: {{ entry.turn.optimistic.error || "Message could not be sent." }}</span>
-              <div class="assistant-transcript__optimistic-actions">
+              <div v-if="!entry.turn.preview" class="assistant-transcript__optimistic-actions">
                 <v-btn
                   class="assistant-transcript__delivery-action"
                   color="primary"
@@ -311,8 +327,14 @@ import {
   normalizeThinkingMessageText
 } from "../../shared/conversation/thinkingText.js";
 
+function previewForTurn(turn) {
+  const preview = turn.previewMessage || props.previewMessage;
+  return (preview?.messageId || preview?.id) === turn.turnId ? preview : null;
+}
+
 const props = defineProps({
   systemLabel: { type: String, default: "Status" },
+  previewMessage: { type: Object, default: null },
   working: { type: Boolean, default: undefined },
   progressPreviewLimit: { type: Number, default: 2 },
   userMessageFormat: { type: String, default: "formatted", validator: (value) => ["plain", "formatted"].includes(value) },
@@ -324,6 +346,10 @@ const props = defineProps({
     default: "",
     type: String
   },
+  errorReloadable: {
+    default: false,
+    type: Boolean
+  },
   followLatestKey: {
     default: 0,
     type: [Number, String]
@@ -352,6 +378,10 @@ const props = defineProps({
     default: false,
     type: Boolean
   },
+  retainWhenHidden: {
+    default: false,
+    type: Boolean
+  },
   scrollKey: {
     default: "",
     type: [Number, String]
@@ -393,6 +423,7 @@ let liveScrollFrame = 0;
 let userScrollIntentTimer = null;
 let initialScrollVersion = 0;
 let loadMoreScrollSnapshot = null;
+let retainedReaderScrollSnapshot = null;
 let loadMoreRequestVersion = 0;
 let pendingTailFollow = false;
 let previousScrollTop = 0;
@@ -636,7 +667,6 @@ function messageScrollKey(message = null) {
 }
 
 const timelineScrollTrigger = computed(() => [
-  props.error ? "error" : "body",
   loadingIndicatorVisible.value ? "loading" : "ready",
   displayEntries.value.length ? "has-messages" : "empty",
   props.scrollKey
@@ -685,6 +715,7 @@ function resumePendingTailFollow() {
 }
 
 function markUserScrollIntent() {
+  retainedReaderScrollSnapshot = null;
   userScrollIntent.value = true;
   clearLiveBottomScroll();
   clearScheduledScrolls();
@@ -722,6 +753,7 @@ function scrollToLatestMessageAfterLayout({
   force = false
 } = {}) {
   if (force) {
+    retainedReaderScrollSnapshot = null;
     followingLatest.value = true;
     clearUserScrollIntent();
   }
@@ -734,6 +766,9 @@ function queueInitialBottomScroll() {
   const version = initialScrollVersion + 1;
   initialScrollVersion = version;
   initialScrollSettled.value = false;
+  if (props.retainWhenHidden && !props.visible) {
+    return;
+  }
   void scrollToLatestMessageAfterLayout({
     behavior: "auto",
     force: true
@@ -752,10 +787,14 @@ function queueLiveBottomScroll({
     return;
   }
   if (force) {
+    retainedReaderScrollSnapshot = null;
     pendingTailFollow = false;
     followingLatest.value = true;
     clearUserScrollIntent();
   }
+  if (props.retainWhenHidden && !props.visible) {
+    return;
+  }
   if (liveScrollFrame) {
     return;
   }
@@ -781,14 +820,22 @@ function clearLiveBottomScroll() {
 }
 
 function updateLatestFollowFromScroll(event = {}) {
+  if (props.retainWhenHidden && !props.visible) {
+    return;
+  }
   const target = event?.currentTarget || bodyElement.value;
+  if (retainedReaderScrollSnapshot?.restoring) {
+    previousScrollTop = target?.scrollTop || 0;
+    return;
+  }
   const scrollTop = target?.scrollTop || 0;
   const scrolledUp = scrollTop < previousScrollTop;
   previousScrollTop = scrollTop;
   // Keep following the reader while the request is pending, before rows prepend.
-  if (loadMoreScrollSnapshot && target.scrollHeight === loadMoreScrollSnapshot.scrollHeight) {
+  if (loadMoreScrollSnapshot && !loadMoreScrollSnapshot.completed) {
     loadMoreScrollSnapshot.scrollTop = scrollTop;
     loadMoreScrollSnapshot.anchor = visibleHistoryAnchor(target);
+    loadMoreScrollSnapshot.scrollHeight = target.scrollHeight;
   }
   const shouldFollow = scrollElementNearBottom(target);
   if (!shouldFollow && !userScrollIntent.value && followingLatest.value) {
@@ -823,8 +870,42 @@ function visibleHistoryAnchor(element) {
   return null;
 }
 
+async function restoreRetainedReaderScroll() {
+  const snapshot = retainedReaderScrollSnapshot;
+  snapshot.restoring = true;
+  await nextTick();
+  for (let pass = 0; pass < 2; pass += 1) {
+    const element = bodyElement.value;
+    if (
+      retainedReaderScrollSnapshot !== snapshot ||
+      element !== snapshot.body ||
+      snapshot.scrollKey !== props.scrollKey ||
+      !props.retainWhenHidden ||
+      !props.visible ||
+      followingLatest.value ||
+      loadMoreScrollSnapshot
+    ) {
+      if (retainedReaderScrollSnapshot === snapshot) retainedReaderScrollSnapshot = null;
+      return;
+    }
+    const anchor = snapshot.anchor;
+    if (anchor && element.contains(anchor.element)) {
+      // Materialize the retained row before reading the browser's adjusted scrollTop.
+      const offset = anchor.element.getBoundingClientRect().top - element.getBoundingClientRect().top;
+      previousScrollTop = element.scrollTop + offset - anchor.offset;
+    } else {
+      previousScrollTop = snapshot.scrollTop + (element.scrollHeight - snapshot.scrollHeight);
+    }
+    element.scrollTop = previousScrollTop;
+    if (pass === 0 && typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
+      await new Promise(resolve => window.requestAnimationFrame(() => window.requestAnimationFrame(resolve)));
+    }
+  }
+  if (retainedReaderScrollSnapshot === snapshot) retainedReaderScrollSnapshot = null;
+}
+
 function requestLoadMore() {
-  if (!props.hasMoreBefore || props.loadingMore || loadMoreScrollSnapshot) {
+  if ((props.retainWhenHidden && !props.visible) || !props.hasMoreBefore || props.loadingMore || loadMoreScrollSnapshot) {
     return;
   }
   followingLatest.value = false;
@@ -863,24 +944,43 @@ async function completeLoadMoreRequest(version, changed) {
     clearLoadMoreScrollSnapshot();
     return;
   }
+  snapshot.completed = true;
   await nextTick();
   if (loadMoreScrollSnapshot?.version !== version) {
     return;
   }
-  const element = bodyElement.value;
-  if (element) {
-    // Offscreen turns use estimated heights. Preserve the visible turn instead
-    // of moving by the total height difference, which can change during layout.
-    const anchor = snapshot.anchor;
-    previousScrollTop = anchor && element.contains(anchor.element)
-      ? element.scrollTop + anchor.element.getBoundingClientRect().top - element.getBoundingClientRect().top - anchor.offset
-      : snapshot.scrollTop + (element.scrollHeight - snapshot.scrollHeight);
-    element.scrollTop = previousScrollTop;
+  const passes = props.retainWhenHidden ? 2 : 1;
+  for (let pass = 0; pass < passes; pass += 1) {
+    if (
+      (props.retainWhenHidden && !props.visible) ||
+      loadMoreScrollSnapshot?.version !== version ||
+      snapshot.scrollKey !== props.scrollKey
+    ) {
+      return;
+    }
+    const element = bodyElement.value;
+    if (element) {
+      // Offscreen turns use estimated heights. Preserve the visible turn instead
+      // of moving by the total height difference, which can change during layout.
+      const anchor = snapshot.anchor;
+      if (anchor && element.contains(anchor.element)) {
+        const offset = anchor.element.getBoundingClientRect().top - element.getBoundingClientRect().top;
+        previousScrollTop = element.scrollTop + offset - anchor.offset;
+      } else {
+        previousScrollTop = snapshot.scrollTop + (element.scrollHeight - snapshot.scrollHeight);
+      }
+      element.scrollTop = previousScrollTop;
+    }
+    if (pass + 1 < passes && typeof window !== "undefined" && typeof window.requestAnimationFrame === "function") {
+      // Reopening materializes previously hidden content-visibility estimates.
+      await new Promise(resolve => window.requestAnimationFrame(() => window.requestAnimationFrame(resolve)));
+    }
   }
   clearLoadMoreScrollSnapshot();
 }
 
 onBeforeUnmount(() => {
+  retainedReaderScrollSnapshot = null;
   clearLiveBottomScroll();
   clearUserScrollIntent();
   clearLoadMoreScrollSnapshot();
@@ -923,6 +1023,7 @@ watch(() => [
 });
 
 watch(timelineScrollTrigger, () => {
+  retainedReaderScrollSnapshot = null;
   clearLoadMoreScrollSnapshot();
   queueInitialBottomScroll();
 }, {
@@ -930,7 +1031,50 @@ watch(timelineScrollTrigger, () => {
   immediate: true
 });
 
+watch(() => props.error, () => {
+  if (followingLatest.value) queueLiveBottomScroll();
+}, { flush: "post" });
+
+// Capture before this transcript or its parent's v-show removes its geometry.
+watch(() => props.visible, (visible) => {
+  if (visible) return;
+  retainedReaderScrollSnapshot = null;
+  const element = bodyElement.value;
+  if (
+    props.retainWhenHidden &&
+    initialScrollSettled.value &&
+    !followingLatest.value &&
+    !loadMoreScrollSnapshot &&
+    element?.clientHeight > 0
+  ) {
+    retainedReaderScrollSnapshot = {
+      anchor: visibleHistoryAnchor(element),
+      body: element,
+      scrollHeight: element.scrollHeight,
+      scrollKey: props.scrollKey,
+      scrollTop: element.scrollTop
+    };
+  }
+}, { flush: "sync" });
+
 watch(() => props.visible, (visible) => {
+  if (props.retainWhenHidden) {
+    if (!visible) {
+      clearLiveBottomScroll();
+      clearScheduledScrolls();
+      clearUserScrollIntent();
+      initialScrollVersion += 1;
+    } else if (loadMoreScrollSnapshot?.completed) {
+      void completeLoadMoreRequest(loadMoreScrollSnapshot.version, true);
+    } else if (!initialScrollSettled.value) {
+      queueInitialBottomScroll();
+    } else if (retainedReaderScrollSnapshot) {
+      void restoreRetainedReaderScroll();
+    } else {
+      queueLiveBottomScroll();
+    }
+    return;
+  }
   clearLoadMoreScrollSnapshot();
   if (visible) queueLiveBottomScroll({ force: true });
 }, { flush: "post" });
@@ -958,6 +1102,31 @@ watch(() => props.visible, (visible) => {
   z-index: 1;
 }
 
+.assistant-transcript--error {
+  grid-template-rows: auto minmax(0, 1fr);
+}
+
+.assistant-transcript__error {
+  font-size: 0.85rem;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.assistant-transcript__error-content {
+  align-items: flex-start;
+  display: flex;
+  gap: 0.5rem;
+}
+
+.assistant-transcript__error-content > span {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+
+.assistant-transcript__error-content > .v-btn {
+  flex: 0 0 auto;
+}
+
 .assistant-transcript__settling {
   background: rgb(var(--v-theme-surface));
   inset: 0;
@@ -1043,6 +1212,11 @@ watch(() => props.visible, (visible) => {
   min-width: 0;
 }
 
+.assistant-transcript--retained .assistant-transcript__turn {
+  /* Late offscreen height estimates cannot move a restored reader anchor. */
+  content-visibility: visible;
+}
+
 .assistant-transcript__message-row {
   align-items: start;
   display: grid;

package/src/server/conversation/claudeClient.js

@@ -156,7 +156,8 @@ function createClaudeJsonClient({ stream, onEvent = async () => {}, onControlReq
 
   const completion = (async () => {
     try {
-      for await (const frame of readClaudeJsonFrames(stream)) {
+      // Teardown belongs to this client after queued events finish, not the iterator.
+      for await (const frame of readClaudeJsonFrames(stream.iterator({ destroyOnReturn: false }))) {
         if (frame.type === "control_response") {
           const response = frame.response;
           const pending = requests.get(response?.request_id);

package/src/server/conversation/claudeTurn.js

@@ -903,9 +903,17 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       if (frame.state === "queued" || frame.type === "user") {
         const pending = admissions.get(uuid);
         if (pending) {
-          await pending.accept();
-          admissions.delete(uuid);
-          pending.resolve();
+          // Once acknowledged, storage owns the admission decision. Its write
+          // must not race a native-ack timeout and a second submission.
+          clearTimeout(pending.timer);
+          try {
+            await pending.accept();
+            admissions.delete(uuid);
+            pending.resolve();
+          } catch (error) {
+            pending.reject(error);
+            throw error;
+          }
         }
         await publish({ type: "admitted", messageId: uuid, userEcho: frame.type === "user" });
       }
@@ -959,10 +967,11 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
         await publishMessage(block);
       }
     } else if (frame.type === "result") {
-      result = typeof frame.structured_output === "object" ? JSON.stringify(frame.structured_output) : String(frame.result || "");
-      checkOutput(result);
+      const output = typeof frame.structured_output === "object" ? JSON.stringify(frame.structured_output) : String(frame.result || "");
+      checkOutput(output);
       const failed = frame.is_error || frame.subtype !== "success";
-      const message = failed ? (frame.errors || []).join("; ") || result || frame.subtype : "";
+      const message = failed ? (frame.errors || []).join("; ") || output || frame.subtype : "";
+      result = failed ? "" : output;
       if (result && ![...messages.values()].some((block) => block.complete && block.role === "assistant" && block.text === result)) {
         await publishMessage({ id: `claude_${frame.uuid || turnId}_result`, role: "assistant", text: result, complete: true });
       }
@@ -1038,12 +1047,12 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       if (!uuid || typeof accept !== "function" || admissions.has(uuid)) throw new TypeError("A distinct message id and admission writer are required.");
       const admitted = Promise.withResolvers();
       void admitted.promise.catch(() => {});
-      admissions.set(uuid, { ...admitted, accept });
       inFlight.add(uuid);
       const timer = setTimeout(() => admitted.reject(Object.assign(
         failure("Claude has not acknowledged this prompt. Its delivery is uncertain.", "assistant_claude_admission_unknown"),
         { delivery: "uncertain" }
       )), timeoutMs);
+      admissions.set(uuid, { ...admitted, accept, timer });
       try {
         await Promise.all([client.send(message, { messageId: uuid, sessionId: conversationId }), admitted.promise]);
       } finally {

package/src/server/conversation/codexConversations.js

@@ -298,6 +298,99 @@ export function createCodexConversationCommands({
     });
   }
 
+  async function runDetachedCodexAppServerConversation(sessionId, input = {}, options = {}) {
+    const preparation = conversationPreparation.detached(sessionId, input);
+    const { admission } = preparation;
+    if (admission.ok === false) return admission;
+    try {
+      return await codexAppServerConversationResult(async () => {
+        const unavailable = preparation.result;
+        if (unavailable) return unavailable;
+        const prompt = preparation.prompt;
+        const context = await codexAppServerConversationContext(sessionId, input, options);
+        if (context.ok === false) return context;
+        const { provider, runtime, workdir } = context;
+        const executionProfile = input.executionProfile && typeof input.executionProfile === "object" &&
+          !Array.isArray(input.executionProfile) ? input.executionProfile : null;
+        const helperTurn = Boolean(executionProfile);
+        const emitDetachedEvent = event => {
+          if (typeof options.onEvent === "function") options.onEvent(event);
+        };
+        const onRetired = ({ threadId }) => emitDetachedEvent({ threadId, type: "thread-retired" });
+        if (helperTurn) {
+          await assertCodexAppServerHelperAccountIdentity(provider, input.expectedAccountIdentitySignature, helperOwnershipError);
+        }
+        const execution = preparation.execution(context);
+        const threadSettings = helperTurn ? null : await prepareCodexAppServerConversationThread(
+          provider, execution.threadPreparation, conversationPreparation.isolation
+        );
+        const requestedThreadId = normalizeCodexRunText(input.threadId || input.codexSessionId);
+        let helper = null;
+        let thread;
+        if (helperTurn) {
+          const scope = { executionProfile, onRetired, projectRuntimeRoot: normalizeCodexRunText(runtime?.stateRoot),
+            projectContextRoot: normalizeCodexRunText(runtime?.projectContextRoot), provider, sessionId, requestedThreadId, workdir,
+            ...(requestedThreadId ? { record: helperLifecycle.threadForOperation({ executionProfile,
+              projectRuntimeRoot: normalizeCodexRunText(runtime?.stateRoot), provider, sessionId,
+              threadId: requestedThreadId, workdir }) } : {}) };
+          helper = await helperLifecycle.prepareDetached(scope, execution.helperPreparation);
+          thread = helper.thread;
+        } else {
+          thread = await acquireCodexAppServerDetachedThread(provider, requestedThreadId, threadSettings, input);
+        }
+        const threadId = codexAppServerDetachedThreadId(thread, requestedThreadId);
+        emitDetachedEvent({ threadId, type: "thread" });
+        const requestedTimeoutMs = Number(input.timeoutMs || 0);
+        const profileTimeoutMs = Number(executionProfile?.limits?.timeoutMs || 0);
+        let turnId = "";
+        const result = await runDetachedCodexAppServerTurn({
+          provider, threadId, onEvent: emitDetachedEvent,
+          timeoutMs: helperTurn
+            ? Math.min(requestedTimeoutMs > 0 ? requestedTimeoutMs : profileTimeoutMs, profileTimeoutMs)
+            : requestedTimeoutMs > 0 ? requestedTimeoutMs : CODEX_APP_SERVER_DETACHED_TURN_TIMEOUT_MS,
+          async onFailure(error, status) {
+            await helper?.discard();
+            return execution.failure(error, status);
+          }
+        }, async failDispatch => {
+          let dispatched;
+          if (helperTurn) {
+            dispatched = await helper.dispatch(threadId, failDispatch);
+          } else {
+            try {
+              dispatched = await dispatchCodexAppServerDetachedTurn({ provider, prompt, threadId }, execution.authorized);
+            } catch (error) {
+              await failDispatch(error);
+            }
+          }
+          turnId = dispatched.turnId;
+          return dispatched;
+        });
+        if (helperTurn) {
+          try {
+            await assertCodexAppServerHelperAccountIdentity(provider, input.expectedAccountIdentitySignature, helperOwnershipError);
+          } catch (error) {
+            await helper.discard();
+            throw error;
+          }
+          try {
+            execution.validateOutput(result.text);
+          } catch (error) {
+            await helper.discard();
+            throw error;
+          }
+          await helper.complete();
+        }
+        emitDetachedEvent({ status: result.status || "completed", text: result.text,
+          threadId, turnId: result.turnId || turnId, type: "completed" });
+        return { ok: true, text: result.text, threadId, turnId: result.turnId || turnId,
+          ...(helperTurn ? { inputCharacters: prompt.length, outputCharacters: result.text.length, usage: result.usage || null } : {}) };
+      });
+    } finally {
+      admission.release();
+    }
+  }
+
   async function startCodexAppServerConversationTurn(sessionId, input = {}, options = {}) {
     const messageId = normalizeCodexRunText(input.messageId);
     return withCodexAppServerConversationTurnStart(sessionId, input, () => codexAppServerConversationResult(async () => {
@@ -1063,6 +1156,7 @@ export function createCodexConversationCommands({
     codexAppServerConversationContext,
     codexAppServerEphemeralScopeContext,
     createCodexAppServerConversation,
+    runDetachedCodexAppServerConversation,
     startCodexAppServerConversationTurn,
     readCodexAppServerConversation,
     waitForCodexAppServerConversationTurn,

package/src/server/conversation/codexProvider.js

@@ -1279,6 +1279,10 @@ export class CodexAppServerAgentProvider {
       prepareHistory: (params, client, context) => this.withHistoryAdapter(params, client, context),
       threadParameters: codexAppServerThreadRequestParams,
       verifyEnvironment: (...args) => this.#verifyThreadEnvironment(...args),
+      recordInterruption: (threadId, turnId) => {
+        const key = JSON.stringify([threadId, turnId]);
+        this.interruptedTurns.set(key, this.interruptedTurns.get(key) || "control_reconfiguration");
+      },
       onRecoveryFailure: (id) => {
         const probe = this.threadControlProbes.get(id);
         if (probe && !probe.verified) {
@@ -1292,7 +1296,7 @@ export class CodexAppServerAgentProvider {
     });
     this.threadControlProbes = new Map();
     this.commandExecutions = new Map();
-    this.interruptedTurns = new Set();
+    this.interruptedTurns = new Map();
     this.commandStopFailure = null;
   }
 
@@ -2574,16 +2578,22 @@ export class CodexAppServerAgentProvider {
     };
   }
 
-  async interruptTurn(threadId = "", turnId = "") {
+  interruptionOutcome(threadId = "", turnId = "") {
+    const key = JSON.stringify([normalizeAgentText(threadId), normalizeAgentText(turnId)]);
+    return this.interruptedTurns.get(key) || "";
+  }
+
+  async interruptTurn(threadId = "", turnId = "", { outcome = "" } = {}) {
     const client = await this.activeClient();
     return this.runRequest(
-      () => this.#interruptTurn(client, normalizeAgentText(threadId), normalizeAgentText(turnId)),
+      () => this.#interruptTurn(client, normalizeAgentText(threadId), normalizeAgentText(turnId), undefined, outcome),
       "codex-app-server-turn-interrupt"
     );
   }
 
-  async #interruptTurn(client, threadId, turnId, signal) {
-    this.interruptedTurns.add(JSON.stringify([threadId, turnId]));
+  async #interruptTurn(client, threadId, turnId, signal, outcome = "") {
+    const key = JSON.stringify([threadId, turnId]);
+    this.interruptedTurns.set(key, outcome || this.interruptedTurns.get(key) || "");
     const result = await client.request("turn/interrupt", { threadId, turnId }, { signal });
     await Promise.all([...this.commandExecutions.values()]
       .filter((command) => command.threadId === threadId && command.turnId === turnId)