@triflux/core 10.28.1 → 10.30.0

package/hooks/hook-orchestrator.mjs

@@ -441,6 +441,30 @@ async function main() {
     }
   }
 
+  // ── UserPromptSubmit: interactive 세션 liveness heartbeat ──
+  // SessionStart 가 register, 매 프롬프트가 갱신한다(사용자 활동 = liveness). 이
+  // 갱신이 없으면 hub monitor 가 5분 TTL 후 세션을 stale 로 전이시켜 `cto status`
+  // 의 live_sessions 가 항상 비어 보인다. fire-and-forget POST 는 process.exit 가
+  // 버리므로(cf. [[project_process_exit_drops_fire_and_forget]]) 발사 직후 바로
+  // drain 한다 — 아래 registry hook 이 없어 early-exit 하는 경로에서도 flush 를
+  // 보장하기 위해서다. drain 은 localhost POST 라 보통 즉시 반환되고, hub stall
+  // 시에만 짧은 상한(500ms)으로 프롬프트 지연을 막는다. keyword-detector /
+  // north-star 등 registry hook 은 그 뒤로 평소대로 실행된다.
+  if (eventName === "UserPromptSubmit") {
+    try {
+      const { heartbeatInteractiveSession } = await import(
+        "./session-start-fast.mjs"
+      );
+      heartbeatInteractiveSession(stdinRaw);
+      const { drainPendingSynapse } = await import(
+        "../hub/team/synapse-http.mjs"
+      );
+      await drainPendingSynapse(500);
+    } catch {
+      /* best-effort — heartbeat 실패가 프롬프트 턴을 막지 않는다 */
+    }
+  }
+
   // 이벤트에 해당하는 훅 목록
   const hooks = registry.events[eventName];
   if (!hooks || hooks.length === 0) process.exit(0);

package/hooks/session-end-cleanup.mjs

@@ -9,6 +9,7 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { unregisterSynapseSession } from "../hub/team/synapse-http.mjs";
 
 const MARKER = "[session-end-cleanup]";
 const STALE_MS = 30 * 60 * 1000;
