triflux 10.9.21 → 10.9.23

package/.claude-plugin/marketplace.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "triflux",
+  "description": "CLI-first multi-model orchestrator — Codex/Gemini/Claude routing with DAG execution, auto-triage, and cost optimization",
+  "owner": {
+    "name": "tellang"
+  },
+  "plugins": [
+    {
+      "name": "triflux",
+      "description": "Tri-CLI orchestrator for Claude Code. Routes tasks across Claude + Codex + Gemini with consensus intelligence, natural language routing, 42 skills, and cross-model review.",
+      "version": "10.9.21",
+      "author": {
+        "name": "tellang"
+      },
+      "source": {
+        "source": "npm",
+        "package": "triflux"
+      },
+      "category": "productivity",
+      "homepage": "https://github.com/tellang/triflux",
+      "tags": [
+        "multi-model",
+        "codex",
+        "gemini",
+        "cli-routing",
+        "orchestration",
+        "cost-optimization",
+        "dag-execution"
+      ]
+    }
+  ],
+  "version": "10.9.21"
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "triflux",
+  "version": "10.9.22",
+  "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
+  "author": {
+    "name": "tellang"
+  },
+  "repository": "https://github.com/tellang/triflux",
+  "homepage": "https://github.com/tellang/triflux",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "plugin",
+    "codex",
+    "gemini",
+    "cli-routing",
+    "orchestration",
+    "multi-model"
+  ],
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json"
+}

package/config/mcp-registry.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "mcp-registry-schema",
+  "version": 1,
+  "description": "MCP 서버 중앙 레지스트리 — 진실의 원천",
+  "defaults": {
+    "transport": "hub-url",
+    "hub_base": "http://127.0.0.1:27888"
+  },
+  "servers": {
+    "tfx-hub": {
+      "transport": "hub-url",
+      "url": "http://127.0.0.1:27888/mcp",
+      "safe": true,
+      "targets": ["claude", "gemini", "codex"],
+      "description": "triflux Hub MCP 서버"
+    }
+  },
+  "policies": {
+    "stdio_action": "replace-with-hub",
+    "unknown_server_action": "warn",
+    "watched_paths": [
+      "~/.gemini/settings.json",
+      "~/.codex/config.toml",
+      "~/.claude/settings.json",
+      "~/.claude/settings.local.json",
+      ".mcp.json"
+    ]
+  }
+}

package/hub/account-broker.mjs

