triflux 8.0.0 → 8.2.1

package/hub/team/headless.mjs

@@ -21,6 +21,8 @@ import {
 } from "./psmux.mjs";
 import { HANDOFF_INSTRUCTION_SHORT, processHandoff } from "./handoff.mjs";
 import { getBackend } from "./backend.mjs";
+import { resolveDashboardLayout } from "./dashboard-layout.mjs";
+import { createLogDashboard } from "./tui.mjs";
 
 const RESULT_DIR = join(tmpdir(), "tfx-headless");
 
@@ -92,11 +94,9 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
   const promptFile = join(RESULT_DIR, "prompt-" + randomUUID().slice(0, 8) + ".txt").replace(/\\/g, "/");
   writeFileSync(promptFile, fullPrompt, "utf8");
 
-  const cls = "Clear-Host; ";
-
   const backend = getBackend(resolvedCli);
   const promptExpr = `(Get-Content -Raw '${promptFile}')`;
-  return `${cls}${backend.buildArgs(promptExpr, resultFile, { ...opts, model })}`;
+  return backend.buildArgs(promptExpr, resultFile, { ...opts, model });
 }
 
 /**
@@ -114,10 +114,23 @@ function readResult(resultFile, paneId) {
 }
 
 /** progressive 스플릿 모드: lead pane만 생성 후, 워커를 하나씩 추가하며 dispatch */
