@jskit-ai/assistant-core 0.1.205 → 0.1.207

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.205",
-    "@jskit-ai/http-runtime": "0.1.225",
-    "@jskit-ai/kernel": "0.1.227",
+    "@jskit-ai/assistant-core": "0.1.207",
+    "@jskit-ai/http-runtime": "0.1.227",
+    "@jskit-ai/kernel": "0.1.229",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.1.44",
-    "@jskit-ai/connectors-catalog": "0.1.44"
+    "@jskit-ai/connectors-core": "0.1.46",
+    "@jskit-ai/connectors-catalog": "0.1.46"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/fixtures/responsive-assistant/App.vue

@@ -4,8 +4,12 @@ import AssistantConversationElement from "../../src/client/conversation/Assistan
 import { conversationTurnsFromMessages } from "../../src/shared/conversation/turns.js";
 import { mergeConversationStream } from "../../src/shared/conversation/streaming.js";
 const draft = ref("");
-const visible = ref(true);
+const error = ref("");
+const reloads = ref(0);
 const query = new URLSearchParams(location.search);
+const visible = ref(!query.has("initial-hidden"));
+const retainWhenHidden = query.has("retain-hidden");
+const mounted = ref(true);
 const controls = query.has("controls");
 const deferredHistory = query.has("history");
 const pagedHistory = query.has("paged-history");
