triflux 9.2.2 → 9.2.3

package/bin/triflux.mjs

@@ -20,7 +20,7 @@ const CODEX_CONFIG_PATH = join(CODEX_DIR, "config.toml");
 const PKG = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
 
 // 이 배열에 포함된 버전에서만 star prompt를 표시한다 (빈 배열 = 모든 버전에서 표시)
-const STAR_PROMPT_VERSIONS = [];
+const STAR_PROMPT_VERSIONS = ["9.2.2"];
 
 const REQUIRED_CODEX_PROFILES = [
   {

package/hooks/agent-route-guard.mjs

@@ -1,8 +1,109 @@
 #!/usr/bin/env node
-// PreToolUse:Agent hook — triflux 프로젝트 기본 에이전트 라우팅
-// 특정 시스템을 차단하지 않고, triflux의 의도를 context로 주입
+// hooks/agent-route-guard.mjs — PreToolUse:Agent 훅
+// 서브에이전트 스폰 시 triflux 컨텍스트를 구조화 JSON으로 주입한다.
+// - subagent_type별 최적 라우팅 가이드
+// - tfx-multi 활성 상태 시 headless dispatch 강제
+// - 프로젝트 컨텍스트 자동 첨부
 
-console.log(
-  "triflux 프로젝트 기본: Agent spawn 시 subagent_type='general-purpose'를 사용하세요. " +
-  "프로젝트 스킬(tfx-*)이 활성 상태이면 스킬 MD의 라우팅 지시를 우선합니다."
-);
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const TFX_MULTI_STATE = join(tmpdir(), "tfx-multi-state.json");
+const EXPIRE_MS = 30 * 60 * 1000; // 30분
+
+// 서브에이전트 타입별 라우팅 힌트
+const AGENT_HINTS = {
+  "general-purpose": "범용 에이전트. tfx 스킬이 활성이면 스킬 MD의 라우팅을 우선한다.",
+  Explore: "탐색 전용. 파일 수정 불가. Glob/Grep/Read만 사용.",
+  Plan: "설계 전용. 파일 수정 불가. 구현 계획 반환.",
+  "oh-my-claudecode:executor": "OMC executor. triflux 프로젝트에서는 tfx-auto 라우팅을 우선.",
+  "oh-my-claudecode:code-reviewer": "OMC 리뷰어. 교차 리뷰 시 CLAUDE.md 교차 검증 규칙 준수.",
+  "oh-my-claudecode:architect": "OMC 아키텍트. READ-ONLY.",
+  "oh-my-claudecode:debugger": "OMC 디버거. 근본 원인 분석 집중.",
+  "oh-my-claudecode:test-engineer": "OMC 테스트. npm test 실행 후 결과 반환.",
+};
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function getTfxMultiState() {
+  if (!existsSync(TFX_MULTI_STATE)) return null;
+  try {
+    const state = JSON.parse(readFileSync(TFX_MULTI_STATE, "utf8"));
+    if (Date.now() - state.activatedAt > EXPIRE_MS) return null;
+    return state.active ? state : null;
+  } catch {
+    return null;
+  }
+}
+
+function buildContext(agentType, prompt) {
+  const parts = [];
+
+  // 1. tfx-multi 활성 상태 확인
+  const multiState = getTfxMultiState();
+  if (multiState) {
+    parts.push(
+      "[tfx-multi ACTIVE] headless dispatch 모드. " +
+        "CLI 작업은 Bash(tfx-route.sh)를 통해 실행하세요."
+    );
+  }
+
+  // 2. 에이전트 타입별 힌트
+  const hint = AGENT_HINTS[agentType];
+  if (hint) {
+    parts.push(`[Agent:${agentType}] ${hint}`);
+  }
+
+  // 3. 프로젝트 컨텍스트
+  parts.push(
+    "triflux 프로젝트: subagent_type 미지정 시 'general-purpose' 기본. " +
+      "tfx-* 스킬 활성 시 스킬 MD 라우팅 우선."
+  );
+
+  return parts.join("\n");
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  if (input.tool_name !== "Agent") process.exit(0);
+
+  const toolInput = input.tool_input || {};
+  const agentType = toolInput.subagent_type || toolInput.agent || "general-purpose";
+  const prompt = toolInput.prompt || "";
+
+  const context = buildContext(agentType, prompt);
+
+  // 구조화된 hookSpecificOutput 반환
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow",
+      additionalContext: context,
+    },
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+try {
+  main();
+} catch {
+  // 훅 실패 시 블로킹하지 않음
+  process.exit(0);
+}

package/hooks/cross-review-tracker.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// hooks/cross-review-tracker.mjs — PostToolUse:Edit|Write 훅
+//
+// 파일 수정을 추적하여 교차 리뷰 미검증 파일을 감지한다.
+// CLAUDE.md 규칙: "Claude 작성 코드 → Codex 리뷰, Codex 작성 → Claude 리뷰"
+//
+// 동작:
+//   1. Edit/Write 성공 시 수정된 파일 경로를 상태 파일에 누적
+//   2. 일정 수(REVIEW_THRESHOLD) 이상 미검증 파일이 쌓이면 nudge 메시지 주입
+//   3. git commit 전 미검증 파일 경고
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+import { tmpdir } from "node:os";
+
+const STATE_DIR = join(tmpdir(), "tfx-cross-review");
+const STATE_FILE = join(STATE_DIR, "pending-review.json");
+const REVIEW_THRESHOLD = 5; // 이 수 이상 미검증 파일 → nudge
+const EXPIRE_MS = 60 * 60 * 1000; // 1시간 후 자동 만료
+
+// 코드 파일만 추적 (설정/문서/빌드 산출물 제외)
+const CODE_EXTENSIONS = new Set([
+  ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx",
+  ".py", ".rs", ".go", ".java", ".c", ".cpp", ".h",
+  ".vue", ".svelte", ".sh", ".bash", ".ps1",
+]);
+
+function isCodeFile(filePath) {
+  if (!filePath) return false;
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return CODE_EXTENSIONS.has(ext);
+}
+
+function loadState() {
+  if (!existsSync(STATE_FILE)) {
+    return { files: {}, startedAt: Date.now() };
+  }
+  try {
+    const state = JSON.parse(readFileSync(STATE_FILE, "utf8"));
+    // 만료 체크
+    if (Date.now() - state.startedAt > EXPIRE_MS) {
+      return { files: {}, startedAt: Date.now() };
+    }
+    return state;
+  } catch {
+    return { files: {}, startedAt: Date.now() };
+  }
+}
+
+function saveState(state) {
+  mkdirSync(STATE_DIR, { recursive: true });
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const toolName = input.tool_name || "";
+  if (toolName !== "Edit" && toolName !== "Write") process.exit(0);
+
+  const toolInput = input.tool_input || {};
+  const filePath = toolInput.file_path || "";
+
+  if (!filePath || !isCodeFile(filePath)) process.exit(0);
+
+  // 프로젝트 루트 기준 상대 경로
+  const cwd = input.cwd || process.cwd();
+  const relPath = relative(cwd, filePath) || filePath;
+
+  // 상태 갱신: 파일 추가
+  const state = loadState();
+  state.files[relPath] = {
+    tool: toolName,
+    modifiedAt: Date.now(),
+    reviewed: false,
+  };
+  saveState(state);
+
+  // 미검증 파일 수 체크
+  const unreviewed = Object.entries(state.files).filter(
+    ([, v]) => !v.reviewed
+  );
+  const count = unreviewed.length;
+
+  if (count >= REVIEW_THRESHOLD) {
+    // nudge 메시지 주입
+    const fileList = unreviewed
+      .slice(0, 8)
+      .map(([f]) => `  - ${f}`)
+      .join("\n");
+
+    const output = {
+      systemMessage:
+        `[교차 리뷰 nudge] 미검증 코드 파일 ${count}개:\n${fileList}\n` +
+        (count > 8 ? `  ... 외 ${count - 8}개\n` : "") +
+        `커밋 전 교차 리뷰를 권장합니다. (Claude→Codex 또는 Codex→Claude)`,
+    };
+    process.stdout.write(JSON.stringify(output));
+  }
+}
+
+try {
+  main();
+} catch {
+  process.exit(0);
+}

package/hooks/error-context.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// hooks/error-context.mjs — PostToolUseFailure 훅
+//
+// 도구 실패 시 에러 패턴을 분석하여 해결 힌트를 additionalContext로 주입한다.
+// Claude가 동일 에러를 반복하지 않도록 구체적 가이드를 제공.
+
+import { readFileSync } from "node:fs";
+
+// ── 에러 패턴 → 해결 힌트 매핑 ─────────────────────────────
+const ERROR_HINTS = [
+  // Node.js / npm
+  {
+    pattern: /ENOENT.*no such file or directory/i,
+    hint: "파일/디렉토리가 존재하지 않습니다. 경로를 확인하거나 mkdir -p로 디렉토리를 먼저 생성하세요.",
+  },
+  {
+    pattern: /EACCES.*permission denied/i,
+    hint: "권한 부족. Windows에서는 관리자 권한, Unix에서는 chmod/sudo를 확인하세요.",
+  },
+  {
+    pattern: /EADDRINUSE/i,
+    hint: "포트가 이미 사용 중입니다. lsof -i :{port} 또는 netstat -ano | findstr :{port}로 확인 후 프로세스를 종료하세요.",
+  },
+  {
+    pattern: /ERR_MODULE_NOT_FOUND|Cannot find module/i,
+    hint: "모듈을 찾을 수 없습니다. npm install을 실행하거나, import 경로에 .mjs/.js 확장자를 명시하세요.",
+  },
+  {
+    pattern: /ETARGET|ERR_INVALID_PACKAGE_TARGET/i,
+    hint: "패키지 버전 해석 실패. package.json의 exports 필드 또는 의존성 버전을 확인하세요.",
+  },
+  {
+    pattern: /npm ERR! code E40[134]/i,
+    hint: "npm 인증 오류. npm login 또는 .npmrc 토큰을 확인하세요.",
+  },
+
+  // Git
+  {
+    pattern: /fatal: not a git repository/i,
+    hint: "git 저장소가 아닙니다. git init 또는 올바른 디렉토리로 이동하세요.",
+  },
+  {
+    pattern: /merge conflict|CONFLICT.*Merge/i,
+    hint: "병합 충돌 발생. 충돌 파일을 수동 해결 후 git add + git commit 하세요.",
+  },
+  {
+    pattern: /rejected.*non-fast-forward/i,
+    hint: "원격에 새 커밋이 있습니다. git pull --rebase 후 다시 push하세요.",
+  },
+  {
+    pattern: /fatal: refusing to merge unrelated histories/i,
+    hint: "--allow-unrelated-histories 플래그가 필요할 수 있습니다.",
+  },
+
+  // Python
+  {
+    pattern: /ModuleNotFoundError/i,
+    hint: "Python 모듈 미설치. pip install 또는 가상환경 활성화를 확인하세요.",
+  },
+  {
+    pattern: /SyntaxError.*invalid syntax/i,
+    hint: "Python 문법 오류. Python 버전(2 vs 3) 호환성도 확인하세요.",
+  },
+
+  // Windows 특이
+  {
+    pattern: /is not recognized as an internal or external command/i,
+    hint: "명령어를 찾을 수 없습니다. PATH 환경변수를 확인하거나 절대 경로를 사용하세요.",
+  },
+  {
+    pattern: /execution policy/i,
+    hint: "PowerShell 실행 정책 제한. -ExecutionPolicy Bypass 플래그를 추가하세요.",
+  },
+  {
+    pattern: /The process cannot access the file because it is being used/i,
+    hint: "파일이 다른 프로세스에 의해 잠겨 있습니다. 해당 프로세스를 종료하거나 잠시 후 재시도하세요.",
+  },
+
+  // 일반
+  {
+    pattern: /timeout|timed out|ETIMEDOUT/i,
+    hint: "타임아웃 발생. 네트워크 상태를 확인하거나 timeout 값을 늘리세요.",
+  },
+  {
+    pattern: /out of memory|heap|ENOMEM/i,
+    hint: "메모리 부족. --max-old-space-size를 늘리거나 데이터 크기를 줄이세요.",
+  },
+  {
+    pattern: /ECONNREFUSED/i,
+    hint: "연결 거부. 대상 서버/서비스가 실행 중인지 확인하세요.",
+  },
+];
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function findHints(errorText) {
+  const hints = [];
+  for (const rule of ERROR_HINTS) {
+    if (rule.pattern.test(errorText)) {
+      hints.push(rule.hint);
+    }
+  }
+  return hints;
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  // tool_output 또는 error 필드에서 에러 텍스트 추출
+  const errorText = [
+    input.tool_output || "",
+    input.error || "",
+    input.tool_input?.command || "",
+    JSON.stringify(input.tool_result || ""),
+  ].join("\n");
+
+  const hints = findHints(errorText);
+  if (hints.length === 0) process.exit(0);
+
+  const toolName = input.tool_name || "Unknown";
+  const output = {
+    systemMessage:
+      `[error-context] ${toolName} 실패 — 해결 힌트:\n` +
+      hints.map((h) => `  → ${h}`).join("\n"),
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+try {
+  main();
+} catch {
+  process.exit(0);
+}

package/hooks/pipeline-stop.mjs

@@ -1,57 +1,81 @@
-#!/usr/bin/env node
-// hooks/pipeline-stop.mjs — 파이프라인 진행 중 세션 중단 시 지속 프롬프트 주입
-//
-// Claude Code의 Stop 이벤트에서 실행.
-// 비터미널 단계의 파이프라인이 있으면 "작업 계속" 프롬프트를 반환한다.
-
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { getPipelineStateDbPath } from '../hub/pipeline/state.mjs';
-
-const PROJECT_ROOT = fileURLToPath(new URL('..', import.meta.url));
-const HUB_DB_PATH = getPipelineStateDbPath(PROJECT_ROOT);
-const TERMINAL = new Set(['complete', 'failed']);
-
-async function getPipelineStopPrompt() {
-  if (!existsSync(HUB_DB_PATH)) return null;
-
-  try {
-    const { default: Database } = await import('better-sqlite3');
-    const { ensurePipelineTable, listPipelineStates } = await import(
-      join(process.env.CLAUDE_PLUGIN_ROOT || '.', 'hub', 'pipeline', 'state.mjs')
-    );
-
-    const db = new Database(HUB_DB_PATH, { readonly: true });
-    ensurePipelineTable(db);
-    const states = listPipelineStates(db);
-    db.close();
-
-    // 비터미널 단계의 활성 파이프라인 찾기
-    const active = states.filter((s) => !TERMINAL.has(s.phase));
-    if (active.length === 0) return null;
-
-    const lines = active.map((s) =>
-      `- 팀 ${s.team_name}: ${s.phase} 단계 (fix: ${s.fix_attempt}/${s.fix_max}, ralph: ${s.ralph_iteration}/${s.ralph_max})`
-    );
-
-    return `[tfx-multi 파이프라인 진행 중]
-활성 파이프라인이 있습니다:
-${lines.join('\n')}
-
-파이프라인을 이어서 진행하려면 /tfx-multi status 로 상태를 확인하세요.`;
-  } catch {
-    return null;
-  }
-}
-
-try {
-  const prompt = await getPipelineStopPrompt();
-  if (prompt) {
-    // hook 출력으로 지속 프롬프트 전달
-    console.log(prompt);
-  }
-} catch {
-  // stop 훅 실패는 무시
-}
+#!/usr/bin/env node
+// hooks/pipeline-stop.mjs — Stop 훅: 활성 파이프라인 감지 시 구조화 decision 반환
+//
+// Claude Code Stop 이벤트에서 실행.
+// 비터미널 단계의 파이프라인이 있으면 decision:"block" + reason으로 중단을 방지한다.
+// 파이프라인이 없으면 정상 종료를 허용한다.
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+let getPipelineStateDbPath;
+try {
+  const stateModule = await import("../hub/pipeline/state.mjs");
+  getPipelineStateDbPath = stateModule.getPipelineStateDbPath;
+} catch {
+  // hub/pipeline 모듈 없으면 훅 무동작
+  process.exit(0);
+}
+
+const PROJECT_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const HUB_DB_PATH = getPipelineStateDbPath(PROJECT_ROOT);
+const TERMINAL = new Set(["complete", "failed"]);
+
+async function checkActivePipelines() {
+  if (!existsSync(HUB_DB_PATH)) return [];
+
+  try {
+    const { default: Database } = await import("better-sqlite3");
+    const { ensurePipelineTable, listPipelineStates } = await import(
+      join(
+        process.env.CLAUDE_PLUGIN_ROOT || PROJECT_ROOT,
+        "hub",
+        "pipeline",
+        "state.mjs"
+      )
+    );
+
+    const db = new Database(HUB_DB_PATH, { readonly: true });
+    ensurePipelineTable(db);
+    const states = listPipelineStates(db);
+    db.close();
+
+    return states.filter((s) => !TERMINAL.has(s.phase));
+  } catch {
+    return [];
+  }
+}
+
+try {
+  const active = await checkActivePipelines();
+
+  if (active.length === 0) {
+    // 활성 파이프라인 없음 → 정상 종료 허용
+    process.exit(0);
+  }
+
+  // 활성 파이프라인 발견 → 구조화 decision으로 block
+  const lines = active.map(
+    (s) =>
+      `  - 팀 ${s.team_name}: ${s.phase} 단계 (fix: ${s.fix_attempt}/${s.fix_max}, ralph: ${s.ralph_iteration}/${s.ralph_max})`
+  );
+
+  const reason =
+    `[tfx-multi 파이프라인 진행 중]\n` +
+    `활성 파이프라인 ${active.length}개가 아직 완료되지 않았습니다:\n` +
+    `${lines.join("\n")}\n\n` +
+    `파이프라인을 이어서 진행하려면 /tfx-multi status 로 상태를 확인하세요.\n` +
+    `강제 종료하려면 /tfx-multi cancel 을 먼저 실행하세요.`;
+
+  // 구조화된 Stop hook 출력: decision + reason
+  const output = {
+    decision: "block",
+    reason,
+  };
+
+  process.stdout.write(JSON.stringify(output));
+} catch {
+  // 훅 실패 시 종료 허용
+  process.exit(0);
+}

package/hooks/safety-guard.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// hooks/safety-guard.mjs — PreToolUse:Bash 훅
+//
+// 위험한 Bash 명령을 사전 차단(exit 2)하거나 경고(additionalContext)한다.
+// hooks.json에서 `if: "Bash(*)"` 필터와 함께 사용.
+//
+// 차단 레벨:
+//   BLOCK (exit 2)  — 복구 불가능한 파괴적 명령
+//   WARN  (allow + context) — 주의가 필요한 명령
+
+import { readFileSync } from "node:fs";
+
+// ── 차단 규칙 ──────────────────────────────────────────────
+const BLOCK_RULES = [
+  { pattern: /\brm\s+(-[^\s]*)?-rf?\s+[/~](?!\S*node_modules)/i, reason: "루트/홈 디렉토리 rm -rf 차단" },
+  { pattern: /\brm\s+(-[^\s]*)?-rf?\s+\.\s*$/i, reason: "현재 디렉토리 rm -rf . 차단" },
+  { pattern: /\bgit\s+push\s+.*--force\s+.*\b(main|master)\b/i, reason: "main/master force push 차단" },
+  { pattern: /\bgit\s+push\s+--force\s*$/i, reason: "대상 미지정 force push 차단" },
+  { pattern: /\bgit\s+reset\s+--hard\s+origin\//i, reason: "remote reset --hard 차단 — 로컬 작업 소실 위험" },
+  { pattern: /\bdrop\s+(table|database|schema)\b/i, reason: "SQL DROP 차단" },
+  { pattern: /\btruncate\s+table\b/i, reason: "SQL TRUNCATE 차단" },
+  { pattern: /\bformat\s+[a-z]:/i, reason: "디스크 포맷 차단" },
+  { pattern: /\b(del|rmdir)\s+\/[sq]\b/i, reason: "Windows 재귀 삭제 차단" },
+  { pattern: /\bgit\s+clean\s+.*-fd/i, reason: "git clean -fd 차단 — 추적되지 않은 파일 소실 위험" },
+];
+
+// ── 경고 규칙 ──────────────────────────────────────────────
+const WARN_RULES = [
+  { pattern: /\bgit\s+push\b(?!.*--force)/i, warn: "git push 감지. 원격 저장소에 반영됩니다." },
+  { pattern: /\bgit\s+rebase\b/i, warn: "git rebase 감지. 커밋 히스토리가 변경됩니다." },
+  { pattern: /\bgit\s+branch\s+-[dD]\b/i, warn: "브랜치 삭제 감지." },
+  { pattern: /\bnpm\s+publish\b/i, warn: "npm publish 감지. 공개 레지스트리에 배포됩니다." },
+  { pattern: /\brm\s+(-[^\s]*)?-rf?\s/i, warn: "재귀 삭제 감지. 대상을 확인하세요." },
+  { pattern: /--no-verify\b/i, warn: "--no-verify 감지. 훅 건너뛰기는 권장하지 않습니다." },
+  { pattern: /\bchmod\s+777\b/i, warn: "chmod 777 감지. 보안 위험." },
+  { pattern: /\bcurl\s.*\|\s*(bash|sh)\b/i, warn: "curl | sh 감지. 원격 스크립트 실행 주의." },
+];
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  if (input.tool_name !== "Bash") process.exit(0);
+
+  const command = (input.tool_input?.command || "").trim();
+  if (!command) process.exit(0);
+
+  // 1. BLOCK 체크 — exit 2로 차단
+  for (const rule of BLOCK_RULES) {
+    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);
+    }
+  }
+
+  // 2. WARN 체크 — allow + additionalContext
+  const warnings = [];
+  for (const rule of WARN_RULES) {
+    if (rule.pattern.test(command)) {
+      warnings.push(rule.warn);
+    }
+  }
+
+  if (warnings.length > 0) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        additionalContext:
+          `[safety-guard] ⚠ ${warnings.join(" | ")}\n` +
+          `명령어: ${command.slice(0, 200)}`,
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  }
+
+  // 3. 안전한 명령 → 통과
+  process.exit(0);
+}
+
+try {
+  main();
+} catch {
+  // 훅 실패 시 블로킹하지 않음
+  process.exit(0);
+}

package/hooks/subagent-verifier.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// hooks/subagent-verifier.mjs — SubagentStop 훅
+//
+// 서브에이전트 완료 시 결과 품질을 체크한다:
+//   - 빈 결과 감지 → 재시도 제안
+//   - 에러 종료 감지 → 원인 분석 컨텍스트 주입
+//   - 과도한 토큰 사용 감지 → 효율성 알림
+
+import { readFileSync } from "node:fs";
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  const agentType = input.agent_type || input.subagent_type || "unknown";
+  const result = input.tool_output || input.result || "";
+  const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+
+  const issues = [];
+
+  // 1. 빈 결과 체크
+  if (!resultStr.trim() || resultStr.trim().length < 20) {
+    issues.push(
+      `서브에이전트(${agentType})가 거의 빈 결과를 반환했습니다. ` +
+        "프롬프트를 더 구체적으로 작성하거나, 다른 subagent_type을 시도하세요."
+    );
+  }
+
+  // 2. 에러 키워드 감지
+  const errorPatterns = [
+    /error:|exception:|traceback|failed to|fatal:/i,
+    /❌|FAILED|ERROR/,
+  ];
+  const hasError = errorPatterns.some((p) => p.test(resultStr));
+  if (hasError && resultStr.length > 50) {
+    issues.push(
+      `서브에이전트(${agentType}) 결과에 에러 신호가 감지되었습니다. ` +
+        "결과를 검토하고, 필요 시 다른 접근 방식을 사용하세요."
+    );
+  }
+
+  // 3. 결과가 너무 길면 요약 필요 알림
+  if (resultStr.length > 15000) {
+    issues.push(
+      `서브에이전트(${agentType}) 결과가 ${Math.round(resultStr.length / 1000)}K 자입니다. ` +
+        "핵심만 추출하여 컨텍스트 윈도우를 절약하세요."
+    );
+  }
+
+  if (issues.length === 0) process.exit(0);
+
+  const output = {
+    systemMessage:
+      `[subagent-verifier] ${agentType} 완료 — 주의사항:\n` +
+      issues.map((i) => `  → ${i}`).join("\n"),
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+try {
+  main();
+} catch {
+  process.exit(0);
+}

package/package.json

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