@triflux/remote 10.50.2 → 10.52.0

package/hub/team/headless.mjs

@@ -1,8 +1,5 @@
 // hub/team/headless.mjs — 헤드리스 CLI 오케스트레이션
 // psmux pane에서 CLI를 헤드리스 모드로 실행하고 결과를 수집한다.
-// v5.2.0: 기본 headless 엔진 (runHeadless, runHeadlessWithCleanup)
-// v6.0.0: Lead-direct 모드 (runHeadlessInteractive, autoAttachTerminal)
-// 의존성: psmux.mjs (Node.js 내장 모듈만 사용)
 
 import { execSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -10,20 +7,16 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
-  renameSync,
   rmSync,
   statSync,
   writeFileSync,
 } from "node:fs";
 import { createRequire } from "node:module";
-import net from "node:net";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveNestedCodexAgentProfile } from "../../scripts/lib/agent-route-policy.mjs";
-import { requestJson } from "@triflux/core/hub/bridge.mjs";
 import { escapePwshSingleQuoted } from "@triflux/core/hub/cli-adapter-base.mjs";
-import { getMaxSpawnPerSec } from "@triflux/core/hub/lib/spawn-trace.mjs";
 import {
   createActivityLifecycle,
   isActivityLifecycleEnabled,
@@ -31,27 +24,15 @@ import {
   resolveStallInterventionMs,
 } from "@triflux/core/hub/lib/worker-lifecycle.mjs";
 import { IS_WINDOWS } from "@triflux/core/hub/platform.mjs";
+import { createAgentsRowOwnership, openAgentsRow } from "./agents-row.mjs";
 import { getBackend } from "./backend.mjs";
-import {
-  buildDaemonControlAuth,
-  buildDaemonExecDispatchPayload,
-  deriveClaudeDaemonPaths as deriveClaudeControlPaths,
-  dispatchClaudeDaemonJob,
-  killDaemonJob,
-  sendKillBySessionId,
-} from "./claude-daemon-control.mjs";
-import { startClaudeNativeBridge } from "./claude-native-bridge.mjs";
-import { removeClaudeSessionProjection } from "./claude-session-projection.mjs";
 import { resolveDashboardLayout } from "./dashboard-layout.mjs";
 import {
   formatHandoffForLead,
   HANDOFF_INSTRUCTION_SHORT,
   processHandoff,
 } from "./handoff.mjs";
-import {
-  createFileActivitySource,
-  createInterventionLadder,
-} from "./intervention.mjs";
+import { createInterventionLadder } from "./intervention.mjs";
 import {
   capturePsmuxPane,
   createPsmuxSession,
@@ -59,26 +40,18 @@ import {
   killPsmuxSession,
   psmuxExec,
   psmuxSessionExists,
-  sendKeysToPane,
   startCapture,
   waitForCompletion,
 } from "./psmux.mjs";
-import {
-  buildSynapseTaskSummary,
-  registerSynapseSession,
-  unregisterSynapseSession,
-} from "./synapse-http.mjs";
 import { createLogDashboard } from "./tui.mjs";
 import { createWtManager } from "./wt-manager.mjs";
 
 const RESULT_DIR = join(tmpdir(), "tfx-headless");
-const DAEMON_COMPLETION_PREFIX = "__TFX_HEADLESS_DONE__:";
 const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
 
 /** CLI별 브랜드 — 이모지 + 공식 색상 (HUD와 통일) */
 const CLI_BRAND = {
   codex: { emoji: "\u{26AA}", label: "Codex", ansi: "\x1b[97m" }, // ⚪ bright white (codexWhite)
-  gemini: { emoji: "\u{1F535}", label: "Gemini", ansi: "\x1b[38;5;39m" }, // 🔵 geminiBlue
   antigravity: {
     emoji: "\u{1F535}",
     label: "Antigravity",
@@ -90,8 +63,6 @@ const CLI_BRAND = {
     ansi: "\x1b[38;2;232;112;64m",
   }, // 🟠 claudeOrange
 };
-const _ANSI_RESET = "\x1b[0m";
-const _ANSI_DIM = "\x1b[2m";
 
 /** 에이전트 역할명 → CLI 타입 매핑 (단일 소스: agent-map.json) */
 const _require = createRequire(import.meta.url);
@@ -109,11 +80,6 @@ export function resolveCliType(agentOrCli) {
   return AGENT_TO_CLI[agentOrCli] || agentOrCli;
 }
 
-function resolveHeadlessCliType(agentOrCli) {
-  const resolved = resolveCliType(agentOrCli);
-  return resolved === "gemini" ? "antigravity" : resolved;
-}
-
 function shellQuote(value) {
   return `'${String(value).replace(/'/g, "'\\''")}'`;
 }
@@ -146,7 +112,7 @@ function resolveRouteAgentForHeadless(resolvedCli, opts = {}) {
   if (
     role &&
     VALID_ROUTE_AGENTS.has(role) &&
-    !["gemini", "antigravity", "agy"].includes(role)
+    !["antigravity", "agy"].includes(role)
   ) {
     return role;
   }
@@ -215,95 +181,6 @@ export function getHeadlessWorkerAgentId(sessionName, index) {
   return `headless-${sessionName}-${index}`;
 }
 
-export function getHeadlessLeadAgentId(sessionName) {
-  return `headless-${sessionName}-lead`;
-}
-
-const HUB_CLI_VALUES = new Set(["codex", "gemini", "claude", "other"]);
-const presenceOwnerByAgent = new Map();
-function normalizeCliForHub(cli) {
-  return HUB_CLI_VALUES.has(cli) ? cli : "other";
-}
-
-export async function registerHeadlessWorker(
-  sessionName,
-  index,
-  cli,
-  requestJsonFn = requestJson,
-) {
-  const agentId = getHeadlessWorkerAgentId(sessionName, index);
-  const result = await requestJsonFn("/bridge/register", {
-    body: {
-      agent_id: agentId,
-      cli: normalizeCliForHub(cli),
-      topics: ["headless.worker"],
-      capabilities: [cli],
-    },
-  }).catch(() => null);
-  if (result?.ok && result.data?.presence_generation != null) {
-    presenceOwnerByAgent.set(agentId, {
-      presence_generation: result.data.presence_generation,
-      hub_instance_id: result.data.hub_instance_id,
-      store_fingerprint: result.data.store_fingerprint,
-    });
-  }
-  return result;
-}
-
-export async function publishHeadlessResult(
-  sessionName,
-  workerId,
-  status,
-  handoff,
-  requestJsonFn = requestJson,
-) {
-  await requestJsonFn("/bridge/publish", {
-    body: {
-      from: getHeadlessLeadAgentId(sessionName),
-      to: "topic:headless.results",
-      type: "event",
-      payload: { workerId, status, handoff },
-    },
-  }).catch(() => {});
-}
-
-export async function deregisterHeadlessWorkers(
-  sessionName,
-  workerCount,
-  requestJsonFn = requestJson,
-) {
-  await Promise.all(
-    Array.from({ length: workerCount }, (_, index) =>
-      requestJsonFn("/bridge/deregister", {
-        body: {
-          agent_id: getHeadlessWorkerAgentId(sessionName, index),
-          ...(presenceOwnerByAgent.get(
-            getHeadlessWorkerAgentId(sessionName, index),
-          ) || {}),
-        },
-      })
-        .catch(() => {})
-        .finally(() =>
-          presenceOwnerByAgent.delete(
-            getHeadlessWorkerAgentId(sessionName, index),
-          ),
-        ),
-    ),
-  );
-}
-
-function registerHeadlessSynapseWorker(workerId, prompt) {
-  registerSynapseSession({
-    sessionId: workerId,
-    host: "local",
-    taskSummary: buildSynapseTaskSummary(prompt),
-  });
-}
-
-function unregisterHeadlessSynapseWorker(workerId) {
-  unregisterSynapseSession(workerId);
-}
-
 /** MCP 프로필별 프롬프트 힌트 (tfx-route.sh resolve_mcp_policy의 경량 미러) */
 const MCP_PROFILE_HINTS = {
   implement:
@@ -314,19 +191,6 @@ const MCP_PROFILE_HINTS = {
   docs: "Focus on documentation and explanation tasks.",
 };
 
-/**
- * CLI별 헤드리스 명령 빌더
- * @param {'codex'|'antigravity'|'claude'} cli
- * @param {string} prompt — 실행할 프롬프트
- * @param {string} resultFile — 결과 저장 파일 경로
- * @param {object} [opts]
- * @param {boolean} [opts.handoff=true]
- * @param {string} [opts.mcp] — MCP 프로필 ("implement"|"analyze"|"review"|"docs")
- * @param {string} [opts.contextFile] — 컨텍스트 파일 경로 (최대 32KB, UTF-8 안전 절단)
- * @returns {string} PowerShell 명령
- */
-// ── Dashboard attach args for WT ────────────────────────────────
-
 export function buildDashboardAttachArgs(
   sessionName,
   layout,
@@ -348,7 +212,7 @@ export function buildDashboardAttachArgs(
 
 export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
   const { handoff = true, mcp, contextFile, model, cwd } = opts;
-  const resolvedCli = resolveHeadlessCliType(cli);
+  const resolvedCli = resolveCliType(cli);
 
   // contextFile 처리: 32KB(32768 bytes) 초과 시 UTF-8 안전 절단
   let contextPrefix = "";
@@ -357,7 +221,11 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
     let ctx = readFileSync(contextFile, "utf8");
     let truncated = false;
     if (Buffer.byteLength(ctx, "utf8") > 32768) {
-      ctx = Buffer.from(ctx).subarray(0, 32768).toString("utf8");
+      // 바이트 경계에서 잘린 다바이트 글자는 U+FFFD 로 디코딩되므로 떼어 낸다.
+      ctx = Buffer.from(ctx)
+        .subarray(0, 32768)
+        .toString("utf8")
+        .replace(/�+$/u, "");
       truncated = true;
     }
     if (truncated) {
@@ -391,7 +259,6 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
     "prompt-" + randomUUID().slice(0, 8) + ".txt",
   ).replace(/\\/g, "/");
   writeFileSync(promptFile, fullPrompt, "utf8");
-  void IS_WINDOWS; // referenced for diagnostic guard chain below
 
   // Codex와 Antigravity는 tfx-route.sh를 통해서만 headless 실행한다. 이 경로가
   // disable/fallback/fail-loud 정책의 유일한 판정원이다. 여기서 같은 정책을
@@ -432,48 +299,6 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
   return `cd '${safeCwd.replace(/'/g, "'\\''")}' && ${backendCommand}`;
 }
 
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-export function buildDaemonWrappedCommand(command, token) {
-  return `{ ${command}; __ec=$?; echo "${DAEMON_COMPLETION_PREFIX}${token}:$__ec"; }`;
-}
-
-export function waitForDaemonCompletionFromMessages(
-  messages,
-  { token, resultFile } = {},
-) {
-  const completionRegex = new RegExp(
-    `${escapeRegExp(DAEMON_COMPLETION_PREFIX)}${escapeRegExp(token)}:(\\d+)`,
-  );
-  const stream = [];
-  let matched = false;
-  let exitCode = null;
-
-  for (const message of messages) {
-    if (Array.isArray(message?.streamTail)) {
-      stream.push(...message.streamTail.map((line) => `${line}\n`));
-    }
-    if (typeof message?.line !== "string") continue;
-    const match = completionRegex.exec(message.line);
-    if (match) {
-      const beforeCompletion = message.line.slice(0, match.index);
-      if (beforeCompletion) stream.push(beforeCompletion);
-      matched = true;
-      exitCode = Number.parseInt(match[1], 10);
-      continue;
-    }
-    stream.push(message.line);
-  }
-
-  if (resultFile) {
-    writeFileSync(`${resultFile}.partial`, stream.join(""), "utf8");
-  }
-
-  return { matched, exitCode };
-}
-
 /**
  * 이전 run 의 stale .txt / .partial / .err 를 제거한다.
  * Issue #118 Codex review R1 HIGH: resultFile 경로 재사용 시 (워커 restart 또는
@@ -531,125 +356,33 @@ export function readResult(resultFile, paneId) {
   return capturePsmuxPane(paneId, 30);
 }
 
-// ─── Stall Detection ───
-
-/** Stall detection 기본값 (immutable) */
-export const STALL_DEFAULTS = Object.freeze({
-  pollInterval: 5_000,
-  stallTimeout: 120_000,
-  interventionTimeout: resolveStallInterventionMs(),
-  hardCeiling: resolveHardCeilingMs(),
-  maxRestarts: 2,
-  maxInterventions: 1,
-});
-
-/** CLI pane stall 감지 에러 (STALL_EXHAUSTED | COMPLETION_TIMEOUT) */
-export class StallError extends Error {
-  constructor(
-    message,
-    { code = "STALL_DETECTED", category = "transient", recovery = "" } = {},
-  ) {
-    super(message);
-    this.name = "StallError";
-    this.code = code;
-    this.category = category;
-    this.recovery = recovery;
-  }
-}
-
-/**
- * Stall 모니터 팩토리 — output + resultFile mtime 하이브리드 감지
- * @param {string} paneId
- * @param {string} resultFile
- * @param {{ stallTimeout: number }} config
- * @param {{ capturePsmuxPane?: Function, statSync?: Function }} [deps]
- * @returns {{ poll: () => { snapshot: string, mtimeChanged: boolean, stalled: boolean, elapsed: number } }}
- */
-export function createStallMonitor(paneId, resultFile, config, deps = {}) {
-  const capture = deps.capturePsmuxPane || capturePsmuxPane;
-  const stat = deps.statSync || statSync;
-  let lastSnapshot = "";
-  let lastMtime = 0;
-  let lastChangeAt = Date.now();
-
-  try {
-    lastMtime = stat(resultFile).mtimeMs;
-  } catch {
-    /* not created yet */
-  }
-
-  return Object.freeze({
-    poll() {
-      const snapshot = capture(paneId, 50);
-      let currentMtime = 0;
-      try {
-        currentMtime = stat(resultFile).mtimeMs;
-      } catch {
-        /* ignore */
-      }
-
-      const outputChanged = snapshot !== lastSnapshot;
-      const mtimeChanged = currentMtime > 0 && currentMtime !== lastMtime;
-
-      if (outputChanged || mtimeChanged) {
-        lastChangeAt = Date.now();
-        lastSnapshot = snapshot;
-        if (mtimeChanged) lastMtime = currentMtime;
-      }
-
-      const elapsed = Date.now() - lastChangeAt;
-      return Object.freeze({
-        snapshot,
-        mtimeChanged,
-        stalled: elapsed >= config.stallTimeout,
-        elapsed,
-      });
-    },
-  });
-}
-
 function createHeadlessIntervention(dispatch, fallback) {
   return async (context) => {
     if (typeof fallback === "function")
       return (await fallback(context)) === true;
 
-    const isDaemon = context.channel === "daemon";
-    const readActivitySignature = isDaemon
-      ? createFileActivitySource({ files: [dispatch.resultFile] })
-      : () => {
-          let mtime = 0;
-          try {
-            mtime = statSync(dispatch.resultFile).mtimeMs;
-          } catch {
-            /* result file has not been written yet */
-          }
-          return `${capturePsmuxPane(context.paneId || dispatch.paneId, 50)}\0${mtime}`;
-        };
+    const readActivitySignature = () => {
+      let mtime = 0;
+      try {
+        mtime = statSync(dispatch.resultFile).mtimeMs;
+      } catch {
+        /* result file has not been written yet */
+      }
+      return `${capturePsmuxPane(context.paneId || dispatch.paneId, 50)}\0${mtime}`;
+    };
     const ladder = createInterventionLadder({
-      target: isDaemon
-        ? {
-            channel: "claude-daemon",
-            cli: dispatch.cli || "claude",
-            sessionId: dispatch.sessionId,
-            daemon: {
-              controlSock: dispatch.controlSock,
-              short: dispatch.daemonShort,
-              sessionId: dispatch.sessionId,
-              configDir: dispatch.daemonPaths?.configDir,
-            },
-          }
-        : {
-            channel: "tmux-pane",
-            paneId: context.paneId || dispatch.paneId,
-            cli: dispatch.cli,
-            sessionId: dispatch.sessionId,
-          },
+      target: {
+        channel: "tmux-pane",
+        paneId: context.paneId || dispatch.paneId,
+        cli: dispatch.cli,
+        sessionId: dispatch.sessionId,
+      },
       readActivitySignature,
       deps: {
         // 이 트랙이 재실행 소유자다. pane 채널은 기존 completion wrapper를 다시
         // dispatch하여 token/result 계약을 보존한다.
         resumeHandler: async () => {
-          if (isDaemon || !dispatch.command) return { ok: false };
+          if (!dispatch.command) return { ok: false };
           const restarted = dispatchCommand(
             context.sessionName,
             context.paneId || dispatch.paneId,
@@ -706,254 +439,6 @@ export function createActivityPollGuard({
   });
 }
 
-/**
- * 하이브리드 stall 감지 대기 — output 변화 + resultFile mtime 모니터링.
- * 2분 무변화 시 pane kill → re-dispatch (최대 2회 재시작).
- *
- * @param {string} sessionName
- * @param {string} paneId — 현재 pane 타겟 (예: "tfx:0.1")
- * @param {string} resultFile — 결과 저장 파일 경로
- * @param {object} [opts]
- * @param {number} [opts.pollInterval=5000] — 폴링 간격 ms
- * @param {number} [opts.stallTimeout=120000] — 무변화 stall 판정 ms
- * @param {number} [opts.hardCeiling] — 활동과 무관한 절대 상한 ms
- * @param {number} [opts.completionTimeout] — hardCeiling의 하위호환 alias
- * @param {number} [opts.maxRestarts=2] — 최대 재시작 횟수
- * @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, paneId: string, token?: string, logPath?: string|null }>}
- */
-export async function waitForCompletionWithStallDetect(
-  sessionName,
-  paneId,
-  resultFile,
-  opts = {},
-) {
-  const {
-    pollInterval = 5000,
-    stallTimeout = 120000,
-    maxRestarts = 2,
-    maxInterventions = 1,
-    command,
-    token,
-    onPoll,
-    onIntervene,
-    _deps,
-  } = opts;
-  const hardCeiling =
-    opts.hardCeiling ??
-    opts.completionTimeout ??
-    (isActivityLifecycleEnabled() ? resolveHardCeilingMs() : 900_000);
-
-  // 의존성 (테스트 시 _deps로 주입 가능)
-  const deps = _deps || {};
-  const _capture = deps.capturePsmuxPane || capturePsmuxPane;
-  const _exists = deps.existsSync || existsSync;
-  const _stat = deps.statSync || statSync;
-  const _readFile = deps.readFileSync || readFileSync;
-  const _exec = deps.psmuxExec || psmuxExec;
-  const _dispatch = deps.dispatchCommand || dispatchCommand;
-  const _startCapture = deps.startCapture || startCapture;
-
-  const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  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 interventions = 0;
-  const runStartedAt = Date.now();
-  let currentPaneId = paneId;
-  let stallDetected = false;
-  let currentToken = token;
-  let currentLogPath = opts.logPath || null;
-
-  while (true) {
-    let lastOutput = "";
-    let lastMtime = 0;
-    let lastChangeAt = Date.now();
-
-    // 초기 resultFile mtime
-    try {
-      if (_exists(resultFile)) lastMtime = _stat(resultFile).mtimeMs;
-    } catch {
-      /* 무시 */
-    }
-
-    while (true) {
-      await new Promise((r) => setTimeout(r, pollInterval));
-      const now = Date.now();
-
-      // 절대 상한은 재시작과 활동 여부를 관통하는 유일한 wall-clock kill이다.
-      if (now - runStartedAt > hardCeiling) {
-        // Issue #118: timeout kill 전에 capture-pane 출력을 .partial 파일로 persist.
-        // resultFile(`.txt`)이 아직 생성되지 않았을 수 있으므로 readResult 가 fallback 으로 읽는다.
-        try {
-          const partialSnapshot = _capture(currentPaneId, 200);
-          if (partialSnapshot && partialSnapshot.trim().length > 0) {
-            const writer = deps.writeFileSync || writeFileSync;
-            writer(`${resultFile}.partial`, partialSnapshot, "utf8");
-          }
-        } catch {
-          /* best-effort, timeout 은 이미 확정 */
-        }
-        return {
-          matched: false,
-          exitCode: null,
-          restarts,
-          stallDetected,
-          timedOut: true,
-          timeoutReason: "hard_ceiling",
-          paneId: currentPaneId,
-          token: currentToken,
-          logPath: currentLogPath,
-        };
-      }
-
-      // 1) capture-pane 출력 확인
-      const currentOutput = _capture(currentPaneId, 50);
-      if (onPoll) {
-        try {
-          onPoll(currentOutput);
-        } catch {
-          /* 삼킴 */
-        }
-      }
-
-      // 2) completion 토큰 감지
-      const completionRe = buildCompletionRegex(currentToken);
-      const completionMatch = completionRe.exec(currentOutput);
-      if (completionMatch) {
-        return {
-          matched: true,
-          exitCode: Number.parseInt(
-            completionMatch.slice(1).find(Boolean) || "0",
-            10,
-          ),
-          restarts,
-          stallDetected,
-          timedOut: false,
-          paneId: currentPaneId,
-          token: currentToken,
-          logPath: currentLogPath,
-        };
-      }
-
-      // 3) resultFile 존재 + mtime 변화 확인
-      let currentMtime = 0;
-      try {
-        if (_exists(resultFile)) currentMtime = _stat(resultFile).mtimeMs;
-      } catch {
-        /* 무시 */
-      }
-
-      // 4) 변화 감지 → stallTimer 리셋
-      const outputChanged = currentOutput !== lastOutput;
-      const mtimeChanged = currentMtime > 0 && currentMtime !== lastMtime;
-
-      if (outputChanged || mtimeChanged) {
-        lastChangeAt = now;
-        lastOutput = currentOutput;
-        if (mtimeChanged) lastMtime = currentMtime;
-      }
-
-      // resultFile이 갱신되고 내용이 있으면 완료로 간주
-      if (mtimeChanged && currentMtime > 0 && _exists(resultFile)) {
-        try {
-          const content = _readFile(resultFile, "utf8").trim();
-          if (content.length > 0) {
-            return {
-              matched: true,
-              exitCode: 0,
-              restarts,
-              stallDetected,
-              timedOut: false,
-              paneId: currentPaneId,
-              token: currentToken,
-              logPath: currentLogPath,
-            };
-          }
-        } catch {
-          /* 무시 */
-        }
-      }
-
-      // 5) stall 판정
-      if (now - lastChangeAt >= stallTimeout) {
-        stallDetected = true;
-
-        if (restarts >= maxRestarts) {
-          if (onIntervene && interventions < maxInterventions) {
-            interventions += 1;
-            let handled = false;
-            try {
-              handled =
-                (await onIntervene({
-                  channel: "pane",
-                  sessionName,
-                  paneId: currentPaneId,
-                  resultFile,
-                  inactiveMs: now - lastChangeAt,
-                  restarts,
-                  interventions,
-                })) === true;
-            } catch {
-              handled = false;
-            }
-            if (handled) {
-              lastChangeAt = Date.now();
-              continue;
-            }
-          }
-          const err = new Error("CLI가 반복적으로 멈춤. 수동 확인 필요.");
-          err.code = "STALL_EXHAUSTED";
-          err.category = "transient";
-          err.recovery = "CLI가 반복적으로 멈춤. 수동 확인 필요.";
-          err.restarts = restarts;
-          err.interventions = interventions;
-          throw err;
-        }
-
-        // kill pane → re-dispatch
-        try {
-          _exec(["kill-pane", "-t", currentPaneId]);
-        } catch {
-          /* 이미 종료 */
-        }
-
-        if (command) {
-          // 새 pane split + 동일 command re-dispatch
-          const newPaneId = _exec([
-            "split-window",
-            "-t",
-            sessionName,
-            "-P",
-            "-F",
-            "#{session_name}:#{window_index}.#{pane_index}",
-          ]);
-          _startCapture(sessionName, newPaneId);
-          const redispatch = _dispatch(sessionName, newPaneId, command);
-          currentPaneId = redispatch?.paneId || newPaneId;
-          if (redispatch?.token) currentToken = redispatch.token;
-          if (redispatch?.logPath) currentLogPath = redispatch.logPath;
-        }
-
-        restarts++;
-        break; // inner loop 재시작 (stallTimer 리셋)
-      }
-    }
-  }
-}
-
 function createHeadlessSessionOwnership(killSession) {
   let owned = false;
   let ownedSessionName = "";
@@ -1021,7 +506,7 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
     const paneName = `worker-${i + 1}`;
     const displayName = resolveHeadlessDisplayName(assignment, paneName);
     const workerId = getHeadlessWorkerAgentId(sessionName, i);
-    const resolvedCli = resolveHeadlessCliType(assignment.cli);
+    const resolvedCli = resolveCliType(assignment.cli);
     const brand = CLI_BRAND[resolvedCli] || {
       emoji: "\u{25CF}",
       label: resolvedCli,
@@ -1047,7 +532,6 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
     } catch {
       /* 무시 */
     }
-    await registerHeadlessWorker(sessionName, i, resolvedCli);
 
     if (safeProgress)
       safeProgress({
@@ -1081,7 +565,6 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
     // pane 간 pipe-pane EBUSY 방지 — 이벤트 루프 해방하며 순차 대기
     if (i > 0) await new Promise((r) => setTimeout(r, 300));
     const dispatch = dispatchCommand(sessionName, newPaneId, cmd);
-    registerHeadlessSynapseWorker(workerId, assignment.prompt);
 
     if (safeProgress)
       safeProgress({ type: "dispatched", paneName, cli: resolvedCli });
@@ -1150,7 +633,7 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
       const paneName = `worker-${i + 1}`;
       const displayName = resolveHeadlessDisplayName(assignment, paneName);
       const workerId = getHeadlessWorkerAgentId(sessionName, i);
-      const resolvedCli = resolveHeadlessCliType(assignment.cli);
+      const resolvedCli = resolveCliType(assignment.cli);
       const resultFile = join(
         RESULT_DIR,
         `${sessionName}-${paneName}.txt`,
@@ -1170,12 +653,10 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
         },
       );
       const scriptDir = join(RESULT_DIR, sessionName);
-      await registerHeadlessWorker(sessionName, i, resolvedCli);
       const dispatch = dispatchCommand(sessionName, paneName, cmd, {
         scriptDir,
         scriptName: paneName,
       });
-      registerHeadlessSynapseWorker(workerId, assignment.prompt);
 
       // P1 fix: 비-progressive에서는 pane 리네임 금지 — 캡처 로그 경로가 타이틀 기반이므로
       // 리네임하면 waitForCompletion이 "codex (role).log"를 찾지만 실제는 "worker-N.log"로 불일치
@@ -1204,135 +685,6 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
   );
 }
 
-async function dispatchDaemonBatch(sessionName, assignments, opts = {}) {
-  const { safeProgress, configDir } = opts;
-  const paths = deriveClaudeControlPaths({ configDir });
-  const dispatches = [];
-
-  try {
-    for (let i = 0; i < assignments.length; i += 1) {
-      const assignment = assignments[i];
-      const paneName = `worker-${i + 1}`;
-      const displayName = resolveHeadlessDisplayName(assignment, paneName);
-      const workerId = getHeadlessWorkerAgentId(sessionName, i);
-      const resolvedCli = resolveHeadlessCliType(assignment.cli);
-      const resultFile = join(
-        RESULT_DIR,
-        `${sessionName}-${paneName}.txt`,
-      ).replace(/\\/g, "/");
-      cleanStaleResultArtifacts(resultFile);
-      const command = buildHeadlessCommand(
-        assignment.cli,
-        assignment.prompt,
-        resultFile,
-        {
-          mcp: assignment.mcp,
-          role: assignment.role,
-          model: assignment.model,
-          profile: assignment.profile,
-          cwd: assignment.cwd || assignment.workdir,
-        },
-      );
-      const token = randomUUID().slice(0, 10);
-      const short = randomUUID().replace(/-/g, "").slice(0, 8);
-      const name = `Triflux ${resolvedCli || "worker"} ${displayName}`;
-      const record = {
-        paneId: `daemon:${short}`,
-        paneName,
-        displayName,
-        resultFile,
-        cli: resolvedCli,
-        role: assignment.role,
-        command,
-        token,
-        workerId,
-        cwd: assignment.cwd || assignment.workdir,
-        daemonShort: short,
-        daemonPaths: paths,
-        controlSock: paths.controlSock,
-        sessionId: "",
-        sessionProjectionPath: "",
-        daemonCompletionMatched: false,
-      };
-      dispatches.push(record);
-
-      const payload = buildDaemonExecDispatchPayload({
-        short,
-        cwd: assignment.cwd || assignment.workdir || process.cwd(),
-        command: buildDaemonWrappedCommand(command, token),
-        name,
-      });
-      record.sessionId = payload.sessionId;
-      // buildDaemonWrappedCommand + token completion 시맨틱은 헬퍼 밖(headless 전용)에
-      // 남기고, dispatch→pid→bridge→projection 시퀀스만 공유 헬퍼로 위임한다.
-      // CRITICAL: waitForDaemonCompletion 이 나중에 record.daemonCompletionMatched 를
-      // 변경하고 cleanupDaemonDispatches 가 같은 record 를 읽으므로, 헬퍼가 새 객체를
-      // 반환해도 record 를 교체하지 말고 plain 필드를 Object.assign 한다.
-      const dispatched = await dispatchClaudeDaemonJob({
-        paths,
-        controlSock: paths.controlSock,
-        payload,
-        agent: resolvedCli || "codex",
-        name,
-        cwd: assignment.cwd || assignment.workdir || process.cwd(),
-        dispatchTimeoutMs: 5000,
-      }).catch((error) => {
-        throw new Error(
-          `[headless] Claude daemon dispatch failed for ${paneName}: ${
-            error?.message || error
-          }`,
-        );
-      });
-      Object.assign(record, {
-        sessionId: dispatched.sessionId,
-        sessionProjectionPath: dispatched.sessionProjectionPath,
-      });
-      await registerHeadlessWorker(sessionName, i, resolvedCli);
-      registerHeadlessSynapseWorker(workerId, assignment.prompt);
-      if (safeProgress) {
-        safeProgress({ type: "dispatched", paneName, cli: resolvedCli });
-      }
-    }
-  } catch (error) {
-    await cleanupDaemonDispatches(dispatches);
-    throw error;
-  }
-
-  return dispatches;
-}
-
-export async function cleanupDaemonDispatches(dispatches) {
-  await Promise.all(
-    dispatches.map(async (dispatch) => {
-      if (dispatch.sessionProjectionPath) {
-        await removeClaudeSessionProjection(
-          dispatch.sessionProjectionPath,
-        ).catch(() => {});
-      }
-      if (
-        dispatch.daemonCompletionMatched === true &&
-        dispatch.daemonPaths &&
-        dispatch.sessionId
-      ) {
-        await sendKillBySessionId({
-          daemonPaths: dispatch.daemonPaths,
-          sessionId: dispatch.sessionId,
-        }).catch(() => {});
-      }
-      if (dispatch.controlSock && dispatch.daemonShort) {
-        const controlAuth = await buildDaemonControlAuth(
-          dispatch.daemonPaths?.configDir,
-        ).catch(() => ({}));
-        await killDaemonJob(
-          dispatch.controlSock,
-          dispatch.daemonShort,
-          controlAuth,
-        ).catch(() => {});
-      }
-    }),
-  );
-}
-
 /**
  * 모든 dispatch를 병렬 대기하며 완료 결과를 수집한다.
  * @param {string} sessionName
@@ -1348,7 +700,6 @@ async function awaitAll(
   timeoutSec,
   safeProgress,
   progressIntervalSec,
-  stallOpts,
   lifecycle,
 ) {
   // 병렬 대기 (Promise.all — 모든 pane 동시 폴링, 총 시간 = max(개별 시간))
@@ -1375,73 +726,7 @@ async function awaitAll(
       }
 
       let completion;
-      if (stallOpts?.enabled) {
-        // 하이브리드 stall detection 모드
-        try {
-          const stallPollCb =
-            safeProgress && progressIntervalSec > 0
-              ? (snapshot) => {
-                  try {
-                    safeProgress({
-                      type: "progress",
-                      paneName: d.paneName,
-                      displayName: d.displayName,
-                      cli: d.cli,
-                      snapshot: snapshot.split("\n").slice(-15).join("\n"),
-                    });
-                  } catch {
-                    /* 삼킴 */
-                  }
-                }
-              : undefined;
-
-          const stallResult = await waitForCompletionWithStallDetect(
-            sessionName,
-            d.paneId || d.paneName,
-            d.resultFile,
-            {
-              pollInterval: stallOpts.pollInterval,
-              stallTimeout: stallOpts.stallTimeout,
-              hardCeiling: lifecycle?.enabled
-                ? (stallOpts.hardCeiling ??
-                  stallOpts.completionTimeout ??
-                  lifecycle.hardCeilingMs)
-                : (stallOpts.completionTimeout ?? timeoutSec * 1000),
-              maxRestarts: stallOpts.maxRestarts,
-              maxInterventions: stallOpts.maxInterventions,
-              command: d.command,
-              token: d.token,
-              onPoll: stallPollCb,
-              onIntervene: lifecycle?.enabled
-                ? createHeadlessIntervention(
-                    d,
-                    stallOpts.onIntervene ?? lifecycle.onIntervene,
-                  )
-                : undefined,
-            },
-          );
-          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,
-            stallDetected: stallResult.stallDetected,
-            restarts: stallResult.restarts,
-          };
-        } catch (stallErr) {
-          if (stallErr.code === "STALL_EXHAUSTED") {
-            completion = {
-              matched: false,
-              exitCode: null,
-              stallExhausted: true,
-              restarts: stallErr.restarts,
-            };
-          } else {
-            throw stallErr;
-          }
-        }
-      } else if (lifecycle?.enabled) {
+      if (lifecycle?.enabled) {
         if (d.logPath) pollOpts.logPath = d.logPath;
         const activity = createActivityLifecycle({
           interventionMs: lifecycle.interventionMs,
@@ -1501,7 +786,6 @@ async function awaitAll(
       }
 
       const output = readResult(d.resultFile, d.paneId);
-      unregisterHeadlessSynapseWorker(d.workerId);
 
       if (safeProgress) {
         safeProgress({
@@ -1512,174 +796,6 @@ async function awaitAll(
           matched: completion.matched,
           exitCode: completion.exitCode,
           sessionDead: completion.sessionDead || false,
-          stallDetected: completion.stallDetected || false,
-          stallExhausted: completion.stallExhausted || false,
-        });
-      }
-
-      return { d, completion, output };
-    }),
-  );
-}
-
-export async function waitForDaemonCompletion(
-  dispatch,
-  timeoutSec,
-  safeProgress,
-  progressIntervalSec,
-  lifecycle = null,
-) {
-  const messages = [];
-  const socket = net.connect(dispatch.controlSock);
-  let buffer = "";
-  let settled = false;
-  let lastProgressAt = 0;
-  const activity = lifecycle?.enabled
-    ? createActivityLifecycle({
-        interventionMs: lifecycle.interventionMs,
-        hardCeilingMs: lifecycle.hardCeilingMs,
-        onIntervene: createHeadlessIntervention(
-          dispatch,
-          lifecycle.onIntervene,
-        ),
-      })
-    : null;
-
-  return await new Promise((resolve) => {
-    const finish = (completion, timeoutReason = "") => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      clearInterval(timer);
-      socket.destroy();
-      const finalCompletion =
-        completion ||
-        waitForDaemonCompletionFromMessages(messages, {
-          token: dispatch.token,
-          resultFile: dispatch.resultFile,
-        });
-      if (!finalCompletion.matched && timeoutReason) {
-        finalCompletion.timedOut = true;
-        finalCompletion.timeoutReason = timeoutReason;
-      }
-      if (finalCompletion.matched) {
-        dispatch.daemonCompletionMatched = true;
-        cleanupDaemonDispatches([dispatch]).catch(() => {});
-      } else {
-        buildDaemonControlAuth(dispatch.daemonPaths?.configDir)
-          .catch(() => ({}))
-          .then((controlAuth) =>
-            killDaemonJob(
-              dispatch.controlSock,
-              dispatch.daemonShort,
-              controlAuth,
-            ),
-          )
-          .catch(() => {});
-      }
-      resolve(finalCompletion);
-    };
-
-    const timer = activity
-      ? setInterval(() => {
-          void activity
-            .check({
-              channel: "daemon",
-              controlSock: dispatch.controlSock,
-              daemonShort: dispatch.daemonShort,
-              resultFile: dispatch.resultFile,
-            })
-            .then((reason) => {
-              if (reason) finish(null, reason);
-            });
-        }, lifecycle.checkIntervalMs ?? 5_000)
-      : setTimeout(
-          () => finish(null, "wall_clock"),
-          Math.max(0, timeoutSec * 1000),
-        );
-    if (typeof timer.unref === "function") timer.unref();
-
-    socket.on("error", () => finish(null, "socket_error"));
-    socket.on("close", () => {
-      if (!settled) finish(null, "socket_closed");
-    });
-    socket.on("connect", () => {
-      socket.write(
-        `${JSON.stringify({
-          proto: 1,
-          op: "subscribe",
-          short: dispatch.daemonShort,
-          tail: 20,
-        })}\n`,
-      );
-    });
-    socket.on("data", (chunk) => {
-      buffer += chunk.toString("utf8");
-      while (buffer.includes("\n")) {
-        const index = buffer.indexOf("\n");
-        const line = buffer.slice(0, index);
-        buffer = buffer.slice(index + 1);
-        if (!line.trim()) continue;
-        const message = JSON.parse(line);
-        messages.push(message);
-        activity?.observe();
-        if (
-          safeProgress &&
-          progressIntervalSec > 0 &&
-          typeof message.line === "string"
-        ) {
-          const now = Date.now();
-          if (now - lastProgressAt >= progressIntervalSec * 1000) {
-            lastProgressAt = now;
-            safeProgress({
-              type: "progress",
-              paneName: dispatch.paneName,
-              displayName: dispatch.displayName,
-              cli: dispatch.cli,
-              snapshot: message.line.split("\n").slice(-15).join("\n"),
-            });
-          }
-        }
-        const completion = waitForDaemonCompletionFromMessages(messages, {
-          token: dispatch.token,
-          resultFile: dispatch.resultFile,
-        });
-        if (completion.matched) finish(completion);
-      }
-    });
-  });
-}
-
-async function awaitAllDaemon(
-  dispatches,
-  timeoutSec,
-  safeProgress,
-  progressIntervalSec,
-  lifecycle,
-) {
-  return Promise.all(
-    dispatches.map(async (d) => {
-      const completion = await waitForDaemonCompletion(
-        d,
-        timeoutSec,
-        safeProgress,
-        progressIntervalSec,
-        lifecycle,
-      );
-      const output = readResult(d.resultFile, d.paneId);
-      unregisterHeadlessSynapseWorker(d.workerId);
-
-      if (safeProgress) {
-        safeProgress({
-          type: "completed",
-          paneName: d.paneName,
-          displayName: d.displayName,
-          cli: d.cli,
-          matched: completion.matched,
-          exitCode: completion.exitCode,
-          sessionDead: false,
-          stallDetected: false,
-          stallExhausted: false,
         });
       }
 
@@ -1693,7 +809,7 @@ async function awaitAllDaemon(
  * @param {Array<{d, completion, output}>} results
  * @returns {Array}
  */
-async function collectResults(sessionName, results) {
+async function collectResults(results) {
   // handoff 파이프라인: parse → validate → format (각 워커 결과에 적용)
   return await Promise.all(
     results.map(async ({ d, completion, output }) => {
@@ -1715,18 +831,6 @@ async function collectResults(sessionName, results) {
         };
         handoffResult.formatted = formatHandoffForLead(handoffResult.handoff);
       }
-      const status =
-        handoffResult.handoff?.status ||
-        (completion.matched && completion.exitCode === 0
-          ? "completed"
-          : "failed");
-      await publishHeadlessResult(
-        sessionName,
-        d.workerId,
-        status,
-        handoffResult.handoff,
-      );
-
       return {
         cli: d.cli,
         paneName: d.paneName,
@@ -1782,21 +886,18 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
   const sessionOwnership =
     opts._sessionOwnership ||
     createHeadlessSessionOwnership(deps.killPsmuxSession || killPsmuxSession);
+  const agentsRows = opts._agentsRows || createAgentsRowOwnership();
   let {
     timeoutSec = 900,
     layout = "2x2",
     onProgress,
     progressIntervalSec = 0,
     progressive = true,
-    autoAttach = false,
     dashboard = false,
     dashboardLayout = "single",
-    stallDetect,
     nativeBridge = false,
-    nativeBridgeMode = "roster",
+    nativeBridgeMode = "agents",
     onIntervene,
-    leadPane = null,
-    leadTmux = null,
   } = opts;
   if (!Number.isFinite(Number(timeoutSec)) || Number(timeoutSec) <= 0)
     timeoutSec = 900;
@@ -1814,70 +915,13 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
   );
 
   if (normalizedAssignments.length === 0) {
-    return { sessionName, results: [], sessionOwnership };
+    return { sessionName, results: [], sessionOwnership, agentsRows };
   }
 
-  let nativeBridgeHandle = null;
-  let daemonDispatches = [];
   let runCompleted = false;
   let completedResults = [];
   let runFailed = false;
   let runError;
-  if (nativeBridge && nativeBridgeMode === "claude-wrapper") {
-    throw new Error(
-      "[headless] --native-bridge-mode claude-wrapper is reserved and not implemented yet",
-    );
-  }
-  if (
-    nativeBridge &&
-    (nativeBridgeMode === "roster" || nativeBridgeMode === "interactive-attach")
-  ) {
-    nativeBridgeHandle = await startClaudeNativeBridge({
-      sessionName,
-      assignments: normalizedAssignments,
-      cwd: process.cwd(),
-      workerType:
-        nativeBridgeMode === "interactive-attach" ? "interactive" : "headless",
-      onKill() {
-        sessionOwnership.release();
-      },
-    });
-    process.stderr.write(
-      `[headless] Claude native bridge roster written: ${nativeBridgeHandle.rosterPath}\n`,
-    );
-  }
-
-  // Hub version skew pre-flight (fail-open, best-effort)
-  requestJson("/status", { method: "GET", timeoutMs: 500 })
-    .then((status) => {
-      const hubRate = status?.spawn_trace?.max_per_sec;
-      const localRate = getMaxSpawnPerSec();
-      if (typeof hubRate === "number" && hubRate !== localRate) {
-        console.warn(
-          `[headless] Hub version skew detected: hub spawn rate=${hubRate}/s, local=${localRate}/s. Restart hub to sync.`,
-        );
-      }
-    })
-    .catch(() => {});
-
-  // Synapse: 세션 registration (fire-and-forget, hub 미응답 시 무시)
-  const synapseIds = normalizedAssignments.map(
-    (_, i) => `${sessionName}-worker-${i + 1}`,
-  );
-  for (let i = 0; i < normalizedAssignments.length; i++) {
-    const a = normalizedAssignments[i];
-    requestJson("/synapse/register", {
-      method: "POST",
-      body: {
-        sessionId: synapseIds[i],
-        host: "local",
-        taskSummary: String(a.prompt || "").slice(0, 100),
-        isRemote: false,
-      },
-      timeoutMs: 1000,
-    }).catch(() => {});
-  }
-
   // in-process TUI: dashboard=true이고 stdout이 TTY일 때 직접 구동
   let tui = null;
   const resolvedLayout = resolveDashboardLayout(
@@ -1897,7 +941,7 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
       const a = normalizedAssignments[i];
       const paneName = `worker-${i + 1}`;
       tui.updateWorker(paneName, {
-        cli: resolveHeadlessCliType(a.cli || "codex"),
+        cli: resolveCliType(a.cli || "codex"),
         displayName: resolveHeadlessDisplayName(a, paneName),
         role: a.role || "",
         status: "pending",
@@ -1905,11 +949,10 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
       });
     }
   } else if (dashboard) {
-    // Issue #116-F: --dashboard 요청이 non-TTY 환경에서 silent skip 되던 혼란 해소.
-    // stderr 로만 안내 (stdout 은 readHeadlessResult 파싱 대상이라 건드리지 않는다).
+    // stdout은 결과 파싱 대상이므로 안내는 stderr로 보낸다.
     const logDir = join(tmpdir(), "tfx-headless");
     process.stderr.write(
-      `\n⚠ --dashboard requested but stdout is not a TTY; dashboard is skipped.\n` +
+      `\n⚠ stdout is not a TTY; dashboard is skipped.\n` +
         `  Session is running in background. Worker logs:\n` +
         `    ${logDir}${IS_WINDOWS ? "\\" : "/"}${sessionName}-worker-N.txt\n` +
         `    ${logDir}${IS_WINDOWS ? "\\" : "/"}${sessionName}-worker-N.txt.err\n\n`,
@@ -1951,62 +994,9 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     }
   }
 
-  // Synapse heartbeat: progress 이벤트마다 해당 워커의 세션 갱신
-  const feedSynapse = (event) => {
-    if (!event?.paneName) return;
-    const match = event.paneName.match(/worker-(\d+)/);
-    if (!match) return;
-    const idx = parseInt(match[1], 10) - 1;
-    const sid = synapseIds[idx];
-    if (!sid) return;
-    requestJson("/synapse/heartbeat", {
-      method: "POST",
-      body: {
-        sessionId: sid,
-        partial: { taskSummary: (event.snapshot || "").slice(0, 100) },
-      },
-      timeoutMs: 500,
-    }).catch(() => {});
-  };
-
-  const HUB_ACTIVITY_MIN_INTERVAL_MS = 30_000;
-  const lastHubBeatByWorker = new Map();
-  const feedHubActivity = (event) => {
-    if (event?.type !== "progress" || !event.paneName) return;
-    const match = event.paneName.match(/worker-(\d+)/);
-    if (!match) return;
-    const idx = parseInt(match[1], 10) - 1;
-    const agentId = getHeadlessWorkerAgentId(sessionName, idx);
-    const nowMs = Date.now();
-    if (
-      (lastHubBeatByWorker.get(agentId) || 0) + HUB_ACTIVITY_MIN_INTERVAL_MS >
-      nowMs
-    )
-      return;
-    lastHubBeatByWorker.set(agentId, nowMs);
-    requestJson("/bridge/heartbeat", {
-      method: "POST",
-      body: {
-        agent_id: agentId,
-        ...(presenceOwnerByAgent.get(agentId) || {}),
-      },
-      timeoutMs: 500,
-    }).catch(() => {});
-    const assignJobId = normalizedAssignments[idx]?.assignJobId;
-    if (assignJobId)
-      requestJson("/bridge/assign/result", {
-        method: "POST",
-        body: { job_id: assignJobId, worker_agent: agentId, status: "running" },
-        timeoutMs: 500,
-      }).catch(() => {});
-  };
-
   // onProgress 예외를 삼켜 실행 흐름 보호 (onPoll과 동일 패턴)
   const combinedProgress = (event) => {
-    nativeBridgeHandle?.handleProgress(event);
     feedTui(event);
-    feedSynapse(event);
-    feedHubActivity(event);
     if (onProgress) {
       try {
         onProgress(event);
@@ -2026,82 +1016,37 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
   try {
     const progressiveDispatch = deps.dispatchProgressive || dispatchProgressive;
     const batchDispatch = deps.dispatchBatch || dispatchBatch;
-    const dispatches =
-      nativeBridge && nativeBridgeMode === "agents"
-        ? await dispatchDaemonBatch(sessionName, normalizedAssignments, {
-            safeProgress,
-          })
-        : progressive
-          ? await progressiveDispatch(sessionName, normalizedAssignments, {
-              layout,
-              safeProgress,
-              dashboardLayout,
-              sessionOwnership,
-              _deps: deps,
-            })
-          : await batchDispatch(sessionName, normalizedAssignments, {
-              layout,
-              safeProgress,
-              dashboardLayout,
-              sessionOwnership,
-              _deps: deps,
-            });
-    if (nativeBridge && nativeBridgeMode === "agents") {
-      daemonDispatches = dispatches;
-      const createObservationSession =
-        deps.createDaemonObservationSession || createDaemonObservationSession;
-      let observation = null;
-      try {
-        observation = createObservationSession(sessionName, dispatches, {
-          autoAttach,
-          dashboard,
+    const dispatches = progressive
+      ? await progressiveDispatch(sessionName, normalizedAssignments, {
+          layout,
+          safeProgress,
           dashboardLayout,
-          leadPane,
-          leadTmux,
-          onProgress: safeProgress,
+          sessionOwnership,
           _deps: deps,
-        });
-      } catch (error) {
-        emitObserverWarning(
+        })
+      : await batchDispatch(sessionName, normalizedAssignments, {
+          layout,
           safeProgress,
-          sessionName,
-          "observer_session_create",
-          error,
-          "observer setup failed",
-        );
-      }
-      if (observation) {
-        sessionOwnership.acquire(observation.sessionName);
-        safeProgress({
-          type: "session_created",
-          sessionName: observation.sessionName,
-          panes: observation.panes,
-          dashboardLayout: observation.dashboardLayout,
-          observationSource: "daemon-files",
+          dashboardLayout,
+          sessionOwnership,
+          _deps: deps,
         });
-      }
+    if (nativeBridge && nativeBridgeMode === "agents") {
+      await openHeadlessAgentsRows(sessionName, dispatches, agentsRows, {
+        safeProgress,
+        _deps: deps,
+      });
     }
 
-    const results =
-      nativeBridge && nativeBridgeMode === "agents"
-        ? await awaitAllDaemon(
-            dispatches,
-            timeoutSec,
-            safeProgress,
-            progressIntervalSec,
-            lifecycle,
-          )
-        : await awaitAll(
-            sessionName,
-            dispatches,
-            timeoutSec,
-            safeProgress,
-            progressIntervalSec,
-            stallDetect,
-            lifecycle,
-          );
-    const collected = await collectResults(sessionName, results);
-    for (const result of collected) nativeBridgeHandle?.completeWorker(result);
+    const results = await (deps.awaitAll || awaitAll)(
+      sessionName,
+      dispatches,
+      timeoutSec,
+      safeProgress,
+      progressIntervalSec,
+      lifecycle,
+    );
+    const collected = await collectResults(results);
 
     // 완료 시 TUI에 최종 상태 반영 후 닫기
     if (tui) {
@@ -2133,30 +1078,17 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     runError = error;
   }
 
-  if (!runCompleted) sessionOwnership.release();
-  try {
-    // Synapse: 세션 unregister (fire-and-forget)
-    for (const sid of synapseIds) {
-      requestJson("/synapse/unregister", {
-        method: "POST",
-        body: { sessionId: sid },
-        timeoutMs: 1000,
-      }).catch(() => {});
-    }
-    if (nativeBridgeHandle) await nativeBridgeHandle.close();
-    if (daemonDispatches.length > 0) {
-      await cleanupDaemonDispatches(daemonDispatches);
-    }
-  } catch (error) {
+  if (!runCompleted) {
     sessionOwnership.release();
-    if (!runFailed) {
-      runFailed = true;
-      runError = error;
-    }
+    await agentsRows.release();
   }
-
   if (runFailed) throw runError;
-  return { sessionName, results: completedResults, sessionOwnership };
+  return {
+    sessionName,
+    results: completedResults,
+    sessionOwnership,
+    agentsRows,
+  };
 }
 
 /**
@@ -2175,23 +1107,17 @@ export async function runHeadlessWithCleanup(assignments, opts = {}) {
   const sessionOwnership = createHeadlessSessionOwnership(
     deps.killPsmuxSession || killPsmuxSession,
   );
+  const agentsRows = createAgentsRowOwnership();
 
   try {
     return await run(sessionName, assignments, {
       ...runOpts,
       _sessionOwnership: sessionOwnership,
+      _agentsRows: agentsRows,
     });
   } finally {
-    try {
-      for (let index = 0; index < assignments.length; index++) {
-        unregisterHeadlessSynapseWorker(
-          getHeadlessWorkerAgentId(sessionName, index),
-        );
-      }
-      await deregisterHeadlessWorkers(sessionName, assignments.length);
-    } finally {
-      sessionOwnership.release();
-    }
+    await agentsRows.release();
+    sessionOwnership.release();
     // WT split pane은 psmux 종료 시 셸이 끝나면서 자동으로 닫힘
     // 수동 close-pane 불필요 (레이스 컨디션으로 WT 에러 발생)
   }
@@ -2233,71 +1159,6 @@ export function applyTrifluxTheme(sessionName) {
   }
 }
 
-/**
- * Windows Terminal에 triflux 프로필을 자동 생성/갱신한다.
- * 반투명 + 비포커스 시 더 투명 + Catppuccin 테마.
- * @returns {boolean} 성공 여부
- */
-
-/**
- * WT 기본 프로필의 폰트 크기를 읽는다.
- * @returns {number} 기본 폰트 크기 (못 읽으면 12)
- */
-function _getWtDefaultFontSize() {
-  const settingsPaths = [
-    join(
-      process.env.LOCALAPPDATA || "",
-      "Packages/Microsoft.WindowsTerminal_8wekyb3d8bbwe/LocalState/settings.json",
-    ),
-    join(
-      process.env.LOCALAPPDATA || "",
-      "Microsoft/Windows Terminal/settings.json",
-    ),
-  ];
-  for (const p of settingsPaths) {
-    if (!existsSync(p)) continue;
-    try {
-      const settings = JSON.parse(
-        readFileSync(p, "utf8").replace(/^\s*\/\/.*$/gm, ""),
-      );
-      // 기본 프로필 or 첫 프로필의 폰트
-      const defaultGuid = settings.defaultProfile;
-      const profiles = settings.profiles?.list || [];
-      const defaultProfile =
-        profiles.find((pr) => pr.guid === defaultGuid) || profiles[0];
-      return (
-        defaultProfile?.font?.size ||
-        settings.profiles?.defaults?.font?.size ||
-        12
-      );
-    } catch {
-      /* 다음 */
-    }
-  }
-  return 12;
-}
-
-/**
- * 파일을 원자적으로 쓴다 — 임시 파일에 먼저 기록 후 rename으로 교체.
- * 프로세스가 쓰기 도중 충돌해도 원본 파일이 손상되지 않는다.
- * @param {string} filePath — 대상 파일 경로
- * @param {string} data — 쓸 내용
- */
-function _atomicWriteSync(filePath, data) {
-  const tmpPath = `${filePath}.${process.pid}.tmp`;
-  try {
-    writeFileSync(tmpPath, data, "utf8");
-    renameSync(tmpPath, filePath);
-  } catch (err) {
-    try {
-      writeFileSync(tmpPath.replace(/\.tmp$/, ".tmp.del"), "");
-    } catch {
-      /* 무시 */
-    }
-    throw err;
-  }
-}
-
 function sanitizeSessionName(value) {
   return String(value || "").replace(/[^a-zA-Z0-9_-]/g, "") || "tfx-session";
 }
@@ -2338,98 +1199,52 @@ function emitObserverWarning(
   });
 }
 
-// ─── v6.0.0: Lead-Direct Interactive Mode ───
-
 /**
- * daemon/native-bridge worker를 read-only로 관찰하는 tmux session을 만든다.
- * 실제 worker process는 daemon에 남고, viewer는 result/partial/stderr 파일만 읽는다.
- *
- * @param {string} sessionName
- * @param {Array<{resultFile:string}>} dispatches
- * @param {object} [opts]
- * @returns {{sessionName:string, panes:string[], dashboardLayout:string}|null}
+ * 워커 pane 마다 `claude agents` 행을 연다. 행은 그 pane 을 읽기 전용으로 보여 준다.
+ * 행을 못 열어도 워커는 tmux 에서 계속 돈다. 실패는 observer_warning 으로 알린다.
  */
-export function createDaemonObservationSession(
+async function openHeadlessAgentsRows(
   sessionName,
   dispatches,
+  rows,
   opts = {},
 ) {
   const deps = opts._deps || {};
   const platform = deps.platform ?? process.platform;
-  const leadPane = String(opts.leadPane || "");
-  const leadTmux = String(opts.leadTmux || "");
-  if (!opts.autoAttach) return null;
-  if (platform !== "darwin" && platform !== "linux") return null;
-  if (!leadTmux.trim()) return null;
-  if (!/^%\d+$/u.test(leadPane)) return null;
-  if (!Array.isArray(dispatches) || dispatches.length === 0) return null;
-
-  const safeSessionName = sanitizeSessionName(sessionName);
-  const resolvedLayout = opts.dashboard
-    ? resolveDashboardLayout(opts.dashboardLayout, dispatches.length)
-    : "lite";
-  const createSession = deps.createPsmuxSession || createPsmuxSession;
-  const applyTheme = deps.applyTrifluxTheme || applyTrifluxTheme;
-  const sendKeys = deps.sendKeysToPane || sendKeysToPane;
-  const killSession = deps.killPsmuxSession || killPsmuxSession;
-  let created = false;
-  let stage = "observer_session_create";
-
-  try {
-    const session = createSession(safeSessionName, {
-      layout: "2x2",
-      paneCount: 1,
-    });
-    created = true;
-    stage = "observer_theme";
-    applyTheme(safeSessionName);
-    stage = "observer_viewer_start";
-    const targetPane = session.panes?.[0];
-    if (!targetPane) throw new Error("observer pane was not created");
-
-    const viewerCommand = [
-      "exec",
-      shellQuote(process.execPath),
-      shellQuote(join(SCRIPT_DIR, "tui-viewer.mjs")),
-      "--session",
-      shellQuote(safeSessionName),
-      "--result-dir",
-      shellQuote(RESULT_DIR),
-      "--layout",
-      shellQuote(resolvedLayout),
-      "--source",
-      "files",
-      "--workers",
-      String(dispatches.length),
-      "--lead-pane",
-      shellQuote(leadPane),
-    ].join(" ");
-    sendKeys(targetPane, viewerCommand, true);
-
-    return {
-      sessionName: safeSessionName,
-      panes: session.panes,
-      dashboardLayout: resolvedLayout,
-    };
-  } catch (error) {
-    if (created) {
-      try {
-        killSession(safeSessionName);
-      } catch {
-        /* fail-open: observer failure must not stop daemon workers */
-      }
-    }
+  if (platform !== "darwin" && platform !== "linux") {
     emitObserverWarning(
-      opts.onProgress,
-      safeSessionName,
-      stage,
-      error,
-      "observer setup failed",
+      opts.safeProgress,
+      sessionName,
+      "agents_row",
+      null,
+      `claude agents rows need tmux on macOS/Linux (platform: ${platform})`,
     );
-    return null;
+    return;
+  }
+  const open = deps.openAgentsRow || openAgentsRow;
+  for (const d of dispatches) {
+    try {
+      const row = await open({
+        name: `${d.cli} ${d.displayName || d.paneName}`,
+        target: d.paneId,
+        cwd: d.cwd || process.cwd(),
+      });
+      rows.add(row.short);
+      d.agentsRowShort = row.short;
+    } catch (error) {
+      emitObserverWarning(
+        opts.safeProgress,
+        sessionName,
+        "agents_row",
+        error,
+        `claude agents row failed for ${d.paneName}`,
+      );
+    }
   }
 }
 
+// ─── v6.0.0: Lead-Direct Interactive Mode ───
+
 /**
  * attached tmux의 현재 leader pane 옆에 headless session view를 연다.
  * 새 pane의 attach client는 headless session 종료와 함께 자연스럽게 종료된다.
@@ -2789,11 +1604,13 @@ export async function runHeadlessInteractive(
   let sessionOwnership = createHeadlessSessionOwnership(
     deps.killPsmuxSession || killPsmuxSession,
   );
+  const agentsRows = createAgentsRowOwnership();
 
   // Phase 1: 세션 생성 → 즉시 관찰 pane/tab attach → dispatch → 대기 → 결과 수집
   const runResult = await run(sessionName, assignments, {
     ...interactiveRunOpts,
     _sessionOwnership: sessionOwnership,
+    _agentsRows: agentsRows,
   });
   const { results } = runResult;
   sessionOwnership = runResult.sessionOwnership || sessionOwnership;
@@ -2876,12 +1693,7 @@ export async function runHeadlessInteractive(
     kill() {
       if (this._killed) return;
       this._killed = true;
-      for (let index = 0; index < assignments.length; index++) {
-        unregisterHeadlessSynapseWorker(
-          getHeadlessWorkerAgentId(sessionName, index),
-        );
-      }
-      void deregisterHeadlessWorkers(sessionName, assignments.length);
+      void agentsRows.release();
       sessionOwnership.release();
       // attach pane/tab은 psmux 종료 → attach client 종료 → 자동 닫힘
       // 수동 close-pane 불필요 (레이스 컨디션으로 WT 0x80070002 에러 발생)