@@ -292,6 +293,20 @@ function buildOutput(summary, cleanup, tmuxReport) {
 export function run(input, env = process.env) {
   if (input?.hook_event_name !== "SessionEnd") return "";
 
+  // Best-effort Synapse unregister (fire-and-forget). Crash-safe: if this hook
+  // never fires, the 5-min interactive TTL eventually marks the row stale, so
+  // unregister is an optimization, not a correctness dependency. Never throws,
+  // never changes the report-only stdout contract below.
+  //
+  // Bounded timeout (unref AbortController inside synapse-http) so a stalled hub
+  // cannot keep this short-lived SessionEnd hook process alive past its budget.
+  try {
+    const sessionId = String(input?.session_id || "").trim();
+    if (sessionId) unregisterSynapseSession(sessionId, { timeoutMs: 1500 });
+  } catch {
+    /* swallow — report-only charter preserved */
+  }
+
   const root = env.CLAUDE_CWD || process.cwd();
   const statePath = join(root, ".triflux", "subagents", "subagents.json");
   if (!existsSync(statePath)) return "";

package/hooks/session-start-fast.mjs

@@ -10,8 +10,15 @@
 //
 // external source 훅 (session-vault 등)은 여전히 execFile로 실행된다.
 
+import { execFile } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  buildSynapseTaskSummary,
+  drainPendingSynapse,
+  heartbeatSynapseSession,
+  registerSynapseSession,
+} from "../hub/team/synapse-http.mjs";
 import { createModuleLogger } from "../scripts/lib/logger.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -20,6 +27,145 @@ const importMod = (p) => import(pathToFileURL(p).href);
 
 const log = createModuleLogger("session-start-fast");
 
+/**
+ * SessionStart 페이로드(JSON 문자열)에서 session_id / cwd 를 추출한다.
+ * 파싱 실패는 빈 객체로 흡수한다 (BLOCKING path 에 절대 영향 없음).
+ */
+function parseStartPayload(stdinData) {
+  try {
+    const raw = typeof stdinData === "string" ? stdinData : "";
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * cwd 기준 git 컨텍스트(worktree root / branch)를 best-effort, 비동기로 수집.
+ * execFileSync 와 달리 호출자(BACKGROUND)를 블로킹하지 않는다. 각 git 호출은
+ * tight timeout(1.5s) + 강제 kill 로 묶여 hub/디스크 stall 시에도 잔류하지 않는다.
+ * @param {string} cwd
+ * @param {(args:string[], cb:(out:string)=>void)=>void} [gitRunner] 테스트용 seam
+ * @returns {Promise<{ worktreePath: string, branch: string }>}
+ */
+function gitContextAsync(cwd, gitRunner = defaultGitRunner) {
+  const run = (args) =>
+    new Promise((resolve) => {
+      try {
+        gitRunner(cwd, args, (out) => resolve(out));
+      } catch {
+        resolve("");
+      }
+    });
+  return Promise.all([
+    run(["rev-parse", "--show-toplevel"]),
+    run(["rev-parse", "--abbrev-ref", "HEAD"]),
+  ]).then(([toplevel, branch]) => ({
+    worktreePath: toplevel || cwd,
+    branch,
+  }));
+}
+
+/** 기본 git runner: execFile(async) + tight timeout + kill. 실패는 빈 문자열. */
+function defaultGitRunner(cwd, args, cb) {
+  execFile(
+    "git",
+    args,
+    {
+      cwd,
+      encoding: "utf8",
+      timeout: 1500,
+      killSignal: "SIGKILL",
+      windowsHide: true,
+    },
+    (err, stdout) => {
+      cb(err ? "" : String(stdout || "").trim());
+    },
+  );
+}
+
+/**
+ * 인터랙티브 세션을 Synapse 레지스트리에 self-register (fire-and-forget).
+ * hub 미응답이면 silent no-op. BLOCKING path 에 latency 0 — git 컨텍스트는
+ * 블로킹 경로 밖에서 비동기로 enrich 한다 (cwd 만으로 즉시 minimal register).
+ *
+ * pid 는 의도적으로 보내지 않는다: 이 훅 프로세스의 process.pid 는 short-lived
+ * 훅 PID 일 뿐 세션 PID 가 아니므로 오기재가 된다. liveness 는 TTL 이 담당한다.
+ *
+ * @param {string} stdinData
+ * @param {object} [seams] 테스트용 injectable seam
+ * @param {Function} [seams.register]  registerSynapseSession 대체
+ * @param {Function} [seams.heartbeat] heartbeatSynapseSession 대체
+ * @param {Function} [seams.gitRunner] git runner 대체
+ * @returns {void} (enrich 는 백그라운드에서 완료)
+ */
+export function registerInteractiveSession(stdinData, seams = {}) {
+  const register = seams.register || registerSynapseSession;
+  const heartbeat = seams.heartbeat || heartbeatSynapseSession;
+  const gitRunner = seams.gitRunner || defaultGitRunner;
+  try {
+    const payload = parseStartPayload(stdinData);
+    const sessionId = String(payload?.session_id || "").trim();
+    if (!sessionId) return;
+    const cwd = typeof payload?.cwd === "string" ? payload.cwd : process.cwd();
+
+    // 1) cwd 만으로 즉시 minimal register (블로킹 git 없음, latency 0).
+    register({
+      sessionId,
+      cwd,
+      worktreePath: cwd,
+      branch: "",
+      host: "local",
+      sessionKind: "interactive",
+      isRemote: false,
+    });
+
+    // 2) worktree/branch 는 블로킹 경로 밖에서 비동기 enrich → heartbeat partial.
+    gitContextAsync(cwd, gitRunner)
+      .then(({ worktreePath, branch }) => {
+        if (worktreePath === cwd && !branch) return; // 추가 정보 없음
+        heartbeat(sessionId, { worktreePath, branch });
+      })
+      .catch(() => {});
+  } catch {
+    /* best-effort — never affects session start */
+  }
+}
+
+/**
+ * UserPromptSubmit 마다 interactive 세션의 liveness 를 갱신한다.
+ * SessionStart 가 register, 이후 매 프롬프트가 heartbeat — 사용자 활동이 곧
+ * liveness 다. 이 갱신이 없으면 hub monitor 가 5분 TTL 후 세션을 stale 로 전이시켜
+ * `cto status` 의 live_sessions 가 항상 비어 보인다.
+ *
+ * heartbeat 는 fire-and-forget POST 이므로 호출측(hook-orchestrator)이
+ * process.exit 전에 drainPendingSynapse 로 flush 해야 drop 되지 않는다
+ * (cf. SessionStart 의 execute() 자체 drain).
+ *
+ * pid 는 register 와 동일하게 보내지 않는다(91-92 주석): liveness 는 TTL +
+ * heartbeat 가 담당한다.
+ *
+ * @param {string} stdinData UserPromptSubmit stdin JSON
+ * @param {object} [seams] 테스트용 injectable seam
+ * @param {Function} [seams.heartbeat] heartbeatSynapseSession 대체
+ * @returns {void}
+ */
+export function heartbeatInteractiveSession(stdinData, seams = {}) {
+  const heartbeat = seams.heartbeat || heartbeatSynapseSession;
+  try {
+    const payload = parseStartPayload(stdinData);
+    const sessionId = String(payload?.session_id || "").trim();
+    if (!sessionId) return;
+    const cwd = typeof payload?.cwd === "string" ? payload.cwd : process.cwd();
+    const partial = { worktreePath: cwd, host: "local" };
+    const prompt = typeof payload?.prompt === "string" ? payload.prompt : "";
+    if (prompt) partial.taskSummary = buildSynapseTaskSummary(prompt);
+    heartbeat(sessionId, partial);
+  } catch {
+    /* best-effort — never affects the prompt turn */
+  }
+}
+
 /**
  * BLOCKING 훅을 순차 실행. 하나라도 throw하면 로그만 남기고 계속.
  * @param {string} stdinData
@@ -174,6 +320,9 @@ function runBackground(stdinData) {
     .then((mod) => mod.run(stdinData))
     .catch(() => {}); // 완전 무시
 
+  // Synapse: 인터랙티브 세션 self-register (fire-and-forget, hub 미응답 무시)
+  registerInteractiveSession(stdinData);
+
   // session-vault은 external source — hook-orchestrator가 execFile로 실행
 }
 
@@ -195,6 +344,15 @@ export async function execute(stdinData, externalHooks = []) {
   runDeferred(stdinData);
   runBackground(stdinData);
 
+  // hook-orchestrator process.exit(0)s immediately after we return, which would
+  // drop the just-fired Synapse register POST before it flushes to the loopback
+  // socket (Node's exit abandons pending I/O). Drain it with a tight bound: the
+  // register is a fast localhost POST (hub was ensured up in the BLOCKING phase)
+  // and the ceiling caps a hub stall so SessionStart never hangs. The async
+  // git-enrich heartbeat stays best-effort (it may not have fired yet) — losing
+  // it only drops worktree/branch enrichment, not the core registration.
+  await drainPendingSynapse(1000);
+
   const totalDur = performance.now() - totalStart;
   log.info(
     {

package/hub/team/synapse-http.mjs

@@ -0,0 +1,166 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const HUB_DEFAULT_PORT = 27888;
+// Same token file as hub/bridge.mjs (HUB_TOKEN_FILE). Kept inline rather than
+// imported so this helper stays dependency-free and byte-identical across the
+// packages/core mirror (which cannot carry relative cross-package imports).
+const HUB_TOKEN_FILE = join(homedir(), ".claude", ".tfx-hub-token");
+
+// In-flight fire-and-forget POSTs. A short-lived caller (the SessionStart hook,
+// which process.exit(0)s immediately after firing register) must be able to
+// flush these before the process dies: Node's process.exit() abandons pending
+// socket I/O, so an un-awaited loopback POST is created but never written.
+// Callers on an exit budget drain this set via drainPendingSynapse() first.
+const inFlightSynapse = new Set();
+
+function normalizeToken(raw) {
+  if (raw == null) return null;
+  const token = String(raw).trim();
+  return token || null;
+}
+
+// Mirrors hub/bridge.mjs:readHubToken — env override first, then the token file.
+// Missing token → null (backward-compatible with token-less hubs).
+function readHubToken() {
+  const envToken = normalizeToken(process.env.TFX_HUB_TOKEN);
+  if (envToken) return envToken;
+  try {
+    return normalizeToken(readFileSync(HUB_TOKEN_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// Wrap IPv6 hosts in [...] so they form a valid URL authority (cf. bridge.mjs).
+function formatHostForUrl(host) {
+  return String(host).includes(":") ? `[${host}]` : host;
+}
+
+// Resolve the hub base URL from env (TFX_HUB_URL / TFX_HUB_PORT) before falling
+// back to the loopback default, so a cascaded / non-default hub port is hit
+// instead of silently posting to 127.0.0.1:27888 and missing the live hub.
+function resolveSynapseBaseUrl() {
+  const envUrl = normalizeToken(process.env.TFX_HUB_URL);
+  if (envUrl) return envUrl.replace(/\/mcp$/, "");
+
+  const envPort = Number.parseInt(String(process.env.TFX_HUB_PORT ?? ""), 10);
+  if (Number.isFinite(envPort) && envPort > 0) {
+    return `http://${formatHostForUrl("127.0.0.1")}:${envPort}`;
+  }
+  return `http://${formatHostForUrl("127.0.0.1")}:${HUB_DEFAULT_PORT}`;
+}
+
+function resolveSynapseFetch(fetchImpl) {
+  if (fetchImpl === null) return null;
+  if (typeof fetchImpl === "function") return fetchImpl;
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  return null;
+}
+
+export function buildSynapseTaskSummary(prompt, maxLength = 100) {
+  if (maxLength <= 0) return "";
+  return String(prompt ?? "").slice(0, maxLength);
+}
+
+export function fireAndForgetSynapse(path, payload, opts = {}) {
+  const fetchImpl = resolveSynapseFetch(opts.fetchImpl);
+  if (!fetchImpl) return false;
+
+  try {
+    const baseUrl = opts.baseUrl || resolveSynapseBaseUrl();
+    const url = new URL(path, baseUrl).toString();
+    const headers = { "content-type": "application/json" };
+    // token: false explicitly skips auth; otherwise reuse the hub token so a
+    // token-required hub does not 401 (the failure would be swallowed silently).
+    if (opts.token !== false) {
+      const token =
+        typeof opts.token === "string" && opts.token.trim()
+          ? opts.token.trim()
+          : readHubToken();
+      if (token) headers.Authorization = `Bearer ${token}`;
+    }
+    const init = {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+    };
+    // Optional bounded timeout so callers on a teardown budget (e.g. SessionEnd)
+    // cannot hang the host process if the hub stalls. The timer is unref'd so it
+    // never keeps the event loop (and thus the hook process) alive on its own.
+    let timer = null;
+    const timeoutMs = Number(opts.timeoutMs);
+    if (
+      Number.isFinite(timeoutMs) &&
+      timeoutMs > 0 &&
+      typeof AbortController === "function"
+    ) {
+      const controller = new AbortController();
+      init.signal = controller.signal;
+      timer = setTimeout(() => controller.abort(), timeoutMs);
+      if (typeof timer.unref === "function") timer.unref();
+    }
+    const tracked = Promise.resolve(fetchImpl(url, init))
+      .catch(() => {})
+      .finally(() => {
+        if (timer) clearTimeout(timer);
+        inFlightSynapse.delete(tracked);
+      });
+    inFlightSynapse.add(tracked);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Await any in-flight fire-and-forget Synapse POSTs, bounded by timeoutMs so a
+// stalled hub can never hang the caller. The SessionStart hook calls this right
+// before process.exit(0) so the register POST actually flushes to the socket.
+export function drainPendingSynapse(timeoutMs = 1000) {
+  if (inFlightSynapse.size === 0) return Promise.resolve();
+  const settled = Promise.allSettled([...inFlightSynapse]);
+  const ms = Number(timeoutMs);
+  if (!Number.isFinite(ms) || ms <= 0) return settled;
+  let timeout = null;
+  const timeoutPromise = new Promise((resolve) => {
+    // Keep this timer ref'ed: drainPendingSynapse() is awaited specifically
+    // to hold the process open until either in-flight POSTs settle or the
+    // bounded drain budget expires. An unref'ed timer can let Node's test
+    // runner/process exit before the Promise resolves when no other handles
+    // remain.
+    timeout = setTimeout(resolve, ms);
+  });
+  return Promise.race([settled, timeoutPromise]).finally(() => {
+    if (timeout) clearTimeout(timeout);
+  });
+}
+
+export function registerSynapseSession(meta, opts = {}) {
+  return fireAndForgetSynapse("/synapse/register", meta, opts);
+}
+
+export function heartbeatSynapseSession(
+  sessionId,
+  partialMeta = {},
+  opts = {},
+) {
+  // The live route reads `{ sessionId, partial }` (hub/server.mjs
+  // /synapse/heartbeat → synapseRegistry.heartbeat(sessionId, partial)), so the
+  // helper must nest the meta under `partial` rather than spreading it top-level.
+  return fireAndForgetSynapse(
+    "/synapse/heartbeat",
+    {
+      sessionId,
+      partial:
+        partialMeta && typeof partialMeta === "object" ? partialMeta : {},
+    },
+    opts,
+  );
+}
+
+export function unregisterSynapseSession(sessionId, opts = {}) {
+  return fireAndForgetSynapse("/synapse/unregister", { sessionId }, opts);
+}

package/hud/constants.mjs

@@ -36,6 +36,13 @@ export const TEAM_STATE_PATH = join(
   "tfx-hub",
   "team-state.json",
 );
+export const CTO_LAKE_CURRENT_RELATIVE_PATH = join(
+  ".triflux",
+  "lake",
+  "current.md",
+);
+export const CTO_STATUS_STALE_MS = 60 * 60 * 1000; // 1시간
+export const CTO_STATUS_LINE_MAX_CHARS = 140;
 export const CONTEXT_MONITOR_CACHE_PATH = join(
   homedir(),
   ".claude",
@@ -73,6 +80,21 @@ export const CLAUDE_CREDENTIALS_PATH = join(
   ".claude",
   ".credentials.json",
 );
+export const CLAUDE_CREDENTIALS_FILENAME = ".credentials.json";
+export const CLAUDE_CODE_USER_AGENT_FALLBACK = "claude-code/2.x";
+export function getClaudeCredentialPaths(env = process.env) {
+  const paths = [];
+  if (env.CLAUDE_CONFIG_DIR) {
+    paths.push(join(env.CLAUDE_CONFIG_DIR, CLAUDE_CREDENTIALS_FILENAME));
+  }
+  paths.push(CLAUDE_CREDENTIALS_PATH);
+  return paths;
+}
+export function getClaudeCodeUserAgent(env = process.env) {
+  return env.CLAUDE_CODE_VERSION
+    ? `claude-code/${env.CLAUDE_CODE_VERSION}`
+    : CLAUDE_CODE_USER_AGENT_FALLBACK;
+}
 export const CLAUDE_USAGE_CACHE_PATH = join(
   homedir(),
   ".claude",
@@ -143,6 +165,29 @@ export const ANTIGRAVITY_OAUTH_PATHS = [
   join(homedir(), ".gemini", "antigravity-cli", "credentials.json"),
   GEMINI_OAUTH_PATH,
 ];
+export const ANTIGRAVITY_SETTINGS_PATH = join(
+  homedir(),
+  ".gemini",
+  "antigravity-cli",
+  "settings.json",
+);
+// Antigravity CLI 현재 장착 모델 라벨 → HUD 2자 약어 매핑
+// /usage 실측 (2026-05-22): Gemini 4개 모델이 동일 reset window 공유 (family-pool).
+// Claude/GPT-OSS family는 Gemini와 별도 quota 윈도우.
+export const ANTIGRAVITY_MODEL_ABBREV = {
+  // Gemini family — 통합 quota
+  "Gemini 3.5 Flash (High)": "Fh",
+  "Gemini 3.5 Flash (Medium)": "Fm",
+  "Gemini 3.5 Flash (Low)": "Fl",
+  "Gemini 3.1 Pro (High)": "Ph",
+  "Gemini 3.1 Pro (Low)": "Pl",
+  "Gemini 3 Flash": "F3",
+  // Claude family — 각자 별도 quota
+  "Claude Sonnet 4.6 (Thinking)": "Cs",
+  "Claude Opus 4.6 (Thinking)": "Co",
+  // GPT-OSS family — 각자 별도 quota
+  "GPT-OSS 120B (Medium)": "Go",
+};
 export const GEMINI_QUOTA_CACHE_PATH = join(
   homedir(),
   ".claude",

package/hud/hud-qos-status.mjs

@@ -47,11 +47,16 @@ import {
   refreshCodexRateLimitsCache,
   scheduleCodexRateLimitRefresh,
 } from "./providers/codex.mjs";
+import { readCtoStatus } from "./providers/cto.mjs";
 // Gemini provider
 import {
   buildGeminiAuthContext,
+  deriveGeminiFamilyBucket,
   fetchGeminiQuota,
+  getAntigravityCurrentModel,
   getAntigravityEmail,
+  getAntigravityModelAbbrev,
+  getAntigravityModelFamily,
   getGeminiEmail,
   readGeminiQuotaSnapshot,
   readGeminiSessionSnapshot,
@@ -78,6 +83,7 @@ import {
   getProviderAccountId,
   readJson,
   readStdinJson,
+  stripAnsi,
 } from "./utils.mjs";
 
 // ============================================================================
@@ -151,7 +157,9 @@ async function main() {
   // 실측 데이터 추출
   const stdin = await stdinPromise;
   const contextView = buildContextUsageView(stdin, contextSnapshot);
-  const claudeUsage = claudeUsageSnapshot.data;
+  const claudeUsage = claudeUsageSnapshot.data
+    ? { ...claudeUsageSnapshot.data, stale: claudeUsageSnapshot.isStale }
+    : claudeUsageSnapshot.data;
   const codexEmail = getCodexEmail();
   const geminiEmail = getGeminiEmail();
   const antigravityEmail = getAntigravityEmail();
@@ -199,6 +207,15 @@ async function main() {
   const geminiLiteBucket =
     geminiBuckets.find((b) => b.modelId?.includes("flash-lite")) || null;
 
+  // Antigravity 현재 장착 모델 + family 통합 bucket (slot1 = 장착 모델 약어, slot2 = Gn family)
+  // slot1 quota: 현재 모델이 Gemini family면 family bucket, 아니면(Claude/GPT-OSS) placeholder.
+  const antigravityModel = getAntigravityCurrentModel();
+  const antigravityAbbrev = getAntigravityModelAbbrev(antigravityModel);
+  const antigravityModelFamily = getAntigravityModelFamily(antigravityModel);
+  const antigravityFamilyBucket = deriveGeminiFamilyBucket(geminiBuckets);
+  const antigravitySlot1Bucket =
+    antigravityModelFamily === "gemini" ? antigravityFamilyBucket : null;
+
   // 합산 절약: Codex+Gemini sv% 합산 (컨텍스트 대비 위임 토큰 비율)
   const combinedSvPct = Math.round(((codexSv ?? 0) + (geminiSv ?? 0)) * 100);
 
@@ -257,13 +274,37 @@ async function main() {
       qosProfile,
       accountsConfig,
       accountsState,
-      antigravityReady ? { type: "antigravity" } : geminiQuotaData,
+      antigravityReady
+        ? {
+            type: "antigravity",
+            pools: {
+              current: antigravitySlot1Bucket,
+              gemini_family: antigravityFamilyBucket,
+            },
+            currentAbbrev: antigravityAbbrev,
+            currentModel: antigravityModel,
+            currentFamily: antigravityModelFamily,
+          }
+        : geminiQuotaData,
       antigravityReady ? antigravityEmail : geminiEmail,
       antigravityReady ? null : geminiSv,
       null,
     ),
   ];
 
+  const ctoStatus = readCtoStatus();
+  if (ctoStatus) {
+    const rightTag =
+      CURRENT_TIER === "nano" || CURRENT_TIER === "micro"
+        ? ""
+        : stripAnsi(ctoStatus.rightTag || "").trim();
+    rows.push({
+      prefix: `${bold(claudeOrange("^"))}:`,
+      left: `${dim("cto:")}${stripAnsi(ctoStatus.line)}`,
+      right: rightTag ? dim(rightTag) : "",
+    });
+  }
+
   // tfx-multi 활성 시 팀 상태 행 추가 (v2.2)
   const teamRow = getTeamRow(CURRENT_TIER);
   if (teamRow) rows.push(teamRow);

package/hud/providers/claude.mjs

@@ -3,8 +3,10 @@
 // ============================================================================
 
 import { execFileSync, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 import { existsSync, writeFileSync } from "node:fs";
 import https from "node:https";
+import { userInfo } from "node:os";
 import {
   CLAUDE_API_TIMEOUT_MS,
   CLAUDE_CREDENTIALS_PATH,
@@ -17,6 +19,8 @@ import {
   CLAUDE_USAGE_STALE_MS_WITH_OMC,
   DEFAULT_OAUTH_CLIENT_ID,
   FIVE_HOUR_MS,
+  getClaudeCodeUserAgent,
+  getClaudeCredentialPaths,
   OMC_PLUGIN_USAGE_CACHE_PATH,
   SEVEN_DAY_MS,
   SPAWN_LOCK_TTL_MS,
@@ -112,30 +116,91 @@ function normalizeClaudeCredentials(data, source, supportsUsageApi = true) {
   };
 }
 
-function readClaudeKeychainCredentials(execFileSyncFn = execFileSync) {
+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}`;
+  }
+  return CLAUDE_KEYCHAIN_SERVICE;
+}
+
+function isCredentialExpired(creds) {
+  return creds.expiresAt != null && creds.expiresAt <= Date.now();
+}
+
+function getKeychainAccount() {
   try {
-    const raw = execFileSyncFn(
-      "security",
-      ["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-w"],
-      { encoding: "utf8" },
-    );
+    return userInfo().username?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function readClaudeKeychainCredential(
+  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");
   } catch {
     return 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;
+}
+
 export function readClaudeCredentials({
-  readCredentialFile = () => readJson(CLAUDE_CREDENTIALS_PATH, null),
+  readCredentialFile = (filePath = CLAUDE_CREDENTIALS_PATH) =>
+    readJson(filePath, null),
   platform = process.platform,
   execFileSyncFn = execFileSync,
   env = process.env,
 } = {}) {
-  const fileCreds = normalizeClaudeCredentials(readCredentialFile(), "file");
-  if (fileCreds) return fileCreds;
+  for (const filePath of getClaudeCredentialPaths(env)) {
+    try {
+      const fileCreds = normalizeClaudeCredentials(
+        readCredentialFile(filePath),
+        "file",
+      );
+      if (fileCreds) return fileCreds;
+    } catch {
+      /* try next credential source */
+    }
+  }
 
   if (platform === "darwin") {
-    const keychainCreds = readClaudeKeychainCredentials(execFileSyncFn);
+    const keychainCreds = readClaudeKeychainCredentials(execFileSyncFn, env);
     if (keychainCreds) return keychainCreds;
   }
 
@@ -169,6 +234,7 @@ export function refreshClaudeAccessToken(refreshToken) {
         headers: {
           "Content-Type": "application/x-www-form-urlencoded",
           "Content-Length": Buffer.byteLength(body),
+          "User-Agent": getClaudeCodeUserAgent(),
         },
         timeout: CLAUDE_API_TIMEOUT_MS,
       },
@@ -217,13 +283,20 @@ function serializeClaudeCredentials(creds) {
   return { claudeAiOauth: oauth };
 }
 
-function writeClaudeKeychainCredentials(creds, execFileSyncFn = execFileSync) {
+function writeClaudeKeychainCredentials(
+  creds,
+  execFileSyncFn = execFileSync,
+  env = process.env,
+) {
+  const username = getKeychainAccount();
+  const accountArgs = username ? ["-a", username] : [];
   execFileSyncFn(
     "security",
     [
       "add-generic-password",
       "-s",
-      CLAUDE_KEYCHAIN_SERVICE,
+      getKeychainServiceName(env),
+      ...accountArgs,
       "-w",
       JSON.stringify(serializeClaudeCredentials(creds)),
       "-U",
@@ -240,6 +313,7 @@ export function writeBackClaudeCredentials(
       writeFileSync(CLAUDE_CREDENTIALS_PATH, JSON.stringify(data, null, 2)),
     platform = process.platform,
     execFileSyncFn = execFileSync,
+    env = process.env,
   } = {},
 ) {
   if (creds?.source === "env") return;
@@ -265,7 +339,7 @@ export function writeBackClaudeCredentials(
 
   if (platform === "darwin") {
     try {
-      writeClaudeKeychainCredentials(creds, execFileSyncFn);
+      writeClaudeKeychainCredentials(creds, execFileSyncFn, env);
     } catch {
       /* Keychain 쓰기 실패 무시 */
     }
@@ -283,6 +357,7 @@ export function fetchClaudeUsageFromApi(accessToken) {
           Authorization: `Bearer ${accessToken}`,
           "anthropic-beta": "oauth-2025-04-20",
           "Content-Type": "application/json",
+          "User-Agent": getClaudeCodeUserAgent(),
         },
         timeout: CLAUDE_API_TIMEOUT_MS,
       },

package/hud/providers/cto.mjs

@@ -0,0 +1,73 @@
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import {
+  CTO_LAKE_CURRENT_RELATIVE_PATH,
+  CTO_STATUS_LINE_MAX_CHARS,
+  CTO_STATUS_STALE_MS,
+} from "../constants.mjs";
+
+function oneLine(value) {
+  return String(value || "")
+    .replace(/\x1b\[[0-9;]*m/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function capLine(line) {
+  const text = oneLine(line);
+  if (text.length <= CTO_STATUS_LINE_MAX_CHARS) return text;
+  return `${text.slice(0, CTO_STATUS_LINE_MAX_CHARS - 3)}...`;
+}
+
+function resolveCurrentPath({ currentPath, rootDir } = {}) {
+  if (currentPath) return currentPath;
+  return join(rootDir || process.cwd(), CTO_LAKE_CURRENT_RELATIVE_PATH);
+}
+
+function extractBriefVersion(lines) {
+  const versionLine = lines.find((line) => /^brief_version:\s*/i.test(line));
+  return oneLine(versionLine?.replace(/^brief_version:\s*/i, "")) || null;
+}
+
+function extractStatusLine(lines) {
+  const summaryLine = lines.find((line) => /^summary:\s*/i.test(line));
+  const summary = oneLine(summaryLine?.replace(/^summary:\s*/i, ""));
+  if (summary) return capLine(summary);
+
+  const sectionHeaders = new Set([
+    "repo_state",
+    "active_goals",
+    "swarm_shards",
+    "hub_status",
+    "recent_events",
+    "generated_at",
+    "injection_note",
+  ]);
+  const fallback = lines.find((line) => {
+    const clean = oneLine(line);
+    return (
+      clean && !/^brief_version:\s*/i.test(clean) && !sectionHeaders.has(clean)
+    );
+  });
+  return fallback ? capLine(fallback) : null;
+}
+
+export function readCtoStatus(options = {}) {
+  try {
+    const currentPath = resolveCurrentPath(options);
+    const stat = statSync(currentPath);
+    const raw = readFileSync(currentPath, "utf8");
+    const lines = raw.split(/\r?\n/u).map(oneLine).filter(Boolean);
+    const line = extractStatusLine(lines);
+    if (!line) return null;
+
+    const version = extractBriefVersion(lines);
+    const isStale = Date.now() - stat.mtimeMs > CTO_STATUS_STALE_MS;
+    return {
+      line,
+      rightTag: isStale ? "stale" : version || "cto",
+    };
+  } catch {
+    return null;
+  }
+}

package/hud/providers/gemini.mjs

@@ -8,7 +8,9 @@ import https from "node:https";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
+  ANTIGRAVITY_MODEL_ABBREV,
   ANTIGRAVITY_OAUTH_PATHS,
+  ANTIGRAVITY_SETTINGS_PATH,
   GEMINI_API_TIMEOUT_MS,
   GEMINI_OAUTH_PATH,
   GEMINI_PROJECT_CACHE_PATH,
@@ -116,6 +118,52 @@ export function getAntigravityEmail() {
   return null;
 }
 
+// agy 1.0.1+ settings.json `model` 필드에서 현재 장착 모델 라벨을 읽는다.
+// 예: "Gemini 3.5 Flash (High)". 없으면 null.
+export function getAntigravityCurrentModel() {
+  const s = readJson(ANTIGRAVITY_SETTINGS_PATH, null);
+  return s?.model || null;
+}
+
+// 모델 라벨 → 2자 약어 (constants의 ANTIGRAVITY_MODEL_ABBREV 매핑).
+// 매핑에 없으면 "<Head> ... (<Level>)" 패턴에서 자동 추출.
+export function getAntigravityModelAbbrev(label) {
+  if (!label) return "??";
+  const known = ANTIGRAVITY_MODEL_ABBREV[label];
+  if (known) return known;
+  const parens = label.match(/\(([^)]+)\)/);
+  const head = label.match(/^(\w+)/);
+  if (head && parens) {
+    return `${head[1][0].toUpperCase()}${parens[1][0].toLowerCase()}`;
+  }
+  if (head) return head[1].slice(0, 2);
+  return "??";
+}
+
+// 모델 라벨 → family ("gemini" | "claude" | "gpt-oss" | "unknown")
+// quota 풀이 family 단위로 분리되므로 slot1 데이터 채울지 결정할 때 사용.
+export function getAntigravityModelFamily(label) {
+  if (!label) return "unknown";
+  if (label.startsWith("Gemini")) return "gemini";
+  if (label.startsWith("Claude")) return "claude";
+  if (label.startsWith("GPT")) return "gpt-oss";
+  return "unknown";
+}
+
+// Gemini family 통합 quota — 모든 bucket 중 최소 remainingFraction을 가진 bucket을 대표로 반환.
+// /usage 실측 (2026-05-22): 4개 모델이 같은 reset window 공유하므로 결과는 사실상 family 단일 카운터.
+export function deriveGeminiFamilyBucket(buckets) {
+  if (!Array.isArray(buckets) || buckets.length === 0) return null;
+  let chosen = null;
+  for (const b of buckets) {
+    if (b?.remainingFraction == null) continue;
+    if (!chosen || b.remainingFraction < chosen.remainingFraction) {
+      chosen = b;
+    }
+  }
+  return chosen;
+}
+
 export function buildGeminiAuthContext(accountId) {
   const oauth = readJson(GEMINI_OAUTH_PATH, null);
   const tokenSource =

package/hud/renderers.mjs

@@ -397,7 +397,8 @@ export function getClaudeRows(
   }
 
   if (currentTier === "compact") {
-    const quotaSection = `${dim("5h:")}${fStr} ${dim(fTime)} ${dim("1w:")}${wStr} ${dim(wTime)}`;
+    const staleTag = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
+    const quotaSection = `${dim("5h:")}${fStr} ${dim(fTime)} ${dim("1w:")}${wStr} ${dim(wTime)}${staleTag}`;
     const warning = ctxView.warningTag
       ? ` ${dim("|")} ${yellow(ctxView.warningTag)}`
       : "";
@@ -406,7 +407,8 @@ export function getClaudeRows(
   }
 
   // full tier (>= 120 cols)
-  const quotaSection = `${dim("5h:")}${fBar}${fStr} ${dim(fTime)} ${dim("1w:")}${wBar}${wStr} ${dim(wTime)}`;
+  const staleTag = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
+  const quotaSection = `${dim("5h:")}${fBar}${fStr} ${dim(fTime)} ${dim("1w:")}${wBar}${wStr} ${dim(wTime)}${staleTag}`;
   const warning = ctxView.warningTag
     ? ` ${dim("|")} ${yellow(ctxView.warningTag)}`
     : "";
@@ -434,14 +436,56 @@ export function getAccountLabel(
   return label;
 }
 
-function formatAntigravityQuotaSection(currentTier) {
+// 2슬롯: slot1 = 현재 장착 모델 약어 (Fh/Fm/Ph/Pl 등), slot2 = "Gn" Gemini family 통합
+// realQuota.pools.{current,gemini_family} 가 있으면 실데이터, 없으면 placeholder.
+function formatAntigravityQuotaSection(
+  currentTier,
+  realQuota,
+  provFn,
+  provAnsi,
+) {
+  const pools = realQuota?.pools || {};
+  const abbr = realQuota?.currentAbbrev || "??";
+  const currentBucket = pools.current;
+  const familyBucket = pools.gemini_family;
+  const hasData = Boolean(currentBucket || familyBucket);
+
+  if (!hasData) {
+    // 기존 placeholder 동작 유지
+    if (currentTier === "minimal") {
+      return `${dim(`${abbr}:`)}${dim(formatPlaceholderPercentCell())} ${dim("Gn:")}${dim(formatPlaceholderPercentCell())}`;
+    }
+    if (currentTier === "compact") {
+      return `${dim(`${abbr}:`)}${dim(formatPlaceholderPercentCell())} ${dim(formatTimeCell("n/a"))} ${dim("Gn:")}${dim(formatPlaceholderPercentCell())} ${dim(formatTimeCell("n/a"))}`;
+    }
+    return `${dim(`${abbr}:`)}${tierDimBar(currentTier)}${dim(formatPlaceholderPercentCell())} ${dim(formatTimeCell("n/a"))} ${dim("Gn:")}${tierDimBar(currentTier)}${dim(formatPlaceholderPercentCell())} ${dim(formatTimeCell("n/a"))}`;
+  }
+
+  const slot = (bucket, label, { withBar, withTime }) => {
+    if (!bucket) {
+      const bar = withBar ? tierDimBar(currentTier) : "";
+      const base = `${dim(`${label}:`)}${bar}${dim(formatPlaceholderPercentCell())}`;
+      return withTime ? `${base} ${dim(formatTimeCell("n/a"))}` : base;
+    }
+    const gl = deriveGeminiLimits(bucket);
+    const usedP = gl
+      ? gl.usedPct
+      : clampPercent(Math.round((1 - (bucket.remainingFraction ?? 1)) * 100));
+    const bar = withBar ? tierBar(currentTier, usedP, provAnsi) : "";
+    const base = `${dim(`${label}:`)}${bar}${colorByProvider(usedP, formatPercentCell(usedP), provFn)}`;
+    if (!withTime) return base;
+    const rstRemaining =
+      formatResetRemaining(bucket.resetTime, ONE_DAY_MS) || "n/a";
+    return `${base} ${dim(formatTimeCell(rstRemaining))}`;
+  };
+
   if (currentTier === "minimal") {
-    return `${dim("q:")}${dim(formatPlaceholderPercentCell())}`;
+    return `${slot(currentBucket, abbr, { withBar: false, withTime: false })} ${slot(familyBucket, "Gn", { withBar: false, withTime: false })}`;
   }
   if (currentTier === "compact") {
-    return `${dim("q:")}${dim(formatPlaceholderPercentCell())} ${dim(formatTimeCell("n/a"))}`;
+    return `${slot(currentBucket, abbr, { withBar: false, withTime: true })} ${slot(familyBucket, "Gn", { withBar: false, withTime: true })}`;
   }
-  return `${dim("q:")}${tierDimBar(currentTier)}${dim(formatPlaceholderPercentCell())} ${dim(formatTimeCell("n/a"))}`;
+  return `${slot(currentBucket, abbr, { withBar: true, withTime: true })} ${slot(familyBucket, "Gn", { withBar: true, withTime: true })}`;
 }
 
 export function getProviderRow(
@@ -540,7 +584,12 @@ export function getProviderRow(
 
   if (currentTier === "minimal") {
     if (provider === "antigravity") {
-      quotaSection = formatAntigravityQuotaSection(currentTier);
+      quotaSection = formatAntigravityQuotaSection(
+        currentTier,
+        realQuota,
+        provFn,
+        provAnsi,
+      );
     }
     if (realQuota?.type === "codex") {
       const main =
@@ -596,7 +645,12 @@ export function getProviderRow(
 
   if (currentTier === "compact") {
     if (provider === "antigravity") {
-      quotaSection = formatAntigravityQuotaSection(currentTier);
+      quotaSection = formatAntigravityQuotaSection(
+        currentTier,
+        realQuota,
+        provFn,
+        provAnsi,
+      );
     }
     if (realQuota?.type === "codex") {
       const main =
@@ -664,7 +718,12 @@ export function getProviderRow(
 
   // full tier
   if (provider === "antigravity") {
-    quotaSection = formatAntigravityQuotaSection(currentTier);
+    quotaSection = formatAntigravityQuotaSection(
+      currentTier,
+      realQuota,
+      provFn,
+      provAnsi,
+    );
   }
 
   if (realQuota?.type === "codex") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.28.1",
+  "version": "10.30.0",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",