triflux 10.9.18 → 10.9.19

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "triflux",
       "description": "Tri-CLI orchestrator for Claude Code. Routes tasks across Claude + Codex + Gemini with consensus intelligence, natural language routing, 42 skills, and cross-model review.",
-      "version": "10.9.18",
+      "version": "10.9.19",
       "author": {
         "name": "tellang"
       },
@@ -30,5 +30,5 @@
       ]
     }
   ],
-  "version": "10.9.18"
+  "version": "10.9.19"
 }

package/hooks/hook-orchestrator.mjs

@@ -21,7 +21,14 @@
 //   HOME / USERPROFILE    — ${HOME} 치환용
 
 import { execFile, execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -30,6 +37,13 @@ import { PLUGIN_ROOT } from "./lib/resolve-root.mjs";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const REGISTRY_PATH =
   process.env.TRIFLUX_HOOK_REGISTRY || join(__dirname, "hook-registry.json");
+const HOOK_CACHE_DIR =
+  process.env.TRIFLUX_HOOK_CACHE_DIR ||
+  join(tmpdir(), "triflux-hook-orchestrator-cache");
+const HOOK_CACHE_TTL_MS = Math.max(
+  0,
+  Number.parseInt(process.env.TRIFLUX_HOOK_CACHE_TTL_MS || "1500", 10) || 1500,
+);
 
 // ── stdin 읽기 ──────────────────────────────────────────────
 function readStdin() {
@@ -77,6 +91,57 @@ function matchesMatcher(hookMatcher, toolName, eventInput) {
   });
 }
 
