@triflux/core 10.0.0-alpha.1 → 10.0.0-alpha.2

package/hub/middleware/request-logger.mjs

@@ -12,10 +12,13 @@
  */
 import { withRequestContext, getCorrelationId } from '../../scripts/lib/context.mjs';
 import { createModuleLogger } from '../../scripts/lib/logger.mjs';
+import { createContextMonitor } from '../../hud/context-monitor.mjs';
 
 const log = createModuleLogger('hub');
+const contextMonitor = createContextMonitor();
 
 const SKIP_PATHS = new Set(['/health', '/healthz', '/status', '/ready']);
+const MAX_CAPTURE_BYTES = 256 * 1024;
 
 /**
  * 원본 request handler를 래핑하여 로깅 + 컨텍스트 전파를 추가한다.
@@ -44,6 +47,50 @@ export function wrapRequestHandler(handler) {
       },
       () => {
         const startTime = process.hrtime.bigint();
+        const reqChunks = [];
+        let reqBytes = 0;
+        let reqOverflow = false;
+
+        req.on('data', (chunk) => {
+          if (reqOverflow) return;
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+          reqBytes += buf.length;
+          if (reqBytes > MAX_CAPTURE_BYTES) {
+            reqOverflow = true;
+            reqChunks.length = 0;
+            return;
+          }
+          reqChunks.push(buf);
+        });
+
+        const resChunks = [];
+        let resBytes = 0;
+        let resOverflow = false;
+
+        const originalWrite = res.write.bind(res);
+        const originalEnd = res.end.bind(res);
+
+        function captureResponseChunk(chunk) {
+          if (resOverflow || chunk == null) return;
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+          resBytes += buf.length;
+          if (resBytes > MAX_CAPTURE_BYTES) {
+            resOverflow = true;
+            resChunks.length = 0;
+            return;
+          }
+          resChunks.push(buf);
+        }
+
+        res.write = function writePatched(chunk, ...args) {
+          captureResponseChunk(chunk);
+          return originalWrite(chunk, ...args);
+        };
+
+        res.end = function endPatched(chunk, ...args) {
+          captureResponseChunk(chunk);
+          return originalEnd(chunk, ...args);
+        };
 
         // 응답 헤더에 상관 ID 포함
         const cid = getCorrelationId();
@@ -55,15 +102,48 @@ export function wrapRequestHandler(handler) {
           const level = res.statusCode >= 500 ? 'error'
             : res.statusCode >= 400 ? 'warn'
             : 'info';
+          const reqBodyText = reqOverflow ? '' : Buffer.concat(reqChunks).toString('utf8');
+          const resBodyText = resOverflow ? '' : Buffer.concat(resChunks).toString('utf8');
+          const tokenSummary = contextMonitor.record({
+            requestBody: reqBodyText,
+            requestBytes: reqBytes || Number(req.headers['content-length'] || 0),
+            responseBody: resBodyText,
+            responseBytes: resBytes || Number(res.getHeader('content-length') || 0),
+          });
 
           log[level](
             {
               status: res.statusCode,
               duration: Math.round(duration * 100) / 100,
               contentLength: res.getHeader('content-length') || 0,
+              tokenUsage: {
+                request: tokenSummary.requestTokens,
+                response: tokenSummary.responseTokens,
+                total: tokenSummary.totalTokens,
+                context: tokenSummary.display,
+                warningLevel: tokenSummary.warningLevel,
+                overheadMs: tokenSummary.overheadMs,
+              },
             },
             'http.response',
           );
+
+          if (tokenSummary.warningLevel === 'critical') {
+            log.error(
+              { context: tokenSummary.display, message: tokenSummary.warningMessage },
+              'context.critical',
+            );
+          } else if (tokenSummary.warningLevel === 'warn') {
+            log.warn(
+              { context: tokenSummary.display, message: tokenSummary.warningMessage },
+              'context.warn',
+            );
+          } else if (tokenSummary.warningLevel === 'info') {
+            log.info(
+              { context: tokenSummary.display, message: tokenSummary.warningMessage },
+              'context.info',
+            );
+          }
         });
 
         handler(req, res);

package/hub/router.mjs

@@ -1,7 +1,7 @@
 // hub/router.mjs — 실시간 라우팅/수신함 상태 관리자
 // SQLite는 감사 로그만 담당하고, 실제 배달 상태는 메모리에서 관리한다.
 import { EventEmitter, once } from 'node:events';
-import { uuidv7 } from './store.mjs';
+import { uuidv7 } from './lib/uuidv7.mjs';
 
 const ASSIGN_PENDING_STATUSES = new Set(['queued', 'running']);
 

package/hub/team-bridge.mjs

@@ -1,25 +1,27 @@
-// hub/team-bridge.mjs — core ↔ team 디커플링 인터페이스
-// pipe.mjs, tools.mjs가 team/nativeProxy를 직접 참조하지 않도록
-// registry 패턴으로 구현을 주입받는다.
-// remote 미설치 시 graceful no-op 반환.
+// @triflux/core — team-bridge 인터페이스
+// remote 패키지가 런타임에 구현을 주입한다.
 
-const noTeam = async () => ({
-  ok: false,
-  error: { code: 'NO_TEAM', message: 'Team module not loaded' },
-});
+/**
+ * @typedef {object} TeamBridge
+ * @property {(args?: object) => Promise<object>} teamInfo
+ * @property {(args?: object) => Promise<object>} teamTaskList
+ * @property {(args?: object) => Promise<object>} teamTaskUpdate
+ * @property {(args?: object) => Promise<object>} teamSendMessage
+ */
 
