orkestrator 2.34.4-beta → 2.34.5-beta

package/resources/codex-bridge/dist/index.js

@@ -3752,6 +3752,66 @@ function structuredOutputFailure(provider, code, message, options = {}) {
   };
 }
 
+// ../protocol/src/agent-platforms.ts
+var AGENT_PLATFORMS = Object.freeze([
+  "claude",
+  "codex",
+  "cursor",
+  "grok",
+  "opencode",
+  "pi"
+]);
+var AGENT_PLATFORM_LABELS = Object.freeze({
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor Agent",
+  grok: "Grok Build",
+  opencode: "OpenCode",
+  pi: "Pi"
+});
+var LEGACY_ENABLED_AGENT_PLATFORMS = Object.freeze([
+  "claude",
+  "codex",
+  "opencode"
+]);
+
+// ../protocol/src/native-agent-goal.ts
+var NATIVE_AGENT_GOAL_LIMITS = Object.freeze({
+  objectiveMaxChars: 4000,
+  checkMaxBytes: 4 * 1024,
+  reportMessageMaxBytes: 2 * 1024,
+  checkOutputMaxBytes: 8 * 1024,
+  statusDetailMaxBytes: 1024,
+  maxIterationsDefault: 20,
+  maxIterationsLimit: 100,
+  noProgressLimit: 3,
+  checkTimeoutDefaultMs: 10 * 60000,
+  checkTimeoutMaxMs: 30 * 60000,
+  verifierModelMaxChars: 200,
+  verifierTimeoutDefaultMs: 30 * 60000,
+  verdictSummaryMaxBytes: 2 * 1024,
+  verdictReasonsMax: 16,
+  verdictReasonMaxBytes: 512,
+  historyLimit: 5
+});
+var AGENT_GOAL_TOOL_NAMES = Object.freeze(["report_goal"]);
+var GOAL_QUALIFIED_PLATFORMS = Object.freeze([
+  "claude",
+  "codex",
+  "opencode",
+  "cursor",
+  "grok",
+  "pi"
+]);
+var GOAL_TOKEN_BUDGET_PLATFORMS = Object.freeze([
+  "claude",
+  "codex",
+  "opencode",
+  "cursor",
+  "grok",
+  "pi"
+]);
+
 // ../protocol/src/permission-rules.ts
 var PERMISSION_RULE_KINDS = [
   "command-prefix",
@@ -4153,29 +4213,6 @@ var JOURNAL_ENVELOPE_BYTES = serializedBytes({
   entries: []
 });
 
-// ../protocol/src/agent-platforms.ts
-var AGENT_PLATFORMS = Object.freeze([
-  "claude",
-  "codex",
-  "cursor",
-  "grok",
-  "opencode",
-  "pi"
-]);
-var AGENT_PLATFORM_LABELS = Object.freeze({
-  claude: "Claude Code",
-  codex: "Codex",
-  cursor: "Cursor Agent",
-  grok: "Grok Build",
-  opencode: "OpenCode",
-  pi: "Pi"
-});
-var LEGACY_ENABLED_AGENT_PLATFORMS = Object.freeze([
-  "claude",
-  "codex",
-  "opencode"
-]);
-
 // ../protocol/src/native-agent-transcript-patch.ts
 var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 
@@ -4542,6 +4579,7 @@ var PROJECTION_FIELD_SET = new Set([
   "queue",
   "asyncQuestionResponses",
   "contextUsage",
+  "goal",
   "rateLimits",
   "runtime",
   "runtimeHealthAuthoritative",
@@ -4566,6 +4604,7 @@ var OPTIONAL_PROJECTION_FIELD_SET = new Set([
   "queue",
   "asyncQuestionResponses",
   "contextUsage",
+  "goal",
   "rateLimits",
   "runtime",
   "runtimeHealthAuthoritative",
@@ -5522,7 +5561,7 @@ function parseSessionActivityObservation(value) {
   if (!isRecord(value))
     return;
   const { activity, readyForInput, completionPending, asyncQuestionItemIds, closing } = value;
-  const { contentRevision } = value;
+  const { contentRevision, turnFailed } = value;
   if (typeof activity !== "string" || !SESSION_ACTIVITY_STATES.has(activity))
     return;
   if (readyForInput !== undefined && typeof readyForInput !== "boolean")
@@ -5531,6 +5570,8 @@ function parseSessionActivityObservation(value) {
     return;
   if (closing !== undefined && typeof closing !== "boolean")
     return;
+  if (turnFailed !== undefined && typeof turnFailed !== "boolean")
+    return;
   if (contentRevision !== undefined && !isContentRevision(contentRevision))
     return;
   let itemIds;
@@ -5546,6 +5587,7 @@ function parseSessionActivityObservation(value) {
     ...completionPending !== undefined ? { completionPending } : {},
     ...itemIds !== undefined ? { asyncQuestionItemIds: itemIds } : {},
     ...closing !== undefined ? { closing } : {},
+    ...turnFailed === true ? { turnFailed } : {},
     ...contentRevision !== undefined ? { contentRevision } : {}
   };
 }
@@ -12074,6 +12116,7 @@ function unconfirmedTurnId(requestId) {
 class TurnAccumulator {
   threadId;
   requestId;
+  providerRequestId;
   expectsStructuredOutput;
   assistantMessageId;
   startedAt;
@@ -12083,6 +12126,7 @@ class TurnAccumulator {
   phase = "starting";
   cancelRequested = false;
   stoppedByShutdown = false;
+  capacityRetry;
   error;
   finalDiff;
   completedAt;
@@ -12362,12 +12406,22 @@ class TurnAccumulator {
     if (error)
       this.error = error;
     this.completedAt = new Date().toISOString();
+    this.settleEndedAttempt();
+  }
+  settleEndedAttempt() {
     this.interruptOpenAgentMessages();
     for (const accumulator of this.items.values()) {
       if (!accumulator.completed && !accumulator.interrupted)
         this.touch(accumulator);
     }
   }
+  recordRetryCard(id, text, state) {
+    this.onItemCompleted({ id, type: "retry", text, state });
+  }
+  retryCardState(id) {
+    const item = this.items.get(id)?.item;
+    return item?.type === "retry" ? item.state : undefined;
+  }
   recordProviderFailure(error) {
     this.onItemCompleted({
       id: turnFailureItemId(this.turnId),
@@ -12820,6 +12874,8 @@ async function itemToParts(item, cwd, fileChangeContext) {
           ...item.severity ? { severity: item.severity } : {}
         }
       ];
+    case "retry":
+      return [{ type: "retry", content: item.text, toolState: item.state }];
     default: {
       const unknown = item;
       const name = typeof unknown.type === "string" ? unknown.type : "unknown";
@@ -13012,16 +13068,19 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "add_ticket_comment",
   "address_multi_review",
   "adopt_workflow",
+  "answer_worker_question",
   "cancel_build_pipeline",
   "cancel_graph_run",
   "cancel_multi_review",
   "cancel_schedule",
+  "clear_worker_goal",
   "compare_project_files",
   "create_pr",
   "create_schedule",
   "create_ticket",
   "custom_fix_multi_review",
   "edit_worker_tab",
+  "fork_worker",
   "get_build_pipeline",
   "get_environment",
   "get_feature_plan",
@@ -13034,6 +13093,9 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "get_tab_state",
   "get_tab_transcript",
   "get_ticket",
+  "get_usage_limits",
+  "get_worker_changes",
+  "get_worker_goal",
   "launch_environment",
   "launch_feature_plan",
   "launch_graph",
@@ -13048,14 +13110,18 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "list_node_environments",
   "list_nodes",
   "list_projects",
+  "list_provider_accounts",
   "list_schedules",
   "list_tabs",
   "list_tickets",
+  "list_worker_commands",
   "list_workflows",
   "open_multi_review",
   "open_multi_review_fix",
   "open_worker_browser",
   "pause_build_pipeline",
+  "pause_schedule",
+  "pause_worker_goal",
   "propose_agents_md_update",
   "read_messages",
   "read_node_environment",
@@ -13064,18 +13130,25 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "request_project_file_update",
   "request_project_on_node",
   "request_root_changes",
+  "resolve_conflicts",
   "resume_build_pipeline",
+  "resume_schedule",
+  "run_worker_command",
   "send_message",
   "send_node_message",
   "send_prompt_to_node_tab",
   "send_prompt_to_tab",
+  "set_worker_goal",
   "start_build_pipeline",
   "start_environment",
   "start_multi_review",
   "start_node_environment",
   "stop_environment",
   "stop_node_environment",
+  "stop_worker_turn",
+  "switch_provider_account",
   "transfer_files",
+  "update_schedule",
   "update_ticket"
 ]);
 var COORDINATOR_CONTEXT_OPEN_TAG = "<orkestrator-coordinator-context>";
@@ -13089,6 +13162,78 @@ function stripCoordinatorContext(text) {
   return text.slice(end + COORDINATOR_CONTEXT_CLOSE_TAG.length).replace(/^\s+/, "");
 }
 
+// ../protocol/src/capacity-retry.ts
+var DEFAULT_CAPACITY_RETRY_POLICY = {
+  maxAttempts: 5,
+  baseDelayMs: 2000,
+  multiplier: 3,
+  maxDelayMs: 60000
+};
+function capacityRetryDelayMs(policy, nextAttempt, random = Math.random) {
+  const retryIndex = Math.max(0, nextAttempt - 2);
+  const nominal = Math.min(policy.maxDelayMs, policy.baseDelayMs * policy.multiplier ** retryIndex);
+  const unit = Math.min(1, Math.max(0, random()));
+  return Math.round(nominal / 2 + nominal / 2 * unit);
+}
+function formatRetryDelay(delayMs) {
+  return `${Math.max(1, Math.round(delayMs / 1000))} s`;
+}
+
+// ../../bridges/codex-bridge/src/sessions/capacity-retry.ts
+var CODEX_SERVER_OVERLOADED_MESSAGE = "Selected model is at capacity. Please try a different model.";
+var CODEX_POLICY_CAPACITY_UNAVAILABLE_MESSAGE = "Policy-restricted capacity is unavailable. Please try again later.";
+var CAPACITY_CODES = new Set(["serverOverloaded", "policyCapacityUnavailable"]);
+var CAPACITY_MESSAGES = new Set([
+  CODEX_SERVER_OVERLOADED_MESSAGE,
+  CODEX_POLICY_CAPACITY_UNAVAILABLE_MESSAGE
+]);
+function isModelCapacityError(error) {
+  if (!error)
+    return false;
+  if (error.httpStatusCode === 401 || error.httpStatusCode === 403)
+    return false;
+  if (error.code !== undefined)
+    return CAPACITY_CODES.has(error.code);
+  return CAPACITY_MESSAGES.has(error.message.trim());
+}
+function capacityRetryWaitingText(delayMs, nextAttempt, maxAttempts) {
+  return `Model at capacity, retrying in ${formatRetryDelay(delayMs)} (attempt ${nextAttempt} of ${maxAttempts})`;
+}
+function capacityRetryStartedText(nextAttempt, maxAttempts) {
+  return `Model at capacity, retried automatically (attempt ${nextAttempt} of ${maxAttempts})`;
+}
+var CAPACITY_RETRY_CANCELLED_TEXT = "Model at capacity, automatic retry cancelled";
+var CAPACITY_RETRY_START_FAILED_TEXT = "Model at capacity, automatic retry could not be started";
+function capacityRetriesExhaustedError(error, attempts) {
+  return {
+    ...error,
+    message: `${error.message} Automatic retries exhausted after ${attempts} attempts.`
+  };
+}
+function capacityRetryItemId(requestId, nextAttempt) {
+  return `capacity-retry:${requestId}:${nextAttempt}`;
+}
+function capacityRetryClientId(requestId, nextAttempt) {
+  return `${requestId}:capacity-retry:${nextAttempt}`;
+}
+var CAPACITY_RETRY_CONTINUATION_MARKER = "[Orkestrator automatic retry]";
+function capacityRetryContinuationText(nextAttempt, maxAttempts) {
+  return [
+    `${CAPACITY_RETRY_CONTINUATION_MARKER} attempt ${nextAttempt} of ${maxAttempts}.`,
+    "The previous attempt of this turn ended because the model was at capacity. This message was sent automatically, not by the user.",
+    "Continue the original request from where it stopped. Do not repeat work or tool calls that already completed; check the conversation so far and finish the request."
+  ].join(`
+`);
+}
+function parseCapacityRetryContinuation(text) {
+  if (!text.startsWith(CAPACITY_RETRY_CONTINUATION_MARKER))
+    return;
+  const match = /^ attempt (\d+) of (\d+)\./.exec(text.slice(CAPACITY_RETRY_CONTINUATION_MARKER.length));
+  if (!match)
+    return;
+  return { attempt: Number(match[1]), maxAttempts: Number(match[2]) };
+}
+
 // ../../bridges/codex-bridge/src/history/rollout.ts
 function getCodexHomeDir() {
   return process.env.CODEX_HOME || join11(homedir(), ".codex");
@@ -14126,6 +14271,20 @@ async function replayPersistedRollout(threadId, snapshot, meta, structuredTurns)
       assistantMessage.parts.push({ type: "text", content: displayText });
       return;
     }
+    const continuation = parseCapacityRetryContinuation(text);
+    if (continuation) {
+      const previous = messages.at(-1);
+      const row = previous?.role === "assistant" ? previous : ensureAssistantMessage(timestamp);
+      const last = row.parts.at(-1);
+      if (last?.type === "status" && last.severity === "error")
+        row.parts.pop();
+      row.parts.push({
+        type: "retry",
+        content: capacityRetryStartedText(continuation.attempt, continuation.maxAttempts),
+        toolState: "success"
+      });
+      return;
+    }
     closeAssistantRow();
     messages.push({
       id: nextRowId("user"),
@@ -18650,7 +18809,7 @@ function isPersistedRecord(value) {
   if (!value || typeof value !== "object")
     return false;
   const record = value;
-  if (typeof record.requestId !== "string" || record.requestId.length === 0 || typeof record.bridgeSessionId !== "string" || record.threadId !== null && typeof record.threadId !== "string" || !isOptionalString(record.turnId) || !DISPATCH_STATES.has(record.state) || !isTimestamp(record.createdAt) || !isTimestamp(record.updatedAt) || record.quarantined !== undefined && record.quarantined !== true) {
+  if (typeof record.requestId !== "string" || record.requestId.length === 0 || typeof record.bridgeSessionId !== "string" || record.threadId !== null && typeof record.threadId !== "string" || !isOptionalString(record.turnId) || !isOptionalString(record.providerRequestId) || !DISPATCH_STATES.has(record.state) || !isTimestamp(record.createdAt) || !isTimestamp(record.updatedAt) || record.quarantined !== undefined && record.quarantined !== true) {
     return false;
   }
   if (record.state === "accepted") {
@@ -18858,6 +19017,21 @@ class DispatchJournal {
     await this.flush({ failClosed: true });
     return record;
   }
+  async markContinuation(requestId, providerRequestId) {
+    if (this.integrityError)
+      throw new DispatchJournalIntegrityError(this.integrityError);
+    const existing = this.records.get(requestId);
+    if (!existing || existing.quarantined) {
+      throw new DispatchJournalIntegrityError(`Dispatch ${requestId} is unavailable`);
+    }
+    this.records.set(requestId, {
+      ...existing,
+      providerRequestId,
+      updatedAt: new Date(this.now()).toISOString(),
+      sequence: ++this.nextSequence
+    });
+    await this.flush({ failClosed: true });
+  }
   async markAccepted(requestId, options) {
     if (this.integrityError)
       throw new DispatchJournalIntegrityError(this.integrityError);
@@ -18868,6 +19042,7 @@ class DispatchJournal {
     const timestamp = new Date(this.now()).toISOString();
     this.records.set(requestId, {
       requestId,
+      providerRequestId: existing?.providerRequestId,
       bridgeSessionId: existing?.bridgeSessionId ?? "",
       threadId: options.threadId,
       turnId: options.turnId,
@@ -18887,6 +19062,7 @@ class DispatchJournal {
     const timestamp = new Date(this.now()).toISOString();
     this.records.set(requestId, {
       requestId,
+      providerRequestId: existing?.providerRequestId,
       bridgeSessionId: existing?.bridgeSessionId ?? "",
       threadId: options.threadId ?? existing?.threadId ?? null,
       turnId: options.turnId ?? existing?.turnId,
@@ -18908,6 +19084,7 @@ class DispatchJournal {
     const timestamp = new Date(this.now()).toISOString();
     this.records.set(requestId, {
       requestId,
+      providerRequestId: existing?.providerRequestId,
       bridgeSessionId: existing?.bridgeSessionId ?? "",
       threadId: existing?.threadId ?? null,
       state: "retryable",
@@ -19543,7 +19720,8 @@ function codexAppServerConfigOverrides(env = process.env) {
   const overrides = {
     "agents.max_concurrent_threads_per_session": String(childLimit),
     "features.multi_agent_v2.max_concurrent_threads_per_session": String(childLimit + 1),
-    "features.incremental_tools": "false"
+    "features.incremental_tools": "false",
+    "features.goals": "false"
   };
   const rawUrl = env[ORKESTRATOR_AGENT_MCP_URL_ENV]?.trim();
   const token = env[ORKESTRATOR_AGENT_MCP_TOKEN_ENV]?.trim();
@@ -19613,7 +19791,11 @@ function codexAppServerConfigOverrides(env = process.env) {
         if (isCoordinatorReadOnlyEnvironment(env)) {
           overrides["mcp_servers.orkestrator.default_tools_approval_mode"] = JSON.stringify("approve");
         } else {
-          for (const name of [...AGENT_MAIL_TOOL_NAMES, ...ARTIFACT_TOOL_NAMES]) {
+          for (const name of [
+            ...AGENT_MAIL_TOOL_NAMES,
+            ...ARTIFACT_TOOL_NAMES,
+            ...AGENT_GOAL_TOOL_NAMES
+          ]) {
             overrides[`mcp_servers.orkestrator.tools.${name}.approval_mode`] = JSON.stringify("approve");
           }
         }
@@ -19781,7 +19963,7 @@ var APP_SERVER_CAPABILITIES = {
 };
 
 // ../../bridges/codex-bridge/src/engine/app-server-engine.ts
-var AGENT_MAIL_TOOL_APPROVALS = Object.fromEntries([...AGENT_MAIL_TOOL_NAMES, ...ARTIFACT_TOOL_NAMES].map((name) => [
+var AGENT_MAIL_TOOL_APPROVALS = Object.fromEntries([...AGENT_MAIL_TOOL_NAMES, ...ARTIFACT_TOOL_NAMES, ...AGENT_GOAL_TOOL_NAMES].map((name) => [
   name,
   { approval_mode: "approve" }
 ]));
@@ -21226,7 +21408,11 @@ class AppServerEngine {
       return {
         id: String(turn.id ?? ""),
         status: turn.status ?? "completed",
-        items: [],
+        items: items.flatMap((item) => {
+          const adapted = adaptAppServerItem(item).item;
+          return adapted ? [adapted] : [];
+        }),
+        ...turn.error ? { error: toTurnError(turn.error) } : {},
         clientId: clientIds[0] ?? null,
         clientIds,
         reconciliationItems,
@@ -21377,7 +21563,13 @@ class AppServerEngine {
         clientId
       }))
     }));
-    return reconcileFromThreadTurns(turns, requestId);
+    const outcome = reconcileFromThreadTurns(turns, requestId);
+    const matched = thread?.turns?.find((turn) => turn.id === outcome.turnId);
+    return {
+      ...outcome,
+      ...matched?.items.length ? { items: matched.items } : {},
+      ...matched?.error ? { error: matched.error } : {}
+    };
   }
   classifyFailure(error) {
     return {
@@ -22725,8 +22917,10 @@ class CodexRuntimeSessions {
     const session = this.ctx.registry.getSession(sessionId);
     if (!session)
       return { activity: "missing" };
+    const turnFailed = activity === "idle" && (this.ctx.registry.getThreadForSession(sessionId)?.phase ?? (session.restartFailure ? "failed" : "idle")) === "failed";
     return {
       activity,
+      ...turnFailed ? { turnFailed: true } : {},
       ...session.asyncQuestionItemIds.length > 0 ? { asyncQuestionItemIds: [...session.asyncQuestionItemIds] } : {},
       contentRevision: `${ACTIVITY_PROCESS}:${session.contentEpoch}.${session.messageRevision}:${session.asyncQuestionItemIds.length}`
     };
@@ -22771,9 +22965,11 @@ class CodexRuntimeSessions {
     const context = this.ctx.registry.getThreadForSession(sessionId);
     const turn = context?.activeTurn;
     if (context && turn && context.bridgeSessionIds.size === 1) {
-      await this.ctx.options.engine.interruptTurn(context.engineHandle, turn.turnId).catch(() => {
-        return;
-      });
+      if (!await this.lifecycle.capacityRetry.cancelForClose(context, turn)) {
+        await this.ctx.options.engine.interruptTurn(context.engineHandle, turn.turnId).catch(() => {
+          return;
+        });
+      }
     }
     this.retiredSessions.add(session);
     try {
@@ -24371,6 +24567,256 @@ class UpdateCoalescer {
   }
 }
 
+// ../../bridges/codex-bridge/src/app-server-runtime-capacity-retry.ts
+import { stat as stat8 } from "node:fs/promises";
+class CodexCapacityRetry {
+  ctx;
+  lifecycle;
+  pending = new Map;
+  constructor(ctx, lifecycle) {
+    this.ctx = ctx;
+    this.lifecycle = lifecycle;
+  }
+  policy() {
+    return { ...DEFAULT_CAPACITY_RETRY_POLICY, ...this.ctx.options.capacityRetry };
+  }
+  isPending(turn) {
+    return this.pending.has(turn);
+  }
+  onTurnFailed(context, turn, error) {
+    const plan = turn.capacityRetry;
+    if (!plan || !turn.requestId || !isModelCapacityError(error))
+      return { retrying: false };
+    const policy = this.policy();
+    if (plan.attempt >= policy.maxAttempts) {
+      return {
+        retrying: false,
+        ...plan.attempt > 1 ? { error: capacityRetriesExhaustedError(error, plan.attempt) } : {}
+      };
+    }
+    if (this.ctx.stopping || turn.cancelRequested || turn.stoppedByShutdown || context.phase !== "running" || context.bridgeSessionIds.size === 0) {
+      return { retrying: false };
+    }
+    const attempt = plan.attempt + 1;
+    const delayMs = capacityRetryDelayMs(policy, attempt, this.ctx.options.capacityRetryRandom);
+    const itemId = capacityRetryItemId(turn.requestId, attempt);
+    turn.settleEndedAttempt();
+    turn.error = undefined;
+    turn.recordRetryCard(itemId, capacityRetryWaitingText(delayMs, attempt, policy.maxAttempts), "pending");
+    const entry = { attempt, itemId, error, stage: "waiting" };
+    entry.timer = setTimeout(() => this.fire(context, turn), delayMs);
+    entry.timer.unref?.();
+    this.pending.set(turn, entry);
+    this.publish(context);
+    return { retrying: true };
+  }
+  stop(context, turn) {
+    const entry = this.pending.get(turn);
+    if (!entry)
+      return false;
+    turn.markCancelling();
+    this.ctx.registry.setPhase(context, "cancelling");
+    this.lifecycle.emitStatus(context);
+    if (entry.stage === "starting") {
+      entry.stopAfterStart = true;
+      return true;
+    }
+    this.end(context, turn, "interrupted");
+    return true;
+  }
+  async cancelForClose(context, turn) {
+    const entry = this.pending.get(turn);
+    if (!entry || !this.stop(context, turn))
+      return false;
+    await entry.work;
+    if (!turn.isTerminal()) {
+      await this.ctx.options.engine.waitForTurnTerminal(context.engineHandle, turn.turnId, {
+        allowRestart: true
+      });
+      if (!turn.isTerminal()) {
+        turn.complete("interrupted");
+        await this.lifecycle.runFinalization(context, turn);
+      }
+    }
+    return true;
+  }
+  endForParentExit(context, turn) {
+    const entry = this.pending.get(turn);
+    if (!entry || entry.stage !== "waiting")
+      return false;
+    turn.stoppedByShutdown = true;
+    this.clear(turn, entry, CAPACITY_RETRY_CANCELLED_TEXT);
+    this.lifecycle.completeRecoveredTurn(turn, "interrupted");
+    this.lifecycle.runFinalization(context, turn);
+    return true;
+  }
+  dispose() {
+    for (const [turn, entry] of Array.from(this.pending)) {
+      if (entry.stage !== "waiting")
+        continue;
+      const context = this.ctx.registry.getThread(turn.threadId);
+      if (!context || context.activeTurn !== turn) {
+        this.clear(turn, entry, CAPACITY_RETRY_CANCELLED_TEXT);
+        continue;
+      }
+      this.end(context, turn, "failed", entry.error, CAPACITY_RETRY_CANCELLED_TEXT);
+    }
+  }
+  discard(turn) {
+    const entry = this.pending.get(turn);
+    if (entry)
+      this.clear(turn, entry, CAPACITY_RETRY_CANCELLED_TEXT);
+  }
+  fire(context, turn) {
+    const entry = this.pending.get(turn);
+    if (!entry || entry.stage !== "waiting")
+      return;
+    entry.timer = undefined;
+    if (!this.owns(context, turn)) {
+      if (context.activeTurn === turn && !turn.isTerminal()) {
+        this.end(context, turn, "failed", entry.error, CAPACITY_RETRY_CANCELLED_TEXT);
+      } else
+        this.clear(turn, entry, CAPACITY_RETRY_CANCELLED_TEXT);
+      return;
+    }
+    entry.stage = "starting";
+    const work = this.startContinuation(context, turn, entry).catch((error) => {
+      console.error(`[codex-bridge] Capacity retry of turn ${turn.turnId} failed:`, error instanceof Error ? error.message : error);
+      if (this.pending.get(turn) === entry && context.activeTurn === turn && !turn.isTerminal()) {
+        this.end(context, turn, "failed", entry.error, CAPACITY_RETRY_START_FAILED_TEXT);
+      }
+    });
+    entry.work = work;
+    this.ctx.pendingFinalizations.add(work);
+    work.finally(() => this.ctx.pendingFinalizations.delete(work));
+  }
+  owns(context, turn) {
+    return !this.ctx.stopping && this.ctx.registry.getThread(context.threadId) === context && context.activeTurn === turn && !turn.isTerminal() && !turn.cancelRequested && context.phase === "running" && context.bridgeSessionIds.size > 0 && turn.engineGeneration === this.ctx.options.engine.info().generation;
+  }
+  async startContinuation(context, turn, entry) {
+    const plan = turn.capacityRetry;
+    const requestId = turn.requestId;
+    const policy = this.policy();
+    const clientId = capacityRetryClientId(requestId, entry.attempt);
+    const engine = this.ctx.options.engine;
+    const previousTurnId = turn.turnId;
+    turn.providerRequestId = clientId;
+    turn.turnId = unconfirmedTurnId(clientId);
+    await this.ctx.journal.markContinuation(requestId, clientId);
+    plan.attempt = entry.attempt;
+    const path = engine.rolloutPath(context.threadId);
+    const offset = path ? await stat8(path).then((stats) => stats.size, () => {
+      return;
+    }) : undefined;
+    this.lifecycle.stateFor(context.threadId).refusedCellOffset = offset;
+    let started;
+    let reconciled;
+    try {
+      started = await engine.startTurn({
+        handle: context.engineHandle,
+        input: [
+          { type: "text", text: capacityRetryContinuationText(entry.attempt, policy.maxAttempts) }
+        ],
+        config: plan.config,
+        requestId: clientId,
+        outputSchema: plan.outputSchema
+      });
+    } catch (error) {
+      const failure = engine.classifyFailure(error);
+      if (!this.ctx.stopping && failure.class !== "rejected" && !failure.retryImmediately) {
+        const outcome = await engine.reconcileRequest(context.threadId, clientId).catch(() => {
+          return;
+        });
+        if (outcome && outcome.result !== "absent" && outcome.turnId) {
+          started = { turnId: outcome.turnId, engineGeneration: engine.info().generation };
+          reconciled = outcome;
+        } else if (!outcome) {
+          this.clear(turn, entry, CAPACITY_RETRY_START_FAILED_TEXT);
+          this.ctx.registry.setPhase(context, "recovering");
+          this.lifecycle.emitStatus(context);
+          this.ctx.callbacks.scheduleRecoveryBackstop(context);
+          return;
+        }
+      }
+      if (!started) {
+        turn.turnId = previousTurnId;
+        this.end(context, turn, entry.stopAfterStart ? "interrupted" : "failed", entry.error, CAPACITY_RETRY_START_FAILED_TEXT);
+        return;
+      }
+    }
+    if (this.pending.get(turn) !== entry || context.activeTurn !== turn || turn.isTerminal()) {
+      await engine.interruptTurn(context.engineHandle, started.turnId).catch(() => {
+        return;
+      });
+      return;
+    }
+    await this.ctx.journal.markAccepted(requestId, { threadId: context.threadId, turnId: started.turnId }).catch((error) => console.warn(`[codex-bridge] Could not journal capacity retry of ${requestId}:`, error instanceof Error ? error.message : error));
+    if (plan.outputSchema) {
+      const ledger = this.ctx.registry.recordStructuredOutputTurn(context.threadId, started.turnId, false);
+      await Promise.all(ledger.map((session) => this.ctx.callbacks.persistSession(session)));
+    }
+    turn.turnId = started.turnId;
+    turn.engineGeneration = started.engineGeneration;
+    context.engineGeneration = started.engineGeneration;
+    if (entry.stopAfterStart)
+      this.clear(turn, entry, CAPACITY_RETRY_CANCELLED_TEXT);
+    else {
+      this.clear(turn, entry, capacityRetryStartedText(entry.attempt, policy.maxAttempts), "success");
+    }
+    if (reconciled?.items) {
+      for (const item of reconciled.items)
+        turn.onItemCompleted(item);
+    }
+    this.publish(context);
+    this.lifecycle.drainPendingEvents(context, started.turnId);
+    if (reconciled?.result === "terminal" && context.activeTurn === turn && !turn.isTerminal() && !this.isPending(turn)) {
+      this.lifecycle.applyEvent(context, {
+        kind: "turn.completed",
+        threadId: context.threadId,
+        turnId: started.turnId,
+        engineGeneration: started.engineGeneration,
+        status: reconciled.status ?? "completed",
+        error: reconciled.error
+      });
+    }
+    if (entry.stopAfterStart && !turn.isTerminal()) {
+      const sessionId = context.bridgeSessionIds.values().next().value;
+      if (sessionId)
+        await this.ctx.callbacks.abort(sessionId);
+      else
+        await engine.interruptTurn(context.engineHandle, started.turnId).catch(() => {
+          return;
+        });
+    }
+  }
+  end(context, turn, status, error, cardText = CAPACITY_RETRY_CANCELLED_TEXT) {
+    const entry = this.pending.get(turn);
+    if (entry)
+      this.clear(turn, entry, cardText);
+    if (status === "failed" && error) {
+      turn.complete("failed", error);
+      turn.recordProviderFailure(error);
+    } else
+      turn.complete(status);
+    const work = this.lifecycle.runFinalization(context, turn);
+    if (entry)
+      entry.work = work;
+  }
+  clear(turn, entry, cardText, state = "failure") {
+    if (entry.timer)
+      clearTimeout(entry.timer);
+    entry.timer = undefined;
+    this.pending.delete(turn);
+    if (turn.retryCardState(entry.itemId) === "pending") {
+      turn.recordRetryCard(entry.itemId, cardText, state);
+    }
+  }
+  publish(context) {
+    this.lifecycle.stateFor(context.threadId).coalescer.flushNow();
+    this.lifecycle.emitStatus(context);
+  }
+}
+
 // ../../bridges/codex-bridge/src/app-server-runtime-lifecycle.ts
 function artifactConnectionToken(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -24381,8 +24827,10 @@ function artifactConnectionToken(value) {
 
 class CodexRuntimeLifecycle {
   ctx;
+  capacityRetry;
   constructor(ctx) {
     this.ctx = ctx;
+    this.capacityRetry = new CodexCapacityRetry(ctx, this);
   }
   async start() {
     if (this.ctx.started)
@@ -24464,6 +24912,7 @@ class CodexRuntimeLifecycle {
       clearTimeout(timer);
     this.ctx.recoveryBackstops.clear();
     this.ctx.commandCatalogue.dispose();
+    this.capacityRetry.dispose();
     this.ctx.callbacks.notifyThreadActivity();
     await this.ctx.options.engine.stop();
     await this.drainPendingWork();
@@ -25144,12 +25593,23 @@ class CodexRuntimeLifecycle {
           this.setThreadAuthNotice(context, refusedLoginNotice(context.authNotice, this.ctx.options.engine.getAccountLoginKind(), () => crypto.randomUUID()));
         }
         this.discardOutlivingCommandWindows(turn);
+        let failure = event.error;
+        if (event.status === "failed") {
+          const decision = this.capacityRetry.onTurnFailed(context, turn, event.error);
+          if (decision.retrying) {
+            this.ctx.options.changeEvidence?.turn(this.evidenceSource(context, turn), "failed");
+            this.takeRefusedCellTail(threadId, turn)?.close();
+            return;
+          }
+          if (decision.error)
+            failure = decision.error;
+        }
         if (turn.stoppedByShutdown && event.status === "interrupted")
           this.completeRecoveredTurn(turn, event.status);
         else {
-          turn.complete(event.status, event.error);
-          if (event.status === "failed" && event.error)
-            turn.recordProviderFailure(event.error);
+          turn.complete(event.status, failure);
+          if (event.status === "failed" && failure)
+            turn.recordProviderFailure(failure);
         }
         this.ctx.options.changeEvidence?.turn(this.evidenceSource(context, turn), event.status);
         const finalize = () => this.runFinalization(context, turn).catch((error) => {
@@ -25627,8 +26087,14 @@ class CodexRuntimeLifecycle {
           this.emitStatus(context);
           continue;
         }
-        const outcome = await this.ctx.options.engine.reconcileRequest(context.threadId, turn.requestId);
+        const outcome = await this.ctx.options.engine.reconcileRequest(context.threadId, turn.providerRequestId ?? turn.requestId);
         if (outcome.result === "terminal") {
+          if (outcome.turnId)
+            turn.turnId = outcome.turnId;
+          for (const item of outcome.items ?? [])
+            turn.onItemCompleted(item);
+          if (outcome.error)
+            turn.onError(outcome.error);
           this.completeRecoveredTurn(turn, outcome.status ?? "completed");
           await this.runFinalization(context, turn);
           continue;
@@ -25678,6 +26144,7 @@ class CodexRuntimeLifecycle {
     turn.complete(status);
   }
   async finalizeTurn(context, turn) {
+    this.capacityRetry.discard(turn);
     const state = this.stateFor(context.threadId);
     const structuredResult = turn.expectsStructuredOutput ? parseCodexStructuredOutput(turn) : undefined;
     const structuredSessions = structuredResult ? [...context.bridgeSessionIds].map((sessionId) => this.ctx.registry.getSession(sessionId)).filter((session) => session?.structuredOutputRequestId === turn.requestId) : [];
@@ -25940,7 +26407,7 @@ function requiredCoordinatorPermissionProfile() {
 }
 
 // ../../bridges/codex-bridge/src/app-server-runtime-prompt.ts
-import { stat as stat8 } from "node:fs/promises";
+import { stat as stat9 } from "node:fs/promises";
 function commandRefusal(message) {
   return { ok: false, status: 422, error: message, kind: "command-unavailable" };
 }
@@ -26043,7 +26510,7 @@ class CodexRuntimePrompt {
         };
       }
       if (decision.action === "reconcile" && decision.record?.threadId) {
-        const outcome = await this.ctx.options.engine.reconcileRequest(decision.record.threadId, requestId);
+        const outcome = await this.ctx.options.engine.reconcileRequest(decision.record.threadId, decision.record.providerRequestId ?? requestId);
         if (outcome.result === "terminal") {
           await this.ctx.journal.markTerminal(requestId, outcome.status ?? "completed", {
             threadId: decision.record.threadId,
@@ -26307,7 +26774,7 @@ class CodexRuntimePrompt {
       let refusedCellOffset;
       const startTurn = async () => {
         const path = this.ctx.options.engine.rolloutPath(context.threadId);
-        refusedCellOffset = path ? await stat8(path).then((stats) => stats.size, (error) => error.code === "ENOENT" ? 0 : undefined) : undefined;
+        refusedCellOffset = path ? await stat9(path).then((stats) => stats.size, (error) => error.code === "ENOENT" ? 0 : undefined) : undefined;
         return this.ctx.options.engine.startTurn({
           handle: context.engineHandle,
           input: engineInput,
@@ -26464,6 +26931,11 @@ class CodexRuntimePrompt {
         startedAt: context.turnStartedAt
       });
       accumulator.markRunning();
+      accumulator.capacityRetry = {
+        config: turnConfig,
+        ...input.outputSchema ? { outputSchema: input.outputSchema } : {},
+        attempt: 1
+      };
       context.activeTurn = accumulator;
       context.engineGeneration = turn.engineGeneration;
       context.dispatchInFlight = false;
@@ -26590,10 +27062,11 @@ class CodexRuntimePrompt {
         ...recoveredModelId ? { modelId: recoveredModelId } : {}
       });
     }
+    accumulator.providerRequestId = this.ctx.journal.get(requestId)?.providerRequestId ?? requestId;
     this.scheduleRecoveryBackstop(context);
     let outcome;
     try {
-      outcome = await this.ctx.options.engine.reconcileRequest(context.threadId, requestId);
+      outcome = await this.ctx.options.engine.reconcileRequest(context.threadId, accumulator.providerRequestId);
     } catch (error) {
       console.warn(`[codex-bridge] Could not reconcile ${requestId} on thread ${context.threadId}:`, error instanceof Error ? error.message : error);
       return "recovering";
@@ -26915,6 +27388,8 @@ class CodexRuntimeTail {
       const turn = context.activeTurn;
       if (!turn || turn.isTerminal() || turn.isUnconfirmed())
         continue;
+      if (this.lifecycle.capacityRetry.endForParentExit(context, turn))
+        continue;
       turn.stoppedByShutdown = true;
       const { engineHandle } = context;
       stopping.push(this.ctx.options.engine.interruptTurn(engineHandle, turn.turnId).then(() => this.ctx.options.engine.waitForTurnTerminal(engineHandle, turn.turnId, {
@@ -26950,6 +27425,9 @@ class CodexRuntimeTail {
         phase: context?.phase ?? "idle"
       };
     }
+    if (this.lifecycle.capacityRetry.stop(context, turn)) {
+      return { status: "cancelling", phase: "cancelling" };
+    }
     this.ctx.threadState.get(context.threadId)?.refusedCellTail?.tail.close();
     turn.markCancelling();
     this.ctx.registry.setPhase(context, "cancelling");
@@ -27051,9 +27529,10 @@ class CodexRuntimeTail {
     const windows = accountUsageFromLimits(limits);
     return windows.length > 0 ? windows : undefined;
   }
-  async listSessions() {
+  async listSessions(options = {}) {
     const cwd = getWorkingDirectory(this.ctx.options.cwd);
     const merged = new Map;
+    const archivedRows = new Map;
     try {
       const { threads } = await this.ctx.options.engine.listThreads({ cwd });
       for (const thread of threads) {
@@ -27078,9 +27557,16 @@ class CodexRuntimeTail {
           onlyArchived: true,
           ...cursor ? { cursor } : {}
         });
-        for (const thread of page.threads)
-          if (thread.id)
-            archived.add(thread.id);
+        for (const thread of page.threads) {
+          if (!thread.id)
+            continue;
+          archived.add(thread.id);
+          archivedRows.set(thread.id, {
+            id: thread.id,
+            title: thread.name ?? thread.preview ?? undefined,
+            updatedAt: thread.updatedAt ?? new Date(this.ctx.now()).toISOString()
+          });
+        }
         cursor = page.nextCursor ?? undefined;
       } while (cursor);
     } catch {}
@@ -27105,6 +27591,9 @@ class CodexRuntimeTail {
     for (const meta of persisted) {
       if (isArchived(meta)) {
         merged.delete(meta.id);
+        if (!archivedRows.has(meta.id)) {
+          archivedRows.set(meta.id, { id: meta.id, title: meta.title, updatedAt: meta.updatedAt });
+        }
         continue;
       }
       const existing = merged.get(meta.id);
@@ -27117,14 +27606,18 @@ class CodexRuntimeTail {
     }
     try {
       const generated = generatedTitles ?? await readPersistedSessionTitleEntries(this.ctx.options.codexHome);
-      for (const session of merged.values()) {
+      for (const session of [...merged.values(), ...archivedRows.values()]) {
         const entry = generated.get(session.id);
         if (entry)
           session.title = entry.title;
       }
     } catch {}
+    const byActivity = (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
     return {
-      sessions: [...merged.values()].sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()),
+      sessions: [
+        ...boundedResumeRows([...merged.values()].sort(byActivity)),
+        ...options.includeArchived ? boundedResumeRows([...archivedRows.values()].filter((row) => !merged.has(row.id)).sort(byActivity).map((row) => ({ ...row, archived: true }))) : []
+      ],
       cwd
     };
   }
@@ -27160,6 +27653,21 @@ class CodexRuntimeTail {
     };
   }
 }
+function boundedResumeRows(rows) {
+  const result = [];
+  let remaining = 900 * 1024;
+  for (const row of rows) {
+    if (result.length >= 512)
+      break;
+    const bounded = { ...row, title: row.title?.slice(0, 512) };
+    const bytes = Buffer.byteLength(JSON.stringify(bounded), "utf8") + 1;
+    if (bytes > remaining)
+      continue;
+    remaining -= bytes;
+    result.push(bounded);
+  }
+  return result;
+}
 
 // ../../bridges/codex-bridge/src/app-server-runtime.ts
 class AppServerRuntime {
@@ -28536,7 +29044,9 @@ app.post("/session/:id/commands/refresh", async (c) => {
   return c.json(await appServerRuntime.refreshCommandCatalogue(c.req.param("id")));
 });
 app.get("/session/list", async (c) => {
-  return c.json(await appServerRuntime.listSessions());
+  return c.json(await appServerRuntime.listSessions({
+    includeArchived: c.req.query("includeArchived") === "1"
+  }));
 });
 for (const action of ["archive", "unarchive"]) {
   app.post(`/session/list/:threadId/${action}`, async (c) => {