@triflux/remote 10.44.0 → 10.46.0

package/hub/team/interactive-tui-transport.mjs

@@ -14,6 +14,7 @@ const STARTUP_PROMPT_MAX_ATTEMPTS = 30;
 const STARTUP_PROMPT_POLL_INTERVAL_MS = 300;
 const PIPE_TEMP_PREFIX = "triflux-tui-pipe-";
 const PIPE_OUTPUT_FILE = "pane.out";
+const CODEX_NO_APPROVAL_FLAG = "--dangerously-bypass-approvals-and-sandbox";
 
 const CONTROL_SEQUENCES = [
   ["\x1b[A", "Up"],
@@ -41,6 +42,13 @@ export async function defaultRunTmux(args, options = {}) {
   });
 }
 
+export function ensureInteractiveCodexPosture(launchCmd) {
+  const command = String(launchCmd || "").trim();
+  if (!/^codex(?:\s|$)/u.test(command)) return command;
+  if (command.includes(CODEX_NO_APPROVAL_FLAG)) return command;
+  return command.replace(/^codex/u, `codex ${CODEX_NO_APPROVAL_FLAG}`);
+}
+
 export function createInteractiveTuiTransport({
   runTmux = defaultRunTmux,
   sessionName,
@@ -113,7 +121,13 @@ export function createInteractiveTuiTransport({
       ...(cwd ? ["-c", cwd] : []),
       ...buildTmuxEnvArgs(env),
     ]);
-    await tmux(["send-keys", "-t", sessionName, String(launchCmd), "Enter"]);
+    await tmux([
+      "send-keys",
+      "-t",
+      sessionName,
+      ensureInteractiveCodexPosture(launchCmd),
+      "Enter",
+    ]);
     await dismissStartupPrompts({ tmux, captureVisible, sessionName });
     started = true;
     await startOutputStream();

package/hub/team/launcher-template.mjs

@@ -5,6 +5,11 @@
 // F4 해결: codex exec "prompt" 인라인 (파이프/리다이렉트 아님)
 // F5 해결: 동일 입력 → 동일 args 배열 (런타임 분기 없음)
 
+import {
+  buildDisabledCliError,
+  normalizeCliName,
+  resolveCliPolicy,
+} from "../../scripts/lib/machine-profile.mjs";
 import { buildExecArgs as buildCodexArgs } from "@triflux/core/hub/codex-adapter.mjs";
 
 function shellSingleQuote(value) {
@@ -13,7 +18,7 @@ function shellSingleQuote(value) {
 
 function buildAntigravityArgs(opts = {}) {
   const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
-  const command = `printf %s ${shellSingleQuote(prompt)} | agy --print --dangerously-skip-permissions`;
+  const command = `agy --dangerously-skip-permissions --print ${shellSingleQuote(prompt)}`;
   if (opts.resultFile) {
     return `${command} > ${shellSingleQuote(opts.resultFile)} 2>${shellSingleQuote(`${opts.resultFile}.err`)}`;
   }
@@ -90,6 +95,17 @@ export function buildLauncher(opts) {
   if (!agent) throw new Error("agent is required");
   if (!prompt && prompt !== "") throw new Error("prompt is required");
 
+  // TFX_DISABLE_* SSOT 집행. 이 런처는 tfx-route.sh 를 거치지 않고 codex/agy
+  // 바이너리를 직접 실행하는 경로라서 같은 정책을 여기서 다시 확인한다. 정책
+  // 판독 시임은 opts.cliPolicy(계산된 정책)와 opts.policyEnv(env 객체)뿐이다.
+  // claude 처럼 정책 대상이 아닌 CLI 는 프로파일 파일을 읽지 않는다.
+  if (normalizeCliName(agent)) {
+    const cliPolicy =
+      opts.cliPolicy ?? resolveCliPolicy(opts.policyEnv ?? process.env);
+    const blockedCli = buildDisabledCliError(agent, cliPolicy);
+    if (blockedCli) throw blockedCli;
+  }
+
   const adapter = getAdapter(agent);
 
   const command = adapter.buildArgs({

package/hub/team/orchestrator.mjs

@@ -126,7 +126,8 @@ export function buildPrompt(subtask, config) {
  * @param {string} opts.hubUrl — Hub URL
  * @param {{target:string, cli:string, task:string}|null} opts.lead
  * @param {string} opts.teammateMode
- * @returns {Promise<void>}
+ * @param {(failure: {target:string, cli:string, role:string, message:string}) => void} [opts.onInjectionFailure]
+ * @returns {Promise<Array<{target:string, cli:string, role:string, message:string}>>}
  */
 export async function orchestrate(sessionName, assignments, opts = {}) {
   const {
@@ -134,7 +135,24 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
     lead = null,
     teammateMode = "tmux",
     injectPrompt = defaultInjectPrompt,
+    onInjectionFailure,
   } = opts;
+  const failures = [];
+
+  function recordInjectionFailure(target, cli, role, error) {
+    const failure = {
+      target,
+      cli: cli || "unknown",
+      role,
+      message: String(error?.message || error || "prompt submission failed"),
+    };
+    failures.push(failure);
+    try {
+      onInjectionFailure?.(failure);
+    } catch {
+      // reporting failure must not stop the remaining pane injections
+    }
+  }
 
   const workers = assignments.map(({ target, cli, subtask }) => ({
     target,
@@ -155,10 +173,14 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
         subtask: w.subtask,
       })),
     });
-    injectPrompt(lead.target, leadPrompt, {
-      useFileRef: true,
-      cli: lead.cli,
-    });
+    try {
+      injectPrompt(lead.target, leadPrompt, {
+        useFileRef: true,
+        cli: lead.cli,
+      });
+    } catch (error) {
+      recordInjectionFailure(lead.target, lead.cli, "lead", error);
+    }
     await new Promise((r) => setTimeout(r, 100));
   }
 
@@ -169,10 +191,15 @@ export async function orchestrate(sessionName, assignments, opts = {}) {
       hubUrl,
       sessionName,
     });
-    injectPrompt(worker.target, prompt, {
-      useFileRef: true,
-      cli: worker.cli,
-    });
+    try {
+      injectPrompt(worker.target, prompt, {
+        useFileRef: true,
+        cli: worker.cli,
+      });
+    } catch (error) {
+      recordInjectionFailure(worker.target, worker.cli, "worker", error);
+    }
     await new Promise((r) => setTimeout(r, 100));
   }
+  return failures;
 }

package/hub/team/pane.mjs

@@ -62,7 +62,7 @@ export function buildCliCommand(cli, options = {}) {
       if (trustMode) {
         return buildExecArgs({});
       }
-      return "codex";
+      return "codex --dangerously-bypass-approvals-and-sandbox";
     case "gemini":
       // interactive 모드 — MCP는 ~/.gemini/settings.json에 사전 등록
       return "gemini";
@@ -105,6 +105,149 @@ export function shouldUseFileRef({ multiplexer, useFileRef, cli }) {
   return multiplexer === "psmux" && useFileRef && cli !== "codex";
 }
 
+/** 동기 sleep — injectPrompt는 sync 경로라 setTimeout을 쓸 수 없다 */
+function sleepMs(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+// paste 직후 Enter가 TUI paste-burst 감지에 개행으로 흡수되는 것을 피하는 정착 지연
+const PASTE_SETTLE_MS = 350;
+// 제출 확인 재시도 상한
+const SUBMIT_RETRY_LIMIT = 3;
+// TUI 준비 대기 상한 — 배너/composer 렌더 완료 전 주입은 키 입력이 통째로 유실될 수 있음
+const COMPOSER_READY_TIMEOUT_MS = 8000;
+
+function capturePaneText(target) {
+  try {
+    if (detectMultiplexer() === "psmux") {
+      return String(
+        psmuxExec(["capture-pane", "-t", target, "-p"], { encoding: "utf8" }) ??
+          "",
+      );
+    }
+    return String(muxExec(`capture-pane -t ${target} -p`) ?? "");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * TUI가 그리기를 마칠 때까지 대기: pane 내용이 비어 있지 않고 연속 두 번의
+ * capture가 동일(정적)해질 때까지 폴링한다. CLI 종류와 무관한 준비 신호이며
+ * 시간 초과 시 그냥 진행한다 (기존 고정-대기 동작으로 degrade).
+ */
+function waitForComposerReady(target) {
+  const deadline = Date.now() + COMPOSER_READY_TIMEOUT_MS;
+  let prev = null;
+  while (Date.now() < deadline) {
+    const text = capturePaneText(target);
+    if (text.trim() && prev !== null && text === prev) return;
+    prev = text;
+    sleepMs(400);
+  }
+}
+
+/**
+ * 주입한 프롬프트가 실제 제출됐는지 확인하고, 안 됐으면 Enter를 재전송한다.
+ *
+ * TUI는 연속 키 입력을 paste burst로 묶으므로 paste 직후의 Enter가 제출 대신
+ * composer 개행으로 흡수될 수 있다. transcript의 과거 prompt가 아니라 마지막
+ * composer line에서 현재 prompt가 사라졌을 때만 제출로 판정한다. Antigravity는
+ * capture 불가 또는 재시도 소진을 성공으로 숨기지 않고 오류로 반환한다.
+ */
+function isAntigravityCli(cli) {
+  return ["agy", "antigravity", "gemini"].includes(
+    String(cli || "").toLowerCase(),
+  );
+}
+
+function promptComposerNeedle(prompt) {
+  const firstContentLine = String(prompt || "")
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find(Boolean);
+  return (firstContentLine || "").slice(0, 16);
+}
+
+function isComposerPromptLine(line) {
+  return /^\s*(?:[│┃]\s*)?[›❯▶▸>]\s*/u.test(String(line || ""));
+}
+
+function composerPromptState(text, needle) {
+  const composerLines = String(text || "")
+    .split("\n")
+    .filter(isComposerPromptLine);
+  if (composerLines.length === 0) return "unknown";
+  return composerLines.at(-1).includes(needle) ? "present" : "absent";
+}
+
+function hasBusyMarkerOutsideComposer(text) {
+  return String(text || "")
+    .split("\n")
+    .some(
+      (line) =>
+        !isComposerPromptLine(line) &&
+        /esc to (?:interrupt|cancel)/iu.test(line),
+    );
+}
+
+/**
+ * paste된 prompt가 실제 제출될 때까지 Enter를 bounded retry한다.
+ * Antigravity는 capture로 성공을 확인하지 못하면 조용히 idle 상태로 남기지 않고
+ * caller에 명확한 오류를 반환한다.
+ */
+export function submitPromptWithVerification({
+  cli,
+  prompt,
+  capture,
+  sendEnter,
+  sleep = sleepMs,
+  settleMs = PASTE_SETTLE_MS,
+  retryLimit = SUBMIT_RETRY_LIMIT,
+} = {}) {
+  if (typeof capture !== "function" || typeof sendEnter !== "function") {
+    throw new TypeError("capture and sendEnter are required");
+  }
+
+  const strictVerification = isAntigravityCli(cli);
+  const needle = promptComposerNeedle(prompt);
+  sleep(settleMs);
+
+  if (!needle) {
+    sendEnter();
+    return;
+  }
+
+  for (let attempt = 1; attempt <= retryLimit; attempt++) {
+    sendEnter();
+    sleep(400 * attempt);
+    const text = String(capture() ?? "");
+    if (!text) {
+      if (strictVerification) continue;
+      return;
+    }
+    if (hasBusyMarkerOutsideComposer(text)) return;
+    const composerState = composerPromptState(text, needle);
+    if (composerState === "absent") return;
+    if (composerState === "unknown" && !strictVerification) return;
+  }
+
+  if (strictVerification) {
+    throw new Error(
+      `Antigravity prompt submission failed after ${retryLimit} attempts: prompt remains in composer or submission could not be verified`,
+    );
+  }
+}
+
+function confirmSubmit(target, prompt, cli, sendEnter) {
+  submitPromptWithVerification({
+    cli,
+    prompt,
+    capture: () => capturePaneText(target),
+    sendEnter,
+  });
+}
+
 /**
  * pane에 프롬프트 주입
  * @param {string} target — 예: tfx-multi-abc:0.1
@@ -131,16 +274,29 @@ export function injectPrompt(
   if (shouldUseFileRef({ multiplexer, useFileRef, cli })) {
     writeFileSync(tmpFile, prompt, "utf8");
     const filePath = tmpFile.replace(/\\/g, "/");
-    psmuxExec(["select-pane", "-t", target]);
-    psmuxExec(["send-keys", "-t", target, "-l", `@${filePath}`]);
-    psmuxExec(["send-keys", "-t", target, "Enter"]);
-    // TUI가 파일을 읽을 시간을 주고 정리
-    setTimeout(() => {
-      try {
-        unlinkSync(tmpFile);
-      } catch {}
-    }, 10000);
-    return;
+    let cleanupScheduled = false;
+    try {
+      waitForComposerReady(target);
+      psmuxExec(["select-pane", "-t", target]);
+      psmuxExec(["send-keys", "-t", target, "-l", `@${filePath}`]);
+      confirmSubmit(target, `@${filePath}`, cli, () =>
+        psmuxExec(["send-keys", "-t", target, "Enter"]),
+      );
+      // TUI가 파일을 읽을 시간을 주고 정리
+      setTimeout(() => {
+        try {
+          unlinkSync(tmpFile);
+        } catch {}
+      }, 10000);
+      cleanupScheduled = true;
+      return;
+    } finally {
+      if (!cleanupScheduled) {
+        try {
+          unlinkSync(tmpFile);
+        } catch {}
+      }
+    }
   }
 
   try {
@@ -148,17 +304,23 @@ export function injectPrompt(
 
     if (detectMultiplexer() === "psmux") {
       const sessionName = getPsmuxSessionName(target);
+      waitForComposerReady(target);
       psmuxExec(["load-buffer", "-t", sessionName, toMuxPath(tmpFile)]);
       psmuxExec(["select-pane", "-t", target]);
       psmuxExec(["paste-buffer", "-t", target]);
-      psmuxExec(["send-keys", "-t", target, "Enter"]);
+      confirmSubmit(target, prompt, cli, () =>
+        psmuxExec(["send-keys", "-t", target, "Enter"]),
+      );
       return;
     }
 
-    // tmux load-buffer → paste-buffer → Enter
+    // tmux load-buffer → paste-buffer → (정착 지연 + 제출 확인) Enter
+    waitForComposerReady(target);
     muxExec(`load-buffer ${quoteArg(toMuxPath(tmpFile))}`);
     muxExec(`paste-buffer -t ${target}`);
-    muxExec(`send-keys -t ${target} Enter`);
+    confirmSubmit(target, prompt, cli, () =>
+      muxExec(`send-keys -t ${target} Enter`),
+    );
   } finally {
     try {
       unlinkSync(tmpFile);

package/hub/team/psmux.mjs

@@ -676,41 +676,32 @@ export function createPsmuxSession(sessionName, opts = {}) {
     newSessionArgs.push(PWSH_BIN, "-NoLogo", "-NoProfile");
   const leadPane = psmuxExec(newSessionArgs);
 
-  // split-window로 생성되는 pane도 동일 셸 사용 (Windows: PowerShell 강제)
-  if (PWSH_BIN && IS_WINDOWS) {
-    try {
-      psmuxExec([
-        "set-option",
-        "-t",
-        sessionName,
-        "default-command",
-        `${PWSH_BIN} -NoLogo -NoProfile`,
-      ]);
-    } catch {
-      /* 미지원 시 무시 */
+  try {
+    // split-window로 생성되는 pane도 동일 셸 사용 (Windows: PowerShell 강제)
+    if (PWSH_BIN && IS_WINDOWS) {
+      try {
+        psmuxExec([
+          "set-option",
+          "-t",
+          sessionName,
+          "default-command",
+          `${PWSH_BIN} -NoLogo -NoProfile`,
+        ]);
+      } catch {
+        /* 미지원 시 무시 */
+      }
     }
-  }
 
-  if (layout === "2x2" && limitedPaneCount >= 3) {
-    const rightPane = psmuxExec([
-      "split-window",
-      "-h",
-      "-P",
-      "-F",
-      "#{session_name}:#{window_index}.#{pane_index}",
-      "-t",
-      leadPane,
-    ]);
-    psmuxExec([
-      "split-window",
-      "-v",
-      "-P",
-      "-F",
-      "#{session_name}:#{window_index}.#{pane_index}",
-      "-t",
-      rightPane,
-    ]);
-    if (limitedPaneCount >= 4) {
+    if (layout === "2x2" && limitedPaneCount >= 3) {
+      const rightPane = psmuxExec([
+        "split-window",
+        "-h",
+        "-P",
+        "-F",
+        "#{session_name}:#{window_index}.#{pane_index}",
+        "-t",
+        leadPane,
+      ]);
       psmuxExec([
         "split-window",
         "-v",
@@ -718,51 +709,69 @@ export function createPsmuxSession(sessionName, opts = {}) {
         "-F",
         "#{session_name}:#{window_index}.#{pane_index}",
         "-t",
-        leadPane,
+        rightPane,
       ]);
+      if (limitedPaneCount >= 4) {
+        psmuxExec([
+          "split-window",
+          "-v",
+          "-P",
+          "-F",
+          "#{session_name}:#{window_index}.#{pane_index}",
+          "-t",
+          leadPane,
+        ]);
+      }
+      psmuxExec(["select-layout", "-t", sessionTarget, "tiled"]);
+    } else if (layout === "1xN") {
+      for (let index = 1; index < limitedPaneCount; index += 1) {
+        psmuxExec(["split-window", "-h", "-t", sessionTarget]);
+      }
+      psmuxExec(["select-layout", "-t", sessionTarget, "even-horizontal"]);
+    } else {
+      for (let index = 1; index < limitedPaneCount; index += 1) {
+        psmuxExec(["split-window", "-v", "-t", sessionTarget]);
+      }
+      psmuxExec(["select-layout", "-t", sessionTarget, "even-vertical"]);
     }
-    psmuxExec(["select-layout", "-t", sessionTarget, "tiled"]);
-  } else if (layout === "1xN") {
-    for (let index = 1; index < limitedPaneCount; index += 1) {
-      psmuxExec(["split-window", "-h", "-t", sessionTarget]);
-    }
-    psmuxExec(["select-layout", "-t", sessionTarget, "even-horizontal"]);
-  } else {
-    for (let index = 1; index < limitedPaneCount; index += 1) {
-      psmuxExec(["split-window", "-v", "-t", sessionTarget]);
-    }
-    psmuxExec(["select-layout", "-t", sessionTarget, "even-vertical"]);
-  }
 
-  psmuxExec(["select-pane", "-t", leadPane]);
+    psmuxExec(["select-pane", "-t", leadPane]);
 
-  const panes = collectSessionPanes(sessionName).slice(0, limitedPaneCount);
-  panes.forEach((pane, index) => {
+    const panes = collectSessionPanes(sessionName).slice(0, limitedPaneCount);
+    panes.forEach((pane, index) => {
+      try {
+        psmuxExec(["select-pane", "-t", pane, "-T", toPaneTitle(index)]);
+      } catch {
+        // tmux 2.6 미만: select-pane -T 미지원 — pane title 없이 계속 진행
+      }
+    });
+
+    // CP949 등 non-UTF-8 codepage 환경에서 CLI stdout 깨짐 방지:
+    // pane 생성 직후 UTF-8 인코딩을 강제 설정한다.
+    // chcp 65001: 프로세스 코드 페이지를 UTF-8로 전환
+    // OutputEncoding: 네이티브 명령(gemini/codex) stdout 디코딩
+    // $OutputEncoding: PowerShell 파이프라인 기본 인코딩
+    if (IS_WINDOWS) {
+      const encodingInit = [
+        "chcp 65001 > $null",
+        "[Console]::InputEncoding = [System.Text.Encoding]::UTF8",
+        "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
+        "$OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+      ].join("; ");
+      panes.forEach((paneId) => {
+        sendLiteralToPane(paneId, encodingInit, true);
+      });
+    }
+
+    return { sessionName, panes };
+  } catch (error) {
     try {
-      psmuxExec(["select-pane", "-t", pane, "-T", toPaneTitle(index)]);
+      killPsmuxSession(sessionName);
     } catch {
-      // tmux 2.6 미만: select-pane -T 미지원 — pane title 없이 계속 진행
+      /* rollback is best-effort; preserve the initialization error */
     }
-  });
-
-  // CP949 등 non-UTF-8 codepage 환경에서 CLI stdout 깨짐 방지:
-  // pane 생성 직후 UTF-8 인코딩을 강제 설정한다.
-  // chcp 65001: 프로세스 코드 페이지를 UTF-8로 전환
-  // OutputEncoding: 네이티브 명령(gemini/codex) stdout 디코딩
-  // $OutputEncoding: PowerShell 파이프라인 기본 인코딩
-  if (IS_WINDOWS) {
-    const encodingInit = [
-      "chcp 65001 > $null",
-      "[Console]::InputEncoding = [System.Text.Encoding]::UTF8",
-      "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
-      "$OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
-    ].join("; ");
-    panes.forEach((paneId) => {
-      sendLiteralToPane(paneId, encodingInit, true);
-    });
+    throw error;
   }
-
-  return { sessionName, panes };
 }
 
 /**

package/hub/team/retry-state-machine.mjs

@@ -23,6 +23,11 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
+import {
+  canonicalCodexProfileModel,
+  normalizeCodexProfileName,
+} from "../../scripts/lib/codex-profile-config.mjs";
+
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
   EXECUTING: "EXECUTING",
@@ -39,21 +44,29 @@ export const MODES = Object.freeze({
 });
 
 const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
+const DEFAULT_CLAUDE_MODEL = "fable";
 
-// Escalation chain (2026-05-27 정책):
-//   1. codex gpt-5.6-sol max — 최난도 단일 작업용 Codex escalation 단계
-//   2. claude opus-4-8 — 최종 수단
+// Escalation chain (2026-09-22 정책):
+//   1. codex gpt-6-astra max: 최난도 단일 작업용 Codex escalation 단계
+//   2. claude fable alias: Claude CLI가 최신 Fable tier로 해석하는 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({
     cli: "codex",
-    model: "gpt-5.6-sol",
-    profile: "gpt56_sol_max",
+    model: "gpt-6-astra",
+    profile: "gpt6_astra_max",
   }),
-  Object.freeze({ cli: "claude", model: "opus-4-8" }),
+  Object.freeze({ cli: "claude", model: DEFAULT_CLAUDE_MODEL }),
 ]);
 
 const STUCK_THRESHOLD = 3;
 
+function normalizeEscalationProfile(profile) {
+  const normalized = normalizeCodexProfileName(profile);
+  return normalized === "ultra" || normalized === "gpt6_astra_ultra"
+    ? "gpt6_astra_max"
+    : normalized;
+}
+
 export function createRetryStateMachine(options = {}) {
   const mode = options.mode || MODES.BOUNDED;
   const cliChain = resolveEscalationChain(options);
@@ -234,15 +247,25 @@ function resolveEscalationChain(options) {
   }
 
   const projectRoot = options.projectRoot || process.cwd();
-  return (
-    loadEscalationChainOverride(projectRoot) ||
-    normalizeEscalationChain(
-      DEFAULT_ESCALATION_CHAIN,
-      "DEFAULT_ESCALATION_CHAIN",
-    )
+  const projectOverride = loadEscalationChainOverride(projectRoot);
+  if (projectOverride) return projectOverride;
+
+  return normalizeEscalationChain(
+    resolveDefaultEscalationChain(options.env || process.env),
+    "DEFAULT_ESCALATION_CHAIN",
   );
 }
 
+function resolveDefaultEscalationChain(env) {
+  const configuredModel = env?.TFX_ESCALATION_CLAUDE_MODEL?.trim();
+  if (!configuredModel) return DEFAULT_ESCALATION_CHAIN;
+
+  return [
+    DEFAULT_ESCALATION_CHAIN[0],
+    { cli: "claude", model: configuredModel },
+  ];
+}
+
 export function loadEscalationChainOverride(projectRoot = process.cwd()) {
   const configPath = join(projectRoot, ESCALATION_CHAIN_CONFIG_PATH);
   if (!existsSync(configPath)) return null;
@@ -297,10 +320,12 @@ function normalizeEscalationChainEntry(entry, index, source) {
   if (typeof entry.profile === "string" && entry.profile.trim() !== "") {
     const profile = entry.profile.trim();
     normalized.profile =
-      entry.cli === "codex" &&
-      (profile === "ultra" || profile === "gpt56_sol_ultra")
-        ? "gpt56_sol_max"
-        : profile;
+      entry.cli === "codex" ? normalizeEscalationProfile(profile) : profile;
+    // A remapped legacy profile must not keep reporting its old model.
+    if (normalized.profile !== profile) {
+      normalized.model =
+        canonicalCodexProfileModel(normalized.profile) ?? normalized.model;
+    }
   }
   return normalized;
 }
@@ -333,6 +358,12 @@ export function loadSnapshot(snapshotFile) {
       `unsupported snapshot version: ${parsed.version} (expected 1)`,
     );
   }
+  if (Array.isArray(parsed.cliChain) && parsed.cliChain.length > 0) {
+    return {
+      ...parsed,
+      cliChain: normalizeEscalationChain(parsed.cliChain, "snapshot.cliChain"),
+    };
+  }
   return parsed;
 }