triflux 10.3.4 → 10.7.0

package/scripts/doctor-diagnose.mjs

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+// scripts/doctor-diagnose.mjs — 진단 번들 생성기
+//
+// spawn-trace JSONL + process report + hook timing + spawn stats + system info
+// → ~/.triflux/diagnostics/diag-{timestamp}.zip (PowerShell Compress-Archive)
+
+import { execFileSync, execSync } from "node:child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { arch, cpus, freemem, homedir, platform, release, totalmem } from "node:os";
+import { join } from "node:path";
+
+const TRIFLUX_DIR = join(homedir(), ".triflux");
+const LOGS_DIR = join(TRIFLUX_DIR, "logs");
+const DIAG_DIR = join(TRIFLUX_DIR, "diagnostics");
+const ONE_HOUR_MS = 60 * 60 * 1000;
+
+function collectSpawnTraces(cutoffMs = ONE_HOUR_MS) {
+  if (!existsSync(LOGS_DIR)) return [];
+
+  const now = Date.now();
+  const entries = [];
+
+  for (const file of readdirSync(LOGS_DIR)) {
+    if (!file.startsWith("spawn-trace-") || !file.endsWith(".jsonl")) continue;
+    const lines = readFileSync(join(LOGS_DIR, file), "utf8")
+      .split("\n")
+      .filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        const ts = new Date(entry.ts).getTime();
+        if (now - ts <= cutoffMs) entries.push(entry);
+      } catch { /* skip malformed */ }
+    }
+  }
+
+  return entries;
+}
+
+function computeSpawnStats(traces) {
+  if (traces.length === 0) {
+    return { total: 0, peakRatePerSec: 0, maxConcurrent: 0, blocked: 0 };
+  }
+
+  const spawnEvents = traces.filter((t) => t.event === "spawn");
+  const exitEvents = traces.filter((t) => t.event === "exit" || t.event === "error");
+  const blockedEvents = traces.filter((t) => t.event === "blocked");
+
+  // peak rate per second
+  let peakRate = 0;
+  for (const evt of spawnEvents) {
+    const ts = new Date(evt.ts).getTime();
+    const windowEnd = ts + 1000;
+    const inWindow = spawnEvents.filter((e) => {
+      const t = new Date(e.ts).getTime();
+      return t >= ts && t < windowEnd;
+    }).length;
+    if (inWindow > peakRate) peakRate = inWindow;
+  }
+
+  // max concurrent (spawn without matching exit)
+  const events = [
+    ...spawnEvents.map((e) => ({ ts: new Date(e.ts).getTime(), delta: 1 })),
+    ...exitEvents.map((e) => ({ ts: new Date(e.ts).getTime(), delta: -1 })),
+  ].sort((a, b) => a.ts - b.ts);
+
+  let concurrent = 0;
+  let maxConcurrent = 0;
+  for (const e of events) {
+    concurrent += e.delta;
+    if (concurrent > maxConcurrent) maxConcurrent = concurrent;
+  }
+
+  return {
+    total: spawnEvents.length,
+    peakRatePerSec: peakRate,
+    maxConcurrent,
+    blocked: blockedEvents.length,
+  };
+}
+
+function collectSystemInfo() {
+  const info = {
+    platform: platform(),
+    release: release(),
+    arch: arch(),
+    nodeVersion: process.version,
+    cpuModel: cpus()[0]?.model ?? "unknown",
+    cpuCores: cpus().length,
+    totalMemMB: Math.round(totalmem() / 1024 / 1024),
+    freeMemMB: Math.round(freemem() / 1024 / 1024),
+  };
+
+  // Windows Terminal version
+  try {
+    const wtVer = execSync("wt.exe --version 2>&1", {
+      encoding: "utf8",
+      timeout: 5000,
+      windowsHide: true,
+    }).trim();
+    info.wtVersion = wtVer;
+  } catch {
+    info.wtVersion = "not found";
+  }
+
+  // triflux version
+  try {
+    const pkgPath = join(homedir(), ".triflux", "package.json");
+    if (existsSync(pkgPath)) {
+      info.trifluxVersion = JSON.parse(readFileSync(pkgPath, "utf8")).version;
+    }
+  } catch { /* ignore */ }
+
+  return info;
+}
+
+function collectHookTimings() {
+  // hook-orchestrator 또는 session-start-fast 로그에서 타이밍 추출
+  const hookLogDir = join(TRIFLUX_DIR, "logs");
+  if (!existsSync(hookLogDir)) return [];
+
+  const timings = [];
+  for (const file of readdirSync(hookLogDir)) {
+    if (!file.startsWith("hook-") || !file.endsWith(".jsonl")) continue;
+    try {
+      const lines = readFileSync(join(hookLogDir, file), "utf8")
+        .split("\n")
+        .filter(Boolean);
+      const now = Date.now();
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          const ts = new Date(entry.ts || entry.time).getTime();
+          if (now - ts <= ONE_HOUR_MS) timings.push(entry);
+        } catch { /* skip */ }
+      }
+    } catch { /* skip */ }
+  }
+  return timings;
+}
+
+function generateSummary(stats, sysInfo, hookTimings, traceCount) {
+  const lines = [
+    "=== triflux diagnostic summary ===",
+    `generated: ${new Date().toISOString()}`,
+    "",
+    "--- System ---",
+    `OS:       ${sysInfo.platform} ${sysInfo.release} (${sysInfo.arch})`,
+    `Node:     ${sysInfo.nodeVersion}`,
+    `CPU:      ${sysInfo.cpuModel} (${sysInfo.cpuCores} cores)`,
+    `RAM:      ${sysInfo.freeMemMB}MB free / ${sysInfo.totalMemMB}MB total`,
+    `WT:       ${sysInfo.wtVersion}`,
+    `triflux:  ${sysInfo.trifluxVersion || "unknown"}`,
+    "",
+    "--- Spawn Stats (last 1h) ---",
+    `total spawns:      ${stats.total}`,
+    `peak rate/sec:     ${stats.peakRatePerSec}`,
+    `max concurrent:    ${stats.maxConcurrent}`,
+    `blocked:           ${stats.blocked}`,
+    `trace entries:     ${traceCount}`,
+    "",
+    "--- Hook Timings (last 1h) ---",
+  ];
+
+  if (hookTimings.length === 0) {
+    lines.push("no hook timing data found");
+  } else {
+    for (const t of hookTimings.slice(-20)) {
+      const hook = t.hook || t.msg || "unknown";
+      const dur = t.dur_ms ?? t.duration_ms ?? "?";
+      lines.push(`  ${hook}: ${dur}ms`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export async function diagnose({ json = false } = {}) {
+  mkdirSync(DIAG_DIR, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const bundleDir = join(DIAG_DIR, `diag-${timestamp}`);
+  mkdirSync(bundleDir, { recursive: true });
+
+  // 1. spawn-trace JSONL
+  const traces = collectSpawnTraces();
+  writeFileSync(
+    join(bundleDir, "blackbox.jsonl"),
+    traces.map((t) => JSON.stringify(t)).join("\n") + "\n",
+  );
+
+  // 2. process report
+  try {
+    const reportPath = process.report.writeReport(join(bundleDir, "process-report.json"));
+    // writeReport returns the path it wrote to
+    if (reportPath && reportPath !== join(bundleDir, "process-report.json")) {
+      // move if written elsewhere
+      const { renameSync } = await import("node:fs");
+      try { renameSync(reportPath, join(bundleDir, "process-report.json")); } catch { /* ignore */ }
+    }
+  } catch {
+    writeFileSync(join(bundleDir, "process-report.json"), JSON.stringify({ error: "report generation failed" }));
+  }
+
+  // 3. hook timings
+  const hookTimings = collectHookTimings();
+  writeFileSync(
+    join(bundleDir, "hook-timings.jsonl"),
+    hookTimings.map((t) => JSON.stringify(t)).join("\n") + "\n",
+  );
+
+  // 4. spawn stats
+  const stats = computeSpawnStats(traces);
+  writeFileSync(join(bundleDir, "spawn-stats.json"), JSON.stringify(stats, null, 2));
+
+  // 5. system info
+  const sysInfo = collectSystemInfo();
+  writeFileSync(join(bundleDir, "system-info.json"), JSON.stringify(sysInfo, null, 2));
+
+  // 6. summary
+  const summary = generateSummary(stats, sysInfo, hookTimings, traces.length);
+  writeFileSync(join(bundleDir, "summary.txt"), summary);
+
+  // 7. zip via PowerShell Compress-Archive
+  const zipPath = `${bundleDir}.zip`;
+  try {
+    execFileSync("powershell.exe", [
+      "-NoProfile", "-NonInteractive", "-Command",
+      `Compress-Archive -Path '${bundleDir}\\*' -DestinationPath '${zipPath}' -Force`,
+    ], { timeout: 30000, windowsHide: true });
+  } catch (err) {
+    // fallback: leave the directory unzipped
+    if (json) {
+      return { ok: false, bundleDir, error: `zip failed: ${err.message}` };
+    }
+    return { ok: false, bundleDir, zipPath: null, error: err.message };
+  }
+
+  // cleanup temp directory
+  try {
+    const { rmSync } = await import("node:fs");
+    rmSync(bundleDir, { recursive: true, force: true });
+  } catch { /* leave it */ }
+
+  const result = {
+    ok: true,
+    zipPath,
+    stats,
+    sysInfo,
+    traceCount: traces.length,
+    hookTimingCount: hookTimings.length,
+  };
+
+  if (json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  }
+
+  return result;
+}
+
+// CLI direct execution
+const isMain =
+  import.meta.url === `file:///${process.argv[1]?.replace(/\\/g, "/")}` ||
+  import.meta.url === `file://${process.argv[1]?.replace(/\\/g, "/")}`;
+
+if (isMain) {
+  const json = process.argv.includes("--json");
+  const result = await diagnose({ json });
+  if (!json) {
+    if (result.ok) {
+      console.log(`\n  진단 번들 생성: ${result.zipPath}`);
+      console.log(`  spawn 이벤트: ${result.traceCount}건, 훅 타이밍: ${result.hookTimingCount}건\n`);
+    } else {
+      console.error(`  진단 실패: ${result.error}`);
+      process.exit(1);
+    }
+  }
+}

package/scripts/gen-skill-docs.mjs

@@ -33,7 +33,9 @@ function collectSkillTemplateFiles(skillsDir) {
     .filter((file) => file.endsWith("SKILL.md.tmpl"))
     .filter(
       (file) =>
-        !relative(skillsDir, file).replace(/\\/g, "/").startsWith("_templates/"),
+        !relative(skillsDir, file)
+          .replace(/\\/g, "/")
+          .startsWith("_templates/"),
     )
     .sort((left, right) => left.localeCompare(right));
 }
@@ -78,7 +80,10 @@ export function generateSkillDocs({
     generated.push({
       templatePath,
       outputPath,
-      relativeTemplatePath: relative(skillsDir, templatePath).replace(/\\/g, "/"),
+      relativeTemplatePath: relative(skillsDir, templatePath).replace(
+        /\\/g,
+        "/",
+      ),
       context,
       rendered,
     });

package/scripts/gen-skill-manifest.mjs

@@ -23,7 +23,8 @@ function extractManifest(skillMdContent) {
   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;
+  if (data.internal === true || data.internal === "true")
+    manifest.internal = true;
 
   return manifest;
 }

package/scripts/headless-guard.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+
 /**
  * headless-guard.mjs — PreToolUse 훅 (상시 활성 auto-route)
  *
@@ -24,11 +25,11 @@
  * 성능: psmux 감지 결과를 5분간 캐시 ($TMPDIR/tfx-psmux-check.json)
  */
 
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { nudge, deny } from "./lib/hook-utils.mjs";
+import { deny, nudge } from "./lib/hook-utils.mjs";
 import { probePsmuxSupport } from "./lib/psmux-info.mjs";
 
 const CACHE_FILE = join(tmpdir(), "tfx-psmux-check.json");
@@ -37,8 +38,8 @@ const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
 // ── tfx-multi 상태 관리 (A+B) ──
 const MULTI_STATE_FILE = join(tmpdir(), "tfx-multi-state.json");
 const MULTI_EXPIRE_MS = 30 * 60 * 1000; // 30분 자동 만료
-const GATE_THRESHOLD = 2;   // A: dispatch 전 허용할 Agent 호출 수
-const NUDGE_THRESHOLD = 4;  // B: dispatch 후 nudge 트리거 횟수
+const GATE_THRESHOLD = 2; // A: dispatch 전 허용할 Agent 호출 수
+const NUDGE_THRESHOLD = 4; // B: dispatch 후 nudge 트리거 횟수
 
 function readMultiState() {
   try {
@@ -47,17 +48,25 @@ function readMultiState() {
     if (!state.active) return null;
     // 자동 만료
     if (Date.now() - state.activatedAt > MULTI_EXPIRE_MS) {
-      try { unlinkSync(MULTI_STATE_FILE); } catch { /* ignore */ }
+      try {
+        unlinkSync(MULTI_STATE_FILE);
+      } catch {
+        /* ignore */
+      }
       return null;
     }
     return state;
-  } catch { return null; }
+  } catch {
+    return null;
+  }
 }
 
 function writeMultiState(state) {
   try {
     writeFileSync(MULTI_STATE_FILE, JSON.stringify(state));
-  } catch { /* ignore */ }
+  } catch {
+    /* ignore */
+  }
 }
 
 function isPsmuxInstalled() {
@@ -69,15 +78,27 @@ function isPsmuxInstalled() {
       if (age >= 0 && age < CACHE_TTL_MS) return cache.ok;
       // age < 0 → 미래 ts (오염) → 캐시 무시하고 재검사
     }
-  } catch { /* cache miss */ }
+  } catch {
+    /* cache miss */
+  }
 
   const probe = probePsmuxSupport({ execFileSyncFn: execFileSync });
   const ok = probe.ok;
 
   // 캐시 저장
   try {
-    writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), ok, version: probe.version, missingCommands: probe.missingCommands }));
-  } catch { /* ignore */ }
+    writeFileSync(
+      CACHE_FILE,
+      JSON.stringify({
+        ts: Date.now(),
+        ok,
+        version: probe.version,
+        missingCommands: probe.missingCommands,
+      }),
+    );
+  } catch {
+    /* ignore */
+  }
 
   return ok;
 }