-let _impl = {
-  teamInfo: noTeam,
-  teamTaskList: noTeam,
-  teamTaskUpdate: noTeam,
-  teamSendMessage: noTeam,
-};
+/** @type {TeamBridge | null} */
+let _bridge = null;
 
+/**
+ * @param {TeamBridge | null} impl
+ */
 export function registerTeamBridge(impl) {
-  _impl = { ..._impl, ...impl };
+  _bridge = impl;
 }
 
-export function teamInfo(args) { return _impl.teamInfo(args); }
-export function teamTaskList(args) { return _impl.teamTaskList(args); }
-export function teamTaskUpdate(args) { return _impl.teamTaskUpdate(args); }
-export function teamSendMessage(args) { return _impl.teamSendMessage(args); }
+/**
+ * @returns {TeamBridge | null}
+ */
+export function getTeamBridge() {
+  return _bridge;
+}

package/hud/constants.mjs

@@ -12,6 +12,13 @@ export const ACCOUNTS_STATE_PATH = join(homedir(), ".omc", "state", "cli_account
 
 // tfx-multi 상태 (v2.2 HUD 통합)
 export const TEAM_STATE_PATH = join(homedir(), ".claude", "cache", "tfx-hub", "team-state.json");
+export const CONTEXT_MONITOR_CACHE_PATH = join(homedir(), ".claude", "cache", "tfx-hub", "context-monitor.json");
+export const CONTEXT_MONITOR_LEGACY_PATH = join(homedir(), ".omc", "state", "context-monitor.json");
+export const CONTEXT_MONITOR_LOG_DIR = join(homedir(), ".omc", "logs");
+
+// 원격 프로브 캐시 (tfx-remote-spawn)
+export const REMOTE_ENV_CACHE_DIR = join(homedir(), ".claude", "cache", "tfx-hub", "remote-env");
+export const REMOTE_ENV_CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
 
 // Claude OAuth Usage API (api.anthropic.com/api/oauth/usage)
 export const CLAUDE_CREDENTIALS_PATH = join(homedir(), ".claude", ".credentials.json");

package/hud/context-monitor.mjs

@@ -0,0 +1,403 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+
+import {
+  CONTEXT_MONITOR_CACHE_PATH,
+  CONTEXT_MONITOR_LEGACY_PATH,
+  CONTEXT_MONITOR_LOG_DIR,
+} from "./constants.mjs";
+import { clampPercent, formatTokenCount, readJsonMigrate } from "./utils.mjs";
+
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+const MAX_CAPTURE_BYTES = 256 * 1024;
+const MAX_TOP_KEYS = 20;
+
+const WARNING_LEVELS = Object.freeze({
+  ok: { min: 0, message: "" },
+  info: { min: 60, message: "컨텍스트 절반 이상 사용" },
+  warn: { min: 80, message: "압축 권장" },
+  critical: { min: 90, message: "에이전트 분할 또는 세션 교체 권장" },
+});
+
+// Unlike clampPercent (rounds), this preserves decimals for precise threshold comparison.
+function clampThresholdPercent(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return 0;
+  return Math.max(0, Math.min(100, numeric));
+}
+
+function safeWriteJson(filePath, data) {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+  } catch {
+    // noop
+  }
+}
+
+function normalizeText(input) {
+  if (typeof input === "string") return input;
+  if (input == null) return "";
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+
+function safeJsonParse(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function toTokenEstimate(bytesOrText) {
+  if (typeof bytesOrText === "number" && Number.isFinite(bytesOrText)) {
+    if (bytesOrText <= 0) return 0;
+    return Math.max(1, Math.ceil(bytesOrText / 4));
+  }
+  const text = normalizeText(bytesOrText);
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (bytes <= 0) return 0;
+  return Math.max(1, Math.ceil(bytes / 4));
+}
+
+function normalizeUsage(usage) {
+  if (!usage || typeof usage !== "object") return null;
+  const input = Number(usage.input_tokens ?? usage.inputTokens ?? 0);
+  const output = Number(usage.output_tokens ?? usage.outputTokens ?? 0);
+  const cacheCreation = Number(
+    usage.cache_creation_input_tokens
+      ?? usage.cacheCreationInputTokens
+      ?? usage.cache_creation_tokens
+      ?? 0,
+  );
+  const cacheRead = Number(
+    usage.cache_read_input_tokens
+      ?? usage.cacheReadInputTokens
+      ?? usage.cache_read_tokens
+      ?? 0,
+  );
+  const totalCandidate = Number(usage.total_tokens ?? usage.totalTokens ?? Number.NaN);
+  const total = Number.isFinite(totalCandidate) && totalCandidate > 0
+    ? totalCandidate
+    : input + output + cacheCreation + cacheRead;
+  if (!Number.isFinite(total) || total <= 0) return null;
+  return {
+    input: Math.max(0, Math.round(input)),
+    output: Math.max(0, Math.round(output)),
+    cacheCreation: Math.max(0, Math.round(cacheCreation)),
+    cacheRead: Math.max(0, Math.round(cacheRead)),
+    total: Math.max(0, Math.round(total)),
+  };
+}
+
+function extractUsage(payload) {
+  if (!payload || typeof payload !== "object") return null;
+
+  const queue = [payload];
+  const seen = new Set();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || typeof current !== "object") continue;
+    if (seen.has(current)) continue;
+    seen.add(current);
+
+    const directUsage = normalizeUsage(current.usage);
+    if (directUsage) return directUsage;
+
+    if (Array.isArray(current.content)) {
+      for (const item of current.content) queue.push(item);
+    }
+
+    for (const key of ["result", "payload", "response", "message", "data"]) {
+      if (current[key] && typeof current[key] === "object") {
+        queue.push(current[key]);
+      }
+    }
+  }
+  return null;
+}
+
+function bumpCounter(target, key, tokens) {
+  if (!key) return;
+  const prev = target[key] || 0;
+  target[key] = prev + tokens;
+}
+
+function pushTopKeys(inputMap, maxKeys = MAX_TOP_KEYS) {
+  const entries = Object.entries(inputMap || {});
+  entries.sort((a, b) => b[1] - a[1]);
+  return Object.fromEntries(entries.slice(0, maxKeys));
+}
+
+function extractFileKeys(args) {
+  if (!args || typeof args !== "object") return [];
+  const out = [];
+  const add = (value) => {
+    if (typeof value !== "string" || !value.trim()) return;
+    out.push(value.trim());
+  };
+  add(args.path);
+  add(args.file);
+  add(args.filename);
+  add(args.relative_path);
+  add(args.requestFilePath);
+  add(args.responseFilePath);
+  if (Array.isArray(args.paths)) {
+    for (const p of args.paths) add(p);
+  }
+  return Array.from(new Set(out)).slice(0, 5);
+}
+
+function detectSkillHints(payloadText) {
+  if (!payloadText) return [];
+  const matches = payloadText.match(/\$[a-z0-9_-]+/gi) || [];
+  return Array.from(new Set(matches.map((m) => m.replace(/^\$/, "")))).slice(0, 5);
+}
+
+export function estimateTokens(input) {
+  return toTokenEstimate(input);
+}
+
+export function parseUsageFromPayload(payload) {
+  return extractUsage(payload);
+}
+
+export function classifyContextThreshold(percent) {
+  const p = clampThresholdPercent(percent);
+  if (p >= WARNING_LEVELS.critical.min) return { level: "critical", message: WARNING_LEVELS.critical.message };
+  if (p >= WARNING_LEVELS.warn.min) return { level: "warn", message: WARNING_LEVELS.warn.message };
+  if (p >= WARNING_LEVELS.info.min) return { level: "info", message: WARNING_LEVELS.info.message };
+  return { level: "ok", message: "" };
+}
+
+export function formatContextUsage(usedTokens, limitTokens, percent = null) {
+  const used = Math.max(0, Math.round(Number(usedTokens) || 0));
+  const limit = Math.max(1, Math.round(Number(limitTokens) || DEFAULT_CONTEXT_LIMIT));
+  const pct = percent == null ? clampPercent((used / limit) * 100) : clampPercent(percent);
+  return `${formatTokenCount(used)}/${formatTokenCount(limit)} (${pct}%)`;
+}
+
+export function readContextMonitorSnapshot() {
+  return readJsonMigrate(CONTEXT_MONITOR_CACHE_PATH, CONTEXT_MONITOR_LEGACY_PATH, null);
+}
+
+function getStdinContextUsage(stdin) {
+  const limitTokens = Number(stdin?.context_window?.context_window_size || 0);
+  const nativePercent = Number(stdin?.context_window?.used_percentage);
+  const usage = stdin?.context_window?.current_usage || {};
+  const explicitUsed = Number(usage.total_tokens || 0);
+  const calculatedUsed = Number(usage.input_tokens || 0)
+    + Number(usage.cache_creation_input_tokens || 0)
+    + Number(usage.cache_read_input_tokens || 0);
+  const usedTokens = explicitUsed > 0 ? explicitUsed : calculatedUsed;
+
+  if (limitTokens > 0 && usedTokens > 0) {
+    return {
+      usedTokens: Math.round(usedTokens),
+      limitTokens: Math.round(limitTokens),
+      percent: clampPercent((usedTokens / limitTokens) * 100),
+      source: "stdin.tokens",
+    };
+  }
+
+  if (limitTokens > 0 && Number.isFinite(nativePercent)) {
+    const percent = clampPercent(nativePercent);
+    return {
+      usedTokens: Math.round((limitTokens * percent) / 100),
+      limitTokens: Math.round(limitTokens),
+      percent,
+      source: "stdin.percent",
+    };
+  }
+  return null;
+}
+
+export function buildContextUsageView(stdin, snapshot = null) {
+  const stdinUsage = getStdinContextUsage(stdin);
+  const monitor = snapshot || readContextMonitorSnapshot();
+  const fallbackLimit = Number(monitor?.limitTokens || DEFAULT_CONTEXT_LIMIT);
+
+  const usedTokens = stdinUsage?.usedTokens
+    ?? Number(monitor?.usedTokens || 0);
+  const limitTokens = stdinUsage?.limitTokens
+    ?? Math.max(1, fallbackLimit);
+  const percent = stdinUsage?.percent
+    ?? (limitTokens > 0 ? clampPercent((usedTokens / limitTokens) * 100) : 0);
+
+  const warning = classifyContextThreshold(percent);
+  return {
+    usedTokens,
+    limitTokens,
+    percent,
+    display: formatContextUsage(usedTokens, limitTokens, percent),
+    warningLevel: warning.level,
+    warningMessage: warning.message,
+    warningTag: warning.level === "warn" ? "⚠ 압축 권장"
+      : warning.level === "critical" ? "‼ 분할 권장"
+      : warning.level === "info" ? "ℹ 절반 이상 사용"
+      : "",
+    source: stdinUsage?.source || (monitor ? "monitor" : "none"),
+  };
+}
+
+export function createContextMonitor(options = {}) {
+  const limitTokens = Number(options.limitTokens || DEFAULT_CONTEXT_LIMIT);
+  const cachePath = options.cachePath || CONTEXT_MONITOR_CACHE_PATH;
+  const logsDir = options.logsDir || CONTEXT_MONITOR_LOG_DIR;
+  const sessionId = options.sessionId || randomUUID().slice(0, 8);
+  const registerExitHooks = options.registerExitHooks !== false;
+
+  const state = {
+    sessionId,
+    startedAt: new Date().toISOString(),
+    updatedAt: null,
+    limitTokens,
+    usedTokens: 0,
+    requestTokens: 0,
+    responseTokens: 0,
+    exactUsageTokens: 0,
+    totalUpdates: 0,
+    maxPercent: 0,
+    warningLevel: "ok",
+    warningMessage: "",
+    bySkill: {},
+    byFile: {},
+    byTool: {},
+  };
+
+  const writeSnapshot = () => {
+    const percent = clampPercent((state.usedTokens / state.limitTokens) * 100);
+    const warning = classifyContextThreshold(percent);
+    state.maxPercent = Math.max(state.maxPercent, percent);
+    state.warningLevel = warning.level;
+    state.warningMessage = warning.message;
+    state.updatedAt = new Date().toISOString();
+    safeWriteJson(cachePath, {
+      ...state,
+      display: formatContextUsage(state.usedTokens, state.limitTokens, percent),
+      percent,
+      bySkill: pushTopKeys(state.bySkill),
+      byFile: pushTopKeys(state.byFile),
+      byTool: pushTopKeys(state.byTool),
+    });
+    return { percent, warning };
+  };
+
+  const writeReport = (reason = "shutdown") => {
+    const percent = clampPercent((state.usedTokens / state.limitTokens) * 100);
+    const warning = classifyContextThreshold(percent);
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const reportPath = join(logsDir, `context-usage-${state.sessionId}-${ts}.json`);
+    safeWriteJson(reportPath, {
+      sessionId: state.sessionId,
+      reason,
+      startedAt: state.startedAt,
+      endedAt: new Date().toISOString(),
+      summary: {
+        usedTokens: state.usedTokens,
+        limitTokens: state.limitTokens,
+        percent,
+        warningLevel: warning.level,
+        warningMessage: warning.message,
+        requestTokens: state.requestTokens,
+        responseTokens: state.responseTokens,
+        exactUsageTokens: state.exactUsageTokens,
+        updates: state.totalUpdates,
+      },
+      breakdown: {
+        skills: pushTopKeys(state.bySkill),
+        files: pushTopKeys(state.byFile),
+        tools: pushTopKeys(state.byTool),
+      },
+    });
+    return reportPath;
+  };
+
+  const record = ({
+    requestBody = null,
+    requestBytes = 0,
+    responseBody = null,
+    responseBytes = 0,
+    toolName = "",
+  } = {}) => {
+    const started = process.hrtime.bigint();
+    const reqObj = typeof requestBody === "object" ? requestBody : safeJsonParse(String(requestBody || ""));
+    const resObj = typeof responseBody === "object" ? responseBody : safeJsonParse(String(responseBody || ""));
+
+    const usage = parseUsageFromPayload(resObj);
+    const requestTokens = requestBytes > 0 ? toTokenEstimate(requestBytes) : toTokenEstimate(requestBody);
+    const responseTokens = usage?.total ?? (responseBytes > 0 ? toTokenEstimate(responseBytes) : toTokenEstimate(responseBody));
+    const totalTokens = Math.max(0, requestTokens + responseTokens);
+
+    const method = reqObj?.method || reqObj?.params?.name || "";
+    const name = toolName || reqObj?.params?.name || reqObj?.tool || "";
+    const args = reqObj?.params?.arguments || reqObj?.arguments || reqObj?.params || {};
+    const payloadText = normalizeText(requestBody).slice(0, MAX_CAPTURE_BYTES);
+    const skills = detectSkillHints(payloadText);
+    const files = extractFileKeys(args);
+
+    if (name) bumpCounter(state.byTool, String(name), totalTokens);
+    if (method?.includes("tool")) {
+      bumpCounter(state.byTool, String(method), totalTokens);
+    }
+    for (const file of files) bumpCounter(state.byFile, file, totalTokens);
+    for (const skill of skills) bumpCounter(state.bySkill, skill, totalTokens);
+
+    state.requestTokens += requestTokens;
+    state.responseTokens += responseTokens;
+    state.exactUsageTokens += usage?.total || 0;
+    state.usedTokens += totalTokens;
+    state.totalUpdates += 1;
+
+    const { percent, warning } = writeSnapshot();
+    const overheadMs = Number(process.hrtime.bigint() - started) / 1_000_000;
+
+    return {
+      requestTokens,
+      responseTokens,
+      totalTokens,
+      usedTokens: state.usedTokens,
+      limitTokens: state.limitTokens,
+      percent,
+      warningLevel: warning.level,
+      warningMessage: warning.message,
+      display: formatContextUsage(state.usedTokens, state.limitTokens, percent),
+      overheadMs: Math.round(overheadMs * 1000) / 1000,
+    };
+  };
+
+  let reportWritten = false;
+  const flush = (reason = "shutdown") => {
+    if (reportWritten) return null;
+    reportWritten = true;
+    return writeReport(reason);
+  };
+
+  if (registerExitHooks) {
+    const flushOnExit = () => {
+      try { flush("process.exit"); } catch {}
+    };
+    process.once("exit", flushOnExit);
+    process.once("SIGINT", flushOnExit);
+    process.once("SIGTERM", flushOnExit);
+  }
+
+  return {
+    record,
+    flush,
+    snapshot: () => ({
+      ...state,
+      bySkill: pushTopKeys(state.bySkill),
+      byFile: pushTopKeys(state.byFile),
+      byTool: pushTopKeys(state.byTool),
+    }),
+  };
+}

