@triflux/core 10.50.1 → 10.51.0

package/hub/token-mode.mjs

@@ -1,228 +0,0 @@
-// hub/token-mode.mjs — Token Efficiency Mode
-// GAP 분석 P2 #7: 심볼 통신 + 약어로 30-50% 토큰 절감
-
-/**
- * @experimental 런타임 미연결 — 향후 통합 예정
- * @experimental
- * @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>}
- */
-export const COMPACT_RULES = [
-  // ── 심볼 치환 (긴 매칭 우선 정렬) ──
-  { from: ["greater than or equal"], to: "≥", type: "symbol" },
-  { from: ["less than or equal"], to: "≤", type: "symbol" },
-  { from: ["results in", "결과적으로"], to: "→", type: "symbol" },
-  { from: ["therefore", "따라서"], to: "∴", type: "symbol" },
-  { from: ["because", "왜냐하면"], to: "∵", type: "symbol" },
-  { from: ["approximately", "대략"], to: "≈", type: "symbol" },
-  { from: ["not equal", "같지 않"], to: "≠", type: "symbol" },
-  { from: ["in progress", "진행 중"], to: "⏳", type: "symbol" },
-  { from: ["completed", "완료"], to: "✓", type: "symbol" },
-  { from: ["success", "성공"], to: "✓", type: "symbol" },
-  { from: ["failure", "실패"], to: "✗", type: "symbol" },
-  { from: ["warning", "경고"], to: "⚠", type: "symbol" },
-  { from: ["error", "에러"], to: "✗", type: "symbol" },
-  { from: ["pending", "대기"], to: "⏸", type: "symbol" },
-
-  // ── 약어 (긴 매칭 우선 정렬) ──
-  { from: ["configuration", "설정"], to: "cfg", type: "abbrev" },
-  { from: ["implementation", "구현"], to: "impl", type: "abbrev" },
-  { from: ["architecture", "아키텍처"], to: "arch", type: "abbrev" },
-  { from: ["dependency", "의존성"], to: "dep", type: "abbrev" },
-  { from: ["function", "함수"], to: "fn", type: "abbrev" },
-  { from: ["parameter", "파라미터"], to: "param", type: "abbrev" },
-  { from: ["repository", "저장소"], to: "repo", type: "abbrev" },
-  { from: ["environment", "환경"], to: "env", type: "abbrev" },
-  { from: ["variable", "변수"], to: "var", type: "abbrev" },
-  { from: ["directory", "디렉토리"], to: "dir", type: "abbrev" },
-
-  // ── 한국어 동사/명령형 약어 ──
-  { from: ["구현해"], to: "impl", type: "abbrev" },
-  { from: ["확인해"], to: "check", type: "abbrev" },
-  { from: ["수정해"], to: "fix", type: "abbrev" },
-  { from: ["테스트"], to: "test", type: "abbrev" },
-  { from: ["리뷰"], to: "review", type: "abbrev" },
-  { from: ["분석"], to: "analyze", type: "abbrev" },
-  { from: ["설계"], to: "design", type: "abbrev" },
-  { from: ["문서화"], to: "docs", type: "abbrev" },
-];
-
-/** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
-export const REVIEW_RULES = [
-  { from: ["looks good to me", "lgtm"], to: "✓lgtm", type: "abbrev" },
-  { from: ["needs changes", "수정 필요"], to: "✗chg", type: "abbrev" },
-  { from: ["nitpick", "사소한"], to: "nit", type: "abbrev" },
-  { from: ["blocking", "블로킹"], to: "blk", type: "abbrev" },
-  { from: ["suggestion", "제안"], to: "sug", type: "abbrev" },
-  { from: ["question", "질문"], to: "q", type: "abbrev" },
-  { from: ["approved", "승인"], to: "✓apv", type: "abbrev" },
-  { from: ["request changes", "변경 요청"], to: "✗req", type: "abbrev" },
-];
-
-/** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
-export const DESIGN_RULES = [
-  { from: ["component", "컴포넌트"], to: "cmp", type: "abbrev" },
-  { from: ["interface", "인터페이스"], to: "iface", type: "abbrev" },
-  { from: ["abstraction", "추상화"], to: "abs", type: "abbrev" },
-  { from: ["pattern", "패턴"], to: "ptn", type: "abbrev" },
-  { from: ["dependency injection", "의존성 주입"], to: "di", type: "abbrev" },
-  { from: ["single responsibility", "단일 책임"], to: "srp", type: "abbrev" },
-  { from: ["open closed", "개방 폐쇄"], to: "ocp", type: "abbrev" },
-  { from: ["inheritance", "상속"], to: "inh", type: "abbrev" },
-];
-
-/** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
-export const DOCS_RULES = [
-  { from: ["description", "설명"], to: "desc", type: "abbrev" },
-  { from: ["example", "예시"], to: "ex", type: "abbrev" },
-  { from: ["reference", "참조"], to: "ref", type: "abbrev" },
-  { from: ["introduction", "소개"], to: "intro", type: "abbrev" },
-  { from: ["deprecated", "사용 중단"], to: "dep", type: "abbrev" },
-  { from: ["optional", "선택적"], to: "opt", type: "abbrev" },
-  { from: ["required", "필수"], to: "req", type: "abbrev" },
-  { from: ["returns", "반환"], to: "ret", type: "abbrev" },
-];
-
-// ── 프로필 맵 ──
-
-/** @type {Record<string, Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>>} */
-const PROFILE_MAP = {
-  default: COMPACT_RULES,
-  review: [...COMPACT_RULES, ...REVIEW_RULES],
-  design: [...COMPACT_RULES, ...DESIGN_RULES],
-  docs: [...COMPACT_RULES, ...DOCS_RULES],
-};
-
-// ── 내부: 정렬된 치환 쌍 빌드 헬퍼 ──
-
-/**
- * 규칙 배열로부터 패턴 쌍을 빌드하고 긴 패턴 우선 정렬
- * @param {Array<{ from: string[], to: string }>} rules
- * @returns {Array<{ pattern: string, to: string, len: number }>}
- */
-function buildCompactPairs(rules) {
-  const pairs = [];
-  for (const rule of rules) {
-    for (const keyword of rule.from) {
-      pairs.push({ pattern: keyword, to: rule.to, len: keyword.length });
-    }
-  }
-  pairs.sort((a, b) => b.len - a.len);
-  return pairs;
-}
-
-/**
- * 규칙 배열로부터 확장 쌍을 빌드
- * @param {Array<{ from: string[], to: string }>} rules
- * @returns {Array<{ symbol: string, restore: string }>}
- */
-function buildExpandPairs(rules) {
-  return rules.map((rule) => ({ symbol: rule.to, restore: rule.from[0] }));
-}
-
-// 기본 프로필 쌍 (기존 동작 유지)
-const _compactPairs = buildCompactPairs(COMPACT_RULES);
-const _expandPairs = buildExpandPairs(COMPACT_RULES);
-
-// ── 코드 블록 보호 유틸 ──
-
-const CODE_BLOCK_RE = /```[\s\S]*?```/g;
-
-/**
- * 코드 블록을 플레이스홀더로 치환, 변환 후 복원
- * @param {string} text
- * @param {(segment: string) => string} transform
- * @returns {string}
- */
-function withCodeProtection(text, transform) {
-  const blocks = [];
-  const placeholder = "\x00CB";
-  let idx = 0;
-  const masked = text.replace(CODE_BLOCK_RE, (match) => {
-    blocks.push(match);
-    return `${placeholder}${idx++}${placeholder}`;
-  });
-
-  const transformed = transform(masked);
-
-  // 플레이스홀더 복원
-  return transformed.replace(
-    new RegExp(`${placeholder}(\\d+)${placeholder}`, "g"),
-    (_, i) => blocks[Number(i)],
-  );
-}
-
-// ── compact 모드 상태 ──
-
-let _compactMode = false;
-
-/**
- * compact 모드 활성 여부
- * @returns {boolean}
- */
-export function isCompactMode() {
-  return _compactMode;
-}
-
-/**
- * 텍스트를 compact 모드로 변환
- * 심볼 치환 + 약어 적용, 코드 블록 내부는 보호
- * @param {string} text
- * @returns {string}
- */
-export function compactify(text) {
-  if (!text || typeof text !== "string") return text ?? "";
-  _compactMode = true;
-
-  return withCodeProtection(text, (segment) => {
-    let result = segment;
-    for (const { pattern, to } of _compactPairs) {
-      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(escaped, "gi");
-      result = result.replace(re, to);
-    }
-    return result;
-  });
-}
-
-/**
- * 텍스트를 compact 모드로 변환 (도메인 프로필 선택 가능)
- * @param {string} text
- * @param {'default'|'review'|'design'|'docs'} [profile='default'] — 도메인 프로필
- * @returns {string}
- */
-export function applyCompactRules(text, profile = "default") {
-  if (!text || typeof text !== "string") return text ?? "";
-
-  const rules = PROFILE_MAP[profile] ?? COMPACT_RULES;
-  const pairs = buildCompactPairs(rules);
-
-  return withCodeProtection(text, (segment) => {
-    let result = segment;
-    for (const { pattern, to } of pairs) {
-      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(escaped, "gi");
-      result = result.replace(re, to);
-    }
-    return result;
-  });
-}
-
-/**
- * compact 텍스트를 원래 형태로 복원 (best-effort)
- * @param {string} text
- * @returns {string}
- */
-export function expand(text) {
-  if (!text || typeof text !== "string") return text ?? "";
-  _compactMode = false;
-
-  return withCodeProtection(text, (segment) => {
-    let result = segment;
-    for (const { symbol, restore } of _expandPairs) {
-      const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(escaped, "g");
-      result = result.replace(re, restore);
-    }
-    return result;
-  });
-}

