@triflux/core 10.28.1 → 10.29.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,14 @@
 //
 // external source 훅 (session-vault 등)은 여전히 execFile로 실행된다.
 
+import { execFile } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  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 +26,111 @@ 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 */
+  }
+}
+
 /**
  * BLOCKING 훅을 순차 실행. 하나라도 throw하면 로그만 남기고 계속.
  * @param {string} stdinData
@@ -174,6 +285,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 +309,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,161 @@
+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;
+  return Promise.race([
+    settled,
+    new Promise((resolve) => {
+      const t = setTimeout(resolve, ms);
+      if (typeof t.unref === "function") t.unref();
+    }),
+  ]);
+}
+
+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

@@ -73,6 +73,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 +158,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

@@ -50,8 +50,12 @@ import {
 // Gemini provider
 import {
   buildGeminiAuthContext,
+  deriveGeminiFamilyBucket,
   fetchGeminiQuota,
+  getAntigravityCurrentModel,
   getAntigravityEmail,
+  getAntigravityModelAbbrev,
+  getAntigravityModelFamily,
   getGeminiEmail,
   readGeminiQuotaSnapshot,
   readGeminiSessionSnapshot,
@@ -151,7 +155,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 +205,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,7 +272,18 @@ 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,

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,
       },
@@ -320,7 +395,7 @@ export function parseClaudeUsageResponse(response) {
   // 키 자체가 부재하면 percent=null (HUD --% placeholder), utilization=null 만 0%로 처리
   const fiveHourPresent = response.five_hour != null;
   const sevenDayPresent = response.seven_day != null;
-  return {
+  const result = {
     fiveHourPercent: fiveHourPresent
       ? clampPercent(response.five_hour.utilization ?? 0)
       : null,
@@ -330,6 +405,19 @@ export function parseClaudeUsageResponse(response) {
     fiveHourResetsAt: response.five_hour?.resets_at || null,
     weeklyResetsAt: response.seven_day?.resets_at || null,
   };
+  if (response.seven_day_sonnet != null) {
+    result.sonnetWeeklyPercent = clampPercent(
+      response.seven_day_sonnet.utilization ?? 0,
+    );
+    result.sonnetWeeklyResetsAt = response.seven_day_sonnet.resets_at || null;
+  }
+  if (response.seven_day_opus != null) {
+    result.opusWeeklyPercent = clampPercent(
+      response.seven_day_opus.utilization ?? 0,
+    );
+    result.opusWeeklyResetsAt = response.seven_day_opus.resets_at || null;
+  }
+  return result;
 }
 
 // stale 캐시의 과거 resetsAt → 다음 주기로 순환 추정 (null 대신 다음 reset 시간 계산)
@@ -350,6 +438,20 @@ export function stripStaleResets(data) {
         advanceToNextCycle(t, SEVEN_DAY_MS),
       ).toISOString();
   }
+  if (copy.sonnetWeeklyResetsAt) {
+    const t = new Date(copy.sonnetWeeklyResetsAt).getTime();
+    if (!Number.isNaN(t))
+      copy.sonnetWeeklyResetsAt = new Date(
+        advanceToNextCycle(t, SEVEN_DAY_MS),
+      ).toISOString();
+  }
+  if (copy.opusWeeklyResetsAt) {
+    const t = new Date(copy.opusWeeklyResetsAt).getTime();
+    if (!Number.isNaN(t))
+      copy.opusWeeklyResetsAt = new Date(
+        advanceToNextCycle(t, SEVEN_DAY_MS),
+      ).toISOString();
+  }
   return copy;
 }
 

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

@@ -375,6 +375,34 @@ export function getClaudeRows(
       : tierDimBar(currentTier);
   const fTime = formatTimeCell(fiveHourReset);
   const wTime = formatTimeCellDH(weeklyReset);
+  const modelWeeklyPart = (label, percent, resetsAt, { includeTime }) => {
+    if (!hasData || percent == null || percent <= 0) return null;
+    const value = colorByProvider(
+      percent,
+      formatPercentCell(percent),
+      claudeOrange,
+    );
+    const reset = resetsAt
+      ? formatResetRemainingDayHour(resetsAt, SEVEN_DAY_MS)
+      : null;
+    const time = includeTime && reset ? ` ${dim(formatTimeCellDH(reset))}` : "";
+    return `${dim(`${label}:`)}${value}${time}`;
+  };
+  const modelWeeklyParts = ({ includeTime = false } = {}) =>
+    [
+      modelWeeklyPart(
+        "Sn",
+        claudeUsage?.sonnetWeeklyPercent,
+        claudeUsage?.sonnetWeeklyResetsAt,
+        { includeTime },
+      ),
+      modelWeeklyPart(
+        "Op",
+        claudeUsage?.opusWeeklyPercent,
+        claudeUsage?.opusWeeklyResetsAt,
+        { includeTime },
+      ),
+    ].filter(Boolean);
 
   if (currentTier === "nano" || currentTier === "micro") {
     const fShort =
@@ -391,13 +419,18 @@ export function getClaudeRows(
 
   if (currentTier === "minimal") {
     const staleTag = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
-    const quotaSection = `${dim("5h:")}${fStr} ${dim("1w:")}${wStr}${staleTag}`;
+    const modelSection = modelWeeklyParts();
+    const modelSuffix = modelSection.length ? ` ${modelSection.join(" ")}` : "";
+    const quotaSection = `${dim("5h:")}${fStr} ${dim("1w:")}${wStr}${modelSuffix}${staleTag}`;
     const right = `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}`;
     return [{ prefix, left: quotaSection, right }];
   }
 
   if (currentTier === "compact") {
-    const quotaSection = `${dim("5h:")}${fStr} ${dim(fTime)} ${dim("1w:")}${wStr} ${dim(wTime)}`;
+    const staleTag = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
+    const modelSection = modelWeeklyParts();
+    const modelSuffix = modelSection.length ? ` ${modelSection.join(" ")}` : "";
+    const quotaSection = `${dim("5h:")}${fStr} ${dim(fTime)} ${dim("1w:")}${wStr} ${dim(wTime)}${modelSuffix}${staleTag}`;
     const warning = ctxView.warningTag
       ? ` ${dim("|")} ${yellow(ctxView.warningTag)}`
       : "";
@@ -406,7 +439,10 @@ 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 modelSection = modelWeeklyParts({ includeTime: true });
+  const modelSuffix = modelSection.length ? ` ${modelSection.join(" ")}` : "";
+  const quotaSection = `${dim("5h:")}${fBar}${fStr} ${dim(fTime)} ${dim("1w:")}${wBar}${wStr} ${dim(wTime)}${modelSuffix}${staleTag}`;
   const warning = ctxView.warningTag
     ? ` ${dim("|")} ${yellow(ctxView.warningTag)}`
     : "";
@@ -434,14 +470,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 +618,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 +679,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 +752,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.29.0",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",