triflux 8.9.1 → 8.10.0

package/README.ko.md

@@ -66,6 +66,8 @@ tfx setup
 /tfx-debate "Redis vs PostgreSQL LISTEN/NOTIFY for real-time events"
 
 # Persistence — 완료될 때까지 멈추지 않음
+/tfx-persist "implement full auth flow with tests"
+# 호환 별칭
 /tfx-ralph "implement full auth flow with tests"
 
 # Team — Multi-CLI 병렬 오케스트레이션
@@ -91,7 +93,7 @@ tfx setup
 - **Anti-Herding** — 1라운드는 상호 참조 없이 병렬 실행하여 편향 오염을 원천 차단
 - **Expert Panel** — `tfx-panel`을 통한 가상 전문가 시뮬레이션 (Fowler, Newman, Porter 등)
 - **94% 토큰 절감** — `tfx-index`가 58K 토큰 분량의 파일 읽기를 3KB 프로젝트 맵으로 대체
-- **Persistence Loop** — `tfx-ralph`(3자 검증)와 `tfx-sisyphus`(자동 라우팅)가 검증 완료까지 반복 실행
+- **Persistence Loop** — `tfx-persist`(정식 이름, 3자 검증), `/tfx-ralph`(호환 별칭), `tfx-sisyphus`(자동 라우팅)가 검증 완료까지 반복 실행
 - **Hub IPC** — Named Pipe 및 HTTP MCP 브리지를 활용한 초고속 상주형 Hub 서버
 - **psmux / Windows 네이티브** — `tmux`(WSL)와 `psmux`(Windows Terminal) 하이브리드 지원
 
@@ -184,7 +186,7 @@ Phase 3: Resolution (합의율 < 70%일 경우)
 
 | 스킬 | 유형 | 설명 | 토큰 |
 |------|------|------|------|
-| `tfx-ralph` | Deep | 완료될 때까지 3자 검증 기반 반복 실행 | 가변 |
+| `tfx-persist` | Deep | 완료될 때까지 3자 검증 기반 반복 실행 (`/tfx-ralph` 호환 별칭) | 가변 |
 | `tfx-sisyphus` | Light | 모델 에스컬레이션을 갖춘 자동 라우팅 실행 | 가변 |
 
 ### 메타 및 유틸리티
@@ -306,7 +308,7 @@ tfx setup
 /tfx-debate "Redis vs PostgreSQL LISTEN/NOTIFY for real-time events"
 
 # Persistence — 완료될 때까지 멈추지 않음
-/tfx-ralph "implement full auth flow with tests"
+/tfx-persist "implement full auth flow with tests"  # /tfx-ralph도 동작
 
 # Team — Multi-CLI 병렬 오케스트레이션
 /tfx-multi "refactor auth + update UI + add tests"

package/README.md

@@ -66,6 +66,8 @@ tfx setup
 /tfx-debate "Redis vs PostgreSQL LISTEN/NOTIFY for real-time events"
 
 # Persistence — don't stop until done
+/tfx-persist "implement full auth flow with tests"
+# Compatibility alias
 /tfx-ralph "implement full auth flow with tests"
 
 # Team — Multi-CLI parallel orchestration
@@ -91,7 +93,7 @@ tfx setup
 - **Anti-Herding** — Round 1 runs in parallel with zero cross-visibility to prevent bias contamination
 - **Expert Panel** — Virtual expert simulation (Fowler, Newman, Porter, etc.) via `tfx-panel`
 - **94% Token Reduction** — `tfx-index` creates a 3KB project map replacing 58K tokens of file reads
-- **Persistence Loops** — `tfx-ralph` (3-party verified) and `tfx-sisyphus` (auto-routing) run until verified complete
+- **Persistence Loops** — `tfx-persist` (canonical, 3-party verified), `/tfx-ralph` (compat alias), and `tfx-sisyphus` (auto-routing) run until verified complete
 - **Hub IPC** — Lightning-fast resident Hub server with Named Pipe & HTTP MCP bridge
 - **psmux / Windows Native** — Hybrid support for `tmux` (WSL) and `psmux` (Windows Terminal)
 
@@ -184,7 +186,7 @@ Phase 3: Resolution (if consensus < 70%)
 
 | Skill | Type | Description | Tokens |
 |-------|------|-------------|--------|
-| `tfx-ralph` | Deep | 3-party verified persistence loop until done | varies |
+| `tfx-persist` | Deep | 3-party verified persistence loop until done (`/tfx-ralph` compat alias) | varies |
 | `tfx-sisyphus` | Light | Auto-routing execution with model escalation | varies |
 
 ### Meta & Utility
@@ -306,7 +308,7 @@ tfx setup
 /tfx-debate "Redis vs PostgreSQL LISTEN/NOTIFY for real-time events"
 
 # Persistence — Don't stop until done
-/tfx-ralph "implement full auth flow with tests"
+/tfx-persist "implement full auth flow with tests"  # /tfx-ralph also works
 
 # Team — Multi-CLI parallel orchestration
 /tfx-multi "refactor auth + update UI + add tests"

package/bin/triflux.mjs

@@ -42,6 +42,49 @@ const REQUIRED_CODEX_PROFILES = [
   },
 ];
 