@@ -52,12 +56,16 @@ function finishHistory(error = "") {
 const adapter = computed(() => ({
   conversation: {
     visible: visible.value,
+    retainWhenHidden,
+    error: error.value,
+    errorReloadable: true,
     turns: mergeConversationStream(conversationTurnsFromMessages(messages.value), { messages: [liveMessage.value] }), scrollKey: scope.value,
     hasMoreBefore: hasMoreBefore.value, loadingMore: loadingMore.value, loadMoreError: loadMoreError.value
   },
   composer: { draft: draft.value, canSend: Boolean(draft.value.trim()), rows: 2 },
   actions: {
     setDraft(value) { draft.value = value; },
+    reload() { reloads.value += 1; error.value = ""; },
     submit() { draft.value = ""; },
     loadMore({ complete }) {
       historyRequests.value += 1;
@@ -81,6 +89,8 @@ const adapter = computed(() => ({
           <button @click="visible = !visible">Toggle visibility</button>
           <button @click="scope = scope === 'one' ? 'two' : 'one'">Change conversation</button>
           <button @click="messages.push({ id: `added-${messages.length}`, role: 'assistant', text: 'New reply. '.repeat(30), status: 'completed' })">Append reply</button>
+          <button v-if="query.has('update-errors')" @click="error = 'Conversation updates are temporarily unavailable. Reload to reconnect; the assistant may still be working.'">Show update error</button>
+          <button v-if="retainWhenHidden" @click="mounted = !mounted">Toggle mount</button>
         </nav>
         <nav v-if="deferredHistory">
           <button :disabled="!loadingMore" @click="finishHistory()">Complete history load</button>
@@ -88,7 +98,7 @@ const adapter = computed(() => ({
           <button @click="hasMoreBefore = false">Exhaust history</button>
           <output>History requests: {{ historyRequests }}</output>
         </nav>
-        <AssistantConversationElement v-show="visible" :adapter="adapter" class="assistant-responsive-fixture__conversation" />
+        <AssistantConversationElement v-if="mounted" v-show="visible" :adapter="adapter" :data-error-reloads="reloads" class="assistant-responsive-fixture__conversation" />
       </main>
     </v-main>
   </v-app>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.205",
+  "version": "0.1.207",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -32,7 +32,9 @@
     "./server/codex-provider": "./src/server/hosts/codexProvider.js",
     "./server/native-history": "./src/server/hosts/nativeHistory.js",
     "./testing/native-codex": "./src/testing/nativeCodex.js",
-    "./testing/native-opencode": "./src/testing/nativeOpenCode.js"
+    "./testing/native-opencode": "./src/testing/nativeOpenCode.js",
+    "./server/codex-client": "./src/server/conversation/codexClient.js",
+    "./client/conversation-submit": "./src/client/conversation/submitText.js"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^4.0.53",
@@ -45,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.169",
-    "@jskit-ai/resource-crud-core": "0.1.169",
+    "@jskit-ai/resource-core": "0.1.171",
+    "@jskit-ai/resource-crud-core": "0.1.171",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -55,8 +57,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.225",
-    "@jskit-ai/kernel": "0.1.227",
+    "@jskit-ai/http-runtime": "0.1.227",
+    "@jskit-ai/kernel": "0.1.229",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },
@@ -126,15 +128,15 @@
           },
           {
             "subpath": "./server/codex-events",
-            "summary": "Advanced native host: Codex event identities, thread-history projections and context-refresh facts for native hosts."
+            "summary": "Advanced native host: Original Codex event classification, text, status and identity helpers, thread-history projections and context-refresh facts."
           },
           {
             "subpath": "./server/codex-turn",
-            "summary": "Advanced native host: Original Codex run, receipt, observation, goal, steering, control, scoped-turn and renewal coordination."
+            "summary": "Advanced native host: Original detached-turn watcher and status predicates, plus Codex run, receipt, observation, goal, steering, control, scoped-turn and renewal coordination."
           },
           {
             "subpath": "./server/opencode-client",
-            "summary": "Advanced native host: OpenCode native history retirement for existing hosts."
+            "summary": "Advanced native host: Original OpenCode loopback client, bounded response and assistant text helpers, plus native history retirement."
           },
           {
             "subpath": "./server/claude-history",
@@ -187,6 +189,14 @@
           {
             "subpath": "./testing/native-opencode",
             "summary": "Testing: Original OpenCode loopback client for isolated host integration tests; tests own endpoints, authorization and cleanup."
+          },
+          {
+            "subpath": "./server/codex-client",
+            "summary": "Advanced native host: Original Codex JSON-RPC client and endpoint socket-path helper; hosts retain authorization, transport limits and native lifecycle coordination."
+          },
+          {
+            "subpath": "./client/conversation-submit",
+            "summary": "Optional UI: Original text submission helper forwards companion text through the application draft and canonical send action; also exported by ./client/conversation."
           }
         ],
         "capabilities": []

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"
@@ -337,6 +346,10 @@ const props = defineProps({
     default: "",
     type: String
   },
+  errorReloadable: {
+    default: false,
+    type: Boolean
+  },
   followLatestKey: {
     default: 0,
     type: [Number, String]
@@ -365,6 +378,10 @@ const props = defineProps({
     default: false,
     type: Boolean
   },
+  retainWhenHidden: {
+    default: false,
+    type: Boolean
+  },
   scrollKey: {
     default: "",
     type: [Number, String]
@@ -406,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;
@@ -649,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
@@ -698,6 +715,7 @@ function resumePendingTailFollow() {
 }
 
 function markUserScrollIntent() {
+  retainedReaderScrollSnapshot = null;
   userScrollIntent.value = true;
   clearLiveBottomScroll();
   clearScheduledScrolls();
@@ -735,6 +753,7 @@ function scrollToLatestMessageAfterLayout({
   force = false
 } = {}) {
   if (force) {
+    retainedReaderScrollSnapshot = null;
     followingLatest.value = true;
     clearUserScrollIntent();
   }
@@ -747,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
@@ -765,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;
   }
@@ -794,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) {
@@ -836,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;
@@ -876,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();
@@ -936,6 +1023,7 @@ watch(() => [
 });
 
 watch(timelineScrollTrigger, () => {
+  retainedReaderScrollSnapshot = null;
   clearLoadMoreScrollSnapshot();
   queueInitialBottomScroll();
 }, {
@@ -943,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" });
@@ -971,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;
@@ -1056,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/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,