@triflux/core 10.0.0 → 10.0.2

package/hooks/hook-orchestrator.mjs

@@ -19,7 +19,7 @@
 //   CLAUDE_PLUGIN_ROOT    — ${PLUGIN_ROOT} 치환용
 //   HOME / USERPROFILE    — ${HOME} 치환용
 
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFileSync, execFile } from "node:child_process";
@@ -210,8 +210,55 @@ function mergeOutputs(accumulated, newOutput) {
   }
 }
 
+// ── 라우팅 가중치 기록 ────────────────────────────────────────
+function recordRouteOutcome(slug, mode, outcome) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const projDir = join(home, ".gstack", "projects", slug);
+  const weightsPath = join(projDir, "routing-weights.json");
+
+  mkdirSync(projDir, { recursive: true });
+
+  const weights = existsSync(weightsPath)
+    ? JSON.parse(readFileSync(weightsPath, "utf8"))
+    : { updated_at: null, total_routes: 0, overrides: 0, weights: { mode_bias: {}, profile_bias: {}, depth_bias: {} } };
+
+  weights.total_routes++;
+  weights.updated_at = new Date().toISOString();
+
+  const bias = weights.weights.mode_bias;
+  const current = bias[mode] || 0;
+
+  if (outcome === "override") {
+    bias[mode] = Math.max(0, current - 0.1);
+    weights.overrides++;
+  } else if (outcome === "completion") {
+    bias[mode] = Math.min(1, current + 0.05);
+  } else if (outcome === "abort") {
+    bias[mode] = Math.max(0, current - 0.1);
+  }
+
+  const total = Object.values(bias).reduce((s, v) => s + v, 0);
+  if (total > 0) {
+    for (const key of Object.keys(bias)) {
+      bias[key] = +(bias[key] / total).toFixed(3);
+    }
+  }
+
+  writeFileSync(weightsPath, JSON.stringify(weights, null, 2), "utf8");
+}
+
 // ── 메인 ────────────────────────────────────────────────────
 async function main() {
+  // CLI: --record-route <slug> <mode> <outcome>
+  const rrIdx = process.argv.indexOf("--record-route");
+  if (rrIdx !== -1) {
+    const slug = process.argv[rrIdx + 1];
+    const mode = process.argv[rrIdx + 2];
+    const outcome = process.argv[rrIdx + 3];
+    if (slug && mode && outcome) recordRouteOutcome(slug, mode, outcome);
+    process.exit(0);
+  }
+
   const stdinRaw = readStdin();
   const registry = loadRegistry();
 

package/hooks/keyword-rules.json

@@ -13,8 +13,7 @@
       "priority": 0,
       "supersedes": [
         "tfx-multi",
-        "tfx-auto",
-        "tfx-auto-codex",
+        "tfx-unified",
         "tfx-codex",
         "tfx-gemini"
       ],
@@ -38,8 +37,12 @@
       "mcp_route": null
     },
     {
-      "id": "tfx-codex-swarm",
+      "id": "tfx-swarm",
       "patterns": [
+        {
+          "source": "\\btfx[\\s-]?swarm\\b",
+          "flags": "i"
+        },
         {
           "source": "\\btfx[\\s-]?codex[\\s-]?swarm\\b",
           "flags": "i"
@@ -47,21 +50,7 @@
         {
           "source": "\\bcodex[\\s-]?swarm\\b",
           "flags": "i"
-        }
-      ],
-      "skill": "tfx-swarm",
-      "deprecated_from": "tfx-codex-swarm",
-      "priority": 1,
-      "supersedes": [
-        "tfx-codex"
-      ],
-      "exclusive": false,
-      "state": null,
-      "mcp_route": null
-    },
-    {
-      "id": "tfx-remote-spawn",
-      "patterns": [
+        },
         {
           "source": "\\btfx[\\s-]?remote[\\s-]?spawn\\b",
           "flags": "i"
@@ -71,25 +60,9 @@
           "flags": "i"
         }
       ],
-      "skill": "tfx-remote-spawn",
-      "priority": 1,
-      "supersedes": [],
-      "exclusive": false,
-      "state": null,
-      "mcp_route": null
-    },
-    {
-      "id": "tfx-auto-codex",
-      "patterns": [
-        {
-          "source": "\\btfx[\\s-]?auto[\\s-]?codex\\b",
-          "flags": "i"
-        }
-      ],
-      "skill": "tfx-auto-codex",
+      "skill": "tfx-swarm",
       "priority": 1,
       "supersedes": [
-        "tfx-auto",
         "tfx-codex"
       ],
       "exclusive": false,
@@ -97,16 +70,21 @@
       "mcp_route": null
     },
     {
-      "id": "tfx-auto",
+      "id": "tfx-unified",
       "patterns": [
-        {
-          "source": "\\btfx[\\s-]?auto\\b",
-          "flags": "i"
-        }
+        { "source": "\\btfx[\\s-]?auto\\b", "flags": "i" },
+        { "source": "\\btfx[\\s-]?auto[\\s-]?codex\\b", "flags": "i" },
+        { "source": "(?:만들어|고쳐|구현해|짜줘|수정해|바꿔)", "flags": "i" },
+        { "source": "(?:리뷰해|검토해|봐줘|괜찮아)", "flags": "i" },
+        { "source": "(?:테스트|검증|돌려봐|QA)", "flags": "i" },
+        { "source": "(?:분석해|계획|설계해)", "flags": "i" },
+        { "source": "(?:찾아봐|조사해|검색해)", "flags": "i" },
+        { "source": "(?:정리해|슬롭|클린업)", "flags": "i" },
+        { "source": "\\b(?:implement|build|fix|review|test|plan|analyze)\\b", "flags": "i" }
       ],
       "skill": "tfx-auto",
       "priority": 2,
-      "supersedes": [],
+      "supersedes": ["tfx-auto-codex"],
       "exclusive": false,
       "state": null,
       "mcp_route": null

package/hooks/safety-guard.mjs

@@ -26,6 +26,18 @@ const BLOCK_RULES = [
   { pattern: /\bpsmux\s+kill-server\b/i, reason: "psmux kill-server 차단 — 모든 세션이 즉시 종료됩니다. node hub/team/psmux.mjs kill-swarm 사용", skipIfGit: true },
 ];
 
+const WT_DIRECT_PATTERNS = [
+  /\bwt\.exe\b/i,
+  /\bwt\s+new-tab\b/i,
+  /\bwt\s+split-pane\b/i,
+  /\bwt\s+-w\b/i,
+  /\bStart-Process\s+wt/i,
+  /\bStart-Process\s+['"]?wt\.exe/i,
+];
+
+const WT_DIRECT_BLOCK_MESSAGE =
+  "[safety-guard] wt.exe 직접 호출 차단됨. → hub/team/wt-manager.mjs의 createTab() / splitPane() / applySplitLayout()을 사용하세요.";
+
 // ── 경고 규칙 ──────────────────────────────────────────────
 const WARN_RULES = [
   { pattern: /\bgit\s+push\b(?!.*--force)/i, warn: "git push 감지. 원격 저장소에 반영됩니다." },
@@ -46,6 +58,45 @@ function readStdin() {
   }
 }
 
+function shouldSkipSegment(segment) {
+  return !segment || segment.startsWith("#") || /^\s*(echo|printf|grep|git\s+commit)\b/i.test(segment);
+}
+
+function hasSegmentInvocation(cmd, patterns) {
+  if (!patterns.some((pattern) => pattern.test(cmd))) return false;
+
+  const lines = cmd.split(/\n/);
+  let heredocDelimiter = null;
+  return lines.some((line) => {
+    if (heredocDelimiter !== null) {
+      if (line.trim() === heredocDelimiter) heredocDelimiter = null;
+      return false;
+    }
+
+    const heredocMatch = line.match(/<<['"]?(\w+)['"]?/);
+    if (heredocMatch) {
+      heredocDelimiter = heredocMatch[1];
+      return false;
+    }
+
+    const segments = line.split(/\s*(?:&&|;|\|\|)\s*/);
+    return segments.some((seg) => {
+      const trimmed = seg.trim();
+      if (shouldSkipSegment(trimmed)) return false;
+      return patterns.some((pattern) => pattern.test(trimmed));
+    });
+  });
+}
+
+function blockCommand(message, command) {
+  process.stderr.write(
+    `${message}\n` +
+      `명령어: ${command.slice(0, 120)}${command.length > 120 ? "..." : ""}\n` +
+      "이 명령은 실행할 수 없습니다. 안전한 대안을 사용하세요."
+  );
+  process.exit(2);
+}
+
 function main() {
   const raw = readStdin();
   if (!raw.trim()) process.exit(0);
@@ -65,47 +116,22 @@ function main() {
   // psmux 명령이 실제 CLI 호출인지 판별 (오탐 방지)
   // git commit 메시지, echo, grep, cat, heredoc 안의 텍스트는 무시
   function isPsmuxInvocation(cmd) {
-    // psmux kill-session/server가 명령에 없으면 즉시 false
-    if (!/\bpsmux\s+kill-(session|server)\b/i.test(cmd)) return false;
-
-    // 줄 분할 → heredoc 경계 추적 → 세그먼트 분할(&&, ;, ||)로 각 명령 단위 검사
-    // 세그먼트가 echo/grep/git-commit으로 시작하면 인자 텍스트이므로 무시
-    const lines = cmd.split(/\n/);
-    let heredocDelimiter = null;
-    return lines.some((line) => {
-      // heredoc 내부이면 닫는 구분자인지만 확인하고 건너뜀
-      if (heredocDelimiter !== null) {
-        if (line.trim() === heredocDelimiter) heredocDelimiter = null;
-        return false;
-      }
-      // heredoc 시작 감지: <<'WORD', <<"WORD", <<WORD
-      const heredocMatch = line.match(/<<['"]?(\w+)['"]?/);
-      if (heredocMatch) {
-        heredocDelimiter = heredocMatch[1];
-        // heredoc 시작 줄 자체는 실제 명령이므로 계속 검사하되
-        // 시작 줄에 psmux kill이 포함될 리 없으므로 여기서 false 반환
-        return false;
-      }
-      const segments = line.split(/\s*(?:&&|;|\|\|)\s*/);
-      return segments.some((seg) => {
-        const t = seg.trim();
-        if (!t || t.startsWith("#")) return false;
-        if (/^\s*(echo|printf|grep|git\s+commit)\b/i.test(t)) return false;
-        return /\bpsmux\s+kill-(session|server)\b/i.test(t);
-      });
-    });
+    return hasSegmentInvocation(cmd, [/\bpsmux\s+kill-(session|server)\b/i]);
+  }
+
+  function isWtDirectInvocation(cmd) {
+    return hasSegmentInvocation(cmd, WT_DIRECT_PATTERNS);
+  }
+
+  if (isWtDirectInvocation(command)) {
+    blockCommand(WT_DIRECT_BLOCK_MESSAGE, command);
   }
 
   // 1. BLOCK 체크 — exit 2로 차단
   for (const rule of BLOCK_RULES) {
     if (rule.skipIfGit && !isPsmuxInvocation(command)) continue;
     if (rule.pattern.test(command)) {
-      process.stderr.write(
-        `[triflux safety-guard] BLOCKED: ${rule.reason}\n` +
-          `명령어: ${command.slice(0, 120)}${command.length > 120 ? "..." : ""}\n` +
-          `이 명령은 실행할 수 없습니다. 안전한 대안을 사용하세요.`
-      );
-      process.exit(2);
+      blockCommand(`[triflux safety-guard] BLOCKED: ${rule.reason}`, command);
     }
   }
 

package/hub/adaptive-inject.mjs

@@ -183,4 +183,4 @@ export function createAdaptiveInjector(opts = {}) {
   });
 }
 
-export default createAdaptiveInjector;
+export default createAdaptiveInjector;

package/hub/cli-adapter-base.mjs

@@ -38,15 +38,16 @@ export function gte(minMinor) {
 
 /**
  * Codex CLI 기능별 분기 객체.
- * 117 = 0.117.0 (Rust 리라이트, exec 서브커맨드 도입)
+ * 실측 기반 임계값: 0.114.0에서 exec/skip-git-repo-check/color 확인됨.
+ * --output-last-message는 0.114.0에 없음 (0.117+ 추정).
  */
 export const FEATURES = {
-  /** exec 서브커맨드 사용 가능 여부 */
-  get execSubcommand() { return gte(117); },
-  /** --output-last-message 플래그 지원 여부 */
+  /** exec 서브커맨드 사용 가능 여부 (0.110+ 이전부터 존재) */
+  get execSubcommand() { return gte(110); },
+  /** --output-last-message 플래그 지원 여부 (0.117+) */
   get outputLastMessage() { return gte(117); },
-  /** --color never 플래그 지원 여부 */
-  get colorNever() { return gte(117); },
+  /** --color <COLOR> 플래그 지원 여부 (exec와 동시 도입) */
+  get colorNever() { return gte(110); },
   /** 플러그인 시스템 지원 여부 (향후 확장용) */
   get pluginSystem() { return gte(120); },
 };

package/hub/lib/ssh-command.mjs

@@ -8,6 +8,22 @@ import { join } from "node:path";
 /** hosts.json 캐시 (프로세스 수명 동안 유지) */
 let hostsCache = null;
 
+/**
+ * hosts.json을 로드하여 캐시한다.
+ * @param {string} [repoRoot] — 프로젝트 루트 경로
+ */
+function loadHostsCache(repoRoot) {
+  if (hostsCache) return;
+  try {
+    const hostsPath = repoRoot
+      ? join(repoRoot, "references", "hosts.json")
+      : join(process.cwd(), "references", "hosts.json");
+    hostsCache = JSON.parse(readFileSync(hostsPath, "utf8"));
+  } catch {
+    hostsCache = { hosts: {} };
+  }
+}
+
 /**
  * hosts.json에서 호스트 OS를 조회한다.
  * @param {string} hostAlias — hosts.json의 키 (e.g. "ultra4")
@@ -15,16 +31,7 @@ let hostsCache = null;
  * @returns {"windows"|"posix"} 호스트 OS 유형
  */
 export function detectHostOs(hostAlias, repoRoot) {
-  if (!hostsCache) {
-    try {
-      const hostsPath = repoRoot
-        ? join(repoRoot, "references", "hosts.json")
-        : join(process.cwd(), "references", "hosts.json");
-      hostsCache = JSON.parse(readFileSync(hostsPath, "utf8"));
-    } catch {
-      hostsCache = { hosts: {} };
-    }
-  }
+  loadHostsCache(repoRoot);
 
   const hostCfg = hostsCache.hosts?.[hostAlias];
   if (hostCfg?.os === "windows") return "windows";
@@ -88,12 +95,14 @@ export function nullDevice(os) {
  * @param {string[]} remoteCmd — 원격에서 실행할 명령 + 인자
  * @param {object} [opts]
  * @param {number} [opts.connectTimeout=5] — SSH 연결 타임아웃(초)
+ * @param {boolean} [opts.keepalive=true] — ServerAliveInterval/CountMax 활성화
  * @param {"windows"|"posix"} [opts.os] — 호스트 OS (미지정 시 자동 감지)
  * @param {string} [opts.repoRoot] — hosts.json 탐색 경로
  * @returns {string[]} execFileSync('ssh', returnValue) 형태로 사용
  */
 export function buildSshArgs(host, remoteCmd, opts = {}) {
   const connectTimeout = opts.connectTimeout ?? 5;
+  const keepalive = opts.keepalive !== false;
   const hostAlias = host.includes("@") ? host.split("@").pop() : host;
   const os = opts.os ?? detectHostOs(hostAlias, opts.repoRoot);
 
@@ -102,12 +111,17 @@ export function buildSshArgs(host, remoteCmd, opts = {}) {
   const quotedArgs = args.map((a) => shellQuoteForHost(a, os));
   const remoteCmdStr = [cmd, ...quotedArgs].join(" ");
 
-  return [
+  const sshArgs = [
     "-o", `ConnectTimeout=${connectTimeout}`,
     "-o", "BatchMode=yes",
-    host,
-    remoteCmdStr,
   ];
+
+  if (keepalive) {
+    sshArgs.push("-o", "ServerAliveInterval=30", "-o", "ServerAliveCountMax=3");
+  }
+
+  sshArgs.push(host, remoteCmdStr);
+  return sshArgs;
 }
 
 /**
@@ -144,6 +158,53 @@ export function validateCommandForOs(command, os) {
   return { safe: violations.length === 0, violations };
 }
 
+/**
+ * hosts.json에서 호스트 전체 설정을 조회한다.
+ * @param {string} hostAlias — hosts.json의 키 (e.g. "ultra4")
+ * @param {string} [repoRoot]
+ * @returns {object|null}
+ */
+export function getHostConfig(hostAlias, repoRoot) {
+  loadHostsCache(repoRoot);
+  return hostsCache.hosts?.[hostAlias] ?? null;
+}
+
+/**
+ * 별칭(alias)으로 호스트 키를 찾는다.
+ * @param {string} alias — 호스트 키 또는 aliases 배열 내 값
+ * @param {string} [repoRoot]
+ * @returns {string|null} 호스트 키 (e.g. "ultra4") 또는 null
+ */
+export function resolveHostAlias(alias, repoRoot) {
+  loadHostsCache(repoRoot);
+
+  if (hostsCache.hosts?.[alias]) return alias;
+
+  for (const [name, cfg] of Object.entries(hostsCache.hosts || {})) {
+    if (cfg.aliases?.includes(alias)) return name;
+  }
+
+  return null;
+}
+
+/**
+ * 특정 capability를 보유한 호스트 목록을 반환한다.
+ * @param {string} capability — e.g. "codex", "claude", "gpu"
+ * @param {string} [repoRoot]
+ * @returns {Array<{ name: string, config: object }>}
+ */
+export function selectHostForCapability(capability, repoRoot) {
+  loadHostsCache(repoRoot);
+
+  const matches = [];
+  for (const [name, cfg] of Object.entries(hostsCache.hosts || {})) {
+    if (cfg.capabilities?.includes(capability)) {
+      matches.push({ name, config: cfg });
+    }
+  }
+  return matches;
+}
+
 /** hosts.json 캐시 초기화 (테스트용) */
 export function resetHostsCache() {
   hostsCache = null;

package/hub/lib/ssh-retry.mjs

@@ -0,0 +1,59 @@
+// hub/lib/ssh-retry.mjs — SSH command retry with exponential backoff
+// transient SSH 에러(connection reset, broken pipe 등)를 감지하여 자동 재시도한다.
+
+import { execFileSync } from "node:child_process";
+
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_BASE_DELAY_MS = 1000;
+
+/** transient SSH 에러 패턴 */
+const TRANSIENT_RE =
+  /connection (reset|refused|timed out)|broken pipe|network is unreachable|ssh_exchange_identification|kex_exchange_identification/i;
+
+/**
+ * execFileSync('ssh', args) 를 retry 래핑한다.
+ * transient 에러만 재시도하고, 그 외 에러는 즉시 throw.
+ *
+ * @param {string[]} args — ssh 인자 배열
+ * @param {object} [opts] — execFileSync 옵션 + retry 설정
+ * @param {number} [opts.maxRetries=2]
+ * @param {number} [opts.baseDelayMs=1000]
+ * @returns {string|Buffer} ssh stdout
+ */
+export function execSshWithRetry(args, opts = {}) {
+  const { maxRetries = DEFAULT_MAX_RETRIES, baseDelayMs = DEFAULT_BASE_DELAY_MS, ...execOpts } = opts;
+
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return execFileSync("ssh", args, execOpts);
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxRetries && isTransientSshError(err)) {
+        sleepSync(baseDelayMs * 2 ** attempt);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError;
+}
+
+/**
+ * transient SSH 에러인지 판별한다.
+ * @param {Error} err
+ * @returns {boolean}
+ */
+export function isTransientSshError(err) {
+  const msg = String(err.stderr || err.message || "");
+  return TRANSIENT_RE.test(msg);
+}
+
+/**
+ * 동기 sleep (Atomics.wait 기반).
+ * @param {number} ms
+ */
+function sleepSync(ms) {
+  if (ms <= 0) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}

package/hub/state.mjs

@@ -5,7 +5,8 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const PROJECT_ROOT = fileURLToPath(new URL('..', import.meta.url));
-const STATE_FILE_NAME = 'hub-state.json';
+const PID_FILE_NAME = 'hub.pid';
+const LEGACY_STATE_FILE_NAME = 'hub-state.json';
 const LOCK_FILE_NAME = 'hub-start.lock';
 
 let heldLockPath = null;
@@ -17,7 +18,11 @@ function getStateDir(options = {}) {
 }
 
 function getStatePath(options = {}) {
-  return join(getStateDir(options), STATE_FILE_NAME);
+  return options.statePath || join(getStateDir(options), PID_FILE_NAME);
+}
+
+function getLegacyStatePath(options = {}) {
+  return join(getStateDir(options), LEGACY_STATE_FILE_NAME);
 }
 
 function getLockPath(options = {}) {
@@ -59,6 +64,21 @@ function safeReplaceFile(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) 쓰기를 위해 임시 파일을 생성한 후 교체하는 방식을 사용합니다.
@@ -73,15 +93,14 @@ function safeReplaceFile(tempPath, targetPath) {
  * @param {string} [options.stateDir] - 상태 파일이 저장될 디렉토리
  * @returns {object} 기록된 상태 데이터
  */
-export function writeState({ pid, port, version, sessionId, startedAt }, options = {}) {
+export function writeState({ pid, port, version, sessionId, startedAt, ...rest }, options = {}) {
   const stateDir = getStateDir(options);
   const statePath = getStatePath(options);
-  const tempPath = join(stateDir, `${STATE_FILE_NAME}.${process.pid}.${Date.now()}.tmp`);
-  const payload = { pid, port, version, sessionId, startedAt };
+  const payload = { pid, port, version, sessionId, startedAt, ...rest };
 
   mkdirSync(stateDir, { recursive: true });
-  writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
-  safeReplaceFile(tempPath, statePath);
+  writeJsonFile(statePath, payload);
+  try { unlinkSync(getLegacyStatePath(options)); } catch {}
   return payload;
 }
 
@@ -93,13 +112,7 @@ export function writeState({ pid, port, version, sessionId, startedAt }, options
  * @returns {object|null} 읽어온 상태 데이터 또는 실패 시 null
  */
 export function readState(options = {}) {
-  const statePath = getStatePath(options);
-  try {
-    if (!existsSync(statePath)) return null;
-    return parseJson(readFileSync(statePath, 'utf8'), null);
-  } catch {
-    return null;
-  }
+  return readJsonFile(getStatePath(options)) ?? readJsonFile(getLegacyStatePath(options));
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.0.0",
+  "version": "10.0.2",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "type": "module",
   "main": "hub/index.mjs",
@@ -9,7 +9,9 @@
     "./hub/*": "./hub/*",
     "./scripts/*": "./scripts/*"
   },
-  "engines": { "node": ">=18.0.0" },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
@@ -21,7 +23,13 @@
     "hooks",
     "hud"
   ],
-  "keywords": ["claude-code", "cli-routing", "codex", "gemini", "triflux"],
+  "keywords": [
+    "claude-code",
+    "cli-routing",
+    "codex",
+    "gemini",
+    "triflux"
+  ],
   "author": "tellang",
   "license": "MIT",
   "repository": {

package/scripts/lib/skill-template.mjs

@@ -1,8 +1,9 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { basename, extname, join, relative } from "node:path";
+import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
 
 const IF_TAG_RE = /{{\s*(#if\s+([A-Za-z0-9_.-]+)|\/if)\s*}}/g;
-const INCLUDE_RE = /{{>\s*([A-Za-z0-9_./-]+)\s*}}/g;
+const PARTIAL_RE = /{{>\s*([A-Za-z0-9_./-]+)\s*}}/g;
+const FILE_INCLUDE_RE = /{{#include\s+([A-Za-z0-9_./-]+)\s*}}/g;
 const VARIABLE_RE = /{{\s*([A-Za-z0-9_.-]+)\s*}}/g;
 const FRONTMATTER_RE = /^---\r?\n(?:([\s\S]*?)\r?\n)?---\r?\n?/;
 
@@ -152,8 +153,8 @@ function evaluateConditionals(source, context) {
   return walk(0, false).output;
 }
 
-function renderIncludes(source, context, partials, includeStack) {
-  return source.replace(INCLUDE_RE, (_full, partialName) => {
+function renderPartials(source, context, partials, options, includeStack) {
+  return source.replace(PARTIAL_RE, (_full, partialName) => {
     const partial = partials[partialName];
     if (partial == null) {
       throw new Error(`Missing partial: ${partialName}`);
@@ -162,7 +163,53 @@ function renderIncludes(source, context, partials, includeStack) {
       const chain = [...includeStack, partialName].join(" -> ");
       throw new Error(`Circular partial include: ${chain}`);
     }
-    return renderWithContext(partial, context, partials, [...includeStack, partialName]);
+    return renderWithContext(partial, context, partials, options, [
+      ...includeStack,
+      partialName,
+    ]);
+  });
+}
+
+function normalizeIncludeName(includeName) {
+  return includeName.replace(/\\/g, "/");
+}
+
+function resolveIncludeContent(includeName, options) {
+  const normalizedName = normalizeIncludeName(includeName);
+  if (Object.prototype.hasOwnProperty.call(options.includes, normalizedName)) {
+    return options.includes[normalizedName];
+  }
+  if (!options.includeBaseDir) {
+    throw new Error(`Missing include: ${normalizedName}`);
+  }
+
+  const baseDir = resolve(options.includeBaseDir);
+  const fullPath = resolve(baseDir, normalizedName);
+  const relativePath = relative(baseDir, fullPath);
+  const isInsideBaseDir =
+    relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+
+  if (!isInsideBaseDir || !existsSync(fullPath)) {
+    throw new Error(`Missing include: ${normalizedName}`);
+  }
+
+  const content = readFileSync(fullPath, "utf8");
+  options.includes[normalizedName] = content;
+  return content;
+}
+
+function renderFileIncludes(source, context, partials, options, includeStack) {
+  return source.replace(FILE_INCLUDE_RE, (_full, includeName) => {
+    const normalizedName = normalizeIncludeName(includeName);
+    const content = resolveIncludeContent(normalizedName, options);
+    if (includeStack.includes(normalizedName)) {
+      const chain = [...includeStack, normalizedName].join(" -> ");
+      throw new Error(`Circular template include: ${chain}`);
+    }
+    return renderWithContext(content, context, partials, options, [
+      ...includeStack,
+      normalizedName,
+    ]);
   });
 }
 
@@ -176,10 +223,17 @@ function renderVariables(source, context) {
   });
 }
 
-function renderWithContext(source, context, partials, includeStack = []) {
+function renderWithContext(source, context, partials, options, includeStack = []) {
   const afterIf = evaluateConditionals(source, context);
-  const afterInclude = renderIncludes(afterIf, context, partials, includeStack);
-  return renderVariables(afterInclude, context);
+  const afterPartials = renderPartials(afterIf, context, partials, options, includeStack);
+  const afterFileIncludes = renderFileIncludes(
+    afterPartials,
+    context,
+    partials,
+    options,
+    includeStack,
+  );
+  return renderVariables(afterFileIncludes, context);
 }
 
 function readAllTemplateFiles(rootDir, currentDir = rootDir) {
@@ -263,7 +317,34 @@ export function loadTemplatePartials(partialsDir) {
   return partials;
 }
 
+export function loadSkillManifest(skillDir) {
+  const manifestPath = join(skillDir, "skill.json");
+  if (!existsSync(manifestPath)) return null;
+
+  const raw = readFileSync(manifestPath, "utf8");
+  return JSON.parse(raw);
+}
+
+export function parseFrontmatterWithManifest(source, skillDir) {
+  const manifest = skillDir ? loadSkillManifest(skillDir) : null;
+  const { data: yamlData, body } = parseFrontmatter(source);
+
+  if (!manifest) return { data: yamlData, body };
+
+  const merged = { ...yamlData };
+  if (manifest.name) merged.name = manifest.name;
+  if (manifest.description) merged.description = manifest.description;
+  if (manifest.triggers) merged.triggers = manifest.triggers;
+  if (manifest.argument_hint) merged["argument-hint"] = manifest.argument_hint;
+  if (manifest.internal != null) merged.internal = manifest.internal;
+
+  return { data: merged, body };
+}
+
 export function renderSkillTemplate(template, context = {}, options = {}) {
-  const { partials = {} } = options;
-  return renderWithContext(template, context, partials);
+  const { partials = {}, includes = {}, includeBaseDir = "" } = options;
+  return renderWithContext(template, context, partials, {
+    includeBaseDir,
+    includes: { ...includes },
+  });
 }