@triflux/core 10.1.0 → 10.26.0

package/hub/codex-adapter.mjs

@@ -1,46 +1,55 @@
-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 { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
 import {
-  createCircuitBreaker,
-  createResult,
-  appendWarnings,
   buildExecCommand,
+  createResult,
+  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,49 +72,58 @@ 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,
     sandboxBypass: true,
     cwd: opts.cwd,
+    // stdinPrompt 가 명시되면 buildExecCommand 로 forward.
+    // headless 워커 spawn (backend.mjs) 은 default (stdin on, macOS hook fix).
+    // launcher path (launcher-template.mjs) 는 결정론 위해 false 전달.
+    stdinPrompt: opts.stdinPrompt,
   });
 
-  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)) {
+  // PowerShell: (Get-Content -Raw '...'), bash: "$(cat '...')"
+  if (
+    (/^\(Get-Content\b[\s\S]*\)$/u.test(prompt) ||
+      /^"\$\(cat\b[\s\S]*\)"$/u.test(prompt)) &&
+    command.endsWith(quotedPrompt)
+  ) {
     result = `${command.slice(0, -quotedPrompt.length)}${prompt}`;
   } else {
     result = command;
@@ -120,13 +138,16 @@ export function buildExecArgs(opts = {}) {
 
 // ── Codex execution ─────────────────────────────────────────────
 
-async function runCodex(prompt, workdir, preflight, attempt) {
-  const dir = join(tmpdir(), 'triflux-codex-exec');
+async function runCodex(prompt, workdir, preflight, attempt, lease) {
+  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,
+      profile: lease?.profile ?? attempt.profile,
       skipGitRepoCheck: true,
       sandboxBypass: attempt.forceBypass,
     }),
@@ -134,66 +155,131 @@ async function runCodex(prompt, workdir, preflight, attempt) {
     preflight.codexPath,
     buildOverrides(attempt.requested, attempt.excluded),
   );
-  return runProcess(command, workdir, attempt.timeout, { resultFile, inferStallMode });
+  // PRD A1 — lease 메타데이터를 spawn env 에 적용한다. lease.authFile 이 있으면
+  // 해당 파일이 위치한 디렉토리를 CODEX_HOME 으로 export 해서 codex CLI 가 그
+  // account 의 auth.json 을 사용하게 한다. lease 가 null 이면 default ~/.codex
+  // 동작 유지 (회귀 없음). lease.env 는 추가 환경변수 (provider 고정 등) 주입용.
+  const spawnEnv = lease ? buildLeaseSpawnEnv(lease) : undefined;
+  const authCheck = validateLeaseAuth(lease, spawnEnv);
+  if (!authCheck.ok) {
+    return createResult(false, {
+      stderr: authCheck.error,
+      failureMode: "auth_sync",
+      skipCircuit: true,
+    });
+  }
+  return runProcess(command, workdir, attempt.timeout, {
+    resultFile,
+    inferStallMode,
+    spawnEnv,
+  });
 }
 
-// ── Public API ──────────────────────────────────────────────────
-
-export function getCircuitState(now) {
-  return breaker.getState(now);
+function buildLeaseSpawnEnv(lease) {
+  const extra = {};
+  if (lease.authFile) {
+    // lease.authFile 은 보통 ~/.claude/cache/tfx-hub/codex-auth-<account>.json 형식.
+    // codex CLI 는 CODEX_HOME 을 통해 auth.json 위치를 결정하므로, 이 cache 파일을
+    // 직접 CODEX_HOME 후보 디렉토리로 사용한다. cache 파일 자체가 auth.json 이름이
+    // 아니라면 후속 PR 에서 isolated dir + symlink/복사 처리한다 (PRD Open Question).
+    // 현재는 lease.authFile 의 dirname 을 export 하되, 그 dirname 안에 auth.json 이
+    // 실제로 있을 때만 적용한다 (false-positive 회피).
+    try {
+      const dir = dirnameOf(lease.authFile);
+      if (dir) extra.CODEX_HOME = dir;
+    } catch {}
+  }
+  if (lease.env && typeof lease.env === "object") {
+    Object.assign(extra, lease.env);
+  }
+  return Object.keys(extra).length ? { ...process.env, ...extra } : undefined;
 }
 
-export async function execute(opts = {}) {
-  const entry = breaker.canExecute();
-  if (!entry.allowed) {
-    return createResult(false, { fellBack: true, failureMode: 'circuit_open' });
+function validateLeaseAuth(lease, spawnEnv) {
+  if (!lease?.authFile) return { ok: true };
+  if (basename(lease.authFile) !== "auth.json") {
+    return {
+      ok: false,
+      error: `lease authFile must resolve to auth.json for account ${lease.id}`,
+    };
   }
-
-  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',
-    });
+  if (!existsSync(lease.authFile)) {
+    return {
+      ok: false,
+      error: `lease authFile missing for account ${lease.id}: ${lease.authFile}`,
+    };
+  }
+  if (dirnameOf(lease.authFile) !== spawnEnv?.CODEX_HOME) {
+    return {
+      ok: false,
+      // This is currently expected to match because buildLeaseSpawnEnv derives
+      // CODEX_HOME from authFile. Keep the guard so future lease.env overrides
+      // cannot silently point Codex at a different account home.
+      error: `CODEX_HOME mismatch for account ${lease.id}`,
+    };
   }
-
-  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,
-    });
+    const parsed = JSON.parse(readFileSync(lease.authFile, "utf8"));
+    const accountId =
+      parsed?.tokens?.account_id ??
+      parsed?.account_id ??
+      parsed?.accountId ??
+      null;
+    if (!accountId) {
+      return {
+        ok: false,
+        error: `lease authFile has no account_id for account ${lease.id}`,
+      };
+    }
+    if (accountId !== lease.id) {
+      return {
+        ok: false,
+        error: `lease authFile account mismatch: expected ${lease.id}, got ${accountId}`,
+      };
+    }
   } catch (error) {
-    lastResult = error?.result || createResult(false, { stderr: String(error?.message || error) });
+    return {
+      ok: false,
+      error: `lease authFile unreadable for account ${lease.id}: ${error?.message || error}`,
+    };
   }
+  return { ok: true };
+}
 
