triflux 9.7.7 → 9.7.9

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "triflux",
       "description": "CLI-first multi-model orchestrator for Claude Code. Routes tasks to Codex, Gemini, and Claude CLIs with automatic triage, DAG-based parallel execution, headless psmux sessions, and cost-optimized routing. Includes 41 skills, HUD status bar, hook orchestrator, and shell-based CLI routing.",
-      "version": "9.7.2",
+      "version": "9.7.9",
       "author": {
         "name": "tellang"
       },
@@ -30,5 +30,5 @@
       ]
     }
   ],
-  "version": "9.7.2"
+  "version": "9.7.9"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "9.7.2",
+  "version": "9.7.9",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "author": {
     "name": "tellang"

package/bin/triflux.mjs

@@ -160,12 +160,12 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
     },
   },
   multi: {
-    usage: "tfx multi [--dashboard-layout single|split-2col|split-3col|auto] <subcommand|task>",
+    usage: "tfx multi [--dashboard-layout lite|single|split-2col|split-3col|auto] <subcommand|task>",
     description: "멀티-CLI 팀 모드",
     options: [
       { name: "--dashboard", type: "boolean", description: "headless dashboard viewer 표시 (기본값: 켜짐)" },
       { name: "--no-dashboard", type: "boolean", description: "headless dashboard viewer 비활성화" },
-      { name: "--dashboard-layout", type: "string", description: "dashboard viewer 레이아웃 선택: single|split-2col|split-3col|auto" },
+      { name: "--dashboard-layout", type: "string", description: "dashboard viewer 레이아웃 선택: lite|single|split-2col|split-3col|auto" },
     ],
     subcommands: {
       status: {

package/hooks/pipeline-stop.mjs

@@ -6,7 +6,6 @@
 // 파이프라인이 없으면 정상 종료를 허용한다.
 
 import { existsSync } from "node:fs";
-import { PLUGIN_ROOT } from "./lib/resolve-root.mjs";
 
 let getPipelineStateDbPath;
 let ensurePipelineTable;
@@ -22,7 +21,8 @@ try {
   process.exit(0);
 }
 
-const HUB_DB_PATH = getPipelineStateDbPath(PLUGIN_ROOT);
+const PROJECT_ROOT = process.env.CLAUDE_CWD || process.cwd();
+const HUB_DB_PATH = getPipelineStateDbPath(PROJECT_ROOT);
 const TERMINAL = new Set(["complete", "failed"]);
 
 async function checkActivePipelines() {

package/hub/team/ansi.mjs

@@ -22,6 +22,7 @@ export function moveDown(n = 1)  { return `${ESC}[${n}B`; }
 // ── 줄 제어 ──
 export const clearLine    = `${ESC}[2K`;
 export const clearToEnd   = `${ESC}[K`;
+export const eraseBelow   = `${ESC}[J`;
 
 // ── 색상 (triflux 디자인 시스템) ──
 export const RESET = `${ESC}[0m`;

package/hub/team/cli/commands/start/index.mjs

@@ -16,6 +16,7 @@ function printStartUsage() {
   console.log(`  사용법: ${WHITE}tfx multi "작업 설명"${RESET}`);
   console.log(`          ${WHITE}tfx multi --agents codex,gemini --lead claude "작업"${RESET}`);
   console.log(`          ${WHITE}tfx multi --teammate-mode headless "작업"${RESET} ${DIM}(psmux 헤드리스, 기본)${RESET}`);
+  console.log(`          ${WHITE}tfx multi --dashboard-layout lite "작업"${RESET} ${DIM}(dashboard-lite 기본 뷰)${RESET}`);
   console.log(`          ${WHITE}tfx multi --dashboard-layout auto "작업"${RESET} ${DIM}(dashboard viewer 레이아웃 자동)${RESET}`);
   console.log(`          ${WHITE}tfx multi --dashboard-anchor window "작업"${RESET} ${DIM}(dashboard anchor: window|tab, 기본 window)${RESET}`);
   console.log(`          ${WHITE}tfx multi --teammate-mode wt "작업"${RESET} ${DIM}(Windows Terminal split-pane)${RESET}`);

package/hub/team/cli/commands/start/parse-args.mjs

@@ -50,7 +50,7 @@ export function parseTeamArgs(args = []) {
   let timeoutSec = 300;
   let verbose = false;
   let dashboard = true;
-  let dashboardLayout = "single";
+  let dashboardLayout = "lite";
   let dashboardSize = 0.40;
   let dashboardAnchor = "window";
   let mcpProfile = "";

package/hub/team/cli/help.mjs

@@ -11,6 +11,7 @@ export function renderTeamHelp() {
     ${WHITE}tfx multi --teammate-mode wt "작업"${RESET}   ${DIM}(Windows Terminal split-pane)${RESET}
     ${WHITE}tfx multi --layout 1xN "작업"${RESET}               ${DIM}(세로 분할 컬럼)${RESET}
     ${WHITE}tfx multi --layout Nx1 "작업"${RESET}               ${DIM}(가로 분할 스택)${RESET}
+    ${WHITE}tfx multi --dashboard-layout lite "작업"${RESET}    ${DIM}(dashboard-lite 기본 뷰)${RESET}
     ${WHITE}tfx multi --dashboard-layout auto "작업"${RESET}    ${DIM}(dashboard viewer 레이아웃 자동 결정)${RESET}
     ${WHITE}tfx multi --dashboard-size 0.4 "작업"${RESET}      ${DIM}(대시보드 분할 비율 0.2~0.8, 기본 0.50)${RESET}
     ${WHITE}tfx multi --dashboard-anchor window "작업"${RESET} ${DIM}(대시보드 고정 위치: window|tab, 기본 window)${RESET}

package/hub/team/dashboard-open.mjs

@@ -0,0 +1,150 @@
+import { spawn } from "node:child_process";
+
+import { psmuxExec } from "./psmux.mjs";
+import {
+  detectMultiplexer,
+  focusWtPane,
+  hasWindowsTerminal,
+  resolveAttachCommand,
+  tmuxExec,
+} from "./session.mjs";
+
+function sanitizeWindowTitle(value, fallback = "triflux") {
+  const text = String(value || "").replace(/[\r\n]+/g, " ").trim();
+  return text || fallback;
+}
+
+function sanitizeSessionName(value) {
+  return String(value || "").replace(/[^a-zA-Z0-9_\-]/g, "") || "tfx-session";
+}
+
+function sanitizeWorkingDirectory(value) {
+  const text = String(value || "").replace(/[\r\n\x00-\x1f]/g, "").trim();
+  return text || process.cwd();
+}
+
+export function parseWorkerNumber(value) {
+  const text = String(value || "").trim();
+  const workerMatch = text.match(/^worker-(\d+)$/i);
+  if (workerMatch) return Number.parseInt(workerMatch[1], 10);
+  const paneMatch = text.match(/:(\d+)$/);
+  if (paneMatch) return Number.parseInt(paneMatch[1], 10);
+  return null;
+}
+
+export function decideDashboardOpenMode({ openAll = false, hasWtSession = !!process.env.WT_SESSION } = {}) {
+  if (openAll) return hasWtSession ? "tab" : "window";
+  return hasWtSession ? "split" : "window";
+}
+
+function spawnWindowsTerminal(spec, opts = {}) {
+  if (!hasWindowsTerminal()) return false;
+
+  const {
+    mode = "window",
+    title = "triflux",
+    cwd = process.cwd(),
+    split = { orientation: "H", size: 0.50 },
+  } = opts;
+
+  const safeTitle = sanitizeWindowTitle(title);
+  const safeCwd = sanitizeWorkingDirectory(cwd);
+  const orientation = split?.orientation === "V" ? "V" : "H";
+  const size = Number.isFinite(split?.size) ? Math.min(0.8, Math.max(0.2, split.size)) : 0.50;
+  const baseArgs = ["--profile", "triflux", "--title", safeTitle, "-d", safeCwd, "--", spec.command, ...spec.args];
+  const args = mode === "split"
+    ? ["-w", "0", "sp", `-${orientation}`, "-s", String(size), ...baseArgs]
+    : mode === "tab"
+      ? ["-w", "0", "nt", ...baseArgs]
+      : ["-w", "new", ...baseArgs];
+
+  const child = spawn("wt.exe", args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: false,
+  });
+  child.unref();
+  return true;
+}
+
+export function focusManagedPane(target, opts = {}) {
+  const { teammateMode = "", layout = "1xN" } = opts;
+  const paneRef = String(target || "");
+
+  if (teammateMode === "wt" || paneRef.startsWith("wt:")) {
+    const paneIndex = parseWorkerNumber(paneRef);
+    return paneIndex != null && focusWtPane(paneIndex, { layout });
+  }
+
+  if (!paneRef) return false;
+  try {
+    if (detectMultiplexer() === "psmux") psmuxExec(["select-pane", "-t", paneRef]);
+    else tmuxExec(`select-pane -t ${paneRef}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function openHeadlessDashboardTarget(sessionName, opts = {}) {
+  const {
+    worker = null,
+    openAll = false,
+    cwd = process.cwd(),
+    title,
+  } = opts;
+
+  const safeSession = sanitizeSessionName(sessionName);
+  const workerNumber = worker == null ? null : parseWorkerNumber(worker);
+
+  if (!openAll && workerNumber != null) {
+    try {
+      psmuxExec(["select-pane", "-t", `${safeSession}:0.${workerNumber}`]);
+    } catch {}
+  }
+
+  return spawnWindowsTerminal(
+    { command: "psmux", args: ["attach-session", "-t", safeSession] },
+    {
+      mode: decideDashboardOpenMode({ openAll }),
+      title: title || (openAll ? `▲ ${safeSession}` : `▲ ${safeSession}:${workerNumber ?? "all"}`),
+      cwd,
+    },
+  );
+}
+
+export function openDashboardRuntimeTarget(runtime, opts = {}) {
+  const {
+    teammateMode = "",
+    sessionName = "",
+    targetPane = "",
+    layout = "1xN",
+    openAll = false,
+    cwd = process.cwd(),
+    title = "",
+  } = { ...runtime, ...opts };
+
+  if (teammateMode === "headless") {
+    return openHeadlessDashboardTarget(sessionName, {
+      worker: openAll ? null : targetPane,
+      openAll,
+      cwd,
+      title,
+    });
+  }
+
+  if ((teammateMode === "wt" || String(targetPane).startsWith("wt:")) && !openAll) {
+    return focusManagedPane(targetPane, { teammateMode: "wt", layout });
+  }
+
+  try {
+    if (!openAll && targetPane) focusManagedPane(targetPane, { teammateMode, layout });
+    return spawnWindowsTerminal(resolveAttachCommand(sessionName), {
+      mode: decideDashboardOpenMode({ openAll }),
+      title: title || `▲ ${sanitizeSessionName(sessionName)}`,
+      cwd,
+    });
+  } catch {
+    return false;
+  }
+}

package/hub/team/tui-lite.mjs

@@ -1,4 +1,4 @@
-import { altScreenOff, altScreenOn, BG, bold, box, clearScreen, color, cursorHide, cursorHome, cursorShow, dim, FG, MOCHA, padRight, progressBar, statusBadge, stripAnsi, truncate, wcswidth } from "./ansi.mjs";
+import { altScreenOff, altScreenOn, BG, bold, box, clearScreen, clearToEnd, color, cursorHide, cursorHome, cursorShow, dim, eraseBelow, FG, MOCHA, padRight, progressBar, statusBadge, stripAnsi, truncate, wcswidth } from "./ansi.mjs";
 
 const FALLBACK_COLUMNS = 100, FALLBACK_ROWS = 24;
 const VALID_TABS = new Set(["log", "detail", "files"]);
@@ -154,8 +154,11 @@ function buildDetail(workerName, worker, width, tab, helpVisible) {
     return frame(
       [
         bold("tui-lite"),
-        "selectWorker(name) / setFocusTab(tab) / render()",
-        "tabs: log | detail | files",
+        "j/k or arrows: worker selection",
+        "Enter: open selected worker",
+        "Shift+Enter: open all workers",
+        "l: tabs log/detail/files",
+        "1-9: direct select, q: quit",
         "toggleDetail(false) 로 상세 패널 숨김",
       ],
       width,
@@ -185,11 +188,14 @@ function buildDetail(workerName, worker, width, tab, helpVisible) {
 export function createLiteDashboard(opts = {}) {
   const {
     stream = process.stdout,
+    input = process.stdin,
     refreshMs = 1000,
     columns,
     rows,
     layout = "auto",
     forceTTY = false,
+    onOpenSelectedWorker,
+    onOpenAllWorkers,
   } = opts;
 
   const isTTY = forceTTY || !!stream?.isTTY;
@@ -203,6 +209,8 @@ export function createLiteDashboard(opts = {}) {
   let detailExpanded = true;
   let focusTab = "log";
   let helpVisible = false;
+  let inputAttached = false;
+  let rawModeEnabled = false;
 
   const write = (text) => { if (!closed) stream.write(text); };
   const workerNames = () => [...workers.keys()].sort();
@@ -210,6 +218,95 @@ export function createLiteDashboard(opts = {}) {
   const viewportRows = () => Math.max(10, rows || stream?.rows || process.stdout?.rows || FALLBACK_ROWS);
   const ensureSelection = (names) => { if (names.length && (!selectedWorker || !workers.has(selectedWorker))) selectedWorker = names[0]; };
 
+  function selectRelative(offset) {
+    const names = workerNames();
+    if (names.length === 0) return;
+    ensureSelection(names);
+    const idx = Math.max(0, names.indexOf(selectedWorker));
+    selectedWorker = names[(idx + offset + names.length) % names.length];
+  }
+
+  function triggerOpenSelected() {
+    if (typeof onOpenSelectedWorker !== "function" || !selectedWorker || !workers.has(selectedWorker)) return;
+    try {
+      const result = onOpenSelectedWorker(selectedWorker, workers.get(selectedWorker), new Map(workers));
+      if (result && typeof result.catch === "function") result.catch(() => {});
+    } catch {}
+  }
+
+  function triggerOpenAll() {
+    if (typeof onOpenAllWorkers !== "function") return;
+    try {
+      const result = onOpenAllWorkers(selectedWorker, workers.get(selectedWorker), new Map(workers));
+      if (result && typeof result.catch === "function") result.catch(() => {});
+    } catch {}
+  }
+
+  function handleInput(chunk) {
+    const key = String(chunk);
+    if (key === "\u0003") return;
+
+    if (helpVisible) {
+      helpVisible = false;
+      render();
+      return;
+    }
+
+    if (key === "j" || key === "\u001b[B") {
+      selectRelative(1);
+      render();
+      return;
+    }
+    if (key === "k" || key === "\u001b[A") {
+      selectRelative(-1);
+      render();
+      return;
+    }
+    if (key === "\r" || key === "\n") {
+      triggerOpenSelected();
+      return;
+    }
+    if (key === "\x1b[13;2u" || key === "\x1b[27;13;2~" || key === "\x1b\r" || key === "\x1b\n") {
+      triggerOpenAll();
+      return;
+    }
+    if (key === "l") {
+      const tabs = ["log", "detail", "files"];
+      focusTab = tabs[(tabs.indexOf(focusTab) + 1) % tabs.length];
+      render();
+      return;
+    }
+    if (key === "h" || key === "?") {
+      helpVisible = true;
+      render();
+      return;
+    }
+    if (key === "q") {
+      close();
+      return;
+    }
+    if (/^[1-9]$/.test(key)) {
+      const names = workerNames();
+      const target = names[Number.parseInt(key, 10) - 1];
+      if (target) {
+        selectedWorker = target;
+        render();
+      }
+    }
+  }
+
+  function attachInput() {
+    if (inputAttached) return;
+    if (!isTTY || !input?.isTTY || typeof input?.on !== "function") return;
+    inputAttached = true;
+    if (typeof input.setRawMode === "function") {
+      input.setRawMode(true);
+      rawModeEnabled = true;
+    }
+    if (typeof input.resume === "function") input.resume();
+    input.on("data", handleInput);
+  }
+
   function buildRows() {
     const names = workerNames();
     ensureSelection(names);
@@ -235,15 +332,22 @@ export function createLiteDashboard(opts = {}) {
 
   function render() {
     if (closed) return;
+    attachInput();
     frameCount++;
     const rowsOut = buildRows();
-    if (isTTY) write(cursorHome + clearScreen + rowsOut.join("\n"));
-    else write(`${rowsOut.join("\n")}\n`);
+    if (isTTY) {
+      const width = viewportColumns();
+      const padded = rowsOut.map((line) => padRight(String(line ?? ""), width) + clearToEnd);
+      write(cursorHome + padded.join("\n") + eraseBelow);
+    } else write(`${rowsOut.join("\n")}\n`);
   }
 
   function close() {
     if (closed) return;
     if (timer) clearInterval(timer);
+    if (inputAttached && typeof input?.off === "function") input.off("data", handleInput);
+    if (rawModeEnabled && typeof input?.setRawMode === "function") input.setRawMode(false);
+    if (inputAttached && typeof input?.pause === "function") input.pause();
     if (isTTY) write(cursorShow + altScreenOff);
     closed = true;
   }

package/hub/team/tui-viewer.mjs

@@ -9,6 +9,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { createLogDashboard } from "./tui.mjs";
 import { createLiteDashboard } from "./tui-lite.mjs";
+import { openHeadlessDashboardTarget } from "./dashboard-open.mjs";
 import { processHandoff } from "./handoff.mjs";
 import { statusBadge } from "./ansi.mjs";
 
@@ -53,6 +54,15 @@ const tui = tuiFactory({
   input: process.stdin,
   columns: process.stdout.columns || parseInt(process.env.COLUMNS, 10) || 120,
   layout: LAYOUT,
+  onOpenSelectedWorker: (workerName) => openHeadlessDashboardTarget(SESSION, {
+    worker: workerName,
+    openAll: false,
+    cwd: process.cwd(),
+  }),
+  onOpenAllWorkers: () => openHeadlessDashboardTarget(SESSION, {
+    openAll: true,
+    cwd: process.cwd(),
+  }),
 });
 const startTime = Date.now();
 tui.setStartTime(startTime);
@@ -221,6 +231,8 @@ function makeWorkerState(paneIdx) {
     handoff: null,
     progress: 0,
     activityAt: Date.now(),
+    title: "",
+    cli: "codex",
   };
 }
 
@@ -278,6 +290,8 @@ function ingest() {
     let cli = "codex";
     if (pane.title.includes("gemini") || pane.title.includes("🔵")) cli = "gemini";
     else if (pane.title.includes("claude") || pane.title.includes("🟠")) cli = "claude";
+    ws.title = pane.title;
+    ws.cli = cli;
 
     const resultData = checkResultFile(paneName);
     if (resultData?.processed && !resultData.processed.fallback) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "9.7.7",
+  "version": "9.7.9",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {

package/scripts/cache-warmup.mjs

@@ -14,10 +14,12 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 import { readPreflightCache } from "./preflight-cache.mjs";
-import { checkCli, checkHub, detectCodexPlan } from "./lib/env-probe.mjs";
+import { checkCli, checkHub, detectCodexAuthState } from "./lib/env-probe.mjs";
 import { SEARCH_SERVER_ORDER, MCP_SERVER_DOMAIN_TAGS } from "./lib/mcp-server-catalog.mjs";
 
 export const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
+const WARMUP_METADATA_FILE = ["state", "warmup-metadata.json"];
+const AUTH_SENSITIVE_TARGETS = new Set(["codexSkills", "tierEnvironment", "searchEngines"]);
 
 export const CACHE_TARGETS = Object.freeze({
   codexSkills: Object.freeze({
@@ -83,6 +85,21 @@ export function resolveTargetPath(target, { cwd = process.cwd() } = {}) {
   return join(omcDir, ...spec.file);
 }
 
+function resolveWarmupMetadataPath({ cwd = process.cwd() } = {}) {
+  const { omcDir } = resolveRootDirs(cwd);
+  return join(omcDir, ...WARMUP_METADATA_FILE);
+}
+
+function readWarmupMetadata(options = {}) {
+  const metadataPath = resolveWarmupMetadataPath(options);
+  if (!existsSync(metadataPath)) return null;
+  try {
+    return JSON.parse(readFileSync(metadataPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
 function resolveTtlMs(target, options = {}) {
   if (Number.isFinite(options.ttlByTarget?.[target])) {
     return Math.max(0, Math.trunc(options.ttlByTarget[target]));
@@ -188,6 +205,7 @@ export function probeTierEnvironment(options = {}) {
   const homeDir = resolveHomeDir(options.homeDir);
   const preflight = options.preflight ?? readPreflightCache();
   const execSyncFn = options.execSyncFn || execSync;
+  const codexAuth = preflight?.codex_plan ?? detectCodexAuthState({ homeDir });
 
   const codexCheck = preflight?.codex || checkCli("codex", { execSyncFn });
   const geminiCheck = preflight?.gemini || checkCli("gemini", { execSyncFn });
@@ -198,8 +216,6 @@ export function probeTierEnvironment(options = {}) {
     pollAttempts: options.hubRestart === true ? 8 : 0,
     execSyncFn,
   });
-  const codexPlan = preflight?.codex_plan || detectCodexPlan({ homeDir });
-
   const checks = {
     psmux: false,
     hub: !!hubCheck?.ok,
@@ -241,7 +257,9 @@ export function probeTierEnvironment(options = {}) {
     tier,
     checks,
     available_agents: agents,
-    codex_plan: codexPlan,
+    codex_plan: codexAuth.source == null
+      ? { plan: codexAuth.plan }
+      : { plan: codexAuth.plan, source: codexAuth.source },
     source: {
       preflight: !!preflight,
       home_dir: homeDir,
@@ -250,6 +268,21 @@ export function probeTierEnvironment(options = {}) {
   };
 }
 
+function getCodexAuthFingerprint(options = {}) {
+  if (typeof options.preflight?.codex_plan?.fingerprint === "string") {
+    return options.preflight.codex_plan.fingerprint;
+  }
+  return detectCodexAuthState({ homeDir: resolveHomeDir(options.homeDir) }).fingerprint;
+}
+
+function hasAuthFingerprintChanged(target, options = {}) {
+  if (!AUTH_SENSITIVE_TARGETS.has(target)) return false;
+  const nextFingerprint = getCodexAuthFingerprint(options);
+  const previousFingerprint = readWarmupMetadata(options)?.codex_auth_fingerprint || null;
+  if (previousFingerprint === null) return false;
+  return previousFingerprint !== nextFingerprint;
+}
+
 export function extractProjectMeta(options = {}) {
   const cwd = options.cwd || process.cwd();
   const execSyncFn = options.execSyncFn || execSync;
@@ -422,7 +455,7 @@ export function checkSearchEngines(options = {}) {
 
 function buildTarget(target, options = {}) {
   const filePath = resolveTargetPath(target, options);
-  if (!options.force && isFresh(target, options)) {
+  if (!options.force && isFresh(target, options) && !hasAuthFingerprintChanged(target, options)) {
     return { target, status: "skipped", file: filePath, reason: "fresh" };
   }
 
@@ -476,6 +509,15 @@ export function buildAll(options = {}) {
   const built = results.filter((result) => result.status === "built").length;
   const skipped = results.filter((result) => result.status === "skipped").length;
   const failed = results.filter((result) => result.status === "failed").length;
+  const authFingerprint = getCodexAuthFingerprint(options);
+
+  if (failed === 0) {
+    writeJSON(resolveWarmupMetadataPath(options), {
+      updated_at: new Date(options.now ?? Date.now()).toISOString(),
+      codex_auth_fingerprint: authFingerprint,
+      targets,
+    });
+  }
 
   return {
     ok: failed === 0,

package/scripts/lib/env-probe.mjs

@@ -3,6 +3,7 @@ import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { execSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
 
 const DEFAULT_STATUS_URL = "http://127.0.0.1:27888/status";
 const _sab = new Int32Array(new SharedArrayBuffer(4));
@@ -48,29 +49,58 @@ export function checkCli(name, { execSyncFn = execSync } = {}) {
   }
 }
 
-export function detectCodexPlan({
+export function detectCodexAuthState({
   homeDir = homedir(),
   existsSyncFn = existsSync,
   readFileSyncFn = readFileSync,
 } = {}) {
   try {
     const authPath = join(homeDir, ".codex", "auth.json");
-    if (!existsSyncFn(authPath)) return { plan: "unknown", source: "no_auth" };
+    if (!existsSyncFn(authPath)) return { plan: "unknown", source: "no_auth", fingerprint: "no_auth" };
 
     const auth = JSON.parse(readFileSyncFn(authPath, "utf8"));
-    if (auth.auth_mode !== "chatgpt") return { plan: "api", source: "api_key" };
+    if (auth.auth_mode !== "chatgpt") {
+      const fingerprint = createHash("sha256")
+        .update(JSON.stringify({
+          auth_mode: auth.auth_mode || "api_key",
+          has_api_key: Boolean(auth.api_key || auth.apiKey),
+        }))
+        .digest("hex");
+      return { plan: "api", source: "api_key", fingerprint };
+    }
 
     const token = auth.tokens?.id_token || auth.tokens?.access_token;
-    if (!token) return { plan: "unknown", source: "no_token" };
+    if (!token) {
+      return {
+        plan: "unknown",
+        source: "no_token",
+        fingerprint: createHash("sha256")
+          .update(JSON.stringify({ auth_mode: auth.auth_mode || "chatgpt", token: null }))
+          .digest("hex"),
+      };
+    }
 
     const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString());
     const plan = payload?.["https://api.openai.com/auth"]?.chatgpt_plan_type || "unknown";
-    return { plan, source: "jwt" };
+    const fingerprint = createHash("sha256")
+      .update(JSON.stringify({
+        auth_mode: auth.auth_mode || "chatgpt",
+        plan,
+        sub: payload?.sub || null,
+        exp: payload?.exp || null,
+      }))
+      .digest("hex");
+    return { plan, source: "jwt", fingerprint };
   } catch {
-    return { plan: "unknown", source: "error" };
+    return { plan: "unknown", source: "error", fingerprint: "error" };
   }
 }
 
+export function detectCodexPlan(options = {}) {
+  const { plan, source } = detectCodexAuthState(options);
+  return { plan, source };
+}
+
 export function checkHub({
   pkgRoot = DEFAULT_PKG_ROOT,
   statusUrl = DEFAULT_STATUS_URL,