@triflux/core 10.50.2 → 10.52.0

package/hub/state.mjs

@@ -1,300 +0,0 @@
-import { execSync } from "node:child_process";
-import {
-  closeSync,
-  existsSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const PROJECT_ROOT = fileURLToPath(new URL("..", import.meta.url));
-const PID_FILE_NAME = "hub.pid";
-const LEGACY_STATE_FILE_NAME = "hub-state.json";
-const LOCK_FILE_NAME = "hub-start.lock";
-
-let heldLockPath = null;
-let heldLockFd = null;
-let cachedVersionHash = null;
-
-function getStateDir(options = {}) {
-  return (
-    options.stateDir ||
-    process.env.TFX_HUB_STATE_DIR?.trim() ||
-    join(homedir(), ".claude", "cache", "tfx-hub")
-  );
-}
-
-function getStatePath(options = {}) {
-  return options.statePath || join(getStateDir(options), PID_FILE_NAME);
-}
-
-function getLegacyStatePath(options = {}) {
-  return join(getStateDir(options), LEGACY_STATE_FILE_NAME);
-}
-
-function getLockPath(options = {}) {
-  return options.lockPath || join(getStateDir(options), LOCK_FILE_NAME);
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function isPidAlive(pid) {
-  if (!Number.isFinite(Number(pid)) || Number(pid) <= 0) return false;
-  try {
-    process.kill(Number(pid), 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function parseJson(text, fallback = null) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return fallback;
-  }
-}
-
-function safeReplaceFile(tempPath, targetPath) {
-  try {
-    renameSync(tempPath, targetPath);
-  } catch (error) {
-    if (!["EEXIST", "EPERM", "EACCES"].includes(error?.code)) {
-      try {
-        unlinkSync(tempPath);
-      } catch {}
-      throw error;
-    }
-    try {
-      unlinkSync(targetPath);
-    } catch {}
-    renameSync(tempPath, targetPath);
-  }
-}
-
-function writeJsonFile(targetPath, payload) {
-  const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
-  writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, {
-    encoding: "utf8",
-    mode: 0o600,
-  });
-  safeReplaceFile(tempPath, targetPath);
-}
-
-function readJsonFile(filePath) {
-  try {
-    if (!existsSync(filePath)) return null;
-    return parseJson(readFileSync(filePath, "utf8"), null);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 허브의 현재 상태(PID, 포트, 버전 등)를 파일에 기록합니다.
- * 원자적(atomic) 쓰기를 위해 임시 파일을 생성한 후 교체하는 방식을 사용합니다.
- *
- * @param {object} payload - 상태 데이터
- * @param {number} payload.pid - 허브 프로세스 ID
- * @param {number} payload.port - 허브 서버 포트
- * @param {string} payload.version - 허브 버전
- * @param {string} payload.sessionId - 현재 세션 ID
- * @param {string} payload.startedAt - 시작 시각 (ISO 8601)
- * @param {object} [options] - 옵션
- * @param {string} [options.stateDir] - 상태 파일이 저장될 디렉토리
- * @returns {object} 기록된 상태 데이터
- */
-export function writeState(
-  { pid, port, version, sessionId, startedAt, ...rest },
-  options = {},
-) {
-  const stateDir = getStateDir(options);
-  const statePath = getStatePath(options);
-  const payload = { pid, port, version, sessionId, startedAt, ...rest };
-
-  mkdirSync(stateDir, { recursive: true });
-  writeJsonFile(statePath, payload);
-  try {
-    unlinkSync(getLegacyStatePath(options));
-  } catch {}
-  return payload;
-}
-
-/**
- * 파일로부터 허브의 현재 상태를 읽어옵니다.
- *
- * @param {object} [options] - 옵션
- * @param {string} [options.stateDir] - 상태 파일이 저장된 디렉토리
- * @returns {object|null} 읽어온 상태 데이터 또는 실패 시 null
- */
-export function readState(options = {}) {
-  return (
-    readJsonFile(getStatePath(options)) ??
-    readJsonFile(getLegacyStatePath(options))
-  );
-}
-
-/**
- * 지정된 포트에서 실행 중인 허브 서버의 헬스 체크를 수행합니다.
- *
- * @param {number|string} port - 서버 포트
- * @param {object} [options] - 옵션
- * @param {number} [options.timeoutMs=1000] - 요청 타임아웃
- * @param {string} [options.baseUrl] - 서버 베이스 URL
- * @returns {Promise<boolean>} 서버 정상 작동 여부
- */
-export async function isServerHealthy(port, options = {}) {
-  const resolvedPort = Number(port);
-  if (!Number.isFinite(resolvedPort) || resolvedPort <= 0) return false;
-
-  const timeoutMs = Math.max(100, Number(options.timeoutMs) || 1000);
-  const baseUrl = options.baseUrl || `http://127.0.0.1:${resolvedPort}`;
-
-  try {
-    const response = await fetch(`${baseUrl}/health`, {
-      method: "GET",
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (!response.ok) return false;
-    const body = await response.json().catch(() => null);
-    return body?.ok === true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * 현재 프로젝트의 버전 해시를 생성합니다.
- * package.json의 버전과 Git commit SHA를 조합합니다.
- *
- * @param {object} [options] - 옵션
- * @param {boolean} [options.force=false] - 캐시를 무시하고 새로 생성할지 여부
- * @returns {string} 버전 해시 문자열
- */
-export function getVersionHash(options = {}) {
-  if (cachedVersionHash && !options.force) return cachedVersionHash;
-
-  const packageJsonPath = join(PROJECT_ROOT, "package.json");
-  const pkg = parseJson(readFileSync(packageJsonPath, "utf8"), {});
-  const version = String(pkg?.version || "0.0.0").trim();
-
-  let sha = String(process.env.TFX_HUB_GIT_SHA || "").trim();
-  if (!sha) {
-    try {
-      sha = execSync("git rev-parse --short HEAD", {
-        cwd: PROJECT_ROOT,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true,
-      }).trim();
-    } catch {
-      sha = "";
-    }
-  }
-
-  cachedVersionHash = sha ? `${version}-${sha}` : version;
-  return cachedVersionHash;
-}
-
-/**
- * 허브 시작 시 중복 실행을 방지하기 위한 잠금(lock)을 획득합니다.
- * 이미 실행 중인 다른 프로세스가 있는지 확인하고 유효한 잠금을 획득할 때까지 재시도합니다.
- *
- * @param {object} [options] - 옵션
- * @param {number} [options.timeoutMs=3000] - 최대 대기 시간
- * @param {number} [options.pollMs=50] - 재시도 간격
- * @param {string} [options.lockPath] - 잠금 파일 경로
- * @returns {Promise<{path: string}>} 잠금 파일 경로
- * @throws {Error} 타임아웃 내에 잠금을 획득하지 못한 경우
- */
-export async function acquireLock(options = {}) {
-  if (heldLockFd !== null && heldLockPath) {
-    return { path: heldLockPath };
-  }
-
-  const lockPath = getLockPath(options);
-  const timeoutMs = Math.max(100, Number(options.timeoutMs) || 3000);
-  const pollMs = Math.max(10, Number(options.pollMs) || 50);
-  const deadline = Date.now() + timeoutMs;
-
-  mkdirSync(dirname(lockPath), { recursive: true });
-
-  while (Date.now() <= deadline) {
-    try {
-      const fd = openSync(lockPath, "wx", 0o600);
-      writeFileSync(
-        fd,
-        `${JSON.stringify(
-          {
-            pid: process.pid,
-            createdAt: new Date().toISOString(),
-          },
-          null,
-          2,
-        )}\n`,
-        "utf8",
-      );
-      heldLockFd = fd;
-      heldLockPath = lockPath;
-      return { path: lockPath };
-    } catch (error) {
-      if (error?.code !== "EEXIST") {
-        throw error;
-      }
-
-      try {
-        const raw = readFileSync(lockPath, "utf8");
-        const data = parseJson(raw, {});
-        const stats = statSync(lockPath);
-        const STALE_LOCK_AGE_MS = 60_000;
-        const staleByPid = !isPidAlive(data?.pid);
-        const staleByAge = Date.now() - stats.mtimeMs > STALE_LOCK_AGE_MS;
-        if (staleByPid || staleByAge) {
-          try {
-            unlinkSync(lockPath);
-          } catch {}
-          continue;
-        }
-      } catch {}
-
-      await sleep(pollMs);
-    }
-  }
-
-  throw new Error(`hub start lock busy: ${lockPath}`);
-}
-
-/**
- * 획득했던 잠금을 해제합니다. 잠금 파일을 삭제하고 관련 리소스를 정리합니다.
- *
- * @param {object} [options] - 옵션
- * @param {string} [options.lockPath] - 명시적인 잠금 파일 경로
- */
-export function releaseLock(options = {}) {
-  const lockPath = options.lockPath || heldLockPath || getLockPath(options);
-
-  if (heldLockFd !== null) {
-    try {
-      closeSync(heldLockFd);
-    } catch {}
-    heldLockFd = null;
-  }
-
-  try {
-    if (existsSync(lockPath)) unlinkSync(lockPath);
-  } catch {}
-
-  if (!options.lockPath || options.lockPath === heldLockPath) {
-    heldLockPath = null;
-  }
-}

package/hub/team/synapse-http.mjs

@@ -1,311 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir, hostname } from "node:os";
-import { dirname, join } from "node:path";
-import { normalizeRoleKey } from "../role-contract.mjs";
-
-const HUB_DEFAULT_PORT = 27888;
-// Same token file as hub/bridge.mjs (HUB_TOKEN_FILE). Kept inline rather than
-// imported so this helper stays dependency-free and byte-identical across the
-// packages/core mirror (which cannot carry relative cross-package imports).
-const HUB_TOKEN_FILE = join(homedir(), ".claude", ".tfx-hub-token");
-
-// In-flight fire-and-forget POSTs. A short-lived caller (the SessionStart hook,
-// which process.exit(0)s immediately after firing register) must be able to
-// flush these before the process dies: Node's process.exit() abandons pending
-// socket I/O, so an un-awaited loopback POST is created but never written.
-// Callers on an exit budget drain this set via drainPendingSynapse() first.
-const inFlightSynapse = new Set();
-
-function normalizeToken(raw) {
-  if (raw == null) return null;
-  const token = String(raw).trim();
-  return token || null;
-}
-
-function opaqueId(prefix, value) {
-  return `${prefix}_${createHash("sha256")
-    .update(String(value || ""))
-    .digest("base64url")
-    .slice(0, 22)}`;
-}
-
-function normalizedProjectId(value) {
-  try {
-    return normalizeRoleKey({ project_id: value, role_kind: "cto" }).project_id;
-  } catch {
-    return "";
-  }
-}
-
-function resolveProjectId(cwd, meta, opts = {}) {
-  const explicit = meta?.project_id || process.env.TFX_PROJECT_ID;
-  if (explicit) return normalizedProjectId(explicit);
-  if (typeof opts.resolveProjectId === "function") {
-    return normalizedProjectId(opts.resolveProjectId(cwd));
-  }
-  let current = cwd;
-  while (current) {
-    const manifest = join(current, ".triflux", "project.json");
-    if (existsSync(manifest)) {
-      try {
-        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
-        if (parsed?.schema_version !== "tfx.project.v1") return "";
-        return normalizedProjectId(parsed.project_id);
-      } catch {
-        return "";
-      }
-    }
-    const parent = dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return "";
-}
-
-function inferSessionCli(meta, opts = {}) {
-  const explicit = String(meta?.cli || meta?.actor_cli || "")
-    .trim()
-    .toLowerCase();
-  if (explicit === "codex" || explicit === "claude") return explicit;
-  const entrypoint = String(opts.entrypoint ?? process.argv[1] ?? "");
-  if (entrypoint.includes("codex-session-hook")) return "codex";
-  if (entrypoint.includes("agy-session-hook")) return "other";
-  return "claude";
-}
-
-function resolveTmuxSession(meta, opts = {}) {
-  const explicit =
-    meta?.tmux_session || meta?.session_name || process.env.TFX_TMUX_SESSION;
-  if (explicit) return String(explicit).trim();
-  if (!process.env.TMUX) return "";
-  try {
-    const run =
-      opts.tmuxSessionName ||
-      (() =>
-        execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
-          encoding: "utf8",
-          timeout: 200,
-          windowsHide: true,
-        }));
-    return String(run() || "").trim();
-  } catch {
-    return "";
-  }
-}
-
-export function buildSynapseRegistrationMeta(meta, opts = {}) {
-  if (!meta || meta.sessionKind !== "interactive") return meta;
-  const sessionId = String(meta.sessionId || "").trim();
-  if (!sessionId) return meta;
-  const cwd = typeof meta.cwd === "string" ? meta.cwd : process.cwd();
-  const cli = inferSessionCli(meta, opts);
-  const hostId = String(
-    meta.host_id ||
-      process.env.TFX_HOST_ID ||
-      opaqueId("hst", opts.hostname?.() || hostname()),
-  ).trim();
-  const expiresAtMs = Number(opts.nowMs?.() ?? Date.now()) + 299000;
-  const transportLocators = [];
-  if (cli === "claude") {
-    transportLocators.push({
-      schema_version: "tfx.transport-locator.v1",
-      transport_id: opaqueId("trn", `claude-uds:${hostId}:${sessionId}`),
-      kind: "claude-uds",
-      host_id: hostId,
-      capabilities: ["probe", "wake", "activate", "interrupt"],
-      priority: 100,
-      expires_at_ms: expiresAtMs,
-      locator: {
-        session_id: sessionId,
-        bridge_id: String(
-          meta.bridge_id || process.env.TFX_BRIDGE_ID || "local-hub",
-        ),
-      },
-    });
-  }
-  const tmuxSession = resolveTmuxSession(meta, opts);
-  if (tmuxSession) {
-    const muxServerSource =
-      meta.mux_server_id ||
-      process.env.TFX_MUX_SERVER_ID ||
-      String(process.env.TMUX || "default").split(",", 1)[0];
-    transportLocators.push({
-      schema_version: "tfx.transport-locator.v1",
-      transport_id: opaqueId("trn", `tmux:${hostId}:${tmuxSession}`),
-      kind: "tmux",
-      host_id: hostId,
-      capabilities: ["probe", "wake", "activate", "interrupt"],
-      priority: cli === "codex" ? 100 : 50,
-      expires_at_ms: expiresAtMs,
-      locator: {
-        session_name: tmuxSession,
-        mux_server_id: opaqueId("mux", muxServerSource),
-      },
-    });
-  }
-  const directAgentId = `session:${sessionId}`;
-  return {
-    ...meta,
-    agent_id:
-      meta.agent_id ||
-      (directAgentId.length <= 64 && /^[a-zA-Z0-9._:-]+$/u.test(directAgentId)
-        ? directAgentId
-        : opaqueId("session", sessionId)),
-    cli,
-    project_id: resolveProjectId(cwd, meta, opts) || undefined,
-    session_id: meta.session_id || sessionId,
-    host_id: hostId,
-    transport_locators_json:
-      meta.transport_locators_json ?? JSON.stringify(transportLocators),
-  };
-}
-
-// Mirrors hub/bridge.mjs:readHubToken — env override first, then the token file.
-// Missing token → null (backward-compatible with token-less hubs).
-function readHubToken() {
-  const envToken = normalizeToken(process.env.TFX_HUB_TOKEN);
-  if (envToken) return envToken;
-  try {
-    return normalizeToken(readFileSync(HUB_TOKEN_FILE, "utf8"));
-  } catch {
-    return null;
-  }
-}
-
-// Wrap IPv6 hosts in [...] so they form a valid URL authority (cf. bridge.mjs).
-function formatHostForUrl(host) {
-  return String(host).includes(":") ? `[${host}]` : host;
-}
-
-// Resolve the hub base URL from env (TFX_HUB_URL / TFX_HUB_PORT) before falling
-// back to the loopback default, so a cascaded / non-default hub port is hit
-// instead of silently posting to 127.0.0.1:27888 and missing the live hub.
-function resolveSynapseBaseUrl() {
-  const envUrl = normalizeToken(process.env.TFX_HUB_URL);
-  if (envUrl) return envUrl.replace(/\/mcp$/, "");
-
-  const envPort = Number.parseInt(String(process.env.TFX_HUB_PORT ?? ""), 10);
-  if (Number.isFinite(envPort) && envPort > 0) {
-    return `http://${formatHostForUrl("127.0.0.1")}:${envPort}`;
-  }
-  return `http://${formatHostForUrl("127.0.0.1")}:${HUB_DEFAULT_PORT}`;
-}
-
-function resolveSynapseFetch(fetchImpl) {
-  if (fetchImpl === null) return null;
-  if (typeof fetchImpl === "function") return fetchImpl;
-  if (typeof globalThis.fetch === "function") {
-    return globalThis.fetch.bind(globalThis);
-  }
-  return null;
-}
-
-export function buildSynapseTaskSummary(prompt, maxLength = 100) {
-  if (maxLength <= 0) return "";
-  return String(prompt ?? "").slice(0, maxLength);
-}
-
-export function fireAndForgetSynapse(path, payload, opts = {}) {
-  const fetchImpl = resolveSynapseFetch(opts.fetchImpl);
-  if (!fetchImpl) return false;
-
-  try {
-    const baseUrl = opts.baseUrl || resolveSynapseBaseUrl();
-    const url = new URL(path, baseUrl).toString();
-    const headers = { "content-type": "application/json" };
-    // token: false explicitly skips auth; otherwise reuse the hub token so a
-    // token-required hub does not 401 (the failure would be swallowed silently).
-    if (opts.token !== false) {
-      const token =
-        typeof opts.token === "string" && opts.token.trim()
-          ? opts.token.trim()
-          : readHubToken();
-      if (token) headers.Authorization = `Bearer ${token}`;
-    }
-    const init = {
-      method: "POST",
-      headers,
-      body: JSON.stringify(payload),
-    };
-    // Optional bounded timeout so callers on a teardown budget (e.g. SessionEnd)
-    // cannot hang the host process if the hub stalls. The timer is unref'd so it
-    // never keeps the event loop (and thus the hook process) alive on its own.
-    let timer = null;
-    const timeoutMs = Number(opts.timeoutMs);
-    if (
-      Number.isFinite(timeoutMs) &&
-      timeoutMs > 0 &&
-      typeof AbortController === "function"
-    ) {
-      const controller = new AbortController();
-      init.signal = controller.signal;
-      timer = setTimeout(() => controller.abort(), timeoutMs);
-      if (typeof timer.unref === "function") timer.unref();
-    }
-    const tracked = Promise.resolve(fetchImpl(url, init))
-      .catch(() => {})
-      .finally(() => {
-        if (timer) clearTimeout(timer);
-        inFlightSynapse.delete(tracked);
-      });
-    inFlightSynapse.add(tracked);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Await any in-flight fire-and-forget Synapse POSTs, bounded by timeoutMs so a
-// stalled hub can never hang the caller. The SessionStart hook calls this right
-// before process.exit(0) so the register POST actually flushes to the socket.
-export function drainPendingSynapse(timeoutMs = 1000) {
-  if (inFlightSynapse.size === 0) return Promise.resolve();
-  const settled = Promise.allSettled([...inFlightSynapse]);
-  const ms = Number(timeoutMs);
-  if (!Number.isFinite(ms) || ms <= 0) return settled;
-  let timeout = null;
-  const timeoutPromise = new Promise((resolve) => {
-    // Keep this timer ref'ed: drainPendingSynapse() is awaited specifically
-    // to hold the process open until either in-flight POSTs settle or the
-    // bounded drain budget expires. An unref'ed timer can let Node's test
-    // runner/process exit before the Promise resolves when no other handles
-    // remain.
-    timeout = setTimeout(resolve, ms);
-  });
-  return Promise.race([settled, timeoutPromise]).finally(() => {
-    if (timeout) clearTimeout(timeout);
-  });
-}
-
-export function registerSynapseSession(meta, opts = {}) {
-  return fireAndForgetSynapse(
-    "/synapse/register",
-    buildSynapseRegistrationMeta(meta, opts),
-    opts,
-  );
-}
-
-export function heartbeatSynapseSession(
-  sessionId,
-  partialMeta = {},
-  opts = {},
-) {
-  // The live route reads `{ sessionId, partial }` (hub/server.mjs
-  // /synapse/heartbeat → synapseRegistry.heartbeat(sessionId, partial)), so the
-  // helper must nest the meta under `partial` rather than spreading it top-level.
-  return fireAndForgetSynapse(
-    "/synapse/heartbeat",
-    {
-      sessionId,
-      partial:
-        partialMeta && typeof partialMeta === "object" ? partialMeta : {},
-    },
-    opts,
-  );
-}
-
-export function unregisterSynapseSession(sessionId, opts = {}) {
-  return fireAndForgetSynapse("/synapse/unregister", { sessionId }, opts);
-}

package/hub/team-bridge.mjs

@@ -1,27 +0,0 @@
-// @triflux/core — team-bridge 인터페이스
-// remote 패키지가 런타임에 구현을 주입한다.
-
-/**
- * @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
- */
-
-/** @type {TeamBridge | null} */
-let _bridge = null;
-
-/**
- * @param {TeamBridge | null} impl
- */
-export function registerTeamBridge(impl) {
-  _bridge = impl;
-}
-
-/**
- * @returns {TeamBridge | null}
- */
-export function getTeamBridge() {
-  return _bridge;
-}

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