triflux 10.0.0 → 10.0.2

package/hud/utils.mjs

@@ -0,0 +1,313 @@
+// ============================================================================
+// 유틸리티 함수
+// ============================================================================
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  PERCENT_CELL_WIDTH, TIME_CELL_INNER_WIDTH, SV_CELL_WIDTH,
+} from "./constants.mjs";
+
+export async function readStdinJson() {
+  if (process.stdin.isTTY) return {};
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      process.stdin.destroy();
+      resolve({});
+    }, 200);
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      const raw = chunks.join("").trim();
+      if (!raw) { resolve({}); return; }
+      try { resolve(JSON.parse(raw)); } catch { resolve({}); }
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timeout);
+      resolve({});
+    });
+    process.stdin.resume();
+  });
+}
+
+export function readJson(filePath, fallback) {
+  if (!existsSync(filePath)) 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 { /* 쓰기 실패 무시 */ }
+}
+
+// .omc/ → .claude/cache/ 마이그레이션: 새 경로 우선, 없으면 레거시 읽고 복사
+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; }
+  return fallback;
+}
+
+export function stripAnsi(text) {
+  return String(text).replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+function getVisibleLength(text) {
+  return stripAnsi(text).length;
+}
+
+function padAnsi(text, width, align = "right") {
+  const len = getVisibleLength(text);
+  if (len >= width) return text;
+  const padding = " ".repeat(width - len);
+  return align === "left" ? padding + text : text + padding;
+}
+
+export function padAnsiRight(text, width) {
+  return padAnsi(text, width, "right");
+}
+
+export function padAnsiLeft(text, width) {
+  return padAnsi(text, width, "left");
+}
+
+export function fitText(text, width) {
+  const t = String(text || "");
+  if (t.length <= width) return t;
+  if (width <= 1) return "…";
+  return `${t.slice(0, width - 1)}…`;
+}
+
+/**
+ * ANSI 이스케이프 시퀀스를 보존하면서 visible width 기준으로 truncate.
+ * maxWidth 초과 시 잘라내고 RESET(\x1b[0m)을 추가한다.
+ */
+export function truncateAnsi(text, maxWidth) {
+  if (maxWidth <= 0) return "";
+  const str = String(text);
+  let visible = 0;
+  let i = 0;
+  while (i < str.length) {
+    if (str.charCodeAt(i) === 0x1b && str[i + 1] === "[") {
+      const mIdx = str.indexOf("m", i + 2);
+      if (mIdx !== -1) {
+        i = mIdx + 1;
+        continue;
+      }
+    }
+    visible++;
+    if (visible > maxWidth) {
+      return str.slice(0, i) + "\x1b[0m";
+    }
+    i++;
+  }
+  return str;
+}
+
+export function makeHash(text) {
+  return createHash("sha256").update(String(text || ""), "utf8").digest("hex").slice(0, 16);
+}
+
+export function clampPercent(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return 0;
+  return Math.max(0, Math.min(100, Math.round(numeric)));
+}
+
+export function formatPercentCell(value) {
+  return `${clampPercent(value)}%`.padStart(PERCENT_CELL_WIDTH, " ");
+}
+
+export function formatPlaceholderPercentCell() {
+  return "--%".padStart(PERCENT_CELL_WIDTH, " ");
+}
+
+export function normalizeTimeToken(value) {
+  const text = String(value || "n/a");
+  const hourMinute = text.match(/^(\d+)h(\d+)m$/);
+  if (hourMinute) {
+    return `${Number(hourMinute[1])}h${String(Number(hourMinute[2])).padStart(2, "0")}m`;
+  }
+  const dayHour = text.match(/^(\d+)d(\d+)h$/);
+  if (dayHour) {
+    return `${String(Number(dayHour[1])).padStart(2, "0")}d${String(Number(dayHour[2])).padStart(2, "0")}h`;
+  }
+  return text;
+}
+
+export function formatTimeCell(value) {
+  const text = normalizeTimeToken(value);
+  // 시간값(숫자 포함)은 0패딩, 비시간값(n/a 등)은 공백패딩
+  const padChar = /\d/.test(text) ? "0" : " ";
+  return `(${text.padStart(TIME_CELL_INNER_WIDTH, padChar)})`;
+}
+
+// 주간(d/h) 전용 — 최대 7d00h(5자)이므로 공백 불필요
+export function formatTimeCellDH(value) {
+  const text = normalizeTimeToken(value);
+  return `(${text})`;
+}
+
+export function getCliArgValue(flag) {
+  const idx = process.argv.indexOf(flag);
+  if (idx < 0) return null;
+  return process.argv[idx + 1] || null;
+}
+
+export function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "n/a";
+  const totalMinutes = Math.floor(ms / 60000);
+  const days = Math.floor(totalMinutes / (60 * 24));
+  const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
+  const minutes = totalMinutes % 60;
+  if (days > 0) return hours > 0 ? `${days}d${hours}h` : `${days}d`;
+  if (hours > 0) return minutes > 0 ? `${hours}h${minutes}m` : `${hours}h`;
+  return `${minutes}m`;
+}
+
+export function formatTokenCount(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${Math.round(n / 1_000)}K`;
+  return String(n);
+}
+
+export function getContextPercent(stdin) {
+  const nativePercent = stdin?.context_window?.used_percentage;
+  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 capacity = Number(stdin?.context_window?.context_window_size || 0);
+  if (!capacity || capacity <= 0) return 0;
+  return clampPercent((totalTokens / capacity) * 100);
+}
+
+// 과거 리셋 시간 → 다음 주기로 순환하여 미래 시점 반환
+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;
+}
+
+function parseResetDate(isoOrUnix) {
+  if (!isoOrUnix) return null;
+  const date = typeof isoOrUnix === "string"
+    ? new Date(isoOrUnix)
+    : new Date(isoOrUnix * 1000);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function getResetTargetMs(isoOrUnix, cycleMs = 0) {
+  const date = parseResetDate(isoOrUnix);
+  if (!date) return null;
+  return advanceToNextCycle(date.getTime(), cycleMs);
+}
+
+function getRemainingResetMs(isoOrUnix, cycleMs = 0) {
+  const targetMs = getResetTargetMs(isoOrUnix, cycleMs);
+  if (targetMs == null) return null;
+  return targetMs - Date.now();
+}
+
+export function formatResetRemaining(isoOrUnix, cycleMs = 0) {
+  const diffMs = getRemainingResetMs(isoOrUnix, cycleMs);
+  if (diffMs == null || diffMs <= 0) return "";
+  const totalMinutes = Math.floor(diffMs / 60000);
+  const totalHours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${totalHours}h${String(minutes).padStart(2, "0")}m`;
+}
+
+export function isResetPast(isoOrUnix) {
+  const date = parseResetDate(isoOrUnix);
+  return date != null && date.getTime() <= Date.now();
+}
+
+export function formatResetRemainingDayHour(isoOrUnix, cycleMs = 0) {
+  const diffMs = getRemainingResetMs(isoOrUnix, cycleMs);
+  if (diffMs == null || diffMs <= 0) return "";
+  const totalMinutes = Math.floor(diffMs / 60000);
+  const days = Math.floor(totalMinutes / (60 * 24));
+  const hours = Math.floor((totalMinutes % (60 * 24)) / 60);
+  return `${String(days).padStart(2, "0")}d${String(hours).padStart(2, "0")}h`;
+}
+
+export function calcCooldownLeftSeconds(isoDatetime) {
+  if (!isoDatetime) return 0;
+  const cooldownMs = new Date(isoDatetime).getTime() - Date.now();
+  if (!Number.isFinite(cooldownMs) || cooldownMs <= 0) return 0;
+  return Math.ceil(cooldownMs / 1000);
+}
+
+export function getProviderAccountId(provider, accountsConfig, accountsState) {
+  const providerState = accountsState?.providers?.[provider] || {};
+  const selectedId = providerState.last_selected_id;
+  if (selectedId) return selectedId;
+  const providerConfig = accountsConfig?.providers?.[provider] || [];
+  return providerConfig[0]?.id || `${provider}-main`;
+}
+
+// JWT base64 디코딩 공통 헬퍼
+export function decodeJwtEmail(idToken) {
+  if (!idToken) return null;
+  const parts = idToken.split(".");
+  if (parts.length < 2) return null;
+  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"));
+    return decoded.email || null;
+  } catch { return null; }
+}
+
+// HTTPS POST (타임아웃 포함) — https 모듈은 호출자가 주입
+export function createHttpsPost(https, timeoutMs) {
+  return function httpsPost(url, body, accessToken) {
+    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),
+        },
+        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); }
+        });
+      });
+      req.on("error", () => resolve(null));
+      req.on("timeout", () => { req.destroy(); resolve(null); });
+      req.write(data);
+      req.end();
+    });
+  };
+}
+
+// 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);
+  return `${value}%`.padStart(SV_CELL_WIDTH);
+}
+
+export function formatSavings(dollars) {
+  if (dollars >= 100) return `$${Math.round(dollars)}`;
+  if (dollars >= 10) return `$${dollars.toFixed(1)}`;
+  return `$${dollars.toFixed(2)}`;
+}

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 };
+}

