@triflux/core 10.0.0-alpha.2 → 10.0.1

package/hooks/keyword-rules.json

@@ -38,8 +38,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,20 +51,7 @@
         {
           "source": "\\bcodex[\\s-]?swarm\\b",
           "flags": "i"
-        }
-      ],
-      "skill": "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"
@@ -70,9 +61,11 @@
           "flags": "i"
         }
       ],
-      "skill": "tfx-remote-spawn",
+      "skill": "tfx-swarm",
       "priority": 1,
-      "supersedes": [],
+      "supersedes": [
+        "tfx-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/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-alpha.2",
+  "version": "10.0.1",
   "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 { readdirSync, readFileSync } from "node:fs";
-import { basename, extname, join, relative } from "node:path";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+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?/;
 
@@ -39,6 +40,44 @@ function parseScalar(raw) {
   return bool ?? value;
 }
 
+function parseMultilineValue(lines, startIndex, marker) {
+  const fold = marker.startsWith(">");
+  const chunks = [];
+  let index = startIndex;
+
+  while (index + 1 < lines.length && /^\s+/.test(lines[index + 1])) {
+    index += 1;
+    chunks.push(lines[index].replace(/^\s+/, ""));
+  }
+
+  return {
+    index,
+    value: fold ? chunks.join(" ").trim() : chunks.join("\n").trim(),
+  };
+}
+
+function parseListValue(lines, startIndex) {
+  const items = [];
+  let index = startIndex;
+
+  while (index + 1 < lines.length) {
+    const nextLine = lines[index + 1];
+    const match = nextLine.match(/^\s*-\s+(.*)$/);
+    if (match) {
+      index += 1;
+      items.push(parseScalar(match[1]));
+      continue;
+    }
+    if (/^\s*$/.test(nextLine)) {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+
+  return { index, value: items };
+}
+
 function parseFrontmatterBlock(block) {
   const lines = block.split(/\r?\n/);
   const data = {};
@@ -53,16 +92,21 @@ function parseFrontmatterBlock(block) {
     const value = rawValue.trim();
 
     if (value === ">" || value === "|" || value === ">-" || value === "|-") {
-      const fold = value.startsWith(">");
-      const chunks = [];
-      while (i + 1 < lines.length && /^\s+/.test(lines[i + 1])) {
-        i += 1;
-        chunks.push(lines[i].replace(/^\s+/, ""));
-      }
-      data[key] = fold ? chunks.join(" ").trim() : chunks.join("\n").trim();
+      const parsed = parseMultilineValue(lines, i, value);
+      data[key] = parsed.value;
+      i = parsed.index;
       continue;
     }
 
+    if (!value) {
+      const parsed = parseListValue(lines, i);
+      if (parsed.index !== i) {
+        data[key] = parsed.value;
+        i = parsed.index;
+        continue;
+      }
+    }
+
     data[key] = parseScalar(value);
   }
 
@@ -109,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}`);
@@ -119,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,
+    ]);
   });
 }
 
@@ -133,14 +223,25 @@ 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) {
-  const entries = readdirSync(currentDir, { withFileTypes: true });
+  if (!rootDir || !existsSync(rootDir)) return [];
+
+  const entries = readdirSync(currentDir, { withFileTypes: true }).sort((left, right) =>
+    left.name.localeCompare(right.name),
+  );
   const files = [];
 
   for (const entry of entries) {
@@ -217,6 +318,9 @@ export function loadTemplatePartials(partialsDir) {
 }
 
 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 },
+  });
 }