+function shouldDedupePreToolUseBash(eventName, toolName) {
+  return eventName === "PreToolUse" && toolName === "Bash";
+}
+
+function buildHookCachePath(stdinData) {
+  const digest = createHash("sha1").update(stdinData).digest("hex");
+  return join(HOOK_CACHE_DIR, `pretool-bash-${digest}.json`);
+}
+
+function readHookCache(stdinData) {
+  if (HOOK_CACHE_TTL_MS <= 0) return null;
+
+  const cachePath = buildHookCachePath(stdinData);
+  if (!existsSync(cachePath)) return null;
+
+  try {
+    const cached = JSON.parse(readFileSync(cachePath, "utf8"));
+    const ageMs = Date.now() - Number(cached?.ts || 0);
+    if (!Number.isFinite(ageMs) || ageMs < 0 || ageMs > HOOK_CACHE_TTL_MS) {
+      unlinkSync(cachePath);
+      return null;
+    }
+    return cached;
+  } catch {
+    try {
+      unlinkSync(cachePath);
+    } catch {}
+    return null;
+  }
+}
+
+function writeHookCache(stdinData, payload) {
+  if (HOOK_CACHE_TTL_MS <= 0) return;
+
+  try {
+    mkdirSync(HOOK_CACHE_DIR, { recursive: true });
+    writeFileSync(
+      buildHookCachePath(stdinData),
+      JSON.stringify({ ts: Date.now(), ...payload }),
+      "utf8",
+    );
+  } catch {
+    // 캐시 실패는 훅 실행에 영향 주지 않음
+  }
+}
+
+function shouldShortCircuitPreToolUseBash(result) {
+  if (!result || result.code === 2) return true;
+  return result.code === 0 && Boolean(result.stdout?.trim());
+}
+
 // ── 단일 훅 실행 ────────────────────────────────────────────
 function executeHook(hook, stdinData) {
   const cmd = resolveCommand(hook.command);
@@ -315,9 +380,23 @@ async function main() {
 
   if (!eventName) process.exit(0);
 
+  const dedupePreToolUseBash = shouldDedupePreToolUseBash(eventName, toolName);
+  if (dedupePreToolUseBash) {
+    const cached = readHookCache(stdinRaw);
+    if (cached?.stderr) process.stderr.write(cached.stderr);
+    if (cached?.blocked) process.exit(2);
+    if (cached?.mergedOutput) {
+      process.stdout.write(JSON.stringify(cached.mergedOutput));
+    }
+    if (cached) process.exit(0);
+  }
+
   // ── SessionStart fast-path ──
   // TRIFLUX_HOOK_FAST_PATH=false로 비활성화 가능 (rollback)
-  if (eventName === "SessionStart" && process.env.TRIFLUX_HOOK_FAST_PATH !== "false") {
+  if (
+    eventName === "SessionStart" &&
+    process.env.TRIFLUX_HOOK_FAST_PATH !== "false"
+  ) {
     try {
       const { execute } = await import("./session-start-fast.mjs");
       const result = await execute(stdinRaw);
@@ -328,7 +407,9 @@ async function main() {
 
       // external source 훅 (session-vault 등)은 기존 방식으로 실행
       const allHooks = registry.events.SessionStart || [];
-      const externalHooks = allHooks.filter((h) => h.enabled !== false && h.source !== "triflux");
+      const externalHooks = allHooks.filter(
+        (h) => h.enabled !== false && h.source !== "triflux",
+      );
       for (const hook of externalHooks) {
         const hookResult = executeHookAsync(hook, stdinRaw);
         hookResult.catch(() => {}); // fire-and-forget for external hooks
@@ -337,7 +418,9 @@ async function main() {
       process.exit(0);
     } catch (err) {
       // fast-path 실패 시 기존 방식으로 폴백
-      process.stderr.write(`[orchestrator] fast-path failed, falling back: ${err.message}\n`);
+      process.stderr.write(
+        `[orchestrator] fast-path failed, falling back: ${err.message}\n`,
+      );
     }
   }
 
@@ -366,35 +449,56 @@ async function main() {
 
   let mergedOutput = null;
   let blocked = false;
+  let blockingStderr = "";
 
-  for (const group of groups) {
-    if (blocked) break;
-
-    if (group.hooks.length === 1) {
-      // 단일 훅 — 기존 동기 실행
-      const result = executeHook(group.hooks[0], stdinRaw);
+  if (dedupePreToolUseBash) {
+    for (const hook of matched) {
+      const result = executeHook(hook, stdinRaw);
       if (result.code === 2) {
-        if (result.stderr) process.stderr.write(result.stderr);
+        blockingStderr = result.stderr || "";
+        if (blockingStderr) process.stderr.write(blockingStderr);
         blocked = true;
         break;
       }
       if (result.code === 0 && result.stdout.trim()) {
         mergedOutput = mergeOutputs(mergedOutput, result.stdout.trim());
       }
-    } else {
-      // 같은 priority 다중 훅 — 비동기 병렬 실행
-      const results = await Promise.all(
-        group.hooks.map((h) => executeHookAsync(h, stdinRaw)),
-      );
-      for (const result of results) {
+      if (shouldShortCircuitPreToolUseBash(result)) {
+        break;
+      }
+    }
+  } else {
+    for (const group of groups) {
+      if (blocked) break;
+
+      if (group.hooks.length === 1) {
+        // 단일 훅 — 기존 동기 실행
+        const result = executeHook(group.hooks[0], stdinRaw);
         if (result.code === 2) {
-          if (result.stderr) process.stderr.write(result.stderr);
+          blockingStderr = result.stderr || "";
+          if (blockingStderr) process.stderr.write(blockingStderr);
           blocked = true;
           break;
         }
         if (result.code === 0 && result.stdout.trim()) {
           mergedOutput = mergeOutputs(mergedOutput, result.stdout.trim());
         }
+      } else {
+        // 같은 priority 다중 훅 — 비동기 병렬 실행
+        const results = await Promise.all(
+          group.hooks.map((h) => executeHookAsync(h, stdinRaw)),
+        );
+        for (const result of results) {
+          if (result.code === 2) {
+            blockingStderr = result.stderr || "";
+            if (blockingStderr) process.stderr.write(blockingStderr);
+            blocked = true;
+            break;
+          }
+          if (result.code === 0 && result.stdout.trim()) {
+            mergedOutput = mergeOutputs(mergedOutput, result.stdout.trim());
+          }
+        }
       }
     }
   }
@@ -403,23 +507,35 @@ async function main() {
   if (eventName === "PostToolUse" && !blocked) {
     try {
       const home = process.env.HOME || process.env.USERPROFILE || "";
-      const snapshotPath = join(home, ".claude", "cache", "tfx-hub", "context-monitor.json");
+      const snapshotPath = join(
+        home,
+        ".claude",
+        "cache",
+        "tfx-hub",
+        "context-monitor.json",
+      );
       const nudgeMarker = join(tmpdir(), "tfx-compact-nudge-sent");
       if (existsSync(snapshotPath) && !existsSync(nudgeMarker)) {
         const snap = JSON.parse(readFileSync(snapshotPath, "utf8"));
         const percent = Number(snap.percent || 0);
         if (percent >= 80) {
           const level = percent >= 90 ? "critical" : "warn";
-          const msg = level === "critical"
-            ? `[context ${percent}%] 컨텍스트 ${percent}% 사용. /compact 또는 에이전트 분할을 강력 권장합니다.`
-            : `[context ${percent}%] 컨텍스트 ${percent}% 사용. 마일스톤이면 /compact를 권장합니다.`;
-          mergedOutput = mergeOutputs(mergedOutput, JSON.stringify({ systemMessage: msg }));
+          const msg =
+            level === "critical"
+              ? `[context ${percent}%] 컨텍스트 ${percent}% 사용. /compact 또는 에이전트 분할을 강력 권장합니다.`
+              : `[context ${percent}%] 컨텍스트 ${percent}% 사용. 마일스톤이면 /compact를 권장합니다.`;
+          mergedOutput = mergeOutputs(
+            mergedOutput,
+            JSON.stringify({ systemMessage: msg }),
+          );
           if (level === "warn") {
             writeFileSync(nudgeMarker, new Date().toISOString());
           }
         }
       }
-    } catch { /* 컨텍스트 모니터 읽기 실패 무시 */ }
+    } catch {
+      /* 컨텍스트 모니터 읽기 실패 무시 */
+    }
   }
 
   // ── PostToolUse:Skill 완료 시 라우팅 가중치 기록 ──
@@ -440,9 +556,24 @@ async function main() {
 
   // 결과 출력
   if (blocked) {
+    if (dedupePreToolUseBash) {
+      writeHookCache(stdinRaw, {
+        blocked: true,
+        mergedOutput: null,
+        stderr: blockingStderr,
+      });
+    }
     process.exit(2);
   }
 
+  if (dedupePreToolUseBash) {
+    writeHookCache(stdinRaw, {
+      blocked: false,
+      mergedOutput,
+      stderr: "",
+    });
+  }
+
   if (mergedOutput) {
     process.stdout.write(JSON.stringify(mergedOutput));
   }

package/hub/team/process-cleanup.mjs

@@ -1,7 +1,7 @@
 // hub/team/process-cleanup.mjs — 고아 node/python 프로세스 감지 및 정리
 // Windows: Get-CimInstance Win32_Process로 parent PID + cmdLine 접근
 // Unix: ps aux 파싱
-import { execFile as nodeExecFile } from "node:child_process";
+import { execFile as nodeExecFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 import { IS_WINDOWS } from "../platform.mjs";
 
@@ -12,6 +12,28 @@ const execFileAsync = promisify(nodeExecFile);
 const TARGET_PROCESS_NAMES = ["node", "python", "python3"];
 const SIGTERM_GRACE_MS = 5000;
 
+function forceKillPid(pid) {
+  if (IS_WINDOWS) {
+    try {
+      execFileSync("taskkill", ["/F", "/PID", String(pid)], {
+        stdio: "ignore",
+        timeout: 5000,
+        windowsHide: true,
+      });
+      return;
+    } catch (taskkillError) {
+      try {
+        process.kill(pid);
+        return;
+      } catch {
+        throw taskkillError;
+      }
+    }
+  }
+
+  process.kill(pid, "SIGKILL");
+}
+
 // cmdLine 패턴 기반 화이트리스트 (고아 후보에서 제외)
 const WHITELIST_CMDLINE = [/oh-my-claudecode/i, /triflux[\\/]hub[\\/]s/i];
 
@@ -293,7 +315,7 @@ export function createProcessCleanup(opts = {}) {
   /**
    * 마지막 scan 결과의 프로세스를 kill한다.
    * dryRun=true이면 kill 없이 목록만 반환한다.
-   * SIGTERM → 5s 대기 → SIGKILL 순서.
+   * SIGTERM → 5s 대기 → 강제 종료(taskkill/SIGKILL) 순서.
    * @returns {Promise<Array<{pid,name,killed,error}>>}
    */
   async function kill() {
@@ -312,14 +334,14 @@ export function createProcessCleanup(opts = {}) {
           // SIGTERM
           process.kill(p.pid, "SIGTERM");
 
-          // 5초 대기 후 살아있으면 SIGKILL
+          // 5초 대기 후 살아있으면 강제 종료
           await new Promise((resolve) => setTimeout(resolve, SIGTERM_GRACE_MS));
 
           try {
             // 프로세스가 아직 살아있는지 확인 (signal 0)
             process.kill(p.pid, 0);
-            // 여전히 살아있음 → SIGKILL
-            process.kill(p.pid, "SIGKILL");
+            // 여전히 살아있음 → Windows는 taskkill/process.kill, 그 외는 SIGKILL
+            forceKillPid(p.pid);
           } catch {
             // ESRCH: 이미 종료됨 — 정상
           }

package/hub/team/swarm-hypervisor.mjs

@@ -172,6 +172,23 @@ export function createSwarmHypervisor(opts) {
 
   const results = new Map(); // shardName → validated result
   const failures = new Map(); // shardName → failure info
+  let integrationResult = null;
+  let resolveIntegrationPromise = null;
+  let integrationPromiseState = {
+    state: "idle",
+    startedAt: null,
+    settledAt: null,
+    partial: false,
+    integrated: [],
+    failed: [],
+    integrationFailures: [],
+    skipped: [],
+    integrationBranch: null,
+    error: null,
+  };
+  const integrationPromise = new Promise((resolve) => {
+    resolveIntegrationPromise = resolve;
+  });
 
   if (meshRegistryFallback) {
     eventLog.append("mesh_registry_fallback", { reason: meshRegistryFallback });
@@ -186,6 +203,52 @@ export function createSwarmHypervisor(opts) {
     emitter.emit("stateChange", { from: prev, to: next, reason });
   }
 
+  function markIntegrationPromisePending() {
+    if (integrationPromiseState.state !== "idle") return;
+    integrationPromiseState = {
+      ...integrationPromiseState,
+      state: "pending",
+      startedAt: Date.now(),
+    };
+  }
+
+  function settleIntegrationPromise(payload) {
+    if (integrationPromiseState.state === "fulfilled" && integrationResult) {
+      return integrationResult;
+    }
+
+    integrationResult = Object.freeze({
+      integrated: Object.freeze([...(payload.integrated || [])]),
+      failed: Object.freeze([...(payload.failed || [])]),
+      integrationFailures: Object.freeze([
+        ...(payload.integrationFailures || []),
+      ]),
+      skipped: Object.freeze([...(payload.skipped || [])]),
+      integrationBranch: payload.integrationBranch || null,
+      results: Object.freeze([...(payload.results || [])]),
+      partial:
+        payload.partial ??
+        (Array.isArray(payload.failed) && payload.failed.length > 0),
+      error: payload.error || null,
+    });
+
+    integrationPromiseState = {
+      state: "fulfilled",
+      startedAt: integrationPromiseState.startedAt ?? Date.now(),
+      settledAt: Date.now(),
+      partial: integrationResult.partial,
+      integrated: [...integrationResult.integrated],
+      failed: [...integrationResult.failed],
+      integrationFailures: [...integrationResult.integrationFailures],
+      skipped: [...integrationResult.skipped],
+      integrationBranch: integrationResult.integrationBranch,
+      error: integrationResult.error,
+    };
+
+    resolveIntegrationPromise?.(integrationResult);
+    return integrationResult;
+  }
+
   // ── Worker lifecycle ────────────────────────────────────────
 
   function buildSessionConfig(shard) {
@@ -516,114 +579,163 @@ export function createSwarmHypervisor(opts) {
 
     const integrated = [];
     const integrationFailures = [];
-    const { integrationBranch } = await prepareIntegrationBranchImpl({
-      runId,
-      baseBranch,
-      rootDir: workdir,
-    });
+    const preIntegrationFailures = [...failures.keys()];
+    let integrationBranch = null;
 
-    for (const shardName of plan.mergeOrder) {
-      if (failures.has(shardName)) {
-        eventLog.append("skip_failed_shard", { shard: shardName });
-        continue;
-      }
+    try {
+      ({ integrationBranch } = await prepareIntegrationBranchImpl({
+        runId,
+        baseBranch,
+        rootDir: workdir,
+      }));
 
-      const worker = workers.get(shardName);
-      if (!worker) continue;
+      for (const shardName of plan.mergeOrder) {
+        if (failures.has(shardName)) {
+          eventLog.append("skip_failed_shard", { shard: shardName });
+          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, workdir);
-        const sshUser = hostConfig?.ssh_user || shard.host;
-        const remoteRepoPath = resolveRemoteDir(
-          workdir,
-          shard._remoteEnv,
-        );
-        const fetchResult = await fetchRemoteShard({
-          host: shard.host,
-          sshUser,
-          remoteRepoPath,
-          branchName: worker.branchName || `swarm/${runId}/${shardName}`,
-          rootDir: workdir,
-        });
+        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, workdir);
+          const sshUser = hostConfig?.ssh_user || shard.host;
+          const remoteRepoPath = resolveRemoteDir(
+            workdir,
+            shard._remoteEnv,
+          );
+          const fetchResult = await fetchRemoteShard({
+            host: shard.host,
+            sshUser,
+            remoteRepoPath,
+            branchName: worker.branchName || `swarm/${runId}/${shardName}`,
+            rootDir: workdir,
+          });
 
-        if (!fetchResult.ok) {
-          eventLog.append("remote_fetch_failed", {
+          if (!fetchResult.ok) {
+            eventLog.append("remote_fetch_failed", {
+              shard: shardName,
+              error: fetchResult.error,
+            });
+            await maybeCleanupWorktree(shardName, worker, shard);
+            integrationFailures.push(shardName);
+            continue;
+          }
+          eventLog.append("remote_fetch_ok", {
             shard: shardName,
-            error: fetchResult.error,
+            headCommit: fetchResult.headCommit,
+          });
+        }
+
+        // Read shard output log for changed files
+        const changedFiles = detectChangedFiles(shardName, worker);
+
+        // Validate against lease map
+        const validation = validateResult(shardName, changedFiles);
+        if (!validation.ok) {
+          failures.set(shardName, {
+            mode: FAILURE_MODES.F4_LEASE_VIOLATION,
+            violations: validation.violations,
+          });
+          eventLog.append("lease_violation_revert", {
+            shard: shardName,
+            violations: validation.violations,
           });
           await maybeCleanupWorktree(shardName, worker, shard);
           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);
 
-      // Validate against lease map
-      const validation = validateResult(shardName, changedFiles);
-      if (!validation.ok) {
-        failures.set(shardName, {
-          mode: FAILURE_MODES.F4_LEASE_VIOLATION,
-          violations: validation.violations,
-        });
-        eventLog.append("lease_violation_revert", {
-          shard: shardName,
-          violations: validation.violations,
+        const shardBranch = worker.branchName || `swarm/${runId}/${shardName}`;
+        const rebaseResult = await rebaseShardOntoIntegrationImpl({
+          shardBranch,
+          integrationBranch,
+          rootDir: workdir,
         });
-        await maybeCleanupWorktree(shardName, worker, shard);
-        integrationFailures.push(shardName);
-        continue;
-      }
+        if (!rebaseResult.ok) {
+          eventLog.append("integration_rebase_failed", {
+            shard: shardName,
+            shardBranch,
+            integrationBranch,
+            error: rebaseResult.error,
+          });
+          await maybeCleanupWorktree(shardName, worker, shard);
+          integrationFailures.push(shardName);
+          continue;
+        }
 
-      const shardBranch = worker.branchName || `swarm/${runId}/${shardName}`;
-      const rebaseResult = await rebaseShardOntoIntegrationImpl({
-        shardBranch,
-        integrationBranch,
-        rootDir: workdir,
-      });
-      if (!rebaseResult.ok) {
-        eventLog.append("integration_rebase_failed", {
+        results.set(shardName, {
           shard: shardName,
-          shardBranch,
+          changedFiles,
+          branchName: shardBranch,
+          worktreePath: worker.worktreePath || null,
           integrationBranch,
-          error: rebaseResult.error,
+          headCommit: rebaseResult.headCommit,
+          completedAt: Date.now(),
         });
-        await maybeCleanupWorktree(shardName, worker, shard);
-        integrationFailures.push(shardName);
-        continue;
+        integrated.push(shardName);
+
+        await maybeCleanupWorktree(shardName, worker, shard, shardBranch);
       }
+    } catch (err) {
+      const unresolved = plan.mergeOrder.filter(
+        (name) =>
+          !integrated.includes(name) &&
+          !preIntegrationFailures.includes(name) &&
+          !integrationFailures.includes(name),
+      );
+      const failed = [
+        ...new Set([
+          ...preIntegrationFailures,
+          ...integrationFailures,
+          ...unresolved,
+        ]),
+      ];
+      const skipped = preIntegrationFailures.filter(
+        (name) => !integrationFailures.includes(name),
+      );
 
-      results.set(shardName, {
-        shard: shardName,
-        changedFiles,
-        branchName: shardBranch,
-        worktreePath: worker.worktreePath || null,
+      eventLog.append("integration_complete", {
+        integrated,
+        failed,
+        integrationFailures,
         integrationBranch,
-        headCommit: rebaseResult.headCommit,
-        completedAt: Date.now(),
+        skipped,
+        error: err.message,
       });
-      integrated.push(shardName);
 
-      await maybeCleanupWorktree(shardName, worker, shard, shardBranch);
+      setState(SWARM_STATES.FAILED, "integration_error");
+      const payload = settleIntegrationPromise({
+        integrated,
+        failed,
+        integrationFailures,
+        integrationBranch,
+        skipped,
+        results: [...results.values()],
+        partial: true,
+        error: err.message,
+      });
+      emitter.emit("integrationComplete", payload);
+      return payload;
     }
 
+    const skipped = preIntegrationFailures.filter(
+      (name) => !integrationFailures.includes(name),
+    );
+    const failed = [...new Set([...skipped, ...integrationFailures])];
+
     eventLog.append("integration_complete", {
       integrated,
-      failed: integrationFailures,
+      failed,
+      integrationFailures,
       integrationBranch,
-      skipped: [...failures.keys()].filter(
-        (n) => !integrationFailures.includes(n),
-      ),
+      skipped,
     });
 
-    if (integrationFailures.length > 0 && integrated.length === 0) {
+    if (failed.length > 0 && integrated.length === 0) {
       setState(SWARM_STATES.FAILED, "all_shards_failed_integration");
     } else {
       setState(
@@ -632,12 +744,17 @@ export function createSwarmHypervisor(opts) {
       );
     }
 
-    emitter.emit("integrationComplete", {
+    const payload = settleIntegrationPromise({
       integrated,
-      failed: integrationFailures,
+      failed,
+      integrationFailures,
       integrationBranch,
+      skipped,
       results: [...results.values()],
+      partial: failed.length > 0,
     });
+    emitter.emit("integrationComplete", payload);
+    return payload;
   }
 
   async function maybeCleanupWorktree(
@@ -758,6 +875,18 @@ export function createSwarmHypervisor(opts) {
       mergeOrder: plan?.mergeOrder || [],
       criticalShards: plan?.criticalShards || [],
       locks: lockManager?.snapshot() || [],
+      integrationPromise: Object.freeze({
+        state: integrationPromiseState.state,
+        startedAt: integrationPromiseState.startedAt,
+        settledAt: integrationPromiseState.settledAt,
+        partial: integrationPromiseState.partial,
+        integrated: [...integrationPromiseState.integrated],
+        failed: [...integrationPromiseState.failed],
+        integrationFailures: [...integrationPromiseState.integrationFailures],
+        skipped: [...integrationPromiseState.skipped],
+        integrationBranch: integrationPromiseState.integrationBranch,
+        error: integrationPromiseState.error,
+      }),
     });
   }
 
@@ -806,6 +935,7 @@ export function createSwarmHypervisor(opts) {
     }
 
     plan = swarmPlan;
+    markIntegrationPromisePending();
 
     // Hub alive 확인 — 죽어있으면 재시작
     if (ensureHubAliveFn) {
@@ -914,6 +1044,9 @@ export function createSwarmHypervisor(opts) {
     launch,
     shutdown,
     getStatus,
+    integrationComplete() {
+      return integrationPromise;
+    },
     getMeshRegistry() {
       return sharedRegistry;
     },

package/hub/team/tui-viewer.mjs

@@ -74,6 +74,9 @@ const INTERNAL_PATTERNS = [
   /\.err\b/,
   /completion[-_]token/i,
   /^---\s*HANDOFF\s*---$/i,
+  /Get-Content/,
+  /-color\s+never/,
+  /AppData[\\/]Local[\\/]Temp[\\/]tfx-headless/,
 ];
 
 function isInternalLine(line) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.9.18",
+  "version": "10.9.19",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {
@@ -42,8 +42,8 @@
     "setup": "node scripts/setup.mjs",
     "preinstall": "node scripts/preinstall.mjs",
     "postinstall": "node scripts/setup.mjs",
-    "lint": "biome check .",
-    "lint:fix": "biome check --fix .",
+    "lint": "biome check bin config hooks hub hud mesh scripts tests .claude-plugin .github package.json package-lock.json biome.json",
+    "lint:fix": "biome check --write bin config hooks hub hud mesh scripts tests .claude-plugin .github package.json package-lock.json biome.json",
     "health": "npm test && npm run lint",
     "test": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 \"tests/**/*.test.mjs\" \"scripts/__tests__/**/*.test.mjs\"",
     "test:unit": "node scripts/test-lock.mjs --test --test-force-exit --test-concurrency=8 tests/unit/**/*.test.mjs",

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

@@ -34,7 +34,7 @@ const { extractPrompt, sanitizeForKeywordDetection } = detectorModule;
 
 function loadCompiledRules() {
   const rules = loadRules(rulesPath);
-  assert.equal(rules.length, 32);
+  assert.ok(rules.length >= 32);
   return compileRules(rules);
 }
 
@@ -108,8 +108,8 @@ test("sanitizeForKeywordDetection: 코드블록/URL/파일경로/XML 태그 제
 
 test("loadRules: 유효한 JSON 로드", () => {
   const rules = loadRules(rulesPath);
-  assert.equal(rules.length, 32);
-  assert.equal(rules.filter((rule) => rule.skill).length, 18);
+  assert.ok(rules.length >= 32);
+  assert.ok(rules.filter((rule) => rule.skill).length >= 18);
   assert.equal(rules.filter((rule) => rule.mcp_route).length, 10);
 });
 
@@ -130,7 +130,7 @@ test("loadRules: 잘못된 파일 처리", () => {
 test("compileRules: 정규식 컴파일 성공", () => {
   const rules = loadRules(rulesPath);
   const compiled = compileRules(rules);
-  assert.equal(compiled.length, 32);
+  assert.equal(compiled.length, rules.length);
   for (const rule of compiled) {
     assert.ok(Array.isArray(rule.compiledPatterns));
     assert.ok(rule.compiledPatterns.length > 0);