triflux 10.3.2 → 10.3.4

package/hub/workers/factory.mjs

@@ -1,21 +1,21 @@
-// hub/workers/factory.mjs — Worker 생성 팩토리
-
-import { GeminiWorker } from './gemini-worker.mjs';
-import { ClaudeWorker } from './claude-worker.mjs';
-import { CodexMcpWorker } from './codex-mcp.mjs';
-import { DelegatorMcpWorker } from './delegator-mcp.mjs';
-
-export function createWorker(type, opts = {}) {
-  switch (type) {
-    case 'gemini':
-      return new GeminiWorker(opts);
-    case 'claude':
-      return new ClaudeWorker(opts);
-    case 'codex':
-      return new CodexMcpWorker(opts);
-    case 'delegator':
-      return new DelegatorMcpWorker(opts);
-    default:
-      throw new Error(`Unknown worker type: ${type}`);
-  }
-}
+// hub/workers/factory.mjs — Worker 생성 팩토리
+
+import { GeminiWorker } from './gemini-worker.mjs';
+import { ClaudeWorker } from './claude-worker.mjs';
+import { CodexMcpWorker } from './codex-mcp.mjs';
+import { DelegatorMcpWorker } from './delegator-mcp.mjs';
+
+export function createWorker(type, opts = {}) {
+  switch (type) {
+    case 'gemini':
+      return new GeminiWorker(opts);
+    case 'claude':
+      return new ClaudeWorker(opts);
+    case 'codex':
+      return new CodexMcpWorker(opts);
+    case 'delegator':
+      return new DelegatorMcpWorker(opts);
+    default:
+      throw new Error(`Unknown worker type: ${type}`);
+  }
+}

package/hud/hud-qos-status.mjs

@@ -16,6 +16,7 @@ import {
   readJson, readStdinJson, getProviderAccountId, getCliArgValue,
 } from "./utils.mjs";
 import { selectTier } from "./terminal.mjs";