@@ -120,11 +120,13 @@ class AccountBroker extends EventEmitter {
   #config;
   #state; // Map<accountId, accountState>
   #roundRobinIndex; // Map<provider, number>
+  #persist; // boolean — disable persistence for tests
 
-  constructor(config) {
+  constructor(config, { _skipPersistence = false } = {}) {
     super();
     const parsed = ConfigSchema.parse(config);
     this.#config = parsed;
+    this.#persist = !_skipPersistence;
 
     this.#state = new Map();
     this.#roundRobinIndex = new Map();
@@ -134,7 +136,7 @@ class AccountBroker extends EventEmitter {
       ...(parsed.gemini || []).map((a) => ({ ...a, provider: "gemini" })),
     ];
 
-    const persisted = loadPersistedState();
+    const persisted = this.#persist ? loadPersistedState() : null;
     const pEntries = persisted?.entries || {};
 
     for (const account of allAccounts) {
@@ -386,7 +388,7 @@ class AccountBroker extends EventEmitter {
     };
 
     this.#state.set(accountId, updated);
-    persistState(this.#state);
+    if (this.#persist) persistState(this.#state);
     this.emit("release", { id: accountId, ok });
   }
 
@@ -401,7 +403,7 @@ class AccountBroker extends EventEmitter {
       leasedAt: null,
       cooldownUntil: Date.now() + coolMs,
     });
-    persistState(this.#state);
+    if (this.#persist) persistState(this.#state);
   }
 
   // ── snapshot ──────────────────────────────────────────────────

package/hub/cli-adapter-base.mjs

@@ -218,14 +218,15 @@ export async function executeWithCircuitBroker({
   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) {
+  const hasBroker = brokerMod.broker != null;
+  const lease = hasBroker ? brokerMod.broker.lease({ provider }) : null;
+  if (hasBroker && !lease) {
     return createResult(false, { fellBack: true, failureMode: "circuit_open" });
   }
 
   const preflight = await preflightFn(opts);
   if (!preflight.ok) {
-    brokerMod.broker.release(lease.id, { ok: false });
+    if (lease) brokerMod.broker.release(lease.id, { ok: false });
     return createResult(false, {
       stderr: appendWarnings("", preflight.warnings),
       fellBack: opts.fallbackToClaude !== false,
@@ -273,20 +274,19 @@ export async function executeWithCircuitBroker({
   }
 
   if (lastResult.ok) {
-    brokerMod.broker.release(lease.id, { ok: true });
+    if (lease) brokerMod.broker.release(lease.id, { ok: true });
     return lastResult;
   }
 
-  if (lastResult.failureMode === "rate_limited") {
-    const text = `${lastResult.output || ""}\n${lastResult.stderr || ""}`;
-    const coolMs = parseRetryAfterMs(text, provider);
-    brokerMod.broker.markRateLimited(lease.id, coolMs);
-    brokerMod.broker.emit("cooldown", { id: lease.id, provider, coolMs, reason: "quota_exhausted" });
-  } else if (lastResult.failureMode === "crash") {
-    // 인프라 에러(모듈 누락, 서버 에러 등)는 계정 문제가 아님 → circuit/cooldown 건너뜀
-    brokerMod.broker.release(lease.id, { ok: false, skipCircuit: true });
-  } else {
-    brokerMod.broker.release(lease.id, { ok: false });
+  if (lease) {
+    if (lastResult.failureMode === "rate_limited") {
+      const text = `${lastResult.output || ""}\n${lastResult.stderr || ""}`;
+      const coolMs = parseRetryAfterMs(text, provider);
+      brokerMod.broker.markRateLimited(lease.id, coolMs);
+      brokerMod.broker.emit("cooldown", { id: lease.id, provider, coolMs, reason: "quota_exhausted" });
+    } else {
+      brokerMod.broker.release(lease.id, { ok: false });
+    }
   }
   return {
     ...lastResult,

package/hub/lib/env-detect.mjs

@@ -3,68 +3,95 @@ import { execFileSync } from "node:child_process";
 import { platform as osPlatform } from "node:os";
 
 let _cached = null;
+let _shellCache = null;
+let _terminalCache = null;
+let _multiplexerCache = null;
+
+const PIPE_OPTS = { encoding: "utf8", timeout: 3000, stdio: "pipe" };
 
 /**
  * 기본 쉘 감지
- * Windows: pwsh → powershell
- * Unix: $SHELL → /bin/sh
+ * Windows: pwsh → powershell (full path + version)
+ * Unix: $SHELL → /bin/sh (+ version)
  */
 export function detectShell() {
+  if (_shellCache) return _shellCache;
+
   const platform = osPlatform();
+
   if (platform === "win32") {
     try {
-      execFileSync("where", ["pwsh.exe"], { stdio: "ignore", timeout: 3000 });
-      return { name: "pwsh", path: "pwsh.exe", version: null };
+      const path = execFileSync("where", ["pwsh.exe"], PIPE_OPTS).trim().split(/\r?\n/)[0];
+      let version = null;
+      try {
+        version = execFileSync(path, ["-NoLogo", "-NoProfile", "-Command", "$PSVersionTable.PSVersion.ToString()"], PIPE_OPTS).trim();
+      } catch {}
+      _shellCache = { name: "pwsh", path, version };
     } catch {
       try {
-        execFileSync("where", ["powershell.exe"], { stdio: "ignore", timeout: 3000 });
-        return { name: "powershell", path: "powershell.exe", version: null };
+        const path = execFileSync("where", ["powershell.exe"], PIPE_OPTS).trim().split(/\r?\n/)[0];
+        _shellCache = { name: "powershell", path, version: null };
       } catch {
-        return { name: "cmd", path: "cmd.exe", version: null, installHint: "pwsh: winget install Microsoft.PowerShell" };
+        _shellCache = { name: "powershell", path: "", version: null, installHint: "pwsh: winget install Microsoft.PowerShell" };
       }
     }
+    return _shellCache;
   }
 
   const shellPath = process.env.SHELL || "/bin/sh";
   const name = shellPath.split("/").pop() || "sh";
-  return { name, path: shellPath, version: null };
+  let version = null;
+  try {
+    version = execFileSync(shellPath, ["--version"], PIPE_OPTS).trim();
+  } catch {}
+  _shellCache = { name, path: shellPath, version };
+  return _shellCache;
 }
 
 /**
  * 터미널 에뮬레이터 감지
  */
 export function detectTerminal() {
+  if (_terminalCache) return _terminalCache;
+
   const platform = osPlatform();
   if (platform === "win32") {
     try {
-      execFileSync("where", ["wt.exe"], { stdio: "ignore", timeout: 3000 });
-      return { name: "windows-terminal", hasWt: true };
+      execFileSync("where", ["wt.exe"], PIPE_OPTS);
+      _terminalCache = { name: "windows-terminal", hasWt: true };
     } catch {
-      return { name: "conhost", hasWt: false, installHint: "Windows Terminal: winget install Microsoft.WindowsTerminal" };
+      _terminalCache = { name: "unknown", hasWt: false, installHint: "wt: winget install Microsoft.WindowsTerminal" };
     }
+    return _terminalCache;
   }
 
   if (process.env.TERM_PROGRAM === "iTerm.app") {
-    return { name: "iterm2", hasWt: false };
-  }
-  if (process.env.TERM_PROGRAM === "Apple_Terminal") {
-    return { name: "terminal-app", hasWt: false };
+    _terminalCache = { name: "iterm2", hasWt: false };
+  } else if (process.env.TERM_PROGRAM === "Apple_Terminal") {
+    _terminalCache = { name: "terminal-app", hasWt: false };
+  } else {
+    _terminalCache = { name: "unknown", hasWt: false };
   }
-
-  return { name: "unknown", hasWt: false };
+  return _terminalCache;
 }
 
 /**
  * 멀티플렉서 감지 (tmux)
  */
 export function detectMultiplexer() {
+  if (_multiplexerCache) return _multiplexerCache;
+
   try {
     const cmd = osPlatform() === "win32" ? "where" : "which";
-    const path = execFileSync(cmd, ["tmux"], { encoding: "utf8", timeout: 3000, stdio: ["ignore", "pipe", "ignore"] }).trim();
-    return { name: "tmux", path };
+    const path = execFileSync(cmd, ["tmux"], PIPE_OPTS).trim();
+    _multiplexerCache = { name: "tmux", path };
   } catch {
-    return { name: "none", path: null };
+    const hint = osPlatform() === "win32"
+      ? "tmux: install tmux in WSL or MSYS2"
+      : undefined;
+    _multiplexerCache = { name: "none", path: null, ...(hint ? { installHint: hint } : {}) };
   }
+  return _multiplexerCache;
 }
 
 /**

package/hub/server.mjs

@@ -80,7 +80,7 @@ const AIMD_WINDOW_MS = 30 * 60 * 1000;
 const AIMD_INITIAL_BATCH_SIZE = 3;
 const AIMD_MIN_BATCH_SIZE = 1;
 const AIMD_MAX_BATCH_SIZE = 10;
-const HUB_IDLE_TIMEOUT_DEFAULT_MS = 10 * 60 * 1000;
+const HUB_IDLE_TIMEOUT_DEFAULT_MS = 0; // 0 = 영구 실행 (idle shutdown 비활성). TFX_HUB_IDLE_TIMEOUT_MS 환경변수로 오버라이드 가능
 const HUB_IDLE_SWEEP_DEFAULT_MS = 60 * 1000;
 const STATIC_CONTENT_TYPES = Object.freeze({
   ".html": "text/html",
@@ -1655,21 +1655,23 @@ export async function startHub({
           return stopPromise;
         };
 
-        idleTimer = setInterval(() => {
-          const idleMs = Date.now() - lastRequestAt;
-          if (idleMs < hubIdleTimeoutMs) return;
-          hubLog.warn(
-            { idleMs, idleTimeoutMs: hubIdleTimeoutMs, port },
-            "hub.idle_timeout_shutdown",
-          );
-          void stopFn().catch((error) => {
-            hubLog.error(
-              { err: error, idleMs, idleTimeoutMs: hubIdleTimeoutMs, port },
-              "hub.idle_timeout_shutdown_failed",
+        if (hubIdleTimeoutMs > 0) {
+          idleTimer = setInterval(() => {
+            const idleMs = Date.now() - lastRequestAt;
+            if (idleMs < hubIdleTimeoutMs) return;
+            hubLog.warn(
+              { idleMs, idleTimeoutMs: hubIdleTimeoutMs, port },
+              "hub.idle_timeout_shutdown",
             );
-          });
-        }, hubIdleSweepMs);
-        idleTimer.unref();
+            void stopFn().catch((error) => {
+              hubLog.error(
+                { err: error, idleMs, idleTimeoutMs: hubIdleTimeoutMs, port },
+                "hub.idle_timeout_shutdown_failed",
+              );
+            });
+          }, hubIdleSweepMs);
+          idleTimer.unref();
+        }
 
         resolveHub({
           reused: false,

package/hub/team/headless.mjs

@@ -161,6 +161,16 @@ const MCP_PROFILE_HINTS = {
  * @param {string} [opts.contextFile] — 컨텍스트 파일 경로 (최대 32KB, UTF-8 안전 절단)
  * @returns {string} PowerShell 명령
  */
+// ── Dashboard attach args for WT ────────────────────────────────
+
+export function buildDashboardAttachArgs(sessionName, layout, workerCount, anchor = "window") {
+  const safeName = String(sessionName).replace(/[^a-zA-Z0-9_-]/g, "");
+  const base = anchor === "tab"
+    ? ["-w", "0", "nt"]
+    : ["-w", "new"];
+  return [...base, "--session", safeName, "--layout", layout, "--workers", String(workerCount)];
+}
+
 export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
   const { handoff = true, mcp, contextFile, model, cwd } = opts;
   const resolvedCli = resolveCliType(cli);

package/hub/team/swarm-hypervisor.mjs

@@ -1065,10 +1065,10 @@ export function createSwarmHypervisor(opts) {
    * @param {SwarmPlan} swarmPlan — from planSwarm()
    * @returns {Promise<SwarmStatus>}
    */
-  /** Hub keepalive — 스웜 실행 중 Hub idle timeout 방지 */
+  /** Hub keepalive — Hub crash recovery (idle timeout은 기본 비활성이므로 crash 복구 용도) */
   let hubKeepaliveTimer = null;
   function startHubKeepalive() {
-    // 5분마다 Hub /status 핑 (idle timeout 기본 10분)
+    // 5분마다 Hub /status 핑 — crash 감지 시 ensureHubAlive로 재시작
     hubKeepaliveTimer = setInterval(
       async () => {
         try {

package/hub/workers/delegator-mcp.mjs

@@ -14,6 +14,7 @@ import * as z from "zod";
 import { resolveBashExecutable } from "../lib/bash-path.mjs";
 import { CodexMcpWorker } from "./codex-mcp.mjs";
 import { GeminiWorker } from "./gemini-worker.mjs";
+import { runHeadlessWithCleanup } from "../team/headless.mjs";
 
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
 
@@ -321,6 +322,18 @@ const DelegateInputSchema = z.object({
   teamAgentName: z.string().optional().describe("TFX_TEAM_AGENT_NAME"),
   teamLeadName: z.string().optional().describe("TFX_TEAM_LEAD_NAME"),
   hubUrl: z.string().optional().describe("TFX_HUB_URL"),
+  workers: z
+    .array(
+      z.object({
+        provider: z.enum(["codex", "gemini"]).describe("워커 provider"),
+        agentType: z.string().default("executor").describe("역할명"),
+        prompt: z.string().describe("워커별 프롬프트"),
+        mcpProfile: z.string().default("auto").describe("MCP 프로필"),
+        model: z.string().optional().describe("모델 오버라이드"),
+      }),
+    )
+    .optional()
+    .describe("병렬 멀티워커 목록. 지정 시 psmux 기반 병렬 실행"),
 });
 
 const DelegateStatusInputSchema = z.object({
@@ -341,7 +354,7 @@ const DelegateOutputSchema = z.object({
   jobId: z.string().optional(),
   job_id: z.string().optional(),
   mode: z.enum(["sync", "async"]).optional(),
-  status: z.enum(["running", "completed", "failed"]).optional(),
+  status: z.enum(["running", "completed", "failed", "partial"]).optional(),
   error: z.string().optional(),
   providerRequested: z.string().optional(),
   providerResolved: z.string().nullable().optional(),
@@ -357,6 +370,20 @@ const DelegateOutputSchema = z.object({
   threadId: z.string().nullable().optional(),
   sessionKey: z.string().nullable().optional(),
   conversationOpen: z.boolean().optional(),
+  workerResults: z
+    .array(
+      z.object({
+        cli: z.string(),
+        role: z.string().optional(),
+        paneName: z.string(),
+        matched: z.boolean(),
+        exitCode: z.number().nullable(),
+        output: z.string(),
+      }),
+    )
+    .optional()
+    .describe("멀티워커 개별 결과"),
+  sessionName: z.string().optional().describe("psmux 세션명"),
 });
 
 function isTeamRouteRequested(args) {
@@ -791,6 +818,23 @@ export class DelegatorMcpWorker {
       "위임 실행을 시작합니다.",
     );
 
+    // 멀티워커 분기: workers 배열이 있으면 headless psmux 병렬 실행
+    if (Array.isArray(args.workers) && args.workers.length > 0) {
+      try {
+        const result = await this._executeMultiWorker(args, extra);
+        await emitProgress(extra, DIRECT_PROGRESS_DONE, 100, "위임이 완료되었습니다.");
+        return result;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return createErrorPayload(message, {
+          mode: "sync",
+          providerRequested: "multi",
+          agentType: args.agentType,
+          transport: "headless-psmux",
+        });
+      }
+    }
+
     const runViaRoute = this._shouldUseRoute(args);
 
     try {
@@ -816,6 +860,90 @@ export class DelegatorMcpWorker {
     }
   }
 
+  async _executeMultiWorker(args, extra) {
+    await emitProgress(
+      extra,
+      DIRECT_PROGRESS_START,
+      100,
+      "멀티워커 psmux 병렬 실행을 시작합니다.",
+    );
+
+    // workers 배열을 headless assignments 형식으로 변환
+    const assignments = args.workers.map((w) => {
+      // provider를 CLI 이름으로 매핑 (codex/gemini 그대로)
+      const cli = w.provider;
+      const role = w.agentType || "executor";
+      // buildDirectPrompt와 동일한 context 처리
+      const prompt = withContext(String(w.prompt || ""), args.contextFile);
+      return { cli, prompt, role };
+    });
+
+    // 타임아웃: 워커 중 가장 긴 타임아웃 사용
+    const maxTimeoutSec = Math.max(
+      ...args.workers.map((w) =>
+        Math.ceil(resolveTimeoutMs(w.agentType || "executor", args.timeoutMs) / 1000),
+      ),
+      300,
+    );
+
+    try {
+      const { results, sessionName } = await runHeadlessWithCleanup(assignments, {
+        sessionPrefix: "dlg",
+        timeoutSec: maxTimeoutSec,
+        layout: assignments.length <= 2 ? "even-horizontal" : "2x2",
+        progressive: true,
+        dashboard: true,
+        dashboardLayout: "single",
+      });
+
+      await emitProgress(
+        extra,
+        DIRECT_PROGRESS_DONE,
+        100,
+        `멀티워커 실행 완료: ${results.length}개 워커`,
+      );
+
+      // 전체 성공 판단: 모든 워커가 matched && exitCode === 0
+      const allOk = results.every((r) => r.matched && r.exitCode === 0);
+      // 개별 출력을 합산
+      const combinedOutput = results
+        .map(
+          (r, i) =>
+            `=== Worker ${i + 1} (${r.cli}/${assignments[i].role}) ===\n${r.output || "(no output)"}`,
+        )
+        .join("\n\n");
+
+      return {
+        ok: allOk,
+        mode: "sync",
+        status: allOk ? "completed" : "partial",
+        providerRequested: "multi",
+        providerResolved: "multi",
+        agentType: args.agentType || "executor",
+        transport: "headless-psmux",
+        exitCode: allOk ? 0 : 1,
+        output: combinedOutput,
+        workerResults: results.map((r) => ({
+          cli: r.cli,
+          role: r.role || "",
+          paneName: r.paneName,
+          matched: r.matched,
+          exitCode: r.exitCode,
+          output: r.output || "",
+        })),
+        sessionName,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return createErrorPayload(message, {
+        mode: "sync",
+        providerRequested: "multi",
+        agentType: args.agentType || "executor",
+        transport: "headless-psmux",
+      });
+    }
+  }
+
   async _executeWorker(args, extra) {
     await emitProgress(
       extra,

package/hud/constants.mjs

@@ -8,20 +8,23 @@ export const VERSION = "2.0";
 
 export const QOS_PATH = join(
   homedir(),
-  ".omc",
-  "state",
+  ".claude",
+  "cache",
+  "tfx-hub",
   "cli_qos_profile.json",
 );
 export const ACCOUNTS_CONFIG_PATH = join(
   homedir(),
-  ".omc",
-  "router",
+  ".claude",
+  "cache",
+  "tfx-hub",
   "accounts.json",
 );
 export const ACCOUNTS_STATE_PATH = join(
   homedir(),
-  ".omc",
-  "state",
+  ".claude",
+  "cache",
+  "tfx-hub",
   "cli_accounts_state.json",
 );
 
@@ -46,7 +49,13 @@ export const CONTEXT_MONITOR_LEGACY_PATH = join(
   "state",
   "context-monitor.json",
 );
-export const CONTEXT_MONITOR_LOG_DIR = join(homedir(), ".omc", "logs");
+export const CONTEXT_MONITOR_LOG_DIR = join(
+  homedir(),
+  ".claude",
+  "cache",
+  "tfx-hub",
+  "logs",
+);
 
 // 원격 프로브 캐시 (tfx-remote-spawn)
 export const REMOTE_ENV_CACHE_DIR = join(
@@ -70,15 +79,17 @@ export const CLAUDE_USAGE_CACHE_PATH = join(
   "cache",
   "claude-usage-cache.json",
 );
-export const OMC_PLUGIN_USAGE_CACHE_PATH = join(
+export const PLUGIN_USAGE_CACHE_PATH = join(
   homedir(),
   ".claude",
-  "plugins",
-  "oh-my-claudecode",
-  ".usage-cache.json",
+  "cache",
+  "tfx-hub",
+  "plugin-usage-cache.json",
 );
-export const CLAUDE_USAGE_STALE_MS_SOLO = 5 * 60 * 1000; // OMC 없을 때: 5분 캐시
-export const CLAUDE_USAGE_STALE_MS_WITH_OMC = 15 * 60 * 1000; // OMC 있을 때: 15분 (OMC가 30초마다 갱신)
+export const OMC_PLUGIN_USAGE_CACHE_PATH = PLUGIN_USAGE_CACHE_PATH; // OMC alias
+export const CLAUDE_USAGE_STALE_MS_SOLO = 5 * 60 * 1000; // 플러그인 없을 때: 5분 캐시
+export const CLAUDE_USAGE_STALE_MS_WITH_PLUGIN = 15 * 60 * 1000; // 플러그인 있을 때: 15분
+export const CLAUDE_USAGE_STALE_MS_WITH_OMC = CLAUDE_USAGE_STALE_MS_WITH_PLUGIN; // OMC alias
 export const CLAUDE_USAGE_429_BACKOFF_MS = 10 * 60 * 1000; // 429 에러 시 10분 backoff
 export const GEMINI_429_BASE_DELAY_MS = 2000;
 export const GEMINI_429_MAX_RETRIES = 3;

package/hud/renderers.mjs

@@ -389,7 +389,8 @@ export function getClaudeRows(
   }
 
   if (currentTier === "minimal") {
-    const quotaSection = `${dim("5h:")}${fStr} ${dim("1w:")}${wStr}`;
+    const staleTag = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
+    const quotaSection = `${dim("5h:")}${fStr} ${dim("1w:")}${wStr}${staleTag}`;
     const right = `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}`;
     return [{ prefix, left: quotaSection, right }];
   }