@triflux/remote 10.43.0 → 10.45.0

package/hub/team/retry-state-machine.mjs

@@ -23,6 +23,8 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
+import { normalizeCodexProfileName } from "../../scripts/lib/codex-profile-config.mjs";
+
 export const STATES = Object.freeze({
   PLANNING: "PLANNING",
   EXECUTING: "EXECUTING",
@@ -39,21 +41,29 @@ export const MODES = Object.freeze({
 });
 
 const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
+const DEFAULT_CLAUDE_MODEL = "fable";
 
-// Escalation chain (2026-05-27 정책):
-//   1. codex gpt-5.6-sol — 기존 최상위 Codex escalation 단계
-//   2. claude opus-4-8 — 최종 수단
+// Escalation chain (2026-09-22 정책):
+//   1. codex gpt-6-astra max: 최난도 단일 작업용 Codex escalation 단계
+//   2. claude fable alias: Claude CLI가 최신 Fable tier로 해석하는 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({
     cli: "codex",
-    model: "gpt-5.6-sol",
-    profile: "gpt56_sol_xhigh",
+    model: "gpt-6-astra",
+    profile: "gpt6_astra_max",
   }),
-  Object.freeze({ cli: "claude", model: "opus-4-8" }),
+  Object.freeze({ cli: "claude", model: DEFAULT_CLAUDE_MODEL }),
 ]);
 
 const STUCK_THRESHOLD = 3;
 
+function normalizeEscalationProfile(profile) {
+  const normalized = normalizeCodexProfileName(profile);
+  return normalized === "ultra" || normalized === "gpt6_astra_ultra"
+    ? "gpt6_astra_max"
+    : normalized;
+}
+
 export function createRetryStateMachine(options = {}) {
   const mode = options.mode || MODES.BOUNDED;
   const cliChain = resolveEscalationChain(options);
@@ -234,15 +244,25 @@ function resolveEscalationChain(options) {
   }
 
   const projectRoot = options.projectRoot || process.cwd();
-  return (
-    loadEscalationChainOverride(projectRoot) ||
-    normalizeEscalationChain(
-      DEFAULT_ESCALATION_CHAIN,
-      "DEFAULT_ESCALATION_CHAIN",
-    )
+  const projectOverride = loadEscalationChainOverride(projectRoot);
+  if (projectOverride) return projectOverride;
+
+  return normalizeEscalationChain(
+    resolveDefaultEscalationChain(options.env || process.env),
+    "DEFAULT_ESCALATION_CHAIN",
   );
 }
 
+function resolveDefaultEscalationChain(env) {
+  const configuredModel = env?.TFX_ESCALATION_CLAUDE_MODEL?.trim();
+  if (!configuredModel) return DEFAULT_ESCALATION_CHAIN;
+
+  return [
+    DEFAULT_ESCALATION_CHAIN[0],
+    { cli: "claude", model: configuredModel },
+  ];
+}
+
 export function loadEscalationChainOverride(projectRoot = process.cwd()) {
   const configPath = join(projectRoot, ESCALATION_CHAIN_CONFIG_PATH);
   if (!existsSync(configPath)) return null;
@@ -295,7 +315,9 @@ function normalizeEscalationChainEntry(entry, index, source) {
     model: entry.model,
   };
   if (typeof entry.profile === "string" && entry.profile.trim() !== "") {
-    normalized.profile = entry.profile;
+    const profile = entry.profile.trim();
+    normalized.profile =
+      entry.cli === "codex" ? normalizeEscalationProfile(profile) : profile;
   }
   return normalized;
 }
@@ -328,6 +350,12 @@ export function loadSnapshot(snapshotFile) {
       `unsupported snapshot version: ${parsed.version} (expected 1)`,
     );
   }
+  if (Array.isArray(parsed.cliChain) && parsed.cliChain.length > 0) {
+    return {
+      ...parsed,
+      cliChain: normalizeEscalationChain(parsed.cliChain, "snapshot.cliChain"),
+    };
+  }
   return parsed;
 }
 

package/hub/team/session.mjs

@@ -475,6 +475,63 @@ export function attachSession(sessionName) {
   }
 }
 