@@ -116,7 +137,7 @@ function parseRouteCommand(cmd) {
   // v3: 원본 명령에서 추가 플래그 추출
   const flags = {};
   const afterPrompt = cmd.replace(/'.+?'/gs, "").replace(/".+?"/gs, "");
-  const timeoutMatch = afterPrompt.match(/(?:^|\s)(\d{2,4})(?:\s|$)/);  // 4번째 인자 (timeout)
+  const timeoutMatch = afterPrompt.match(/(?:^|\s)(\d{2,4})(?:\s|$)/); // 4번째 인자 (timeout)
   if (timeoutMatch) flags.timeout = parseInt(timeoutMatch[1], 10);
 
   // 환경변수 기반 글로벌 플래그
@@ -127,18 +148,20 @@ function parseRouteCommand(cmd) {
 }
 
 function autoRoute(updatedCommand, reason) {
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: "PreToolUse",
-      updatedInput: { command: updatedCommand },
-      additionalContext: reason,
-    },
-  }));
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        updatedInput: { command: updatedCommand },
+        additionalContext: reason,
+      },
+    }),
+  );
   process.exit(0);
 }
 
 const HEADLESS_FALLBACK_COMMAND =
-  'Bash("tfx multi --teammate-mode headless --assign \'codex:prompt:role\' ...")';
+  "Bash(\"tfx multi --teammate-mode headless --assign 'codex:prompt:role' ...\")";
 const DIRECT_CLI_BYPASS_HINT =
   "로컬 디버깅이 목적이면 TFX_ALLOW_DIRECT_CLI=1로 일시 우회할 수 있습니다.";
 
