@triflux/core 10.44.0 → 10.45.0

package/hud/context-monitor.mjs

@@ -15,13 +15,12 @@ const MAX_CAPTURE_BYTES = 256 * 1024;
 const MAX_TOP_KEYS = 20;
 
 // stdin 이 context_window_size 를 제공하지 않을 때 모델 ID 로 한도를 추정한다.
-// Anthropic 공식 문서(2026-04 기준): Opus 4.8 / Opus 4.7 / Opus 4.6 / Sonnet 4.6 = 1M,
-// Sonnet 4.5 / Haiku 4.5 = 200K. 그 외 모델은 [1m] suffix 로 opt-in 가능.
+// Anthropic 공식 문서(2026-09-22 기준): Opus 4.6 이상, Sonnet 4.6/5,
+// Fable 5/5.1 = 1M. Sonnet 4.5 / Haiku 4.5 = 200K이며 [1m]도 유지한다.
 const MODEL_HINT_1M_PREFIXES = [
-  "claude-opus-4-8",
-  "claude-opus-4-7",
-  "claude-opus-4-6",
   "claude-sonnet-4-6",
+  "claude-sonnet-5",
+  "claude-fable-5",
 ];
 
 function normalizeModelId(modelId) {
@@ -29,24 +28,34 @@ function normalizeModelId(modelId) {
   return String(modelId).toLowerCase();
 }
 
-function resolveModelLimit(modelId) {
-  const id = normalizeModelId(modelId);
-  if (!id) return DEFAULT_CONTEXT_LIMIT;
-  if (id.includes("[1m]")) return MILLION_CONTEXT_LIMIT;
-  for (const prefix of MODEL_HINT_1M_PREFIXES) {
-    if (id.startsWith(prefix)) return MILLION_CONTEXT_LIMIT;
-  }
-  return DEFAULT_CONTEXT_LIMIT;
+function isMillionContextOpusModel(modelId) {
+  const match = /^claude-opus-(\d+)(?:-(\d+))?(?:$|[-[\s])/u.exec(modelId);
+  if (!match) return false;
+
+  const major = Number(match[1]);
+  const minor = Number(match[2] || 0);
+  return major > 4 || (major === 4 && minor >= 6);
 }
 
-export function shouldSuppressInfoOnlyContextStatus(modelId) {
+function isMillionContextModel(modelId) {
   const id = normalizeModelId(modelId);
   if (!id) return false;
-  return (
-    id.startsWith("claude-opus-4-8") ||
-    id.startsWith("claude-opus-4-7") ||
-    id.includes("[1m]")
-  );
+  if (id.includes("[1m]")) return true;
+  if (isMillionContextOpusModel(id)) return true;
+  return MODEL_HINT_1M_PREFIXES.some((prefix) => id.startsWith(prefix));
+}
+
+function resolveModelLimit(modelId) {
+  return isMillionContextModel(modelId)
+    ? MILLION_CONTEXT_LIMIT
+    : DEFAULT_CONTEXT_LIMIT;
+}
+
+export function shouldSuppressInfoOnlyContextStatus(modelId, contextLimit = 0) {
+  const explicitLimit = Number(contextLimit);
+  return explicitLimit > 0
+    ? explicitLimit >= MILLION_CONTEXT_LIMIT
+    : isMillionContextModel(modelId);
 }
 
 const WARNING_LEVELS = Object.freeze({
@@ -282,6 +291,7 @@ export function deriveContextLimit(stdin) {
 }
 
 export function buildContextUsageView(stdin, snapshot = null) {
+  const modelId = stdin?.model?.id ?? stdin?.model;
   const stdinUsage = getStdinContextUsage(stdin);
   if (!stdinUsage) {
     return {
@@ -296,14 +306,14 @@ export function buildContextUsageView(stdin, snapshot = null) {
     };
   }
 
-  const modelId = stdin?.model?.id ?? stdin?.model;
   const limitTokens = Math.max(1, stdinUsage.limitTokens);
   const usedTokens = stdinUsage.usedTokens;
   const percent = clampPercent((usedTokens / limitTokens) * 100);
 
   const warning = classifyContextThreshold(percent);
   const showInfoOnlyStatus = !(
-    warning.level === "info" && shouldSuppressInfoOnlyContextStatus(modelId)
+    warning.level === "info" &&
+    shouldSuppressInfoOnlyContextStatus(modelId, stdinUsage.limitTokens)
   );
   return {
     usedTokens,

package/hud/hud-qos-status.mjs

@@ -5,6 +5,10 @@
 // 각 모듈에서 색상, 터미널, 프로바이더, 렌더러를 가져와 조합한다.
 // ============================================================================
 
+import {
+  resolveHudCliVisibility,
+  shouldRenderGeminiFallbackRow,
+} from "./cli-policy.mjs";
 import {
   bold,
   claudeOrange,
@@ -28,10 +32,7 @@ import {
   TFX_PREFLIGHT_CACHE_PATH,
   TFX_PREFLIGHT_CACHE_STALE_MS,
 } from "./constants.mjs";
-import {
-  buildContextUsageView,
-  deriveContextLimit,
-} from "./context-monitor.mjs";
+import { buildContextUsageView } from "./context-monitor.mjs";
 import { getMissionBoardState } from "./mission-board.mjs";
 // Claude provider
 import {
@@ -72,8 +73,6 @@ import {
   getProviderRow,
   getTeamRow,
   readLatestBenchmarkDiff,
-  readSvAccumulator,
-  readTokenSavings,
   renderAlignedRows,
   renderMissionBoard,
 } from "./renderers.mjs";
@@ -123,8 +122,14 @@ async function main() {
   const preflightFresh =
     Number.isFinite(preflightTimestamp) &&
     Date.now() - preflightTimestamp <= TFX_PREFLIGHT_CACHE_STALE_MS;
+  // machine profile 의 TFX_DISABLE_* 정책. 차단된 CLI 는 행 자체를 그리지 않는다.
+  // antigravity 가 꺼지면 antigravityReady 를 강제로 내려서 기존 슬롯 로직이 그대로
+  // gemini 폴백 경로를 타게 한다.
+  const { showCodex, antigravityAllowed } = resolveHudCliVisibility();
   const antigravityReady =
-    preflightFresh && preflightCache?.antigravity?.ok === true;
+    antigravityAllowed &&
+    preflightFresh &&
+    preflightCache?.antigravity?.ok === true;
   const accountsConfig = readJson(ACCOUNTS_CONFIG_PATH, { providers: {} });
   const accountsState = readJson(ACCOUNTS_STATE_PATH, { providers: {} });
   const claudeUsageSnapshot = readClaudeUsageSnapshot();
@@ -168,35 +173,6 @@ async function main() {
   const geminiQuota = geminiQuotaSnapshot.quota;
   const missionBoardState = await getMissionBoardState();
 
-  // 누적 절약 데이터 읽기
-  const svSavings = readTokenSavings();
-  const svAccumulator = readSvAccumulator();
-  const _totalCostSaved =
-    svSavings?.totalSaved || svAccumulator?.totalCostSaved || 0;
-
-  // 세션/누적 토큰 → context 대비 절약 배수 (개별 provider sv%)
-  const ctxCapacity = deriveContextLimit(stdin);
-  let codexSv = null;
-  let codexAccumulatorSv = null;
-  if (svAccumulator?.codex?.tokens > 0) {
-    codexAccumulatorSv = svAccumulator.codex.tokens / ctxCapacity;
-    codexSv = codexAccumulatorSv;
-  } else if (codexBuckets) {
-    const main =
-      codexBuckets.codex || codexBuckets[Object.keys(codexBuckets)[0]];
-    if (main?.tokens?.total_tokens)
-      codexSv = main.tokens.total_tokens / ctxCapacity;
-  }
-  let geminiSv = null;
-  let geminiAccumulatorSv = null;
-  if (svAccumulator?.gemini?.tokens > 0) {
-    geminiAccumulatorSv = svAccumulator.gemini.tokens / ctxCapacity;
-    geminiSv = geminiAccumulatorSv;
-  } else {
-    const geminiTokens = geminiSession?.total || null;
-    geminiSv = geminiTokens ? geminiTokens / ctxCapacity : null;
-  }
-
   // Gemini: 3풀 버킷 추출 (Pro/Flash/Lite — 각 풀 내 모델들은 쿼터 공유)
   const geminiModel = geminiSession?.model || "gemini-3-flash-preview";
   const geminiBuckets = geminiQuota?.buckets || [];
@@ -220,19 +196,18 @@ async function main() {
   const antigravitySlot1Bucket =
     antigravityModelFamily === "gemini" ? antigravityFamilyBucket : null;
 
-  // 합산 절약은 svAccumulator 기반일 때만 표시한다.
-  // Codex bucket fallback은 account-window 누적 토큰이고 Gemini fallback은 latest
-  // session 토큰이라 서로 의미가 달라 합산하면 misleading cross-provider total이 된다.
-  const hasComparableSvAccumulator = Boolean(
-    codexAccumulatorSv != null || geminiAccumulatorSv != null,
-  );
-  const combinedSvPct = hasComparableSvAccumulator
-    ? Math.round(((codexAccumulatorSv ?? 0) + (geminiAccumulatorSv ?? 0)) * 100)
-    : null;
-
   // 인디케이터 인식 tier 선택 (stdin + Claude 사용량 기반)
   const CURRENT_TIER = selectTier(stdin, claudeUsageSnapshot.data);
 
+  // antigravity/gemini 슬롯 표시 판정. nano 와 나머지 tier 가 같은 판정을 쓴다.
+  const showGeminiRow = shouldRenderGeminiFallbackRow({
+    antigravityAllowed,
+    antigravityReady,
+    geminiEmail,
+    geminiBucket,
+    geminiSession,
+  });
+
   // nano tier: 1줄 모드 (극소 폭 또는 알림 배너 대응)
   if (CURRENT_TIER === "nano") {
     const microLine = getMicroLine(
@@ -241,8 +216,8 @@ async function main() {
       codexBuckets,
       antigravityReady ? null : geminiSession,
       antigravityReady ? null : geminiBucket,
-      combinedSvPct,
       antigravityReady ? "a" : "g",
+      { showCodex, showGemini: showGeminiRow },
     );
     process.stdout.write(`\x1b[0m${microLine}\n`);
     return;
@@ -262,46 +237,58 @@ async function main() {
     session: geminiSession,
   };
 
-  const rows = [
-    ...getClaudeRows(CURRENT_TIER, contextView, claudeUsage, combinedSvPct),
-    getProviderRow(
-      CURRENT_TIER,
-      "codex",
-      "x",
-      codexWhite,
-      qosProfile,
-      accountsConfig,
-      accountsState,
-      codexQuotaData,
-      codexEmail,
-      codexSv,
-      null,
-    ),
-    getProviderRow(
-      CURRENT_TIER,
-      antigravityReady ? "antigravity" : "gemini",
-      antigravityReady ? "a" : "g",
-      geminiBlue,
-      qosProfile,
-      accountsConfig,
-      accountsState,
-      antigravityReady
-        ? {
-            type: "antigravity",
-            pools: {
-              current: antigravitySlot1Bucket,
-              gemini_family: antigravityFamilyBucket,
-            },
-            currentAbbrev: antigravityAbbrev,
-            currentModel: antigravityModel,
-            currentFamily: antigravityModelFamily,
-          }
-        : geminiQuotaData,
-      antigravityReady ? antigravityEmail : geminiEmail,
-      antigravityReady ? null : geminiSv,
-      null,
-    ),
-  ];
+  const rows = [...getClaudeRows(CURRENT_TIER, contextView, claudeUsage)];
+
+  // 정책으로 생략된 행이 있으면 뒤따르는 행의 인덱스가 밀린다. dim 래핑이
+  // 하드코딩 인덱스를 쓰지 않도록 실제 위치를 기록해 둔다.
+  let codexRowIndex = -1;
+  if (showCodex) {
+    codexRowIndex = rows.length;
+    rows.push(
+      getProviderRow(
+        CURRENT_TIER,
+        "codex",
+        "x",
+        codexWhite,
+        qosProfile,
+        accountsConfig,
+        accountsState,
+        codexQuotaData,
+        codexEmail,
+        null,
+      ),
+    );
+  }
+
+  let geminiRowIndex = -1;
+  if (showGeminiRow) {
+    geminiRowIndex = rows.length;
+    rows.push(
+      getProviderRow(
+        CURRENT_TIER,
+        antigravityReady ? "antigravity" : "gemini",
+        antigravityReady ? "a" : "g",
+        geminiBlue,
+        qosProfile,
+        accountsConfig,
+        accountsState,
+        antigravityReady
+          ? {
+              type: "antigravity",
+              pools: {
+                current: antigravitySlot1Bucket,
+                gemini_family: antigravityFamilyBucket,
+              },
+              currentAbbrev: antigravityAbbrev,
+              currentModel: antigravityModel,
+              currentFamily: antigravityModelFamily,
+            }
+          : geminiQuotaData,
+        antigravityReady ? antigravityEmail : geminiEmail,
+        null,
+      ),
+    );
+  }
 
   const ctoStatus = readCtoStatus();
   if (ctoStatus) {
@@ -348,10 +335,13 @@ async function main() {
 
   const outputLines = renderAlignedRows(rows);
 
-  // 비활성 줄 dim 래핑 (rows 순서: [claude, codex, gemini])
-  if (outputLines.length >= 3) {
-    if (!codexActive) outputLines[1] = `${DIM}${outputLines[1]}${RESET}`;
-    if (!geminiActive) outputLines[2] = `${DIM}${outputLines[2]}${RESET}`;
+  // 비활성 줄 dim 래핑. 정책으로 생략된 행은 인덱스가 -1 이라 건너뛴다.
+  if (!codexActive && outputLines[codexRowIndex] != null) {
+    outputLines[codexRowIndex] = `${DIM}${outputLines[codexRowIndex]}${RESET}`;
+  }
+  if (!geminiActive && outputLines[geminiRowIndex] != null) {
+    outputLines[geminiRowIndex] =
+      `${DIM}${outputLines[geminiRowIndex]}${RESET}`;
   }
 
   // 선행 개행: 알림 배너(노란 글씨)가 빈 첫 줄에 오도록 → HUD 내용 보호

package/hud/providers/claude.mjs

@@ -116,70 +116,85 @@ function normalizeClaudeCredentials(data, source, supportsUsageApi = true) {
   };
 }
 
+// Claude Code 2.1.x secure-storage 규칙(바이너리 실측, 2026-09-21):
+// - CLAUDE_SECURESTORAGE_CONFIG_DIR 가 정의돼 있으면 그 값이 스코프다. 빈 문자열은 기본 디렉터리를
+//   뜻해 접미사를 붙이지 않고, 값이 있으면 NFC 로 정규화한 뒤 해시한다.
+// - 아니면 CLAUDE_CONFIG_DIR 원문(경로 확장·정규화 없이)을 sha256 해 앞 8자리를 붙인다.
+//   OMC 격리 세션의 `Claude Code-credentials-<hash>` 항목이 이 규칙으로 만들어진다.
 export function getKeychainServiceName(env = process.env) {
-  const configDir = env.CLAUDE_CONFIG_DIR;
-  if (configDir) {
-    const hash = createHash("sha256")
-      .update(configDir)
-      .digest("hex")
-      .slice(0, 8);
-    return `${CLAUDE_KEYCHAIN_SERVICE}-${hash}`;
+  const secureDir = env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+  let scope = "";
+  if (secureDir !== undefined) {
+    scope = secureDir ? secureDir.normalize("NFC") : "";
+  } else {
+    scope = env.CLAUDE_CONFIG_DIR || "";
   }
-  return CLAUDE_KEYCHAIN_SERVICE;
+  if (!scope) return CLAUDE_KEYCHAIN_SERVICE;
+  const hash = createHash("sha256").update(scope).digest("hex").slice(0, 8);
+  return `${CLAUDE_KEYCHAIN_SERVICE}-${hash}`;
 }
 
-function isCredentialExpired(creds) {
-  return creds.expiresAt != null && creds.expiresAt <= Date.now();
-}
+const KEYCHAIN_ACCOUNT_PATTERN = /^[a-zA-Z0-9._-]+$/;
+const KEYCHAIN_ACCOUNT_FALLBACK = "claude-code-user";
 
-function getKeychainAccount() {
+// Claude Code 와 같은 계정 규칙: USER 환경변수 → os.userInfo().username → 허용 문자 밖이면 고정 대체값.
+export function getKeychainAccount(env = process.env) {
+  let name = null;
   try {
-    return userInfo().username?.trim() || null;
+    name = env.USER || userInfo().username;
   } catch {
-    return null;
+    name = null;
+  }
+  if (typeof name !== "string" || !KEYCHAIN_ACCOUNT_PATTERN.test(name)) {
+    return KEYCHAIN_ACCOUNT_FALLBACK;
   }
+  return name;
 }
 
-function readClaudeKeychainCredential(
+function readClaudeKeychainRaw(
   serviceName,
   account,
   execFileSyncFn = execFileSync,
 ) {
   try {
-    const args = account
-      ? ["find-generic-password", "-s", serviceName, "-a", account, "-w"]
-      : ["find-generic-password", "-s", serviceName, "-w"];
-    const raw = execFileSyncFn("security", args, { encoding: "utf8" });
-    return normalizeClaudeCredentials(JSON.parse(raw.trim()), "keychain");
+    const raw = execFileSyncFn(
+      "security",
+      ["find-generic-password", "-s", serviceName, "-a", account, "-w"],
+      { encoding: "utf8" },
+    );
+    return JSON.parse(raw.trim());
   } catch {
     return null;
   }
 }
 
+// Keychain 항목은 (service, account) 복합 키다. Claude Code 는 항상 `-a <account>` 로 쓰고 읽으므로
+// 같은 키만 본다. `-a` 없는 조회는 "계정 없는 항목"이 아니라 같은 service 의 임의 계정 항목을 돌려주고,
+// `add-generic-password` 는 `-a` 가 필수라 그런 항목에는 되쓸 수도 없다(2026-09-21 실측, exit 2).
+export function readClaudeKeychainEntry({
+  execFileSyncFn = execFileSync,
+  env = process.env,
+} = {}) {
+  const serviceName = getKeychainServiceName(env);
+  const account = getKeychainAccount(env);
+  const raw = readClaudeKeychainRaw(serviceName, account, execFileSyncFn);
+  return raw ? { raw, account, serviceName } : null;
+}
+
 function readClaudeKeychainCredentials(
   execFileSyncFn = execFileSync,
   env = process.env,
 ) {
-  const serviceName = getKeychainServiceName(env);
-  const candidateAccounts = [];
-  const username = getKeychainAccount();
-  if (username) candidateAccounts.push(username);
-  candidateAccounts.push(undefined);
-
-  let expiredFallback = null;
-  for (const account of candidateAccounts) {
-    const creds = readClaudeKeychainCredential(
-      serviceName,
-      account,
-      execFileSyncFn,
-    );
-    if (!creds) continue;
-    if (!isCredentialExpired(creds)) return creds;
-    expiredFallback ??= creds;
-  }
-  return expiredFallback;
+  const entry = readClaudeKeychainEntry({ execFileSyncFn, env });
+  if (!entry) return null;
+  const creds = normalizeClaudeCredentials(entry.raw, "keychain");
+  // 만료된 항목도 그대로 돌려준다. 호출자가 refreshToken 으로 갱신한 뒤 같은 항목에 되쓴다.
+  return creds ? { ...creds, keychainAccount: entry.account } : null;
 }
 
+// 읽기 순서는 Claude Code 와 같다. macOS 에서는 Keychain 이 정본이고 평문 파일은 Keychain 을 못 쓸 때의
+// 폴백이라, 옛 파일이 남아 있어도 Keychain 항목이 있으면 그쪽이 현재 로그인이다.
+// 반환값에는 되쓰기 대상을 고정하기 위해 출처 위치(keychainAccount 또는 filePath)를 함께 싣는다.
 export function readClaudeCredentials({
   readCredentialFile = (filePath = CLAUDE_CREDENTIALS_PATH) =>
     readJson(filePath, null),
@@ -187,21 +202,31 @@ export function readClaudeCredentials({
   execFileSyncFn = execFileSync,
   env = process.env,
 } = {}) {
-  for (const filePath of getClaudeCredentialPaths(env)) {
-    try {
-      const fileCreds = normalizeClaudeCredentials(
-        readCredentialFile(filePath),
-        "file",
-      );
-      if (fileCreds) return fileCreds;
-    } catch {
-      /* try next credential source */
+  const tryKeychain = () =>
+    platform === "darwin"
+      ? readClaudeKeychainCredentials(execFileSyncFn, env)
+      : null;
+
+  const tryFile = () => {
+    for (const filePath of getClaudeCredentialPaths(env)) {
+      try {
+        const fileCreds = normalizeClaudeCredentials(
+          readCredentialFile(filePath),
+          "file",
+        );
+        if (fileCreds) return { ...fileCreds, filePath };
+      } catch {
+        /* try next credential source */
+      }
     }
-  }
+    return null;
+  };
 
-  if (platform === "darwin") {
-    const keychainCreds = readClaudeKeychainCredentials(execFileSyncFn, env);
-    if (keychainCreds) return keychainCreds;
+  const readers =
+    platform === "darwin" ? [tryKeychain, tryFile] : [tryFile, tryKeychain];
+  for (const read of readers) {
+    const creds = read();
+    if (creds) return creds;
   }
 
   if (env.ANTHROPIC_API_KEY) {
@@ -274,74 +299,115 @@ export function refreshClaudeAccessToken(refreshToken) {
   });
 }
 
-function serializeClaudeCredentials(creds) {
+// 기존 항목의 나머지 필드(scopes, subscriptionType, rateLimitTier, refreshTokenExpiresAt, mcpOAuth 등)를
+// 보존하고 토큰 필드만 갈아 끼운다. 저장 형태(claudeAiOauth 래퍼 또는 legacy 평면)는 그대로 둔다.
+function mergeClaudeCredentials(creds, existingRaw) {
+  const base =
+    existingRaw &&
+    typeof existingRaw === "object" &&
+    !Array.isArray(existingRaw)
+      ? existingRaw
+      : null;
+  const hasWrapper =
+    !!base?.claudeAiOauth && typeof base.claudeAiOauth === "object";
   const oauth = {
+    ...(hasWrapper ? base.claudeAiOauth : (base ?? {})),
     accessToken: creds.accessToken,
   };
   if (creds.expiresAt != null) oauth.expiresAt = creds.expiresAt;
   if (creds.refreshToken) oauth.refreshToken = creds.refreshToken;
+  if (hasWrapper) return { ...base, claudeAiOauth: oauth };
+  if (base) return oauth;
   return { claudeAiOauth: oauth };
 }
 
+// Claude Code 와 같은 쓰기 경로: 비밀값을 argv 에 두지 않도록 `security -i` 표준입력으로 명령 한 줄을
+// 넘기고 payload 는 `-X` 16진수로 싣는다. 한 줄 상한(4032B)을 넘는 큰 항목만 argv 로 내려간다.
+const KEYCHAIN_STDIN_LINE_LIMIT = 4032;
+
 function writeClaudeKeychainCredentials(
   creds,
   execFileSyncFn = execFileSync,
   env = process.env,
 ) {
-  const username = getKeychainAccount();
-  const accountArgs = username ? ["-a", username] : [];
+  const serviceName = getKeychainServiceName(env);
+  // 읽어 온 항목(keychainAccount)에 그대로 되쓴다. 현재 USER 와 달라도 다른 계정 항목을 만들지 않는다.
+  const account = creds.keychainAccount || getKeychainAccount(env);
+  const existingRaw = readClaudeKeychainRaw(
+    serviceName,
+    account,
+    execFileSyncFn,
+  );
+  const payload = mergeClaudeCredentials(creds, existingRaw);
+  const hex = Buffer.from(JSON.stringify(payload), "utf8").toString("hex");
+  const line = `add-generic-password -U -a "${account}" -s "${serviceName}" -X "${hex}"\n`;
+  if (line.length <= KEYCHAIN_STDIN_LINE_LIMIT) {
+    execFileSyncFn("security", ["-i"], {
+      input: line,
+      stdio: ["pipe", "ignore", "ignore"],
+    });
+    return;
+  }
   execFileSyncFn(
     "security",
-    [
-      "add-generic-password",
-      "-s",
-      getKeychainServiceName(env),
-      ...accountArgs,
-      "-w",
-      JSON.stringify(serializeClaudeCredentials(creds)),
-      "-U",
-    ],
+    ["add-generic-password", "-U", "-a", account, "-s", serviceName, "-X", hex],
     { stdio: "ignore" },
   );
 }
 
+function writeClaudeFileCredentials(
+  creds,
+  readCredentialFile,
+  writeCredentialFile,
+) {
+  const filePath = creds.filePath || CLAUDE_CREDENTIALS_PATH;
+  let data = null;
+  try {
+    data = readCredentialFile(filePath);
+  } catch {
+    data = null;
+  }
+  // 파일이 사라졌으면 새로 만들지 않는다 (Claude Code 가 Keychain 으로 옮긴 뒤 지운 경우)
+  if (!data) return;
+  writeCredentialFile(mergeClaudeCredentials(creds, data), filePath);
+}
+
+// 되쓰기는 자격증명을 읽어 온 저장소에만 한다. Keychain 출처를 파일에 쓰거나 파일 출처를 Keychain 에 쓰면
+// 계정이 다른 두 저장소가 섞이고(2026-09 실측: 파일=max 계정 만료분, Keychain=pro 계정 현재 로그인),
+// Claude Code 가 실제로 쓰는 Keychain 항목을 옛 계정 토큰으로 덮어쓴다.
 export function writeBackClaudeCredentials(
   creds,
   {
-    readCredentialFile = () => readJson(CLAUDE_CREDENTIALS_PATH, null),
-    writeCredentialFile = (data) =>
-      writeFileSync(CLAUDE_CREDENTIALS_PATH, JSON.stringify(data, null, 2)),
+    readCredentialFile = (filePath = CLAUDE_CREDENTIALS_PATH) =>
+      readJson(filePath, null),
+    writeCredentialFile = (data, filePath = CLAUDE_CREDENTIALS_PATH) =>
+      writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 }),
     platform = process.platform,
     execFileSyncFn = execFileSync,
     env = process.env,
   } = {},
 ) {
-  if (creds?.source === "env") return;
+  if (!creds || creds.source === "env") return;
 
-  let data = null;
-  try {
-    data = readCredentialFile();
-  } catch {
-    data = null;
-  }
-
-  if (data) {
-    const target = data.claudeAiOauth || data;
-    target.accessToken = creds.accessToken;
-    if (creds.expiresAt != null) target.expiresAt = creds.expiresAt;
-    if (creds.refreshToken) target.refreshToken = creds.refreshToken;
+  if (creds.source === "keychain") {
+    if (platform !== "darwin") return;
     try {
-      writeCredentialFile(data);
+      writeClaudeKeychainCredentials(creds, execFileSyncFn, env);
     } catch {
-      /* 파일 쓰기 실패 무시 */
+      /* Keychain 쓰기 실패 무시 */
     }
+    return;
   }
 
-  if (platform === "darwin") {
+  if (creds.source === "file") {
     try {
-      writeClaudeKeychainCredentials(creds, execFileSyncFn, env);
+      writeClaudeFileCredentials(
+        creds,
+        readCredentialFile,
+        writeCredentialFile,
+      );
     } catch {
-      /* Keychain 쓰기 실패 무시 */
+      /* 파일 쓰기 실패 무시 */
     }
   }
 }

package/hud/providers/codex.mjs

@@ -89,6 +89,9 @@ export function expireStaleCodexBuckets(
 }
 
 const RESET_CLUSTER_TOLERANCE_SEC = 90;
+// A probe may miss the instant immediately after a reset. Keep that brief
+// polling gap, but never let a long-expired cached window win the fallback.
+const STALE_WINDOW_FALLBACK_GRACE_SEC = CODEX_PROBE_TTL_MS / 1000;
 
 function isNewerSnapshot(candidate, current) {
   if (!current) return true;
@@ -149,7 +152,13 @@ function selectCodexWindowSnapshot(snapshots, nowSec, windowKey) {
       })[0];
   } else {
     for (const snapshot of [
-      ...groups.map((group) => group.latest),
+      ...groups
+        .filter(
+          (group) =>
+            nowSec - Number(group.latest[windowKey]?.resets_at) <=
+            STALE_WINDOW_FALLBACK_GRACE_SEC,
+        )
+        .map((group) => group.latest),
       ...ungrouped,
     ]) {
       if (isNewerSnapshot(snapshot, selected)) selected = snapshot;