@triflux/core 10.1.0 → 10.25.1

package/hud/terminal.mjs

@@ -2,51 +2,111 @@
 // 터미널 감지 / 4-Tier 적응형 렌더링
 // ============================================================================
 import { execSync } from "node:child_process";
-import { DIM, RESET, GAUGE_WIDTH, coloredBar } from "./colors.mjs";
+import { coloredBar, DIM, GAUGE_WIDTH, RESET } from "./colors.mjs";
+import {
+  COMPACT_COLS_THRESHOLD,
+  HUD_CONFIG_PATH,
+  MINIMAL_COLS_THRESHOLD,
+} from "./constants.mjs";
 import { readJson } from "./utils.mjs";
-import { HUD_CONFIG_PATH, COMPACT_COLS_THRESHOLD, MINIMAL_COLS_THRESHOLD } from "./constants.mjs";
 
 let _cachedColumns = 0;
 export function getTerminalColumns() {
   if (_cachedColumns > 0) return _cachedColumns;
   const envCols = Number(process.env.COLUMNS);
-  if (envCols > 0) { _cachedColumns = envCols; return _cachedColumns; }
-  if (process.stdout.columns) { _cachedColumns = process.stdout.columns; return _cachedColumns; }
-  if (process.stderr.columns) { _cachedColumns = process.stderr.columns; return _cachedColumns; }
+  if (envCols > 0) {
+    _cachedColumns = envCols;
+    return _cachedColumns;
+  }
+  if (process.stdout.columns) {
+    _cachedColumns = process.stdout.columns;
+    return _cachedColumns;
+  }
+  if (process.stderr.columns) {
+    _cachedColumns = process.stderr.columns;
+    return _cachedColumns;
+  }
   try {
     if (process.platform === "win32") {
-      const raw = execSync("mode con", { timeout: 2000, stdio: ["pipe", "pipe", "pipe"], windowsHide: true }).toString();
-      const m = raw.match(/Columns[^:]*:\s*(\d+)/i) || raw.match(/열[^:]*:\s*(\d+)/);
-      if (m) { _cachedColumns = Number(m[1]); return _cachedColumns; }
+      const raw = execSync("mode con", {
+        timeout: 2000,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+      }).toString();
+      const m =
+        raw.match(/Columns[^:]*:\s*(\d+)/i) || raw.match(/열[^:]*:\s*(\d+)/);
+      if (m) {
+        _cachedColumns = Number(m[1]);
+        return _cachedColumns;
+      }
     } else {
-      const raw = execSync("tput cols 2>/dev/null || stty size 2>/dev/null | awk '{print $2}'", {
-        timeout: 2000, stdio: ["pipe", "pipe", "pipe"],
-      }).toString().trim();
-      if (raw && !isNaN(Number(raw))) { _cachedColumns = Number(raw); return _cachedColumns; }
+      const raw = execSync(
+        "tput cols 2>/dev/null || stty size 2>/dev/null | awk '{print $2}'",
+        {
+          timeout: 2000,
+          stdio: ["pipe", "pipe", "pipe"],
+        },
+      )
+        .toString()
+        .trim();
+      if (raw && !Number.isNaN(Number(raw))) {
+        _cachedColumns = Number(raw);
+        return _cachedColumns;
+      }
     }
-  } catch { /* 감지 실패 */ }
+  } catch {
+    /* 감지 실패 */
+  }
   return 0;
 }
 
 let _cachedRows = 0;
 export function getTerminalRows() {
   if (_cachedRows > 0) return _cachedRows;
-  if (process.stdout.rows) { _cachedRows = process.stdout.rows; return _cachedRows; }
-  if (process.stderr.rows) { _cachedRows = process.stderr.rows; return _cachedRows; }
+  if (process.stdout.rows) {
+    _cachedRows = process.stdout.rows;
+    return _cachedRows;
+  }
+  if (process.stderr.rows) {
+    _cachedRows = process.stderr.rows;
+    return _cachedRows;
+  }
   const envLines = Number(process.env.LINES);
-  if (envLines > 0) { _cachedRows = envLines; return _cachedRows; }
+  if (envLines > 0) {
+    _cachedRows = envLines;
+    return _cachedRows;
+  }
   try {
     if (process.platform === "win32") {
-      const raw = execSync("mode con", { timeout: 2000, stdio: ["pipe", "pipe", "pipe"], windowsHide: true }).toString();
-      const m = raw.match(/Lines[^:]*:\s*(\d+)/i) || raw.match(/줄[^:]*:\s*(\d+)/);
-      if (m) { _cachedRows = Number(m[1]); return _cachedRows; }
+      const raw = execSync("mode con", {
+        timeout: 2000,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+      }).toString();
+      const m =
+        raw.match(/Lines[^:]*:\s*(\d+)/i) || raw.match(/줄[^:]*:\s*(\d+)/);
+      if (m) {
+        _cachedRows = Number(m[1]);
+        return _cachedRows;
+      }
     } else {
-      const raw = execSync("tput lines 2>/dev/null || stty size 2>/dev/null | awk '{print $1}'", {
-        timeout: 2000, stdio: ["pipe", "pipe", "pipe"],
-      }).toString().trim();
-      if (raw && !isNaN(Number(raw))) { _cachedRows = Number(raw); return _cachedRows; }
+      const raw = execSync(
+        "tput lines 2>/dev/null || stty size 2>/dev/null | awk '{print $1}'",
+        {
+          timeout: 2000,
+          stdio: ["pipe", "pipe", "pipe"],
+        },
+      )
+        .toString()
+        .trim();
+      if (raw && !Number.isNaN(Number(raw))) {
+        _cachedRows = Number(raw);
+        return _cachedRows;
+      }
     }
-  } catch { /* 감지 실패 */ }
+  } catch {
+    /* 감지 실패 */
+  }
   return 0;
 }
 