+const SKILL_ALIASES = [
+  {
+    alias: "tfx-ralph",
+    source: "tfx-persist",
+  },
+];
+
+function buildAliasedSkillContent(srcContent, { alias, source }) {
+  return srcContent
+    .replace(/^name:\s*.+$/m, `name: ${alias}`)
+    .replaceAll(source, alias)
+    .replace(/^#\s+.+$/m, `# ${alias} — Compatibility Alias for ${source}`);
+}
+
+function syncAliasedSkillDir(srcDir, dstDir, { alias, source }) {
+  if (!existsSync(dstDir)) mkdirSync(dstDir, { recursive: true });
+
+  let count = 0;
+  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = join(srcDir, entry.name);
+    const dstPath = join(dstDir, entry.name);
+
+    if (entry.isDirectory()) {
+      count += syncAliasedSkillDir(srcPath, dstPath, { alias, source });
+      continue;
+    }
+
+    if (!entry.name.endsWith(".md")) continue;
+
+    const rawContent = readFileSync(srcPath, "utf8");
+    const nextContent = entry.name === "SKILL.md"
+      ? buildAliasedSkillContent(rawContent, { alias, source })
+      : rawContent;
+
+    if (!existsSync(dstPath) || readFileSync(dstPath, "utf8") !== nextContent) {
+      writeFileSync(dstPath, nextContent, "utf8");
+      count++;
+    }
+  }
+
+  return count;
+}
+
 // ── 색상 체계 (triflux brand: amber/orange accent) ──
 const CYAN = "\x1b[36m";
 const GREEN = "\x1b[32m";
@@ -678,6 +721,12 @@ function listSkillSyncActions() {
     if (!existsSync(src)) continue;
     actions.push(describeSyncAction(src, dst, `skill:${name}`));
   }
+  for (const { alias, source } of SKILL_ALIASES) {
+    const src = join(skillsSrc, source, "SKILL.md");
+    const dst = join(CLAUDE_DIR, "skills", alias, "SKILL.md");
+    if (!existsSync(src)) continue;
+    actions.push(describeSyncAction(src, dst, `skill-alias:${alias}`));
+  }
   return actions;
 }
 
@@ -806,6 +855,13 @@ function cmdSetup(options = {}) {
         }
       }
     }
