triflux 10.9.17 → 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.17",
+      "version": "10.9.19",
       "author": {
         "name": "tellang"
       },
@@ -30,5 +30,5 @@
       ]
     }
   ],
-  "version": "10.9.17"
+  "version": "10.9.19"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.3.4",
+  "version": "10.9.17",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "author": {
     "name": "tellang"

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/handoff.mjs

@@ -219,6 +219,14 @@ export function validateHandoff(parsed, context = {}) {
     );
   }
 
+  const filesChangedCount = Array.isArray(h.files_changed)
+    ? h.files_changed.filter(Boolean).length
+    : 0;
+  if (filesChangedCount === 0 && h.lead_action === "accept") {
+    h.lead_action = "needs_read";
+    warnings.push("files_changed empty: accept → needs_read");
+  }
+
   const missingCore = coreRequired.filter((f) => !h[f]);
   const missingRouting = routingRequired.filter((f) => !h[f]);
   const valid = missingCore.length === 0 && missingRouting.length === 0;
@@ -231,15 +239,20 @@ export function validateHandoff(parsed, context = {}) {
  * @param {number} exitCode
  * @param {string} resultFile
  * @param {string} [cli]
+ * @param {object} [context]
+ * @param {string[]} [context.filesChanged]
  * @returns {object}
  */
-export function buildFallbackHandoff(exitCode, resultFile, cli) {
+export function buildFallbackHandoff(exitCode, resultFile, cli, context = {}) {
   const ok = exitCode === 0;
+  const filesChanged = Array.isArray(context.filesChanged)
+    ? context.filesChanged.filter(Boolean)
+    : [];
   return {
     status: ok ? "ok" : "failed",
-    lead_action: ok ? "accept" : "retry",
+    lead_action: ok && filesChanged.length > 0 ? "accept" : ok ? "needs_read" : "retry",
     task: "unknown",
-    files_changed: [],
+    files_changed: filesChanged,
     verdict: `${cli || "worker"} completed (exit ${exitCode})`,
     confidence: "low",
     risk: "low",
@@ -298,6 +311,7 @@ export function processHandoff(rawText, context = {}) {
       context.exitCode ?? 1,
       context.resultFile || "none",
       context.cli,
+      { filesChanged: context.gitDiffFiles },
     );
     return {
       handoff: fb,

package/hub/team/headless.mjs

@@ -22,7 +22,11 @@ import { getMaxSpawnPerSec } from "../lib/spawn-trace.mjs";
 import { escapePwshSingleQuoted } from "../cli-adapter-base.mjs";
 import { getBackend } from "./backend.mjs";
 import { resolveDashboardLayout } from "./dashboard-layout.mjs";
-import { HANDOFF_INSTRUCTION_SHORT, processHandoff } from "./handoff.mjs";
+import {
+  formatHandoffForLead,
+  HANDOFF_INSTRUCTION_SHORT,
+  processHandoff,
+} from "./handoff.mjs";
 import {
   capturePsmuxPane,
   createPsmuxSession,
@@ -317,7 +321,7 @@ export function createStallMonitor(paneId, resultFile, config, deps = {}) {
  * @param {string} [opts.command] — re-dispatch용 원본 명령
  * @param {string} [opts.token] — completion token
  * @param {(snapshot: string) => void} [opts.onPoll] — 폴링 콜백
- * @returns {Promise<{ matched: boolean, exitCode: number|null, restarts: number, stallDetected: boolean }>}
+ * @returns {Promise<{ matched: boolean, exitCode: number|null, restarts: number, stallDetected: boolean, paneId: string, token?: string, logPath?: string|null }>}
  */
 export async function waitForCompletionWithStallDetect(
   sessionName,
@@ -347,19 +351,23 @@ export async function waitForCompletionWithStallDetect(
   const _startCapture = deps.startCapture || startCapture;
 
   const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const completionPatterns = [
-    token
-      ? `${esc("__TRIFLUX_DONE__:")}${esc(token)}:(\\d+)`
-      : `${esc("__TRIFLUX_DONE__:")}\\S+:(\\d+)`,
-    token
-      ? `${esc("TFX_DONE_")}${esc(token)}:(\\d+)`
-      : `${esc("TFX_DONE_")}\\S+:(\\d+)`,
-  ];
-  const completionRe = new RegExp(completionPatterns.join("|"), "m");
+  const buildCompletionRegex = (activeToken) => {
+    const completionPatterns = [
+      activeToken
+        ? `${esc("__TRIFLUX_DONE__:")}${esc(activeToken)}:(\\d+)`
+        : `${esc("__TRIFLUX_DONE__:")}\\S+:(\\d+)`,
+      activeToken
+        ? `${esc("TFX_DONE_")}${esc(activeToken)}:(\\d+)`
+        : `${esc("TFX_DONE_")}\\S+:(\\d+)`,
+    ];
+    return new RegExp(completionPatterns.join("|"), "m");
+  };
 
   let restarts = 0;
   let currentPaneId = paneId;
   let stallDetected = false;
+  let currentToken = token;
+  let currentLogPath = opts.logPath || null;
 
   while (true) {
     let lastOutput = "";
@@ -386,6 +394,9 @@ export async function waitForCompletionWithStallDetect(
           restarts,
           stallDetected,
           timedOut: true,
+          paneId: currentPaneId,
+          token: currentToken,
+          logPath: currentLogPath,
         };
       }
 
@@ -400,6 +411,7 @@ export async function waitForCompletionWithStallDetect(
       }
 
       // 2) completion 토큰 감지
+      const completionRe = buildCompletionRegex(currentToken);
       const completionMatch = completionRe.exec(currentOutput);
       if (completionMatch) {
         return {
@@ -411,6 +423,9 @@ export async function waitForCompletionWithStallDetect(
           restarts,
           stallDetected,
           timedOut: false,
+          paneId: currentPaneId,
+          token: currentToken,
+          logPath: currentLogPath,
         };
       }
 
@@ -443,6 +458,9 @@ export async function waitForCompletionWithStallDetect(
               restarts,
               stallDetected,
               timedOut: false,
+              paneId: currentPaneId,
+              token: currentToken,
+              logPath: currentLogPath,
             };
           }
         } catch {
@@ -481,8 +499,10 @@ export async function waitForCompletionWithStallDetect(
             "#{session_name}:#{window_index}.#{pane_index}",
           ]);
           _startCapture(sessionName, newPaneId);
-          _dispatch(sessionName, newPaneId, command);
-          currentPaneId = newPaneId;
+          const redispatch = _dispatch(sessionName, newPaneId, command);
+          currentPaneId = redispatch?.paneId || newPaneId;
+          if (redispatch?.token) currentToken = redispatch.token;
+          if (redispatch?.logPath) currentLogPath = redispatch.logPath;
         }
 
         restarts++;
@@ -565,7 +585,11 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
       assignment.cli,
       assignment.prompt,
       resultFile,
-      { mcp: assignment.mcp, model: assignment.model },
+      {
+        mcp: assignment.mcp,
+        model: assignment.model,
+        cwd: assignment.cwd || assignment.workdir,
+      },
     );
     startCapture(sessionName, newPaneId);
     // pane 간 pipe-pane EBUSY 방지 — 이벤트 루프 해방하며 순차 대기
@@ -585,6 +609,7 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
       role: assignment.role,
       command: cmd,
       workerId,
+      cwd: assignment.cwd || assignment.workdir,
     });
   }
 
@@ -636,7 +661,11 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
         assignment.cli,
         assignment.prompt,
         resultFile,
-        { mcp: assignment.mcp, model: assignment.model },
+        {
+          mcp: assignment.mcp,
+          model: assignment.model,
+          cwd: assignment.cwd || assignment.workdir,
+        },
       );
       const scriptDir = join(RESULT_DIR, sessionName);
       await registerHeadlessWorker(sessionName, i, assignment.cli);
@@ -661,6 +690,7 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
         role: assignment.role,
         command: cmd,
         workerId,
+        cwd: assignment.cwd || assignment.workdir,
       };
     }),
   );
