orkestrator 2.34.4-beta → 2.35.0-beta

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

@@ -331,7 +331,7 @@ function createBridgeDiagnostics(bridge, state, metrics) {
 import { execFile as execFileCallback2 } from "node:child_process";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { appendFile as appendFile5, mkdir as mkdir9, readFile as readFile7, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // ../../node_modules/.bun/@hono+node-server@2.1.5+c539cad7f494f5c9/node_modules/@hono/node-server/dist/constants-BLSFu_RU.mjs
@@ -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,26 @@ 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",
+  "set_account_auto_switch",
   "transfer_files",
+  "update_schedule",
   "update_ticket"
 ]);
 var COORDINATOR_CONTEXT_OPEN_TAG = "<orkestrator-coordinator-context>";
@@ -13089,6 +13163,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 +14272,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"),
@@ -14994,6 +15154,87 @@ function agentMailCapabilities(tabType, agent, locked = true) {
 }
 var NATIVE_AGENT_MAIL_CAPABILITIES = Object.freeze(Object.fromEntries(AGENT_PLATFORMS.map((agent) => [agent, agentMailCapabilities("agent-native", agent)])));
 
+// ../protocol/src/agent-system-instructions.ts
+var AGENT_IMAGE_PREVIEW_INSTRUCTION = "Orkestrator renders Markdown images inline in the transcript. When you show the user an image in your reply (a screenshot, rendered preview, or chart) using Markdown image syntax, reference it by its absolute path. In a managed worktree or container environment, save the file inside the working directory, preferably in a git-ignored folder so preview files stay out of the change set. Local image previews are limited to Orkestrator-managed workspace storage or the container's /workspace. Project-home checkouts are excluded from host preview reads, even when they are the working directory, so images saved there cannot be previewed from a local Markdown path. Paths outside previewable storage, such as /tmp, also show a placeholder.";
+var AGENT_DOCUMENT_INSTRUCTION = "When the user asks for a document (a report, design doc, plan, analysis, guide, or other writing to keep), prefer writing it as a Markdown file in a `docs/` folder at the root of the working directory, and tell the user the file's path. Project instructions (such as AGENTS.md or CLAUDE.md), local skills, and the user's own request take priority over this default when they say where or how to write documents.";
+var GENERAL_AGENT_INSTRUCTIONS = [
+  AGENT_IMAGE_PREVIEW_INSTRUCTION,
+  AGENT_DOCUMENT_INSTRUCTION
+];
+function agentSystemInstructions(providerSpecific = []) {
+  return [...GENERAL_AGENT_INSTRUCTIONS, ...providerSpecific].filter((line) => line.trim().length > 0).join(`
+
+`);
+}
+var REPOSITORY_INSTRUCTIONS_FILE = "AGENTS.md";
+function repositoryInstructionsBlock(path, content, truncated) {
+  return [
+    `# Repository instructions (${REPOSITORY_INSTRUCTIONS_FILE})`,
+    `This session does not load the repository's ${REPOSITORY_INSTRUCTIONS_FILE} on its own, so Orkestrator includes it here. Follow it as project instructions. Contents of ${path}:`,
+    content.trimEnd(),
+    ...truncated ? [
+      `[${REPOSITORY_INSTRUCTIONS_FILE} is longer than this session can hold, so it is cut here. Read the rest from ${path} before relying on anything it may say.]`
+    ] : []
+  ].join(`
+
+`);
+}
+
+// ../protocol/src/node/repository-instructions.ts
+import { open as open4, realpath } from "node:fs/promises";
+import { join as join12, relative as relative2, isAbsolute as isAbsolute7 } from "node:path";
+var MAX_REPOSITORY_INSTRUCTIONS_BYTES = 256 * 1024;
+async function readRepositoryInstructions(cwd, maxBytes = MAX_REPOSITORY_INSTRUCTIONS_BYTES) {
+  const path = join12(cwd, REPOSITORY_INSTRUCTIONS_FILE);
+  try {
+    const [root, target] = await Promise.all([realpath(cwd), realpath(path)]);
+    const inside = relative2(root, target);
+    if (!inside || inside.startsWith("..") || isAbsolute7(inside))
+      return;
+    const handle = await open4(target, "r");
+    try {
+      const buffer = Buffer.alloc(maxBytes + 1);
+      const { bytesRead } = await handle.read(buffer, 0, maxBytes + 1, 0);
+      const truncated = bytesRead > maxBytes;
+      const text = new TextDecoder().decode(buffer.subarray(0, Math.min(bytesRead, maxBytes))).replace(/�$/, "");
+      return text.trim() ? repositoryInstructionsBlock(path, text, truncated) : undefined;
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return;
+  }
+}
+
+// ../protocol/src/build-pipeline-key-information.ts
+var KEY_INFORMATION_LIMITS = Object.freeze({
+  proseLength: 4000,
+  itemLength: 600,
+  listItems: 30,
+  decisions: 12,
+  decisionLength: 400,
+  options: 6,
+  optionLength: 300,
+  prosCons: 6,
+  rationaleLength: 1000,
+  tests: 40,
+  testNameLength: 400,
+  issues: 60,
+  issueLength: 400,
+  severityLength: 40,
+  resolutionLength: 1000,
+  verifications: 20,
+  summaryLength: 2000,
+  checks: 30,
+  checkLength: 400,
+  updates: 30,
+  maxRound: 1000
+});
+var KEY_INFORMATION_TOOL_NAMES = Object.freeze([
+  "get_key_information",
+  "update_key_information"
+]);
+
 // ../protocol/src/transcript-artifacts.ts
 var ARTIFACT_TOOL_NAMES = Object.freeze([
   "create_artifact",
@@ -15008,9 +15249,9 @@ var ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME = "orkestrator-artifacts";
 var ORKESTRATOR_ARTIFACT_MCP_PATH = "/artifact-mcp";
 
 // ../../bridges/codex-bridge/src/engine/app-server-engine.ts
-import { open as open7 } from "node:fs/promises";
+import { open as open8 } from "node:fs/promises";
 import { createHash as createHash11 } from "node:crypto";
-import { isAbsolute as isAbsolute8, join as join18 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join19 } from "node:path";
 
 // ../../bridges/codex-bridge/src/app-server/process-supervisor.ts
 import { execFile as execFile3, spawn as spawn2 } from "node:child_process";
@@ -15018,14 +15259,14 @@ import { randomUUID as randomUUID6 } from "node:crypto";
 import {
   link,
   mkdir as mkdir6,
-  open as open4,
+  open as open5,
   readFile as readFile5,
   readlink,
   rename as rename4,
   rm as rm5,
   stat as stat5
 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // ../../bridges/codex-bridge/src/app-server/errors.ts
 var APP_SERVER_OVERLOAD_CODE = -32001;
@@ -15625,7 +15866,7 @@ class SerialQueue {
 
 // ../../bridges/codex-bridge/src/app-server/notification-recorder.ts
 import { appendFile as appendFile4, mkdir as mkdir5 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 var DEFAULT_MAX_RECORDING_BYTES = 64 * 1024 * 1024;
 var DEFAULT_FLUSH_INTERVAL_MS = 250;
 var DEFAULT_WARN_INTERVAL_MS = 60000;
@@ -15651,7 +15892,7 @@ class NotificationRecorder {
   stats;
   constructor(options) {
     this.options = options;
-    this.path = join12(options.directory, options.fileName);
+    this.path = join13(options.directory, options.fileName);
     this.maxBytes = options.maxBytes ?? DEFAULT_MAX_RECORDING_BYTES;
     this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
     this.warnIntervalMs = options.warnIntervalMs ?? DEFAULT_WARN_INTERVAL_MS;
@@ -16378,10 +16619,10 @@ class AppServerSupervisor {
     } catch {}
   }
   pidFileDir() {
-    return join13(this.options.codexHome, "orkestrator-bridge");
+    return join14(this.options.codexHome, "orkestrator-bridge");
   }
   pidFilePath() {
-    return join13(this.pidFileDir(), `app-server-${hashPath(this.options.cwd)}.pid`);
+    return join14(this.pidFileDir(), `app-server-${hashPath(this.options.cwd)}.pid`);
   }
   async readOwnedPidRecord(path) {
     let raw;
@@ -16420,7 +16661,7 @@ class AppServerSupervisor {
       instanceId
     }), "utf8");
     const temporary = `${path}.${this.pidOwnerToken}.update`;
-    const handle = await open4(temporary, "wx", 384);
+    const handle = await open5(temporary, "wx", 384);
     try {
       await handle.write(payload, 0, payload.length, 0);
       await handle.sync();
@@ -16444,7 +16685,7 @@ class AppServerSupervisor {
     await mkdir6(this.pidFileDir(), { recursive: true });
     for (let attempt = 0;attempt < PID_ACQUISITION_MAX_ATTEMPTS; attempt += 1) {
       try {
-        const handle = await open4(this.pidFilePath(), "wx", 384);
+        const handle = await open5(this.pidFilePath(), "wx", 384);
         try {
           const record = {
             ownerToken: this.pidOwnerToken,
@@ -16874,10 +17115,11 @@ function describeApproval(options) {
   } : undefined;
   const networkContext = isRecord9(params.networkApprovalContext) ? str2(params.networkApprovalContext.host) : undefined;
   const command = commandText(params.command) ?? commandActionsText(params.commandActions);
-  const exactCommand = options.method === "item/commandExecution/requestApproval" && (params.kind === undefined || params.kind === null || params.kind === "command") && typeof params.command === "string" && params.command.length > 0;
-  const ruleEligible = networkContext !== undefined ? kind === "command" && exactCommand : kind === "command" ? exactCommand : kind === "file-change" ? str2(params.grantRoot) === undefined : false;
+  const v2Command = options.method === "item/commandExecution/requestApproval" && (params.kind === undefined || params.kind === null || params.kind === "command");
+  const exactCommand = v2Command && typeof params.command === "string" && params.command.length > 0;
+  const ruleEligible = networkContext !== undefined ? v2Command && (exactCommand || command === undefined) : kind === "command" ? exactCommand : kind === "file-change" ? str2(params.grantRoot) === undefined : false;
   const proposal = exactCommand ? proposedPrefix(params.proposedExecpolicyAmendment) : undefined;
-  const actionable = kind === "command" ? command !== undefined : kind === "file-change" ? Boolean(changes?.length) : permissions !== undefined && (permissions.network || permissions.fileSystem);
+  const actionable = kind === "command" ? command !== undefined || networkContext !== undefined : kind === "file-change" ? Boolean(changes?.length) : permissions !== undefined && (permissions.network || permissions.fileSystem);
   return {
     approvalId: options.approvalId,
     kind,
@@ -16942,7 +17184,7 @@ function describeApprovalOutcome(request, decision, resolution) {
     return null;
   if (isGrantingApprovalDecision(decision))
     return null;
-  const subject = request.kind === "command" ? request.command ? `permission to run \`${request.command}\`` : "permission to run a command" : request.kind === "file-change" ? request.changes?.length ? `permission to change ${request.changes.length} file(s)` : "permission to apply a file change" : "additional permissions";
+  const subject = request.kind === "command" ? request.command ? `permission to run \`${request.command}\`` : request.networkHost ? `permission to reach \`${request.networkHost}\`` : "permission to run a command" : request.kind === "file-change" ? request.changes?.length ? `permission to change ${request.changes.length} file(s)` : "permission to apply a file change" : "additional permissions";
   switch (resolution) {
     case "timed-out":
       return `Codex asked for ${subject}. The request expired without an answer, so it was declined.`;
@@ -17881,6 +18123,9 @@ function reduceNotification(notification, generation, handle) {
       if (!isRecord10(params) || !isRecord10(params.rateLimits))
         return { events: [] };
       const snapshot = params.rateLimits;
+      const limitId = str3(snapshot.limitId);
+      if (limitId && limitId !== "codex")
+        return { events: [] };
       const windows = [];
       const limitName = typeof snapshot.limitName === "string" && snapshot.limitName.length > 0 ? snapshot.limitName : undefined;
       if (!isRecord10(snapshot.primary) && limitName !== undefined) {
@@ -18262,8 +18507,8 @@ function redactSecrets(value) {
 
 // ../../bridges/codex-bridge/src/sessions/dispatch-journal.ts
 import { createHash as createHash10 } from "node:crypto";
-import { mkdir as mkdir8, open as open5, rename as rename6, rm as rm7, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { mkdir as mkdir8, open as open6, rename as rename6, rm as rm7, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join16 } from "node:path";
 
 // ../../bridges/codex-bridge/src/sessions/persistence.ts
 import { createHash as createHash9, randomUUID as randomUUID7 } from "node:crypto";
@@ -18278,7 +18523,7 @@ import {
   stat as stat6,
   writeFile as writeFile4
 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 var BRIDGE_SESSION_REGISTRY_VERSION = 2;
 var SESSION_TITLE_SOURCES = new Set([
   "codex",
@@ -18383,20 +18628,20 @@ class BridgeSessionStore {
     return codexBridgeStateDir(this.codexHome);
   }
   path() {
-    return join14(this.dir(), `bridge-sessions-${this.cwdHash}.json`);
+    return join15(this.dir(), `bridge-sessions-${this.cwdHash}.json`);
   }
   recordsDir() {
-    return join14(this.dir(), `bridge-sessions-${this.cwdHash}`);
+    return join15(this.dir(), `bridge-sessions-${this.cwdHash}`);
   }
   loginRecordsDir() {
-    const directory = join14(codexLoginBridgeDir(this.codexHome), `bridge-sessions-${this.cwdHash}`);
+    const directory = join15(codexLoginBridgeDir(this.codexHome), `bridge-sessions-${this.cwdHash}`);
     return directory === this.recordsDir() ? undefined : directory;
   }
   recordKey(bridgeSessionId) {
     return createHash9("sha256").update(bridgeSessionId).digest("hex");
   }
   recordPath(bridgeSessionId) {
-    return join14(this.recordsDir(), `${this.recordKey(bridgeSessionId)}.json`);
+    return join15(this.recordsDir(), `${this.recordKey(bridgeSessionId)}.json`);
   }
   async ensurePrivateStorage() {
     await mkdir7(this.dir(), { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
@@ -18424,7 +18669,7 @@ class BridgeSessionStore {
       return legacy;
     }
     const records = await Promise.all(names.map(async (name) => {
-      const path = join14(this.recordsDir(), name);
+      const path = join15(this.recordsDir(), name);
       if (name.endsWith(".tmp")) {
         await chmod(path, PRIVATE_FILE_MODE).catch(() => {
           return;
@@ -18536,8 +18781,8 @@ class BridgeSessionStore {
       return;
     await this.ensurePrivateStorage();
     await Promise.all(names.map(async (name) => {
-      const from = join14(source, name);
-      const target = join14(this.recordsDir(), name);
+      const from = join15(source, name);
+      const target = join15(this.recordsDir(), name);
       const temporary = `${target}.${process.pid}.${randomUUID7()}.tmp`;
       await writeFile4(temporary, await readFile6(from), { mode: PRIVATE_FILE_MODE });
       await chmod(temporary, PRIVATE_FILE_MODE);
@@ -18650,7 +18895,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") {
@@ -18696,7 +18941,7 @@ class DispatchJournal {
     this.persist = options.persist !== false;
   }
   path() {
-    return join15(codexBridgeStateDir(this.codexHome), `dispatch-journal-${this.cwdHash}.json`);
+    return join16(codexBridgeStateDir(this.codexHome), `dispatch-journal-${this.cwdHash}.json`);
   }
   async load() {
     if (this.loaded)
@@ -18706,7 +18951,7 @@ class DispatchJournal {
       this.loadSettled = true;
       return;
     }
-    const legacy = join15(codexLoginBridgeDir(this.codexHome), `dispatch-journal-${this.cwdHash}.json`);
+    const legacy = join16(codexLoginBridgeDir(this.codexHome), `dispatch-journal-${this.cwdHash}.json`);
     try {
       const hadCurrent = await this.loadPath(this.path());
       const mergedLegacy = legacy !== this.path() && await this.loadPath(legacy, true);
@@ -18782,7 +19027,7 @@ class DispatchJournal {
     return true;
   }
   async readBounded(path) {
-    const handle = await open5(path, "r");
+    const handle = await open6(path, "r");
     try {
       const metadata = await handle.stat();
       if (!metadata.isFile() || metadata.size > this.maxBytes) {
@@ -18858,6 +19103,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 +19128,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 +19148,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 +19170,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",
@@ -19240,7 +19503,7 @@ function coordinatorCapabilityPolicy(mode) {
 // ../../bridges/codex-bridge/src/codex-config.ts
 import { existsSync as existsSync3, readdirSync as readdirSync3, realpathSync, statSync as statSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute7, join as join16, relative as relative2, sep } from "node:path";
+import { isAbsolute as isAbsolute8, join as join17, relative as relative3, sep } from "node:path";
 
 // ../../bridges/codex-bridge/src/engine/mcp-tool-availability.ts
 var ORKESTRATOR_MCP_STARTUP_TIMEOUT_SEC = 15;
@@ -19326,7 +19589,7 @@ function codexNetworkDeniedConfig(policy) {
   };
 }
 function codexProjectTrustConfig(policy, cwd) {
-  if (!policy || policy.projectResources || !cwd || !isAbsolute7(cwd))
+  if (!policy || policy.projectResources || !cwd || !isAbsolute8(cwd))
     return {};
   const roots = new Set([cwd]);
   try {
@@ -19351,20 +19614,20 @@ function codexCoordinatorSkillExtraRoots(env = process.env, cwd = env.CWD?.trim(
     return [];
   const userDir = env[COORDINATOR_CODEX_USER_SKILLS_DIR_ENV]?.trim();
   return [
-    ...userDir && isAbsolute7(userDir) ? [userDir] : [],
-    ...cwd && isAbsolute7(cwd) ? [join16(cwd, ".claude", "skills")] : []
+    ...userDir && isAbsolute8(userDir) ? [userDir] : [],
+    ...cwd && isAbsolute8(cwd) ? [join17(cwd, ".claude", "skills")] : []
   ].filter((dir) => existsSync3(dir));
 }
 var MAX_SKILL_READ_GRANTS = 256;
 function isWithin(parent, child) {
-  const path = relative2(parent, child);
-  return path === "" || !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute7(path);
+  const path = relative3(parent, child);
+  return path === "" || !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute8(path);
 }
 function codexCoordinatorSkillReadRoots(env = process.env, home = env.HOME?.trim() || homedir2()) {
   const userDir = env[COORDINATOR_CODEX_USER_SKILLS_DIR_ENV]?.trim();
   const roots = [
-    ...userDir && isAbsolute7(userDir) ? [userDir] : [],
-    join16(home, ".agents", "skills")
+    ...userDir && isAbsolute8(userDir) ? [userDir] : [],
+    join17(home, ".agents", "skills")
   ];
   const homeReal = (() => {
     try {
@@ -19398,8 +19661,8 @@ function codexCoordinatorSkillReadRoots(env = process.env, home = env.HOME?.trim
         break;
       let target;
       try {
-        target = realpathSync(join16(real, entry));
-        if (!statSync2(target).isDirectory() || !existsSync3(join16(target, "SKILL.md")))
+        target = realpathSync(join17(real, entry));
+        if (!statSync2(target).isDirectory() || !existsSync3(join17(target, "SKILL.md")))
           continue;
       } catch {
         continue;
@@ -19424,7 +19687,7 @@ function codexProjectSkillsConfig(listed) {
       const { path, scope, enabled } = skill ?? {};
       if (enabled === true && typeof scope === "string" && KEPT_SKILL_SCOPES.has(scope))
         continue;
-      if (typeof path !== "string" || !isAbsolute7(path)) {
+      if (typeof path !== "string" || !isAbsolute8(path)) {
         throw new Error("Codex listed a project skill without a path it can be disabled by");
       }
       disabled.add(path);
@@ -19543,7 +19806,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();
@@ -19552,11 +19816,11 @@ function codexAppServerConfigOverrides(env = process.env) {
     const readableRuntimeRoot = env.CODEX_BRIDGE_READABLE_RUNTIME_ROOT?.trim();
     const projectRoot = env.CWD?.trim();
     const attachmentRoot = env[BRIDGE_ATTACHMENT_ROOT_ENV]?.trim();
-    if (!permissionProfile || !/^[A-Za-z0-9_-]+$/.test(permissionProfile) || !readableRuntimeRoot || !isAbsolute7(readableRuntimeRoot) || !projectRoot || !isAbsolute7(projectRoot)) {
+    if (!permissionProfile || !/^[A-Za-z0-9_-]+$/.test(permissionProfile) || !readableRuntimeRoot || !isAbsolute8(readableRuntimeRoot) || !projectRoot || !isAbsolute8(projectRoot)) {
       throw new Error("Coordinator Codex permission profile configuration is invalid");
     }
     overrides.default_permissions = JSON.stringify(permissionProfile);
-    overrides[`permissions.${permissionProfile}.filesystem`] = `{ ":root" = "deny", ":minimal" = "read", ":tmpdir" = "deny", ` + `":slash_tmp" = "deny", ${JSON.stringify(readableRuntimeRoot)} = "read", ` + (attachmentRoot && isAbsolute7(attachmentRoot) ? `${JSON.stringify(attachmentRoot)} = "read", ` : "") + codexCoordinatorSkillReadRoots(env).map((root) => `${JSON.stringify(root)} = "read", `).join("") + `":workspace_roots" = { "." = "read" } }`;
+    overrides[`permissions.${permissionProfile}.filesystem`] = `{ ":root" = "deny", ":minimal" = "read", ":tmpdir" = "deny", ` + `":slash_tmp" = "deny", ${JSON.stringify(readableRuntimeRoot)} = "read", ` + (attachmentRoot && isAbsolute8(attachmentRoot) ? `${JSON.stringify(attachmentRoot)} = "read", ` : "") + codexCoordinatorSkillReadRoots(env).map((root) => `${JSON.stringify(root)} = "read", `).join("") + `":workspace_roots" = { "." = "read" } }`;
     overrides[`permissions.${permissionProfile}.network.enabled`] = "false";
     overrides.web_search = JSON.stringify(codexNetworkDeniedSearchMode(codexCoordinatorPolicy(env)));
     overrides["features.standalone_web_search"] = "false";
@@ -19613,7 +19877,12 @@ 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,
+            ...KEY_INFORMATION_TOOL_NAMES
+          ]) {
             overrides[`mcp_servers.orkestrator.tools.${name}.approval_mode`] = JSON.stringify("approve");
           }
         }
@@ -19626,7 +19895,7 @@ function codexAppServerConfigOverrides(env = process.env) {
 // ../../bridges/codex-bridge/src/github-credential-config.ts
 import { mkdtemp as mkdtemp2 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 var CODEX_INHERITED_GIT_CONFIG_PATTERNS = Object.freeze([
   "GIT_CONFIG_COUNT",
   "GIT_CONFIG_KEY_*",
@@ -19661,7 +19930,7 @@ function codexGitHubCredentialThreadConfig(policy, options) {
 }
 var withheldGhConfigDir;
 function emptyGhConfigDir() {
-  withheldGhConfigDir ??= mkdtemp2(join17(tmpdir2(), "orkestrator-gh-withheld-")).catch((error) => {
+  withheldGhConfigDir ??= mkdtemp2(join18(tmpdir2(), "orkestrator-gh-withheld-")).catch((error) => {
     withheldGhConfigDir = undefined;
     throw error;
   });
@@ -19669,11 +19938,11 @@ function emptyGhConfigDir() {
 }
 
 // ../../bridges/codex-bridge/src/sessions/tool-history-guard.ts
-import { open as open6 } from "node:fs/promises";
+import { open as open7 } from "node:fs/promises";
 var TOOL_HISTORY_MARKER = '"type":"additional_tools"';
 var MAX_TOOL_HISTORY_LINEAGE_DEPTH = 32;
 async function rolloutDeclaresToolHistory(path, end) {
-  const handle = await open6(path, "r");
+  const handle = await open7(path, "r");
   try {
     const size = (await handle.stat()).size;
     const limit = end === undefined ? size : Math.min(end, size);
@@ -19698,7 +19967,7 @@ async function rolloutDeclaresToolHistory(path, end) {
   }
 }
 async function historyBase(path) {
-  const handle = await open6(path, "r");
+  const handle = await open7(path, "r");
   try {
     const chunks = [];
     let filled = 0;
@@ -19781,10 +20050,12 @@ 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) => [
-  name,
-  { approval_mode: "approve" }
-]));
+var AGENT_MAIL_TOOL_APPROVALS = Object.fromEntries([
+  ...AGENT_MAIL_TOOL_NAMES,
+  ...ARTIFACT_TOOL_NAMES,
+  ...AGENT_GOAL_TOOL_NAMES,
+  ...KEY_INFORMATION_TOOL_NAMES
+].map((name) => [name, { approval_mode: "approve" }]));
 var ROOT_THREAD_SOURCE_KINDS = ["cli", "vscode", "exec", "appServer", "unknown"];
 var CODEX_SIGN_IN_EXPIRED_NOTICE = "Codex sign-in expired. Sign in again to continue.";
 var CODEX_SIGN_IN_REQUIRED_MESSAGE = "You've been signed out of Codex. Sign in again to keep working.";
@@ -20135,7 +20406,7 @@ function signedOutAccountRead(error) {
 }
 async function readStoredLoginFingerprint(codexHome) {
   try {
-    const file = await open7(join18(codexHome, "auth.json"), "r");
+    const file = await open8(join19(codexHome, "auth.json"), "r");
     let raw;
     try {
       const bytes = Buffer.alloc(65537);
@@ -20709,7 +20980,26 @@ class AppServerEngine {
     ]);
     return { ...skills, ...mcp, ...credential };
   }
-  toThreadParams(config, extraConfig = {}) {
+  async developerInstructions(generation, config) {
+    const loadsProject = !config.policy || config.policy.projectResources;
+    const cwd = config.cwd ?? this.options.cwd;
+    const ours = [
+      ...config.policy?.id === "coordinator-read-only" ? [] : [agentSystemInstructions()],
+      ...loadsProject || config.sandbox === "read-only" || config.policy?.id === "coordinator-read-only" ? [] : [await readRepositoryInstructions(cwd)]
+    ].filter((part) => Boolean(part));
+    if (ours.length === 0)
+      return;
+    const read = this.options.readConfiguredDeveloperInstructions ?? ((projectCwd) => this.supervisor.requestOnGeneration(generation, "config/read", projectCwd ? { cwd: projectCwd } : {}).then((result) => result?.config?.developer_instructions));
+    const configured = await read(loadsProject ? cwd : undefined).catch(() => {
+      return;
+    });
+    if (typeof configured === "string" && configured.trim())
+      ours.push(configured);
+    return ours.join(`
+
+`);
+  }
+  toThreadParams(config, extraConfig = {}, developerInstructions) {
     const approveAgentMcpTools = config.policy?.approvals === "auto-approve" && (config.approvalPolicy ?? "never") === "never" && config.sandbox !== "read-only" || config.policy?.id === "coordinator-read-only" && Boolean(config.permissionProfile) || Boolean(config.workflowResultTool && config.agentMcp);
     const cwd = config.cwd ?? this.options.cwd;
     const threadConfig = {
@@ -20753,6 +21043,7 @@ class AppServerEngine {
       },
       ...config.model ? { model: config.model } : {},
       serviceTier: config.serviceTier ?? null,
+      ...developerInstructions ? { developerInstructions } : {},
       ...Object.keys(threadConfig).length > 0 ? { config: threadConfig } : {}
     };
   }
@@ -20815,7 +21106,8 @@ class AppServerEngine {
     const generation = await this.assertHostedNetworkLock(options.config);
     await this.assertToolHistoryLock(generation, options.config);
     const extra = await this.policyThreadConfig(generation, options.config);
-    const response = await this.supervisor.requestOnGeneration(generation, "thread/start", this.toThreadParams(options.config, extra));
+    const instructions = await this.developerInstructions(generation, options.config);
+    const response = await this.supervisor.requestOnGeneration(generation, "thread/start", this.toThreadParams(options.config, extra, instructions));
     this.assertPermissionProfile(response.activePermissionProfile, options.config);
     return this.bindThread(response.thread, options.config, response.model);
   }
@@ -20823,7 +21115,11 @@ class AppServerEngine {
     const generation = await this.assertHostedNetworkLock(options.config);
     await this.assertToolHistoryLock(generation, options.config);
     const extra = await this.policyThreadConfig(generation, options.config);
-    const response = await this.supervisor.requestOnGeneration(generation, "thread/resume", { threadId, ...this.toThreadParams(options.config, extra) });
+    const instructions = await this.developerInstructions(generation, options.config);
+    const response = await this.supervisor.requestOnGeneration(generation, "thread/resume", {
+      threadId,
+      ...this.toThreadParams(options.config, extra, instructions)
+    });
     this.assertPermissionProfile(response.activePermissionProfile, options.config);
     const thread = this.bindThread(response.thread, options.config, response.model);
     await this.assertNoToolHistory(thread.id ?? threadId, options.config, true);
@@ -20845,10 +21141,11 @@ class AppServerEngine {
     await this.assertToolHistoryLock(generation, config);
     await this.assertNoToolHistory(threadId, config, false);
     const extra = await this.policyThreadConfig(generation, config);
+    const instructions = await this.developerInstructions(generation, config);
     const response = await this.supervisor.requestOnGeneration(generation, "thread/fork", {
       threadId,
       ...lastTurnId ? { lastTurnId } : {},
-      ...this.toThreadParams(config, extra)
+      ...this.toThreadParams(config, extra, instructions)
     });
     this.assertPermissionProfile(response.activePermissionProfile, config);
     return this.bindThread(response.thread, config, response.model);
@@ -21178,7 +21475,7 @@ class AppServerEngine {
       thread.model = confirmedModel.trim();
     }
     if (thread.id) {
-      if (typeof raw.path === "string" && isAbsolute8(raw.path)) {
+      if (typeof raw.path === "string" && isAbsolute9(raw.path)) {
         this.rolloutPaths.set(thread.id, raw.path);
       }
       this.bindings.set(thread.id, {
@@ -21226,7 +21523,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 +21678,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 +23032,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 +23080,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 {
@@ -23092,8 +23403,8 @@ function parseCommandToken(text, sigils = ["/"]) {
 
 // ../../bridges/codex-bridge/src/prompts/template-discovery.ts
 import { createHash as createHash13 } from "node:crypto";
-import { open as open8, readdir as readdir3, stat as stat7 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { open as open9, readdir as readdir3, stat as stat7 } from "node:fs/promises";
+import { join as join20 } from "node:path";
 var TEMPLATE_LIMITS = Object.freeze({
   maxTemplates: 512,
   maxVisitedEntries: 2048,
@@ -23113,8 +23424,8 @@ var RESERVED_TEMPLATE_PREFIXES = ["/skill:", "/prompts:"];
 var TEMPLATE_ID_PREFIX = "codex-template:";
 function templateRoots(cwd, codexHome = getCodexHomeDir()) {
   return [
-    { origin: "project", dir: join19(cwd, ".codex", "prompts") },
-    { origin: "user", dir: join19(codexHome, "prompts") }
+    { origin: "project", dir: join20(cwd, ".codex", "prompts") },
+    { origin: "user", dir: join20(codexHome, "prompts") }
   ];
 }
 function templateCommandId(origin, relativePath) {
@@ -23139,7 +23450,7 @@ function isReservedName(name) {
 var metadataCache = new Map;
 var METADATA_CACHE_MAX = 1024;
 async function readBounded2(absolutePath, maxBytes) {
-  const handle = await open8(absolutePath, "r");
+  const handle = await open9(absolutePath, "r");
   try {
     const info = await handle.stat();
     if (!info.isFile())
@@ -23219,7 +23530,7 @@ async function scanPromptTemplates(roots, limits = TEMPLATE_LIMITS) {
         return;
       }
       visited += 1;
-      const absolutePath = join19(dir, entry.name);
+      const absolutePath = join20(dir, entry.name);
       const relativePath = relative ? `${relative}/${entry.name}` : entry.name;
       if (entry.isDirectory()) {
         if (depth + 1 > limits.maxDepth) {
@@ -23386,7 +23697,7 @@ async function loadTemplateBody(entry, limits = TEMPLATE_LIMITS) {
 }
 
 // ../../bridges/codex-bridge/src/commands/skill-inventory.ts
-import { isAbsolute as isAbsolute9 } from "node:path";
+import { isAbsolute as isAbsolute10 } from "node:path";
 var SKILL_INVENTORY_LIMITS = Object.freeze({
   maxSkills: 512,
   maxDescriptionBytes: 1000,
@@ -23438,7 +23749,7 @@ function normalizeSkillsList(raw, context) {
       }
       const name = nonEmpty(candidate.name);
       const path = typeof candidate.path === "string" ? candidate.path : undefined;
-      if (!name || !usableSkillName(name) || !path || !isAbsolute9(path)) {
+      if (!name || !usableSkillName(name) || !path || !isAbsolute10(path)) {
         truncated = true;
         continue;
       }
@@ -24371,6 +24682,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 +24942,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 +25027,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 +25708,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 +26202,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 +26259,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 +26522,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 +26625,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 +26889,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 +27046,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 +27177,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";
@@ -26899,7 +27487,7 @@ class CodexRuntimePrompt {
 }
 
 // ../../bridges/codex-bridge/src/app-server-runtime-tail.ts
-import { join as join20, relative as relative3, isAbsolute as isAbsolute10 } from "node:path";
+import { join as join21, relative as relative4, isAbsolute as isAbsolute11 } from "node:path";
 class CodexRuntimeTail {
   ctx;
   lifecycle;
@@ -26915,6 +27503,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 +27540,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 +27644,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,20 +27672,27 @@ 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 {}
-    const archivedRoot = join20(this.ctx.options.codexHome, "archived_sessions");
+    const archivedRoot = join21(this.ctx.options.codexHome, "archived_sessions");
     const isArchived = (meta) => {
       if (archived.has(meta.id))
         return true;
       if (!meta.transcriptPath)
         return false;
-      const fromRoot = relative3(archivedRoot, meta.transcriptPath);
-      return fromRoot !== "" && !fromRoot.startsWith("..") && !isAbsolute10(fromRoot);
+      const fromRoot = relative4(archivedRoot, meta.transcriptPath);
+      return fromRoot !== "" && !fromRoot.startsWith("..") && !isAbsolute11(fromRoot);
     };
     let persisted = [];
     let generatedTitles = null;
@@ -27105,6 +27706,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 +27721,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 +27768,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 {
@@ -27967,7 +28590,7 @@ async function writeCodexRawLog(sessionId, entry, logDir = codexRawLogDir) {
   try {
     await mkdir9(logDir, { recursive: true });
     const filename = `${sanitizeLogFileComponent(sessionId)}.jsonl`;
-    await appendFile5(join21(logDir, filename), `${JSON.stringify({
+    await appendFile5(join22(logDir, filename), `${JSON.stringify({
       timestamp: new Date().toISOString(),
       sessionId,
       ...entry
@@ -28159,10 +28782,10 @@ function emit(event) {
   }
 }
 function bridgeCacheDir() {
-  return join21(getCodexHomeDir(), "orkestrator-bridge");
+  return join22(getCodexHomeDir(), "orkestrator-bridge");
 }
 function bridgeCachePath() {
-  return join21(bridgeCacheDir(), "models-cache.json");
+  return join22(bridgeCacheDir(), "models-cache.json");
 }
 var BRIDGE_MODEL_CACHE_VERSION = 2;
 async function readPersistedBridgeCache() {
@@ -28186,7 +28809,7 @@ async function writePersistedBridgeCache(models) {
 }
 async function readCodexCliModelCache() {
   try {
-    const raw = await readFile7(join21(getCodexHomeDir(), "models_cache.json"), "utf8");
+    const raw = await readFile7(join22(getCodexHomeDir(), "models_cache.json"), "utf8");
     const models = parseModelCatalog(raw);
     return models.length > 0 ? models : null;
   } catch {
@@ -28536,7 +29159,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) => {