-  if (lastResult.ok) {
-    breaker.reset();
-    return lastResult;
-  }
+function dirnameOf(filePath) {
+  if (typeof filePath !== "string" || !filePath) return null;
+  const lastSep = Math.max(
+    filePath.lastIndexOf("/"),
+    filePath.lastIndexOf("\\"),
+  );
+  if (lastSep < 0) return null;
+  return filePath.slice(0, lastSep);
+}
 
-  breaker.recordFailure(entry.halfOpen);
-  return {
-    ...lastResult,
-    retried: attempts.length > 1,
-    fellBack: opts.fallbackToClaude !== false,
-  };
+// ── Public API ──────────────────────────────────────────────────
+
+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 function execute(opts = {}) {
+  return executeWithCircuitBroker({
+    provider: "codex",
+    runFn: runCodex,
+    preflightFn: (o) =>
+      runPreflight({
+        mcpServers: o.mcpServers,
+        subcommand: "exec",
+        workdir: o.workdir,
+      }),
+    buildAttemptsFn: buildAttempts,
+    opts,
+  });
 }

package/hub/codex-compat.mjs

@@ -1,12 +1,12 @@
 // hub/codex-compat.mjs — backward-compatible facade for legacy imports
 
-/** @experimental */
+/** @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";

package/hub/codex-preflight.mjs

@@ -1,28 +1,30 @@
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { execSync } from 'node:child_process';
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
-import { whichCommandAsync } from './platform.mjs';
+import { whichCommandAsync } from "./platform.mjs";
 
 const MIN_RECOMMENDED_MINOR = 118;
 let _cachedVersion = null;
 
 function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-function readConfigText(configPath = join(homedir(), '.codex', 'config.toml')) {
-  if (!existsSync(configPath)) return '';
+function readConfigText(configPath = join(homedir(), ".codex", "config.toml")) {
+  if (!existsSync(configPath)) return "";
   try {
-    return readFileSync(configPath, 'utf8');
+    return readFileSync(configPath, "utf8");
   } catch {
-    return '';
+    return "";
   }
 }
 
 function readTomlString(text, key) {
-  const match = String(text).match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, 'mu'));
+  const match = String(text).match(
+    new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, "mu"),
+  );
   return match?.[1] ?? null;
 }
 
@@ -30,13 +32,13 @@ function readSection(text, name) {
   const lines = String(text).split(/\r?\n/u);
   const header = `[${name}]`;
   const start = lines.findIndex((line) => line.trim() === header);
-  if (start < 0) return '';
+  if (start < 0) return "";
   const body = [];
   for (const line of lines.slice(start + 1)) {
     if (/^\s*\[[^\]]+\]\s*$/u.test(line)) break;
     body.push(line);
   }
-  return body.join('\n');
+  return body.join("\n");
 }
 
 /**
@@ -47,7 +49,10 @@ function readSection(text, name) {
 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();
     // "codex 0.117.0" 또는 "0.117.0" 형식 대응
     const match = out.match(/(\d+)\.(\d+)\.(\d+)/);
     _cachedVersion = match ? parseInt(match[2], 10) : 0;
@@ -58,29 +63,34 @@ export function getCodexVersion() {
 }
 
 async function checkCodexInstalled() {
-  const codexPath = await whichCommandAsync('codex');
+  const codexPath = await whichCommandAsync("codex");
   if (codexPath) return { codexPath, ok: true, warnings: [] };
   return {
     codexPath: null,
     ok: false,
-    warnings: ['Codex CLI not found. Install Codex and ensure `codex` is available on PATH.'],
+    warnings: [
+      "Codex CLI not found. Install Codex and ensure `codex` is available on PATH.",
+    ],
   };
 }
 
 function checkCodexVersion() {
   const version = getCodexVersion();
-  const warnings = version >= MIN_RECOMMENDED_MINOR
-    ? []
-    : [`Codex CLI 0.${version}.x detected; 0.${MIN_RECOMMENDED_MINOR}.x or newer is recommended.`];
+  const warnings =
+    version >= MIN_RECOMMENDED_MINOR
+      ? []
+      : [
+          `Codex CLI 0.${version}.x detected; 0.${MIN_RECOMMENDED_MINOR}.x or newer is recommended.`,
+        ];
   return { version, warnings };
 }
 
 function checkApprovalMode(configText, opts = {}) {
-  const approvalMode = readTomlString(configText, 'approval_mode');
-  const sandbox = readTomlString(configText, 'sandbox');
-  const subcommand = opts.subcommand || 'exec';
+  const approvalMode = readTomlString(configText, "approval_mode");
+  const sandbox = readTomlString(configText, "sandbox");
+  const subcommand = opts.subcommand || "exec";
   return {
-    needsBypass: subcommand === 'exec' || approvalMode !== 'full-auto',
+    needsBypass: subcommand === "exec" || approvalMode !== "full-auto",
     approvalMode,
     sandbox,
   };
@@ -88,28 +98,41 @@ function checkApprovalMode(configText, opts = {}) {
 
 async function verifyServerHealth(name, configText) {
   const section = readSection(configText, `mcp_servers.${name}`);
-  if (!section) return { ok: false, warning: `MCP server '${name}' is not configured.` };
+  if (!section)
+    return { ok: false, warning: `MCP server '${name}' is not configured.` };
   if (/^\s*enabled\s*=\s*false\s*$/mu.test(section)) {
-    return { ok: false, warning: `MCP server '${name}' is disabled in config.toml.` };
+    return {
+      ok: false,
+      warning: `MCP server '${name}' is disabled in config.toml.`,
+    };
   }
 
-  const command = readTomlString(section, 'command');
+  const command = readTomlString(section, "command");
   if (command) {
     const resolved = await whichCommandAsync(command);
     return resolved
-      ? { ok: true, warning: '' }
-      : { ok: false, warning: `MCP server '${name}' command not found: ${command}` };
+      ? { ok: true, warning: "" }
+      : {
+          ok: false,
+          warning: `MCP server '${name}' command not found: ${command}`,
+        };
   }
 
-  const url = readTomlString(section, 'url');
-  if (!url || !/^https?:\/\//u.test(url)) return { ok: true, warning: '' };
+  const url = readTomlString(section, "url");
+  if (!url || !/^https?:\/\//u.test(url)) return { ok: true, warning: "" };
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(2000) });
     return response.status < 500
-      ? { ok: true, warning: '' }
-      : { ok: false, warning: `MCP server '${name}' returned HTTP ${response.status}.` };
+      ? { ok: true, warning: "" }
+      : {
+          ok: false,
+          warning: `MCP server '${name}' returned HTTP ${response.status}.`,
+        };
   } catch {
-    return { ok: false, warning: `MCP server '${name}' is unreachable at ${url}.` };
+    return {
+      ok: false,
+      warning: `MCP server '${name}' is unreachable at ${url}.`,
+    };
   }
 }
 
@@ -118,7 +141,7 @@ async function checkMcpHealth(mcpServers, configText) {
   const warnings = [];
 
   for (const name of Array.isArray(mcpServers) ? mcpServers : []) {
-    const server = String(name ?? '').trim();
+    const server = String(name ?? "").trim();
     if (!server) continue;
     const result = await verifyServerHealth(server, configText);
     if (!result.ok) excludeMcpServers.push(server);
@@ -128,6 +151,53 @@ async function checkMcpHealth(mcpServers, configText) {
   return { excludeMcpServers, warnings };
 }
 
+/**
+ * Detects codex config drift between global (~/.codex/config.toml) and the
+ * target workdir. Covers:
+ *   1. workdir-local `.codex/config.toml` overriding global approval_mode/sandbox
+ *   2. instruction-file asymmetry (AGENTS.md vs CLAUDE.md)
+ *
+ * @param {string} [workdir] absolute path to the invocation workdir
+ * @param {string} [globalConfigText] already-read ~/.codex/config.toml content
+ * @returns {{ warnings: string[] }}
+ */
+export function detectWorkdirDrift(workdir, globalConfigText = "") {
+  if (!workdir || typeof workdir !== "string") return { warnings: [] };
+  const warnings = [];
+
+  const localCodexConfig = join(workdir, ".codex", "config.toml");
+  if (existsSync(localCodexConfig)) {
+    let localText = "";
+    try {
+      localText = readFileSync(localCodexConfig, "utf8");
+    } catch {
+      localText = "";
+    }
+    const keys = ["approval_mode", "sandbox", "model"];
+    for (const key of keys) {
+      const local = readTomlString(localText, key);
+      const global = readTomlString(globalConfigText, key);
+      if (local && local !== global) {
+        warnings.push(
+          `workdir '.codex/config.toml' overrides ${key}='${local}' (global='${global || "unset"}').`,
+        );
+      }
+    }
+  }
+
+  const hasAgentsMd = existsSync(join(workdir, "AGENTS.md"));
+  const hasClaudeMd = existsSync(join(workdir, "CLAUDE.md"));
+  if (hasAgentsMd !== hasClaudeMd) {
+    const present = hasAgentsMd ? "AGENTS.md" : "CLAUDE.md";
+    const missing = hasAgentsMd ? "CLAUDE.md" : "AGENTS.md";
+    warnings.push(
+      `workdir has ${present} but not ${missing}; codex and other CLIs may read different instruction sources.`,
+    );
+  }
+
+  return { warnings };
+}
+
 export async function runPreflight(opts = {}) {
   const install = await checkCodexInstalled();
   if (!install.ok) {
@@ -147,14 +217,20 @@ export async function runPreflight(opts = {}) {
 
   const configText = readConfigText(opts.configPath);
   const approval = checkApprovalMode(configText, opts);
-  if (approval.approvalMode !== 'full-auto') {
-    warnings.push(`approval_mode is '${approval.approvalMode || 'unset'}'; bypass flag will be used.`);
+  if (approval.approvalMode !== "full-auto") {
+    warnings.push(
+      `approval_mode is '${approval.approvalMode || "unset"}'; bypass flag will be used.`,
+    );
   }
-  if (approval.sandbox) warnings.push(`sandbox mode from config.toml: ${approval.sandbox}`);
+  if (approval.sandbox)
+    warnings.push(`sandbox mode from config.toml: ${approval.sandbox}`);
 
   const mcp = await checkMcpHealth(opts.mcpServers, configText);
   warnings.push(...mcp.warnings);
 
+  const drift = detectWorkdirDrift(opts.workdir, configText);
+  warnings.push(...drift.warnings);
+
   return {
     codexPath: install.codexPath,
     version,