package/hud/hud-qos-status.mjs

@@ -13,14 +13,16 @@ import {
   GEMINI_PRO_POOL, GEMINI_FLASH_POOL,
 } from "./constants.mjs";
 import {
-  readJson, readStdinJson, getContextPercent, getProviderAccountId, getCliArgValue,
+  readJson, readStdinJson, getProviderAccountId, getCliArgValue,
 } from "./utils.mjs";
 import { selectTier } from "./terminal.mjs";
 
 // Claude provider
 import {
   readClaudeUsageSnapshot, scheduleClaudeUsageRefresh, fetchClaudeUsage,
+  readClaudeContextSnapshot,
 } from "./providers/claude.mjs";
+import { buildContextUsageView } from "./context-monitor.mjs";
 
 // Codex provider
 import {
@@ -79,6 +81,7 @@ async function main() {
   const accountsConfig = readJson(ACCOUNTS_CONFIG_PATH, { providers: {} });
   const accountsState = readJson(ACCOUNTS_STATE_PATH, { providers: {} });
   const claudeUsageSnapshot = readClaudeUsageSnapshot();
+  const contextSnapshot = readClaudeContextSnapshot();
   if (claudeUsageSnapshot.shouldRefresh) {
     scheduleClaudeUsageRefresh();
   }
@@ -99,6 +102,7 @@ async function main() {
 
   // 실측 데이터 추출
   const stdin = await stdinPromise;
+  const contextView = buildContextUsageView(stdin, contextSnapshot);
   const codexEmail = getCodexEmail();
   const geminiEmail = getGeminiEmail();
   const codexBuckets = codexSnapshot.buckets;
@@ -145,7 +149,7 @@ async function main() {
 
   // nano tier: 1줄 모드 (극소 폭 또는 알림 배너 대응)
   if (CURRENT_TIER === "nano") {
-    const microLine = getMicroLine(stdin, claudeUsageSnapshot.data, codexBuckets,
+    const microLine = getMicroLine(contextView, claudeUsageSnapshot.data, codexBuckets,
       geminiSession, geminiBucket, combinedSvPct);
     process.stdout.write(`\x1b[0m${microLine}\n`);
     return;
@@ -160,7 +164,7 @@ async function main() {
   };
 
   const rows = [
-    ...getClaudeRows(CURRENT_TIER, stdin, claudeUsageSnapshot.data, combinedSvPct),
+    ...getClaudeRows(CURRENT_TIER, contextView, claudeUsageSnapshot.data, combinedSvPct),
     getProviderRow(CURRENT_TIER, "codex", "x", codexWhite, qosProfile, accountsConfig, accountsState,
       codexQuotaData, codexEmail, codexSv, null),
     getProviderRow(CURRENT_TIER, "gemini", "g", geminiBlue, qosProfile, accountsConfig, accountsState,
@@ -194,7 +198,7 @@ async function main() {
   }
 
   // 선행 개행: 알림 배너(노란 글씨)가 빈 첫 줄에 오도록 → HUD 내용 보호
-  const contextPercent = getContextPercent(stdin);
+  const contextPercent = contextView.percent;
   const leadingBreaks = contextPercent >= 85 ? "\n\n" : "\n";
   // 줄별 RESET: Claude Code TUI 스타일 간섭 방지 (색상 밝기 버그 수정)
   const resetedLines = outputLines.map(line => `\x1b[0m${line}`);

package/hud/providers/claude.mjs

@@ -14,6 +14,7 @@ import {
   DEFAULT_OAUTH_CLIENT_ID, CLAUDE_REFRESH_FLAG,
 } from "../constants.mjs";
 import { readJson, writeJsonSafe, clampPercent, advanceToNextCycle } from "../utils.mjs";
+import { readContextMonitorSnapshot } from "../context-monitor.mjs";
 
 // OMC 활성 여부에 따라 캐시 TTL 동적 결정
 function getClaudeUsageStaleMs() {
@@ -307,3 +308,7 @@ export function scheduleClaudeUsageRefresh() {
     writeClaudeUsageCache(null, { type: "network", status: 0, hint: String(spawnErr?.message || spawnErr) });
   }
 }
+
+export function readClaudeContextSnapshot() {
+  return readContextMonitorSnapshot();
+}