+    for (const { alias, source } of SKILL_ALIASES) {
+      const srcDir = join(skillsSrc, source);
+      const src = join(srcDir, "SKILL.md");
+      if (!existsSync(src)) continue;
+      skillTotal++;
+      skillCount += syncAliasedSkillDir(srcDir, join(skillsDst, alias), { alias, source });
+    }
     if (skillCount > 0) {
       ok(`스킬: ${skillCount}/${skillTotal}개 업데이트됨`);
     } else {
@@ -1765,6 +1821,8 @@ function cmdList(options = {}) {
   const installedSkills = join(CLAUDE_DIR, "skills");
   const packageSkills = [];
   const userSkills = [];
+  const aliasNames = new Set(SKILL_ALIASES.map(({ alias }) => alias));
+  const skillAliases = [];
 
   if (existsSync(pluginSkills)) {
     for (const name of readdirSync(pluginSkills).sort()) {
@@ -1775,10 +1833,15 @@ function cmdList(options = {}) {
     }
   }
 
+  for (const { alias, source } of SKILL_ALIASES) {
+    const dst = join(installedSkills, alias, "SKILL.md");
+    skillAliases.push({ alias, source, installed: existsSync(dst) });
+  }
+
   const pkgNames = new Set(existsSync(pluginSkills) ? readdirSync(pluginSkills) : []);
   if (existsSync(installedSkills)) {
     for (const name of readdirSync(installedSkills).sort()) {
-      if (pkgNames.has(name)) continue;
+      if (pkgNames.has(name) || aliasNames.has(name)) continue;
       const skill = join(installedSkills, name, "SKILL.md");
       if (!existsSync(skill)) continue;
       userSkills.push(name);
@@ -1788,6 +1851,7 @@ function cmdList(options = {}) {
   if (json) {
     printJson({
       package_skills: packageSkills,
+      skill_aliases: skillAliases,
       user_skills: userSkills,
       install_path: installedSkills,
     });
@@ -1812,6 +1876,15 @@ function cmdList(options = {}) {
   }
   if (userSkills.length === 0) console.log(`    ${GRAY}없음${RESET}`);
 
+  if (skillAliases.length > 0) {
+    section("호환 alias");
+    for (const entry of skillAliases) {
+      const icon = entry.installed ? `${GREEN_BRIGHT}↳${RESET}` : `${RED_BRIGHT}↳${RESET}`;
+      const status = entry.installed ? "" : ` ${GRAY}(미설치)${RESET}`;
+      console.log(`    ${icon} ${BOLD}${entry.alias}${RESET} ${GRAY}→ ${entry.source}${RESET}${status}`);
+    }
+  }
+
   console.log(`\n  ${LINE}`);
   console.log(`  ${GRAY}${installedSkills}${RESET}\n`);
 }

package/hub/lib/process-utils.mjs

@@ -11,7 +11,7 @@ const SCAN_SCRIPT_PATH = join(CLEANUP_SCRIPT_DIR, "scan-processes.ps1");
 const TREE_SCRIPT_PATH = join(CLEANUP_SCRIPT_DIR, "get-ancestor-tree.ps1");
 
 // 스크립트 버전 — 내용 변경 시 증가하여 캐시된 스크립트를 갱신
-const SCRIPT_VERSION = 2;
+const SCRIPT_VERSION = 3;
 const VERSION_FILE = join(CLEANUP_SCRIPT_DIR, ".version");
 
 /**
@@ -32,6 +32,69 @@ export function isPidAlive(pid) {
   }
 }
 
+/**
+ * 동기적 sleep. Atomics.wait 우선, 불가 시 busy-wait 폴백.
+ */
+function sleepSyncMs(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { /* spin */ }
+  }
+}
+
+/**
+ * 고아 PID 목록에 SIGTERM → 3초 대기 → SIGKILL 에스컬레이션을 적용한다.
+ * PID 재사용 레이스 방어: SIGTERM 전 alive 확인, SIGKILL 전 재검증.
+ * @param {number[]} orphanPids
+ * @param {Map<number, {ppid: number, name: string}>} [procMap] PID 재사용 감지용 스냅샷
+ * @returns {number} killed count
+ */
+function killWithEscalation(orphanPids, procMap) {
+  if (orphanPids.length === 0) return 0;
+
+  // SIGTERM 전 alive 스냅샷 — 이미 죽은 PID는 카운트에서 제외
+  const aliveBeforeKill = new Set(orphanPids.filter(pid => isPidAlive(pid)));
+
+  for (const pid of aliveBeforeKill) {
+    try { process.kill(pid, "SIGTERM"); } catch {}
+  }
+
+  sleepSyncMs(3000);
+
+  let killed = 0;
+  for (const pid of aliveBeforeKill) {
+    if (isPidAlive(pid)) {
+      // PID 재사용 방어: procMap이 있으면 스캔 시점의 ppid와 현재 ppid 비교
+      // ppid가 변경되었으면 PID가 재사용된 것이므로 kill하지 않���
+      if (procMap) {
+        const snapshot = procMap.get(pid);
+        if (snapshot) {
+          try {
+            const current = execSync(
+              process.platform === "win32"
+                ? `powershell -NoProfile -WindowStyle Hidden -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' -ErrorAction SilentlyContinue).ParentProcessId"`
+                : `ps -o ppid= -p ${pid}`,
+              { encoding: "utf8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"], windowsHide: true },
+            );
+            const currentPpid = Number.parseInt(current.trim(), 10);
+            if (Number.isFinite(currentPpid) && currentPpid !== snapshot.ppid) {
+              continue; // PID 재사용 감지 — skip
+            }
+          } catch {
+            // 조회 실패 시 안전하게 skip
+            continue;
+          }
+        }
+      }
+      try { process.kill(pid, "SIGKILL"); } catch {}
+    }
+    if (!isPidAlive(pid)) killed++;
+  }
+  return killed;
+}
+
 /**
  * PowerShell 헬퍼 스크립트를 임시 디렉토리에 생성한다.
  * bash의 $_ 이스케이핑 문제를 피하기 위해 -File로 실행.
@@ -69,10 +132,12 @@ function ensureHelperScripts() {
   }
 
   if (!existsSync(SCAN_SCRIPT_PATH)) {
-    // node.exe + bash.exe + cmd.exe 전체를 스캔하여 PID,ParentPID,Name 출력
+    // CLI + 쉘 + 런타임 전체를 스캔하여 PID,ParentPID,Name 출력
+    // codex/claude/pwsh/uvx 누락 시 중간 프로세스가 alive 판정되어 고아 트리 전체가 보호됨
+    // 예: WT(dead)→pwsh(alive,미스캔)→codex→cmd→node — pwsh에서 isPidAlive=true로 끊김
     writeFileSync(SCAN_SCRIPT_PATH, [
       "$ErrorActionPreference = 'SilentlyContinue'",
-      "Get-CimInstance Win32_Process -Filter \"Name='node.exe' OR Name='bash.exe' OR Name='cmd.exe'\" | ForEach-Object {",
+      "Get-CimInstance Win32_Process -Filter \"Name='node.exe' OR Name='bash.exe' OR Name='cmd.exe' OR Name='codex.exe' OR Name='claude.exe' OR Name='pwsh.exe' OR Name='uvx.exe'\" | ForEach-Object {",
       '    Write-Output "$($_.ProcessId),$($_.ParentProcessId),$($_.Name)"',
       "}",
     ].join("\n"), "utf8");
@@ -121,18 +186,27 @@ function hasLiveAncestorChain(pid, procMap, protectedPids) {
   return false;
 }
 
+// kill 대상 프로세스 이름 (Windows)
+// codex/claude도 포함: protectedPids + hasLiveAncestorChain이 활성 인스턴스를 보호하므로
+// 고아(부모 dead + 자식 dead)만 kill됨. pwsh.exe는 사용자 인터랙티브 쉘이므로 제외.
+const KILLABLE_NAMES = new Set([
+  "node.exe", "bash.exe", "cmd.exe", "uvx.exe",
+  "codex.exe", "claude.exe",
+]);
+
 /**
- * 고아 프로세스 트리를 정리한다 (node.exe + bash.exe + cmd.exe).
+ * 고아 프로세스 트리를 정리한다 (node.exe + bash.exe + cmd.exe + uvx.exe).
  * Windows 전용 — Agent 서브프로세스가 MCP 서버, bash 래퍼, cmd 래퍼를 남기는 문제 대응.
  *
  * 전략: 부모 체인을 루트까지 추적하여, 체인 중간에 죽은 프로세스가 있으면
  * 해당 프로세스 아래의 전체 트리를 고아로 판정하고 정리.
+ * 스캔 범위에는 codex/claude/pwsh도 포함하여 체인 추적 정확도를 높인다.
  *
  * 보호 대상: 현재 프로세스 조상 트리, Hub PID
  * @returns {{ killed: number, remaining: number }}
  */
 export function cleanupOrphanNodeProcesses() {
-  if (process.platform !== "win32") return { killed: 0, remaining: 0 };
+  if (process.platform !== "win32") return cleanupOrphansUnix();
 
   ensureHelperScripts();
 
@@ -164,7 +238,7 @@ export function cleanupOrphanNodeProcesses() {
     }
   } catch {}
 
-  // 전체 프로세스 맵 구축 (node + bash + cmd)
+  // 전체 프로세스 맵 구축 (node + bash + cmd + codex + claude + pwsh + uvx)
   const procMap = new Map();
   try {
     const output = execSync(
@@ -184,21 +258,18 @@ export function cleanupOrphanNodeProcesses() {
     }
   } catch {}
 
-  // 고아 판정 + 정리
-  let killed = 0;
+  // 고아 판정 + 정리 (SIGTERM → 3s → SIGKILL 에스컬레이션)
+  // CLI 도구(codex/claude/pwsh)는 체인 추적용으로만 스캔 — kill 대상에서 제외
+  const orphanPids = [];
   for (const [pid, info] of procMap) {
     if (protectedPids.has(pid)) continue;
-
-    // 조상 체인이 살아있으면 건드리지 않음
+    if (!KILLABLE_NAMES.has(info.name?.toLowerCase())) continue;
     if (hasLiveAncestorChain(pid, procMap, protectedPids)) continue;
-
-    // 고아 → 종료
-    try {
-      process.kill(pid, "SIGTERM");
-      killed++;
-    } catch {}
+    orphanPids.push(pid);
   }
 
+  const killed = killWithEscalation(orphanPids, procMap);
+
   // 남은 프로세스 수 확인
   let remaining = 0;
   try {
@@ -211,3 +282,79 @@ export function cleanupOrphanNodeProcesses() {
 
   return { killed, remaining };
 }
+
+/**
+ * Unix/macOS 고아 프로세스 정리.
+ * `ps -eo pid,ppid,comm` 기반 프로세스 맵 → 동일한 조상 체인 판정 → SIGKILL 에스컬레이션.
+ * @returns {{ killed: number, remaining: number }}
+ */
+function cleanupOrphansUnix() {
+  const myPid = process.pid;
+
+  // Hub PID 보호
+  const protectedPids = new Set();
+  protectedPids.add(myPid);
+  try {
+    const hubPidPath = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
+    if (existsSync(hubPidPath)) {
+      const hubPid = Number(JSON.parse(readFileSync(hubPidPath, "utf8"))?.pid);
+      if (Number.isFinite(hubPid) && hubPid > 0) protectedPids.add(hubPid);
+    }
+  } catch {}
+
+  // 현재 프로세스의 조상 트리 보호
+  try {
+    let current = myPid;
+    for (let i = 0; i < 10; i++) {
+      protectedPids.add(current);
+      const output = execSync(`ps -o ppid= -p ${current}`, {
+        encoding: "utf8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+      });
+      const ppid = Number.parseInt(output.trim(), 10);
+      if (!Number.isFinite(ppid) || ppid <= 1) break;
+      current = ppid;
+    }
+  } catch {}
+
+  // 프로세스 맵 구축 (런타임 + CLI — 체인 추적 정확도를 위해 CLI도 포함)
+  const procMap = new Map();
+  try {
+    const output = execSync("ps -eo pid,ppid,comm", {
+      encoding: "utf8", timeout: 10000, stdio: ["pipe", "pipe", "pipe"],
+    });
+    for (const line of output.split("\n").slice(1)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 3) continue;
+      const pid = Number.parseInt(parts[0], 10);
+      const ppid = Number.parseInt(parts[1], 10);
+      const name = parts.slice(2).join(" ");
+      if (Number.isFinite(pid) && pid > 0 && /^(node|bash|sh|python|codex|claude|uvx)/.test(name)) {
+        procMap.set(pid, { ppid, name });
+      }
+    }
+  } catch {}
+
+  // kill 대상: node, python, codex, claude, uvx — bash/sh는 사용자 인터랙티브 쉘 가능성
+  const killableUnix = /^(node|python|codex|claude|uvx)/;
+
+  // 고아 판정 + SIGKILL 에스컬레이션
+  const orphanPids = [];
+  for (const [pid, info] of procMap) {
+    if (protectedPids.has(pid)) continue;
+    if (!killableUnix.test(info.name)) continue;
+    if (hasLiveAncestorChain(pid, procMap, protectedPids)) continue;
+    orphanPids.push(pid);
+  }
+
+  const killed = killWithEscalation(orphanPids, procMap);
+
+  let remaining = 0;
+  try {
+    const output = execSync("ps -eo comm | grep -c '^node$'", {
+      encoding: "utf8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+    });
+    remaining = Number.parseInt(output.trim(), 10) || 0;
+  } catch {}
+
+  return { killed, remaining };
+}

package/hub/server.mjs

@@ -5,6 +5,7 @@ import { extname, join, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { writeFileSync, unlinkSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { execSync as execSyncHub } from 'node:child_process';
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -779,8 +780,7 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
   }, 60000);
   sessionTimer.unref();
 
-  // 고아 node.exe 프로세스 주기적 정리 (5분마다)
-  // Agent 서브프로세스가 MCP 서버를 남기는 Windows 이슈 대응
+  // 고아 node.exe 프로세스 + stale spawn 세션 주기적 정리 (5분마다)
   const orphanCleanupTimer = setInterval(() => {
     try {
       const { killed } = cleanupOrphanNodeProcesses();
@@ -788,6 +788,14 @@ export async function startHub({ port = 27888, dbPath, host = '127.0.0.1', sessi
         hubLog.info({ killed }, 'hub.orphan_cleanup');
       }
     } catch {}
+
+    // stale tfx-spawn-* psmux 세션 정리 (30분 이상 idle)
+    try {
+      const staleKilled = cleanupStaleSpawnSessions(hubLog);
+      if (staleKilled > 0) {
+        hubLog.info({ killed: staleKilled }, 'hub.stale_spawn_cleanup');
+      }
+    } catch {}
   }, 5 * 60 * 1000);
   orphanCleanupTimer.unref();
 
@@ -920,6 +928,56 @@ export function getHubInfo() {
   }
 }
 
+/**
+ * stale tfx-spawn-* psmux 세션을 감지하고 정리한다.
+ * 30분 이상 경과 + pane이 idle 쉘 프롬프트만 표시 → kill.
+ * @param {object} [log] logger (optional)
+ * @returns {number} killed session count
+ */
+function cleanupStaleSpawnSessions(log) {
+  const MAX_AGE_MS = 30 * 60 * 1000;
+  const IDLE_PROMPT_RE = /^(PS\s|[$%>#]\s*$|\w+@[\w.-]+[:\s]|╰─|╭─|[fb]wd-i-search:|client_loop:\s|Connection\s+(reset|closed))/;
+  const execOpts = { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"], windowsHide: true };
+
+  let killed = 0;
+  let raw;
+  try {
+    raw = execSyncHub("psmux list-sessions", execOpts);
+  } catch {
+    return 0; // psmux 없거나 실패
+  }
+
+  const now = Date.now();
+  for (const line of raw.split(/\r?\n/)) {
+    const match = line.match(/^(tfx-spawn-[^:]+):\s+\d+\s+windows?\s+\(created\s+(.+)\)/);
+    if (!match) continue;
+
+    const [, sessionName, createdStr] = match;
+    if (!/^[a-zA-Z0-9_-]+$/.test(sessionName)) continue; // shell injection 방지
+    const created = new Date(createdStr).getTime();
+    if (!Number.isFinite(created) || now - created < MAX_AGE_MS) continue;
+
+    // pane 내용 확인 — 마지막 3줄 중 idle 쉘 프롬프트가 있는지
+    try {
+      const pane = execSyncHub(`psmux capture-pane -t "${sessionName}:0.0" -p`, execOpts);
+      const tailLines = pane.split(/\r?\n/).filter((l) => l.trim()).slice(-3);
+      const hasIdleLine = tailLines.some((l) => IDLE_PROMPT_RE.test(l.trim()));
+      if (!hasIdleLine) continue; // 아직 활성 — 건드리지 않음
+    } catch {
+      continue; // pane 접근 실패 — 건드리지 않음
+    }
+
+    // stale + idle → 정리
+    try {
+      execSyncHub(`psmux kill-session -t "${sessionName}"`, execOpts);
+      killed++;
+      if (log) log.info({ session: sessionName, ageMin: Math.round((now - created) / 60000) }, "hub.stale_spawn_killed");
+    } catch {}
+  }
+
+  return killed;
+}
+
 const selfRun = process.argv[1]?.replace(/\\/g, '/').endsWith('hub/server.mjs');
 if (selfRun) {
   const port = parseInt(process.env.TFX_HUB_PORT || '27888', 10);
@@ -928,6 +986,8 @@ if (selfRun) {
   startHub({ port, dbPath }).then((info) => {
     const shutdown = async (signal) => {
       hubLog.info({ signal }, 'hub.stopping');
+      try { cleanupOrphanNodeProcesses(); } catch {}
+      try { cleanupStaleSpawnSessions(hubLog); } catch {}
       await info.stop();
       process.exit(0);
     };

package/hub/team/native-supervisor.mjs

@@ -1,6 +1,6 @@
 // hub/team/native-supervisor.mjs — tmux 없이 멀티 CLI를 직접 띄우는 네이티브 팀 런타임
 import { createServer } from "node:http";
-import { spawn } from "node:child_process";
+import { spawn, execSync as execSyncSupervisor } from "node:child_process";
 import { mkdirSync, readFileSync, writeFileSync, createWriteStream } from "node:fs";
 import { dirname, join } from "node:path";
 import { verifySlimWrapperRouteExecution } from "./native.mjs";
@@ -275,7 +275,13 @@ async function shutdown() {
   setTimeout(() => {
     for (const state of processMap.values()) {
       if (state.status === "running") {
-        try { state.child.kill("SIGKILL"); } catch {}
+        const pid = state.child?.pid;
+        if (process.platform === "win32" && Number.isInteger(pid) && pid > 0) {
+          // Windows: 프로세스 트리 전체 강제 종료 (손자 MCP 서버 포함)
+          try { execSyncSupervisor(`taskkill /T /F /PID ${pid}`, { stdio: "pipe", windowsHide: true, timeout: 5000 }); } catch {}
+        } else {
+          try { state.child.kill("SIGKILL"); } catch {}
+        }
       }
     }
     process.exit(0);

package/package.json

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

package/scripts/hub-ensure.mjs

@@ -72,7 +72,6 @@ function startHubDetached(port) {
       // hook timeout 시 프로세스 트리 킬에서 살아남음
       const child = spawn("cmd.exe", ["/c", "start", "/b", "", process.execPath, serverPath], {
         env,
-        detached: true,
         stdio: "ignore",
         windowsHide: true,
       });

package/scripts/mcp-cleanup.ps1

@@ -0,0 +1,17 @@
+# mcp-cleanup.ps1 — Claude Code Stop hook: MCP 고아 프로세스 정리
+# Windows에서 Claude Code 세션 종료 시 남는 MCP 서버 고아 프로세스를 정리한다.
+# 원인: Claude Code가 stdio MCP 자식 프로세스 트리를 Windows에서 제대로 kill하지 못함
+#       (GitHub Issues #1935, #15211, #28126)
+$ErrorActionPreference = 'SilentlyContinue'
+
+# npx MCP servers (brave, notion, context7, exa, tavily, jira, playwright, etc.)
+# + oh-my-codex MCP servers (team/code-intel/memory/trace/state)
+# + omc bridge
+Get-CimInstance Win32_Process -Filter "Name='node.exe' OR Name='cmd.exe'" |
+  Where-Object { $_.CommandLine -match 'npx-cli|oh-my-codex[\\/]dist[\\/]mcp|omc.*bridge.*mcp-server' } |
+  ForEach-Object { taskkill /F /PID $_.ProcessId 2>$null }
+
+# serena (uvx) + python MCP orphans
+Get-CimInstance Win32_Process -Filter "Name='python.exe' OR Name='uvx.exe'" |
+  Where-Object { $_.CommandLine -match 'serena|uv[\\/](cache|python)' } |
+  ForEach-Object { taskkill /F /PID $_.ProcessId 2>$null }

package/scripts/remote-spawn.mjs

@@ -19,6 +19,7 @@ import {
   capturePsmuxPane,
   createPsmuxSession,
   hasPsmux,
+  killPsmuxSession,
   listPsmuxSessions,
   psmuxExec,
   psmuxSessionExists,
@@ -661,35 +662,40 @@ function spawnLocal(args, claudePath, prompt) {
   }
 
   createPsmuxSession(sessionName, { layout: "1xN", paneCount: 1 });
-  sendKeysToPane(paneId, `cd '${escapePwshSingleQuoted(dir)}'`);
-  sleepMs(300);
-
-  if (prompt && tmpFile) {
-    // pwsh -File 패턴: 인라인 쿼팅 문제 회피 (피드백: -Command 금지)
-    // 1단계: 프롬프트를 Get-Content -Raw → claude -p (one-shot), 세션 ID 추출
-    // 2단계: --resume으로 인터랙티브 세션 이어붙이기
-    const tmpFileNorm = normalizeCommandPath(tmpFile);
-    const flags = getPermissionFlag().map((f) => `'${escapePwshSingleQuoted(f)}'`).join(", ");
-    const scriptContent = [
-      `$ErrorActionPreference = 'SilentlyContinue'`,
-      `$t = '${escapePwshSingleQuoted(tmpFileNorm)}'`,
-      `$c = '${escapePwshSingleQuoted(claudePathNorm)}'`,
-      `$f = @(${flags})`,
-      `$raw = Get-Content -Raw $t`,
-      `Remove-Item -ErrorAction SilentlyContinue $t`,
-      `Remove-Item -ErrorAction SilentlyContinue $MyInvocation.MyCommand.Definition`,
-      `& $c @f $raw`,
-    ].join("\n");
-    const scriptFile = join(tmpdir(), `tfx-spawn-${randomUUID().slice(0, 8)}.ps1`);
-    writeFileSync(scriptFile, scriptContent, { encoding: "utf8" });
-    sendKeysToPane(paneId, `pwsh -NoProfile -NoExit -File '${escapePwshSingleQuoted(normalizeCommandPath(scriptFile))}'`);
-  } else {
-    const command = `& '${escapePwshSingleQuoted(claudePathNorm)}'${permissionFlags ? ` ${permissionFlags}` : ""}`;
-    sendKeysToPane(paneId, command);
-  }
+  try {
+    sendKeysToPane(paneId, `cd '${escapePwshSingleQuoted(dir)}'`);
+    sleepMs(300);
+
+    if (prompt && tmpFile) {
+      // pwsh -File 패턴: 인라인 쿼팅 문제 회피 (피드백: -Command 금지)
+      // 1단계: 프롬프트를 Get-Content -Raw → claude -p (one-shot), 세션 ID 추출
+      // 2단계: --resume으로 인터랙티브 세션 이어붙이기
+      const tmpFileNorm = normalizeCommandPath(tmpFile);
+      const flags = getPermissionFlag().map((f) => `'${escapePwshSingleQuoted(f)}'`).join(", ");
+      const scriptContent = [
+        `$ErrorActionPreference = 'SilentlyContinue'`,
+        `$t = '${escapePwshSingleQuoted(tmpFileNorm)}'`,
+        `$c = '${escapePwshSingleQuoted(claudePathNorm)}'`,
+        `$f = @(${flags})`,
+        `$raw = Get-Content -Raw $t`,
+        `Remove-Item -ErrorAction SilentlyContinue $t`,
+        `Remove-Item -ErrorAction SilentlyContinue $MyInvocation.MyCommand.Definition`,
+        `& $c @f $raw`,
+      ].join("\n");
+      const scriptFile = join(tmpdir(), `tfx-spawn-${randomUUID().slice(0, 8)}.ps1`);
+      writeFileSync(scriptFile, scriptContent, { encoding: "utf8" });
+      sendKeysToPane(paneId, `pwsh -NoProfile -NoExit -File '${escapePwshSingleQuoted(normalizeCommandPath(scriptFile))}'`);
+    } else {
+      const command = `& '${escapePwshSingleQuoted(claudePathNorm)}'${permissionFlags ? ` ${permissionFlags}` : ""}`;
+      sendKeysToPane(paneId, command);
+    }
 
-  openAttachTab(sessionName, "Claude@local");
-  console.log(sessionName);
+    openAttachTab(sessionName, "Claude@local");
+    console.log(sessionName);
+  } catch (err) {
+    try { killPsmuxSession(sessionName); } catch {}
+    throw err;
+  }
 }
 
 async function spawnRemote(args, prompt) {
@@ -715,26 +721,31 @@ async function spawnRemote(args, prompt) {
   const permissionFlags = getPermissionFlag().join(" ");
 
   createPsmuxSession(sessionName, { layout: "1xN", paneCount: 1 });
-  sendKeysToPane(paneId, `ssh -t ${host}`);
-  await waitForRemotePrompt(sessionName, paneId);
+  try {
+    sendKeysToPane(paneId, `ssh -t ${host}`);
+    await waitForRemotePrompt(sessionName, paneId);
+
+    if (env.shell === "pwsh") {
+      const claudeCommand = `& "${escapePwshDoubleQuoted(env.claudePath)}"${permissionFlags ? ` ${permissionFlags}` : ""}`;
+      sendKeysToPane(paneId, `cd '${escapePwshSingleQuoted(resolvedDir)}'`);
+      sendKeysToPane(paneId, claudeCommand);
+    } else {
+      const claudeCommand = `${shellQuote(env.claudePath)}${permissionFlags ? ` ${permissionFlags}` : ""}`;
+      sendKeysToPane(paneId, `cd ${shellQuote(resolvedDir)}`);
+      sendKeysToPane(paneId, claudeCommand);
+    }
 
-  if (env.shell === "pwsh") {
-    const claudeCommand = `& "${escapePwshDoubleQuoted(env.claudePath)}"${permissionFlags ? ` ${permissionFlags}` : ""}`;
-    sendKeysToPane(paneId, `cd '${escapePwshSingleQuoted(resolvedDir)}'`);
-    sendKeysToPane(paneId, claudeCommand);
-  } else {
-    const claudeCommand = `${shellQuote(env.claudePath)}${permissionFlags ? ` ${permissionFlags}` : ""}`;
-    sendKeysToPane(paneId, `cd ${shellQuote(resolvedDir)}`);
-    sendKeysToPane(paneId, claudeCommand);
-  }
+    if (prompt) {
+      sleepMs(2000);
+      sendKeysToPane(paneId, prompt);
+    }
 
-  if (prompt) {
-    sleepMs(2000);
-    sendKeysToPane(paneId, prompt);
+    openAttachTab(sessionName, `Claude@${host}`);
+    console.log(sessionName);
+  } catch (err) {
+    try { killPsmuxSession(sessionName); } catch {}
+    throw err;
   }
-
-  openAttachTab(sessionName, `Claude@${host}`);
-  console.log(sessionName);
 }
 
 function sendPromptToSession(sessionName, prompt) {

package/scripts/setup.mjs

@@ -53,6 +53,49 @@ const REQUIRED_CODEX_PROFILES = [
   },
 ];
 
+const SKILL_ALIASES = [
+  {
+    alias: "tfx-ralph",
+    source: "tfx-persist",
+  },
+];
+
+function buildAliasedSkillContent(srcContent, { alias, source }) {
+  return srcContent
+    .replace(/^name:\s*.+$/m, `name: ${alias}`)
+    .replaceAll(source, alias)
+    .replace(/^#\s+.+$/m, `# ${alias} — Compatibility Alias for ${source}`);
+}
+
+function syncAliasedSkillDir(srcDir, dstDir, { alias, source }) {
+  if (!existsSync(dstDir)) mkdirSync(dstDir, { recursive: true });
+
+  let count = 0;
+  for (const entry of readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = join(srcDir, entry.name);
+    const dstPath = join(dstDir, entry.name);
+
+    if (entry.isDirectory()) {
+      count += syncAliasedSkillDir(srcPath, dstPath, { alias, source });
+      continue;
+    }
+
+    if (!entry.name.endsWith(".md")) continue;
+
+    const rawContent = readFileSync(srcPath, "utf8");
+    const nextContent = entry.name === "SKILL.md"
+      ? buildAliasedSkillContent(rawContent, { alias, source })
+      : rawContent;
+
+    if (!existsSync(dstPath) || readFileSync(dstPath, "utf8") !== nextContent) {
+      writeFileSync(dstPath, nextContent, "utf8");
+      count++;
+    }
+  }
+
+  return count;
+}
+
 // ── 파일 동기화 ──
 
 const SYNC_MAP = [
@@ -101,6 +144,11 @@ const SYNC_MAP = [
     dst: join(CLAUDE_DIR, "scripts", "hub", "workers", "factory.mjs"),
     label: "hub/workers/factory.mjs",
   },
+  {
+    src: join(PLUGIN_ROOT, "scripts", "mcp-cleanup.ps1"),
+    dst: join(CLAUDE_DIR, "scripts", "mcp-cleanup.ps1"),
+    label: "mcp-cleanup.ps1",
+  },
   {
     src: join(PLUGIN_ROOT, "hud", "hud-qos-status.mjs"),
     dst: join(CLAUDE_DIR, "hud", "hud-qos-status.mjs"),
@@ -282,7 +330,7 @@ function ensureCodexProfiles() {
   }
 }
 
-export { replaceProfileSection, hasProfileSection, detectDevMode, SYNC_MAP, BREADCRUMB_PATH, PLUGIN_ROOT, CLAUDE_DIR };
+export { replaceProfileSection, hasProfileSection, detectDevMode, SYNC_MAP, BREADCRUMB_PATH, PLUGIN_ROOT, CLAUDE_DIR, SKILL_ALIASES };
 
 async function main() {
 const isSync = process.argv.includes("--sync");
@@ -424,6 +472,13 @@ if (existsSync(skillsSrc)) {
 
     synced += syncSkillDir(skillDir, join(skillsDst, name));
   }
+
+  for (const { alias, source } of SKILL_ALIASES) {
+    const sourceDir = join(skillsSrc, source);
+    const sourceSkillMd = join(sourceDir, "SKILL.md");
+    if (!existsSync(sourceSkillMd)) continue;
+    synced += syncAliasedSkillDir(sourceDir, join(skillsDst, alias), { alias, source });
+  }
 }
 
 // ── settings.json 통합 R/W ──
@@ -530,6 +585,44 @@ function applyHooks(s) {
     changed = true;
   }
 
+  // ── Stop 훅: MCP 고아 프로세스 정리 (Windows 전용) ──
+  if (process.platform === "win32") {
+    if (!Array.isArray(s.hooks.Stop)) s.hooks.Stop = [];
+
+    const cleanupScriptPath = join(CLAUDE_DIR, "scripts", "mcp-cleanup.ps1").replace(/\\/g, "/");
+    const hasCleanupHook = s.hooks.Stop.some((entry) =>
+      Array.isArray(entry.hooks) &&
+      entry.hooks.some((h) => typeof h.command === "string" && h.command.includes("mcp-cleanup")),
+    );
+
+    if (!hasCleanupHook && existsSync(cleanupScriptPath.replace(/\//g, "\\"))) {
+      // 기존 Stop 엔트리가 있으면 거기에 추가, 없으면 새 엔트리 생성
+      const existingEntry = s.hooks.Stop.find((entry) => entry.matcher === "*" && Array.isArray(entry.hooks));
+      const cleanupHook = {
+        type: "command",
+        command: `powershell -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File "${cleanupScriptPath}"`,
+        timeout: 8,
+      };
+
+      if (existingEntry) {
+        existingEntry.hooks.push(cleanupHook);
+      } else {
+        s.hooks.Stop.push({ matcher: "*", hooks: [cleanupHook] });
+      }
+      changed = true;
+    } else if (hasCleanupHook) {
+      for (const entry of s.hooks.Stop) {
+        if (!Array.isArray(entry.hooks)) continue;
+        for (const h of entry.hooks) {
+          if (typeof h.command === "string" && h.command.includes("mcp-cleanup") && !h.command.includes(cleanupScriptPath)) {
+            h.command = `powershell -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File "${cleanupScriptPath}"`;
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+
   // ── PreToolUse 훅: headless-guard (auto-route) ──
   if (!Array.isArray(s.hooks.PreToolUse)) s.hooks.PreToolUse = [];
 

package/skills/tfx-remote-setup/SKILL.md

@@ -337,7 +337,49 @@ options:
 
 저장 후 결과 보고.
 
-**2-8. 후속 작업**
+**2-8. MCP 고아 프로세스 정리 훅 배포 (Windows 원격 호스트)**
+
+원격 호스트가 Windows인 경우, MCP 고아 프로세스 정리 훅을 자동 배포한다.
+Claude Code 세션 종료 시 MCP 서버 프로세스가 정리되지 않는 Windows 고유 버그 대응.
+(GitHub Issues #1935, #15211, #28126)
+
+```bash
+# mcp-cleanup.ps1 배포
+scp "$(npm root -g)/triflux/scripts/mcp-cleanup.ps1" {host}:~/.claude/scripts/mcp-cleanup.ps1
+```
+
+배포 후 원격 호스트의 `~/.claude/settings.json`에 Stop 훅을 등록한다:
+
+```bash
+ssh {host} "node -e \"
+  const fs = require('fs');
+  const p = require('path').join(require('os').homedir(), '.claude', 'settings.json');
+  const s = JSON.parse(fs.readFileSync(p, 'utf8'));
+  if (!s.hooks) s.hooks = {};
+  if (!Array.isArray(s.hooks.Stop)) s.hooks.Stop = [];
+  const has = s.hooks.Stop.some(e => e.hooks?.some(h => h.command?.includes('mcp-cleanup')));
+  if (!has) {
+    const script = require('path').join(require('os').homedir(), '.claude/scripts/mcp-cleanup.ps1').replace(/\\\\\\\\/g, '/');
+    const entry = s.hooks.Stop.find(e => e.matcher === '*' && Array.isArray(e.hooks));
+    const hook = { type: 'command', command: 'powershell -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File \\\"' + script + '\\\"', timeout: 8 };
+    if (entry) entry.hooks.push(hook); else s.hooks.Stop.push({ matcher: '*', hooks: [hook] });
+    fs.writeFileSync(p, JSON.stringify(s, null, 2) + '\\n');
+    console.log('mcp-cleanup hook registered');
+  } else { console.log('mcp-cleanup hook already exists'); }
+\""
+```
+
+macOS/Linux 원격 호스트에서는 이 단계를 건너뛴다 (PGID 기반 kill이 정상 동작).
+
+프로브 결과에서 OS를 확인하여 자동 판단:
+- Windows → 배포 실행
+- macOS/Linux → 건너뛰기 (표시만)
+
+```
+"{host}는 Windows입니다. MCP 고아 프로세스 정리 훅을 배포합니다."
+```
+
+**2-9. 후속 작업**
 
 ```
 question: "호스트가 등록되었습니다. 추가 작업이 있습니까?"