triflux 10.0.3 → 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.3",
+  "version": "10.0.5",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {
@@ -13,9 +13,11 @@
     "tfx-doctor-tui": "bin/tfx-doctor-tui.mjs",
     "tfx-setup-tui": "bin/tfx-setup-tui.mjs"
   },
-  "engines": { "node": ">=18.0.0" },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
-    "@triflux/core": "^10.0.0-alpha.1",
+    "@triflux/core": "10.0.1",
     "@triflux/remote": "^10.0.0-alpha.1"
   },
   "files": [
@@ -31,7 +33,17 @@
     "README.md",
     "LICENSE"
   ],
-  "keywords": ["claude-code", "plugin", "codex", "gemini", "cli-routing", "orchestration", "multi-model", "triflux", "tfx"],
+  "keywords": [
+    "claude-code",
+    "plugin",
+    "codex",
+    "gemini",
+    "cli-routing",
+    "orchestration",
+    "multi-model",
+    "triflux",
+    "tfx"
+  ],
   "author": "tellang",
   "license": "MIT",
   "homepage": "https://github.com/tellang/triflux#readme",

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/__tests__/smoke.test.mjs

@@ -1,34 +1,34 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-describe("smoke: 주요 모듈 import 검증", () => {
-  it("scripts/lib/keyword-rules.mjs — 순수 함수 export", async () => {
-    const mod = await import("../lib/keyword-rules.mjs");
-    assert.equal(typeof mod.loadRules, "function");
-    assert.equal(typeof mod.compileRules, "function");
-    assert.equal(typeof mod.matchRules, "function");
-    assert.equal(typeof mod.resolveConflicts, "function");
-  });
-
-  it("hub/team/shared.mjs — ANSI 상수 export", async () => {
-    const mod = await import("../../hub/team/shared.mjs");
-    assert.equal(typeof mod.AMBER, "string");
-    assert.equal(typeof mod.RESET, "string");
-  });
-
-  it("hub/team/staleState.mjs — stale 상태 유틸 export", async () => {
-    const mod = await import("../../hub/team/staleState.mjs");
-    assert.equal(typeof mod.TEAM_STATE_FILE_NAME, "string");
-    assert.equal(typeof mod.STALE_TEAM_MAX_AGE_MS, "number");
-  });
-
-  it("hub/pipeline/transitions.mjs — 파이프라인 전이 규칙 export", async () => {
-    const mod = await import("../../hub/pipeline/transitions.mjs");
-    assert.ok(Array.isArray(mod.PHASES));
-    assert.ok(mod.PHASES.includes("plan"));
-    assert.ok(mod.PHASES.includes("complete"));
-    assert.ok(mod.TERMINAL instanceof Set);
-    assert.ok(mod.TERMINAL.has("complete"));
-    assert.ok(mod.TERMINAL.has("failed"));
-  });
-});
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+describe("smoke: 주요 모듈 import 검증", () => {
+  it("scripts/lib/keyword-rules.mjs — 순수 함수 export", async () => {
+    const mod = await import("../lib/keyword-rules.mjs");
+    assert.equal(typeof mod.loadRules, "function");
+    assert.equal(typeof mod.compileRules, "function");
+    assert.equal(typeof mod.matchRules, "function");
+    assert.equal(typeof mod.resolveConflicts, "function");
+  });
+
+  it("hub/team/shared.mjs — ANSI 상수 export", async () => {
+    const mod = await import("../../hub/team/shared.mjs");
+    assert.equal(typeof mod.AMBER, "string");
+    assert.equal(typeof mod.RESET, "string");
+  });
+
+  it("hub/team/staleState.mjs — stale 상태 유틸 export", async () => {
+    const mod = await import("../../hub/team/staleState.mjs");
+    assert.equal(typeof mod.TEAM_STATE_FILE_NAME, "string");
+    assert.equal(typeof mod.STALE_TEAM_MAX_AGE_MS, "number");
+  });
+
+  it("hub/pipeline/transitions.mjs — 파이프라인 전이 규칙 export", async () => {
+    const mod = await import("../../hub/pipeline/transitions.mjs");
+    assert.ok(Array.isArray(mod.PHASES));
+    assert.ok(mod.PHASES.includes("plan"));
+    assert.ok(mod.PHASES.includes("complete"));
+    assert.ok(mod.TERMINAL instanceof Set);
+    assert.ok(mod.TERMINAL.has("complete"));
+    assert.ok(mod.TERMINAL.has("failed"));
+  });
+});

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