triflux 10.0.4 → 10.0.6

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"
       ],
@@ -71,34 +70,21 @@
       "mcp_route": null
     },
     {
-      "id": "tfx-auto-codex",
+      "id": "tfx-unified",
       "patterns": [
-        {
-          "source": "\\btfx[\\s-]?auto[\\s-]?codex\\b",
-          "flags": "i"
-        }
-      ],
-      "skill": "tfx-auto-codex",
-      "priority": 1,
-      "supersedes": [
-        "tfx-auto",
-        "tfx-codex"
-      ],
-      "exclusive": false,
-      "state": null,
-      "mcp_route": null
-    },
-    {
-      "id": "tfx-auto",
-      "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/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/team/swarm-hypervisor.mjs

@@ -19,6 +19,8 @@ import { createConductor, STATES } from './conductor.mjs';
 import { createSwarmLocks } from './swarm-locks.mjs';
 import { createEventLog } from './event-log.mjs';
 import { probeRemoteEnv, resolveRemoteDir } from './remote-session.mjs';
+import { fetchRemoteShard } from './worktree-lifecycle.mjs';
+import { getHostConfig } from '../lib/ssh-command.mjs';
 
 // ── Swarm states ──────────────────────────────────────────────
 
@@ -337,6 +339,28 @@ export function createSwarmHypervisor(opts) {
       const worker = workers.get(shardName);
       if (!worker) continue;
 
+      // Fetch remote shard branch to local (push-blocked hosts like Ultra4)
+      const shard = plan.shards.find((s) => s.name === shardName);
+      if (shard?.host && shard._remoteEnv) {
+        const hostConfig = getHostConfig(shard.host, config.rootDir);
+        const sshUser = hostConfig?.ssh_user || shard.host;
+        const remoteRepoPath = resolveRemoteDir(config.rootDir || process.cwd(), shard._remoteEnv);
+        const fetchResult = await fetchRemoteShard({
+          host: shard.host,
+          sshUser,
+          remoteRepoPath,
+          branchName: worker.branchName || `swarm/${config.runId}/${shardName}`,
+          rootDir: config.rootDir || process.cwd(),
+        });
+
+        if (!fetchResult.ok) {
+          eventLog.append('remote_fetch_failed', { shard: shardName, error: fetchResult.error });
+          integrationFailures.push(shardName);
+          continue;
+        }
+        eventLog.append('remote_fetch_ok', { shard: shardName, headCommit: fetchResult.headCommit });
+      }
+
       // Read shard output log for changed files
       const changedFiles = detectChangedFiles(shardName, worker);
 

package/hub/team/worktree-lifecycle.mjs

@@ -6,7 +6,7 @@
 import { execFile } from 'node:child_process';
 import { resolve, normalize } from 'node:path';
 import { mkdir, rm, access } from 'node:fs/promises';
-import { remoteGit } from './remote-session.mjs';
+import { remoteGit, validateHost } from './remote-session.mjs';
 
 const SWARM_ROOT = '.codex-swarm';
 const SLEEP_MS = 2000; // WT race-guard (MEMORY.md: wt-attach-spacing)
@@ -191,3 +191,39 @@ export async function pruneWorktree({ worktreePath, branchName, rootDir = proces
     try { await git(['branch', '-D', branchName], rootDir); } catch { /* may not exist */ }
   }
 }
+
+/**
+ * Fetch a remote shard's branch to the local repo via SSH.
+ * Workaround for hosts that cannot push to GitHub (e.g. Ultra4).
+ *
+ * Flow: add temp remote → fetch branch → remove remote.
+ *
+ * @param {object} opts
+ * @param {string} opts.host — SSH host (e.g. "ultra4")
+ * @param {string} opts.sshUser — SSH user (e.g. "SSAFY")
+ * @param {string} opts.remoteRepoPath — absolute path on remote (e.g. "/c/Users/SSAFY/Desktop/Projects/cli/triflux")
+ * @param {string} opts.branchName — branch to fetch (e.g. "swarm/run123/auth")
+ * @param {string} [opts.rootDir=process.cwd()] — local repo root
+ * @returns {Promise<{ ok: boolean, localRef?: string, error?: string }>}
+ */
+export async function fetchRemoteShard({ host, sshUser, remoteRepoPath, branchName, rootDir = process.cwd() }) {
+  validateHost(host);
+
+  const remoteName = `_swarm-${host}-${Date.now()}`;
+  const sshUrl = `ssh://${sshUser}@${host}${remoteRepoPath}`;
+
+  try {
+    await git(['remote', 'add', remoteName, sshUrl], rootDir);
+
+    await git(['fetch', remoteName, branchName, '--no-tags'], rootDir);
+
+    const localRef = `${remoteName}/${branchName}`;
+    const headCommit = await git(['rev-parse', `FETCH_HEAD`], rootDir);
+
+    return { ok: true, localRef, headCommit };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  } finally {
+    try { await git(['remote', 'remove', remoteName], rootDir); } catch { /* cleanup */ }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.0.4",
+  "version": "10.0.6",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {

package/scripts/__tests__/gen-skill-docs.test.mjs

@@ -1,10 +1,11 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, it } from "node:test";
 
 import { generateSkillDocs } from "../gen-skill-docs.mjs";
+import { generateSkillManifests } from "../gen-skill-manifest.mjs";
 
 function makeTempDir() {
   return mkdtempSync(join(tmpdir(), "tfx-gen-skill-docs-"));
@@ -84,4 +85,91 @@ describe("gen-skill-docs", () => {
       rmSync(root, { recursive: true, force: true });
     }
   });
+
+  it("partial 내부의 {{#include}}를 해석한다", () => {
+    const root = makeTempDir();
+    try {
+      const skillsDir = join(root, "skills");
+      const templatesDir = join(skillsDir, "_templates");
+      const sharedDir = join(skillsDir, "shared");
+      const skillDir = join(skillsDir, "tfx-inc");
+
+      mkdirSync(templatesDir, { recursive: true });
+      mkdirSync(sharedDir, { recursive: true });
+      mkdirSync(skillDir, { recursive: true });
+
+      writeFileSync(join(sharedDir, "args.md"), "ARGS={{SKILL_NAME}}", "utf8");
+      writeFileSync(join(templatesDir, "base.md"), "{{#include shared/args.md}}", "utf8");
+      writeFileSync(
+        join(skillDir, "SKILL.md.tmpl"),
+        "---\nname: tfx-inc\ndescription: inc test\n---\n{{> base}}\nend",
+        "utf8",
+      );
+
+      const result = generateSkillDocs({ skillsDir, templatesDir, write: true });
+      assert.equal(result.count, 1);
+
+      const output = readFileSync(join(skillDir, "SKILL.md"), "utf8");
+      assert.match(output, /ARGS=tfx-inc/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("gen-skill-manifest", () => {
+  it("SKILL.md frontmatter에서 skill.json을 생성한다", () => {
+    const root = makeTempDir();
+    try {
+      const skillsDir = join(root, "skills");
+      const skillDir = join(skillsDir, "tfx-manifest-test");
+
+      mkdirSync(skillDir, { recursive: true });
+      writeFileSync(
+        join(skillDir, "SKILL.md"),
+        [
+          "---",
+          "name: tfx-manifest-test",
+          "description: test manifest",
+          "triggers:",
+          "  - test",
+          "  - manifest",
+          "argument-hint: <arg>",
+          "internal: true",
+          "---",
+          "body",
+        ].join("\n"),
+        "utf8",
+      );
+
+      const result = generateSkillManifests({ skillsDir, write: true });
+      assert.equal(result.count, 1);
+
+      const manifest = JSON.parse(readFileSync(join(skillDir, "skill.json"), "utf8"));
+      assert.equal(manifest.name, "tfx-manifest-test");
+      assert.equal(manifest.description, "test manifest");
+      assert.deepEqual(manifest.triggers, ["test", "manifest"]);
+      assert.equal(manifest.argument_hint, "<arg>");
+      assert.equal(manifest.internal, true);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("frontmatter가 없는 SKILL.md는 건너뛴다", () => {
+    const root = makeTempDir();
+    try {
+      const skillsDir = join(root, "skills");
+      const skillDir = join(skillsDir, "tfx-no-fm");
+
+      mkdirSync(skillDir, { recursive: true });
+      writeFileSync(join(skillDir, "SKILL.md"), "no frontmatter", "utf8");
+
+      const result = generateSkillManifests({ skillsDir, write: true });
+      assert.equal(result.count, 0);
+      assert.equal(existsSync(join(skillDir, "skill.json")), false);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
 });

package/scripts/__tests__/keyword-detector.test.mjs

@@ -29,7 +29,7 @@ const { extractPrompt, sanitizeForKeywordDetection } = detectorModule;
 
 function loadCompiledRules() {
   const rules = loadRules(rulesPath);
-  assert.equal(rules.length, 33);
+  assert.equal(rules.length, 31);
   return compileRules(rules);
 }
 
@@ -100,8 +100,8 @@ test("sanitizeForKeywordDetection: 코드블록/URL/파일경로/XML 태그 제
 
 test("loadRules: 유효한 JSON 로드", () => {
   const rules = loadRules(rulesPath);
-  assert.equal(rules.length, 33);
-  assert.equal(rules.filter((rule) => rule.skill).length, 20);
+  assert.equal(rules.length, 31);
+  assert.equal(rules.filter((rule) => rule.skill).length, 18);
   assert.equal(rules.filter((rule) => rule.mcp_route).length, 10);
 });
 
@@ -122,7 +122,7 @@ test("loadRules: 잘못된 파일 처리", () => {
 test("compileRules: 정규식 컴파일 성공", () => {
   const rules = loadRules(rulesPath);
   const compiled = compileRules(rules);
-  assert.equal(compiled.length, 33);
+  assert.equal(compiled.length, 31);
   for (const rule of compiled) {
     assert.ok(Array.isArray(rule.compiledPatterns));
     assert.ok(rule.compiledPatterns.length > 0);
@@ -153,7 +153,7 @@ test("matchRules: tfx 키워드 매칭", () => {
   const compiledRules = loadCompiledRules();
   const cases = [
     { text: "tfx multi 세션 시작", expectedId: "tfx-multi" },
-    { text: "tfx auto 돌려줘", expectedId: "tfx-auto" },
+    { text: "tfx auto 돌려줘", expectedId: "tfx-unified" },
     { text: "tfx codex 로 실행", expectedId: "tfx-codex" },
     { text: "tfx gemini 로 실행", expectedId: "tfx-gemini" },
     { text: "canceltfx", expectedId: "tfx-cancel" }

package/scripts/__tests__/skill-template.test.mjs

@@ -6,11 +6,14 @@ import { describe, it } from "node:test";
 
 import {
   buildSkillTemplateContext,
+  loadSkillManifest,
   loadTemplatePartials,
   parseFrontmatter,
+  parseFrontmatterWithManifest,
   renderSkillTemplate,
 } from "../lib/skill-template.mjs";
 import { generateSkillDocs } from "../gen-skill-docs.mjs";
+import { generateSkillManifests } from "../gen-skill-manifest.mjs";
 
 function makeTempDir() {
   return mkdtempSync(join(tmpdir(), "tfx-skill-template-"));
@@ -159,6 +162,93 @@ describe("skill-template engine", () => {
     assert.equal(renderedLines.at(-1), "name=big-template");
   });
 
+  it("{{#include shared/*.md}}로 파일을 인라인 확장한다", () => {
+    const root = makeTempDir();
+    try {
+      const sharedDir = join(root, "shared");
+      mkdirSync(sharedDir, { recursive: true });
+      writeFileSync(join(sharedDir, "telemetry.md"), "TEL={{SKILL_NAME}}", "utf8");
+
+      const template = "before\n{{#include shared/telemetry.md}}\nafter";
+      const output = renderSkillTemplate(template, { SKILL_NAME: "test-skill" }, {
+        partials: {},
+        includeBaseDir: root,
+      });
+
+      assert.match(output, /before/);
+      assert.match(output, /TEL=test-skill/);
+      assert.match(output, /after/);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("loadSkillManifest는 skill.json이 있으면 파싱한다", () => {
+    const root = makeTempDir();
+    try {
+      writeFileSync(join(root, "skill.json"), JSON.stringify({
+        name: "tfx-test",
+        description: "test skill",
+        triggers: ["test"],
+      }), "utf8");
+
+      const manifest = loadSkillManifest(root);
+      assert.equal(manifest.name, "tfx-test");
+      assert.deepEqual(manifest.triggers, ["test"]);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("loadSkillManifest는 skill.json이 없으면 null을 반환한다", () => {
+    const root = makeTempDir();
+    try {
+      assert.equal(loadSkillManifest(root), null);
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("parseFrontmatterWithManifest는 skill.json 우선으로 병합한다", () => {
+    const root = makeTempDir();
+    try {
+      writeFileSync(join(root, "skill.json"), JSON.stringify({
+        name: "manifest-name",
+        description: "manifest-desc",
+        internal: true,
+      }), "utf8");
+
+      const source = [
+        "---",
+        "name: yaml-name",
+        "description: yaml-desc",
+        "deep: true",
+        "---",
+        "body",
+      ].join("\n");
+
+      const result = parseFrontmatterWithManifest(source, root);
+      assert.equal(result.data.name, "manifest-name");
+      assert.equal(result.data.description, "manifest-desc");
+      assert.equal(result.data.internal, true);
+      assert.equal(result.data.deep, true);
+      assert.equal(result.body, "body");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("parseFrontmatterWithManifest는 skill.json 없으면 YAML fallback한다", () => {
+    const root = makeTempDir();
+    try {
+      const source = "---\nname: yaml-only\n---\nbody";
+      const result = parseFrontmatterWithManifest(source, root);
+      assert.equal(result.data.name, "yaml-only");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
   it("gen-skill-docs에서 누락 partial 참조 시 에러를 전파한다", () => {
     const root = makeTempDir();
     try {

package/scripts/gen-skill-docs.mjs

@@ -65,7 +65,10 @@ export function generateSkillDocs({
   for (const templatePath of templateFiles) {
     const templateContent = readFileSync(templatePath, "utf8");
     const context = createRenderContext(templateContent, templatePath);
-    const rendered = renderSkillTemplate(templateContent, context, { partials });
+    const rendered = renderSkillTemplate(templateContent, context, {
+      partials,
+      includeBaseDir: skillsDir,
+    });
     const outputPath = resolveOutputPath(templatePath);
 
     if (write) {

package/scripts/gen-skill-manifest.mjs

@@ -0,0 +1,83 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { parseFrontmatter } from "./lib/skill-template.mjs";
+
+function collectSkillDirs(skillsDir) {
+  return readdirSync(skillsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("_"))
+    .map((entry) => ({
+      name: entry.name,
+      dir: join(skillsDir, entry.name),
+    }))
+    .filter(({ dir }) => existsSync(join(dir, "SKILL.md")))
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+function extractManifest(skillMdContent) {
+  const { data } = parseFrontmatter(skillMdContent);
+  if (!data.name) return null;
+
+  const manifest = { name: data.name };
+  if (data.description) manifest.description = data.description;
+  if (data.triggers) manifest.triggers = data.triggers;
+  if (data["argument-hint"]) manifest.argument_hint = data["argument-hint"];
+  if (data.internal === true || data.internal === "true") manifest.internal = true;
+
+  return manifest;
+}
+
+export function generateSkillManifests({ skillsDir, write = true } = {}) {
+  if (!skillsDir) throw new Error("skillsDir is required");
+
+  const skillDirs = collectSkillDirs(skillsDir);
+  const generated = [];
+
+  for (const { name, dir } of skillDirs) {
+    const skillMdPath = join(dir, "SKILL.md");
+    const content = readFileSync(skillMdPath, "utf8");
+    const manifest = extractManifest(content);
+
+    if (!manifest) continue;
+
+    const manifestPath = join(dir, "skill.json");
+    const json = JSON.stringify(manifest, null, 2) + "\n";
+
+    if (write) {
+      const existing = existsSync(manifestPath)
+        ? readFileSync(manifestPath, "utf8")
+        : null;
+      if (existing !== json) {
+        writeFileSync(manifestPath, json, "utf8");
+      }
+    }
+
+    generated.push({ name, manifestPath, manifest });
+  }
+
+  return { generated, count: generated.length };
+}
+
+function runCli() {
+  const scriptDir = dirname(fileURLToPath(import.meta.url));
+  const repoRoot = resolve(scriptDir, "..");
+  const skillsDir = join(repoRoot, "skills");
+
+  const result = generateSkillManifests({ skillsDir });
+  console.log(`Generated ${result.count} skill.json file(s).`);
+}
+
+const isDirectRun = process.argv[1]
+  ? resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+  : false;
+
+if (isDirectRun) {
+  try {
+    runCli();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[gen-skill-manifest] ${message}`);
+    process.exitCode = 1;
+  }
+}

package/scripts/lib/skill-template.mjs

@@ -317,6 +317,30 @@ 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 = {}, includes = {}, includeBaseDir = "" } = options;
   return renderWithContext(template, context, partials, {

package/scripts/pack.mjs

@@ -227,7 +227,7 @@ export { createSwarmLocks } from './team/swarm-locks.mjs';
 export { parseShards, buildFileLeaseMap, buildMcpManifest, computeMergeOrder, planSwarm } from './team/swarm-planner.mjs';
 export { createSwarmHypervisor, SWARM_STATES } from './team/swarm-hypervisor.mjs';
 export { reconcile, buildRedundantIds, shouldRunRedundant } from './team/swarm-reconciler.mjs';
-export { ensureWorktree, prepareIntegrationBranch, rebaseShardOntoIntegration, pruneWorktree } from './team/worktree-lifecycle.mjs';
+export { ensureWorktree, prepareIntegrationBranch, rebaseShardOntoIntegration, pruneWorktree, fetchRemoteShard } from './team/worktree-lifecycle.mjs';
 `;
 
 function writeIndex(dest, content) {

package/skills/merge-worktree/skill.json

@@ -0,0 +1,5 @@
+{
+  "name": "merge-worktree",
+  "description": "워크트리 브랜치를 main으로 squash-merge + conventional commit 자동 생성. codex-swarm 워크트리 자동 인식. '머지해', 'merge worktree', '워크트리 머지', '결과 수집', 'squash merge' 요청에 사용.",
+  "argument_hint": "[target-branch]"
+}

package/skills/star-prompt/skill.json

@@ -0,0 +1,4 @@
+{
+  "name": "star-prompt",
+  "description": "CLI 프로젝트의 setup/postinstall 흐름에 GitHub 스타 요청 프롬프트를 추가한다. gh CLI 인증 확인 → 이미 스타 여부 감지 → 인터랙티브 confirm → gh API로 자동 스타. Apple 스타일 UX 카피 포함. 'star prompt', '스타 요청', '리포 스타', 'star request', '깃헙 스타 넣어줘', 'star 눌러달라고', '응원 요청' 같은 요청에 사용한다."
+}

package/skills/tfx-analysis/SKILL.md

@@ -1,4 +1,5 @@
 ---
+internal: true
 name: tfx-analysis
 description: "코드나 아키텍처를 분석해야 할 때 사용한다. '코드 분석', 'code analysis', '아키텍처 분석', '이 코드 어떻게 돌아가?', '구조 파악' 같은 요청에 반드시 사용. 코드 품질, 보안, 성능, 복잡도 분석이 필요한 모든 상황에 적극 활용."
 triggers:

package/skills/tfx-analysis/skill.json

@@ -0,0 +1,12 @@
+{
+  "name": "tfx-analysis",
+  "description": "코드나 아키텍처를 분석해야 할 때 사용한다. '코드 분석', 'code analysis', '아키텍처 분석', '이 코드 어떻게 돌아가?', '구조 파악' 같은 요청에 반드시 사용. 코드 품질, 보안, 성능, 복잡도 분석이 필요한 모든 상황에 적극 활용.",
+  "triggers": [
+    "코드 분석",
+    "code analysis",
+    "아키텍처 분석",
+    "analysis"
+  ],
+  "argument_hint": "<분석 대상 — 파일, 디렉토리, 또는 주제>",
+  "internal": true
+}