@rallycry/conveyor-agent 11.0.18 → 11.0.20

package/dist/{chunk-ZFHN7GO7.js → chunk-POK3QCGN.js}

@@ -2,7 +2,7 @@ import {
   mapChatHistory,
   readAgentVersion,
   refreshSkillsAfterCheckout
-} from "./chunk-SR66HQKB.js";
+} from "./chunk-37J5MMQT.js";
 import {
   MAX_BETWEEN_TURN_BUFFER,
   MAX_DIAGNOSTIC_OUTPUT,
@@ -59,11 +59,11 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-WS7QRB37.js";
+} from "./chunk-JBGPARLG.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
-} from "./chunk-GL2DIQEQ.js";
+} from "./chunk-Q4FQOJ7D.js";
 import {
   describeTokenFile,
   ghHostsExternallyOwned,
@@ -1416,6 +1416,7 @@ var ListProjectSessionGroupsRequestSchema = z5.object({
   projectId: z5.string()
 });
 var ListMyLiveSessionsAcrossProjectsRequestSchema = z5.object({});
+var ListSessionGroupsAcrossProjectsRequestSchema = z5.object({});
 var GetProjectAvailableTuisRequestSchema = z5.object({
   projectId: z5.string()
 });
@@ -2042,6 +2043,11 @@ var ANTHROPIC_CATALOG = [
   anthropicEntry(DEFAULT_HAIKU_MODEL, "Haiku 4.5", 1, 5, { supportsEffort: false }),
   anthropicEntry(FABLE_MODEL, "Fable 5.1", 10, 50)
 ];
+var CODEX_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+var DEFAULT_CODEX_CODING_MODEL = "gpt-5.6-terra";
+function isCodexReasoningEffort(value) {
+  return typeof value === "string" && CODEX_REASONING_EFFORTS.includes(value);
+}
 var HUMAN_PROSE_WRITING_STYLE = `## Writing style for humans
 When you write prose a person will read \u2014 chat messages, plan updates, PR titles and bodies, PR review guides (the \`publish_review_guide\` overview and section explanations), review comments \u2014 follow these rules (based on ASD-STE100 Simplified Technical English):
 - Use active voice. Say who does what ("The API rejects the request", not "the request is rejected").
@@ -3251,6 +3257,13 @@ var JsonlTailer = class {
 };
 
 // src/harness/codex/event-source.ts
+var USAGE_CAP_PATTERN = /usage_limit_(?:reached|exceeded)|rate_limit_reached|UsageLimitReached|hit your usage limit/i;
+var WEEKLY_WINDOW_MINUTES = 24 * 60;
+function isUsageCap(error) {
+  return [error.codex_error_info, error.code, error.type, error.message].some(
+    (value) => typeof value === "string" && USAGE_CAP_PATTERN.test(value)
+  );
+}
 var CodexEventSource = class {
   constructor(emit, onSession, chat) {
     this.emit = emit;
@@ -3263,6 +3276,8 @@ var CodexEventSource = class {
   sessionId = null;
   completed = /* @__PURE__ */ new Set();
   transcript = null;
+  /** Last reported reading per rate-limit window, keyed by `five_hour` / `seven_day`. */
+  windows = /* @__PURE__ */ new Map();
   handleRecord(raw) {
     if (!raw || typeof raw !== "object") return;
     const e = raw;
@@ -3317,11 +3332,16 @@ var CodexEventSource = class {
     if (record.type !== "event_msg" || !record.payload || typeof record.payload !== "object")
       return;
     const event = record.payload;
+    if (event.type === "token_count") {
+      this.handleTokenCount(event);
+      return;
+    }
     if (event.type !== "task_complete" || !event.error || typeof event.error !== "object") return;
     const turn = event.turn_id;
     if (typeof turn !== "string" || this.completed.has(turn)) return;
     this.rememberTurn(turn);
     const error = event.error;
+    if (isUsageCap(error)) this.emitUsageCap();
     this.emit({
       type: "result",
       subtype: "error",
@@ -3329,6 +3349,59 @@ var CodexEventSource = class {
     });
     this.chat({ kind: "turn_end" });
   }
+  /**
+   * `token_count` carries the account's rate-limit gauges on every turn:
+   * `rate_limits.primary` (the 5-hour window) and `.secondary` (weekly), each
+   * with `used_percent`, `window_minutes` and `resets_at` in epoch seconds.
+   * Classified by window length rather than by name, and reported only when a
+   * window's numbers changed — the event fires per turn, and every report
+   * rewrites the key row and fans out `project:codingAgentKeyUpdated`.
+   */
+  handleTokenCount(event) {
+    const limits = event.rate_limits;
+    if (!limits || typeof limits !== "object") return;
+    for (const name of ["primary", "secondary"]) {
+      const window = limits[name];
+      if (!window || typeof window !== "object") continue;
+      const reading = window;
+      if (typeof reading.used_percent !== "number") continue;
+      const minutes = typeof reading.window_minutes === "number" ? reading.window_minutes : name === "secondary" ? WEEKLY_WINDOW_MINUTES : 0;
+      const rateLimitType = minutes >= WEEKLY_WINDOW_MINUTES ? "seven_day" : "five_hour";
+      const resetsAt = typeof reading.resets_at === "number" ? reading.resets_at : void 0;
+      const last = this.windows.get(rateLimitType);
+      if (last && last.usedPercent === reading.used_percent && last.resetsAt === resetsAt) continue;
+      this.windows.set(rateLimitType, { usedPercent: reading.used_percent, resetsAt });
+      this.emit({
+        type: "rate_limit_event",
+        rate_limit_info: {
+          status: "allowed",
+          rateLimitType,
+          utilization: Math.max(0, Math.min(1, reading.used_percent / 100)),
+          resetsAt
+        }
+      });
+    }
+  }
+  /**
+   * The CLI does not say which window capped. The fullest window last reported
+   * is the one that did; with no reading at all, the 5-hour window is the
+   * conservative guess (its fallback pause is the shorter one).
+   */
+  emitUsageCap() {
+    let rateLimitType = "five_hour";
+    let resetsAt;
+    let fullest = -Infinity;
+    for (const [type, window] of this.windows) {
+      if (window.usedPercent <= fullest) continue;
+      fullest = window.usedPercent;
+      rateLimitType = type;
+      resetsAt = window.resetsAt;
+    }
+    this.emit({
+      type: "rate_limit_event",
+      rate_limit_info: { status: "rejected", rateLimitType, resetsAt }
+    });
+  }
   rememberTurn(turn) {
     this.completed.add(turn);
     const oldest = this.completed.values().next().value;
@@ -4774,7 +4847,8 @@ var ClaudeTuiAdapter = class {
     structuredEvents: true,
     prefill: true,
     passiveTurns: true,
-    rawPromptGate: false
+    rawPromptGate: false,
+    prewarm: true
   };
   resolveBinary(env = process.env) {
     return env.CONVEYOR_CLAUDE_BIN ?? "claude";
@@ -4869,7 +4943,6 @@ var PtySession = class {
   // Raw-TUI input detection (see awaitRawTuiInputLive). `probeWindow`, when
   // non-null, accumulates raw output so a probe can look for its own sentinel
   // coming back.
-  spawnedAt = 0;
   // Set once the child writes a DEC private mode — it owns the tty from then on,
   // so the kernel no longer echoes our keystrokes and a sentinel coming back is
   // attributable to the app's own repaint.
@@ -4929,6 +5002,8 @@ var PtySession = class {
   turn;
   codexPromptInArgv = false;
   codexInitialPrompt;
+  /** A fresh CLI intentionally started without input for checkout overlap. */
+  prewarmed = false;
   codexSource = null;
   adapterCleanupPaths = [];
   onIdle(listener) {
@@ -5022,7 +5097,7 @@ var PtySession = class {
    * never set) keeps the Claude semantics byte-identical.
    */
   canReuse(resume, fingerprint) {
-    const resumeMatches = resume === void 0 ? this.reportedOpenCodeId !== null : resume === this.sessionUuid;
+    const resumeMatches = resume === void 0 ? this.reportedOpenCodeId !== null || this.prewarmed : resume === this.sessionUuid;
     return !this._toreDown && !this.exited && this.activeQueue === null && // A parked questionnaire owns the terminal — a fed prompt would type
     // into the dialog. Force teardown + respawn instead.
     !this.questionnairePending && resumeMatches && fingerprint === this.spawnFingerprint;
@@ -5052,6 +5127,7 @@ var PtySession = class {
     if (this.betweenTurnBuffer.length > MAX_BETWEEN_TURN_BUFFER) {
       this.betweenTurnBuffer.shift();
     }
+    if (this.prewarmed) return;
     if (!this.passiveSignaled) {
       this.passiveSignaled = true;
       this.passiveListener?.();
@@ -5063,8 +5139,10 @@ var PtySession = class {
    * the prompt into the live pty. The caller must have verified canReuse().
    */
   async beginTurn(prompt, options) {
+    this.prewarmed = false;
     this.turnPrompt = prompt;
     this.turn = turnOptionsFrom(options);
+    this.attachInput();
     this.resetForTurn();
     this.betweenTurnBuffer = [];
     this.activeQueue = new AsyncEventQueue();
@@ -5155,13 +5233,24 @@ var PtySession = class {
     }
   }
   async start() {
+    await this.startInternal(true);
+  }
+  /** Start the CLI and its event plumbing without allocating a model turn. */
+  async startParked() {
+    this.prewarmed = true;
+    await this.startInternal(false);
+  }
+  // oxlint-disable-next-line complexity -- adapter startup and turn gating share one teardown boundary
+  async startInternal(feedPrompt) {
     await this.collectCodexPrompt();
     const sessionId = this.resume ?? this.options.sessionId;
     if (!sessionId) {
       throw new Error("PtySession requires options.sessionId or a resume target");
     }
-    this.activeQueue = new AsyncEventQueue();
-    this.turnStream = this.activeQueue.drain();
+    if (feedPrompt) {
+      this.activeQueue = new AsyncEventQueue();
+      this.turnStream = this.activeQueue.drain();
+    }
     const signal = this.turn.abortController?.signal;
     if (signal?.aborted) {
       await this.teardown();
@@ -5187,7 +5276,7 @@ var PtySession = class {
           model: this.options.model
         });
       }
-      if (signal) {
+      if (signal && feedPrompt) {
         this.abortHandler = () => {
           void this.teardown();
         };
@@ -5198,10 +5287,10 @@ var PtySession = class {
         }
       }
       if (this.bridge) {
-        this.unsubInput = this.bridge.onInput((data) => this.writeStdin(data));
+        if (feedPrompt) this.attachInput();
         this.unsubResize = this.bridge.onResize((cols, rows) => this.resizePty(cols, rows));
       }
-      await this.feedPrompt();
+      if (feedPrompt) await this.feedPrompt();
     } catch (err) {
       await this.teardown();
       throw err;
@@ -5241,7 +5330,11 @@ var PtySession = class {
           session_id: id,
           model: this.options.model
         });
-        this.sendChatEvent({ kind: "init", model: this.options.model, claudeSessionId: id });
+        this.sendChatEvent({
+          kind: "init",
+          model: this.options.model,
+          claudeSessionId: id
+        });
       },
       (event) => this.sendChatEvent(event)
     );
@@ -5279,7 +5372,11 @@ var PtySession = class {
           session_id: id,
           model: this.options.model
         });
-        this.sendChatEvent({ kind: "init", model: this.options.model, claudeSessionId: id });
+        this.sendChatEvent({
+          kind: "init",
+          model: this.options.model,
+          claudeSessionId: id
+        });
       },
       (event) => this.sendChatEvent(event)
     );
@@ -5393,9 +5490,19 @@ var PtySession = class {
     this.pendingSyntheticQuestionIds = [];
     this.questionResultRemap.clear();
     for (const toolUseId of orphaned) {
-      this.sendChatEvent({ kind: "tool_result", toolUseId, output: "", isError: false });
+      this.sendChatEvent({
+        kind: "tool_result",
+        toolUseId,
+        output: "",
+        isError: false
+      });
     }
   }
+  /** Attach relay keystrokes only once a Git-gated turn is allowed to accept them. */
+  attachInput() {
+    if (!this.bridge || this.unsubInput) return;
+    this.unsubInput = this.bridge.onInput((data) => this.writeStdin(data));
+  }
   writeStdin(text) {
     this.pty?.write(text);
   }
@@ -5562,7 +5669,6 @@ var PtySession = class {
     pty.onExit((event) => {
       void this.finalizeOnExit(event.exitCode);
     });
-    this.spawnedAt = Date.now();
     this.sawTerminalSetup = false;
     this.probeWindow = null;
     this.wroteToProcess = false;
@@ -5606,7 +5712,7 @@ var PtySession = class {
     if (!needsRawReadyGate(this.adapter.capabilities)) return;
     const timing = resolveRawTuiProbeTiming();
     const { sentinel } = timing;
-    const start = this.spawnedAt || Date.now();
+    const start = Date.now();
     const setupDeadline = start + timing.firstOutputMaxMs;
     while (!this._toreDown && Date.now() < setupDeadline) {
       if (this.sawTerminalSetup) break;
@@ -5890,7 +5996,12 @@ var PtySession = class {
     }
     if (!this.adapter.capabilities.structuredEvents) {
       if (exitCode === 0) {
-        this.pushEvent({ type: "result", subtype: "success", result: "", total_cost_usd: 0 });
+        this.pushEvent({
+          type: "result",
+          subtype: "success",
+          result: "",
+          total_cost_usd: 0
+        });
       } else {
         this.pushEvent({
           type: "result",
@@ -6051,6 +6162,9 @@ var PtyHarness = class _PtyHarness {
   authNoticeSent = false;
   /** Once-per-process guard on the pod-recycle escalation (see escalateToPodRecycle). */
   recycleRequested = false;
+  disposed = false;
+  prewarming = null;
+  prewarmInFlight = null;
   /**
    * Wiggle the live pty's size so the CLI repaints its whole screen. No-op on
    * the SDK harness. Falls back to the parked session so an API reconnect while
@@ -6111,6 +6225,60 @@ var PtyHarness = class _PtyHarness {
     yield* this.drain(session);
     yield* this.recoverFailedDelivery(session, options, want);
   }
+  /**
+   * Prepare a fresh TUI while another boot task runs. This deliberately does
+   * not send stdin or create an active event queue, so no model/tool work can
+   * begin before the runner releases its checkout and WIP gates.
+   */
+  async prewarm(options) {
+    if (this.prewarmInFlight) return this.prewarmInFlight;
+    const pending = this.startPrewarm(options);
+    this.prewarmInFlight = pending;
+    try {
+      return await pending;
+    } finally {
+      this.prewarmInFlight = null;
+    }
+  }
+  async startPrewarm(options) {
+    if (this.disposed || !this.adapter.capabilities.prewarm) return false;
+    const startedAt = Date.now();
+    const prepared = ensureSessionTarget(options, void 0);
+    if (prepared !== options) {
+      _PtyHarness.log.warn("prewarm had no session target \u2014 minted one", {
+        sessionId: prepared.sessionId
+      });
+    }
+    const fingerprint = this.fingerprintOf(prepared);
+    if (this.parked?.canReuse(void 0, fingerprint) && !await this.parkedHomeDied(prepared)) {
+      _PtyHarness.log.info("TUI prewarm reused parked process", {
+        elapsedMs: Date.now() - startedAt
+      });
+      return true;
+    }
+    if (this.parked) {
+      const stale = this.parked;
+      this.parked = null;
+      this.cancelEndedTimer();
+      await stale.teardown();
+    }
+    if (this.disposed) return false;
+    _PtyHarness.log.info("TUI prewarm starting fresh process");
+    const session = await this.spawnSession("", prepared, void 0, true, (created) => {
+      this.prewarming = created;
+    });
+    this.prewarming = null;
+    if (this.disposed) {
+      await session.teardown();
+      this.notifyEnded();
+      return false;
+    }
+    this.park(session);
+    _PtyHarness.log.info("TUI prewarm process started", {
+      elapsedMs: Date.now() - startedAt
+    });
+    return true;
+  }
   /**
    * Did the shared `~/.claude` mount die while this session sat parked?
    *
@@ -6147,8 +6315,9 @@ var PtyHarness = class _PtyHarness {
    * environment preparation (config-home health, credential synthesis,
    * auth-readiness warning) and registering the parked-death watch.
    */
-  async spawnSession(prompt, options, want) {
+  async spawnSession(prompt, options, want, parked = false, onAllocated) {
     const session = new PtySession(prompt, options, want, this.bridge, this.adapter);
+    onAllocated?.(session);
     if (this.ownsClaudeConfigHome) {
       await ensureUsableClaudeConfigHome(options.cwd, _PtyHarness.log);
     }
@@ -6157,7 +6326,8 @@ var PtyHarness = class _PtyHarness {
       await this.warnIfAuthNotReady();
     }
     session.onExit(() => this.handleSessionExit(session));
-    await session.start();
+    if (parked) await session.startParked();
+    else await session.start();
     return session;
   }
   /**
@@ -6329,10 +6499,21 @@ var PtyHarness = class _PtyHarness {
    * the Connected-TUI tab hides promptly.
    */
   async dispose() {
+    this.disposed = true;
     this.cancelEndedTimer();
-    const toKill = [this.parked, this.activeSession].filter((s) => s !== null);
+    try {
+      await this.prewarmInFlight;
+    } catch (error) {
+      _PtyHarness.log.warn("TUI prewarm failed during disposal", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    const toKill = [.../* @__PURE__ */ new Set([this.parked, this.activeSession, this.prewarming])].filter(
+      (s) => s !== null
+    );
     this.parked = null;
     this.activeSession = null;
+    this.prewarming = null;
     for (const session of toKill) {
       try {
         await session.teardown();
@@ -6471,13 +6652,16 @@ async function seedOpenCodeOauth(env) {
 }
 
 // src/harness/openai-model.ts
-var DEFAULT_OPENAI_CODING_MODEL = "gpt-5.6-terra";
+var DEFAULT_OPENAI_CODING_MODEL = DEFAULT_CODEX_CODING_MODEL;
 function resolveOpenAiCodingModel(model) {
   if (!model || model.startsWith("claude-") || model.includes("/") && !model.startsWith("openai/")) {
     return DEFAULT_OPENAI_CODING_MODEL;
   }
   return model.replace(/^openai\//, "");
 }
+function resolveCodexReasoningEffort(...candidates) {
+  return candidates.find(isCodexReasoningEffort);
+}
 
 // src/harness/opencode/credentials.ts
 var PROVIDER_KEY_ENV = {
@@ -6771,7 +6955,8 @@ var OpenCodeTuiAdapter = class {
     // opencode silently discards early stdin while the TUI paints; the pasted
     // text itself is lost, so the readiness probe must gate the first write
     // even though structured events exist now.
-    rawPromptGate: true
+    rawPromptGate: true,
+    prewarm: true
   };
   resolveBinary(env = this.env) {
     const override = env.CONVEYOR_OPENCODE_BIN;
@@ -6935,7 +7120,8 @@ var CodexTuiAdapter = class {
     structuredEvents: true,
     prefill: true,
     passiveTurns: true,
-    rawPromptGate: true
+    rawPromptGate: true,
+    prewarm: true
   };
   resolveBinary(env = this.env) {
     const path = findOnPath(env.CONVEYOR_CODEX_BIN ?? "codex", env);
@@ -6987,11 +7173,16 @@ var CodexTuiAdapter = class {
       sandbox_mode: "danger-full-access",
       developer_instructions: [
         input.options.appendSystemPrompt,
-        "Conveyor workflow skills are stored in .claude/skills in the workspace. When instructed to run a /skill-name skill, read .claude/skills/skill-name/SKILL.md and follow its instructions. This is a file-based workflow, not a native slash command."
+        "Conveyor workflow skills are stored in .claude/skills in the workspace. When instructed to run a /skill-name skill, read .claude/skills/skill-name/SKILL.md and follow its instructions. This is a file-based workflow, not a native slash command. When a skill's Goal and finish line section tells you to create a thread goal, do so with your goal tool before the first step; the objective is that section's finish line."
       ].filter(Boolean).join("\n\n"),
       mcp_servers: codexMcpConfig(input.mcpEntries ?? {}),
       projects: { [trustedCwd]: { trust_level: "trusted" } }
     };
+    const effort = resolveCodexReasoningEffort(
+      this.env.CONVEYOR_AGENT_REASONING_EFFORT,
+      input.options.codex?.effort
+    );
+    if (effort) config.model_reasoning_effort = effort;
     if (input.pluginPath && input.eventsSinkPath) {
       const profile = basename(dirname3(input.pluginPath));
       const profilePath = join14(env.CODEX_HOME, `${profile}.config.toml`);
@@ -7009,7 +7200,9 @@ var CodexTuiAdapter = class {
     if (input.pluginPath) args.push("--profile", basename(dirname3(input.pluginPath)));
     for (const [key, value] of Object.entries(config))
       args.push("-c", `${key}=${tomlValue(value)}`);
-    const model = resolveOpenAiCodingModel(this.env.CONVEYOR_AGENT_MODEL ?? input.options.model);
+    const model = resolveOpenAiCodingModel(
+      this.env.CONVEYOR_AGENT_MODEL ?? input.options.codex?.model ?? input.options.model
+    );
     args.push("--model", model);
     if (input.resume) args.push("resume", input.resume);
     if (input.initialPrompt) args.push("--", input.initialPrompt);
@@ -8103,6 +8296,7 @@ function buildParentReviewPrompt() {
 var TYPE_PRIORITY = { rule: 0, doc: 1, file: 2, folder: 3 };
 var SUMMARY_SCAN_CHARS = 4e3;
 var SUMMARY_MAX_CHARS = 160;
+var CONTEXT_READ_CONCURRENCY = 4;
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
   ".jpg",
@@ -8205,24 +8399,61 @@ async function readFolderListing(folderPath) {
     return null;
   }
 }
-async function resolveEntry(entry) {
-  const result = {
-    type: entry.type,
-    path: entry.path,
-    label: entry.label,
-    summary: null
-  };
-  if (entry.label) {
-    result.summary = truncateSummary(entry.label);
+var ContextReadCoordinator = class {
+  availableSlots = CONTEXT_READ_CONCURRENCY;
+  waitingReaders = [];
+  pendingSummaries = /* @__PURE__ */ new Map();
+  async resolveEntry(entry) {
+    const result = {
+      type: entry.type,
+      path: entry.path,
+      label: entry.label,
+      summary: null
+    };
+    if (entry.label) {
+      result.summary = truncateSummary(entry.label);
+      return result;
+    }
+    result.summary = await this.readSummary(entry);
     return result;
   }
-  if (entry.type === "folder") {
-    result.summary = await readFolderListing(entry.path);
-    return result;
+  readSummary(entry) {
+    const kind = entry.type === "folder" ? "folder" : "file";
+    const key = `${kind}:${entry.path}`;
+    const pending = this.pendingSummaries.get(key);
+    if (pending) return pending;
+    const read = this.limit(
+      () => kind === "folder" ? readFolderListing(entry.path) : readFileSummary(entry.path)
+    );
+    this.pendingSummaries.set(key, read);
+    return read;
   }
-  result.summary = await readFileSummary(entry.path);
-  return result;
-}
+  async limit(read) {
+    await this.acquireSlot();
+    try {
+      return await read();
+    } finally {
+      this.releaseSlot();
+    }
+  }
+  async acquireSlot() {
+    if (this.availableSlots > 0) {
+      this.availableSlots -= 1;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.waitingReaders.push(resolve);
+    });
+  }
+  releaseSlot() {
+    const nextReader = this.waitingReaders.shift();
+    if (nextReader) {
+      nextReader();
+      return;
+    }
+    this.availableSlots += 1;
+  }
+};
 function formatEntry(entry) {
   const suffix = entry.summary ? ` \u2014 ${entry.summary}` : "";
   return `- \`${entry.path}\`${suffix}`;
@@ -8277,39 +8508,33 @@ function formatResolvedTags(resolved, subProject, mentioned, runnerMode) {
   }
   return parts.join("\n");
 }