@@ -740,6 +770,9 @@ async function awaitAll(
               onPoll: stallPollCb,
             },
           );
+          if (stallResult.paneId) d.paneId = stallResult.paneId;
+          if (stallResult.token) d.token = stallResult.token;
+          if (stallResult.logPath) d.logPath = stallResult.logPath;
           completion = {
             matched: stallResult.matched,
             exitCode: stallResult.exitCode,
@@ -799,28 +832,27 @@ async function awaitAll(
  * @returns {Array}
  */
 async function collectResults(sessionName, results) {
-  // B3 fix: git diff를 루프 밖에서 1회만 실행 (워커 수만큼 중복 방지)
-  let gitDiffFiles;
-  try {
-    const diffOut = execSync("git diff --name-only HEAD", {
-      encoding: "utf8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    gitDiffFiles = diffOut.trim().split("\n").filter(Boolean);
-  } catch {
-    /* git 미설치 또는 non-repo — 무시 */
-  }
-
   // handoff 파이프라인: parse → validate → format (각 워커 결과에 적용)
   return await Promise.all(
     results.map(async ({ d, completion, output }) => {
+      const workerGitDiffFiles = collectGitDiffFiles(d.cwd);
       const handoffResult = processHandoff(output, {
         exitCode: completion.exitCode,
         resultFile: d.resultFile,
         cli: d.cli,
-        gitDiffFiles,
+        gitDiffFiles: workerGitDiffFiles,
       });
+      if (
+        completion.exitCode === 0 &&
+        workerGitDiffFiles.length === 0 &&
+        handoffResult.handoff?.lead_action === "accept"
+      ) {
+        handoffResult.handoff = {
+          ...handoffResult.handoff,
+          lead_action: "needs_read",
+        };
+        handoffResult.formatted = formatHandoffForLead(handoffResult.handoff);
+      }
       const status =
         handoffResult.handoff?.status ||
         (completion.matched && completion.exitCode === 0
@@ -843,6 +875,7 @@ async function collectResults(sessionName, results) {
         exitCode: completion.exitCode,
         output,
         resultFile: d.resultFile,
+        workerGitDiffFiles,
         sessionDead: completion.sessionDead || false,
         handoff: handoffResult.handoff,
         handoffFormatted: handoffResult.formatted,
@@ -853,6 +886,20 @@ async function collectResults(sessionName, results) {
   );
 }
 
+function collectGitDiffFiles(cwd) {
+  try {
+    const diffOut = execSync("git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return diffOut.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 /**
  * 헤드리스 CLI 오케스트레이션 실행
  *

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/psmux.mjs

@@ -1273,6 +1273,7 @@ export async function waitForPattern(
 
 /**
  * 완료 토큰이 찍힐 때까지 대기하고 exit code를 파싱한다.
+ * NOTE: 주 채널은 headless.waitForCompletionWithStallDetect이며, 본 함수는 fallback 채널이다.
  * @param {string} sessionName
  * @param {string} paneNameOrTarget
  * @param {string} token