triflux 7.0.4 → 7.0.6

package/hub/team/headless.mjs

@@ -144,16 +144,8 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     applyTrifluxTheme(sessionName);
     if (safeProgress) safeProgress({ type: "session_created", sessionName, panes: session.panes });
 
-    // v7.0: dashboard pane — pane 0에 TUI 뷰어를 send-keys로 실행
-    if (dashboard) {
-      const viewerPath = join(import.meta.dirname, "tui-viewer.mjs").replace(/\\/g, "/");
-      const resultDir = RESULT_DIR.replace(/\\/g, "/");
-      const viewerCmd = `node ${viewerPath} --session ${sessionName} --result-dir ${resultDir}`;
-      try {
-        psmuxExec(["send-keys", "-t", `${sessionName}:0.0`, viewerCmd, "Enter"]);
-        psmuxExec(["select-pane", "-t", `${sessionName}:0.0`, "-T", "▲ dashboard"]);
-      } catch { /* 무시 */ }
-    }
+    // dashboard: 워커 pane을 먼저 생성한 후 pane 0에 대시보드를 실행
+    // (listPanes로 워커 감지가 가능하려면 워커 pane이 먼저 존재해야 함)
 
     dispatches = assignments.map((assignment, i) => {
       const paneName = `worker-${i + 1}`;
@@ -196,6 +188,17 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     // 모든 split 완료 후 레이아웃 한 번만 정렬 (깜빡임 방지)
     try { psmuxExec(["select-layout", "-t", sessionName, "tiled"]); } catch { /* 무시 */ }
 
+    // v7.0.6: 워커 pane 생성 후 대시보드 시작 (워커가 먼저 존재해야 listPanes 감지 가능)
+    if (dashboard) {
+      const viewerPath = join(import.meta.dirname, "tui-viewer.mjs").replace(/\\/g, "/");
+      const resultDir = RESULT_DIR.replace(/\\/g, "/");
+      const viewerCmd = `node ${viewerPath} --session ${sessionName}`;
+      try {
+        psmuxExec(["send-keys", "-t", `${sessionName}:0.0`, viewerCmd, "Enter"]);
+        psmuxExec(["select-pane", "-t", `${sessionName}:0.0`, "-T", "▲ dashboard"]);
+      } catch { /* 무시 */ }
+    }
+
   } else {
     // ─── 기존 모드: 모든 pane을 한 번에 생성 ───
     const paneCount = assignments.length + 1;

package/hub/team/tui-viewer.mjs

@@ -1,130 +1,143 @@
 #!/usr/bin/env node
-// hub/team/tui-viewer.mjs — psmux pane용 TUI 대시보드 뷰어
-// 독립 프로세스로 실행되어 headless 워커 상태를 실시간 렌더링한다.
-//
-// 실행: node hub/team/tui-viewer.mjs --session <name> [--result-dir <dir>]
-//
-// 데이터 소스: result 파일 (RESULT_DIR/{session}-worker-N.txt) polling
-// + psmux capture-pane (워커 진행 상황)
+// hub/team/tui-viewer.mjs — psmux pane용 TUI 대시보드 뷰어 v2
+// 같은 psmux 세션의 워커 pane을 capture-pane으로 실시간 모니터링
 
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { createTui } from "./tui.mjs";
 import { processHandoff } from "./handoff.mjs";
 
-// ── 인자 파싱 ──
 const args = process.argv.slice(2);
 const sessionIdx = args.indexOf("--session");
-const resultDirIdx = args.indexOf("--result-dir");
 const SESSION = sessionIdx >= 0 ? args[sessionIdx + 1] : null;
-const RESULT_DIR = resultDirIdx >= 0 ? args[resultDirIdx + 1] : join(tmpdir(), "tfx-headless");
+const RESULT_DIR = join(tmpdir(), "tfx-headless");
 
 if (!SESSION) {
   process.stderr.write("Usage: node tui-viewer.mjs --session <name>\n");
   process.exit(1);
 }
 
-// ── TUI 초기화 ──
-const tui = createTui({ refreshMs: 0 }); // 수동 렌더 (폴링 주기에 맞춤)
-
-// ── 워커 상태 폴링 ──
-const POLL_MS = 800;
-const knownWorkers = new Map(); // paneName → { resultFile, lastSize, done }
-
-function discoverWorkers() {
-  if (!existsSync(RESULT_DIR)) return;
-  const prefix = `${SESSION}-worker-`;
-  for (const f of readdirSync(RESULT_DIR)) {
-    if (!f.startsWith(prefix) || !f.endsWith(".txt")) continue;
-    const paneName = f.replace(`${SESSION}-`, "").replace(".txt", "");
-    if (!knownWorkers.has(paneName)) {
-      knownWorkers.set(paneName, {
-        resultFile: join(RESULT_DIR, f),
-        lastSize: 0,
-        done: false,
-      });
-      tui.updateWorker(paneName, { cli: "codex", status: "running" });
-    }
-  }
+const tui = createTui({ refreshMs: 0 });
+const startTime = Date.now();
+tui.setStartTime(startTime);
+
+// ── psmux pane 목록 조회 ──
+function listPanes() {
+  try {
+    const out = execFileSync("psmux", [
+      "list-panes", "-t", SESSION, "-F",
+      "#{pane_index}:#{pane_title}:#{pane_pid}",
+    ], { encoding: "utf8", timeout: 2000 });
+    return out.trim().split("\n").filter(Boolean).map(line => {
+      const [index, title, pid] = line.split(":");
+      return { index: parseInt(index, 10), title: title || "", pid };
+    });
+  } catch { return []; }
 }
 
-function pollWorkers() {
-  discoverWorkers();
+// ── pane 캡처 ──
+function capturePane(paneIdx, lines = 5) {
+  try {
+    return execFileSync("psmux", [
+      "capture-pane", "-t", `${SESSION}:0.${paneIdx}`, "-p",
+    ], { encoding: "utf8", timeout: 2000 }).trim().split("\n").slice(-lines).join("\n");
+  } catch { return ""; }
+}
 
-  for (const [paneName, state] of knownWorkers) {
-    if (state.done) continue;
+// ── result 파일에서 handoff 파싱 ──
+function checkResultFile(paneName) {
+  const resultFile = join(RESULT_DIR, `${SESSION}-${paneName}.txt`);
+  if (!existsSync(resultFile)) return null;
+  try {
+    const content = readFileSync(resultFile, "utf8");
+    if (content.trim().length === 0) return null;
+    return processHandoff(content, { exitCode: 0, resultFile });
+  } catch { return null; }
+}
 
-    let size = 0;
-    try { size = statSync(state.resultFile).size; } catch { continue; }
+// ── 메인 폴링 ──
+const POLL_MS = 1000;
+const workerState = new Map(); // paneName → { paneIdx, done }
+
+function poll() {
+  const panes = listPanes();
+  // pane 0 = 대시보드 (자기 자신), pane 1+ = 워커
+  for (const pane of panes) {
+    if (pane.index === 0) continue; // 자기 자신 건너뜀
+    const paneName = `worker-${pane.index}`;
+    const existing = workerState.get(paneName);
+
+    if (existing?.done) continue;
+
+    // CLI 타입 추정 (pane title에서)
+    let cli = "codex";
+    if (pane.title.includes("gemini") || pane.title.includes("🔵")) cli = "gemini";
+    else if (pane.title.includes("claude") || pane.title.includes("🟠")) cli = "claude";
+
+    // result 파일 확인 (완료 여부)
+    const handoffResult = checkResultFile(paneName);
+    if (handoffResult && !handoffResult.fallback) {
+      workerState.set(paneName, { paneIdx: pane.index, done: true });
+      tui.updateWorker(paneName, {
+        cli,
+        role: pane.title,
+        status: handoffResult.handoff.status === "failed" ? "failed" : "completed",
+        handoff: handoffResult.handoff,
+        elapsed: Math.round((Date.now() - startTime) / 1000),
+      });
+      continue;
+    }
 
-    if (size === state.lastSize) continue;
-    state.lastSize = size;
+    // 진행 중 — pane 캡처로 스냅샷
+    const snapshot = capturePane(pane.index, 5);
+    const lines = snapshot.split("\n").filter(l => l.trim());
+    const lastLine = lines.pop() || "";
 
-    // 결과 파일 읽기
-    let content = "";
-    try { content = readFileSync(state.resultFile, "utf8"); } catch { continue; }
+    if (!existing) {
+      workerState.set(paneName, { paneIdx: pane.index, done: false });
+    }
 
-    if (content.trim().length === 0) continue;
+    // 완료 감지: (1) result 파일 존재, (2) 셸 프롬프트 복귀, (3) "tokens used" 텍스트
+    const resultFile = join(RESULT_DIR, `${SESSION}-${paneName}.txt`);
+    let resultSize = 0;
+    try { resultSize = statSync(resultFile).size; } catch {}
 
-    // handoff 파싱 시도
-    const result = processHandoff(content, { exitCode: 0, resultFile: state.resultFile });
+    const shellReturned = /^(PS\s|>|\$)\s*/.test(lastLine) && lines.length > 2;
+    const tokensLine = lines.find(l => /tokens?\s+used/i.test(l));
 
-    if (result.handoff && !result.fallback) {
-      // handoff 블록 발견 → 완료
-      state.done = true;
-      tui.updateWorker(paneName, {
-        status: result.handoff.status === "failed" ? "failed" : "completed",
-        handoff: result.handoff,
-        elapsed: Math.round((Date.now() - startTime) / 1000),
-      });
+    const elapsed = Math.round((Date.now() - startTime) / 1000);
+    if (resultSize > 10 || shellReturned) {
+      workerState.set(paneName, { paneIdx: pane.index, done: true });
+      const meaningful = lines.filter(l => !(/^(PS\s|>|\$)/.test(l)) && !(/tokens?\s+used/i.test(l)));
+      const verdict = meaningful.pop()?.slice(0, 80) || "completed";
+      tui.updateWorker(paneName, { cli, role: pane.title, status: "completed", handoff: { verdict, confidence: tokensLine ? "high" : "low" }, elapsed });
     } else {
-      // 아직 진행 중 — 마지막 줄을 스냅샷으로
-      const lastLine = content.trim().split("\n").filter(l => l.trim()).pop() || "";
-      tui.updateWorker(paneName, {
-        status: "running",
-        snapshot: lastLine.slice(0, 60),
-        elapsed: Math.round((Date.now() - startTime) / 1000),
-      });
+      const meaningful = lines.filter(l => !(/^(PS\s|>|\$)/.test(l)));
+      const snap = meaningful.pop()?.slice(0, 60) || lastLine.slice(0, 60);
+      tui.updateWorker(paneName, { cli, role: pane.title, status: "running", snapshot: snap, elapsed });
     }
+    // debug: stderr에 상태 출력 (캡처 영향 없음)
+    process.stderr.write(`[dbg] ${paneName} cli=${cli} status=${shellReturned?"done":"run"} lines=${lines.length}\n`);
   }
 
   tui.render();
 }
 
-// ── 메인 루프 ──
-const startTime = Date.now();
-tui.setStartTime(startTime);
-
 // 초기 렌더
 tui.render();
 
-const timer = setInterval(pollWorkers, POLL_MS);
-
-// 모든 워커 완료 감지 → 10초 후 자동 종료
-let doneCheckTimer = setInterval(() => {
-  if (knownWorkers.size > 0 && [...knownWorkers.values()].every(w => w.done)) {
-    tui.render(); // 최종 렌더
-    setTimeout(() => {
-      tui.close();
-      clearInterval(timer);
-      clearInterval(doneCheckTimer);
-      process.exit(0);
-    }, 10000); // 10초 유지 후 종료
-    clearInterval(doneCheckTimer);
+const timer = setInterval(poll, POLL_MS);
+
+// 모든 워커 완료 → 15초 유지 후 종료
+const doneCheck = setInterval(() => {
+  if (workerState.size > 0 && [...workerState.values()].every(w => w.done)) {
+    tui.render();
+    clearInterval(doneCheck);
+    setTimeout(() => { tui.close(); clearInterval(timer); process.exit(0); }, 15000);
   }
 }, 2000);
 
-// Ctrl+C 정리
-process.on("SIGINT", () => {
-  tui.close();
-  clearInterval(timer);
-  process.exit(0);
-});
-
-// 5분 안전 타임아웃
-setTimeout(() => {
-  tui.close();
-  clearInterval(timer);
-  process.exit(0);
-}, 5 * 60 * 1000);
+process.on("SIGINT", () => { tui.close(); clearInterval(timer); process.exit(0); });
+setTimeout(() => { tui.close(); clearInterval(timer); process.exit(0); }, 10 * 60 * 1000);

package/hub/team/tui.mjs

@@ -1,29 +1,27 @@
-// hub/team/tui.mjs — Zero-dependency TUI 대시보드 (v7.0)
-// handoff 데이터 기반 워커 상태 실시간 ANSI 렌더링
-// 외부 의존성 0 — Node.js 내장 + ansi.mjs만 사용
+// hub/team/tui.mjs — Append-only 로그 대시보드 (v8)
+// ANSI 색상은 유지하되 커서 이동/화면 덮어쓰기는 사용하지 않는다.
 
-import {
-  cursorHome, clearLine, cursorHide, cursorShow,
-  RESET, BOLD, DIM, FG, BG,
-  color, dim, truncate, stripAnsi,
-  STATUS_ICON, CLI_ICON,
-} from "./ansi.mjs";
+import { RESET, FG, color, dim, STATUS_ICON } from "./ansi.mjs";
 
-const VERSION = "7.0.0";
+// package.json에서 동적 로드 (실패 시 fallback)
+let VERSION = "7.x";
+try {
+  const { createRequire } = await import("node:module");
+  const require = createRequire(import.meta.url);
+  VERSION = require("../../package.json").version;
+} catch { /* fallback */ }
 
 /**
- * TUI 대시보드 생성
+ * 로그 스트림 대시보드 생성 (append-only)
  * @param {object} [opts]
  * @param {NodeJS.WriteStream} [opts.stream=process.stdout]
- * @param {number} [opts.refreshMs=1000] — 자동 갱신 주기 (0=수동만)
- * @param {number} [opts.width=0] — 0이면 터미널 폭 자동
- * @returns {TuiHandle}
+ * @param {number} [opts.refreshMs=1000] — 자동 렌더 주기 (0=수동만)
+ * @returns {LogDashboardHandle}
  */
-export function createTui(opts = {}) {
+export function createLogDashboard(opts = {}) {
   const {
     stream = process.stdout,
     refreshMs = 1000,
-    width: fixedWidth = 0,
   } = opts;
 
   const workers = new Map();
@@ -32,105 +30,88 @@ export function createTui(opts = {}) {
   let timer = null;
   let closed = false;
   let frameCount = 0;
+  const lastLineByWorker = new Map();
+  let lastPipelineLine = "";
 
-  function w() { return fixedWidth > 0 ? fixedWidth : (stream.columns || 80); }
-  function out(text) { if (!closed) stream.write(text); }
+  function out(text) { if (!closed) stream.write(`${text}\n`); }
 
-  // ── 렌더 함수 ──
-
-  function header() {
-    const elapsed = Math.round((Date.now() - startedAt) / 1000);
-    const vals = [...workers.values()];
-    const done = vals.filter((s) => s.status === "completed").length;
-    const fail = vals.filter((s) => s.status === "failed").length;
-    const run  = vals.filter((s) => s.status === "running").length;
-
-    const left = ` ${color("▲ triflux", FG.triflux)} ${dim(`v${VERSION}`)}`;
-    const right = `${color(`${done}✓`, FG.green)} ${color(`${fail}✗`, FG.red)} ${run}⏳ ${dim(`${vals.length}총`)} ${dim(`${elapsed}s`)}`;
-    const gap = Math.max(1, w() - stripAnsi(left).length - stripAnsi(right).length - 1);
-    return `${BG.header}${left}${" ".repeat(gap)}${right}${RESET}`;
+  function elapsedLabel(st) {
+    const sec = Number.isFinite(st.elapsed)
+      ? Math.max(0, Math.round(st.elapsed))
+      : Math.max(0, Math.round((Date.now() - startedAt) / 1000));
+    return dim(`[${sec}s]`);
   }
 
-  function workerCard(name, st) {
-    const icon = CLI_ICON[st.cli] || dim("●");
-    const sIcon = STATUS_ICON[st.status] || STATUS_ICON.pending;
-    const el = st.elapsed != null ? `${st.elapsed}s` : "";
-    const role = st.role ? dim(`(${st.role})`) : "";
-    const conf = st.handoff?.confidence ? dim(` ${st.handoff.confidence}`) : "";
-
-    const lines = [];
-    lines.push(`  ${icon} ${st.cli} ${role}  ${sIcon} ${el}${conf}`);
-
-    if (st.handoff?.verdict) {
-      lines.push(`     ${truncate(st.handoff.verdict, w() - 8)}`);
-    }
+  function oneLine(text, fallback = "n/a") {
+    const normalized = String(text || "").replace(/\s+/g, " ").trim();
+    if (!normalized) return fallback;
+    return normalized.length > 160 ? `${normalized.slice(0, 157)}...` : normalized;
+  }
 
-    if (st.handoff?.files_changed?.length) {
-      const f = st.handoff.files_changed.slice(0, 3).join(", ");
-      const more = st.handoff.files_changed.length > 3 ? ` +${st.handoff.files_changed.length - 3}` : "";
-      lines.push(`     ${dim(`files: ${f}${more}`)}`);
-    }
+  function cliColor(cli) {
+    if (cli === "gemini") return FG.gemini;
+    if (cli === "claude") return FG.claude;
+    if (cli === "codex") return FG.codex;
+    return FG.white;
+  }
 
-    if (st.status === "failed" && st.handoff) {
-      const p = [];
-      if (st.handoff.risk) p.push(`risk:${st.handoff.risk}`);
-      if (st.handoff.lead_action) p.push(`action:${st.handoff.lead_action}`);
-      if (p.length) lines.push(`     ${color(p.join(" │ "), FG.red)}`);
-    }
+  function statusLabel(status) {
+    if (status === "completed") return color("completed", FG.green);
+    if (status === "failed") return color("failed", FG.red);
+    if (status === "running") return color("running", FG.blue);
+    return dim(status || "pending");
+  }
 
-    if (st.status === "running" && st.snapshot) {
-      lines.push(`     ${dim(truncate(st.snapshot, w() - 8))}`);
+  function messageLabel(st) {
+    if (st.handoff?.verdict) return oneLine(st.handoff.verdict, "completed");
+    if (st.snapshot) return oneLine(st.snapshot, st.status || "running");
+    if (st.status === "failed" && st.handoff?.lead_action) {
+      return oneLine(`action=${st.handoff.lead_action}`, "failed");
     }
-
-    return lines;
+    return st.status || "pending";
   }
 
-  function pipelineBar() {
-    const phases = ["plan", "prd", "confidence", "exec", "deslop", "verify", "selfcheck", "complete"];
-    const cur = pipeline.phase;
-    const parts = phases.map((p) => {
-      const ci = phases.indexOf(cur);
-      const pi = phases.indexOf(p);
-      if (p === cur) return `${FG.accent}${BOLD}[${p}]${RESET}`;
-      if (pi < ci) return `${FG.green}${p}${RESET}`;
-      return dim(p);
-    });
-    return ` ${parts.join(dim("→"))}`;
+  function workerLine(name, st) {
+    const status = st.status || "pending";
+    const icon = STATUS_ICON[status] || STATUS_ICON.pending;
+    const cli = st.cli || "codex";
+    const cliLabel = `${cliColor(cli)}${cli}${RESET}`;
+    const workerLabel = color(name, FG.triflux);
+    const statusText = statusLabel(status);
+    const message = messageLabel(st);
+    return `${elapsedLabel(st)} ${icon} ${workerLabel} (${cliLabel}) ${statusText} ${dim("—")} ${message}`;
   }
 
-  function footer() {
-    const vals = [...workers.values()];
-    const done = vals.filter((s) => s.status === "completed").length;
-    const tokenSaved = done * 850;
-    return `${BG.header} ${done}✓ 완료 │ ~${tokenSaved} 토큰 절감 ${RESET}`;
+  function pipelineLine() {
+    const phase = pipeline.phase || "exec";
+    const fix = Number.isFinite(pipeline.fix_attempt) ? pipeline.fix_attempt : 0;
+    return `${dim(`[${Math.max(0, Math.round((Date.now() - startedAt) / 1000))}s]`)} ${color("◇", FG.accent)} ${color("pipeline", FG.accent)} ${dim("(system)")} ${dim("state")} ${dim("—")} ${oneLine(`${phase} (fix=${fix})`, phase)}`;
   }
 
+  // 현재 상태와 마지막으로 출력한 라인을 비교해 변경분만 append
   function render() {
     if (closed) return;
     frameCount++;
-    const sep = dim("─".repeat(w()));
-    const buf = [cursorHome];
-
-    buf.push(header() + clearLine + "\n");
-    buf.push(sep + "\n");
-
-    if (workers.size === 0) {
-      buf.push(dim("  (워커 대기 중...)\n"));
-    } else {
-      for (const [name, st] of workers) {
-        for (const l of workerCard(name, st)) buf.push(l + clearLine + "\n");
-        buf.push("\n");
+
+    const names = [...workers.keys()].sort();
+    for (const name of names) {
+      const st = workers.get(name);
+      const line = workerLine(name, st);
+      if (line !== lastLineByWorker.get(name)) {
+        lastLineByWorker.set(name, line);
+        out(line);
       }
     }
 
-    buf.push(sep + "\n");
-    buf.push(pipelineBar() + clearLine + "\n");
-    buf.push(footer() + clearLine + "\n");
-
-    out(buf.join(""));
+    const nextPipelineLine = pipelineLine();
+    if (nextPipelineLine !== lastPipelineLine) {
+      lastPipelineLine = nextPipelineLine;
+      out(nextPipelineLine);
+    }
   }
 
-  // 자동 갱신
+  out(`${dim("[0s]")} ${color("▲ triflux", FG.triflux)} ${dim(`v${VERSION}`)} ${dim("log-dashboard started")}`);
+
   if (refreshMs > 0) {
     timer = setInterval(render, refreshMs);
     if (timer.unref) timer.unref();
@@ -150,6 +131,7 @@ export function createTui(opts = {}) {
       if (closed) return;
       closed = true;
       if (timer) clearInterval(timer);
+      out(`${dim(`[${Math.max(0, Math.round((Date.now() - startedAt) / 1000))}s]`)} ${dim("log-dashboard stopped")}`);
     },
   };
 }

package/package.json

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

package/scripts/headless-guard.mjs

@@ -135,6 +135,11 @@ async function main() {
       process.exit(0);
     }
 
+    // psmux send-keys / capture-pane은 통과 (pane 내 간접 실행)
+    if (/psmux\s+(send-keys|capture-pane|list-panes|split-window|select-pane)/.test(cmd)) {
+      process.exit(0);
+    }
+
     // codex/gemini 직접 CLI 호출 → deny
     if (/\bcodex\s+exec\b/.test(cmd) || /\bgemini\s+(-p|--prompt)\b/.test(cmd)) {
       deny(