+/**
+ * non-TTY 환경용 attach fallback: 요청 프로세스가 명시적으로 넘긴 lead pane을
+ * 분할해 그 pane 안에서 대상 세션에 attach한다.
+ *
+ * 호출 프로세스가 pipe(non-TTY)로 실행돼 attachSession()이 불가능해도,
+ * tmux 서버에 보내는 split-window는 호출자 TTY가 필요 없다. 새 pane에는
+ * tmux가 실제 pty를 붙여주므로 그 안의 attach는 정상 동작한다.
+ * env -u TMUX는 nested-attach 보호 해제용이다.
+ *
+ * @param {string} sessionName attach할 대상 세션
+ * @param {string} targetPane 요청 lead의 `$TMUX_PANE` (`%N`)
+ * @param {string} tmuxEnv 요청 lead의 `$TMUX` (`socket,pid,index`)
+ * @returns {boolean} 분할 attach 성공 여부 (false면 호출자가 기존 생략 경로 유지)
+ */
+export function buildSplitAttachArgs(sessionName, targetPane, tmuxEnv) {
+  const normalizedSessionName = String(sessionName || "");
+  if (!normalizedSessionName.trim()) {
+    throw new Error("session name is required");
+  }
+  if (!/^%\d+$/u.test(String(targetPane || ""))) {
+    throw new Error("requesting lead TMUX_PANE is required");
+  }
+  const socketPath = String(tmuxEnv || "").split(",", 1)[0];
+  if (!socketPath.trim()) {
+    throw new Error("requesting lead TMUX socket is required");
+  }
+  const quotedSocket = `'${socketPath.replace(/'/gu, "'\\''")}'`;
+  const quotedSessionName = `'${normalizedSessionName.replace(/'/gu, "'\\''")}'`;
+  return [
+    "split-window",
+    "-t",
+    targetPane,
+    "-v",
+    "-l",
+    "50%",
+    `env -u TMUX tmux -S ${quotedSocket} attach -t ${quotedSessionName}`,
+  ];
+}
+
+export function splitAttachToClient(sessionName, opts = {}) {
+  const deps = opts._deps || {};
+  const detectMux = deps.detectMultiplexer || detectMultiplexer;
+  if (detectMux() !== "tmux") return false;
+
+  let args;
+  try {
+    args = buildSplitAttachArgs(sessionName, opts.targetPane, opts.tmuxEnv);
+  } catch {
+    return false;
+  }
+
+  // 상하 분할: 좌우 분할은 절반 폭이 워커 pane 가독 하한(100cols) 미만인 경우가 흔함
+  const spawn = deps.spawnSync || spawnSync;
+  const split = spawn("tmux", args);
+  return (split.status ?? 1) === 0;
+}
+
 /**
  * tmux 세션 존재 확인
  * @param {string} sessionName

package/hub/team/swarm-hypervisor.mjs

@@ -20,8 +20,8 @@ import {
   isDynamicRoutingEnabled,
 } from "@triflux/core/hub/dynamic-routing-engine.mjs";
 import { cleanupShardProcesses } from "@triflux/core/hub/lib/process-utils.mjs";
-import { DEFAULT_SWARM_LOCK_TTL_MS } from "@triflux/core/hub/lib/timeout-defaults.mjs";
 import { getHostConfig } from "@triflux/core/hub/lib/ssh-command.mjs";
+import { DEFAULT_SWARM_LOCK_TTL_MS } from "@triflux/core/hub/lib/timeout-defaults.mjs";
 import { buildWorkerPrompt } from "./build-worker-prompt.mjs";
 import { registerSwarmShard } from "./claude-native-bridge.mjs";
 import { createConductor, STATES } from "./conductor.mjs";
@@ -678,6 +678,7 @@ export function createSwarmHypervisor(opts) {
     const config = {
       id: buildSwarmSessionId(shard),
       agent: shard.agent,
+      role: shard.role,
       // #125: append Completion Protocol appendix so workers emit a
       // sentinel-framed JSON payload that conductor can reliably capture.
       prompt: buildWorkerPrompt(shard.prompt, {
@@ -1964,7 +1965,8 @@ export function createSwarmHypervisor(opts) {
     lockRenewTimer = setInterval(() => {
       if (!lockManager) return;
       for (const shardName of workers.keys()) {
-        if (!completedShards.has(shardName) && !failures.has(shardName)) lockManager.renew(shardName);
+        if (!completedShards.has(shardName) && !failures.has(shardName))
+          lockManager.renew(shardName);
       }
     }, DEFAULT_SWARM_LOCK_TTL_MS / 2);
     lockRenewTimer.unref?.();

package/hub/team/swarm-preflight.mjs

@@ -1,6 +1,7 @@
 // hub/team/swarm-preflight.mjs — PRD swarm preflight report/gate (#188)
 // Predicts launch-time blockers before any worker session or worktree spawn.
 
+import { execFileSync } from "node:child_process";
 import { resolve } from "node:path";
 import { readHosts, resolveHost } from "@triflux/core/hub/lib/hosts-compat.mjs";
 import { whichCommand } from "@triflux/core/hub/platform.mjs";
@@ -83,6 +84,44 @@ function checkSensitive(plan, sensitiveDeny) {
   return makeCheck("sensitiveDeny", true, { matches });
 }
 
+function parseTrackedStatus(rawStatus) {
+  const files = [];
+  const records = String(rawStatus || "").split("\0");
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    if (record.length < 4) continue;
+    const status = record.slice(0, 2);
+    files.push(normalizePath(record.slice(3)));
+    if (/[RC]/u.test(status) && records[index + 1]) {
+      files.push(normalizePath(records[++index]));
+    }
+  }
+  return unique(files);
+}
+
+function checkRootDirtyLease(plan, repoRoot, deps = {}) {
+  const gitStatus =
+    deps.gitStatus ||
+    ((cwd) =>
+      execFileSync(
+        "git",
+        ["status", "--porcelain=v1", "-z", "--untracked-files=no"],
+        { cwd, encoding: "utf8", windowsHide: true },
+      ));
+  const dirtyFiles = parseTrackedStatus(gitStatus(repoRoot));
+  const leasedFiles = unique(
+    [...plan.leaseMap.values()].flat().map(normalizePath),
+  );
+  const leaseSet = new Set(leasedFiles);
+  const overlappingFiles = dirtyFiles.filter((file) => leaseSet.has(file));
+
+  return makeCheck("rootDirtyLease", overlappingFiles.length === 0, {
+    dirtyFiles,
+    leasedFiles,
+    overlappingFiles,
+  });
+}
+
 function checkHosts(plan, repoRoot) {
   const registry = readHosts(repoRoot);
   const missing = [];
@@ -216,6 +255,13 @@ function collectMessages(checks) {
     );
   }
 
+  const rootDirtyLease = checks.rootDirtyLease;
+  if (rootDirtyLease && !rootDirtyLease.ok) {
+    errors.push(
+      `rootDir tracked changes overlap shard leases: ${rootDirtyLease.overlappingFiles.join(", ")}`,
+    );
+  }
+
   return { errors: unique(errors), warnings: unique(warnings) };
 }
 
@@ -258,6 +304,7 @@ export function runSwarmPreflight(prdPath, opts = {}) {
     leases: makeCheck("leases", plan.conflicts.length === 0, {
       conflicts: [...plan.conflicts],
     }),
+    rootDirtyLease: checkRootDirtyLease(plan, repoRoot, opts.deps),
     sensitiveDeny: checkSensitive(plan, sensitiveDeny),
     hosts: checkHosts(plan, repoRoot),
     workerCli: checkLocalWorkerClis(plan, opts.deps),

package/hub/team/synapse-http.mjs

@@ -1,6 +1,9 @@
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { normalizeRoleKey } from "@triflux/core/hub/role-contract.mjs";
 
 const HUB_DEFAULT_PORT = 27888;
 // Same token file as hub/bridge.mjs (HUB_TOKEN_FILE). Kept inline rather than
@@ -21,6 +24,144 @@ function normalizeToken(raw) {
   return token || null;
 }
 
+function opaqueId(prefix, value) {
+  return `${prefix}_${createHash("sha256")
+    .update(String(value || ""))
+    .digest("base64url")
+    .slice(0, 22)}`;
+}
+
+function normalizedProjectId(value) {
+  try {
+    return normalizeRoleKey({ project_id: value, role_kind: "cto" }).project_id;
+  } catch {
+    return "";
+  }
+}
+
+function resolveProjectId(cwd, meta, opts = {}) {
+  const explicit = meta?.project_id || process.env.TFX_PROJECT_ID;
+  if (explicit) return normalizedProjectId(explicit);
+  if (typeof opts.resolveProjectId === "function") {
+    return normalizedProjectId(opts.resolveProjectId(cwd));
+  }
+  let current = cwd;
+  while (current) {
+    const manifest = join(current, ".triflux", "project.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        if (parsed?.schema_version !== "tfx.project.v1") return "";
+        return normalizedProjectId(parsed.project_id);
+      } catch {
+        return "";
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "";
+}
+
+function inferSessionCli(meta, opts = {}) {
+  const explicit = String(meta?.cli || meta?.actor_cli || "")
+    .trim()
+    .toLowerCase();
+  if (explicit === "codex" || explicit === "claude") return explicit;
+  const entrypoint = String(opts.entrypoint ?? process.argv[1] ?? "");
+  if (entrypoint.includes("codex-session-hook")) return "codex";
+  if (entrypoint.includes("agy-session-hook")) return "other";
+  return "claude";
+}
+
+function resolveTmuxSession(meta, opts = {}) {
+  const explicit =
+    meta?.tmux_session || meta?.session_name || process.env.TFX_TMUX_SESSION;
+  if (explicit) return String(explicit).trim();
+  if (!process.env.TMUX) return "";
+  try {
+    const run =
+      opts.tmuxSessionName ||
+      (() =>
+        execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
+          encoding: "utf8",
+          timeout: 200,
+          windowsHide: true,
+        }));
+    return String(run() || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+export function buildSynapseRegistrationMeta(meta, opts = {}) {
+  if (!meta || meta.sessionKind !== "interactive") return meta;
+  const sessionId = String(meta.sessionId || "").trim();
+  if (!sessionId) return meta;
+  const cwd = typeof meta.cwd === "string" ? meta.cwd : process.cwd();
+  const cli = inferSessionCli(meta, opts);
+  const hostId = String(
+    meta.host_id ||
+      process.env.TFX_HOST_ID ||
+      opaqueId("hst", opts.hostname?.() || hostname()),
+  ).trim();
+  const expiresAtMs = Number(opts.nowMs?.() ?? Date.now()) + 299000;
+  const transportLocators = [];
+  if (cli === "claude") {
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `claude-uds:${hostId}:${sessionId}`),
+      kind: "claude-uds",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: 100,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_id: sessionId,
+        bridge_id: String(
+          meta.bridge_id || process.env.TFX_BRIDGE_ID || "local-hub",
+        ),
+      },
+    });
+  }
+  const tmuxSession = resolveTmuxSession(meta, opts);
+  if (tmuxSession) {
+    const muxServerSource =
+      meta.mux_server_id ||
+      process.env.TFX_MUX_SERVER_ID ||
+      String(process.env.TMUX || "default").split(",", 1)[0];
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `tmux:${hostId}:${tmuxSession}`),
+      kind: "tmux",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: cli === "codex" ? 100 : 50,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_name: tmuxSession,
+        mux_server_id: opaqueId("mux", muxServerSource),
+      },
+    });
+  }
+  const directAgentId = `session:${sessionId}`;
+  return {
+    ...meta,
+    agent_id:
+      meta.agent_id ||
+      (directAgentId.length <= 64 && /^[a-zA-Z0-9._:-]+$/u.test(directAgentId)
+        ? directAgentId
+        : opaqueId("session", sessionId)),
+    cli,
+    project_id: resolveProjectId(cwd, meta, opts) || undefined,
+    session_id: meta.session_id || sessionId,
+    host_id: hostId,
+    transport_locators_json:
+      meta.transport_locators_json ?? JSON.stringify(transportLocators),
+  };
+}
+
 // Mirrors hub/bridge.mjs:readHubToken — env override first, then the token file.
 // Missing token → null (backward-compatible with token-less hubs).
 function readHubToken() {
@@ -139,7 +280,11 @@ export function drainPendingSynapse(timeoutMs = 1000) {
 }
 
 export function registerSynapseSession(meta, opts = {}) {
-  return fireAndForgetSynapse("/synapse/register", meta, opts);
+  return fireAndForgetSynapse(
+    "/synapse/register",
+    buildSynapseRegistrationMeta(meta, opts),
+    opts,
+  );
 }
 
 export function heartbeatSynapseSession(

package/hub/team/terminal-opener.mjs

@@ -111,6 +111,35 @@ function wtResultSucceeded(result) {
   return result?.success !== false;
 }
 
+function resolveLeadPane(value) {
+  const pane = String(value || "");
+  return /^%\d+$/u.test(pane) ? pane : null;
+}
+
+function resolveLeadWindow(tmuxExec, targetPane) {
+  try {
+    const targetWindow = String(
+      tmuxExec(
+        `display-message -p -t ${targetPane} '#{session_name}:#{window_index}'`,
+      ) ?? "",
+    ).trim();
+    return targetWindow || null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveLeadSocket(tmuxExec, targetPane) {
+  try {
+    const socketPath = String(
+      tmuxExec(`display-message -p -t ${targetPane} '#{socket_path}'`) ?? "",
+    ).trim();
+    return socketPath || null;
+  } catch {
+    return null;
+  }
+}
+
 export function createTerminalOpener(deps = {}) {
   const platform = resolvePlatform(deps);
   const tmuxExec = deps.tmuxExec || defaultTmuxExec;
@@ -134,12 +163,22 @@ export function createTerminalOpener(deps = {}) {
 
     const mux = resolveMux(deps);
     if (isTmuxLikeMux(mux, platform)) {
-      tmuxExec(
-        `new-window -n ${shellQuote(title)} ${shellQuote(
-          buildCommandString(spec),
-        )}`,
-      );
-      return true;
+      const targetPane = resolveLeadPane(spec.targetPane);
+      if (!targetPane) return false;
+      const targetWindow = resolveLeadWindow(tmuxExec, targetPane);
+      if (!targetWindow) return false;
+      try {
+        // tmux new-window는 pane target(%N)을 거부하므로, 요청 pane에서 해석한
+        // 정확한 session:window 뒤에 새 window를 삽입한다.
+        tmuxExec(
+          `new-window -a -t ${shellQuote(targetWindow)} -n ${shellQuote(
+            title,
+          )} ${shellQuote(buildCommandString(spec))}`,
+        );
+        return true;
+      } catch {
+        return false;
+      }
     }
 
     if (platform === "darwin") {
@@ -174,14 +213,30 @@ export function createTerminalOpener(deps = {}) {
 
     const mux = resolveMux(deps);
     if (isTmuxLikeMux(mux, platform)) {
-      const attachCommand = buildAttachCommand(mux, sessionName, deps);
+      const targetPane = resolveLeadPane(opts.targetPane);
+      if (!targetPane) return false;
+      const socketPath =
+        mux === "psmux" ? null : resolveLeadSocket(tmuxExec, targetPane);
+      if (mux !== "psmux" && !socketPath) return false;
+      const attachCommand =
+        mux === "psmux"
+          ? buildAttachCommand(mux, sessionName, deps)
+          : `env -u TMUX tmux -S ${shellQuote(
+              socketPath,
+            )} attach-session -t ${shellQuote(sessionName)}`;
       if (!attachCommand) return false;
-      tmuxExec(
-        `new-window -n ${shellQuote(opts.title ?? sessionName)} ${shellQuote(
-          attachCommand,
-        )}`,
-      );
-      return true;
+      const targetWindow = resolveLeadWindow(tmuxExec, targetPane);
+      if (!targetWindow) return false;
+      try {
+        tmuxExec(
+          `new-window -a -t ${shellQuote(targetWindow)} -n ${shellQuote(
+            opts.title ?? sessionName,
+          )} ${shellQuote(attachCommand)}`,
+        );
+        return true;
+      } catch {
+        return false;
+      }
     }
 
     return false;

package/hub/team/tui-viewer.mjs

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { formatPsmuxInstallGuidance } from "../../scripts/lib/psmux-info.mjs";
 import { openHeadlessDashboardTarget } from "./dashboard-open.mjs";
 import { processHandoff } from "./handoff.mjs";
+import { getMultiplexerType } from "./psmux.mjs";
 import { createLogDashboard } from "./tui.mjs";
 import { createLiteDashboard } from "./tui-lite.mjs";
 
@@ -24,23 +25,36 @@ function argVal(flag) {
 const SESSION = argVal("--session");
 const RESULT_DIR = argVal("--result-dir") ?? join(tmpdir(), "tfx-headless");
 const LAYOUT = argVal("--layout") ?? "single";
-
-if (!SESSION) {
+const SOURCE = argVal("--source") === "files" ? "files" : "mux";
+const LEAD_PANE = argVal("--lead-pane");
+const parsedWorkerCount = Number.parseInt(argVal("--workers") || "0", 10);
+const WORKER_COUNT = Number.isFinite(parsedWorkerCount)
+  ? Math.min(64, Math.max(0, parsedWorkerCount))
+  : 0;
+const MUX_BIN = getMultiplexerType();
+
+if (!SESSION || !/^[a-zA-Z0-9_-]+$/u.test(SESSION)) {
   process.stderr.write(
     "Usage: node tui-viewer.mjs --session <name> [--result-dir <dir>] [--layout <name>]\n",
   );
   process.exit(1);
 }
-
-try {
-  execFileSync("psmux", ["--version"], { encoding: "utf8", timeout: 2000 });
-} catch {
-  process.stderr.write(
-    `ERROR: psmux 미설치. 설치 방법:\n${formatPsmuxInstallGuidance("  ")}\n`,
-  );
+if (SOURCE === "files" && WORKER_COUNT === 0) {
+  process.stderr.write("ERROR: --source files requires --workers <count>\n");
   process.exit(1);
 }
 
+if (SOURCE === "mux") {
+  try {
+    execFileSync(MUX_BIN, ["-V"], { encoding: "utf8", timeout: 2000 });
+  } catch {
+    process.stderr.write(
+      `ERROR: primary multiplexer 미설치. 설치 방법:\n${formatPsmuxInstallGuidance("  ")}\n`,
+    );
+    process.exit(1);
+  }
+}
+
 // ── 메모리 보호 상수 ──
 const MAX_BODY_BYTES = 10240;
 
@@ -59,11 +73,13 @@ const tui = tuiFactory({
       worker: workerName,
       openAll: false,
       cwd: process.cwd(),
+      targetPane: LEAD_PANE,
     }),
   onOpenAllWorkers: () =>
     openHeadlessDashboardTarget(SESSION, {
       openAll: true,
       cwd: process.cwd(),
+      targetPane: LEAD_PANE,
     }),
 });
 const startTime = Date.now();
@@ -166,9 +182,16 @@ function estimateProgress(lines, context = {}) {
 
 // ── psmux 래퍼 ──
 function listPanes() {
+  if (SOURCE === "files") {
+    return Array.from({ length: WORKER_COUNT }, (_, index) => ({
+      index: index + 1,
+      title: `worker-${index + 1} (daemon)`,
+      pid: "",
+    }));
+  }
   try {
     const out = execFileSync(
-      "psmux",
+      MUX_BIN,
       [
         "list-panes",
         "-t",
@@ -192,9 +215,35 @@ function listPanes() {
 }
 
 function capturePane(paneIdx, lines = 20) {
+  if (SOURCE === "files") {
+    const base = join(RESULT_DIR, `${SESSION}-worker-${paneIdx}.txt`);
+    const artifacts = [
+      { path: base, label: "output" },
+      { path: `${base}.partial`, label: "daemon" },
+      { path: `${base}.err`, label: "stderr" },
+    ];
+    const snapshots = [];
+    for (const artifact of artifacts) {
+      try {
+        const content = readFileSync(artifact.path, "utf8").trim();
+        if (!content) continue;
+        snapshots.push(
+          `[${artifact.label}]\n${content.split("\n").slice(-lines).join("\n")}`,
+        );
+      } catch {
+        /* artifact is optional while the daemon job is starting */
+      }
+    }
+    return (
+      snapshots.join("\n") ||
+      `worker-${paneIdx} daemon active · waiting for output · ${Math.round(
+        (Date.now() - startTime) / 1000,
+      )}s`
+    );
+  }
   try {
     return execFileSync(
-      "psmux",
+      MUX_BIN,
       ["capture-pane", "-t", `${SESSION}:0.${paneIdx}`, "-p"],
       { encoding: "utf8", timeout: 2000 },
     )
@@ -368,7 +417,7 @@ function ingest() {
     const tokens = extractTokenLabel(snapshot);
     const elapsed = Math.round((Date.now() - startTime) / 1000);
 
-    if (resultSize > 10 || shellReturned) {
+    if (SOURCE !== "files" && (resultSize > 10 || shellReturned)) {
       const resultContent = existsSync(resultFile)
         ? readFileSync(resultFile, "utf8")
         : snapshot;
@@ -410,8 +459,10 @@ function ingest() {
     // 진행 중
     const progress = estimateProgress(lines, {
       tokens,
-      resultSize,
-      shellReturned,
+      // daemon output files grow while the job is still running; file size is
+      // activity evidence, not a completion signal in read-only file mode.
+      resultSize: SOURCE === "files" ? 0 : resultSize,
+      shellReturned: SOURCE === "files" ? false : shellReturned,
       done: false,
     });
     const verdict = lastLine;