@@ -153,7 +176,7 @@ async function main() {
   for await (const chunk of process.stdin) raw += chunk;
 
   if (!raw?.trim()) {
-    console.error('[headless-guard] stdin이 비어있습니다 — 기본 허용');
+    console.error("[headless-guard] stdin이 비어있습니다 — 기본 허용");
     process.exit(0);
   }
 
@@ -192,8 +215,8 @@ async function main() {
       if (/\b(codex\s+exec|gemini\s+(-p|--prompt))\b/i.test(cmd)) {
         deny(
           "[headless-guard] psmux send-keys/split-window에 codex/gemini 직접 호출이 포함되어 있습니다. " +
-          `승인된 경로: ${HEADLESS_FALLBACK_COMMAND}. ` +
-          DIRECT_CLI_BYPASS_HINT,
+            `승인된 경로: ${HEADLESS_FALLBACK_COMMAND}. ` +
+            DIRECT_CLI_BYPASS_HINT,
         );
       }
       process.exit(0);
@@ -205,7 +228,7 @@ async function main() {
     // #37 Bug4: gh/git 명령은 본문에 codex/gemini 문자열이 있어도 차단하지 않음
     const SAFE_CMD_RE = /^\s*(?:[\w_]+=\S+\s+)*\s*(gh|git)\b/;
     const cmdParts = cmd.split(/\s*(?:&&|\|\||\||;)\s*/);
-    let hasDirectCli = cmdParts.some(part => {
+    let hasDirectCli = cmdParts.some((part) => {
       // gh/git 세그먼트는 건너뜀 (이슈 본문/커밋 메시지 내 codex/gemini 언급은 정상)
       if (SAFE_CMD_RE.test(part)) return false;
       // 1단계: env var prefix 제거 (FOO=bar ...)
@@ -214,24 +237,31 @@ async function main() {
         .replace(/^\s*(?:[\w_]+=\S+\s+)*/, "")
         .replace(/^\s*(?:env|command|nohup)\s+/, "")
         .replace(/^\s*timeout\s+\d+\s+/, "")
-        .replace(/^\s*(?:bash|sh)\s+(?:-\w+\s+)*(?:"([^"]*)".*|'([^']*)'.*)/i, "$1$2")
+        .replace(
+          /^\s*(?:bash|sh)\s+(?:-\w+\s+)*(?:"([^"]*)".*|'([^']*)'.*)/i,
+          "$1$2",
+        )
         .replace(/^\s*(?:\/[\w./+-]+\/)(codex|gemini)\b/, " $1");
-      return /^\s*codex\b.*\bexec\b/i.test(stripped) || /^\s*gemini\s+(-p|--prompt)\b/i.test(stripped);
+      return (
+        /^\s*codex\b.*\bexec\b/i.test(stripped) ||
+        /^\s*gemini\s+(-p|--prompt)\b/i.test(stripped)
+      );
     });
     // 2차 휴리스틱: 1차 세그먼트 검사를 통과한 간접 실행 패턴 탐지
     // full AST 파서 대신 현실적 위협 벡터만 커버 — eval, subshell, variable 확장
     // 2차 휴리스틱: 간접 실행 패턴 탐지 (eval, subshell, variable 확장)
     if (!hasDirectCli) {
-      const isAllSafeCmd = cmdParts.every(p => SAFE_CMD_RE.test(p));
+      const isAllSafeCmd = cmdParts.every((p) => SAFE_CMD_RE.test(p));
       if (isAllSafeCmd) {
         // gh/git 전용: $(codex exec ...) 직접 명령 치환만 차단
         // $(cat <<'EOF'\n...codex exec text...\nEOF) 같은 heredoc 텍스트는 허용
-        hasDirectCli = /\$\(\s*(codex\s+exec|gemini\s+(-p|--prompt))\b/i.test(cmd);
+        hasDirectCli = /\$\(\s*(codex\s+exec|gemini\s+(-p|--prompt))\b/i.test(
+          cmd,
+        );
       } else {
-        hasDirectCli = (
+        hasDirectCli =
           /\beval\b.*\b(codex\s+exec|gemini\s+(-p|--prompt))\b/i.test(cmd) ||
-          /\$[({].*\b(codex\s+exec|gemini\s+(-p|--prompt))\b/i.test(cmd)
-        );
+          /\$[({].*\b(codex\s+exec|gemini\s+(-p|--prompt))\b/i.test(cmd);
       }
     }
 
@@ -242,15 +272,17 @@ async function main() {
       }
       deny(
         "[headless-guard] codex/gemini 직접 호출(파이프/복합 명령 포함)은 headless-guard에서 차단됩니다. " +
-        `승인된 경로: ${HEADLESS_FALLBACK_COMMAND}. ` +
-        DIRECT_CLI_BYPASS_HINT,
+          `승인된 경로: ${HEADLESS_FALLBACK_COMMAND}. ` +
+          DIRECT_CLI_BYPASS_HINT,
       );
     }
 
     // tfx-route.sh 실행만 감지: 명령이 bash로 시작할 때만 (커밋 메시지/echo 등 무시)
     if (/^\s*bash\s+.*tfx-route\.sh\s/.test(cmd)) {
       // --async, --job-status, --job-result, --job-wait는 tfx-route.sh 내부 플래그 → 통과
-      if (/tfx-route\.sh\s+--(async|job-status|job-result|job-wait)\b/.test(cmd)) {
+      if (
+        /tfx-route\.sh\s+--(async|job-status|job-result|job-wait)\b/.test(cmd)
+      ) {
         process.exit(0);
       }
 
@@ -261,7 +293,7 @@ async function main() {
         if (!process.env.TFX_FORCE_HEADLESS) {
           const isMultiWorker = /\s--(multi|parallel)\b/.test(cmd);
           if (!isMultiWorker) {
-            process.exit(0);  // 원본 tfx-route.sh 명령 그대로 통과
+            process.exit(0); // 원본 tfx-route.sh 명령 그대로 통과
           }
         }
 
@@ -272,10 +304,11 @@ async function main() {
         // v3: 플래그 빌더 — 하드코딩 제거, 원본 의도 보존
         const parts = ["tfx multi --teammate-mode headless"];
         if (!f.noAutoAttach) parts.push("--auto-attach");
-        if (!f.noAutoAttach) parts.push("--dashboard");  // 워커 요약 스플릿이 기본
+        if (!f.noAutoAttach) parts.push("--dashboard"); // 워커 요약 스플릿이 기본
         if (f.verbose) parts.push("--verbose");
         parts.push(`--assign '${parsed.agent}:${safePrompt}:${parsed.agent}'`);
-        if (parsed.mcp && VALID_MCP.has(parsed.mcp)) parts.push(`--mcp-profile ${parsed.mcp}`);
+        if (parsed.mcp && VALID_MCP.has(parsed.mcp))
+          parts.push(`--mcp-profile ${parsed.mcp}`);
         parts.push(`--timeout ${f.timeout || 600}`);
 
         const builtCmd = parts.join(" ");
@@ -286,7 +319,7 @@ async function main() {
       }
       deny(
         "[headless-guard] tfx-route.sh를 headless로 변환 실패. " +
-        'Bash("tfx multi --teammate-mode headless --assign \'cli:prompt:role\' ...") 형식을 사용하세요.',
+          "Bash(\"tfx multi --teammate-mode headless --assign 'cli:prompt:role' ...\") 형식을 사용하세요.",
       );
     }
   }
@@ -307,24 +340,27 @@ async function main() {
       if (multiState.nativeWorkCalls > GATE_THRESHOLD) {
         deny(
           `[headless-guard] tfx-multi gate: ${toolName} 호출 ${multiState.nativeWorkCalls}회 — headless dispatch 먼저 하세요.\n` +
-          'Bash("tfx multi --teammate-mode headless --auto-attach --dashboard --assign \'codex:프롬프트:역할\' --timeout 600")',
+            "Bash(\"tfx multi --teammate-mode headless --auto-attach --dashboard --assign 'codex:프롬프트:역할' --timeout 600\")",
         );
       }
 
       nudge(
         `[headless-guard] tfx-multi 활성 (${multiState.nativeWorkCalls}/${GATE_THRESHOLD}). ` +
-        "headless dispatch 후 작업을 시작하세요.",
+          "headless dispatch 후 작업을 시작하세요.",
       );
     }
 
     // H3 fix: Agent gate와 동일하게 NUDGE_THRESHOLD 기반 주기적 nudge
-    multiState.nativeWorkCallsSinceDispatch = (multiState.nativeWorkCallsSinceDispatch || 0) + 1;
+    multiState.nativeWorkCallsSinceDispatch =
+      (multiState.nativeWorkCallsSinceDispatch || 0) + 1;
     writeMultiState(multiState);
 
     if (multiState.nativeWorkCallsSinceDispatch >= NUDGE_THRESHOLD) {
       multiState.nativeWorkCallsSinceDispatch = 0;
       writeMultiState(multiState);
-      nudge("[headless-guard] nudge: headless 워커가 코드 수정 중. 직접 수정은 충돌 위험.");
+      nudge(
+        "[headless-guard] nudge: headless 워커가 코드 수정 중. 직접 수정은 충돌 위험.",
+      );
     }
     process.exit(0); // threshold 미만이면 조용히 통과
   }
@@ -333,7 +369,8 @@ async function main() {
   if (toolName === "Agent") {
     const subType = (toolInput.subagent_type || "").toLowerCase();
     const NATIVE_TYPES = new Set(["explore", "plan", "general-purpose", ""]);
-    const isNative = NATIVE_TYPES.has(subType) || subType.startsWith("oh-my-claudecode:");
+    const isNative =
+      NATIVE_TYPES.has(subType) || subType.startsWith("oh-my-claudecode:");
 
     // ── A+B: tfx-multi 상태 기반 처리 ──
     const multiState = readMultiState();
@@ -346,17 +383,18 @@ async function main() {
         if (multiState.nativeWorkCalls > GATE_THRESHOLD) {
           deny(
             `[headless-guard] tfx-multi gate: Agent(${subType || "default"}) 호출 ${multiState.nativeWorkCalls}회 — headless에 먼저 dispatch하세요.\n` +
-            'Bash("tfx multi --teammate-mode headless --auto-attach --dashboard --assign \'codex:프롬프트:역할\' --timeout 600")',
+              "Bash(\"tfx multi --teammate-mode headless --auto-attach --dashboard --assign 'codex:프롬프트:역할' --timeout 600\")",
           );
         }
         // 허용 범위 내 → 경고 + 통과
         nudge(
           `[headless-guard] tfx-multi 활성 (${multiState.nativeWorkCalls}/${GATE_THRESHOLD}). ` +
-          "headless dispatch 후 작업을 시작하세요.",
+            "headless dispatch 후 작업을 시작하세요.",
         );
       } else {
         // ── B: nudge — dispatch 후, 네이티브 드리프트 감지 ──
-        multiState.nativeWorkCallsSinceDispatch = (multiState.nativeWorkCallsSinceDispatch || 0) + 1;
+        multiState.nativeWorkCallsSinceDispatch =
+          (multiState.nativeWorkCallsSinceDispatch || 0) + 1;
         writeMultiState(multiState);
 
         if (multiState.nativeWorkCallsSinceDispatch >= NUDGE_THRESHOLD) {
@@ -364,7 +402,7 @@ async function main() {
           writeMultiState(multiState);
           nudge(
             "[headless-guard] nudge: headless 워커가 실행 중입니다. " +
-            "결과를 기다리거나 추가 --assign으로 위임하세요.",
+              "결과를 기다리거나 추가 --assign으로 위임하세요.",
           );
         }
       }
@@ -388,8 +426,8 @@ async function main() {
     if (cliPatterns.some((p) => p.test(combined))) {
       deny(
         "[headless-guard] Codex/Gemini를 Agent()로 래핑하지 마세요. " +
-        `승인된 경로: ${HEADLESS_FALLBACK_COMMAND}. ` +
-        DIRECT_CLI_BYPASS_HINT,
+          `승인된 경로: ${HEADLESS_FALLBACK_COMMAND}. ` +
+          DIRECT_CLI_BYPASS_HINT,
       );
     }
   }