-async function resolveEntries(contextPaths) {
-  if (!contextPaths?.length) return [];
+function resolveEntries(contextPaths, coordinator) {
+  if (!contextPaths?.length) return Promise.resolve([]);
   const sorted = [...contextPaths].sort(
     (a, b) => (TYPE_PRIORITY[a.type] ?? 99) - (TYPE_PRIORITY[b.type] ?? 99)
   );
-  const results = [];
-  for (const entry of sorted) {
-    results.push(await resolveEntry(entry));
-  }
-  return results;
+  return Promise.all(sorted.map((entry) => coordinator.resolveEntry(entry)));
 }
 function countResolved(entries) {
   const injected = entries.filter((e) => e.summary !== null).length;
   return { injected, skipped: entries.length - injected };
 }
-async function resolveAssignedTags(assignedTags) {
-  const resolved = [];
-  let injected = 0;
-  let skipped = 0;
-  for (const tag of assignedTags) {
-    const entries = await resolveEntries(tag.contextPaths);
-    const counts = countResolved(entries);
-    injected += counts.injected;
-    skipped += counts.skipped;
-    resolved.push({
+async function resolveAssignedTags(assignedTags, coordinator) {
+  const resolved = await Promise.all(
+    assignedTags.map(async (tag) => ({
       tagName: tag.name,
       description: tag.description,
-      entries,
+      entries: await resolveEntries(tag.contextPaths, coordinator),
       hasOverview: tag.hasOverview,
       overviewPath: tag.overviewPath ?? null
-    });
-  }
-  return { resolved, injected, skipped };
+    }))
+  );
+  const counts = resolved.map((tag) => countResolved(tag.entries));
+  return {
+    resolved,
+    injected: counts.reduce((total, current) => total + current.injected, 0),
+    skipped: counts.reduce((total, current) => total + current.skipped, 0)
+  };
 }
 async function resolveTagContext(projectTags, taskTagIds, _model, _betas, runnerMode, subProject, mentionedTagIds) {
   const taskTagIdSet = new Set(taskTagIds);
@@ -8323,30 +8548,26 @@ async function resolveTagContext(projectTags, taskTagIds, _model, _betas, runner
   if (!hasTagPaths && !hasSubProjectPaths && mentionedTags.length === 0) {
     return { injectedSection: "", stats: { injected: 0, skipped: 0 } };
   }
-  const {
-    resolved,
-    injected: tagInjected,
-    skipped: tagSkipped
-  } = await resolveAssignedTags(assignedTags);
-  const { resolved: mentionedResolved } = await resolveAssignedTags(mentionedTags);
-  let subProjectResolved = null;
-  let subInjected = 0;
-  let subSkipped = 0;
-  if (subProject && hasSubProjectPaths) {
-    const entries = await resolveEntries(subProject.contextPaths);
-    const counts = countResolved(entries);
-    subInjected = counts.injected;
-    subSkipped = counts.skipped;
-    subProjectResolved = { name: subProject.name, entries };
-  }
+  const coordinator = new ContextReadCoordinator();
+  const subProjectEntries = subProject && hasSubProjectPaths ? resolveEntries(subProject.contextPaths, coordinator) : Promise.resolve(null);
+  const [assigned, mentioned, subProjectResolvedEntries] = await Promise.all([
+    resolveAssignedTags(assignedTags, coordinator),
+    resolveAssignedTags(mentionedTags, coordinator),
+    subProjectEntries
+  ]);
+  const subProjectResolved = subProject && subProjectResolvedEntries ? { name: subProject.name, entries: subProjectResolvedEntries } : null;
+  const subProjectCounts = subProjectResolvedEntries ? countResolved(subProjectResolvedEntries) : { injected: 0, skipped: 0 };
   return {
     injectedSection: formatResolvedTags(
-      resolved,
+      assigned.resolved,
       subProjectResolved,
-      mentionedResolved,
+      mentioned.resolved,
       runnerMode
     ),
-    stats: { injected: tagInjected + subInjected, skipped: tagSkipped + subSkipped }
+    stats: {
+      injected: assigned.injected + subProjectCounts.injected,
+      skipped: assigned.skipped + subProjectCounts.skipped
+    }
   };
 }
 
@@ -13243,17 +13464,21 @@ function handleRateLimitEvent(event, host) {
   const { rate_limit_info } = event;
   logger4.info("Rate limit event received", { rate_limit_info });
   const status = rate_limit_info.status;
+  const resetsAt = epochSecondsToISO(rate_limit_info.resetsAt);
   const utilization = rate_limit_info.utilization ?? (status === "rejected" ? 1 : void 0);
   if (utilization !== void 0 && rate_limit_info.rateLimitType) {
     host.connection.sendEvent({
       type: "rate_limit_update",
       rateLimitType: rate_limit_info.rateLimitType,
       utilization,
-      status
+      status,
+      // The server parses this into the key's sessionResetsAt / weeklyResetsAt;
+      // Codex reports a reset instant with every gauge, so allowed events carry
+      // it too, not only rejections.
+      ...resetsAt ? { resetsAt } : {}
     });
   }
   if (status === "rejected") {
-    const resetsAt = epochSecondsToISO(rate_limit_info.resetsAt);
     const resetsAtDisplay = resetsAt ?? "unknown";
     const message = `Rate limit rejected (type: ${rate_limit_info.rateLimitType ?? "unknown"}, resets at: ${resetsAtDisplay})`;
     host.connection.sendEvent({ type: "error", message });
@@ -14120,7 +14345,11 @@ function buildQueryOptions(host, context) {
   const systemPromptText = buildSystemPrompt(
     host.config.mode,
     context,
-    { ...host.config, isAuto: host.isAuto, runtimeTui: process.env.CONVEYOR_TUI },
+    {
+      ...host.config,
+      isAuto: host.isAuto,
+      runtimeTui: process.env.CONVEYOR_TUI
+    },
     host.setupLog,
     mode
   );
@@ -14163,6 +14392,7 @@ function buildQueryOptions(host, context) {
     effort: settings.effort,
     thinking: settings.thinking,
     betas: settings.betas,
+    codex: settings.codex,
     abortController: host.abortController ?? void 0,
     disallowedTools: buildDisallowedTools(settings, mode, host.hasExitedPlanMode),
     enableFileCheckpointing: settings.enableFileCheckpointing,
@@ -14180,7 +14410,11 @@ function buildMultimodalPrompt(textPrompt, context, skipImages = false) {
   for (const msg of context.chatHistory) {
     for (const f2 of msg.files ?? []) {
       if (f2.content && f2.contentEncoding === "base64") {
-        chatImages.push({ fileName: f2.fileName, mimeType: f2.mimeType, content: f2.content });
+        chatImages.push({
+          fileName: f2.fileName,
+          mimeType: f2.mimeType,
+          content: f2.content
+        });
       }
     }
   }
@@ -14195,14 +14429,24 @@ function buildMultimodalPrompt(textPrompt, context, skipImages = false) {
         data: file.content ?? ""
       }
     });
-    blocks.push({ type: "text", text: `[Attached image: ${file.fileName} (${file.mimeType})]` });
+    blocks.push({
+      type: "text",
+      text: `[Attached image: ${file.fileName} (${file.mimeType})]`
+    });
   }
   for (const file of chatImages) {
     blocks.push({
       type: "image",
-      source: { type: "base64", media_type: file.mimeType, data: file.content }
+      source: {
+        type: "base64",
+        media_type: file.mimeType,
+        data: file.content
+      }
+    });
+    blocks.push({
+      type: "text",
+      text: `[Chat image: ${file.fileName} (${file.mimeType})]`
     });
-    blocks.push({ type: "text", text: `[Chat image: ${file.fileName} (${file.mimeType})]` });
   }
   return blocks;
 }
@@ -14318,6 +14562,7 @@ async function* watchForParkedTui(inner, host, opts) {
   const timer = setTimeout(() => {
     parked = true;
     host.connection.emitStatus("waiting_for_input");
+    host.callbacks.onSubmittedPtyParked?.();
     void host.callbacks.onStatusChange("waiting_for_input");
   }, PARKED_TUI_GRACE_MS);
   const silenceTimeoutMs = resolveTurnSilenceTimeoutMs();
@@ -14359,7 +14604,7 @@ async function* watchForParkedTui(inner, host, opts) {
 function takesPlannerOpeningTurn(host, mode) {
   return host.config.mode === "plan" && mode === "discovery";
 }
-async function runSdkQuery(host, context, followUpContent, promptDeliveryOverride) {
+async function runSdkQuery(host, context, followUpContent, promptDeliveryOverride, freshPrewarmed = false) {
   if (host.isStopped()) return;
   const mode = host.agentMode;
   const isDiscoveryLike = mode === "discovery" || mode === "help";
@@ -14368,7 +14613,7 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
     host.config.workspaceDir,
     host.config.mode === "code-review" && process.env.CONVEYOR_TUI !== "codex" ? "claude-code" : process.env.CONVEYOR_TUI
   );
-  const hasExistingSession = !!sessionStart.resume;
+  const hasExistingSession = !!sessionStart.resume && !freshPrewarmed;
   const promptDelivery = promptDeliveryOverride ?? resolvePromptDelivery({
     harnessKind: host.harnessKind,
     runnerMode: host.config.mode,
@@ -14390,11 +14635,49 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
   if (isDiscoveryLike && host.harnessKind === "sdk") {
     return;
   }
-  if (isDiscoveryLike && resume && !takesPlannerOpeningTurn(host, mode)) {
+  if (isDiscoveryLike && resume && !freshPrewarmed && !takesPlannerOpeningTurn(host, mode)) {
     return;
   }
   await runInitialQuery(host, context, options, resume, promptDelivery);
 }
+async function prewarmInitialTuiQuery(host, context) {
+  if (host.harnessKind !== "pty" || !host.harness.prewarm) return false;
+  const mode = host.agentMode;
+  const sessionStart = resolveSessionStart(
+    sessionLineageKey(context.taskId, mode, host.config.mode),
+    host.config.workspaceDir,
+    host.config.mode === "code-review" && process.env.CONVEYOR_TUI !== "codex" ? "claude-code" : process.env.CONVEYOR_TUI
+  );
+  if (sessionStart.resume) return false;
+  const promptDelivery = resolvePromptDelivery({
+    harnessKind: host.harnessKind,
+    runnerMode: host.config.mode,
+    isAuto: host.isAuto,
+    agentMode: mode,
+    isFollowUp: false,
+    hasExistingSession: false
+  });
+  const options = {
+    ...buildQueryOptions(host, context),
+    promptDelivery,
+    ...sessionStart.sessionId ? { sessionId: sessionStart.sessionId } : {}
+  };
+  const initialPrompt = await buildInitialPrompt(
+    host.config.mode,
+    context,
+    host.isAuto,
+    host.agentMode,
+    host.config.packExecution
+  );
+  const { appendSystemPrompt } = selectInitialPromptInput(
+    promptDelivery,
+    initialPrompt,
+    context,
+    options.appendSystemPrompt,
+    host.harnessKind
+  );
+  return host.harness.prewarm({ ...options, appendSystemPrompt });
+}
 async function runFollowUpQuery(host, context, options, resume, followUpContent) {
   if (options.promptDelivery === "prefill") {
     await runPrefilledFollowUp(host, context, options, resume, followUpContent);
@@ -14720,7 +15003,10 @@ function handleRetryError(error, context, host, options, prevImageError) {
     return handleAuthError(context, host, options);
   }
   if (!isRetriableError(error)) throw error;
-  return { action: "continue", lastErrorWasImage: classifyImageError(error) || prevImageError };
+  return {
+    action: "continue",
+    lastErrorWasImage: classifyImageError(error) || prevImageError
+  };
 }
 function handleProcessResult(result, context, host, options) {
   if (result.modeRestart || host.isStopped()) return { action: "return" };
@@ -14737,10 +15023,16 @@ function handleProcessResult(result, context, host, options) {
     };
   }
   if (result.staleSession && context.claudeSessionId) {
-    return { action: "return_promise", promise: handleStaleSession(context, host, options) };
+    return {
+      action: "return_promise",
+      promise: handleStaleSession(context, host, options)
+    };
   }
   if (result.authError) {
-    return { action: "return_promise", promise: handleAuthError(context, host, options) };
+    return {
+      action: "return_promise",
+      promise: handleAuthError(context, host, options)
+    };
   }
   if (!result.retriable) return { action: "return" };
   return {
@@ -14848,6 +15140,7 @@ var QueryBridge = class {
   _apiOutageDetail = null;
   _keyCycleCount = 0;
   _abortController = null;
+  freshPrewarmedInitial = false;
   /** Called by SessionRunner when ExitPlanMode triggers a mode transition. */
   onModeTransition;
   /** Called by tool handlers to soft-stop (abort query, keep session alive). */
@@ -14903,6 +15196,19 @@ var QueryBridge = class {
   forceRepaint() {
     this.harness.forceRepaint?.();
   }
+  /** Warm a fresh interactive task TUI only. It receives no input until SessionRunner's Git gate releases. */
+  async prewarmInitial(context) {
+    try {
+      const warmed = await prewarmInitialTuiQuery(this.buildHost(), context);
+      this.freshPrewarmedInitial = warmed;
+      return warmed;
+    } catch (err) {
+      logger6.warn("TUI prewarm failed; continuing with normal startup", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return false;
+    }
+  }
   stop() {
     this._stopped = true;
     this._abortController?.abort();
@@ -14952,7 +15258,7 @@ var QueryBridge = class {
       isAuto: this.mode.isAuto,
       agentMode: this.mode.effectiveMode,
       isFollowUp: false,
-      hasExistingSession: hasExistingSessionFile(context.taskId, this.runnerConfig.workspaceDir, {
+      hasExistingSession: !this.freshPrewarmedInitial && hasExistingSessionFile(context.taskId, this.runnerConfig.workspaceDir, {
         agentMode: this.mode.effectiveMode,
         runnerMode: this.runnerConfig.mode
       })
@@ -14975,7 +15281,9 @@ var QueryBridge = class {
     this._abortController = new AbortController();
     const host = this.buildHost();
     try {
-      await runSdkQuery(host, context, followUpContent, promptDelivery);
+      const freshPrewarmed = !followUpContent && this.freshPrewarmedInitial;
+      this.freshPrewarmedInitial = false;
+      await runSdkQuery(host, context, followUpContent, promptDelivery, freshPrewarmed);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       const isAbort = this._stopped || /abort/i.test(msg);
@@ -15373,6 +15681,9 @@ async function runUsageProbe(deps = {}) {
 // src/execution/usage-sampler.ts
 var logger7 = createServiceLogger("usage-sampler");
 var NO_SAMPLES = { samples: [], unmeasurable: null };
+function usesNativeUsageReporting(env = process.env) {
+  return env.CONVEYOR_TUI === "codex";
+}
 function isAttributable(identity, sessionToken) {
   if (!identity) return { ok: true };
   if (identity.hasRefreshToken && !identity.isConveyorOwned) {
@@ -15689,7 +16000,10 @@ var SessionRunner = class _SessionRunner {
     });
     const initialMode = config.agentMode ?? (config.runnerMode === "pm" ? config.isAuto ? "auto" : "discovery" : "building");
     this.mode = new ModeController(initialMode, config.runnerMode, config.isAuto);
-    const lifecycleConfig = { ...DEFAULT_LIFECYCLE_CONFIG, ...config.lifecycle };
+    const lifecycleConfig = {
+      ...DEFAULT_LIFECYCLE_CONFIG,
+      ...config.lifecycle
+    };
     this.lifecycle = new Lifecycle(lifecycleConfig, {
       onHeartbeat: () => {
         const loopStatus = this.refreshLoopStatus();
@@ -16048,6 +16362,10 @@ var SessionRunner = class _SessionRunner {
       await this.shutdown("error");
       return;
     }
+    this.mode.applyServerMode(this.fullContext?.agentMode, this.fullContext?.isAuto);
+    this.mode.resolveInitialMode(this.taskContext);
+    this.queryBridge = this.createQueryBridge();
+    const prewarmInitial = this.queryBridge.prewarmInitial(this.fullContext);
     const gitState = await awaitGitReady({
       onLog: (m) => process.stderr.write(`[conveyor-agent] ${m}
 `)
@@ -16056,6 +16374,7 @@ var SessionRunner = class _SessionRunner {
       const message = gitState === "failed" ? "Workspace git preparation failed (see pod logs)" : "Workspace git preparation timed out (see pod logs)";
       this.connection.sendEvent({ type: "error", message });
       await this.callbacks.onEvent({ type: "error", message });
+      await this.queryBridge.dispose();
       await this.shutdown("error");
       return;
     }
@@ -16069,8 +16388,8 @@ var SessionRunner = class _SessionRunner {
         process.stderr.write("[conveyor-agent] WARNING: task-branch checkout failed\n");
       }
       if (ok) void reportBootMilestone({ key: "branch_ready" });
-      await this.refreshSkillsForCheckout();
     }
+    if (this.fullContext?.githubBranch) await this.refreshSkillsForCheckout();
     if (!this.stopped) {
       this.lifecycle.startGitFlush();
     }
@@ -16085,13 +16404,15 @@ var SessionRunner = class _SessionRunner {
       }
     }
     this.workspaceCommands?.notifyWorkspaceReady();
-    this.mode.applyServerMode(this.fullContext?.agentMode, this.fullContext?.isAuto);
-    this.mode.resolveInitialMode(this.taskContext);
     if (this.fullContext?.isAuto && PRE_BUILD_TASK_STATUSES.has(this.taskContext.status) && this.mode.isBuildCapable && hasTaskPlan(this.fullContext.plan)) {
       void this.connection.triggerIdentification().catch(() => {
       });
     }
-    this.queryBridge = this.createQueryBridge();
+    await prewarmInitial;
+    if (this.stopped) {
+      await this.queryBridge.dispose();
+      return;
+    }
     this.logInitialization();
     const staleBatch = [...this.pendingMessages];
     const didExecuteInitialQuery = await this.executeInitialMode();
@@ -16284,7 +16605,11 @@ var SessionRunner = class _SessionRunner {
     }
     if (delivery === "prefill") {
       await this.setState("waiting_for_input");
-      await this.callbacks.onEvent({ type: "execute_mode", mode: effectiveMode, delivery });
+      await this.callbacks.onEvent({
+        type: "execute_mode",
+        mode: effectiveMode,
+        delivery
+      });
       if (this.pendingMessages.length > 0) {
         if (!this.stopped) await this.setState("idle");
         return false;
@@ -16297,7 +16622,10 @@ var SessionRunner = class _SessionRunner {
       }
     } else {
       await this.setState("running");
-      await this.callbacks.onEvent({ type: "execute_mode", mode: effectiveMode });
+      await this.callbacks.onEvent({
+        type: "execute_mode",
+        mode: effectiveMode
+      });
       await this.executeQuery(void 0, delivery);
       await this.requeueWedgedInitialQuery(delivery);
     }
@@ -16606,7 +16934,7 @@ var SessionRunner = class _SessionRunner {
    *  `selectBestKey` rotation honest. Best-effort — never throws, no-op when the
    *  pod has no OAuth token (e.g. API-key projects). */
   async sampleAndReportKeyUsage() {
-    if (this.stopped) return;
+    if (this.stopped || usesNativeUsageReporting()) return;
     const codingAgentKeyId = process.env.CONVEYOR_CODING_AGENT_KEY_ID;
     const { samples, unmeasurable } = await sampleKeyUsage(
       process.env.CLAUDE_CODE_OAUTH_TOKEN,
@@ -16754,16 +17082,8 @@ var SessionRunner = class _SessionRunner {
       isAuto: this.config.isAuto
     };
     const bridge = new QueryBridge(this.connection, this.mode, runnerConfig, {
-      onStatusChange: (status) => {
-        if (status === "running") {
-          this.beginRunningEpisode();
-          if (this._state === "waiting_for_input") {
-            this._state = "running";
-            this.lifecycle.cancelIdleTimer();
-          }
-        }
-        return this.callbacks.onStatusChange(status);
-      },
+      onStatusChange: (status) => this.handleQueryStatus(status),
+      onSubmittedPtyParked: () => this.applySubmittedPtyParkedStatus(),
       onEvent: (event) => {
         if (!this.agentLiveReported) {
           this.agentLiveReported = true;
@@ -16788,7 +17108,11 @@ var SessionRunner = class _SessionRunner {
       const oldMode = this.mode.effectiveMode;
       process.stderr.write(`[conveyor-agent] Mode transition: ${oldMode} \u2192 ${newMode}
 `);
-      this.connection.sendEvent({ type: "mode_transition", from: oldMode, to: newMode });
+      this.connection.sendEvent({
+        type: "mode_transition",
+        from: oldMode,
+        to: newMode
+      });
       this.mode.pendingModeRestart = true;
       this.connection.emitModeChanged(newMode);
       this.softStop();
@@ -17016,6 +17340,32 @@ ${outcome.failures.join("\n")}
     await this.connection.emitStatus(status);
     await this.callbacks.onStatusChange(status);
   }
+  /**
+   * A submitted PTY query can park on an unexpected terminal dialog without
+   * returning its turn. Keep the runner's local state (which drives heartbeat
+   * liveness) in sync with that specific watchdog signal, but do not emit it
+   * again: QueryBridge already sent it.
+   *
+   * Retry delays and pending questionnaires also report `waiting_for_input`,
+   * but they retain their existing bounded liveness holds and must not change
+   * `_state` here.
+   */
+  applySubmittedPtyParkedStatus() {
+    this._state = "waiting_for_input";
+    this.refreshLoopStatus();
+  }
+  /** Forward an ordinary query status without changing liveness for transient
+   * waiting states. The submitted-PTY watchdog calls its dedicated handler. */
+  handleQueryStatus(status) {
+    if (status === "running") {
+      this.beginRunningEpisode();
+      if (this._state === "waiting_for_input") {
+        this._state = "running";
+        this.lifecycle.cancelIdleTimer();
+      }
+    }
+    return this.callbacks.onStatusChange(status);
+  }
   /** Mark a fresh turn without emitting a duplicate status. QueryExecutor's
    * prefilled PTY callback already emitted `running` before it reaches here. */
   beginRunningEpisode() {
@@ -17121,6 +17471,7 @@ export {
   resolveSessionStart,
   parseUsageGauges,
   runUsageProbe,
+  usesNativeUsageReporting,
   sampleKeyUsage,
   buildRateLimitEvents,
   buildUnmeasurableEvent,