triflux 10.3.4 → 10.7.0

package/hub/cli-adapter-base.mjs

@@ -1,10 +1,10 @@
 // hub/cli-adapter-base.mjs — codex/gemini 공통 CLI adapter 인터페이스
 // Phase 2: codex-adapter.mjs에서 추출한 재사용 가능 유틸리티
 
-import { execSync, spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { execSync, spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
 
-import { killProcess, IS_WINDOWS } from './platform.mjs';
+import { IS_WINDOWS, killProcess } from "./platform.mjs";
 
 // ── Codex CLI compatibility ─────────────────────────────────────
 
@@ -18,7 +18,10 @@ let _cachedVersion = null;
 export function getCodexVersion() {
   if (_cachedVersion !== null) return _cachedVersion;
   try {
-    const out = execSync('codex --version', { encoding: 'utf8', timeout: 5000 }).trim();
+    const out = execSync("codex --version", {
+      encoding: "utf8",
+      timeout: 5000,
+    }).trim();
     const match = out.match(/(\d+)\.(\d+)\.(\d+)/);
     _cachedVersion = match ? Number.parseInt(match[2], 10) : 0;
   } catch {
@@ -43,19 +46,27 @@ export function gte(minMinor) {
  */
 export const FEATURES = {
   /** exec 서브커맨드 사용 가능 여부 (0.110+ 이전부터 존재) */
-  get execSubcommand() { return gte(110); },
+  get execSubcommand() {
+    return gte(110);
+  },
   /** --output-last-message 플래그 지원 여부 (0.117+) */
-  get outputLastMessage() { return gte(117); },
+  get outputLastMessage() {
+    return gte(117);
+  },
   /** --color <COLOR> 플래그 지원 여부 (exec와 동시 도입) */
-  get colorNever() { return gte(110); },
+  get colorNever() {
+    return gte(110);
+  },
   /** 플러그인 시스템 지원 여부 (향후 확장용) */
-  get pluginSystem() { return gte(120); },
+  get pluginSystem() {
+    return gte(120);
+  },
 };
 
 // ── Shell utilities ─────────────────────────────────────────────
 
 export function normalizePathForShell(value) {
-  return IS_WINDOWS ? String(value).replace(/\\/g, '/') : String(value);
+  return IS_WINDOWS ? String(value).replace(/\\/g, "/") : String(value);
 }
 
 export function shellQuote(value) {
@@ -77,32 +88,38 @@ export const CODEX_MCP_EXECUTION_EXIT_CODE = 1;
  * @returns {string} 실행할 셸 커맨드
  */
 export function buildExecCommand(prompt, resultFile = null, opts = {}) {
-  const { profile, skipGitRepoCheck = true, sandboxBypass = true, cwd, mcpServers } = opts;
+  const {
+    profile,
+    skipGitRepoCheck = true,
+    sandboxBypass = true,
+    cwd,
+    mcpServers,
+  } = opts;
 
-  const parts = ['codex'];
-  if (profile) parts.push('--profile', profile);
+  const parts = ["codex"];
+  if (profile) parts.push("--profile", profile);
 
   if (FEATURES.execSubcommand) {
-    parts.push('exec');
-    if (sandboxBypass) parts.push('--dangerously-bypass-approvals-and-sandbox');
-    if (skipGitRepoCheck) parts.push('--skip-git-repo-check');
+    parts.push("exec");
+    if (sandboxBypass) parts.push("--dangerously-bypass-approvals-and-sandbox");
+    if (skipGitRepoCheck) parts.push("--skip-git-repo-check");
     if (resultFile && FEATURES.outputLastMessage) {
-      parts.push('--output-last-message', resultFile);
+      parts.push("--output-last-message", resultFile);
     }
-    if (FEATURES.colorNever) parts.push('--color', 'never');
-    if (cwd) parts.push('--cwd', `'${escapePwshSingleQuoted(cwd)}'`);
+    if (FEATURES.colorNever) parts.push("--color", "never");
+    if (cwd) parts.push("--cwd", `'${escapePwshSingleQuoted(cwd)}'`);
     if (Array.isArray(mcpServers)) {
       for (const server of mcpServers) {
-        parts.push('-c', `mcp_servers.${server}.enabled=true`);
+        parts.push("-c", `mcp_servers.${server}.enabled=true`);
       }
     }
   } else {
-    parts.push('--dangerously-bypass-approvals-and-sandbox');
-    if (skipGitRepoCheck) parts.push('--skip-git-repo-check');
+    parts.push("--dangerously-bypass-approvals-and-sandbox");
+    if (skipGitRepoCheck) parts.push("--skip-git-repo-check");
   }
 
   parts.push(JSON.stringify(prompt));
-  return parts.join(' ');
+  return parts.join(" ");
 }
 
 // ── Sleep ───────────────────────────────────────────────────────
@@ -119,24 +136,28 @@ export function sleep(ms) {
 export function createResult(ok, extra = {}) {
   return {
     ok,
-    output: '',
-    stderr: '',
+    output: "",
+    stderr: "",
     exitCode: null,
     duration: 0,
     retried: false,
     fellBack: false,
-    failureMode: ok ? null : 'crash',
+    failureMode: ok ? null : "crash",
     ...extra,
   };
 }
 
 export function appendWarnings(stderr, warnings = []) {
-  const text = warnings.map((item) => `[preflight] ${item}`).join('\n');
-  return [stderr, text].filter(Boolean).join('\n');
+  const text = warnings.map((item) => `[preflight] ${item}`).join("\n");
+  return [stderr, text].filter(Boolean).join("\n");
 }
 
 // ── Circuit breaker factory ─────────────────────────────────────
 
+/**
+ * @deprecated Use per-account circuit breakers in account-broker.mjs instead.
+ * Kept for backward compatibility with code that hasn't migrated yet.
+ */
 export function createCircuitBreaker(opts = {}) {
   const state = {
     failures: [],
@@ -147,7 +168,9 @@ export function createCircuitBreaker(opts = {}) {
   };
 
   function pruneFailures(now = Date.now()) {
-    state.failures = state.failures.filter((stamp) => now - stamp < state.windowMs);
+    state.failures = state.failures.filter(
+      (stamp) => now - stamp < state.windowMs,
+    );
   }
 
   function reset() {
@@ -167,8 +190,13 @@ export function createCircuitBreaker(opts = {}) {
 
   function getState(now = Date.now()) {
     pruneFailures(now);
-    const withinWindow = state.openedAt && now - state.openedAt < state.windowMs;
-    const current = withinWindow ? 'open' : (state.openedAt ? 'half-open' : 'closed');
+    const withinWindow =
+      state.openedAt && now - state.openedAt < state.windowMs;
+    const current = withinWindow
+      ? "open"
+      : state.openedAt
+        ? "half-open"
+        : "closed";
     return {
       state: current,
       failures: [...state.failures],
@@ -181,9 +209,10 @@ export function createCircuitBreaker(opts = {}) {
 
   function canExecute() {
     const circuit = getState();
-    if (circuit.state === 'open') return { allowed: false, halfOpen: false };
-    if (circuit.state === 'half-open' && state.trialInFlight) return { allowed: false, halfOpen: true };
-    const halfOpen = circuit.state === 'half-open';
+    if (circuit.state === "open") return { allowed: false, halfOpen: false };
+    if (circuit.state === "half-open" && state.trialInFlight)
+      return { allowed: false, halfOpen: true };
+    const halfOpen = circuit.state === "half-open";
     if (halfOpen) state.trialInFlight = true;
     return { allowed: true, halfOpen };
   }
@@ -195,14 +224,112 @@ export function createCircuitBreaker(opts = {}) {
   return { getState, recordFailure, reset, canExecute, clearTrial };
 }
 
+// ── Broker-integrated execution ─────────────────────────────────
+
+/**
+ * Shared execute() logic that uses account-broker for per-account circuit
+ * breaking instead of a global breaker.
+ *
+ * @param {object} params
+ * @param {string} params.provider — 'codex' | 'gemini'
+ * @param {(prompt: string, workdir: string, preflight: object, attempt: object) => Promise<object>} params.runFn
+ * @param {(opts: object) => Promise<object>} params.preflightFn
+ * @param {(opts: object, preflight: object) => object[]} params.buildAttemptsFn
+ * @param {object} params.opts — caller-supplied execute options
+ * @returns {Promise<object>} createResult-shaped result
+ */
+export async function executeWithCircuitBroker({
+  provider,
+  runFn,
+  preflightFn,
+  buildAttemptsFn,
+  opts = {},
+}) {
+  // late-import to avoid circular dependency at module load time
+  const brokerMod = await import("./account-broker.mjs");
+  const { withRetry } = await import("./workers/worker-utils.mjs");
+
+  // access broker as live binding property (not destructured) so reloadBroker() propagates
+  const lease = brokerMod.broker?.lease({ provider });
+  if (!lease) {
+    return createResult(false, { fellBack: true, failureMode: "circuit_open" });
+  }
+
+  const preflight = await preflightFn(opts);
+  if (!preflight.ok) {
+    brokerMod.broker.release(lease.id, { ok: false });
+    return createResult(false, {
+      stderr: appendWarnings("", preflight.warnings),
+      fellBack: opts.fallbackToClaude !== false,
+      failureMode: "crash",
+    });
+  }
+
+  const attempts = buildAttemptsFn(opts, preflight);
+  let attemptIndex = 0;
+  let lastResult = createResult(false);
+
+  try {
+    lastResult = await withRetry(
+      async () => {
+        const result = await runFn(
+          opts.prompt || "",
+          opts.workdir || process.cwd(),
+          preflight,
+          attempts[attemptIndex],
+        );
+        const current = {
+          ...result,
+          stderr: appendWarnings(result.stderr, preflight.warnings),
+          retried: attemptIndex > 0,
+        };
+        const canRetry = !current.ok && attemptIndex < attempts.length - 1;
+        attemptIndex += 1;
+        if (!canRetry) return current;
+        const error = new Error("retry");
+        error.retryable = true;
+        error.result = current;
+        throw error;
+      },
+      {
+        maxAttempts: attempts.length,
+        baseDelayMs: 250,
+        maxDelayMs: 750,
+        shouldRetry: (error) => error?.retryable === true,
+      },
+    );
+  } catch (error) {
+    lastResult =
+      error?.result ||
+      createResult(false, { stderr: String(error?.message || error) });
+  }
+
+  if (lastResult.ok) {
+    brokerMod.broker.release(lease.id, { ok: true });
+    return lastResult;
+  }
+
+  brokerMod.broker.release(lease.id, { ok: false });
+  return {
+    ...lastResult,
+    retried: attempts.length > 1,
+    fellBack: opts.fallbackToClaude !== false,
+  };
+}
+
 // ── Process termination ─────────────────────────────────────────
 
 export async function terminateChild(pid, opts = {}) {
   if (!pid) return;
   const graceMs = opts.graceMs ?? 5000;
-  killProcess(pid, { signal: 'SIGTERM', tree: true, timeout: graceMs });
+  killProcess(pid, { signal: "SIGTERM", tree: true, timeout: graceMs });
   await sleep(graceMs);
-  killProcess(pid, { signal: 'SIGKILL', tree: true, force: true, timeout: graceMs });
+  killProcess(pid, {
+    signal: "SIGKILL",
+    tree: true,
+    force: true,
+    timeout: graceMs,
+  });
 }
 
 // ── Process execution with stall detection ──────────────────────
@@ -222,13 +349,13 @@ export async function terminateChild(pid, opts = {}) {
  */
 export async function runProcess(command, workdir, timeout, opts = {}) {
   const startedAt = Date.now();
-  const inferStallMode = opts.inferStallMode || (() => 'timeout');
+  const inferStallMode = opts.inferStallMode || (() => "timeout");
   const stallCheckIntervalMs = opts.stallCheckIntervalMs ?? 10_000;
   const stallThresholdMs = opts.stallThresholdMs ?? 30_000;
   const resultFile = opts.resultFile || null;
 
-  let stdout = '';
-  let stderr = '';
+  let stdout = "";
+  let stderr = "";
   let exitCode = null;
   let failureMode = null;
   let child;
@@ -236,15 +363,29 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
   try {
     child = spawn(command, { cwd: workdir, shell: true, windowsHide: true });
   } catch (error) {
-    return createResult(false, { stderr: String(error?.message || error), duration: Date.now() - startedAt });
+    return createResult(false, {
+      stderr: String(error?.message || error),
+      duration: Date.now() - startedAt,
+    });
   }
 
   let lastBytes = 0;
   let lastChange = Date.now();
-  const touch = () => { lastChange = Date.now(); };
-  child.stdout?.on('data', (chunk) => { stdout += String(chunk); touch(); });
-  child.stderr?.on('data', (chunk) => { stderr += String(chunk); touch(); });
-  child.on('error', (error) => { stderr += String(error?.message || error); failureMode ||= 'crash'; });
+  const touch = () => {
+    lastChange = Date.now();
+  };
+  child.stdout?.on("data", (chunk) => {
+    stdout += String(chunk);
+    touch();
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderr += String(chunk);
+    touch();
+  });
+  child.on("error", (error) => {
+    stderr += String(error?.message || error);
+    failureMode ||= "crash";
+  });
 
   const stopFor = async (mode) => {
     if (failureMode) return;
@@ -252,23 +393,34 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
     await terminateChild(child.pid);
   };
 
-  const timeoutTimer = setTimeout(() => { void stopFor('timeout'); }, timeout);
+  const timeoutTimer = setTimeout(() => {
+    void stopFor("timeout");
+  }, timeout);
   const stallTimer = setInterval(() => {
     const size = Buffer.byteLength(stdout) + Buffer.byteLength(stderr);
     if (size !== lastBytes) {
       lastBytes = size;
       return;
     }
-    if (Date.now() - lastChange >= stallThresholdMs) void stopFor(inferStallMode(stdout, stderr));
+    if (Date.now() - lastChange >= stallThresholdMs)
+      void stopFor(inferStallMode(stdout, stderr));
   }, stallCheckIntervalMs);
   timeoutTimer.unref?.();
   stallTimer.unref?.();
 
-  await new Promise((resolve) => child.on('close', (code) => { exitCode = code; resolve(); }));
+  await new Promise((resolve) =>
+    child.on("close", (code) => {
+      exitCode = code;
+      resolve();
+    }),
+  );
   clearTimeout(timeoutTimer);
   clearInterval(stallTimer);
 
-  const fileOutput = resultFile && existsSync(resultFile) ? readFileSync(resultFile, 'utf8') : '';
+  const fileOutput =
+    resultFile && existsSync(resultFile)
+      ? readFileSync(resultFile, "utf8")
+      : "";
   const output = fileOutput || stdout;
   const ok = failureMode == null && exitCode === 0;
   return createResult(ok, {
@@ -276,6 +428,6 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
     stderr,
     exitCode,
     duration: Date.now() - startedAt,
-    failureMode: ok ? null : (failureMode || 'crash'),
+    failureMode: ok ? null : failureMode || "crash",
   });
 }

package/hub/codex-adapter.mjs

@@ -1,46 +1,54 @@
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { runPreflight } from './codex-preflight.mjs';
-import { withRetry } from './workers/worker-utils.mjs';
+import { mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
-  createCircuitBreaker,
-  createResult,
-  appendWarnings,
   buildExecCommand,
+  executeWithCircuitBroker,
   normalizePathForShell,
-  shellQuote,
   runProcess,
-} from './cli-adapter-base.mjs';
-
-const breaker = createCircuitBreaker();
+  shellQuote,
+} from "./cli-adapter-base.mjs";
+import { runPreflight } from "./codex-preflight.mjs";
 
 // ── Codex-specific stall inference ──────────────────────────────
 
 function inferStallMode(stdout, stderr) {
   const text = `${stdout}\n${stderr}`.toLowerCase();
-  if (/(rate.?limit|quota|throttl|too.many.requests|429|usage.limit)/u.test(text)) return 'rate_limited';
-  if (/(approval|approve|permission|sandbox|bypass)/u.test(text)) return 'approval_stall';
-  if (/\bmcp\b|context7|playwright|tavily|exa|brave|sequential|server/u.test(text)) return 'mcp_stall';
-  return 'timeout';
+  if (
+    /(rate.?limit|quota|throttl|too.many.requests|429|usage.limit)/u.test(text)
+  )
+    return "rate_limited";
+  if (/(approval|approve|permission|sandbox|bypass)/u.test(text))
+    return "approval_stall";
+  if (
+    /\bmcp\b|context7|playwright|tavily|exa|brave|sequential|server/u.test(text)
+  )
+    return "mcp_stall";
+  return "timeout";
 }
 
 // ── Codex command building ──────────────────────────────────────
 
 function commandWithOverrides(command, prompt, codexPath, overrides = []) {
-  const next = codexPath ? command.replace(/^codex\b/u, shellQuote(codexPath)) : command;
+  const next = codexPath
+    ? command.replace(/^codex\b/u, shellQuote(codexPath))
+    : command;
   if (!overrides.length) return next;
   const promptArg = JSON.stringify(prompt);
-  const flags = overrides.flatMap((value) => ['-c', shellQuote(value)]).join(' ');
+  const flags = overrides
+    .flatMap((value) => ["-c", shellQuote(value)])
+    .join(" ");
   return next.endsWith(promptArg)
     ? `${next.slice(0, -promptArg.length)}${flags} ${promptArg}`
     : `${next} ${flags}`;
 }
 
 function buildOverrides(requested, excluded) {
-  return [...new Set((requested || []).filter((name) => (excluded || []).includes(name)))]
-    .map((name) => `mcp_servers.${name}.enabled=false`);
+  return [
+    ...new Set(
+      (requested || []).filter((name) => (excluded || []).includes(name)),
+    ),
+  ].map((name) => `mcp_servers.${name}.enabled=false`);
 }
 
 function buildAttempts(opts, preflight) {
@@ -63,37 +71,37 @@ function buildAttempts(opts, preflight) {
 // ── Launch script ───────────────────────────────────────────────
 
 function createLaunchScriptText(opts) {
-  const parts = ['codex'];
-  if (opts.profile) parts.push('--profile', shellQuote(opts.profile));
+  const parts = ["codex"];
+  if (opts.profile) parts.push("--profile", shellQuote(opts.profile));
   parts.push(
-    'exec',
-    '--dangerously-bypass-approvals-and-sandbox',
-    '--skip-git-repo-check',
+    "exec",
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--skip-git-repo-check",
     '$(cat "$PROMPT_FILE")',
   );
   return [
-    '#!/usr/bin/env bash',
-    'set -euo pipefail',
+    "#!/usr/bin/env bash",
+    "set -euo pipefail",
     `cd ${shellQuote(normalizePathForShell(opts.workdir))}`,
     `PROMPT_FILE=${shellQuote(normalizePathForShell(opts.promptFile))}`,
-    `TFX_CODEX_TIMEOUT_MS=${shellQuote(String(opts.timeout ?? ''))}`,
-    parts.join(' '),
-    '',
-  ].join('\n');
+    `TFX_CODEX_TIMEOUT_MS=${shellQuote(String(opts.timeout ?? ""))}`,
+    parts.join(" "),
+    "",
+  ].join("\n");
 }
 
 export function buildLaunchScript(opts = {}) {
-  const dir = join(tmpdir(), 'triflux-codex-launch');
+  const dir = join(tmpdir(), "triflux-codex-launch");
   mkdirSync(dir, { recursive: true });
-  const path = join(dir, `${String(opts.id || 'launch')}.sh`);
-  writeFileSync(path, createLaunchScriptText(opts), 'utf8');
+  const path = join(dir, `${String(opts.id || "launch")}.sh`);
+  writeFileSync(path, createLaunchScriptText(opts), "utf8");
   return path;
 }
 
 // ── Exec args builder ───────────────────────────────────────────
 
 export function buildExecArgs(opts = {}) {
-  const prompt = typeof opts.prompt === 'string' ? opts.prompt : '';
+  const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
   const command = buildExecCommand(prompt, opts.resultFile || null, {
     profile: opts.profile,
     skipGitRepoCheck: true,
@@ -101,11 +109,14 @@ export function buildExecArgs(opts = {}) {
     cwd: opts.cwd,
   });
 
-  if (!prompt) return command.replace(/\s+""$/u, '');
+  if (!prompt) return command.replace(/\s+""$/u, "");
 
   let result;
   const quotedPrompt = JSON.stringify(prompt);
-  if (/^\(Get-Content\b[\s\S]*\)$/u.test(prompt) && command.endsWith(quotedPrompt)) {
+  if (
+    /^\(Get-Content\b[\s\S]*\)$/u.test(prompt) &&
+    command.endsWith(quotedPrompt)
+  ) {
     result = `${command.slice(0, -quotedPrompt.length)}${prompt}`;
   } else {
     result = command;
@@ -121,9 +132,12 @@ export function buildExecArgs(opts = {}) {
 // ── Codex execution ─────────────────────────────────────────────
 
 async function runCodex(prompt, workdir, preflight, attempt) {
-  const dir = join(tmpdir(), 'triflux-codex-exec');
+  const dir = join(tmpdir(), "triflux-codex-exec");
   mkdirSync(dir, { recursive: true });
-  const resultFile = join(dir, `codex-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+  const resultFile = join(
+    dir,
+    `codex-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`,
+  );
   const command = commandWithOverrides(
     buildExecCommand(prompt, resultFile, {
       profile: attempt.profile,
@@ -134,66 +148,32 @@ async function runCodex(prompt, workdir, preflight, attempt) {
     preflight.codexPath,
     buildOverrides(attempt.requested, attempt.excluded),
   );
-  return runProcess(command, workdir, attempt.timeout, { resultFile, inferStallMode });
+  return runProcess(command, workdir, attempt.timeout, {
+    resultFile,
+    inferStallMode,
+  });
 }
 
 // ── Public API ──────────────────────────────────────────────────
 
-export function getCircuitState(now) {
-  return breaker.getState(now);
+export async function getCircuitState() {
+  const brokerMod = await import("./account-broker.mjs");
+  if (!brokerMod.broker) return { state: "closed", failures: [] };
+  const snap = brokerMod.broker
+    .snapshot()
+    .filter((a) => a.provider === "codex");
+  return snap.length
+    ? { state: snap[0].circuitState, accounts: snap }
+    : { state: "closed", failures: [] };
 }
 
-export async function execute(opts = {}) {
-  const entry = breaker.canExecute();
-  if (!entry.allowed) {
-    return createResult(false, { fellBack: true, failureMode: 'circuit_open' });
-  }
-
-  const preflight = await runPreflight({ mcpServers: opts.mcpServers, subcommand: 'exec' });
-  if (!preflight.ok) {
-    breaker.clearTrial();
-    breaker.recordFailure(entry.halfOpen);
-    return createResult(false, {
-      stderr: appendWarnings('', preflight.warnings),
-      fellBack: opts.fallbackToClaude !== false,
-      failureMode: 'crash',
-    });
-  }
-
-  const attempts = buildAttempts(opts, preflight);
-  let attemptIndex = 0;
-  let lastResult = createResult(false);
-
-  try {
-    lastResult = await withRetry(async () => {
-      const result = await runCodex(opts.prompt || '', opts.workdir || process.cwd(), preflight, attempts[attemptIndex]);
-      const current = { ...result, stderr: appendWarnings(result.stderr, preflight.warnings), retried: attemptIndex > 0 };
-      const canRetry = !current.ok && attemptIndex < attempts.length - 1;
-      attemptIndex += 1;
-      if (!canRetry) return current;
-      const error = new Error('retry');
-      error.retryable = true;
-      error.result = current;
-      throw error;
-    }, {
-      maxAttempts: attempts.length,
-      baseDelayMs: 250,
-      maxDelayMs: 750,
-      shouldRetry: (error) => error?.retryable === true,
-    });
-  } catch (error) {
-    lastResult = error?.result || createResult(false, { stderr: String(error?.message || error) });
-  }
-
-  if (lastResult.ok) {
-    breaker.reset();
-    return lastResult;
-  }
-
-  breaker.recordFailure(entry.halfOpen);
-  return {
-    ...lastResult,
-    retried: attempts.length > 1,
-    fellBack: opts.fallbackToClaude !== false,
-  };
+export function execute(opts = {}) {
+  return executeWithCircuitBroker({
+    provider: "codex",
+    runFn: runCodex,
+    preflightFn: (o) =>
+      runPreflight({ mcpServers: o.mcpServers, subcommand: "exec" }),
+    buildAttemptsFn: buildAttempts,
+    opts,
+  });
 }

package/hub/codex-compat.mjs

@@ -2,11 +2,11 @@
 
 /** @experimental 런타임 미연결 — 향후 통합 예정 */
 export {
+  buildExecCommand,
   CODEX_MCP_EXECUTION_EXIT_CODE,
   CODEX_MCP_TRANSPORT_EXIT_CODE,
-  FEATURES,
-  buildExecCommand,
   escapePwshSingleQuoted,
+  FEATURES,
   getCodexVersion,
   gte,
-} from './cli-adapter-base.mjs';
+} from "./cli-adapter-base.mjs";