@rallycry/conveyor-agent 11.0.31 → 11.0.33

package/dist/{chunk-RFACW7A4.js → chunk-A73WZJ4Y.js}

@@ -6,6 +6,7 @@ import {
 import {
   MAX_BETWEEN_TURN_BUFFER,
   MAX_DIAGNOSTIC_OUTPUT,
+  SUBMIT_SETTLE_MS,
   buildExitErrors,
   buildPromptBytes,
   buildSpawnArgs,
@@ -29,7 +30,7 @@ import {
   spawnOptionsFingerprint,
   transcriptSize,
   turnOptionsFrom
-} from "./chunk-WCJ6HRVU.js";
+} from "./chunk-EKTPDG3G.js";
 import {
   AGENT_STATUS_REASON_USER_QUESTION,
   AgentConnection,
@@ -51,6 +52,7 @@ import {
   MAX_MANUAL_TEST_TITLE_LENGTH,
   PM_CHAT_HISTORY_LIMIT,
   PRE_BUILD_TASK_STATUSES,
+  PTY_CHAT_TURN_FILES_MAX,
   PTY_STREAM_PORT_ATTEMPTS,
   PTY_STREAM_PORT_BASE,
   PortDiscovery,
@@ -95,7 +97,7 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-3MEPGN2A.js";
+} from "./chunk-IHNXVFIB.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
@@ -399,8 +401,8 @@ var ClaudeCodeHarness = class {
 
 // src/harness/pty/session.ts
 import { randomUUID } from "crypto";
-import { mkdtemp, mkdir as mkdir3, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import { join as join7, dirname } from "path";
+import { mkdtemp, mkdir as mkdir3, rm as rm2, writeFile as writeFile7 } from "fs/promises";
+import { join as join8, dirname } from "path";
 
 // src/harness/opencode/plugin.ts
 import { writeFile } from "fs/promises";
@@ -590,6 +592,8 @@ var OpenCodeEventSource = class {
   /** Session ids opencode reported with a `parentID` — subagent sessions. */
   childSessions = /* @__PURE__ */ new Set();
   lastLivenessAt = Number.NEGATIVE_INFINITY;
+  /** When the bus turn opened — the chat `turn_end.durationMs` source. */
+  turnStartedAt = 0;
   /** The opencode-assigned session id, once any event has carried it. */
   get sessionId() {
     return this.latchedSessionId;
@@ -695,6 +699,7 @@ var OpenCodeEventSource = class {
   }
   beginBusTurn() {
     this.active = true;
+    this.turnStartedAt = Date.now();
     this.lastLivenessAt = Number.NEGATIVE_INFINITY;
     this.usage = { inputTokens: 0, outputTokens: 0, totalCostUsd: 0 };
     this.assistantText = "";
@@ -709,7 +714,17 @@ var OpenCodeEventSource = class {
     this.emit(
       error ? buildResultEvent(1, this.usage, "", "", error) : buildResultEvent(0, this.usage, this.assistantText.trim(), "")
     );
-    this.emitChat?.({ kind: "turn_end" });
+    this.emitChat?.({
+      kind: "turn_end",
+      durationMs: Math.max(0, Date.now() - this.turnStartedAt),
+      // opencode reports no cache split on the bus.
+      usage: {
+        input: Math.max(0, Math.floor(this.usage.inputTokens)),
+        output: Math.max(0, Math.floor(this.usage.outputTokens)),
+        cacheRead: 0,
+        cacheWrite: 0
+      }
+    });
   }
   relayAssistantPart(part) {
     if (part.type === "text") {
@@ -980,11 +995,11 @@ function mapTranscriptRecord(raw) {
 // src/harness/pty/jsonl-tailer.ts
 var POLL_INTERVAL_MS = 25;
 var JsonlTailer = class {
-  constructor(path, onEvent, onRawRecord, mapRecord = mapTranscriptRecord) {
+  constructor(path, onEvent, onRawRecord, mapRecord2 = mapTranscriptRecord) {
     this.path = path;
     this.onEvent = onEvent;
     this.onRawRecord = onRawRecord;
-    this.mapRecord = mapRecord;
+    this.mapRecord = mapRecord2;
   }
   path;
   onEvent;
@@ -1093,6 +1108,12 @@ var CodexEventSource = class {
   transcript = null;
   /** Last reported reading per rate-limit window, keyed by `five_hour` / `seven_day`. */
   windows = /* @__PURE__ */ new Map();
+  /** Per-turn chat metadata for the `turn_end` event (see `turnEnd`). */
+  turnStartedAt = null;
+  turnModel;
+  /** Latest cumulative `total_token_usage`, and its value when the turn began. */
+  latestTotal;
+  turnBaseline;
   handleRecord(raw) {
     if (!raw || typeof raw !== "object") return;
     const e = raw;
@@ -1114,6 +1135,8 @@ var CodexEventSource = class {
     if (e.hook_event_name === "UserPromptSubmit") {
       this.turnOpen = true;
       this.lastLivenessAt = Date.now();
+      this.turnStartedAt = this.lastLivenessAt;
+      this.turnBaseline = this.latestTotal;
       this.emit({ type: "tool_progress", tool_name: "Codex", elapsed_time_seconds: 0 });
       if (typeof e.prompt === "string")
         this.chat({ kind: "user_text", text: e.prompt.slice(0, 16e3) });
@@ -1128,7 +1151,7 @@ var CodexEventSource = class {
     } else if (e.hook_event_name === "Interrupt") {
       this.turnOpen = false;
       this.emit({ type: "result", subtype: "error", errors: ["Codex turn interrupted"] });
-      this.chat({ kind: "turn_end" });
+      this.chat(this.turnEnd());
     }
   }
   async close() {
@@ -1161,6 +1184,7 @@ var CodexEventSource = class {
     if (!record.payload || typeof record.payload !== "object") return;
     const event = record.payload;
     if (event.type !== "task_complete") this.emitLiveness();
+    this.trackTurnMetadata(record.type, event);
     if (record.type !== "event_msg") return;
     if (event.type === "token_count") {
       this.handleTokenCount(event);
@@ -1178,7 +1202,63 @@ var CodexEventSource = class {
       subtype: "error",
       errors: [redact(String(error.message ?? "Codex turn failed")).output]
     });
-    this.chat({ kind: "turn_end" });
+    this.chat(this.turnEnd());
+  }
+  /** Model (`turn_context`) and usage (`token_count`) for the chat turn_end. */
+  trackTurnMetadata(recordType, event) {
+    if (recordType === "turn_context" && typeof event.model === "string") {
+      this.turnModel = event.model.slice(0, 200);
+    } else if (recordType === "event_msg" && event.type === "token_count") {
+      this.addTurnUsage(event);
+    }
+  }
+  /**
+   * `token_count.info.total_token_usage` is cumulative for the session, so the
+   * turn's usage is its growth since the prompt — robust to repeated
+   * `token_count` events (rate-limit refreshes resend the same info). Codex
+   * counts cached input inside `input_tokens`; it is split out to match the
+   * Claude shape.
+   */
+  addTurnUsage(event) {
+    const info = event.info;
+    if (!info || typeof info !== "object") return;
+    const total = info.total_token_usage;
+    if (!total || typeof total !== "object") return;
+    const count = (key) => {
+      const value = total[key];
+      return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+    };
+    const cached = count("cached_input_tokens");
+    this.latestTotal = {
+      input: Math.max(0, count("input_tokens") - cached),
+      output: count("output_tokens"),
+      cacheRead: cached,
+      cacheWrite: 0
+    };
+  }
+  /** Usage since the turn's prompt, or undefined when no reading arrived. */
+  turnUsage() {
+    const latest = this.latestTotal;
+    if (!latest || latest === this.turnBaseline) return void 0;
+    const base = this.turnBaseline ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    return {
+      input: Math.max(0, latest.input - base.input),
+      output: Math.max(0, latest.output - base.output),
+      cacheRead: Math.max(0, latest.cacheRead - base.cacheRead),
+      cacheWrite: 0
+    };
+  }
+  /** The `turn_end` chat event with whatever turn metadata is known; resets it. */
+  turnEnd() {
+    const event = { kind: "turn_end" };
+    if (this.turnStartedAt !== null)
+      event.durationMs = Math.max(0, Date.now() - this.turnStartedAt);
+    if (this.turnModel !== void 0) event.model = this.turnModel;
+    const usage = this.turnUsage();
+    if (usage !== void 0) event.usage = usage;
+    this.turnStartedAt = null;
+    this.turnBaseline = this.latestTotal;
+    return event;
   }
   /**
    * `token_count` carries the account's rate-limit gauges on every turn:
@@ -1266,10 +1346,12 @@ var CodexEventSource = class {
         type: "assistant",
         message: { role: "assistant", content: [{ type: "text", text }] }
       });
-      this.chat({ kind: "assistant_text", text: text.slice(0, 16e3) });
+      const reply = { kind: "assistant_text", text: text.slice(0, 16e3) };
+      if (this.turnModel !== void 0) reply.model = this.turnModel;
+      this.chat(reply);
     }
     this.emit({ type: "result", subtype: "success", result: text, total_cost_usd: 0 });
-    this.chat({ kind: "turn_end" });
+    this.chat(this.turnEnd());
   }
 };
 
@@ -1467,192 +1549,9 @@ var HookSocketServer = class {
   }
 };
 
-// src/harness/pty/limit-banner.ts
-var BANNER_RE = /you'?(?:ve| have) (?:hit|reached) your ([\w-]+ )?(?:usage )?limit/i;
-var RESET_RE = /resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(UTC\)/i;
-function nextUtcOccurrenceSeconds(hour12, minute, meridiem, nowMs) {
-  let hour = hour12 % 12;
-  if (meridiem.toLowerCase() === "pm") hour += 12;
-  const candidate = new Date(nowMs);
-  candidate.setUTCHours(hour, minute, 0, 0);
-  if (candidate.getTime() <= nowMs) candidate.setUTCDate(candidate.getUTCDate() + 1);
-  return Math.floor(candidate.getTime() / 1e3);
-}
-function matchUsageLimitBanner(text, now = Date.now()) {
-  const banner = BANNER_RE.exec(text);
-  if (!banner) return null;
-  const qualifier = banner[1]?.trim().toLowerCase();
-  const rateLimitType = qualifier === "weekly" ? "seven_day" : "five_hour";
-  const reset = RESET_RE.exec(text);
-  return {
-    rateLimitType,
-    ...reset ? {
-      resetsAtEpochSeconds: nextUtcOccurrenceSeconds(
-        Number(reset[1]),
-        reset[2] ? Number(reset[2]) : 0,
-        reset[3],
-        now
-      )
-    } : {}
-  };
-}
-
-// src/harness/pty/chat-record-mapper.ts
-var TEXT_MAX = 16e3;
-var TOOL_INPUT_MAX = 1900;
-var TOOL_OUTPUT_MAX = 1900;
-var QUESTION_INPUT_MAX = 16e3;
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
-}
-function isUnknownArray2(value) {
-  return Array.isArray(value);
-}
-function stringField2(record, ...keys) {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string") return value;
-  }
-  return void 0;
-}
-function truncate2(text, max) {
-  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
-}
-function compactQuestionsJson(questions) {
-  const serialize = (qs) => JSON.stringify({ questions: qs });
-  const withDescriptions = (max) => questions.map((q) => ({
-    ...q,
-    options: q.options.map((o) => ({ ...o, description: truncate2(o.description, max) }))
-  }));
-  const full = serialize(questions);
-  if (full.length <= QUESTION_INPUT_MAX) return full;
-  for (const max of [2e3, 600, 80, 0]) {
-    const shortened = serialize(withDescriptions(max));
-    if (shortened.length <= QUESTION_INPUT_MAX) return shortened;
-  }
-  return serialize(withDescriptions(0)).slice(0, QUESTION_INPUT_MAX);
-}
-function compactToolInput(name, input) {
-  if (name === "AskUserQuestion" && isRecord2(input)) {
-    const questions = parseUserQuestions(input);
-    if (questions.length > 0) return compactQuestionsJson(questions);
-  }
-  return JSON.stringify(input ?? {}).slice(0, TOOL_INPUT_MAX);
-}
-var TASK_NOTIFICATION_PREFIX = "<task-notification>";
-function isNonConversationText(text) {
-  const trimmed = text.trimStart();
-  return trimmed.startsWith("<command-name>") || trimmed.startsWith("<local-command-") || trimmed.startsWith(TASK_NOTIFICATION_PREFIX);
-}
-function userRecordText(record) {
-  const message = record.message;
-  if (!isRecord2(message)) return void 0;
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (!isUnknownArray2(content)) return void 0;
-  if (content.some((b) => isRecord2(b) && b.type === "tool_result")) return void 0;
-  return content.filter((b) => isRecord2(b) && b.type === "text").map((b) => typeof b.text === "string" ? b.text : "").filter((t) => t.length > 0).join("\n");
-}
-function isBackgroundTaskNotificationRecord(raw) {
-  if (!isRecord2(raw) || raw.type !== "user") return false;
-  if (raw.isSidechain === true || raw.isMeta === true) return false;
-  const text = userRecordText(raw);
-  return text !== void 0 && text.trimStart().startsWith(TASK_NOTIFICATION_PREFIX);
-}
-function mapSystem2(record) {
-  if (record.subtype === "init") {
-    const event = {
-      kind: "init",
-      model: stringField2(record, "model") ?? ""
-    };
-    const sessionId = stringField2(record, "session_id", "sessionId");
-    if (sessionId !== void 0) event.claudeSessionId = sessionId;
-    return [event];
-  }
-  if (record.subtype === "turn_duration") return [{ kind: "turn_end" }];
-  return [];
-}
-function mapAssistant2(record) {
-  const message = record.message;
-  if (!isRecord2(message)) return [];
-  const content = isUnknownArray2(message.content) ? message.content : [];
-  const events = [];
-  for (const raw of content) {
-    if (!isRecord2(raw)) continue;
-    if (raw.type === "text") {
-      const text = stringField2(raw, "text");
-      if (text && text.length > 0) {
-        events.push({ kind: "assistant_text", text: truncate2(text, TEXT_MAX) });
-      }
-    } else if (raw.type === "tool_use") {
-      const name = stringField2(raw, "name");
-      if (name) {
-        const input = "input" in raw ? raw.input : void 0;
-        const event = {
-          kind: "tool_use",
-          name: truncate2(name, 200),
-          input: compactToolInput(name, input)
-        };
-        const id = stringField2(raw, "id");
-        if (id !== void 0) event.id = id;
-        events.push(event);
-      }
-    }
-  }
-  return events;
-}
-function toolResultText(block) {
-  const content = block.content;
-  if (typeof content === "string") return content;
-  if (isUnknownArray2(content)) {
-    return content.filter((b) => isRecord2(b) && b.type === "text").map((b) => typeof b.text === "string" ? b.text : "").filter((t) => t.length > 0).join("\n");
-  }
-  return "";
-}
-function mapToolResults(content) {
-  const events = [];
-  for (const raw of content) {
-    if (!isRecord2(raw) || raw.type !== "tool_result") continue;
-    const event = {
-      kind: "tool_result",
-      output: truncate2(toolResultText(raw), TOOL_OUTPUT_MAX),
-      isError: raw.is_error === true
-    };
-    const toolUseId = stringField2(raw, "tool_use_id");
-    if (toolUseId !== void 0) event.toolUseId = toolUseId;
-    events.push(event);
-  }
-  return events;
-}
-function mapUser(record) {
-  const message = record.message;
-  if (!isRecord2(message)) return [];
-  const content = message.content;
-  if (isUnknownArray2(content) && content.some((b) => isRecord2(b) && b.type === "tool_result")) {
-    return mapToolResults(content);
-  }
-  const text = userRecordText(record);
-  if (text === void 0) return [];
-  const trimmed = text.trim();
-  if (trimmed.length === 0 || isNonConversationText(trimmed)) return [];
-  return [{ kind: "user_text", text: truncate2(trimmed, TEXT_MAX) }];
-}
-function mapChatRecords(raw) {
-  if (!isRecord2(raw)) return [];
-  if (raw.isSidechain === true || raw.isMeta === true) return [];
-  switch (raw.type) {
-    case "system":
-      return mapSystem2(raw);
-    case "assistant":
-      return mapAssistant2(raw);
-    case "user":
-      return mapUser(raw);
-    case "result":
-      return [{ kind: "turn_end" }];
-    default:
-      return [];
-  }
-}
+// src/harness/pty/model-switch.ts
+import { readFile, writeFile as writeFile4 } from "fs/promises";
+import { join as join4 } from "path";
 
 // src/harness/pty/settings.ts
 import { mkdir, writeFile as writeFile3, chmod } from "fs/promises";
@@ -1917,6 +1816,453 @@ async function writeHookSettings(dir, opts = {}) {
   return { settingsPath, helperPath };
 }
 
+// src/harness/pty/model-switch.ts
+var SWITCH_COMMAND_GAP_MS = 800;
+var RESTORE_RECHECK_MS = 3e3;
+var PERSISTED_KEYS = ["model", "modelSettings"];
+var defaultSleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+async function readSettings(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch {
+    return { state: "missing" };
+  }
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? { state: "ok", data: parsed } : { state: "invalid" };
+  } catch {
+    return { state: "invalid" };
+  }
+}
+async function restorePersistedModelKeys(path, before) {
+  if (before.state === "invalid") return;
+  const current = await readSettings(path);
+  if (current.state !== "ok") return;
+  const prior = before.state === "ok" ? before.data : {};
+  let changed = false;
+  for (const key of PERSISTED_KEYS) {
+    if (JSON.stringify(current.data[key]) === JSON.stringify(prior[key])) continue;
+    if (prior[key] === void 0) delete current.data[key];
+    else current.data[key] = prior[key];
+    changed = true;
+  }
+  if (changed) await writeFile4(path, `${JSON.stringify(current.data, null, 2)}
+`, "utf8");
+}
+var ModelSwitchQueue = class {
+  constructor(host) {
+    this.host = host;
+  }
+  host;
+  pending = null;
+  flushing = null;
+  /** A switch request from the relay. Applied now when idle, else queued. */
+  request(switchTo) {
+    this.pending = { ...this.pending, ...switchTo };
+    if (!this.host.commands(this.pending)) {
+      const deferred = this.pending;
+      this.pending = null;
+      this.host.deferred(deferred);
+      return;
+    }
+    if (this.host.canWriteNow()) void this.flush();
+  }
+  /** True while switch commands are being typed. */
+  get busy() {
+    return this.flushing !== null;
+  }
+  /** Resolves once any in-flight switch finished typing (and was recorded). */
+  async settle() {
+    while (this.flushing) await this.flushing;
+  }
+  /** Turn boundary: write any queued switch. Safe to call when nothing is queued. */
+  flush() {
+    if (this.flushing) return this.flushing;
+    if (!this.pending || !this.host.canWriteNow()) return Promise.resolve();
+    const switchTo = this.pending;
+    this.pending = null;
+    this.flushing = this.write(switchTo).finally(() => {
+      this.flushing = null;
+      if (this.pending) void this.flush();
+    });
+    return this.flushing;
+  }
+  async write(switchTo) {
+    const commands = this.host.commands(switchTo) ?? [];
+    const sleep2 = this.host.sleep ?? defaultSleep;
+    const path = this.host.settingsPath ?? join4(claudeConfigHome(), "settings.json");
+    const before = await readSettings(path);
+    for (const command of commands) {
+      this.host.write(this.host.encode(command));
+      await sleep2(SUBMIT_SETTLE_MS);
+      this.host.write("\r");
+      await sleep2(SWITCH_COMMAND_GAP_MS);
+    }
+    await restorePersistedModelKeys(path, before);
+    this.host.applied(switchTo);
+    void sleep2(RESTORE_RECHECK_MS).then(() => restorePersistedModelKeys(path, before)).catch(() => void 0);
+  }
+};
+
+// src/harness/pty/limit-banner.ts
+var BANNER_RE = /you'?(?:ve| have) (?:hit|reached) your ([\w-]+ )?(?:usage )?limit/i;
+var RESET_RE = /resets?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(UTC\)/i;
+function nextUtcOccurrenceSeconds(hour12, minute, meridiem, nowMs) {
+  let hour = hour12 % 12;
+  if (meridiem.toLowerCase() === "pm") hour += 12;
+  const candidate = new Date(nowMs);
+  candidate.setUTCHours(hour, minute, 0, 0);
+  if (candidate.getTime() <= nowMs) candidate.setUTCDate(candidate.getUTCDate() + 1);
+  return Math.floor(candidate.getTime() / 1e3);
+}
+function matchUsageLimitBanner(text, now = Date.now()) {
+  const banner = BANNER_RE.exec(text);
+  if (!banner) return null;
+  const qualifier = banner[1]?.trim().toLowerCase();
+  const rateLimitType = qualifier === "weekly" ? "seven_day" : "five_hour";
+  const reset = RESET_RE.exec(text);
+  return {
+    rateLimitType,
+    ...reset ? {
+      resetsAtEpochSeconds: nextUtcOccurrenceSeconds(
+        Number(reset[1]),
+        reset[2] ? Number(reset[2]) : 0,
+        reset[3],
+        now
+      )
+    } : {}
+  };
+}
+
+// src/harness/pty/chat-turn-accumulator.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function tokenCount(usage, key) {
+  const value = usage[key];
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function countPatchLines(patch) {
+  let added = 0;
+  let removed = 0;
+  for (const hunk of patch) {
+    if (!isRecord2(hunk) || !Array.isArray(hunk.lines)) continue;
+    for (const line of hunk.lines) {
+      if (typeof line !== "string") continue;
+      if (line.startsWith("+")) added += 1;
+      else if (line.startsWith("-")) removed += 1;
+    }
+  }
+  return { added, removed };
+}
+function countContentLines(content) {
+  if (content.length === 0) return 0;
+  const lines = content.split("\n");
+  return content.endsWith("\n") ? lines.length - 1 : lines.length;
+}
+function editStatsFromToolResult(result) {
+  if (!isRecord2(result)) return void 0;
+  const filePath = result.filePath;
+  if (typeof filePath !== "string" || filePath.length === 0) return void 0;
+  const patch = result.structuredPatch;
+  if (Array.isArray(patch) && patch.length > 0) {
+    return { filePath, ...countPatchLines(patch) };
+  }
+  if (result.type === "create" && typeof result.content === "string") {
+    return { filePath, added: countContentLines(result.content), removed: 0 };
+  }
+  if (Array.isArray(patch)) return { filePath, added: 0, removed: 0 };
+  return void 0;
+}
+function relativePath(filePath, root) {
+  const prefix = root?.replace(/\/+$/, "");
+  if (prefix && filePath.startsWith(`${prefix}/`)) return filePath.slice(prefix.length + 1);
+  return filePath;
+}
+function maxUsage(a, b) {
+  return {
+    input: Math.max(a.input, b.input),
+    output: Math.max(a.output, b.output),
+    cacheRead: Math.max(a.cacheRead, b.cacheRead),
+    cacheWrite: Math.max(a.cacheWrite, b.cacheWrite)
+  };
+}
+function sumUsage(readings) {
+  const total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  for (const r of readings) {
+    total.input += r.input;
+    total.output += r.output;
+    total.cacheRead += r.cacheRead;
+    total.cacheWrite += r.cacheWrite;
+  }
+  return total;
+}
+var ChatTurnAccumulator = class {
+  model;
+  // The CLI writes one transcript record per content block and repeats the
+  // message's usage on each (possibly as a growing streaming snapshot), so
+  // usage is keyed by message id and the largest reading per id wins.
+  usageByMessage = /* @__PURE__ */ new Map();
+  anonymousMessages = 0;
+  files = /* @__PURE__ */ new Map();
+  /** Fold one assistant `message` into the turn. */
+  addAssistantMessage(message) {
+    if (typeof message.model === "string" && message.model.length > 0) {
+      if (message.model !== "<synthetic>") this.model = message.model;
+    }
+    const usage = message.usage;
+    if (!isRecord2(usage)) return;
+    const reading = {
+      input: tokenCount(usage, "input_tokens"),
+      output: tokenCount(usage, "output_tokens"),
+      cacheRead: tokenCount(usage, "cache_read_input_tokens"),
+      cacheWrite: tokenCount(usage, "cache_creation_input_tokens")
+    };
+    const id = typeof message.id === "string" ? message.id : `anon-${this.anonymousMessages++}`;
+    const previous = this.usageByMessage.get(id);
+    this.usageByMessage.set(id, previous ? maxUsage(previous, reading) : reading);
+  }
+  /** Fold one user record's record-level `toolUseResult` into the file stats. */
+  addToolUseResult(result, root) {
+    const stats = editStatsFromToolResult(result);
+    if (!stats) return;
+    const path = relativePath(stats.filePath, root).slice(0, 500);
+    const existing = this.files.get(path);
+    if (existing) {
+      existing.added += stats.added;
+      existing.removed += stats.removed;
+      return;
+    }
+    if (this.files.size >= PTY_CHAT_TURN_FILES_MAX) return;
+    this.files.set(path, { path, added: stats.added, removed: stats.removed });
+  }
+  /** Return the turn's aggregates and reset for the next turn. */
+  drain() {
+    const result = {};
+    if (this.model !== void 0) result.model = this.model.slice(0, 200);
+    if (this.usageByMessage.size > 0) result.usage = sumUsage(this.usageByMessage.values());
+    if (this.files.size > 0) result.files = [...this.files.values()];
+    this.reset();
+    return result;
+  }
+  reset() {
+    this.model = void 0;
+    this.usageByMessage.clear();
+    this.anonymousMessages = 0;
+    this.files.clear();
+  }
+};
+
+// src/harness/pty/chat-record-mapper.ts
+var TEXT_MAX = 16e3;
+var TOOL_INPUT_MAX = 1900;
+var TOOL_OUTPUT_MAX = 1900;
+var QUESTION_INPUT_MAX = 16e3;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function isUnknownArray2(value) {
+  return Array.isArray(value);
+}
+function stringField2(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function truncate2(text, max) {
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function compactQuestionsJson(questions) {
+  const serialize = (qs) => JSON.stringify({ questions: qs });
+  const withDescriptions = (max) => questions.map((q) => ({
+    ...q,
+    options: q.options.map((o) => ({ ...o, description: truncate2(o.description, max) }))
+  }));
+  const full = serialize(questions);
+  if (full.length <= QUESTION_INPUT_MAX) return full;
+  for (const max of [2e3, 600, 80, 0]) {
+    const shortened = serialize(withDescriptions(max));
+    if (shortened.length <= QUESTION_INPUT_MAX) return shortened;
+  }
+  return serialize(withDescriptions(0)).slice(0, QUESTION_INPUT_MAX);
+}
+function compactToolInput(name, input) {
+  if (name === "AskUserQuestion" && isRecord3(input)) {
+    const questions = parseUserQuestions(input);
+    if (questions.length > 0) return compactQuestionsJson(questions);
+  }
+  return JSON.stringify(input ?? {}).slice(0, TOOL_INPUT_MAX);
+}
+var TASK_NOTIFICATION_PREFIX = "<task-notification>";
+function isNonConversationText(text) {
+  const trimmed = text.trimStart();
+  return trimmed.startsWith("<command-name>") || trimmed.startsWith("<local-command-") || trimmed.startsWith(TASK_NOTIFICATION_PREFIX);
+}
+function userRecordText(record) {
+  const message = record.message;
+  if (!isRecord3(message)) return void 0;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!isUnknownArray2(content)) return void 0;
+  if (content.some((b) => isRecord3(b) && b.type === "tool_result")) return void 0;
+  return content.filter((b) => isRecord3(b) && b.type === "text").map((b) => typeof b.text === "string" ? b.text : "").filter((t) => t.length > 0).join("\n");
+}
+function backgroundTaskCompletion(raw) {
+  if (!isRecord3(raw) || raw.isSidechain === true || raw.isMeta === true) return null;
+  const text = notificationText(raw);
+  if (text === void 0 || !text.trimStart().startsWith(TASK_NOTIFICATION_PREFIX)) return null;
+  const taskId = /<task-id>([^<]+)<\/task-id>/.exec(text)?.[1]?.trim();
+  return { taskId: taskId || null };
+}
+function notificationText(record) {
+  if (record.type === "user") return userRecordText(record);
+  if (record.type !== "attachment") return void 0;
+  const attachment = record.attachment;
+  if (!isRecord3(attachment) || attachment.commandMode !== "task-notification") return void 0;
+  return typeof attachment.prompt === "string" ? attachment.prompt : void 0;
+}
+function mapSystem2(record) {
+  if (record.subtype === "init") {
+    const event = {
+      kind: "init",
+      model: stringField2(record, "model") ?? ""
+    };
+    const sessionId = stringField2(record, "session_id", "sessionId");
+    if (sessionId !== void 0) event.claudeSessionId = sessionId;
+    return [event];
+  }
+  if (record.subtype === "turn_duration") {
+    const event = { kind: "turn_end" };
+    const durationMs = record.durationMs;
+    if (typeof durationMs === "number" && Number.isFinite(durationMs) && durationMs >= 0) {
+      event.durationMs = Math.round(durationMs);
+    }
+    return [event];
+  }
+  return [];
+}
+function mapAssistant2(record) {
+  const message = record.message;
+  if (!isRecord3(message)) return [];
+  const content = isUnknownArray2(message.content) ? message.content : [];
+  const model = stringField2(message, "model");
+  const events = [];
+  for (const raw of content) {
+    if (!isRecord3(raw)) continue;
+    if (raw.type === "text") {
+      const text = stringField2(raw, "text");
+      if (text && text.length > 0) {
+        const event = {
+          kind: "assistant_text",
+          text: truncate2(text, TEXT_MAX)
+        };
+        if (model && model !== "<synthetic>") event.model = truncate2(model, 200);
+        events.push(event);
+      }
+    } else if (raw.type === "tool_use") {
+      const name = stringField2(raw, "name");
+      if (name) {
+        const input = "input" in raw ? raw.input : void 0;
+        const event = {
+          kind: "tool_use",
+          name: truncate2(name, 200),
+          input: compactToolInput(name, input)
+        };
+        const id = stringField2(raw, "id");
+        if (id !== void 0) event.id = id;
+        events.push(event);
+      }
+    }
+  }
+  return events;
+}
+function toolResultText(block) {
+  const content = block.content;
+  if (typeof content === "string") return content;
+  if (isUnknownArray2(content)) {
+    return content.filter((b) => isRecord3(b) && b.type === "text").map((b) => typeof b.text === "string" ? b.text : "").filter((t) => t.length > 0).join("\n");
+  }
+  return "";
+}
+function mapToolResults(content) {
+  const events = [];
+  for (const raw of content) {
+    if (!isRecord3(raw) || raw.type !== "tool_result") continue;
+    const event = {
+      kind: "tool_result",
+      output: truncate2(toolResultText(raw), TOOL_OUTPUT_MAX),
+      isError: raw.is_error === true
+    };
+    const toolUseId = stringField2(raw, "tool_use_id");
+    if (toolUseId !== void 0) event.toolUseId = toolUseId;
+    events.push(event);
+  }
+  return events;
+}
+function mapUser(record) {
+  const message = record.message;
+  if (!isRecord3(message)) return [];
+  const content = message.content;
+  if (isUnknownArray2(content) && content.some((b) => isRecord3(b) && b.type === "tool_result")) {
+    return mapToolResults(content);
+  }
+  const text = userRecordText(record);
+  if (text === void 0) return [];
+  const trimmed = text.trim();
+  if (trimmed.length === 0 || isNonConversationText(trimmed)) return [];
+  return [{ kind: "user_text", text: truncate2(trimmed, TEXT_MAX) }];
+}
+function mapRecord(raw) {
+  switch (raw.type) {
+    case "system":
+      return mapSystem2(raw);
+    case "assistant":
+      return mapAssistant2(raw);
+    case "user":
+      return mapUser(raw);
+    case "result":
+      return [{ kind: "turn_end" }];
+    default:
+      return [];
+  }
+}
+function isChatRecord(raw) {
+  return isRecord3(raw) && raw.isSidechain !== true && raw.isMeta !== true;
+}
+function mapChatRecords(raw) {
+  if (!isChatRecord(raw)) return [];
+  const events = mapRecord(raw);
+  const at = stringField2(raw, "timestamp");
+  if (at !== void 0 && at.length <= 40) {
+    for (const event of events) event.at = at;
+  }
+  return events;
+}
+function createChatRecordMapper(rootDir) {
+  const turn = new ChatTurnAccumulator();
+  return {
+    map(raw) {
+      const events = mapChatRecords(raw);
+      if (!isChatRecord(raw)) return events;
+      if (raw.type === "assistant" && isRecord3(raw.message)) {
+        turn.addAssistantMessage(raw.message);
+      } else if (raw.type === "user") {
+        if ("toolUseResult" in raw) turn.addToolUseResult(raw.toolUseResult, rootDir?.());
+        if (events.some((e) => e.kind === "user_text")) turn.reset();
+      }
+      for (const event of events) {
+        if (event.kind === "turn_end") Object.assign(event, turn.drain());
+      }
+      return events;
+    }
+  };
+}
+
 // src/harness/pty/output-coalescer.ts
 var DEFAULT_FLUSH_MS = 40;
 var DEFAULT_MAX_BUFFER_CHARS = 48 * 1024;
@@ -1972,8 +2318,8 @@ var PtyOutputCoalescer = class {
 // src/harness/pty/tool-server.ts
 import { createServer as createServer2 } from "http";
 import { z as z2 } from "zod";
-import { writeFile as writeFile4 } from "fs/promises";
-import { join as join4 } from "path";
+import { writeFile as writeFile5 } from "fs/promises";
+import { join as join5 } from "path";
 import { randomBytes } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -2164,21 +2510,21 @@ async function startToolServers(mcpServers, tempDir) {
     config[name] = { type: "http", url, headers: { Authorization: `Bearer ${token}` } };
   }
   if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null, entries: config };
-  const mcpConfigPath = join4(tempDir, "mcp-config.json");
-  await writeFile4(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
+  const mcpConfigPath = join5(tempDir, "mcp-config.json");
+  await writeFile5(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
   return { servers, mcpConfigPath, entries: config };
 }
 
 // src/harness/pty/credentials.ts
-import { chmod as chmod2, mkdir as mkdir2, readFile, rm, writeFile as writeFile5 } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile2, rm, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/harness/pty/credentials-marker.ts
 import { createHash } from "crypto";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function conveyorCredentialsMarkerPath() {
-  return join5(claudeConfigHome(), ".conveyor-credentials.json");
+  return join6(claudeConfigHome(), ".conveyor-credentials.json");
 }
 function tokenFingerprint(accessToken) {
   return createHash("sha256").update(accessToken).digest("hex");
@@ -2374,14 +2720,14 @@ function planCredentialsWrite(input) {
 
 // src/harness/pty/credentials.ts
 function claudeCredentialsPath() {
-  return join6(claudeConfigHome(), ".credentials.json");
+  return join7(claudeConfigHome(), ".credentials.json");
 }
 function isConveyorCloudEnv(env = process.env) {
   return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
 }
 async function readRaw(path) {
   try {
-    return await readFile(path, "utf8");
+    return await readFile2(path, "utf8");
   } catch {
     return null;
   }
@@ -2410,11 +2756,11 @@ async function readCredentialsIdentity(env = process.env) {
   );
 }
 var READ_BACK_DELAYS_MS = [250, 500, 1e3, 2e3];
-var defaultSleep = (ms) => new Promise((resolve) => {
+var defaultSleep2 = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
 });
 async function writeWithReadBackRetry(io, contents, delaysMs = READ_BACK_DELAYS_MS) {
-  const sleep2 = io.sleep ?? defaultSleep;
+  const sleep2 = io.sleep ?? defaultSleep2;
   for (let attempt = 0; ; attempt++) {
     await io.write(contents);
     if (await io.read() === contents) return true;
@@ -2424,7 +2770,7 @@ async function writeWithReadBackRetry(io, contents, delaysMs = READ_BACK_DELAYS_
 }
 function fsWriteIo(path, mode) {
   return {
-    write: (contents) => writeFile5(path, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
+    write: (contents) => writeFile6(path, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
     read: () => readRaw(path)
   };
 }
@@ -2504,7 +2850,7 @@ async function sanitizeApprovedApiKeys(oauthToken) {
 }
 function claudeJsonPath() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
-  return configDir ? join6(configDir, ".claude.json") : join6(homedir2(), ".claude.json");
+  return configDir ? join7(configDir, ".claude.json") : join7(homedir2(), ".claude.json");
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
@@ -2597,7 +2943,7 @@ function planClaudeJsonSeed(existingRaw, trustCwd, oauthIdentity) {
   return changed ? JSON.stringify(config) : null;
 }
 function conveyorOauthMarkerPath() {
-  return join6(claudeConfigHome(), "conveyor-oauth-account.json");
+  return join7(claudeConfigHome(), "conveyor-oauth-account.json");
 }
 function parseOauthIdentity(raw) {
   if (!raw || raw.trim() === "") return null;
@@ -2696,6 +3042,7 @@ var ClaudeTuiAdapter = class {
       ...resume ? { resume } : {},
       ...options.sessionId ? { sessionId: options.sessionId } : {},
       model: options.model,
+      ...options.effort ? { effort: options.effort } : {},
       permissionMode: options.permissionMode,
       settingsPath: input.settingsPath ?? "",
       ...options.appendSystemPrompt ? { appendSystemPrompt: options.appendSystemPrompt } : {},
@@ -2719,6 +3066,13 @@ var ClaudeTuiAdapter = class {
   encodePromptBytes(text) {
     return buildPromptBytes(text);
   }
+  /** `/model` and `/effort` apply inline (verified on claude 2.1.280). */
+  modelSwitchCommands(switchTo) {
+    return [
+      ...switchTo.model ? [`/model ${switchTo.model}`] : [],
+      ...switchTo.effort ? [`/effort ${switchTo.effort}`] : []
+    ];
+  }
   buildExitErrors(exitCode, rawOutput) {
     return buildExitErrors(exitCode, rawOutput, this.resolveBinary());
   }
@@ -2799,6 +3153,19 @@ var PtySession = class {
   rows = 40;
   unsubInput = null;
   unsubResize = null;
+  unsubModelEffort = null;
+  turnsBegun = 0;
+  // Live model/effort switch from the composer pill: typed as the CLI's own
+  // slash commands between turns. Closures read `this` lazily (class fields
+  // initialize before parameter properties).
+  modelSwitch = new ModelSwitchQueue({
+    canWriteNow: () => !this._toreDown && this.pty !== null && this.activeQueue === null && !this.questionnairePending,
+    write: (bytes) => this.writeStdin(bytes),
+    encode: (text) => this.adapter.encodePromptBytes(text),
+    commands: (switchTo) => this.adapter.modelSwitchCommands?.(switchTo) ?? null,
+    applied: (switchTo) => this.onModelSwitched(switchTo, true),
+    deferred: (switchTo) => this.onModelSwitched(switchTo, false)
+  });
   // In-process HTTP MCP servers exposing the harness tools to the spawned CLI,
   // plus the path to the `--mcp-config` that points at them.
   toolServers = [];
@@ -2829,6 +3196,11 @@ var PtySession = class {
   // synthetic id so the card flips to answered.
   pendingSyntheticQuestionIds = [];
   questionResultRemap = /* @__PURE__ */ new Map();
+  // Chat projection with a per-turn accumulator (usage, model, edited files
+  // ride the turn_end event), so it must live as long as the process.
+  // Edited-file paths are made relative to the spawn cwd (the repo root), read
+  // lazily because class fields initialize before parameter properties.
+  chatMapper = createChatRecordMapper(() => this.options.cwd);
   // An AskUserQuestion questionnaire is parked on screen (PreToolUse hook
   // fired, no PostToolUse envelope yet). While set the parked process must
   // not be reused: feeding follow-up prompt bytes into the live dialog would
@@ -2916,6 +3288,7 @@ var PtySession = class {
   get spawnFingerprint() {
     return this.adapter.spawnFingerprint({
       model: this.options.model,
+      ...this.options.effort ? { effort: this.options.effort } : {},
       permissionMode: this.options.permissionMode,
       ...this.options.appendSystemPrompt ? { appendSystemPrompt: this.options.appendSystemPrompt } : {},
       cwd: this.options.cwd
@@ -2978,6 +3351,7 @@ var PtySession = class {
    * the prompt into the live pty. The caller must have verified canReuse().
    */
   async beginTurn(prompt, options) {
+    this.turnsBegun += 1;
     this.prewarmed = false;
     this.turnPrompt = prompt;
     this.turn = turnOptionsFrom(options);
@@ -3057,6 +3431,31 @@ var PtySession = class {
       this.turn.abortController.signal.removeEventListener("abort", this.abortHandler);
       this.abortHandler = null;
     }
+    void this.modelSwitch.flush();
+  }
+  /** Resolves once an in-flight model/effort switch finished typing — the
+   * harness awaits it before deciding whether this parked process is reusable. */
+  settleModelSwitch() {
+    return this.modelSwitch.settle();
+  }
+  /**
+   * Record a model/effort switch and tell the chat. A live switch also updates
+   * the spawn options so the recorded fingerprint matches the next turn's
+   * (which carries the same override) — the parked process is reused, not
+   * respawned.
+   */
+  onModelSwitched(switchTo, live) {
+    if (live) {
+      if (switchTo.model) this.options.model = switchTo.model;
+      if (switchTo.effort) this.options.effort = switchTo.effort;
+    }
+    const label = [switchTo.model, switchTo.effort && `effort ${switchTo.effort}`].filter(Boolean).join(" \xB7 ");
+    this.sendChatEvent({
+      kind: "user_text",
+      text: live ? `Switched to ${label}` : `Saved ${label} \u2014 applies on next wake`,
+      source: "model_switch",
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   async collectCodexPrompt() {
     if (this.adapter.id === "codex" && typeof this.turnPrompt !== "string") {
@@ -3106,7 +3505,7 @@ var PtySession = class {
         const { settingsPath, socketPath } = await this.startStructuredEventSources(sessionId);
         await this.spawn(settingsPath, socketPath);
       } else {
-        this.tempDir = await mkdtemp(join7(sessionTempBase(), "conveyor-pty-"));
+        this.tempDir = await mkdtemp(join8(sessionTempBase(), "conveyor-pty-"));
         await this.spawn();
         this.pushEvent({
           type: "system",
@@ -3128,6 +3527,7 @@ var PtySession = class {
       if (this.bridge) {
         if (feedPrompt) this.attachInput();
         this.unsubResize = this.bridge.onResize((cols, rows) => this.resizePty(cols, rows));
+        this.unsubModelEffort = this.bridge.onModelEffort?.((switchTo) => this.modelSwitch.request(switchTo)) ?? null;
       }
       if (feedPrompt) await this.feedPrompt();
     } catch (err) {
@@ -3151,7 +3551,7 @@ var PtySession = class {
    * moment it is known, which is how the runner learns the resume target.
    */
   async startCodexEventSources() {
-    this.tempDir = await mkdtemp(join7(sessionTempBase(), "conveyor-codex-"));
+    this.tempDir = await mkdtemp(join8(sessionTempBase(), "conveyor-codex-"));
     const { servers, entries } = await startToolServers(
       this.options.mcpServers ?? {},
       this.tempDir
@@ -3175,7 +3575,8 @@ var PtySession = class {
           claudeSessionId: id
         });
       },
-      (event) => this.sendChatEvent(event)
+      // No per-record transcript timestamp on this path; stamp emit time.
+      (event) => this.sendChatEvent({ ...event, at: event.at ?? (/* @__PURE__ */ new Date()).toISOString() })
     );
     this.codexSource = source;
     this.tailer = new JsonlTailer(
@@ -3188,7 +3589,7 @@ var PtySession = class {
     return { ...extras, mcpEntries: entries };
   }
   async startOpenCodeEventSources() {
-    this.tempDir = await mkdtemp(join7(sessionTempBase(), "conveyor-pty-"));
+    this.tempDir = await mkdtemp(join8(sessionTempBase(), "conveyor-pty-"));
     const { servers, entries } = await startToolServers(
       this.options.mcpServers ?? {},
       this.tempDir
@@ -3198,8 +3599,8 @@ var PtySession = class {
     let instructionsPath;
     const systemPrompt = this.options.appendSystemPrompt;
     if (systemPrompt && systemPrompt.trim() !== "") {
-      instructionsPath = join7(this.tempDir, "conveyor-instructions.md");
-      await writeFile6(instructionsPath, systemPrompt, "utf8");
+      instructionsPath = join8(this.tempDir, "conveyor-instructions.md");
+      await writeFile7(instructionsPath, systemPrompt, "utf8");
     }
     this.opencodeSource = new OpenCodeEventSource(
       (event) => this.handleTranscriptEvent(event),
@@ -3217,7 +3618,8 @@ var PtySession = class {
           claudeSessionId: id
         });
       },
-      (event) => this.sendChatEvent(event)
+      // No per-record transcript timestamp on this path; stamp emit time.
+      (event) => this.sendChatEvent({ ...event, at: event.at ?? (/* @__PURE__ */ new Date()).toISOString() })
     );
     this.tailer = new JsonlTailer(
       eventsSinkPath,
@@ -3241,8 +3643,8 @@ var PtySession = class {
    * paths spawn() must wire into the child's argv/env.
    */
   async startStructuredEventSources(sessionId) {
-    this.tempDir = await mkdtemp(join7(sessionTempBase(), "conveyor-pty-"));
-    const socketPath = join7(this.tempDir, "hook.sock");
+    this.tempDir = await mkdtemp(join8(sessionTempBase(), "conveyor-pty-"));
+    const socketPath = join8(this.tempDir, "hook.sock");
     this.socket = new HookSocketServer(
       socketPath,
       (progress) => this.handleProgress(progress),
@@ -3272,7 +3674,8 @@ var PtySession = class {
    * backgrounded gate/subagent just finished) and the chat-proxy projection.
    */
   handleRawRecord(raw) {
-    if (isBackgroundTaskNotificationRecord(raw)) this.bridge?.notifyBackgroundTaskDone?.();
+    const completion = backgroundTaskCompletion(raw);
+    if (completion) this.bridge?.notifyBackgroundTaskDone?.(completion.taskId);
     if (typeof this.bridge?.sendChatEvent === "function") this.relayChatRecord(raw);
   }
   /**
@@ -3283,7 +3686,7 @@ var PtySession = class {
    * live-rendered card is the one that flips to answered.
    */
   relayChatRecord(raw) {
-    for (const event of mapChatRecords(raw)) {
+    for (const event of this.chatMapper.map(raw)) {
       if (event.kind === "tool_use" && event.name === "AskUserQuestion") {
         const syntheticId = this.pendingSyntheticQuestionIds.shift();
         if (syntheticId) {
@@ -3415,6 +3818,8 @@ var PtySession = class {
     this.unsubInput = null;
     this.unsubResize?.();
     this.unsubResize = null;
+    this.unsubModelEffort?.();
+    this.unsubModelEffort = null;
     if (this.abortHandler) {
       this.turn.abortController?.signal.removeEventListener("abort", this.abortHandler);
       this.abortHandler = null;
@@ -3866,7 +4271,7 @@ var PtySession = class {
 // src/harness/pty/config-home-health.ts
 import { lstat, mkdir as mkdir4, symlink, unlink as unlink2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var MOUNT_DISCONNECT_CODES = /* @__PURE__ */ new Set(["ENOTCONN", "EIO", "ESTALE", "ENXIO"]);
 var MOUNT_DISCONNECT_MESSAGES = [
   "socket is not connected",
@@ -3882,10 +4287,10 @@ function isMountDisconnectError(err) {
   return MOUNT_DISCONNECT_MESSAGES.some((needle) => lower.includes(needle));
 }
 function podLocalConfigHome() {
-  return join8(homedir3(), ".claude-local");
+  return join9(homedir3(), ".claude-local");
 }
 function sharedConfigHomePath() {
-  return join8(homedir3(), ".claude");
+  return join9(homedir3(), ".claude");
 }
 function isConfigHomeFallbackActive() {
   return claudeConfigHome() === podLocalConfigHome();
@@ -3916,7 +4321,7 @@ async function repointSharedConfigHomeSymlink(fallback, log) {
 }
 async function isConfigHomeMountDead(cwd) {
   try {
-    await mkdir4(join8(claudeConfigHome(), "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join9(claudeConfigHome(), "projects", projectSlug(cwd)), { recursive: true });
     return false;
   } catch (err) {
     return isMountDisconnectError(err);
@@ -3925,7 +4330,7 @@ async function isConfigHomeMountDead(cwd) {
 async function ensureUsableClaudeConfigHome(cwd, log) {
   const configHome = claudeConfigHome();
   try {
-    await mkdir4(join8(configHome, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join9(configHome, "projects", projectSlug(cwd)), { recursive: true });
     return { configHome, fellBack: false };
   } catch (err) {
     if (!isMountDisconnectError(err)) throw err;
@@ -3939,7 +4344,7 @@ async function ensureUsableClaudeConfigHome(cwd, log) {
       }
     );
     process.env.CLAUDE_CONFIG_DIR = fallback;
-    await mkdir4(join8(fallback, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join9(fallback, "projects", projectSlug(cwd)), { recursive: true });
     await repointSharedConfigHomeSymlink(fallback, log);
     return { configHome: fallback, fellBack: true };
   }
@@ -3984,6 +4389,7 @@ var PtyHarness = class _PtyHarness {
   fingerprintOf(options) {
     return this.adapter.spawnFingerprint({
       model: options.model,
+      ...options.effort ? { effort: options.effort } : {},
       permissionMode: options.permissionMode,
       ...options.appendSystemPrompt ? { appendSystemPrompt: options.appendSystemPrompt } : {},
       cwd: options.cwd
@@ -4047,6 +4453,7 @@ var PtyHarness = class _PtyHarness {
       });
     }
     const fingerprint = this.fingerprintOf(options);
+    await this.parked?.settleModelSwitch();
     let session;
     if (this.parked?.canReuse(want, fingerprint) && !await this.parkedHomeDied(options)) {
       session = this.parked;
@@ -4372,7 +4779,7 @@ import { spawn } from "child_process";
 
 // src/harness/pty/adapters/types.ts
 import { accessSync, constants, statSync } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var TuiUnavailableError = class extends Error {
   constructor(tui, message) {
     super(message);
@@ -4396,7 +4803,7 @@ function findOnPath(binary, env = process.env) {
   }
   for (const dir of (env.PATH ?? "").split(":")) {
     if (!dir) continue;
-    const candidate = join9(dir, binary);
+    const candidate = join10(dir, binary);
     if (isExecutable(candidate)) return candidate;
   }
   return null;
@@ -4404,18 +4811,18 @@ function findOnPath(binary, env = process.env) {
 
 // src/harness/pty/adapters/opencode-auth.ts
 import { promises as fs } from "fs";
-import { dirname as dirname2, join as join10 } from "path";
+import { dirname as dirname2, join as join11 } from "path";
 import { homedir as homedir4 } from "os";
 var logger = createServiceLogger("opencode-auth");
 var OPENCODE_CODEX_PLUGIN = "opencode-openai-codex-auth@4.4.0";
 var PLUGIN_PACKAGE = "opencode-openai-codex-auth";
 function opencodeAuthPath(env) {
-  const dataHome = env.XDG_DATA_HOME ?? join10(env.HOME ?? homedir4(), ".local", "share");
-  return join10(dataHome, "opencode", "auth.json");
+  const dataHome = env.XDG_DATA_HOME ?? join11(env.HOME ?? homedir4(), ".local", "share");
+  return join11(dataHome, "opencode", "auth.json");
 }
 function opencodeConfigPath(env) {
-  const configHome = env.XDG_CONFIG_HOME ?? join10(env.HOME ?? homedir4(), ".config");
-  return join10(configHome, "opencode", "opencode.json");
+  const configHome = env.XDG_CONFIG_HOME ?? join11(env.HOME ?? homedir4(), ".config");
+  return join11(configHome, "opencode", "opencode.json");
 }
 function parseOauthSeed(b64) {
   if (!b64) return null;
@@ -4608,8 +5015,8 @@ function buildOpenCodeConfigContent(input) {
 }
 
 // src/harness/opencode/index.ts
-import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile7 } from "fs/promises";
-import { join as join11 } from "path";
+import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile8 } from "fs/promises";
+import { join as join12 } from "path";
 var MAX_STDERR_TAIL = 4e3;
 var OpenCodeHeadlessHarness = class {
   /** NDJSON from `--format json` is a trusted structured source. */
@@ -4631,7 +5038,7 @@ var OpenCodeHeadlessHarness = class {
     const prompt = await collectPrompt(opts.prompt);
     const binary = resolveOpenCodeBinary(process.env);
     await prepareOpenCodeCredentials(process.env);
-    this.tempDir = await mkdtemp2(join11(sessionTempBase(), "opencode-headless-"));
+    this.tempDir = await mkdtemp2(join12(sessionTempBase(), "opencode-headless-"));
     const { servers, entries } = await startToolServers(
       opts.options.mcpServers ?? {},
       this.tempDir
@@ -4713,8 +5120,8 @@ var OpenCodeHeadlessHarness = class {
    */
   async writeSystemPrompt(text) {
     if (!text || text.trim() === "") return null;
-    const path = join11(this.tempDir, "conveyor-instructions.md");
-    await writeFile7(path, text, "utf8");
+    const path = join12(this.tempDir, "conveyor-instructions.md");
+    await writeFile8(path, text, "utf8");
     return path;
   }
   /**
@@ -4854,25 +5261,25 @@ ${tail}`);
 
 // src/harness/pty/adapters/codex.ts
 import { realpathSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname as dirname3, join as join14 } from "path";
+import { basename, dirname as dirname3, join as join15 } from "path";
 
 // src/harness/codex/credentials.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir5, readFile as readFile2, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile9 } from "fs/promises";
 import { homedir as homedir5, tmpdir } from "os";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 function codexHome(env = process.env) {
   const key = env.CONVEYOR_CODING_AGENT_KEY_ID ?? "local";
   const scope = createHash2("sha256").update(key).digest("hex").slice(0, 24);
-  return env.CONVEYOR_CODEX_HOME ?? join12(env.HOME ?? homedir5(), ".conveyor-codex", scope);
+  return env.CONVEYOR_CODEX_HOME ?? join13(env.HOME ?? homedir5(), ".conveyor-codex", scope);
 }
 function codexSqliteHome(env = process.env) {
   const scope = createHash2("sha256").update(codexHome(env)).digest("hex").slice(0, 24);
-  return env.CONVEYOR_CODEX_SQLITE_HOME ?? join12(tmpdir(), "conveyor-codex-state", scope);
+  return env.CONVEYOR_CODEX_SQLITE_HOME ?? join13(tmpdir(), "conveyor-codex-state", scope);
 }
 async function readAuth(path) {
   try {
-    return JSON.parse(await readFile2(path, "utf8"));
+    return JSON.parse(await readFile3(path, "utf8"));
   } catch {
     return {};
   }
@@ -4881,7 +5288,7 @@ async function prepareCodexCredentials(env) {
   const home = codexHome(env);
   await mkdir5(home, { recursive: true, mode: 448 });
   await mkdir5(codexSqliteHome(env), { recursive: true, mode: 448 });
-  const path = join12(home, "auth.json");
+  const path = join13(home, "auth.json");
   const seed = env.CONVEYOR_CODEX_OAUTH;
   if (seed) {
     const tokens = JSON.parse(Buffer.from(seed, "base64").toString("utf8"));
@@ -4892,10 +5299,10 @@ async function prepareCodexCredentials(env) {
     }
     const existing = await readAuth(path);
     const stored = existing.tokens;
-    const seededAt = await readAuth(join12(home, "conveyor-auth-seed.json"));
+    const seededAt = await readAuth(join13(home, "conveyor-auth-seed.json"));
     if (stored?.refresh_token && stored.account_id === tokens.accountId && typeof seededAt.expires === "number" && seededAt.expires >= tokens.expires)
       return;
-    await writeFile8(
+    await writeFile9(
       path,
       JSON.stringify({
         auth_mode: "chatgpt",
@@ -4910,13 +5317,13 @@ async function prepareCodexCredentials(env) {
       }),
       { mode: 384 }
     );
-    await writeFile8(
-      join12(home, "conveyor-auth-seed.json"),
+    await writeFile9(
+      join13(home, "conveyor-auth-seed.json"),
       JSON.stringify({ expires: tokens.expires }),
       { mode: 384 }
     );
   } else if (env.CONVEYOR_AGENT_KEY || env.OPENAI_API_KEY) {
-    await writeFile8(
+    await writeFile9(
       path,
       JSON.stringify({ OPENAI_API_KEY: env.CONVEYOR_AGENT_KEY ?? env.OPENAI_API_KEY }),
       { mode: 384 }
@@ -4927,10 +5334,10 @@ async function prepareCodexCredentials(env) {
 // src/harness/codex/lineage.ts
 import { createHash as createHash3 } from "crypto";
 import { readFileSync, mkdirSync, writeFileSync, renameSync } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function lineagePath(id, cwd, env = process.env) {
   const key = createHash3("sha256").update(`${cwd}\0${id}`).digest("hex");
-  return join13(codexHome(env), `conveyor-lineage-${key}.json`);
+  return join14(codexHome(env), `conveyor-lineage-${key}.json`);
 }
 function readCodexLineage(id, cwd) {
   try {
@@ -5035,7 +5442,7 @@ var CodexTuiAdapter = class {
     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`);
+      const profilePath = join15(env.CODEX_HOME, `${profile}.config.toml`);
       writeFileSync2(
         profilePath,
         `hooks = ${tomlValue(codexHookConfig(input.pluginPath, input.eventsSinkPath))}
@@ -5407,6 +5814,18 @@ function wrapBridgeWithDirectStream(inner, reporter, options = {}) {
   };
 }
 
+// src/execution/model-override.ts
+function getModelOverride(env = process.env) {
+  return env.CONVEYOR_MODEL_OVERRIDE || void 0;
+}
+function getEffortOverride(env = process.env) {
+  return env.CONVEYOR_EFFORT_OVERRIDE || void 0;
+}
+function composerOverrides(runMode, env = process.env) {
+  if (runMode.configMode === "code-review" || runMode.agentMode === "review") return {};
+  return { model: getModelOverride(env), effort: getEffortOverride(env) };
+}
+
 // src/execution/query-executor.ts
 import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
 import {
@@ -6375,10 +6794,10 @@ function buildPmRelaunchParts(context, lastAgentIdx, isAuto, agentMode) {
 
 // src/execution/system-prompt.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function repoHasScript(workspaceDir, script) {
   try {
-    const pkg = JSON.parse(readFileSync2(join15(workspaceDir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync2(join16(workspaceDir, "package.json"), "utf8"));
     return typeof pkg.scripts?.[script] === "string";
   } catch {
     return false;
@@ -9655,7 +10074,7 @@ function buildMutationTools(connection, config) {
 }
 
 // src/tools/attachment-tools.ts
-import { basename as basename2, extname, isAbsolute, join as join16 } from "path";
+import { basename as basename2, extname, isAbsolute, join as join17 } from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -9722,7 +10141,7 @@ function buildUploadAttachmentTool(connection, config) {
   return defineContractTool(uploadAttachmentContract, async ({ path, title, comment, tags }) => {
     const caption = title ?? comment;
     try {
-      const filePath = isAbsolute(path) ? path : join16(config.workspaceDir, path);
+      const filePath = isAbsolute(path) ? path : join17(config.workspaceDir, path);
       const mimeType = inferMimeType(filePath);
       const info = await statWorkspacePath(filePath);
       if (!info.isFile) {
@@ -10353,8 +10772,8 @@ function buildDiscoveryTools(connection) {
 import { z as z9 } from "zod";
 
 // src/execution/context-path-verifier.ts
-import { readFile as readFile3 } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join17, normalize } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join18, normalize } from "path";
 var PROBLEM_TEXT = {
   not_found: "does not exist in the repo",
   expected_folder: "is a file, not a folder \u2014 use type 'file', 'rule', or 'doc'",
@@ -10369,7 +10788,7 @@ async function verifyLocator(link, absolutePath, fileSize) {
   if (fileSize !== void 0 && fileSize > MAX_LOCATOR_FILE_BYTES) return null;
   let content;
   try {
-    content = await readFile3(absolutePath, "utf8");
+    content = await readFile4(absolutePath, "utf8");
   } catch {
     return null;
   }
@@ -10399,7 +10818,7 @@ async function verifyContextPaths(links, workspaceDir) {
       problems.push({ type: link.type, path: link.path, reason: shape });
       continue;
     }
-    const absolutePath = join17(workspaceDir, toRelativePath(link.path));
+    const absolutePath = join18(workspaceDir, toRelativePath(link.path));
     const stat = await statWorkspacePath(absolutePath);
     const wantsDirectory = expectsDirectory(link.type);
     if (!stat.exists) {
@@ -12748,6 +13167,7 @@ function buildDisallowedTools(settings, mode, hasExitedPlanMode) {
 function buildQueryOptions(host, context) {
   const settings = context.agentSettings ?? host.config.agentSettings ?? {};
   const mode = host.agentMode;
+  const overrides = composerOverrides({ configMode: host.config.mode, agentMode: mode });
   const isReadOnly = isReadOnlyMode(mode, host.hasExitedPlanMode);
   const needsCanUseTool = isReadOnly;
   const systemPromptText = buildSystemPrompt(
@@ -12768,7 +13188,8 @@ function buildQueryOptions(host, context) {
   );
   const settingSources = settings.settingSources ?? ["user", "project"];
   return {
-    model: context.model || host.config.model,
+    // The user's explicit composer choice outranks the task's own model.
+    model: overrides.model || context.model || host.config.model,
     systemPrompt: {
       type: "preset",
       preset: "claude_code",
@@ -12802,7 +13223,7 @@ function buildQueryOptions(host, context) {
     sandbox: context.useSandbox ? { enabled: true } : { enabled: false },
     hooks: buildHooks(host),
     maxTurns: settings.maxTurns,
-    effort: settings.effort,
+    effort: overrides.effort || settings.effort,
     thinking: settings.thinking,
     betas: settings.betas,
     codex: settings.codex,
@@ -13489,7 +13910,8 @@ function buildPtyBridge(connection, onBackgroundTaskDone) {
     notifyPromptDeliveryFailure: (detail) => connection.postChatMessage(detail),
     requestPodRecycle: (reason) => connection.requestWorkspaceRecycle(reason),
     onInput: (handler) => connection.onPtyInput(handler),
-    onResize: (handler) => connection.onPtyResize(handler)
+    onResize: (handler) => connection.onPtyResize(handler),
+    onModelEffort: (handler) => connection.onPtyModelEffort(handler)
   };
 }
 var QueryBridge = class {
@@ -13503,7 +13925,7 @@ var QueryBridge = class {
     let bridge;
     if (harnessKind === "pty") {
       this.directStream = wrapBridgeWithDirectStream(
-        buildPtyBridge(connection, () => this.onBackgroundTaskDone?.()),
+        buildPtyBridge(connection, (taskId) => this.onBackgroundTaskDone?.(taskId)),
         connection
       );
       bridge = this.directStream.bridge;
@@ -14228,6 +14650,8 @@ function isBackgroundLaunch(tool2, input) {
 var BackgroundWorkTracker = class {
   /** Absolute expiry (epoch ms) of each outstanding launch, oldest first. */
   deadlines = [];
+  /** CLI task ids already counted as complete. */
+  completedTaskIds = /* @__PURE__ */ new Set();
   maxMs;
   onChange;
   log;
@@ -14256,7 +14680,11 @@ var BackgroundWorkTracker = class {
    * runner never saw, a re-injected record) must be a no-op, never a negative
    * balance that would keep the pod awake after the real work finished.
    */
-  noteCompletion(now = Date.now()) {
+  noteCompletion(now = Date.now(), taskId = null) {
+    if (taskId !== null) {
+      if (this.completedTaskIds.has(taskId)) return;
+      this.completedTaskIds.add(taskId);
+    }
     this.prune(now);
     if (this.deadlines.length === 0) return;
     this.deadlines.shift();
@@ -14276,6 +14704,7 @@ var BackgroundWorkTracker = class {
   }
   /** Drop everything (shutdown / session teardown). */
   clear() {
+    this.completedTaskIds.clear();
     if (this.deadlines.length === 0) return;
     this.deadlines.length = 0;
     this.onChange?.();
@@ -15644,7 +16073,7 @@ var SessionRunner = class _SessionRunner {
       onUserQuestion: (signal) => this.handleUserQuestionSignal(signal)
     });
     bridge.isParentTask = this.fullContext?.isParentTask ?? false;
-    bridge.onBackgroundTaskDone = () => this.backgroundWork.noteCompletion();
+    bridge.onBackgroundTaskDone = (taskId) => this.backgroundWork.noteCompletion(Date.now(), taskId ?? null);
     bridge.onSoftStop = () => {
       process.stderr.write("[conveyor-agent] Soft stop requested (discovery ExitPlanMode)\n");
       this.softStop();
@@ -16014,6 +16443,8 @@ export {
   PtyHarness,
   resolveTuiKindFromEnv,
   resolveTuiAdapter,
+  getModelOverride,
+  getEffortOverride,
   buildProjectTools,
   resolvePlaywrightMcpServer,
   resolveSessionStart,