triflux 10.0.4 → 10.0.5

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.0.4",
+  "version": "10.0.5",
   "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__/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/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
+}

package/skills/tfx-auto/SKILL.md.tmpl

@@ -31,6 +31,51 @@ argument-hint: "<command|task> [args...]"
 
 {{> base}}
 
+### Step 0: 스마트 라우팅 (tfx-auto 진입 시 자동 실행)
+
+preamble에서 routing-weights.json을 읽고, 사용자 입력을 분석하여 dispatch 결정.
+
+```bash
+SLUG=$(basename "$(git rev-parse --show-toplevel 2>/dev/null)" 2>/dev/null || echo "unknown")
+WEIGHTS_FILE="$HOME/.gstack/projects/$SLUG/routing-weights.json"
+USER_MODE=""
+if [ -f "$WEIGHTS_FILE" ]; then
+  USER_MODE=$(node -e "
+    const w=JSON.parse(require('fs').readFileSync('$WEIGHTS_FILE','utf8'));
+    const m=w.weights?.mode_bias||{};
+    const top=Object.entries(m).sort((a,b)=>b[1]-a[1])[0];
+    if(top && top[1]>0.3) console.log(top[0]);
+  " 2>/dev/null)
+fi
+echo "USER_PREFERRED_MODE: ${USER_MODE:-none}"
+```
+
+판단 기준 (우선순위 순):
+
+1. **사용자 명시 키워드** (최우선):
+   - "병렬", "swarm", "PRD 돌려" → `Skill("tfx-swarm")` dispatch
+   - "꼼꼼히", "제대로", "deep" → 해당 `tfx-deep-*` dispatch
+   - "끝까지", "멈추지마", "ralph" → `Skill("tfx-persist")` dispatch
+   - "multi", "팀", "협업" → `Skill("tfx-multi")` dispatch
+   - "codex로", "gemini로" → `Skill("tfx-codex")` 또는 `Skill("tfx-gemini")` dispatch
+
+2. **PRD 인자 분석**:
+   - PRD 경로 2개 이상 → `Skill("tfx-swarm")` dispatch
+   - PRD 1개 + XL 규모 → `Skill("tfx-fullcycle")` dispatch
+
+3. **선호도 가중치** (tiebreaker):
+   - USER_PREFERRED_MODE가 있고 가중치 > 0.3이면 제안
+   - "[tfx] 사용자 선호: {mode}. 이 모드로 실행할까요?" 1줄 표시
+   - 응답 없으면 기본(auto) 진행
+
+4. **기본**: 기존 tfx-auto 워크플로우 그대로 실행
+
+dispatch 시 해당 스킬을 Skill 도구로 호출하고 **이 워크플로우를 종료**한다. dispatch하지 않으면 아래 기존 워크플로우 진행.
+
+라우팅 결정 후 1줄 표시:
+```
+[tfx] 규모: {S/M/L/XL}, 모드: {mode} ({profile}) — 오버라이드: /tfx-multi, /tfx-swarm 등
+```
 
 > **MANDATORY RULES**
 >

package/skills/tfx-auto/skill.json

@@ -0,0 +1,26 @@
+{
+  "name": "tfx-auto",
+  "description": "통합 CLI 오케스트레이터. 커맨드 숏컷(단일) + 자동 분류/분해(병렬) + 수동 병렬. tfx-route.sh 기반. '코드 짜줘', '구현해줘', '만들어줘', '수정해줘', '고쳐줘', 'implement', 'build', 'fix' 같은 구현/수정 요청에 사용. CLI 라우팅이 필요한 모든 작업에 적극 활용.",
+  "triggers": [
+    "tfx-auto",
+    "implement",
+    "build",
+    "research",
+    "brainstorm",
+    "design",
+    "test",
+    "analyze",
+    "troubleshoot",
+    "improve",
+    "cleanup",
+    "explain",
+    "document",
+    "pm",
+    "reflect",
+    "estimate",
+    "spec-panel",
+    "business-panel",
+    "index-repo"
+  ],
+  "argument_hint": "<command|task> [args...]"
+}

package/skills/tfx-auto-codex/SKILL.md

@@ -1,4 +1,5 @@
 ---
+internal: true
 name: tfx-auto-codex
 description: >
   Codex 리드형 tfx-auto. Claude 네이티브 역할을 Codex로 치환하고 Gemini 사용은 유지합니다.

package/skills/tfx-auto-codex/skill.json

@@ -0,0 +1,9 @@
+{
+  "name": "tfx-auto-codex",
+  "description": "Codex 리드형 tfx-auto. Claude 네이티브 역할을 Codex로 치환하고 Gemini 사용은 유지합니다. '코덱스 리드', '코덱스가 주도', 'codex lead' 같은 요청에 사용.",
+  "triggers": [
+    "tfx-auto-codex"
+  ],
+  "argument_hint": "\\\"작업 설명\\\" | N:agent_type \\\"작업 설명\\\"",
+  "internal": true
+}

package/skills/tfx-autopilot/SKILL.md

@@ -1,4 +1,5 @@
 ---
+internal: true
 name: tfx-autopilot
 description: "단일 파일/모듈 수준의 간단한 작업을 자율 구현할 때 사용한다. 구현+검증까지 5분 이내 완료 가능한 작업, '간단히', '빠르게', '하나만', '자동으로', '알아서 해', '그냥 해줘' 같은 수식어가 있을 때 사용. 복잡한 멀티파일 작업은 tfx-fullcycle을 사용하세요."
 triggers:

package/skills/tfx-autopilot/skill.json

@@ -0,0 +1,11 @@
+{
+  "name": "tfx-autopilot",
+  "description": "단일 파일/모듈 수준의 간단한 작업을 자율 구현할 때 사용한다. 구현+검증까지 5분 이내 완료 가능한 작업, '간단히', '빠르게', '하나만', '자동으로', '알아서 해', '그냥 해줘' 같은 수식어가 있을 때 사용. 복잡한 멀티파일 작업은 tfx-fullcycle을 사용하세요.",
+  "triggers": [
+    "autopilot",
+    "자동",
+    "알아서 해"
+  ],
+  "argument_hint": "<구현할 작업 설명>",
+  "internal": true
+}

package/skills/tfx-autoresearch/SKILL.md

@@ -1,4 +1,5 @@
 ---
+internal: true
 name: tfx-autoresearch
 description: >
   자율 웹 리서치 → 실행 가능 계획 도출.