chainlesschain 0.166.46 → 0.166.47

package/src/lib/app-server/cli-agent-kernel-adapter.js

@@ -2,6 +2,7 @@ import { PassThrough } from "node:stream";
 import { randomUUID } from "node:crypto";
 import {
   assertSandboxAvailable,
+  assertSandboxCapabilities,
   normalizeAgentSandboxMode,
 } from "../agent-sandbox.js";
 
@@ -127,6 +128,7 @@ export class CliAgentKernelAdapter {
         },
       },
     );
+    assertSandboxCapabilities(sandbox);
     assertSandboxAvailable(sandbox);
 
     const input = new PassThrough();
@@ -166,6 +168,26 @@ export class CliAgentKernelAdapter {
             binding: event.binding,
           });
         }
+        if (event.type === "question_request") {
+          const answerQuestion = async () => {
+            let answer = null;
+            try {
+              answer = await current.requestQuestion(event);
+            } catch {
+              // A missing/rejecting host is cancellation, never implicit consent.
+            }
+            writeLine(input, {
+              type: "answer",
+              id: event.id,
+              answer,
+              binding: event.binding,
+            });
+          };
+          // The Headless runtime owns blocking semantics and its timeout. Keep
+          // the transport event chain free so a timed-out question can emit
+          // question_resolved/result even while a slow host request is pending.
+          void answerQuestion().catch(() => {});
+        }
         if (event.type === "result") {
           session.current = null;
           current.resolve(event);
@@ -194,6 +216,7 @@ export class CliAgentKernelAdapter {
         permissionMode,
         sandbox,
         interactiveApprovals: true,
+        interactiveQuestions: turnOptions.interactiveQuestions === true,
         includePartialMessages: true,
         ephemeral: false,
         evolutionIngress:
@@ -263,6 +286,7 @@ export class CliAgentKernelAdapter {
     options = {},
     emit,
     requestApproval,
+    requestQuestion,
   }) {
     const session = await this._session(threadId, options);
     if (session.current) {
@@ -283,6 +307,10 @@ export class CliAgentKernelAdapter {
         turnId,
         emit,
         requestApproval,
+        requestQuestion:
+          typeof requestQuestion === "function"
+            ? requestQuestion
+            : async () => null,
         resolve,
         reject,
       };

package/src/lib/app-server/server.js

@@ -10,6 +10,7 @@ import { AppServerGraphRuntime } from "./graph-runtime.js";
 import { captureAgentSkillOutcomeIndex } from "../evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../skill-vector-authority.js";
 import { captureSkillRetrievalRevocationReader } from "../evolution/skill-retrieval-revocation-authority.js";
+import { sameInteractionBinding } from "../interaction-binding.js";
 import { compileGraphDefinition } from "../graph-kernel/compiler.js";
 import { createCliContextMemoryRuntime } from "../context-memory-kernel/runtime.js";
 import { isEvolutionWorkbenchCliHost } from "../evolution/evolution-workbench-cli-host.js";
@@ -882,6 +883,10 @@ export class CcAppServer {
         turnOptions.skillRetrievalRevocationReader =
           skillRetrievalRevocationReader;
       }
+      if (this.negotiated) {
+        turnOptions.interactiveQuestions =
+          this.negotiated.features.includes("deferred_questions");
+      }
       const result = await this.kernel.startTurn({
         threadId,
         turnId: attempt.id,
@@ -896,6 +901,7 @@ export class CcAppServer {
             event,
           }),
         requestApproval: (event) => this._requestApproval(turn, event),
+        requestQuestion: (event) => this._requestQuestion(turn, event),
       });
       const failed = result?.is_error === true || result?.subtype === "error";
       const output = typeof result?.result === "string" ? result.result : "";
@@ -1137,6 +1143,8 @@ export class CcAppServer {
         turnOptions.skillRetrievalRevocationReader =
           this.skillRetrievalRevocationReader;
       }
+      turnOptions.interactiveQuestions =
+        this.negotiated?.features.includes("deferred_questions") === true;
       const result = await this.kernel.startTurn({
         threadId: turn.threadId,
         turnId: turn.id,
@@ -1144,6 +1152,7 @@ export class CcAppServer {
         options: turnOptions,
         emit: (event) => this._emitKernelEvent(turn, event),
         requestApproval: (event) => this._requestApproval(turn, event),
+        requestQuestion: (event) => this._requestQuestion(turn, event),
       });
       if (turn.interruptRequested) {
         await this._completeTurn(turn, "interrupted", result);
@@ -1321,6 +1330,48 @@ export class CcAppServer {
       );
       return;
     }
+    if (event?.type === "question_request") {
+      if (!this.negotiated?.features.includes("deferred_questions")) return;
+      const blocking = event.blocking !== false && event.mode !== "deferred";
+      if (blocking) turn.status = "waiting_input";
+      turn.revision += 1;
+      await this._notify(
+        "question/requested",
+        { request: this._questionRequest(turn, event) },
+        {
+          threadId: turn.threadId,
+          turnId: turn.id,
+          itemId: `${turn.id}:question:${safeId(event.id, "question")}`,
+          traceId,
+          idempotencyKey: `question-requested:${turn.id}:${event.id}`,
+        },
+      );
+      return;
+    }
+    if (event?.type === "question_resolved") {
+      if (!this.negotiated?.features.includes("deferred_questions")) return;
+      if (event.blocking !== false && event.mode !== "deferred") {
+        turn.status = "running";
+      }
+      turn.revision += 1;
+      await this._notify(
+        "question/resolved",
+        {
+          threadId: turn.threadId,
+          turnId: turn.id,
+          questionId: safeId(event.id, `${turn.id}:question`),
+          mode: event.mode === "deferred" ? "deferred" : "blocking",
+          via: event.via || "unknown",
+        },
+        {
+          threadId: turn.threadId,
+          turnId: turn.id,
+          traceId,
+          idempotencyKey: `question-resolved:${turn.id}:${event.id}:${event.via}`,
+        },
+      );
+      return;
+    }
     if (event?.type === "plan_update") {
       await this._notify(
         "item/completed",
@@ -1394,6 +1445,48 @@ export class CcAppServer {
     return result;
   }
 
+  _questionRequest(turn, event) {
+    const id = safeId(event.id, `${turn.id}:question`);
+    return {
+      id,
+      threadId: turn.threadId,
+      turnId: turn.id,
+      binding: event.binding || null,
+      question: String(event.question || "").slice(0, 16_384),
+      options: Array.isArray(event.options)
+        ? event.options.slice(0, 128)
+        : null,
+      multiSelect: event.multiSelect === true,
+      mode: event.mode === "deferred" ? "deferred" : "blocking",
+      blocking: event.blocking !== false && event.mode !== "deferred",
+      purpose: event.purpose || "decision",
+      contextRevision: Number.isSafeInteger(event.context_revision)
+        ? event.context_revision
+        : null,
+      expiresAt: new Date(this.now() + this.requestTimeoutMs).toISOString(),
+    };
+  }
+
+  async _requestQuestion(turn, event) {
+    if (!this.negotiated?.features.includes("deferred_questions")) return null;
+    const request = this._questionRequest(turn, event);
+    const result = requireObject(
+      await this._requestClient("question/answer", { request }),
+      "question answer",
+    );
+    if (
+      result.questionId !== request.id ||
+      !request.binding ||
+      !sameInteractionBinding(request.binding, result.binding)
+    ) {
+      throw new JsonRpcError(
+        JSON_RPC_ERROR.INVALID_PARAMS,
+        "client returned an invalid or stale question answer",
+      );
+    }
+    return Object.hasOwn(result, "answer") ? result.answer : null;
+  }
+
   async _requestHumanTask({ task }) {
     const result = await this._requestClient("humanTask/decide", { task });
     const response = requireObject(result, "humanTask decision");

package/src/lib/background-agent-keeper-client.js

@@ -4,6 +4,7 @@ import { createNdjsonReader } from "./background-session-transport.js";
 import {
   BACKGROUND_AGENT_KEEPER_ARM,
   BACKGROUND_AGENT_KEEPER_ARMED,
+  BACKGROUND_AGENT_KEEPER_ARM_TIMEOUT_MS,
   BACKGROUND_AGENT_KEEPER_HELLO,
   BACKGROUND_AGENT_KEEPER_HEARTBEAT,
   BACKGROUND_AGENT_KEEPER_HEARTBEAT_INTERVAL_MS,
@@ -244,6 +245,7 @@ export async function connectBackgroundAgentKeeper(options = {}) {
         BACKGROUND_AGENT_KEEPER_ARM,
         BACKGROUND_AGENT_KEEPER_ARMED,
         normalized,
+        BACKGROUND_AGENT_KEEPER_ARM_TIMEOUT_MS,
       );
       activeTurn = normalized;
       return normalized;

package/src/lib/background-agent-keeper-protocol.js

@@ -50,6 +50,13 @@ export const BACKGROUND_AGENT_KEEPER_IDENTITY_PROBE_TIMEOUT_MS =
 export const BACKGROUND_AGENT_KEEPER_STATE_LOCK_TIMEOUT_MS = 5_000;
 export const BACKGROUND_AGENT_KEEPER_PERSIST_RETRY_TIMEOUT_MS =
   3 * BACKGROUND_AGENT_KEEPER_STATE_LOCK_TIMEOUT_MS;
+// ARM durably binds a newly spawned turn. It can contend with a strict state
+// lock and, on Windows, an incumbent identity probe. Keep this deadline
+// independent from short HELLO requests and long destructive RETIRE cleanup.
+export const BACKGROUND_AGENT_KEEPER_ARM_TIMEOUT_MS =
+  BACKGROUND_AGENT_KEEPER_IDENTITY_PROBE_TIMEOUT_MS +
+  BACKGROUND_AGENT_KEEPER_STATE_LOCK_TIMEOUT_MS +
+  10_000;
 // A 20-Agent macOS formal run can leave successfully SIGKILLed process groups
 // observable for several seconds while launchd reaps their orphaned leaders.
 // Two seconds made that bounded kernel/reaper delay look like an escaped tree.

package/src/lib/background-agent-supervisor.js

@@ -63,6 +63,8 @@ import {
 
 export const DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
 export const DEFAULT_HEARTBEAT_STALE_MS = 120000;
+export const DEFAULT_BACKGROUND_AGENT_PAGE_LIMIT = 50;
+export const MAX_BACKGROUND_AGENT_PAGE_LIMIT = 200;
 
 /**
  * Pid identity tolerance (Gap 1: OS pid reuse). A pid alone does not identify
@@ -1370,7 +1372,14 @@ export function mutateBackgroundAgentState(id, updater, options = {}) {
       // A live numeric pid can belong to a later process after the lock owner
       // was killed. Use the lock acquisition timestamp as a one-sided identity
       // fence so only an owner which existed before acquisition still blocks.
-      _isOwnerAlive: isBackgroundAgentStateLockOwnerAlive,
+      // Periodic telemetry may request a strict try-lock. In that mode an
+      // incumbent is deliberately retained without a Windows PID/start-time
+      // probe: a heartbeat must never synchronously stall a control channel
+      // merely to determine whether it could reclaim a lock.
+      _isOwnerAlive:
+        options.probeLockOwner === false
+          ? () => true
+          : isBackgroundAgentStateLockOwnerAlive,
     },
   );
 }
@@ -1458,57 +1467,65 @@ export async function deliverBackgroundNeedsInputNotification(
  * the only authority to start or continue a turn: a terminal, deleted,
  * corrupt, differently-generated or already-owned record is never revived.
  */
-export function claimBackgroundAgentHeartbeat(id, heartbeat = {}) {
+export function claimBackgroundAgentHeartbeat(
+  id,
+  heartbeat = {},
+  options = {},
+) {
   const workerPid = Number(heartbeat.workerPid ?? heartbeat.pid);
   const workerGeneration = heartbeat.workerGeneration;
   if (!Number.isInteger(workerPid) || workerPid <= 0) {
     throw new Error(`Invalid background worker pid: ${heartbeat.workerPid}`);
   }
-  return mutateBackgroundAgentState(id, (current) => {
-    if (!current || current.status !== "running") return null;
-    if (current.stopRequestedAt) return null;
-    if (
-      current.workerGeneration &&
-      current.workerGeneration !== workerGeneration
-    ) {
-      return null;
-    }
-    const claimedWorkerPid = Number(current.workerClaimedPid);
-    if (
-      current.workerClaimedPid != null &&
-      Number.isInteger(claimedWorkerPid) &&
-      claimedWorkerPid > 0 &&
-      claimedWorkerPid !== workerPid
-    ) {
-      return null;
-    }
-    const currentWorkerPid = Number(current.workerPid ?? current.pid);
-    if (
-      !current.workerGeneration &&
-      Number.isInteger(currentWorkerPid) &&
-      currentWorkerPid > 0 &&
-      currentWorkerPid !== workerPid &&
-      current.launchFinalizationUncertain !== true
-    ) {
-      return null;
-    }
-    return {
-      ...current,
-      ...heartbeat,
-      id,
-      pid: workerPid,
-      workerPid,
-      workerClaimedPid:
+  return mutateBackgroundAgentState(
+    id,
+    (current) => {
+      if (!current || current.status !== "running") return null;
+      if (current.stopRequestedAt) return null;
+      if (
+        current.workerGeneration &&
+        current.workerGeneration !== workerGeneration
+      ) {
+        return null;
+      }
+      const claimedWorkerPid = Number(current.workerClaimedPid);
+      if (
         current.workerClaimedPid != null &&
         Number.isInteger(claimedWorkerPid) &&
-        claimedWorkerPid > 0
-          ? claimedWorkerPid
-          : workerPid,
-      workerClaimedAt: current.workerClaimedAt || Date.now(),
-      status: "running",
-      heartbeatAt: heartbeat.heartbeatAt ?? Date.now(),
-    };
-  });
+        claimedWorkerPid > 0 &&
+        claimedWorkerPid !== workerPid
+      ) {
+        return null;
+      }
+      const currentWorkerPid = Number(current.workerPid ?? current.pid);
+      if (
+        !current.workerGeneration &&
+        Number.isInteger(currentWorkerPid) &&
+        currentWorkerPid > 0 &&
+        currentWorkerPid !== workerPid &&
+        current.launchFinalizationUncertain !== true
+      ) {
+        return null;
+      }
+      return {
+        ...current,
+        ...heartbeat,
+        id,
+        pid: workerPid,
+        workerPid,
+        workerClaimedPid:
+          current.workerClaimedPid != null &&
+          Number.isInteger(claimedWorkerPid) &&
+          claimedWorkerPid > 0
+            ? claimedWorkerPid
+            : workerPid,
+        workerClaimedAt: current.workerClaimedAt || Date.now(),
+        status: "running",
+        heartbeatAt: heartbeat.heartbeatAt ?? Date.now(),
+      };
+    },
+    options,
+  );
 }
 
 function deleteBackgroundAgentState(id, predicate = () => true) {
@@ -2038,7 +2055,21 @@ export function effectiveBackgroundAgentState(state, options = {}) {
   return next;
 }
 
-export function listBackgroundAgents(options = {}) {
+function backgroundAgentStartedAt(state) {
+  const startedAt = Number(state?.startedAt);
+  return Number.isFinite(startedAt) && startedAt >= 0 ? startedAt : 0;
+}
+
+function compareBackgroundAgentListEntries(a, b) {
+  const newestFirst = backgroundAgentStartedAt(b) - backgroundAgentStartedAt(a);
+  if (newestFirst !== 0) return newestFirst;
+  return String(a.id).localeCompare(String(b.id));
+}
+
+function listBackgroundAgentEntries(
+  options = {},
+  { stableTieBreak = false } = {},
+) {
   return (
     readdirSync(backgroundAgentsDir())
       .filter((name) => name.endsWith(".json") && !name.includes(".job."))
@@ -2046,7 +2077,11 @@ export function listBackgroundAgents(options = {}) {
       .filter(Boolean)
       .map((state) => effectiveBackgroundAgentState(state, options))
       .filter((state) => options.all || state.status === "running")
-      .sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0))
+      .sort(
+        stableTieBreak
+          ? compareBackgroundAgentListEntries
+          : (a, b) => (b.startedAt || 0) - (a.startedAt || 0),
+      )
       // Display-only enrichment: attach the canonical unified lifecycle state.
       // This is a list feed (never written back to disk), so the derived field
       // cannot leak into the on-disk schema the way it would in the mutate paths.
@@ -2054,6 +2089,118 @@ export function listBackgroundAgents(options = {}) {
   );
 }
 
+function normalizeBackgroundAgentPageLimit(value) {
+  if (value === undefined || value === null) {
+    return DEFAULT_BACKGROUND_AGENT_PAGE_LIMIT;
+  }
+  const limit =
+    typeof value === "string" && /^\d+$/u.test(value) ? Number(value) : value;
+  if (
+    !Number.isSafeInteger(limit) ||
+    limit < 1 ||
+    limit > MAX_BACKGROUND_AGENT_PAGE_LIMIT
+  ) {
+    throw new TypeError(
+      `background agent page limit must be an integer from 1 to ${MAX_BACKGROUND_AGENT_PAGE_LIMIT}`,
+    );
+  }
+  return limit;
+}
+
+function encodeBackgroundAgentPageCursor(state, all) {
+  const payload = JSON.stringify({
+    version: 1,
+    all: all === true,
+    startedAt: backgroundAgentStartedAt(state),
+    id: safeId(state?.id),
+  });
+  return `bg1.${Buffer.from(payload).toString("base64url")}`;
+}
+
+function decodeBackgroundAgentPageCursor(value) {
+  if (value === undefined || value === null) return null;
+  if (
+    typeof value !== "string" ||
+    value.length > 768 ||
+    !/^bg1\.[A-Za-z0-9_-]+$/u.test(value)
+  ) {
+    throw new TypeError("background agent page cursor is invalid");
+  }
+  let payload;
+  try {
+    const encoded = value.slice(4);
+    const decoded = Buffer.from(encoded, "base64url");
+    if (decoded.toString("base64url") !== encoded) {
+      throw new Error("cursor encoding is not canonical");
+    }
+    payload = JSON.parse(decoded.toString("utf8"));
+  } catch {
+    throw new TypeError("background agent page cursor is invalid");
+  }
+  if (
+    !payload ||
+    typeof payload !== "object" ||
+    Array.isArray(payload) ||
+    Object.keys(payload).length !== 4 ||
+    payload.version !== 1 ||
+    typeof payload.all !== "boolean" ||
+    !Number.isSafeInteger(payload.startedAt) ||
+    payload.startedAt < 0
+  ) {
+    throw new TypeError("background agent page cursor is invalid");
+  }
+  let id;
+  try {
+    id = safeId(payload.id);
+  } catch {
+    throw new TypeError("background agent page cursor is invalid");
+  }
+  return { all: payload.all, startedAt: payload.startedAt, id };
+}
+
+function isBackgroundAgentAfterCursor(state, cursor) {
+  const startedAt = backgroundAgentStartedAt(state);
+  if (startedAt !== cursor.startedAt) return startedAt < cursor.startedAt;
+  return String(state.id).localeCompare(cursor.id) > 0;
+}
+
+/**
+ * Return one stable, bounded page from the newest-first background session
+ * feed. The cursor is an opaque ordering fence, not an authority token.
+ *
+ * State files are still read to preserve the current authoritative lifecycle
+ * reconciliation. A future read-only index may reduce that I/O, but this API
+ * immediately bounds the object graph and protocol response retained by a
+ * caller.
+ */
+export function listBackgroundAgentsPage(options = {}) {
+  const limit = normalizeBackgroundAgentPageLimit(options.limit);
+  const cursor = decodeBackgroundAgentPageCursor(options.cursor);
+  if (cursor && cursor.all !== (options.all === true)) {
+    throw new TypeError(
+      "background agent page cursor does not match the requested filter",
+    );
+  }
+  const eligible = cursor
+    ? listBackgroundAgentEntries(options, { stableTieBreak: true }).filter(
+        (state) => isBackgroundAgentAfterCursor(state, cursor),
+      )
+    : listBackgroundAgentEntries(options, { stableTieBreak: true });
+  const sessions = eligible.slice(0, limit);
+  const nextCursor =
+    eligible.length > sessions.length
+      ? encodeBackgroundAgentPageCursor(sessions.at(-1), options.all)
+      : null;
+  return Object.freeze({
+    sessions: Object.freeze(sessions),
+    nextCursor,
+  });
+}
+
+export function listBackgroundAgents(options = {}) {
+  return listBackgroundAgentEntries(options);
+}
+
 function sleepSyncMs(ms) {
   try {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);

package/src/lib/codex-app-server-adapter.js

@@ -66,18 +66,40 @@ function projectNotification(notification) {
     };
   }
   if (method === "turn/completed" || method === "turn/failed") {
-    const failed = method === "turn/failed";
+    const turn = params.turn || {};
+    const reportedStatus =
+      method === "turn/failed" ? "failed" : String(turn.status || "");
+    const terminalStatus = ["completed", "failed", "interrupted"].includes(
+      reportedStatus,
+    )
+      ? reportedStatus
+      : "failed";
+    const protocolError =
+      terminalStatus === "failed" && reportedStatus !== "failed"
+        ? {
+            code: "CC_CODEX_APP_SERVER_INVALID_TERMINAL_STATUS",
+            message:
+              "Codex App Server emitted turn/completed without a supported terminal status",
+          }
+        : null;
+    const terminalError =
+      terminalStatus === "failed"
+        ? turn.error ||
+          params.error ||
+          protocolError ||
+          "Codex App Server turn failed"
+        : turn.error || params.error || null;
     return {
       method: "turn/completed",
       params: {
         turn: {
-          ...params.turn,
-          status: failed ? "failed" : "completed",
+          ...turn,
+          status: terminalStatus,
         },
       },
-      terminal: failed ? "failed" : "completed",
-      error: failed ? params.error || "Codex App Server turn failed" : null,
-      usage: params.usage || null,
+      terminal: terminalStatus,
+      error: terminalError,
+      usage: params.usage || turn.usage || null,
     };
   }
   return { unknownMethod: String(method || "<missing>") };
@@ -138,6 +160,10 @@ export class CodexAppServerAdapter extends EventEmitter {
     const notifications = [];
     const unknownMethods = new Set();
     let output = "";
+    let activeThreadId = threadId;
+    let submissionStarted = false;
+    let admissionObserved = false;
+    let observedTerminal = null;
     let terminalResolve;
     let terminalReject;
     const terminal = new Promise((resolve, reject) => {
@@ -162,16 +188,38 @@ export class CodexAppServerAdapter extends EventEmitter {
         notifications.push(projected);
         this.emit("notification", projected);
       }
+      if (
+        submissionStarted &&
+        (projected.method === "turn/started" ||
+          projected.method?.startsWith("item/") ||
+          Boolean(projected.terminal))
+      ) {
+        admissionObserved = true;
+      }
       if (projected.output) output = projected.output;
-      if (projected.terminal) terminalResolve(projected);
+      if (projected.terminal) {
+        observedTerminal = projected;
+        terminalResolve(projected);
+      }
     };
     this.client.on?.("notification", onNotification);
-    let admitted = false;
+    const buildResult = (terminalEvent) =>
+      Object.freeze({
+        protocol: CODEX_APP_SERVER_PROTOCOL,
+        threadId: activeThreadId,
+        terminal: terminalEvent.terminal,
+        output,
+        error: terminalEvent.error || null,
+        usage: terminalEvent.usage || null,
+        notifications: Object.freeze(notifications),
+        unknownMethods: Object.freeze([...unknownMethods].sort()),
+        fallback: false,
+        authoritative: false,
+      });
     try {
       if (!this.client.running && typeof this.client.start === "function") {
         await this.client.start();
       }
-      let activeThreadId = threadId;
       if (!activeThreadId) {
         const started = await this.client.request("thread/start", {
           ephemeral: false,
@@ -185,31 +233,37 @@ export class CodexAppServerAdapter extends EventEmitter {
           "Codex App Server did not return a thread identity",
         );
       }
+      // Once turn/start begins, a rejected client promise cannot prove that
+      // the server did not accept the input. Never launch a second execution
+      // path from that ambiguous state.
+      submissionStarted = true;
       const started = await this.client.request("turn/start", {
         threadId: activeThreadId,
         input: [{ type: "text", text: String(prompt || "") }],
       });
-      admitted = true;
-      const terminalEvent =
-        started?.turn?.status === "completed"
-          ? { terminal: "completed", usage: started.turn.usage || null }
-          : await terminal;
-      return Object.freeze({
-        protocol: CODEX_APP_SERVER_PROTOCOL,
-        threadId: activeThreadId,
-        terminal: terminalEvent.terminal,
-        output,
-        error: terminalEvent.error || null,
-        usage: terminalEvent.usage || null,
-        notifications: Object.freeze(notifications),
-        unknownMethods: Object.freeze([...unknownMethods].sort()),
-        fallback: false,
-        authoritative: false,
-      });
+      admissionObserved = true;
+      const initialStatus = String(started?.turn?.status || "");
+      const terminalEvent = ["completed", "failed", "interrupted"].includes(
+        initialStatus,
+      )
+        ? projectNotification({
+            method: "turn/completed",
+            params: { turn: started.turn, usage: started.turn.usage || null },
+          })
+        : await terminal;
+      return buildResult(terminalEvent);
     } catch (error) {
-      if (!admitted) {
+      if (!submissionStarted) {
         return this._fallback(prompt, options, error?.code || "startup_failed");
       }
+      if (observedTerminal) return buildResult(observedTerminal);
+      if (!admissionObserved) {
+        throw adapterError(
+          "CC_CODEX_APP_SERVER_SUBMISSION_UNKNOWN",
+          "Codex App Server turn submission outcome is unknown; fallback was suppressed to prevent duplicate effects",
+          { cause: error },
+        );
+      }
       throw adapterError(
         "CC_CODEX_APP_SERVER_FAILED_AFTER_ADMISSION",
         "Codex App Server failed after the turn was admitted; fallback was suppressed to prevent duplicate effects",