package/mesh/mesh-heartbeat.mjs

@@ -0,0 +1,100 @@
+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 };
+}

package/mesh/mesh-protocol.mjs

@@ -0,0 +1,96 @@
+import { randomUUID } from "node:crypto";
+
+export const MSG_TYPES = Object.freeze({
+  REQUEST: "request",
+  RESPONSE: "response",
+  EVENT: "event",
+  HEARTBEAT: "heartbeat",
+});
+
+const VALID_TYPES = new Set(Object.values(MSG_TYPES));
+
+/**
+ * Creates an immutable mesh message.
+ * @param {string} type - One of MSG_TYPES values
+ * @param {string} from - Sender agent ID
+ * @param {string} to - Recipient agent ID (or "*" for broadcast)
+ * @param {unknown} payload - Message payload
+ * @returns {Readonly<object>}
+ */
+export function createMessage(type, from, to, payload = null) {
+  if (!VALID_TYPES.has(type)) {
+    throw new TypeError(`Invalid message type: ${type}`);
+  }
+  if (!from || typeof from !== "string") {
+    throw new TypeError("from must be a non-empty string");
+  }
+  if (!to || typeof to !== "string") {
+    throw new TypeError("to must be a non-empty string");
+  }
+  return Object.freeze({
+    type,
+    from,
+    to,
+    payload,
+    timestamp: new Date().toISOString(),
+    correlationId: randomUUID(),
+  });
+}
+
+/**
+ * Serializes a message to a JSON string.
+ * @param {object} message
+ * @returns {string}
+ */
+export function serialize(message) {
+  return JSON.stringify(message);
+}
+
+/**
+ * Deserializes a JSON string to a message object.
+ * @param {string} raw
+ * @returns {object}
+ */
+export function deserialize(raw) {
+  if (typeof raw !== "string") {
+    throw new TypeError("raw must be a string");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new SyntaxError(`Failed to parse message: ${raw}`);
+  }
+  return parsed;
+}
+
+/**
+ * Validates a message object.
+ * @param {unknown} message
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validate(message) {
+  const errors = [];
+
+  if (!message || typeof message !== "object") {
+    return { valid: false, errors: ["message must be an object"] };
+  }
+
+  if (!VALID_TYPES.has(message.type)) {
+    errors.push(`Invalid type: ${message.type}`);
+  }
+  if (!message.from || typeof message.from !== "string") {
+    errors.push("from must be a non-empty string");
+  }
+  if (!message.to || typeof message.to !== "string") {
+    errors.push("to must be a non-empty string");
+  }
+  if (!message.timestamp || typeof message.timestamp !== "string") {
+    errors.push("timestamp must be a non-empty string");
+  }
+  if (!message.correlationId || typeof message.correlationId !== "string") {
+    errors.push("correlationId must be a non-empty string");
+  }
+
+  return { valid: errors.length === 0, errors };
+}