package/hud/mission-board.mjs

@@ -1,56 +0,0 @@
-// ============================================================================
-// 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/cto.mjs

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

package/mesh/index.mjs

@@ -1,69 +0,0 @@
-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

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

package/mesh/mesh-heartbeat.mjs

@@ -1,100 +0,0 @@
-const DEFAULT_INTERVAL_MS = 30_000;
-const DEFAULT_THRESHOLD_MS = 60_000;
-
-/**
- * Creates a heartbeat monitor that tracks agent liveness.
- *
- * @param {object} registry - A mesh-registry instance
- * @param {object} [opts]
- * @param {number} [opts.intervalMs=30000]   - Scan interval
- * @param {number} [opts.thresholdMs=60000]  - Stale threshold
- * @param {function} [opts.onStale]          - Called with agentId when stale detected
- * @returns {object} HeartbeatMonitor API
- */
-export function createHeartbeatMonitor(registry, opts = {}) {
-  const {
-    intervalMs = DEFAULT_INTERVAL_MS,
-    thresholdMs = DEFAULT_THRESHOLD_MS,
-    onStale,
-  } = opts;
-
-  /** @type {Map<string, number>} agentId → last heartbeat timestamp */
-  const heartbeats = new Map();
-  let timer = null;
-
-  /**
-   * Records a heartbeat for an agent.
-   * @param {string} agentId
-   */
-  function recordHeartbeat(agentId) {
-    if (!agentId || typeof agentId !== "string") {
-      throw new TypeError("agentId must be a non-empty string");
-    }
-    heartbeats.set(agentId, Date.now());
-  }
-
-  /**
-   * Returns agent IDs whose last heartbeat exceeds the threshold.
-   * Only considers agents currently registered in the registry.
-   *
-   * @param {number} [customThresholdMs] - Override default threshold
-   * @returns {string[]}
-   */
-  function getStaleAgents(customThresholdMs) {
-    const threshold = customThresholdMs ?? thresholdMs;
-    const now = Date.now();
-    const registered = registry.listAll();
-    const stale = [];
-
-    for (const agent of registered) {
-      const lastBeat = heartbeats.get(agent.agentId);
-      if (lastBeat === undefined || now - lastBeat >= threshold) {
-        stale.push(agent.agentId);
-      }
-    }
-    return stale;
-  }
-
-  /**
-   * Runs a single scan: finds stale agents and invokes onStale callback.
-   */
-  function scan() {
-    const stale = getStaleAgents();
-    if (typeof onStale === "function") {
-      for (const agentId of stale) {
-        onStale(agentId);
-      }
-    }
-  }
-
-  /**
-   * Starts periodic heartbeat scanning.
-   * @param {number} [customIntervalMs]
-   */
-  function start(customIntervalMs) {
-    stop();
-    const interval = customIntervalMs ?? intervalMs;
-    timer = setInterval(scan, interval);
-    timer.unref?.();
-  }
-
-  /**
-   * Stops periodic scanning.
-   */
-  function stop() {
-    if (timer !== null) {
-      clearInterval(timer);
-      timer = null;
-    }
-  }
-
-  /**
-   * Removes heartbeat record for an agent.
-   * @param {string} agentId
-   */
-  function remove(agentId) {
-    heartbeats.delete(agentId);
-  }
-
-  return { recordHeartbeat, getStaleAgents, start, stop, scan, remove };
-}