@triflux/remote 10.50.1 → 10.51.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,7 +7,6 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
-  renameSync,
   rmSync,
   statSync,
   writeFileSync,
@@ -20,10 +16,8 @@ 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/cli-codex.mjs";
-import { requestJson } from "@triflux/core/hub/bridge.mjs";
+import { resolveNestedCodexAgentProfile } from "../../scripts/lib/agent-route-policy.mjs";
 import { escapePwshSingleQuoted } from "@triflux/core/hub/cli-adapter-base.mjs";
-import { getMaxSpawnPerSec } from "@triflux/core/hub/lib/spawn-trace.mjs";
 import {
   createActivityLifecycle,
   isActivityLifecycleEnabled,
@@ -40,7 +34,6 @@ import {
   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 {
@@ -63,11 +56,6 @@ import {
   startCapture,
   waitForCompletion,
 } from "./psmux.mjs";
-import {
-  buildSynapseTaskSummary,
-  registerSynapseSession,
-  unregisterSynapseSession,
-} from "./synapse-http.mjs";
 import { createLogDashboard } from "./tui.mjs";
 import { createWtManager } from "./wt-manager.mjs";
 
@@ -78,7 +66,6 @@ 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 +77,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 +94,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 +126,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 +195,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 +205,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 +226,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 = "";
@@ -391,7 +269,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 정책의 유일한 판정원이다. 여기서 같은 정책을
@@ -531,83 +408,6 @@ 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")
@@ -706,254 +506,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 +573,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 +599,6 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
     } catch {
       /* 무시 */
     }
-    await registerHeadlessWorker(sessionName, i, resolvedCli);
 
     if (safeProgress)
       safeProgress({
@@ -1081,7 +632,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 +700,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 +720,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"로 불일치
@@ -1215,7 +763,7 @@ async function dispatchDaemonBatch(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`,
@@ -1287,8 +835,6 @@ async function dispatchDaemonBatch(sessionName, assignments, opts = {}) {
         sessionId: dispatched.sessionId,
         sessionProjectionPath: dispatched.sessionProjectionPath,
       });
-      await registerHeadlessWorker(sessionName, i, resolvedCli);
-      registerHeadlessSynapseWorker(workerId, assignment.prompt);
       if (safeProgress) {
         safeProgress({ type: "dispatched", paneName, cli: resolvedCli });
       }
@@ -1348,7 +894,6 @@ async function awaitAll(
   timeoutSec,
   safeProgress,
   progressIntervalSec,
-  stallOpts,
   lifecycle,
 ) {
   // 병렬 대기 (Promise.all — 모든 pane 동시 폴링, 총 시간 = max(개별 시간))
@@ -1375,73 +920,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 +980,6 @@ async function awaitAll(
       }
 
       const output = readResult(d.resultFile, d.paneId);
-      unregisterHeadlessSynapseWorker(d.workerId);
 
       if (safeProgress) {
         safeProgress({
@@ -1512,8 +990,6 @@ async function awaitAll(
           matched: completion.matched,
           exitCode: completion.exitCode,
           sessionDead: completion.sessionDead || false,
-          stallDetected: completion.stallDetected || false,
-          stallExhausted: completion.stallExhausted || false,
         });
       }
 
@@ -1667,7 +1143,6 @@ async function awaitAllDaemon(
         lifecycle,
       );
       const output = readResult(d.resultFile, d.paneId);
-      unregisterHeadlessSynapseWorker(d.workerId);
 
       if (safeProgress) {
         safeProgress({
@@ -1678,8 +1153,6 @@ async function awaitAllDaemon(
           matched: completion.matched,
           exitCode: completion.exitCode,
           sessionDead: false,
-          stallDetected: false,
-          stallExhausted: false,
         });
       }
 
@@ -1693,7 +1166,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 +1188,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,
@@ -1791,9 +1252,8 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     autoAttach = false,
     dashboard = false,
     dashboardLayout = "single",
-    stallDetect,
     nativeBridge = false,
-    nativeBridgeMode = "roster",
+    nativeBridgeMode = "agents",
     onIntervene,
     leadPane = null,
     leadTmux = null,
@@ -1817,67 +1277,11 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     return { sessionName, results: [], sessionOwnership };
   }
 
-  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 +1301,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 +1309,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 +1354,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);
@@ -2097,11 +1447,9 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
             timeoutSec,
             safeProgress,
             progressIntervalSec,
-            stallDetect,
             lifecycle,
           );
-    const collected = await collectResults(sessionName, results);
-    for (const result of collected) nativeBridgeHandle?.completeWorker(result);
+    const collected = await collectResults(results);
 
     // 완료 시 TUI에 최종 상태 반영 후 닫기
     if (tui) {
@@ -2135,15 +1483,6 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
 
   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);
     }
@@ -2182,16 +1521,7 @@ export async function runHeadlessWithCleanup(assignments, opts = {}) {
       _sessionOwnership: sessionOwnership,
     });
   } finally {
-    try {
-      for (let index = 0; index < assignments.length; index++) {
-        unregisterHeadlessSynapseWorker(
-          getHeadlessWorkerAgentId(sessionName, index),
-        );
-      }
-      await deregisterHeadlessWorkers(sessionName, assignments.length);
-    } finally {
-      sessionOwnership.release();
-    }
+    sessionOwnership.release();
     // WT split pane은 psmux 종료 시 셸이 끝나면서 자동으로 닫힘
     // 수동 close-pane 불필요 (레이스 컨디션으로 WT 에러 발생)
   }
@@ -2233,71 +1563,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";
 }
@@ -2876,12 +2141,6 @@ 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);
       sessionOwnership.release();
       // attach pane/tab은 psmux 종료 → attach client 종료 → 자동 닫힘
       // 수동 close-pane 불필요 (레이스 컨디션으로 WT 0x80070002 에러 발생)