-async function dispatchProgressive(sessionName, assignments, layout, safeProgress) {
+async function dispatchProgressive(sessionName, assignments, opts = {}) {
+  const {
+    layout,
+    safeProgress,
+    dashboardLayout = "single",
+  } = opts;
+  const resolvedDashboardLayout = resolveDashboardLayout(dashboardLayout, assignments.length);
   const session = createPsmuxSession(sessionName, { layout, paneCount: 1 });
   applyTrifluxTheme(sessionName);
-  if (safeProgress) safeProgress({ type: "session_created", sessionName, panes: session.panes });
+  if (safeProgress) {
+    safeProgress({
+      type: "session_created",
+      sessionName,
+      panes: session.panes,
+      dashboardLayout: resolvedDashboardLayout,
+    });
+  }
 
   // dashboard: 워커 pane을 먼저 생성한 후 pane 0에 대시보드를 실행
   // (listPanes로 워커 감지가 가능하려면 워커 pane이 먼저 존재해야 함)
@@ -133,16 +146,12 @@ async function dispatchProgressive(sessionName, assignments, layout, safeProgres
       : `${brand.emoji} ${resolvedCli}-${i + 1}`;
 
     let newPaneId;
-    if (i === 0) {
-      // 첫 번째 워커: 빈 lead pane 사용
-      newPaneId = `${sessionName}:0.0`;
-    } else {
-      // 2번째+: split-window로 추가
-      newPaneId = psmuxExec([
-        "split-window", "-t", sessionName, "-P", "-F",
-        "#{session_name}:#{window_index}.#{pane_index}",
-      ]);
-    }
+    // 모든 워커를 split-window로 생성 (lead pane index 0은 비워둠)
+    // tui-viewer가 index 0을 건너뛰므로, 워커는 항상 index >= 1에 배치
+    newPaneId = psmuxExec([
+      "split-window", "-t", sessionName, "-P", "-F",
+      "#{session_name}:#{window_index}.#{pane_index}",
+    ]);
 
     // 타이틀 설정 (이모지 포함)
     try { psmuxExec(["select-pane", "-t", newPaneId, "-T", paneTitle]); } catch { /* 무시 */ }
@@ -171,13 +180,26 @@ async function dispatchProgressive(sessionName, assignments, layout, safeProgres
 }
 
 /** 기존 batch 모드: 모든 pane을 한 번에 생성하여 dispatch */
-function dispatchBatch(sessionName, assignments, layout, safeProgress) {
+function dispatchBatch(sessionName, assignments, opts = {}) {
+  const {
+    layout,
+    safeProgress,
+    dashboardLayout = "single",
+  } = opts;
   const paneCount = assignments.length + 1;
+  const resolvedDashboardLayout = resolveDashboardLayout(dashboardLayout, assignments.length);
   // A2b fix: 2x2 레이아웃은 최대 4 pane — 초과 시 tiled로 자동 전환
   const effectiveLayout = (layout === "2x2" && paneCount > 4) ? "tiled" : layout;
   const session = createPsmuxSession(sessionName, { layout: effectiveLayout, paneCount });
   applyTrifluxTheme(sessionName);
-  if (safeProgress) safeProgress({ type: "session_created", sessionName, panes: session.panes });
+  if (safeProgress) {
+    safeProgress({
+      type: "session_created",
+      sessionName,
+      panes: session.panes,
+      dashboardLayout: resolvedDashboardLayout,
+    });
+  }
 
   return assignments.map((assignment, i) => {
     const paneName = `worker-${i + 1}`;
@@ -301,6 +323,7 @@ function collectResults(results) {
  * @param {(event: object) => void} [opts.onProgress] — 진행 콜백
  * @param {number} [opts.progressIntervalSec=0] — N초마다 progress 이벤트 발화 (0=비활성)
  * @param {boolean} [opts.progressive=true] — true면 pane을 하나씩 split-window로 추가 (실시간 스플릿)
+ * @param {string} [opts.dashboardLayout='single'] — dashboard viewer 레이아웃
  * @returns {{ sessionName: string, results: Array<{cli: string, paneName: string, matched: boolean, exitCode: number|null, output: string, sessionDead?: boolean}> }}
  */
 export async function runHeadless(sessionName, assignments, opts = {}) {
@@ -311,22 +334,100 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     progressIntervalSec = 0,
     progressive = true,
     dashboard = false,
+    dashboardLayout = "single",
   } = opts;
 
   mkdirSync(RESULT_DIR, { recursive: true });
 
+  // in-process TUI: dashboard=true이고 stdout이 TTY일 때 직접 구동
+  let tui = null;
+  const resolvedLayout = resolveDashboardLayout(dashboardLayout, assignments.length);
+  if (dashboard && process.stdout.isTTY) {
+    tui = createLogDashboard({
+      stream: process.stdout,
+      input: process.stdin,
+      refreshMs: 200,
+      layout: resolvedLayout,
+    });
+    tui.setStartTime(Date.now());
+    // 초기 워커 상태 등록
+    for (let i = 0; i < assignments.length; i++) {
+      const a = assignments[i];
+      tui.updateWorker(`worker-${i + 1}`, {
+        cli: a.cli || "codex",
+        role: a.role || "",
+        status: "pending",
+        progress: 0,
+      });
+    }
+  }
+
+  // per-worker state feed: onProgress 이벤트 → tui.updateWorker()
+  function feedTui(event) {
+    if (!tui) return;
+    const { type, paneName, cli, snapshot, matched, exitCode } = event;
+    if (!paneName) return;
+
+    if (type === "progress" && snapshot) {
+      tui.updateWorker(paneName, {
+        cli: cli || "codex",
+        status: "running",
+        snapshot: snapshot.split("\n").at(-1) || "",
+        summary: snapshot.split("\n").at(-1) || "",
+        detail: snapshot,
+        progress: 0.5,
+      });
+    } else if (type === "completed") {
+      const status = matched && exitCode === 0 ? "completed" : "failed";
+      tui.updateWorker(paneName, {
+        cli: cli || "codex",
+        status,
+        progress: 1,
+      });
+    } else if (type === "worker_added") {
+      tui.updateWorker(paneName, {
+        cli: cli || "codex",
+        status: "running",
+        progress: 0.05,
+      });
+    }
+  }
+
   // onProgress 예외를 삼켜 실행 흐름 보호 (onPoll과 동일 패턴)
-  const safeProgress = onProgress
-    ? (event) => { try { onProgress(event); } catch { /* 콜백 예외 삼킴 */ } }
-    : null;
+  const combinedProgress = (event) => {
+    feedTui(event);
+    if (onProgress) { try { onProgress(event); } catch { /* 콜백 예외 삼킴 */ } }
+  };
+  const safeProgress = (event) => { try { combinedProgress(event); } catch { /* 삼킴 */ } };
 
   const dispatches = progressive
-    ? await dispatchProgressive(sessionName, assignments, layout, safeProgress)
-    : dispatchBatch(sessionName, assignments, layout, safeProgress);
+    ? await dispatchProgressive(sessionName, assignments, { layout, safeProgress, dashboardLayout })
+    : dispatchBatch(sessionName, assignments, { layout, safeProgress, dashboardLayout });
 
   const results = await awaitAll(sessionName, dispatches, timeoutSec, safeProgress, progressIntervalSec);
+  const collected = collectResults(results);
+
+  // 완료 시 TUI에 최종 상태 반영 후 닫기
+  if (tui) {
+    for (const r of collected) {
+      tui.updateWorker(r.paneName, {
+        cli: r.cli,
+        role: r.role || "",
+        status: r.handoff?.status === "failed" ? "failed" : "completed",
+        handoff: r.handoff,
+        summary: r.handoff?.verdict || (r.matched ? "completed" : "failed"),
+        detail: r.output,
+        progress: 1,
+        elapsed: Math.round((Date.now() - (tui._startedAt || Date.now())) / 1000),
+      });
+    }
+    tui.render();
+    // 최종 화면을 잠깐 유지 후 닫기
+    await new Promise((r) => setTimeout(r, 1500));
+    tui.close();
+  }
 
-  return { sessionName, results: collectResults(results) };
+  return { sessionName, results: collected };
 }
 
 /**
@@ -503,21 +604,25 @@ export function autoAttachTerminal(sessionName, opts = {}, workerCount = 2) {
  * v7.0: psmux 세션을 WT 탭에 attach (대시보드 + 워커 전체 뷰)
  * @param {string} sessionName
  * @param {number} workerCount
+ * @param {string} [dashboardLayout='single']
+ * @param {number} [dashboardSize=0.50] — 대시보드 분할 비율 (0.2~0.8)
  * @returns {boolean}
  */
-export function attachDashboardTab(sessionName, workerCount = 2) {
+export function attachDashboardTab(sessionName, workerCount = 2, dashboardLayout = "single", dashboardSize = 0.40) {
   try { execSync("where wt.exe", { stdio: "ignore" }); } catch { return false; }
   ensureWtProfile(workerCount);
+  const resolvedDashboardLayout = resolveDashboardLayout(dashboardLayout, workerCount);
 
   // v7.1.3: 대시보드만 스플릿 (psmux attach 대신 tui-viewer 직접 실행)
   // raw CLI 출력은 사용자에게 불필요 — 대시보드 로그만 표시
   const viewerPath = join(import.meta.dirname, "tui-viewer.mjs").replace(/\\/g, "/");
+  const sizeStr = String(Math.round(dashboardSize * 100) / 100);
   try {
     const child = spawn("wt.exe", [
-      "-w", "0", "sp", "-H", "-s", "0.30",
+      "-w", "0", "sp", "-H", "-s", sizeStr,
       "--profile", "triflux",
       "--title", `▲ ${sessionName}`,
-      "--", "node", viewerPath, "--session", sessionName,
+      "--", "node", viewerPath, "--session", sessionName, "--result-dir", RESULT_DIR, "--layout", resolvedDashboardLayout,
     ], { detached: true, stdio: "ignore" });
     child.unref();
     try { spawn("wt.exe", ["-w", "0", "mf", "up"], { detached: true, stdio: "ignore" }).unref(); } catch {}
@@ -558,6 +663,7 @@ export function getProgressSnapshots(sessionName, dispatches, lines = 15) {
  * @param {(event: object) => void} [opts.onProgress]
  * @param {number} [opts.progressIntervalSec=0]
  * @param {boolean} [opts.autoAttach=false] — Windows Terminal 자동 attach
+ * @param {string} [opts.dashboardLayout='single'] — dashboard viewer 레이아웃
  * @param {AbortSignal} [opts.signal] — abort 시 자동 세션 정리
  * @param {number} [opts.maxIdleSec=0] — 유휴 시 자동 정리 (0=비활성)
  * @returns {Promise<{
@@ -576,32 +682,39 @@ export async function runHeadlessInteractive(sessionName, assignments, opts = {}
   const {
     autoAttach = false,
     dashboard = false,
+    dashboardSize = 0.40,
     signal,
     maxIdleSec = 0,
     ...runOpts
   } = opts;
-
-  // dashboard 옵션을 runHeadless에 전달
-  if (dashboard) runOpts.dashboard = true;
+  const headlessOpts = dashboard
+    ? { ...runOpts, dashboard: true }
+    : { ...runOpts };
 
   // autoAttach를 session_created 시점에 트리거 (CLI 실행 전에 터미널 열림)
-  const userOnProgress = runOpts.onProgress;
+  const userOnProgress = headlessOpts.onProgress;
   let terminalAttached = false;
-  runOpts.onProgress = (event) => {
+  const onProgress = (event) => {
     if (autoAttach && event.type === "session_created" && !terminalAttached) {
       terminalAttached = true;
       if (dashboard) {
         // v7.0: psmux attach로 대시보드+워커 전체 세션을 WT 탭에 표시
-        attachDashboardTab(sessionName, assignments.length);
+        attachDashboardTab(
+          sessionName,
+          assignments.length,
+          event.dashboardLayout || resolveDashboardLayout(headlessOpts.dashboardLayout, assignments.length),
+          dashboardSize,
+        );
       } else {
         autoAttachTerminal(sessionName, {}, assignments.length);
       }
     }
     if (userOnProgress) userOnProgress(event);
   };
+  const interactiveRunOpts = { ...headlessOpts, onProgress };
 
   // Phase 1: 세션 생성 → 즉시 터미널 팝업 → dispatch → 대기 → 결과 수집
-  const { results } = await runHeadless(sessionName, assignments, runOpts);
+  const { results } = await runHeadless(sessionName, assignments, interactiveRunOpts);
 
   // Phase 2: 세션을 유지하고 interactive handle 반환
   // Fix P2: paneId를 dispatches에 포함 (snapshots에서 필요)

package/hub/team/psmux.mjs

@@ -2,7 +2,7 @@
 // 의존성: child_process, fs, os, path (Node.js 내장)만 사용
 import childProcess from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { tmpdir, homedir } from "node:os";
 import { join } from "node:path";
 
 const PSMUX_BIN = process.env.PSMUX_BIN || "psmux";
@@ -26,7 +26,7 @@ function quoteArg(value) {
 }
 
 function sanitizePathPart(value) {
-  return String(value).replace(/[<>:"/\\|?*\u0000-\u001f]/gu, "_");
+  return String(value).replace(/[<>:"/\\|?*\u0000-\u001f']/gu, "_");
 }
 
 function toPaneTitle(index) {
@@ -282,7 +282,7 @@ function refreshCaptureSnapshot(sessionName, paneNameOrTarget) {
   const paneName = pane.title || paneNameOrTarget;
   const logPath = getCaptureLogPath(sessionName, paneName);
   mkdirSync(getCaptureSessionDir(sessionName), { recursive: true });
-  const snapshot = psmuxExec(["capture-pane", "-t", pane.paneId, "-p"]);
+  const snapshot = psmuxExec(["capture-pane", "-t", pane.paneId, "-p", "-S", "-"]);
   writeFileSync(logPath, snapshot, "utf8");
   return { paneId: pane.paneId, paneName, logPath, snapshot };
 }
@@ -453,16 +453,145 @@ export function createPsmuxSession(sessionName, opts = {}) {
   return { sessionName, panes };
 }
 
+/**
+ * psmux 세션의 모든 pane PID를 수집
+ * @param {string} sessionName
+ * @returns {number[]}
+ */
+function collectPanePids(sessionName) {
+  try {
+    const output = psmuxExec([
+      "list-panes", "-t", sessionName, "-F", "#{pane_pid}",
+    ]);
+    return output
+      .split(/\r?\n/)
+      .map((l) => Number.parseInt(l.trim(), 10))
+      .filter((pid) => Number.isFinite(pid) && pid > 0);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Windows 프로세스 트리 강제 종료 (taskkill /T /F)
+ * @param {number} pid
+ */
+function killProcessTree(pid) {
+  if (!IS_WINDOWS || !pid) return;
+  try {
+    childProcess.execSync(`taskkill /T /F /PID ${pid}`, {
+      stdio: "ignore",
+      timeout: 5000,
+    });
+  } catch {
+    // 이미 종료된 프로세스 — 무시
+  }
+}
+
+/**
+ * 세션의 모든 pane에서 pipe-pane 캡처를 해제한다.
+ * pipe-pane을 인자 없이 호출하면 psmux가 reader 프로세스에 EOF를 보내 정상 종료시킨다.
+ * @param {string} sessionName
+ * @param {string[]} paneIds — collectSessionPanes() 결과
+ */
+function disableAllPipeCaptures(sessionName, paneIds) {
+  for (const paneId of paneIds) {
+    try {
+      psmuxExec(["pipe-pane", "-t", paneId]);
+    } catch {
+      // pane이 이미 죽었거나 pipe가 없으면 무시
+    }
+  }
+}
+
+/**
+ * 세션과 관련된 고아 pipe-pane 헬퍼 프로세스를 찾아 종료한다.
+ * pipe-pane disable 후에도 reader가 종료되지 않는 경우의 안전망.
+ * @param {string} sessionName
+ */
+function killOrphanPipeHelpers(sessionName) {
+  if (!IS_WINDOWS) return;
+  const safeSession = sanitizePathPart(sessionName);
+  try {
+    const output = childProcess.execSync(
+      `powershell -NoProfile -Command "$ErrorActionPreference='SilentlyContinue'; Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match 'pipe-pane-capture' -and $_.CommandLine -match '${safeSession}' } | Select-Object -ExpandProperty ProcessId"`,
+      { encoding: "utf8", timeout: 8000, stdio: ["pipe", "pipe", "pipe"] },
+    );
+    const pids = output.split(/\r?\n/).map((l) => Number.parseInt(l.trim(), 10)).filter((p) => Number.isFinite(p) && p > 0);
+    for (const pid of pids) {
+      killProcessTree(pid);
+    }
+  } catch {
+    // WMI 조회 실패 — 무시
+  }
+}
+
+/**
+ * 세션이 spawn한 CLI(codex/gemini)의 고아 MCP 서버 프로세스를 찾아 종료한다.
+ * headless 워커가 codex/gemini를 실행하면 MCP 서버(node.exe)가 자식으로 생성되는데,
+ * 부모가 죽어도 Windows에서는 자식이 자동 종료되지 않아 고아가 된다.
+ * @param {string} sessionName
+ */
+function killOrphanMcpProcesses(sessionName) {
+  if (!IS_WINDOWS) return;
+  const safeSession = sanitizePathPart(sessionName);
+
+  // Hub PID 보호 — Hub 프로세스를 고아로 잘못 식별하지 않도록
+  let hubPid = null;
+  try {
+    const hubPidPath = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
+    if (existsSync(hubPidPath)) {
+      const hubInfo = JSON.parse(readFileSync(hubPidPath, "utf8"));
+      hubPid = Number(hubInfo?.pid);
+    }
+  } catch {}
+
+  try {
+    // 세션 결과 디렉토리 패턴으로 MCP 서버 프로세스 식별
+    const output = childProcess.execSync(
+      `powershell -NoProfile -Command "$ErrorActionPreference='SilentlyContinue'; Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'node.exe' -and $_.CommandLine -match '${safeSession}' } | Select-Object -ExpandProperty ProcessId"`,
+      { encoding: "utf8", timeout: 8000, stdio: ["pipe", "pipe", "pipe"] },
+    );
+    const pids = output.split(/\r?\n/).map((l) => Number.parseInt(l.trim(), 10)).filter((p) => Number.isFinite(p) && p > 0 && p !== hubPid);
+    for (const pid of pids) {
+      killProcessTree(pid);
+    }
+  } catch {
+    // WMI 조회 실패 — 무시
+  }
+}
+
 /**
  * psmux 세션 종료
+ * 순서: pipe-pane 해제 → pane 프로세스 트리 정리 → 세션 종료 → 고아 정리
  * @param {string} sessionName
  */
 export function killPsmuxSession(sessionName) {
+  // 1. pipe-pane 캡처 해제 — reader 프로세스에 EOF 전송하여 정상 종료 유도
+  let paneIds = [];
+  try {
+    paneIds = collectSessionPanes(sessionName);
+  } catch {
+    // 세션이 이미 죽었으면 pane 목록 수집 불가 — 계속 진행
+  }
+  disableAllPipeCaptures(sessionName, paneIds);
+
+  // 2. pane 프로세스 트리 강제 종료 (MCP 서버 포함)
+  const pids = collectPanePids(sessionName);
+  for (const pid of pids) {
+    killProcessTree(pid);
+  }
+
+  // 3. psmux 세션 자체 종료
   try {
     psmuxExec(["kill-session", "-t", sessionName], { stdio: "ignore" });
   } catch {
     // 이미 종료된 세션 — 무시
   }
+
+  // 4. 고아 프로세스 정리 (pipe-pane 헬퍼 + MCP 서버)
+  killOrphanPipeHelpers(sessionName);
+  killOrphanMcpProcesses(sessionName);
 }
 
 /**
@@ -501,7 +630,7 @@ export function listPsmuxSessions() {
  */
 export function capturePsmuxPane(target, lines = 5) {
   try {
-    const full = psmuxExec(["capture-pane", "-t", target, "-p"]);
+    const full = psmuxExec(["capture-pane", "-t", target, "-p", "-S", "-"]);
     const nonEmpty = full.split("\n").filter((line) => line.trim() !== "");
     return nonEmpty.slice(-lines).join("\n");
   } catch {
@@ -635,7 +764,9 @@ export function startCapture(sessionName, paneNameOrTarget) {
  */
 function wrapCliForBash(cmd) {
   const trimmed = cmd.trimStart();
-  const isCli = /^(codex|gemini)\b/u.test(trimmed);
+  // PowerShell 구문(Clear-Host, Get-Content 등) 또는 completion token이 포함되면 PowerShell 직통
+  if (/Clear-Host|Get-Content|__TRIFLUX_DONE__/i.test(trimmed)) return cmd;
+  const isCli = /\b(codex|gemini)\b/u.test(trimmed);
   if (!isCli) return cmd;
   // 단일 따옴표 이스케이프: ' → '\''
   const escaped = trimmed.replace(/'/g, "'\\''");
@@ -654,7 +785,7 @@ export function dispatchCommand(sessionName, paneNameOrTarget, commandText) {
 
   const token = randomToken(paneName);
   const safeCommand = wrapCliForBash(commandText);
-  const wrapped = `${safeCommand}; $trifluxExit = if ($null -ne $LASTEXITCODE) { [int]$LASTEXITCODE } else { 0 }; Write-Output "${COMPLETION_PREFIX}${token}:$trifluxExit"`;
+  const wrapped = `try { ${safeCommand} } finally { $trifluxExit = if ($null -ne $LASTEXITCODE) { [int]$LASTEXITCODE } else { 0 }; Write-Output "${COMPLETION_PREFIX}${token}:$trifluxExit" }`;
 
   sendLiteralToPane(pane.paneId, wrapped, true);
 
@@ -710,7 +841,7 @@ export async function waitForPattern(sessionName, paneNameOrTarget, pattern, tim
     try {
       if (opts.logPath) {
         // logPath 직접 지정 시 — 셸 타이틀 변경과 무관하게 올바른 파일에 기록
-        const snapshot = psmuxExec(["capture-pane", "-t", pane.paneId, "-p"]);
+        const snapshot = psmuxExec(["capture-pane", "-t", pane.paneId, "-p", "-S", "-"]);
         writeFileSync(logPath, snapshot, "utf8");
       } else {
         refreshCaptureSnapshot(sessionName, pane.paneId);
@@ -779,6 +910,30 @@ export async function waitForCompletion(sessionName, paneNameOrTarget, token, ti
     "m",
   );
   const result = await waitForPattern(sessionName, paneNameOrTarget, completionRegex, timeoutSec, opts);
+
+  // 타이밍 이슈 대응: matched=false인 경우 500ms 대기 후 최종 1회 캡처 재시도
+  if (!result.matched && !result.sessionDead && result.logPath) {
+    await new Promise((r) => setTimeout(r, 500));
+    try {
+      const pane = resolvePane(sessionName, paneNameOrTarget);
+      const snapshot = psmuxExec(["capture-pane", "-t", pane.paneId, "-p", "-S", "-"]);
+      writeFileSync(result.logPath, snapshot, "utf8");
+      const content = readCaptureLog(result.logPath);
+      const retryMatch = completionRegex.exec(content);
+      if (retryMatch) {
+        return {
+          ...result,
+          matched: true,
+          match: retryMatch[0],
+          token,
+          exitCode: Number.parseInt(retryMatch[1], 10),
+        };
+      }
+    } catch {
+      // 세션 이미 종료 — 무시
+    }
+  }
+
   const exitMatch = result.match ? completionRegex.exec(result.match) : null;
   return {
     ...result,
@@ -869,6 +1024,18 @@ export function killWorker(sessionName, workerName) {
   try {
     const { paneId, status } = getWorkerStatus(sessionName, workerName);
 
+    // pipe-pane 캡처 해제 — reader 프로세스 정상 종료 유도
+    disablePipeCapture(paneId);
+
+    // pane PID 수집 → 프로세스 트리 정리 (MCP 서버 좀비 방지)
+    try {
+      const pidOutput = psmuxExec(["list-panes", "-t", paneId, "-F", "#{pane_pid}"]);
+      const pid = Number.parseInt(pidOutput.trim(), 10);
+      if (Number.isFinite(pid) && pid > 0) killProcessTree(pid);
+    } catch {
+      // PID 조회 실패 — 아래에서 pane만 정리
+    }
+
     // 이미 종료된 워커 → pane 정리만 수행
     if (status === "exited") {
       try {