@@ -60,12 +120,15 @@ export function detectCompactMode() {
   if (process.env.OMC_HUD_COMPACT === "0") return false;
   // 3. 설정 파일 (~/.omc/config/hud.json)
   const hudConfig = readJson(HUD_CONFIG_PATH, null);
-  if (hudConfig?.compact === true || hudConfig?.compact === "always") return true;
-  if (hudConfig?.compact === false || hudConfig?.compact === "never") return false;
+  if (hudConfig?.compact === true || hudConfig?.compact === "always")
+    return true;
+  if (hudConfig?.compact === false || hudConfig?.compact === "never")
+    return false;
   // 4. maxLines < 3이면 자동 컴팩트 (알림 배너 공존 대응)
   if (Number(hudConfig?.lines) > 0 && Number(hudConfig?.lines) < 3) return true;
   // 5. 터미널 폭 자동 감지 (TTY 있을 때만 유효)
-  const threshold = Number(hudConfig?.compactThreshold) || COMPACT_COLS_THRESHOLD;
+  const threshold =
+    Number(hudConfig?.compactThreshold) || COMPACT_COLS_THRESHOLD;
   const cols = getTerminalColumns();
   if (cols > 0 && cols < threshold) return true;
   return false;
@@ -95,7 +158,8 @@ export function selectTier(stdin, claudeUsage = null) {
 
   // 1) 명시적 tier 강제 설정
   const forcedTier = hudConfig?.tier;
-  if (["full", "compact", "minimal", "micro", "nano"].includes(forcedTier)) return forcedTier;
+  if (["full", "compact", "minimal", "micro", "nano"].includes(forcedTier))
+    return forcedTier;
 
   // 1.5) maxLines=1 → nano (1줄 모드: 알림 배너/분할화면 대응)
   if (Number(hudConfig?.lines) === 1) return "nano";
@@ -123,14 +187,20 @@ export function selectTier(stdin, claudeUsage = null) {
 
 // full tier 전용: 게이지 바 접두사 (normal 이하 tier에서는 빈 문자열)
 export function tierBar(currentTier, percent, baseColor = null) {
-  return currentTier === "full" ? coloredBar(percent, GAUGE_WIDTH, baseColor) + " " : "";
+  return currentTier === "full"
+    ? coloredBar(percent, GAUGE_WIDTH, baseColor) + " "
+    : "";
 }
 export function tierDimBar(currentTier) {
-  return currentTier === "full" ? DIM + "░".repeat(GAUGE_WIDTH) + RESET + " " : "";
+  return currentTier === "full"
+    ? DIM + "░".repeat(GAUGE_WIDTH) + RESET + " "
+    : "";
 }
 // Gemini ∞% 전용: 무한 쿼터이므로 dim 회색 바
 export function tierInfBar(currentTier) {
-  return currentTier === "full" ? DIM + "█".repeat(GAUGE_WIDTH) + RESET + " " : "";
+  return currentTier === "full"
+    ? DIM + "█".repeat(GAUGE_WIDTH) + RESET + " "
+    : "";
 }
 
 // 테스트 지원: 캐시 초기화

package/hud/utils.mjs

@@ -1,11 +1,14 @@
 // ============================================================================
 // 유틸리티 함수
 // ============================================================================
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
+
 import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import {
-  PERCENT_CELL_WIDTH, TIME_CELL_INNER_WIDTH, SV_CELL_WIDTH,
+  PERCENT_CELL_WIDTH,
+  SV_CELL_WIDTH,
+  TIME_CELL_INNER_WIDTH,
 } from "./constants.mjs";
 
 export async function readStdinJson() {
@@ -20,8 +23,15 @@ export async function readStdinJson() {
     process.stdin.on("end", () => {
       clearTimeout(timeout);
       const raw = chunks.join("").trim();
-      if (!raw) { resolve({}); return; }
-      try { resolve(JSON.parse(raw)); } catch { resolve({}); }
+      if (!raw) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        resolve({});
+      }
     });
     process.stdin.on("error", () => {
       clearTimeout(timeout);
@@ -33,14 +43,20 @@ export async function readStdinJson() {
 
 export function readJson(filePath, fallback) {
   if (!existsSync(filePath)) return fallback;
-  try { return JSON.parse(readFileSync(filePath, "utf-8")); } catch { return fallback; }
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
 }
 
 export function writeJsonSafe(filePath, data) {
   try {
     mkdirSync(dirname(filePath), { recursive: true });
     writeFileSync(filePath, JSON.stringify(data), { mode: 0o600 });
-  } catch { /* 쓰기 실패 무시 */ }
+  } catch {
+    /* 쓰기 실패 무시 */
+  }
 }
 
 // .omc/ → .claude/cache/ 마이그레이션: 새 경로 우선, 없으면 레거시 읽고 복사
@@ -48,7 +64,10 @@ export function readJsonMigrate(newPath, legacyPath, fallback) {
   const data = readJson(newPath, null);
   if (data != null) return data;
   const legacy = readJson(legacyPath, null);
-  if (legacy != null) { writeJsonSafe(newPath, legacy); return legacy; }
+  if (legacy != null) {
+    writeJsonSafe(newPath, legacy);
+    return legacy;
+  }
   return fallback;
 }
 
@@ -109,7 +128,10 @@ export function truncateAnsi(text, maxWidth) {
 }
 
 export function makeHash(text) {
-  return createHash("sha256").update(String(text || ""), "utf8").digest("hex").slice(0, 16);
+  return createHash("sha256")
+    .update(String(text || ""), "utf8")
+    .digest("hex")
+    .slice(0, 16);
 }
 
 export function clampPercent(value) {
@@ -177,29 +199,34 @@ export function formatTokenCount(n) {
 
 export function getContextPercent(stdin) {
   const nativePercent = stdin?.context_window?.used_percentage;
-  if (typeof nativePercent === "number" && Number.isFinite(nativePercent)) return clampPercent(nativePercent);
+  if (typeof nativePercent === "number" && Number.isFinite(nativePercent))
+    return clampPercent(nativePercent);
   const usage = stdin?.context_window?.current_usage || {};
-  const totalTokens = Number(usage.input_tokens || 0)
-    + Number(usage.cache_creation_input_tokens || 0)
-    + Number(usage.cache_read_input_tokens || 0);
+  const totalTokens =
+    Number(usage.input_tokens || 0) +
+    Number(usage.cache_creation_input_tokens || 0) +
+    Number(usage.cache_read_input_tokens || 0);
   const capacity = Number(stdin?.context_window?.context_window_size || 0);
   if (!capacity || capacity <= 0) return 0;
   return clampPercent((totalTokens / capacity) * 100);
 }
 
 // 과거 리셋 시간 → 다음 주기로 순환하여 미래 시점 반환
+// elapsed가 cycleMs의 정수배일 때 ceil은 target=now를 반환해 diff=0이 되므로
+// floor+1로 항상 다음 사이클을 가리키도록 한다.
 export function advanceToNextCycle(epochMs, cycleMs) {
   const now = Date.now();
   if (epochMs >= now || !cycleMs) return epochMs;
   const elapsed = now - epochMs;
-  return epochMs + Math.ceil(elapsed / cycleMs) * cycleMs;
+  return epochMs + (Math.floor(elapsed / cycleMs) + 1) * cycleMs;
 }
 
 function parseResetDate(isoOrUnix) {
   if (!isoOrUnix) return null;
-  const date = typeof isoOrUnix === "string"
-    ? new Date(isoOrUnix)
-    : new Date(isoOrUnix * 1000);
+  const date =
+    typeof isoOrUnix === "string"
+      ? new Date(isoOrUnix)
+      : new Date(isoOrUnix * 1000);
   return Number.isNaN(date.getTime()) ? null : date;
 }
 
@@ -261,9 +288,13 @@ export function decodeJwtEmail(idToken) {
   let payload = parts[1].replace(/-/g, "+").replace(/_/g, "/");
   while (payload.length % 4) payload += "=";
   try {
-    const decoded = JSON.parse(Buffer.from(payload, "base64").toString("utf-8"));
+    const decoded = JSON.parse(
+      Buffer.from(payload, "base64").toString("utf-8"),
+    );
     return decoded.email || null;
-  } catch { return null; }
+  } catch {
+    return null;
+  }
 }
 
 // HTTPS POST (타임아웃 포함) — https 모듈은 호출자가 주입
@@ -272,26 +303,35 @@ export function createHttpsPost(https, timeoutMs) {
     return new Promise((resolve) => {
       const urlObj = new URL(url);
       const data = JSON.stringify(body);
-      const req = https.request({
-        hostname: urlObj.hostname,
-        path: urlObj.pathname + urlObj.search,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${accessToken}`,
-          "Content-Length": Buffer.byteLength(data),
+      const req = https.request(
+        {
+          hostname: urlObj.hostname,
+          path: urlObj.pathname + urlObj.search,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Length": Buffer.byteLength(data),
+          },
+          timeout: timeoutMs,
         },
-        timeout: timeoutMs,
-      }, (res) => {
-        const chunks = [];
-        res.on("data", (c) => chunks.push(c));
-        res.on("end", () => {
-          try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
-          catch { resolve(null); }
-        });
-      });
+        (res) => {
+          const chunks = [];
+          res.on("data", (c) => chunks.push(c));
+          res.on("end", () => {
+            try {
+              resolve(JSON.parse(Buffer.concat(chunks).toString()));
+            } catch {
+              resolve(null);
+            }
+          });
+        },
+      );
       req.on("error", () => resolve(null));
-      req.on("timeout", () => { req.destroy(); resolve(null); });
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(null);
+      });
       req.write(data);
       req.end();
     });
@@ -301,8 +341,10 @@ export function createHttpsPost(https, timeoutMs) {
 // sv 퍼센트 포맷 (1000+ → k 표기, 5자 고정폭)
 export function formatSvPct(value) {
   if (value == null) return "--%".padStart(SV_CELL_WIDTH);
-  if (value >= 10000) return `${Math.round(value / 1000)}k%`.padStart(SV_CELL_WIDTH);
-  if (value >= 1000) return `${(value / 1000).toFixed(1)}k%`.padStart(SV_CELL_WIDTH);
+  if (value >= 10000)
+    return `${Math.round(value / 1000)}k%`.padStart(SV_CELL_WIDTH);
+  if (value >= 1000)
+    return `${(value / 1000).toFixed(1)}k%`.padStart(SV_CELL_WIDTH);
   return `${value}%`.padStart(SV_CELL_WIDTH);
 }
 

package/mesh/index.mjs

@@ -0,0 +1,69 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+
+export { createMeshBudget } from "./mesh-budget.mjs";
+export { createHeartbeatMonitor } from "./mesh-heartbeat.mjs";
+export {
+  createMessage,
+  deserialize,
+  MSG_TYPES,
+  serialize,
+  validate,
+} from "./mesh-protocol.mjs";
+export { createMessageQueue } from "./mesh-queue.mjs";
+export { createRegistry } from "./mesh-registry.mjs";
+export { routeMessage, routeOrDeadLetter } from "./mesh-router.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?.includes(agentId)) {
+      skills.push(skillName);
+    }
+  }
+
+  return skills;
+}

package/mesh/mesh-budget.mjs

@@ -0,0 +1,137 @@
+/**
+ * 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 };
+}