+import { getMissionBoardState } from "./mission-board.mjs";
 
 // Claude provider
 import {
@@ -41,7 +42,7 @@ import {
 // Renderers
 import {
   getClaudeRows, getProviderRow, getTeamRow,
-  renderAlignedRows, getMicroLine,
+  renderAlignedRows, getMicroLine, renderMissionBoard,
   readLatestBenchmarkDiff, formatTokenSummary,
   readTokenSavings, readSvAccumulator,
 } from "./renderers.mjs";
@@ -103,11 +104,15 @@ async function main() {
   // 실측 데이터 추출
   const stdin = await stdinPromise;
   const contextView = buildContextUsageView(stdin, contextSnapshot);
+  const claudeUsage = claudeUsageSnapshot.isStale
+    ? { ...(claudeUsageSnapshot.data || {}), stale: true }
+    : claudeUsageSnapshot.data;
   const codexEmail = getCodexEmail();
   const geminiEmail = getGeminiEmail();
   const codexBuckets = codexSnapshot.buckets;
   const geminiSession = geminiSessionSnapshot.session;
   const geminiQuota = geminiQuotaSnapshot.quota;
+  const missionBoardState = await getMissionBoardState();
 
   // 누적 절약 데이터 읽기
   const svSavings = readTokenSavings();
@@ -149,7 +154,7 @@ async function main() {
 
   // nano tier: 1줄 모드 (극소 폭 또는 알림 배너 대응)
   if (CURRENT_TIER === "nano") {
-    const microLine = getMicroLine(contextView, claudeUsageSnapshot.data, codexBuckets,
+    const microLine = getMicroLine(contextView, claudeUsage, codexBuckets,
       geminiSession, geminiBucket, combinedSvPct);
     process.stdout.write(`\x1b[0m${microLine}\n`);
     return;
@@ -164,7 +169,7 @@ async function main() {
   };
 
   const rows = [
-    ...getClaudeRows(CURRENT_TIER, contextView, claudeUsageSnapshot.data, combinedSvPct),
+    ...getClaudeRows(CURRENT_TIER, contextView, claudeUsage, combinedSvPct),
     getProviderRow(CURRENT_TIER, "codex", "x", codexWhite, qosProfile, accountsConfig, accountsState,
       codexQuotaData, codexEmail, codexSv, null),
     getProviderRow(CURRENT_TIER, "gemini", "g", geminiBlue, qosProfile, accountsConfig, accountsState,
@@ -175,6 +180,15 @@ async function main() {
   const teamRow = getTeamRow(CURRENT_TIER);
   if (teamRow) rows.push(teamRow);
 
+  const missionBoard = renderMissionBoard(missionBoardState);
+  if (missionBoard) {
+    rows.push({
+      prefix: bold(claudeOrange("\u25B2")),
+      left: missionBoard,
+      right: "",
+    });
+  }
+
   // 최근 벤치마크 diff → 토큰 요약 행 추가
   const latestDiff = readLatestBenchmarkDiff();
   if (latestDiff) {

package/hud/mission-board.mjs

@@ -0,0 +1,53 @@
+// ============================================================================
+// HUD Mission Board — .omc/state/sessions/ 기반 에이전트 진행률 집계
+// ============================================================================
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const SESSIONS_DIR = join(homedir(), ".omc", "state", "sessions");
+
+/**
+ * .omc/state/sessions/ 디렉토리를 읽어 팀 상태를 반환한다.
+ * @returns {{ agents: Array<{name: string, status: string, progress: number}>, dagLevel: number, totalProgress: number } | null}
+ */
+export async function getMissionBoardState(sessionsDir = SESSIONS_DIR) {
+  let entries;
+  try {
+    entries = await readdir(sessionsDir);
+  } catch {
+    return null;
+  }
+
+  const jsonFiles = entries.filter((f) => f.endsWith(".json"));
+  if (jsonFiles.length === 0) return null;
+
+  const agents = [];
+  for (const file of jsonFiles) {
+    let data;
+    try {
+      const raw = await readFile(join(sessionsDir, file), "utf8");
+      data = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+
+    const name = data.name ?? file.replace(/\.json$/, "");
+    const status = data.status ?? "idle";
+    const progress = typeof data.progress === "number" ? data.progress : 0;
+    agents.push({ name, status, progress });
+  }
+
+  if (agents.length === 0) return null;
+
+  const totalProgress = agents.length > 0
+    ? Math.round(agents.reduce((sum, a) => sum + a.progress, 0) / agents.length)
+    : 0;
+
+  return {
+    agents,
+    // TODO: derive dagLevel from real mission dependency metadata instead of hardcoding 0.
+    dagLevel: 0,
+    totalProgress,
+  };
+}

package/hud/providers/claude.mjs

@@ -16,6 +16,16 @@ import {
 import { readJson, writeJsonSafe, clampPercent, advanceToNextCycle } from "../utils.mjs";
 import { readContextMonitorSnapshot } from "../context-monitor.mjs";
 
+export const CLAUDE_USAGE_POLL_BASE_MS = 5_000;
+export const CLAUDE_USAGE_POLL_JITTER_RATIO = 0.2;
+export const CLAUDE_USAGE_RATE_LIMIT_BACKOFF_MS = [
+  CLAUDE_USAGE_POLL_BASE_MS,
+  10_000,
+  30_000,
+  60_000,
+  120_000,
+];
+
 // OMC 활성 여부에 따라 캐시 TTL 동적 결정
 function getClaudeUsageStaleMs() {
   return existsSync(OMC_PLUGIN_USAGE_CACHE_PATH)
@@ -23,6 +33,49 @@ function getClaudeUsageStaleMs() {
     : CLAUDE_USAGE_STALE_MS_SOLO;
 }
 
+export function computeClaudeUsagePollState({
+  consecutive429s = 0,
+  outcome = "success",
+  random = Math.random,
+  jitterRatio = CLAUDE_USAGE_POLL_JITTER_RATIO,
+} = {}) {
+  const current429s = Number.isFinite(consecutive429s) ? Math.max(0, consecutive429s) : 0;
+  const next429s = outcome === "rate_limit" ? current429s + 1 : 0;
+  const stepIndex = outcome === "rate_limit"
+    ? Math.min(next429s, CLAUDE_USAGE_RATE_LIMIT_BACKOFF_MS.length - 1)
+    : 0;
+  const baseDelayMs = CLAUDE_USAGE_RATE_LIMIT_BACKOFF_MS[stepIndex];
+  const sample = Number(random?.());
+  const normalized = Number.isFinite(sample) ? Math.min(1, Math.max(0, sample)) : 0.5;
+  const jitterFactor = 1 + ((normalized * 2) - 1) * jitterRatio;
+  return {
+    consecutive429s: next429s,
+    baseDelayMs,
+    delayMs: Math.max(1, Math.round(baseDelayMs * jitterFactor)),
+  };
+}
+
+function getSnapshotSchedule(cache) {
+  const timestamp = Number(cache?.timestamp);
+  const nextRefreshAt = Number(cache?.nextRefreshAt);
+  if (Number.isFinite(nextRefreshAt)) {
+    return {
+      nextRefreshAt,
+      shouldRefresh: Date.now() >= nextRefreshAt,
+    };
+  }
+
+  const ageMs = Number.isFinite(timestamp) ? Date.now() - timestamp : Number.MAX_SAFE_INTEGER;
+  const fallbackMs = cache?.error
+    ? (cache.errorType === "rate_limit" ? CLAUDE_USAGE_429_BACKOFF_MS : CLAUDE_USAGE_ERROR_BACKOFF_MS)
+    : getClaudeUsageStaleMs();
+
+  return {
+    nextRefreshAt: Number.isFinite(timestamp) ? timestamp + fallbackMs : null,
+    shouldRefresh: ageMs >= fallbackMs,
+  };
+}
+
 export function readClaudeCredentials() {
   const data = readJson(CLAUDE_CREDENTIALS_PATH, null);
   if (!data) return null;
@@ -154,18 +207,21 @@ export function stripStaleResets(data) {
 export function readClaudeUsageSnapshot() {
   const cache = readJson(CLAUDE_USAGE_CACHE_PATH, null);
   const ts = Number(cache?.timestamp);
-  const ageMs = Number.isFinite(ts) ? Date.now() - ts : Number.MAX_SAFE_INTEGER;
+  const schedule = getSnapshotSchedule(cache);
+  const staleBackoffActive = cache?.errorType === "rate_limit"
+    && Number.isFinite(schedule.nextRefreshAt)
+    && Date.now() < schedule.nextRefreshAt;
 
   // 1차: 자체 캐시에 유효 데이터가 있는 경우
   if (cache?.data) {
     // 에러 상태에서 보존된 stale 데이터 → backoff 존중하되 표시용 데이터 반환
     if (cache.error) {
-      const backoffMs = cache.errorType === "rate_limit"
-        ? CLAUDE_USAGE_429_BACKOFF_MS
-        : CLAUDE_USAGE_ERROR_BACKOFF_MS;
-      return { data: stripStaleResets(cache.data), shouldRefresh: ageMs >= backoffMs };
+      return {
+        data: stripStaleResets(cache.data),
+        shouldRefresh: schedule.shouldRefresh,
+        isStale: staleBackoffActive,
+      };
     }
-    const isFresh = ageMs < getClaudeUsageStaleMs();
     // resets_at이 지난 윈도우의 percent를 0으로 보정 (stale 캐시 방지)
     const data = { ...cache.data };
     const now = Date.now();
@@ -175,24 +231,21 @@ export function readClaudeUsageSnapshot() {
     if (data.weeklyResetsAt && new Date(data.weeklyResetsAt).getTime() <= now) {
       data.weeklyPercent = 0;
     }
-    return { data, shouldRefresh: !isFresh };
+    return { data, shouldRefresh: schedule.shouldRefresh, isStale: false };
   }
 
   // 2차: 에러 backoff — 최근 에러 시 재시도 억제 (무한 spawn 방지)
   if (cache?.error && Number.isFinite(ts)) {
-    const backoffMs = cache.errorType === "rate_limit"
-      ? CLAUDE_USAGE_429_BACKOFF_MS
-      : CLAUDE_USAGE_ERROR_BACKOFF_MS;
-    if (ageMs < backoffMs) {
+    if (!schedule.shouldRefresh) {
       const omcCache = readJson(OMC_PLUGIN_USAGE_CACHE_PATH, null);
       // OMC 캐시가 에러 이후 갱신되었으면 → 에러 캐시 덮어쓰고 그 데이터 사용
       if (omcCache?.data?.fiveHourPercent != null && omcCache.timestamp > ts) {
         writeClaudeUsageCache(omcCache.data);
-        return { data: omcCache.data, shouldRefresh: false };
+        return { data: omcCache.data, shouldRefresh: false, isStale: false };
       }
       // stale OMC fallback 또는 null (--% 플레이스홀더 표시, 가짜 0% 방지)
       const staleData = omcCache?.data?.fiveHourPercent != null ? stripStaleResets(omcCache.data) : null;
-      return { data: staleData, shouldRefresh: false };
+      return { data: staleData, shouldRefresh: false, isStale: staleBackoffActive };
     }
   }
 
@@ -203,23 +256,37 @@ export function readClaudeUsageSnapshot() {
     const omcAge = Number.isFinite(omcCache.timestamp) ? Date.now() - omcCache.timestamp : Number.MAX_SAFE_INTEGER;
     if (omcAge < OMC_CACHE_MAX_AGE_MS) {
       writeClaudeUsageCache(omcCache.data);
-      return { data: omcCache.data, shouldRefresh: omcAge > getClaudeUsageStaleMs() };
+      return { data: omcCache.data, shouldRefresh: omcAge > getClaudeUsageStaleMs(), isStale: false };
     }
     // stale이어도 data: null보다는 오래된 데이터를 fallback으로 표시
-    return { data: stripStaleResets(omcCache.data), shouldRefresh: true };
+    return { data: stripStaleResets(omcCache.data), shouldRefresh: true, isStale: false };
   }
 
   // 캐시/fallback 모두 없음: null 반환 → --% 플레이스홀더 + 리프레시 시도
-  return { data: null, shouldRefresh: true };
+  return { data: null, shouldRefresh: true, isStale: false };
 }
 
-export function writeClaudeUsageCache(data, errorInfo = null) {
+export function writeClaudeUsageCache(data, errorInfo = null, pollState = null) {
+  const state = pollState || (errorInfo
+    ? {
+      consecutive429s: errorInfo.type === "rate_limit" ? 1 : 0,
+      baseDelayMs: errorInfo.type === "rate_limit"
+        ? CLAUDE_USAGE_429_BACKOFF_MS
+        : CLAUDE_USAGE_ERROR_BACKOFF_MS,
+      delayMs: errorInfo.type === "rate_limit"
+        ? CLAUDE_USAGE_429_BACKOFF_MS
+        : CLAUDE_USAGE_ERROR_BACKOFF_MS,
+    }
+    : computeClaudeUsagePollState({ outcome: "success" }));
   const entry = {
     timestamp: Date.now(),
     data,
     error: !!errorInfo,
     errorType: errorInfo?.type || null,   // "rate_limit" | "auth" | "network" | "unknown"
     errorStatus: errorInfo?.status || null, // HTTP 상태 코드
+    consecutive429s: state.consecutive429s,
+    nextRefreshBaseMs: state.baseDelayMs,
+    nextRefreshAt: Date.now() + state.delayMs,
   };
   // 에러 시 기존 유효 데이터 보존 (--% n/a 방지)
   if (errorInfo && data == null) {
@@ -234,9 +301,11 @@ export function writeClaudeUsageCache(data, errorInfo = null) {
 
 export async function fetchClaudeUsage(forceRefresh = false) {
   const existingSnapshot = readClaudeUsageSnapshot();
-  if (!forceRefresh && !existingSnapshot.shouldRefresh && existingSnapshot.data) {
-    return existingSnapshot.data;
+  if (!forceRefresh && !existingSnapshot.shouldRefresh) {
+    return existingSnapshot.data || null;
   }
+  const cache = readJson(CLAUDE_USAGE_CACHE_PATH, null);
+  const consecutive429s = Number.isFinite(cache?.consecutive429s) ? cache.consecutive429s : 0;
   let creds = readClaudeCredentials();
   if (!creds) {
     writeClaudeUsageCache(null, { type: "auth", status: 0 });
@@ -262,11 +331,15 @@ export async function fetchClaudeUsage(forceRefresh = false) {
       : result.status === 401 || result.status === 403 ? "auth"
       : result.error === "timeout" || result.error === "network" ? "network"
       : "unknown";
-    writeClaudeUsageCache(existingSnapshot.data, { type: errorType, status: result.status });
+    const pollState = errorType === "rate_limit"
+      ? computeClaudeUsagePollState({ consecutive429s, outcome: "rate_limit" })
+      : null;
+    writeClaudeUsageCache(existingSnapshot.data, { type: errorType, status: result.status }, pollState);
     return existingSnapshot.data || null;
   }
   const usage = parseClaudeUsageResponse(result.data);
-  writeClaudeUsageCache(usage, usage ? null : { type: "unknown", status: 0 });
+  const pollState = usage ? computeClaudeUsagePollState({ outcome: "success" }) : null;
+  writeClaudeUsageCache(usage, usage ? null : { type: "unknown", status: 0 }, pollState);
   return usage;
 }
 
@@ -291,7 +364,7 @@ export function scheduleClaudeUsageRefresh() {
   try {
     if (existsSync(lockPath)) {
       const lockAge = Date.now() - readJson(lockPath, {}).t;
-      if (lockAge < 30000) return; // 30초 이내 스폰 이력 → 건너뜀
+      if (lockAge < 1000) return; // 짧은 중복 스폰만 억제, 실제 폴링 주기는 nextRefreshAt가 제어
     }
     writeJsonSafe(lockPath, { t: Date.now() });
   } catch { /* 락 실패 무시 — 스폰 진행 */ }

package/hud/renderers.mjs

@@ -122,6 +122,38 @@ export function getTeamRow(currentTier) {
   };
 }
 
+// ============================================================================
+// Mission Board 렌더러
+// ============================================================================
+
+const STATUS_ICON = {
+  active: "*",
+  idle: ".",
+  done: "+",
+  failed: "!",
+};
+
+/**
+ * Mission Board 상태를 1줄 compact 포맷으로 렌더링한다.
+ * 예: "MB: exec:+ ui:* perf:. [2/3 67%]"
+ * @param {{ agents: Array<{name: string, status: string, progress: number}>, dagLevel: number, totalProgress: number } | null} state
+ * @returns {string}
+ */
+export function renderMissionBoard(state) {
+  if (!state) return "";
+
+  const { agents, totalProgress } = state;
+  const done = agents.filter((a) => a.status === "done").length;
+  const total = agents.length;
+
+  const parts = agents.map((a) => {
+    const icon = STATUS_ICON[a.status] ?? "?";
+    return `${a.name}:${icon}`;
+  });
+
+  return `MB: ${parts.join(" ")} [${done}/${total} ${totalProgress}%]`;
+}
+
 // ============================================================================
 // 행 정렬 렌더링
 // ============================================================================
@@ -159,6 +191,7 @@ export function renderAlignedRows(rows) {
 // ============================================================================
 export function getMicroLine(contextView, claudeUsage, codexBuckets, geminiSession, geminiBucket, combinedSvPct) {
   const ctxView = contextView || buildContextUsageView({}, null);
+  const staleMarker = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
 
   // Claude 5h/1w
   const cF = claudeUsage?.fiveHourPercent != null ? clampPercent(claudeUsage.fiveHourPercent) : null;
@@ -198,7 +231,7 @@ export function getMicroLine(contextView, claudeUsage, codexBuckets, geminiSessi
     `${bold(codexWhite("x"))}${dim(":")}${xVal} ` +
     `${bold(geminiBlue("g"))}${dim(":")}${gVal} ` +
     `${dim("sv:")}${sv} ` +
-    `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}`;
+    `${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}${staleMarker}`;
   return truncateAnsi(line, cols);
 }
 
@@ -208,6 +241,7 @@ export function getMicroLine(contextView, claudeUsage, codexBuckets, geminiSessi
 export function getClaudeRows(currentTier, contextView, claudeUsage, combinedSvPct) {
   const ctxView = contextView || buildContextUsageView({}, null);
   const prefix = `${bold(claudeOrange("c"))}:`;
+  const staleMarker = claudeUsage?.stale ? ` ${dim("[stale]")}` : "";
 
   // 절약 퍼센트
   const svStr = formatSvPct(combinedSvPct || 0);
@@ -235,25 +269,25 @@ export function getClaudeRows(currentTier, contextView, claudeUsage, combinedSvP
   if (currentTier === "nano" || currentTier === "micro") {
     const fShort = hasData && fiveHourPercent != null ? colorByProvider(fiveHourPercent, `${fiveHourPercent}%`, claudeOrange) : dim("--");
     const wShort = hasData && weeklyPercent != null ? colorByProvider(weeklyPercent, `${weeklyPercent}%`, claudeOrange) : dim("--");
-    const quotaSection = `${fShort}${dim("/")}${wShort}`;
+    const quotaSection = `${fShort}${dim("/")}${wShort}${staleMarker}`;
     return [{ prefix, left: quotaSection, right: "" }];
   }
 
   if (currentTier === "minimal") {
-    const quotaSection = `${dim("5h:")}${fStr} ${dim("1w:")}${wStr}`;
+    const quotaSection = `${dim("5h:")}${fStr} ${dim("1w:")}${wStr}${staleMarker}`;
     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 quotaSection = `${dim("5h:")}${fStr} ${dim(fTime)} ${dim("1w:")}${wStr} ${dim(wTime)}${staleMarker}`;
     const warning = ctxView.warningTag ? ` ${dim("|")} ${yellow(ctxView.warningTag)}` : "";
     const contextSection = `${svSuffix} ${dim("|")} ${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}${warning}`;
     return [{ prefix, left: quotaSection, right: contextSection }];
   }
 
   // full tier (>= 120 cols)
-  const quotaSection = `${dim("5h:")}${fBar}${fStr} ${dim(fTime)} ${dim("1w:")}${wBar}${wStr} ${dim(wTime)}`;
+  const quotaSection = `${dim("5h:")}${fBar}${fStr} ${dim(fTime)} ${dim("1w:")}${wBar}${wStr} ${dim(wTime)}${staleMarker}`;
   const warning = ctxView.warningTag ? ` ${dim("|")} ${yellow(ctxView.warningTag)}` : "";
   const contextSection = `${svSuffix} ${dim("|")} ${dim("CTX:")}${colorByPercent(ctxView.percent, ctxView.display)}${warning}`;
   return [{ prefix, left: quotaSection, right: contextSection }];

package/mesh/index.mjs

@@ -0,0 +1,63 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+
+export { MSG_TYPES, createMessage, serialize, deserialize, validate } from "./mesh-protocol.mjs";
+export { createRegistry } from "./mesh-registry.mjs";
+export { createMeshBudget } from "./mesh-budget.mjs";
+export { routeMessage, routeOrDeadLetter } from "./mesh-router.mjs";
+export { createMessageQueue } from "./mesh-queue.mjs";
+export { createHeartbeatMonitor } from "./mesh-heartbeat.mjs";
+
+/**
+ * Loads skills assigned to a specific agent from a skills directory.
+ * Reuses the same directory-scan approach as generateSkillDocs().
+ *
+ * @param {string} agentId - The agent identifier
+ * @param {string} skillsDir - Path to the skills directory
+ * @returns {Promise<string[]>} Array of skill names available to this agent
+ */
+export async function loadSkillsForAgent(agentId, skillsDir) {
+  if (!agentId || typeof agentId !== "string") {
+    throw new TypeError("agentId must be a non-empty string");
+  }
+  if (!skillsDir || typeof skillsDir !== "string") {
+    throw new TypeError("skillsDir must be a non-empty string");
+  }
+
+  let entries;
+  try {
+    entries = readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const skills = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillName = entry.name;
+    const skillPath = join(skillsDir, skillName, "SKILL.md");
+    let skillContent = null;
+    try {
+      const { readFileSync } = await import("node:fs");
+      skillContent = readFileSync(skillPath, "utf8");
+    } catch {
+      // Skill has no SKILL.md — include it anyway
+    }
+
+    // If SKILL.md mentions the agentId or no agent restriction, include it
+    const isRestricted = skillContent
+      ? /^agents?\s*:/im.test(skillContent)
+      : false;
+
+    if (!isRestricted) {
+      skills.push(skillName);
+      continue;
+    }
+
+    if (skillContent && skillContent.includes(agentId)) {
+      skills.push(skillName);
+    }
+  }
+
+  return skills;
+}

package/mesh/mesh-budget.mjs

@@ -0,0 +1,128 @@
+/**
+ * Warning level thresholds mirroring context-monitor.mjs classifyContextThreshold().
+ * Reproduced here to avoid cross-module dependency.
+ */
+const WARNING_LEVELS = Object.freeze({
+  critical: 90,
+  warn: 80,
+  info: 60,
+  ok: 0,
+});
+
+/**
+ * Clamps a percentage value to [0, 100].
+ * @param {number} value
+ * @returns {number}
+ */
+function clampPercent(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return 0;
+  return Math.min(100, Math.max(0, n));
+}
+
+/**
+ * Classifies a usage percentage into a warning level.
+ * Mirrors context-monitor.mjs classifyContextThreshold().
+ * @param {number} percent
+ * @returns {{ level: string, message: string }}
+ */
+function classifyLevel(percent) {
+  const p = clampPercent(percent);
+  if (p >= WARNING_LEVELS.critical) return { level: "critical", message: "에이전트 분할 또는 세션 교체 권장" };
+  if (p >= WARNING_LEVELS.warn) return { level: "warn", message: "압축 권장" };
+  if (p >= WARNING_LEVELS.info) return { level: "info", message: "컨텍스트 절반 이상 사용" };
+  return { level: "ok", message: "" };
+}
+
+/**
+ * Creates a per-agent token budget manager.
+ * @returns {object} Budget API
+ */
+export function createMeshBudget() {
+  // Map<agentId, { allocated: number, consumed: number }>
+  const budgets = new Map();
+
+  /**
+   * Allocates a token budget to an agent.
+   * @param {string} agentId
+   * @param {number} tokenLimit
+   */
+  function allocate(agentId, tokenLimit) {
+    if (!agentId || typeof agentId !== "string") {
+      throw new TypeError("agentId must be a non-empty string");
+    }
+    const limit = Math.max(0, Math.round(Number(tokenLimit) || 0));
+    const existing = budgets.get(agentId);
+    budgets.set(agentId, {
+      allocated: limit,
+      consumed: existing?.consumed ?? 0,
+    });
+  }
+
+  /**
+   * Records token consumption for an agent.
+   * @param {string} agentId
+   * @param {number} tokens
+   * @returns {{ remaining: number, percent: number, level: string }}
+   */
+  function consume(agentId, tokens) {
+    const budget = budgets.get(agentId);
+    if (!budget) {
+      throw new Error(`No budget allocated for agent: ${agentId}`);
+    }
+    const amount = Math.max(0, Math.round(Number(tokens) || 0));
+    const updated = {
+      allocated: budget.allocated,
+      consumed: budget.consumed + amount,
+    };
+    budgets.set(agentId, updated);
+
+    const remaining = Math.max(0, updated.allocated - updated.consumed);
+    const percent = updated.allocated > 0
+      ? clampPercent((updated.consumed / updated.allocated) * 100)
+      : 100;
+    const { level } = classifyLevel(percent);
+    return { remaining, percent, level };
+  }
+
+  /**
+   * Returns the budget status for an agent.
+   * @param {string} agentId
+   * @returns {{ allocated: number, consumed: number, remaining: number, level: string }}
+   */
+  function getStatus(agentId) {
+    const budget = budgets.get(agentId);
+    if (!budget) {
+      return { allocated: 0, consumed: 0, remaining: 0, level: "ok" };
+    }
+    const remaining = Math.max(0, budget.allocated - budget.consumed);
+    const percent = budget.allocated > 0
+      ? clampPercent((budget.consumed / budget.allocated) * 100)
+      : 0;
+    const { level } = classifyLevel(percent);
+    return { allocated: budget.allocated, consumed: budget.consumed, remaining, level };
+  }
+
+  /**
+   * Resets consumed tokens for all agents (keeps allocations).
+   */
+  function resetAll() {
+    for (const [agentId, budget] of budgets) {
+      budgets.set(agentId, { allocated: budget.allocated, consumed: 0 });
+    }
+  }
+
+  /**
+   * Returns a snapshot of all current allocations.
+   * @returns {Map<string, { allocated: number, consumed: number }>}
+   */
+  function listAllocations() {
+    const snap = new Map();
+    for (const [id, b] of budgets) {
+      snap.set(id, Object.freeze({ ...b }));
+    }
+    return snap;
+  }
+
+  return { allocate, consume, getStatus, resetAll, listAllocations };
+}