@triflux/remote 10.27.0 → 10.28.0

package/hub/team/claude-daemon-control.mjs

@@ -1,8 +1,60 @@
+import { execFileSync } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
+import {
+  buildClaudeSessionProjection,
+  removeClaudeSessionProjection,
+  writeClaudeSessionProjection,
+} from "./claude-session-projection.mjs";
+
+export function buildClaudePromptDispatchPayload({
+  short = crypto.randomBytes(4).toString("hex"),
+  sessionId,
+  cwd = process.cwd(),
+  prompt,
+  name = "tfx uds claude prompt",
+  createdAt = Date.now(),
+  cols = 120,
+  rows = 40,
+} = {}) {
+  if (!prompt) throw new Error("prompt is required");
+  const uuid = crypto.randomUUID();
+  const resolvedSessionId = sessionId || `${short}${uuid.slice(8)}`;
+  return {
+    proto: 1,
+    short,
+    sessionId: resolvedSessionId,
+    createdAt,
+    source: "shell",
+    cwd,
+    agent: "claude",
+    launch: {
+      mode: "prompt",
+      args: [
+        "--session-id",
+        resolvedSessionId,
+        "--agent",
+        "claude",
+        "--permission-mode",
+        "auto",
+        "--",
+        prompt,
+      ],
+    },
+    env: {},
+    isolation: "none",
+    respawnFlags: [],
+    seed: {
+      intent: "[redacted uds orchestration prompt]",
+      name,
+    },
+    cols,
+    rows,
+  };
+}
 
 export function resolveClaudeConfigDir(env = process.env) {
   if (env.CLAUDE_CONFIG_DIR) return path.resolve(env.CLAUDE_CONFIG_DIR);
@@ -26,12 +78,23 @@ export function deriveClaudeDaemonPaths({
     hash,
     daemonDir,
     controlSock: path.join(daemonDir, "control.sock"),
+    rendezvousDir: path.join(daemonDir, "rv"),
+    ptyDir: path.join(daemonDir, "pty"),
     rosterPath: path.join(resolvedConfigDir, "daemon", "roster.json"),
     sessionsDir: path.join(resolvedConfigDir, "sessions"),
     jobsDir: path.join(resolvedConfigDir, "jobs"),
   };
 }
 
+export function getProcStart(pid = process.pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    throw new Error(`invalid pid: ${pid}`);
+  return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
+  }).trim();
+}
+
 export function readFirstJsonLine(text) {
   const line = String(text)
     .split("\n")
@@ -1128,3 +1191,154 @@ export async function sendKillBySessionId({
     };
   }
 }
+
+/**
+ * Claude 데몬 dispatch 한 건의 공통 시퀀스를 캡슐화한다.
+ * dispatch → waitForDaemonJobPid → resolveDaemonBridgeSessionId →
+ * buildClaudeSessionProjection → writeClaudeSessionProjection.
+ *
+ * 호출 측이 reference 로 들고 있는 record 를 헬퍼가 새로 만들지 않도록
+ * plain 필드만 반환한다. caller 는 이 결과를 자기 record 에 Object.assign 한다.
+ *
+ * @returns {Promise<{ok:boolean, short:string, sessionId:string, job:object,
+ *   pid:number, bridgeSessionId:string, sessionProjectionPath:string,
+ *   controlSock:string, paths:object}>}
+ */
+export async function dispatchClaudeDaemonJob({
+  paths,
+  controlSock,
+  payload,
+  agent,
+  name,
+  cwd,
+  projection = "write",
+  dispatchTimeoutMs = 5000,
+  pidTimeoutMs,
+  bridgeTimeoutMs,
+  accessControlSock,
+  _deps = {},
+} = {}) {
+  if (!payload) throw new Error("payload is required");
+  if (!payload.short) throw new Error("payload.short is required");
+  const resolvedControlSock = controlSock || paths?.controlSock;
+  if (!resolvedControlSock) throw new Error("controlSock is required");
+
+  const sendControl =
+    _deps.sendClaudeControlRequest || sendClaudeControlRequest;
+  const waitForPid = _deps.waitForDaemonJobPid || waitForDaemonJobPid;
+  const resolveBridgeSessionId =
+    _deps.resolveDaemonBridgeSessionId || resolveDaemonBridgeSessionId;
+  const buildProjection =
+    _deps.buildClaudeSessionProjection || buildClaudeSessionProjection;
+  const writeProjection =
+    _deps.writeClaudeSessionProjection || writeClaudeSessionProjection;
+  const readProcStart = _deps.getProcStart || getProcStart;
+
+  const short = payload.short;
+  const sessionsDir =
+    paths?.sessionsDir ||
+    (paths?.configDir ? path.join(paths.configDir, "sessions") : "");
+
+  // native-bridge 는 control.sock 존재를 미리 점검한다 (없으면 fast-fail).
+  if (accessControlSock) await accessControlSock(resolvedControlSock);
+
+  const dispatch = await sendControl(
+    resolvedControlSock,
+    {
+      proto: 1,
+      op: "dispatch",
+      d: payload,
+      timeoutMs: dispatchTimeoutMs,
+    },
+    { timeoutMs: dispatchTimeoutMs },
+  );
+  if (dispatch?.ok !== true) {
+    throw new Error(`Claude daemon dispatch failed for ${name || short}`);
+  }
+
+  const pidOpts =
+    pidTimeoutMs === undefined ? undefined : { timeoutMs: pidTimeoutMs };
+  const job = await waitForPid(resolvedControlSock, short, pidOpts);
+  const pid = job.pid;
+  const bridgeSessionId = await resolveBridgeSessionId({
+    daemonPaths: paths,
+    short,
+    job,
+    ...(bridgeTimeoutMs === undefined ? {} : { timeoutMs: bridgeTimeoutMs }),
+  });
+
+  let sessionProjectionPath = "";
+  if (projection !== "skip") {
+    const projectionRecord = buildProjection({
+      pid,
+      procStart: readProcStart(pid),
+      sessionId: payload.sessionId,
+      short,
+      cwd,
+      name,
+      agent,
+      startedAt: job.startedAt || Date.now(),
+      updatedAt: Date.now(),
+      bridgeSessionId,
+    });
+    sessionProjectionPath = await writeProjection(
+      sessionsDir,
+      projectionRecord,
+    );
+  }
+
+  return {
+    ok: true,
+    short,
+    sessionId: payload.sessionId,
+    job,
+    pid,
+    bridgeSessionId,
+    sessionProjectionPath,
+    controlSock: resolvedControlSock,
+    paths,
+  };
+}
+
+/**
+ * dispatchClaudeDaemonJob 의 대칭 정리 경로.
+ * removeProjection + killDaemonJob (+ optional removeClaudeJobState) 를
+ * 모두 시도하며, 각 스텝 오류는 기존 close()/cleanupDaemonDispatches 와
+ * 동일하게 .catch 로 삼킨다.
+ */
+export async function teardownClaudeDaemonJob({
+  controlSock,
+  paths,
+  short,
+  sessionProjectionPath,
+  sessionId,
+  jobsDir,
+  removeJobState = false,
+  _deps = {},
+} = {}) {
+  const removeProjection =
+    _deps.removeClaudeSessionProjection || removeClaudeSessionProjection;
+  const killJob = _deps.killDaemonJob || killDaemonJob;
+  const removeJobStateImpl = _deps.removeClaudeJobState;
+  const resolvedControlSock = controlSock || paths?.controlSock;
+  const resolvedJobsDir =
+    jobsDir ||
+    paths?.jobsDir ||
+    (paths?.configDir ? path.join(paths.configDir, "jobs") : "");
+
+  const steps = [];
+  if (sessionProjectionPath) {
+    steps.push(removeProjection(sessionProjectionPath).catch(() => {}));
+  }
+  if (sessionId && (paths?.controlSock || resolvedControlSock)) {
+    const daemonPaths = paths || { controlSock: resolvedControlSock };
+    steps.push(sendKillBySessionId({ daemonPaths, sessionId }).catch(() => {}));
+  }
+  if (resolvedControlSock && short) {
+    steps.push(killJob(resolvedControlSock, short).catch(() => {}));
+  }
+  if (removeJobState && removeJobStateImpl && resolvedJobsDir && short) {
+    steps.push(removeJobStateImpl(resolvedJobsDir, short).catch(() => {}));
+  }
+  await Promise.all(steps);
+}

package/hub/team/claude-native-bridge.mjs

@@ -1,4 +1,4 @@
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
@@ -6,9 +6,13 @@ import os from "node:os";
 import path from "node:path";
 import {
   buildDaemonExecDispatchPayload,
+  deriveClaudeDaemonPaths,
+  dispatchClaudeDaemonJob,
+  getProcStart,
   killDaemonJob,
   resolveDaemonBridgeSessionId,
   sendClaudeControlRequest,
+  teardownClaudeDaemonJob,
   waitForDaemonJobPid,
 } from "./claude-daemon-control.mjs";
 import {
@@ -18,6 +22,10 @@ import {
 } from "./claude-session-projection.mjs";
 import { createInteractiveTuiTransport } from "./interactive-tui-transport.mjs";
 
+// daemon-control 이 deriveClaudeDaemonPaths / getProcStart 의 단일 owner 다.
+// 기존 native-bridge import 경로 (headless 포함) 호환을 위해 re-export 한다.
+export { deriveClaudeDaemonPaths, getProcStart };
+
 const DEFAULT_ROWS = 40;
 const DEFAULT_COLS = 120;
 const MAX_TRANSCRIPT_BYTES = 64 * 1024;
@@ -30,39 +38,6 @@ export function resolveClaudeConfigDir(env = process.env) {
   return path.join(os.homedir(), ".claude");
 }
 
-export function deriveClaudeDaemonPaths({
-  configDir = resolveClaudeConfigDir(),
-  uid = typeof process.getuid === "function" ? process.getuid() : 0,
-  tmpRoot = "/tmp",
-} = {}) {
-  const resolvedConfigDir = path.resolve(configDir);
-  const hash = crypto
-    .createHash("sha256")
-    .update(resolvedConfigDir)
-    .digest("hex")
-    .slice(0, 8);
-  const daemonDir = path.join(tmpRoot, `cc-daemon-${uid}`, hash);
-  return {
-    configDir: resolvedConfigDir,
-    daemonDir,
-    controlSock: path.join(daemonDir, "control.sock"),
-    rendezvousDir: path.join(daemonDir, "rv"),
-    ptyDir: path.join(daemonDir, "pty"),
-    rosterPath: path.join(resolvedConfigDir, "daemon", "roster.json"),
-    sessionsDir: path.join(resolvedConfigDir, "sessions"),
-    jobsDir: path.join(resolvedConfigDir, "jobs"),
-  };
-}
-
-export function getProcStart(pid = process.pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    throw new Error(`invalid pid: ${pid}`);
-  return execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
-    encoding: "utf8",
-    env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
-  }).trim();
-}
-
 export function buildPtyDataFrame(value) {
   const payload = Buffer.isBuffer(value) ? value : Buffer.from(value, "utf8");
   const frame = Buffer.allocUnsafe(5 + payload.length);
@@ -379,6 +354,8 @@ export async function registerSwarmShard({
   const removeJobStateImpl = _deps.removeClaudeJobState || removeClaudeJobState;
   const killJob = _deps.killDaemonJob || killDaemonJob;
   const accessControlSock = _deps.accessControlSock || fs.access;
+  const dispatchJob = _deps.dispatchClaudeDaemonJob || dispatchClaudeDaemonJob;
+  const teardownJob = _deps.teardownClaudeDaemonJob || teardownClaudeDaemonJob;
 
   const paths = derivePaths({ configDir, tmpRoot });
   const sessionsDir =
@@ -487,44 +464,30 @@ export async function registerSwarmShard({
     name: displayName,
   });
 
-  await accessControlSock(paths.controlSock);
-  const dispatch = await sendControl(
-    paths.controlSock,
-    {
-      proto: 1,
-      op: "dispatch",
-      d: payload,
-      timeoutMs: 1000,
-    },
-    { timeoutMs: 1000 },
-  );
-  if (dispatch?.ok !== true) {
-    throw new Error(
-      `Claude daemon dispatch failed for swarm shard ${shardName}`,
-    );
-  }
-
-  const job = await waitForPid(paths.controlSock, short, { timeoutMs: 1000 });
-  const pid = job.pid;
-  const bridgeSessionId = await resolveBridgeSessionId({
-    daemonPaths: paths,
-    short,
-    job,
-    timeoutMs: 1000,
-  });
-  const projection = buildProjection({
-    pid,
-    procStart: readProcStart(pid),
-    sessionId: payload.sessionId,
-    short,
-    cwd,
-    name: displayName,
+  // native-bridge 는 데몬이 없으면 빠르게 실패해야 하므로 1000ms 로 고정한다
+  // (headless 의 5000ms 와 다르므로 명시 전달).
+  const dispatched = await dispatchJob({
+    paths,
+    controlSock: paths.controlSock,
+    payload,
     agent: cli,
-    startedAt: job.startedAt || Date.now(),
-    updatedAt: Date.now(),
-    bridgeSessionId,
+    name: displayName,
+    cwd,
+    dispatchTimeoutMs: 1000,
+    pidTimeoutMs: 1000,
+    bridgeTimeoutMs: 1000,
+    accessControlSock,
+    _deps: {
+      sendClaudeControlRequest: sendControl,
+      waitForDaemonJobPid: waitForPid,
+      resolveDaemonBridgeSessionId: resolveBridgeSessionId,
+      buildClaudeSessionProjection: buildProjection,
+      writeClaudeSessionProjection: writeProjection,
+      getProcStart: readProcStart,
+    },
   });
-  const sessionProjectionPath = await writeProjection(sessionsDir, projection);
+  const sessionProjectionPath = dispatched.sessionProjectionPath;
+  void sessionsDir;
   let closed = false;
 
   return {
@@ -543,9 +506,18 @@ export async function registerSwarmShard({
     async close() {
       if (closed) return;
       closed = true;
-      await removeProjection(sessionProjectionPath).catch(() => {});
-      await killJob(paths.controlSock, short).catch(() => {});
-      await removeJobStateImpl(jobsDir, short).catch(() => {});
+      await teardownJob({
+        controlSock: paths.controlSock,
+        short,
+        sessionProjectionPath,
+        jobsDir,
+        removeJobState: true,
+        _deps: {
+          removeClaudeSessionProjection: removeProjection,
+          killDaemonJob: killJob,
+          removeClaudeJobState: removeJobStateImpl,
+        },
+      });
     },
   };
 }

package/hub/team/daemon-pty-tmux-bridge.mjs

@@ -0,0 +1,146 @@
+import { pathToFileURL } from "node:url";
+
+import { createInteractiveTuiTransport } from "./interactive-tui-transport.mjs";
+
+const DEFAULT_COLS = 120;
+const DEFAULT_ROWS = 40;
+const SIGNAL_EXIT_CODES = new Map([
+  ["SIGHUP", 129],
+  ["SIGINT", 130],
+  ["SIGTERM", 143],
+]);
+
+export function encodeBridgeConfig(config) {
+  return Buffer.from(JSON.stringify(config), "utf8").toString("base64");
+}
+
+export function parseBridgeConfig(argv = []) {
+  const index = argv.indexOf("--config");
+  if (index < 0 || !argv[index + 1]) {
+    throw new Error("--config <base64-json> is required");
+  }
+  return JSON.parse(Buffer.from(argv[index + 1], "base64").toString("utf8"));
+}
+
+export async function runBridge({
+  config,
+  stdin,
+  stdout,
+  signals,
+  createTransport = createInteractiveTuiTransport,
+} = {}) {
+  if (!config?.sessionName) throw new Error("config.sessionName is required");
+  if (!stdin) throw new Error("stdin is required");
+  if (!stdout) throw new Error("stdout is required");
+  if (!signals) throw new Error("signals is required");
+
+  const transport = createTransport({
+    sessionName: config.sessionName,
+    cwd: config.cwd,
+    launchCmd: config.launchCmd,
+    env: config.env || {},
+    onData: (chunk) => stdout.write(chunk),
+  });
+  let shutdownPromise = null;
+
+  const currentSize = () => ({
+    cols: stdout.columns || config.cols || DEFAULT_COLS,
+    rows: stdout.rows || config.rows || DEFAULT_ROWS,
+  });
+
+  const shutdown = async ({ exitCode, exitProcess = false } = {}) => {
+    if (!shutdownPromise) {
+      shutdownPromise = (async () => {
+        unregister();
+        await transport.stop();
+      })();
+    }
+    await shutdownPromise;
+    if (exitProcess && typeof signals.exit === "function") {
+      signals.exit(exitCode ?? 0);
+    }
+  };
+
+  const writeInput = (chunk) => {
+    void transport.writeInput(chunk).catch(() => {
+      void shutdown({ exitCode: 1, exitProcess: true });
+    });
+  };
+  const resize = () => {
+    void transport.resize(currentSize()).catch(() => {
+      void shutdown({ exitCode: 1, exitProcess: true });
+    });
+  };
+  const stdinEnd = () => {
+    void shutdown({ exitCode: 0, exitProcess: true });
+  };
+  const signalHandlers = new Map(
+    [...SIGNAL_EXIT_CODES].map(([signal, exitCode]) => [
+      signal,
+      () => {
+        void shutdown({ exitCode, exitProcess: true });
+      },
+    ]),
+  );
+  const uncaughtException = () => {
+    void shutdown({ exitCode: 1, exitProcess: true });
+  };
+  const beforeExit = () => {
+    void shutdown();
+  };
+  const exit = () => {
+    void shutdown();
+  };
+
+  function unregister() {
+    stdin.off?.("data", writeInput);
+    stdin.off?.("end", stdinEnd);
+    stdout.off?.("resize", resize);
+    signals.off?.("uncaughtException", uncaughtException);
+    signals.off?.("beforeExit", beforeExit);
+    signals.off?.("exit", exit);
+    for (const [signal, handler] of signalHandlers) {
+      signals.off?.(signal, handler);
+    }
+  }
+
+  stdin.on("data", writeInput);
+  stdin.on("end", stdinEnd);
+  stdout.on?.("resize", resize);
+  signals.on?.("uncaughtException", uncaughtException);
+  signals.on?.("beforeExit", beforeExit);
+  signals.on?.("exit", exit);
+  for (const [signal, handler] of signalHandlers) {
+    signals.on?.(signal, handler);
+  }
+
+  try {
+    await transport.start();
+    await transport.resize(currentSize());
+  } catch (error) {
+    await shutdown().catch(() => {});
+    throw error;
+  }
+
+  return { shutdown };
+}
+
+async function main() {
+  const config = parseBridgeConfig(process.argv.slice(2));
+  await runBridge({
+    config,
+    stdin: process.stdin,
+    stdout: process.stdout,
+    signals: process,
+  });
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  main().catch((error) => {
+    console.error(error?.stack || error?.message || String(error));
+    process.exit(1);
+  });
+}

package/hub/team/headless.mjs

@@ -28,21 +28,12 @@ import { getBackend } from "./backend.mjs";
 import {
   buildDaemonExecDispatchPayload,
   deriveClaudeDaemonPaths as deriveClaudeControlPaths,
+  dispatchClaudeDaemonJob,
   killDaemonJob,
-  resolveDaemonBridgeSessionId,
-  sendClaudeControlRequest,
   sendKillBySessionId,
-  waitForDaemonJobPid,
 } from "./claude-daemon-control.mjs";
-import {
-  getProcStart,
-  startClaudeNativeBridge,
-} from "./claude-native-bridge.mjs";
-import {
-  buildClaudeSessionProjection,
-  removeClaudeSessionProjection,
-  writeClaudeSessionProjection,
-} from "./claude-session-projection.mjs";
+import { startClaudeNativeBridge } from "./claude-native-bridge.mjs";
+import { removeClaudeSessionProjection } from "./claude-session-projection.mjs";
 import { resolveDashboardLayout } from "./dashboard-layout.mjs";
 import {
   formatHandoffForLead,
@@ -1016,40 +1007,30 @@ async function dispatchDaemonBatch(sessionName, assignments, opts = {}) {
         name,
       });
       record.sessionId = payload.sessionId;
-      const dispatch = await sendClaudeControlRequest(paths.controlSock, {
-        proto: 1,
-        op: "dispatch",
-        d: payload,
-        timeoutMs: 5000,
-      });
-      if (dispatch?.ok !== true) {
+      // 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}`,
+          `[headless] Claude daemon dispatch failed for ${paneName}: ${
+            error?.message || error
+          }`,
         );
-      }
-
-      const job = await waitForDaemonJobPid(paths.controlSock, short);
-      const bridgeSessionId = await resolveDaemonBridgeSessionId({
-        daemonPaths: paths,
-        short,
-        job,
       });
-      const projection = buildClaudeSessionProjection({
-        pid: job.pid,
-        procStart: getProcStart(job.pid),
-        sessionId: payload.sessionId,
-        short,
-        cwd: assignment.cwd || assignment.workdir || process.cwd(),
-        name,
-        agent: resolvedCli || "codex",
-        startedAt: job.startedAt || Date.now(),
-        updatedAt: Date.now(),
-        bridgeSessionId,
+      Object.assign(record, {
+        sessionId: dispatched.sessionId,
+        sessionProjectionPath: dispatched.sessionProjectionPath,
       });
-      record.sessionProjectionPath = await writeClaudeSessionProjection(
-        paths.sessionsDir,
-        projection,
-      );
       await registerHeadlessWorker(sessionName, i, resolvedCli);
       registerHeadlessSynapseWorker(workerId, assignment.prompt);
       if (safeProgress) {

package/hub/team/interactive-native-launcher.mjs

@@ -1,27 +1,17 @@
 import crypto from "node:crypto";
-import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 
 import {
-  buildNativeWorkerRosterEntry,
+  buildDaemonExecDispatchPayload,
   deriveClaudeDaemonPaths,
-  mergeRosterWorkers,
-  removeRosterWorkers,
-} from "./claude-native-bridge.mjs";
-import { startInteractiveNativeWorker } from "./interactive-native-worker.mjs";
+  dispatchClaudeDaemonJob,
+  teardownClaudeDaemonJob,
+} from "./claude-daemon-control.mjs";
+import { encodeBridgeConfig } from "./daemon-pty-tmux-bridge.mjs";
 
-function buildWorkerSocketPaths({ configDir, sessionName, pid, short }) {
-  const hash = crypto
-    .createHash("sha256")
-    .update(`${configDir || ""}:${sessionName}:${pid}:${crypto.randomUUID()}`)
-    .digest("hex")
-    .slice(0, 10);
-  const socketRoot = path.join(os.tmpdir(), `tfx-in-${hash}`);
-  return {
-    rvSock: path.join(socketRoot, `${short}.rv.sock`),
-    ptySock: path.join(socketRoot, `${short}.pty.sock`),
-  };
-}
+const DEFAULT_COLS = 120;
+const DEFAULT_ROWS = 40;
 
 export async function launchAdoptedInteractiveWorker({
   cwd = process.cwd(),
@@ -31,76 +21,99 @@ export async function launchAdoptedInteractiveWorker({
   role = "interactive",
   configDir,
   pid = process.pid,
+  env = {},
+  cols = DEFAULT_COLS,
+  rows = DEFAULT_ROWS,
   _deps = {},
 } = {}) {
-  const startWorker =
-    _deps.startInteractiveNativeWorker || startInteractiveNativeWorker;
-  const buildRosterEntry =
-    _deps.buildNativeWorkerRosterEntry || buildNativeWorkerRosterEntry;
-  const mergeWorkers = _deps.mergeRosterWorkers || mergeRosterWorkers;
   const derivePaths = _deps.deriveClaudeDaemonPaths || deriveClaudeDaemonPaths;
+  const encodeConfig = _deps.encodeBridgeConfig || encodeBridgeConfig;
+  const buildPayload =
+    _deps.buildDaemonExecDispatchPayload || buildDaemonExecDispatchPayload;
+  const dispatchJob = _deps.dispatchClaudeDaemonJob || dispatchClaudeDaemonJob;
+  const teardownJob = _deps.teardownClaudeDaemonJob || teardownClaudeDaemonJob;
 
   const resolvedCwd = path.resolve(cwd);
-  const effectiveSessionName =
-    sessionName || `tfx-${cli}-${role}-${process.pid}`;
+  const effectiveSessionName = sessionName || `tfx-${cli}-${role}-${pid}`;
   const paths = derivePaths({ configDir });
-  const short = crypto.randomUUID().replaceAll("-", "").slice(0, 8);
-  const { rvSock, ptySock } = buildWorkerSocketPaths({
-    configDir,
+  const short = crypto.randomBytes(4).toString("hex");
+  const displayName = `Triflux ${cli} ${role}`;
+  const bridgePath = fileURLToPath(
+    new URL("./daemon-pty-tmux-bridge.mjs", import.meta.url),
+  );
+  const bridgeConfig = encodeConfig({
     sessionName: effectiveSessionName,
-    pid,
+    launchCmd,
+    cwd: resolvedCwd,
+    env,
+    cols,
+    rows,
+  });
+  const command = `${shellQuote(process.execPath)} ${shellQuote(
+    bridgePath,
+  )} --config ${bridgeConfig}`;
+  const payload = buildPayload({
     short,
+    cwd: resolvedCwd,
+    command,
+    name: displayName,
+    cols,
+    rows,
   });
-  const displayName = `Triflux ${cli} ${role}`;
-
-  let worker;
-  let closed = false;
-  let closePromise = null;
-
+  let dispatched;
   try {
-    worker = await startWorker({
-      short,
-      rvSock,
-      ptySock,
-      sessionName: effectiveSessionName,
-      cwd: resolvedCwd,
-      launchCmd,
-      pid,
-    });
-    const workerShort = worker.short || short;
-    const workerPid = worker.pid || pid;
-    const entry = buildRosterEntry({
-      short: workerShort,
-      pid: workerPid,
-      cwd: resolvedCwd,
-      rendezvousSock: worker.rvSock,
-      ptySock: worker.ptySock,
+    dispatched = await dispatchJob({
+      paths,
+      controlSock: paths.controlSock,
+      payload,
+      agent: cli,
       name: displayName,
-      prompt: displayName,
+      cwd: resolvedCwd,
+      dispatchTimeoutMs: 5000,
     });
-    await mergeWorkers(paths.rosterPath, { [workerShort]: entry });
-
-    return {
-      short: workerShort,
-      displayName,
-      rosterPath: paths.rosterPath,
-      close() {
-        if (!closePromise) {
-          closePromise = (async () => {
-            if (closed) return;
-            closed = true;
-            try {
-              await worker.close();
-            } finally {
-              await removeRosterWorkers(paths.rosterPath, [workerShort]);
-            }
-          })();
-        }
-        return closePromise;
-      },
-    };
   } catch (error) {
-    if (worker) await worker.close().catch(() => {});
+    // dispatch may have started a daemon job (pid assigned) before a later
+    // step (bridge-session resolve / projection write) threw. Tear down by
+    // short + sessionId so a failed launch never leaks a running pty/tmux job.
+    await teardownJob({
+      controlSock: paths.controlSock,
+      paths,
+      short,
+      sessionId: payload.sessionId,
+    }).catch(() => {});
     throw error;
   }
+
+  let closed = false;
+  let closePromise = null;
+
+  return {
+    short,
+    displayName,
+    sessionId: dispatched.sessionId,
+    pid: dispatched.pid,
+    bridgeSessionId: dispatched.bridgeSessionId,
+    sessionProjectionPath: dispatched.sessionProjectionPath,
+    controlSock: paths.controlSock,
+    close() {
+      if (!closePromise) {
+        closePromise = (async () => {
+          if (closed) return;
+          closed = true;
+          await teardownJob({
+            controlSock: paths.controlSock,
+            paths,
+            short,
+            sessionProjectionPath: dispatched.sessionProjectionPath,
+            sessionId: dispatched.sessionId,
+          });
+        })();
+      }
+      return closePromise;
+    },
+  };
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
 }

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

@@ -42,10 +42,10 @@ const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
 
 // Escalation chain (2026-05-27 정책):
 //   1. codex gpt-5.5   — 코드/추론/비용에서 mini/5.3-codex 중간 단계를 대체
-//   2. claude opus-4-7 — 최종 수단
+//   2. claude opus-4-8 — 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({ cli: "codex", model: "gpt-5.5" }),
-  Object.freeze({ cli: "claude", model: "opus-4-7" }),
+  Object.freeze({ cli: "claude", model: "opus-4-8" }),
 ]);
 
 const STUCK_THRESHOLD = 3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.27.0",
+  "version": "10.28.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/mcp-gateway-health-check.mjs

@@ -14,6 +14,7 @@
 // 침묵한다 (false-positive 방지).
 
 import { readFileSync, statSync } from "node:fs";
+import { createConnection } from "node:net";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -33,6 +34,27 @@ const START_RE = /^\[START\]\s+(\S+)\s+on\s+:(\d+)$/;
 const SKIP_RUNNING_RE = /^\[SKIP\]\s+(\S+)\s+already running on\s+:(\d+)$/;
 const SKIP_DISABLED_RE = /^\[SKIP\]\s+(\S+)\s+—\s+manifest에서 비활성$/;
 
+function probePortListening(
+  port,
+  { host = "127.0.0.1", timeoutMs = 800 } = {},
+) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ host, port });
+    let settled = false;
+
+    function finish(value) {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(value);
+    }
+
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.setTimeout(timeoutMs, () => finish(false));
+  });
+}
+
 export function checkMcpGatewayHealth({
   fs = { readFileSync, statSync },
   logPath = DEFAULT_LOG_PATH,
@@ -130,6 +152,40 @@ export function checkMcpGatewayHealth({
   };
 }
 
+export async function checkMcpGatewayHealthLive({
+  probePort = probePortListening,
+  ...options
+} = {}) {
+  const result = checkMcpGatewayHealth(options);
+  if (!result.available || result.started.length === 0) {
+    return {
+      ...result,
+      live: [],
+    };
+  }
+
+  const live = [];
+  const findings = [...result.findings];
+  for (const entry of result.started) {
+    const listening = await probePort(entry.port);
+    live.push({ ...entry, listening });
+    if (!listening) {
+      findings.push({
+        server: entry.server,
+        reason: "port-down",
+        detail: `expected listener on :${entry.port}`,
+        port: entry.port,
+      });
+    }
+  }
+
+  return {
+    ...result,
+    findings,
+    live,
+  };
+}
+
 export function summarizeMcpGatewayHealth(result) {
   if (!result?.available) {
     return {
@@ -152,6 +208,15 @@ export function summarizeMcpGatewayHealth(result) {
       fix: "secrets 를 ~/.config/triflux/secrets.env 에 추가하고 `launchctl kickstart -k gui/$(id -u)/com.tellang.mcp-gateway` (macOS) 또는 `systemctl --user restart mcp-gateway` (linux)",
     };
   }
+  const portDown = result.findings.filter((f) => f.reason === "port-down");
+  if (portDown.length > 0) {
+    const list = portDown.map((f) => `${f.server} (:${f.port})`).join(", ");
+    return {
+      level: "warn",
+      message: `${portDown.length}개 MCP gateway port down: ${list}`,
+      fix: "gateway 를 재기동하세요: `node scripts/mcp-gateway-start.mjs` 또는 macOS `launchctl kickstart -k gui/$(id -u)/com.tellang.mcp-gateway`",
+    };
+  }
   return {
     level: "warn",
     message: `${result.findings.length}개 gateway 이슈`,

package/scripts/lib/mcp-guard-engine.mjs

@@ -22,7 +22,12 @@ const PROJECT_ROOT = fileURLToPath(new URL("../../", import.meta.url));
 const DEFAULT_REGISTRY_PATH = join(PROJECT_ROOT, "config", "mcp-registry.json");
 const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
 const DEFAULT_HUB_PATH = "/mcp";
-const SERVER_POLICIES = new Set(["hosted", "gateway-sse", "stdio"]);
+const SERVER_POLICIES = new Set([
+  "hosted",
+  "gateway-sse",
+  "gateway-http",
+  "stdio",
+]);
 const GATEWAY_PORTS = Object.freeze({
   context7: 8100,
   "brave-search": 8101,
@@ -792,6 +797,23 @@ function gatewaySseUrl(name, serverConfig = {}) {
   return `http://127.0.0.1:${port}/sse`;
 }
 
+function gatewayHttpUrl(name, serverConfig = {}) {
+  if (typeof serverConfig.url === "string" && serverConfig.url.trim()) {
+    return normalizeUrl(serverConfig.url);
+  }
+  const port =
+    Number(serverConfig.gateway_port || serverConfig.port || 0) ||
+    GATEWAY_PORTS[name];
+  if (!Number.isFinite(port) || port <= 0) return "";
+  const path =
+    typeof serverConfig.gateway_path === "string" &&
+    serverConfig.gateway_path.trim()
+      ? serverConfig.gateway_path.trim()
+      : "/mcp";
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `http://127.0.0.1:${port}${normalizedPath}`;
+}
+
 function syncDenylistEntries(policy = {}) {
   if (!Array.isArray(policy?.sync_denylist)) return new Set();
   return new Set(
@@ -836,9 +858,11 @@ export function buildDesiredServerRecord(name, serverConfig, filePath) {
   const url =
     policy === "gateway-sse"
       ? gatewaySseUrl(name, serverConfig)
-      : serverConfig?.transport === "hub-url"
-        ? resolveHubUrl()
-        : normalizeUrl(serverConfig?.url || "");
+      : policy === "gateway-http"
+        ? gatewayHttpUrl(name, serverConfig)
+        : serverConfig?.transport === "hub-url"
+          ? resolveHubUrl()
+          : normalizeUrl(serverConfig?.url || "");
   const basenameValue = pathBasename(filePath);
   const resolvedHeaders = resolveHeaderDescriptors(
     name,
@@ -849,6 +873,26 @@ export function buildDesiredServerRecord(name, serverConfig, filePath) {
     ? { headers: resolvedHeaders.headers }
     : {};
 
+  if (policy === "gateway-http") {
+    if (isCodexConfig(filePath)) {
+      return {
+        name,
+        config: { url },
+        headerDescriptors: {},
+        codex: {},
+        warnings: [],
+      };
+    }
+
+    return {
+      name,
+      config: { type: "http", url },
+      headerDescriptors: {},
+      codex: {},
+      warnings: [],
+    };
+  }
+
   if (policy === "gateway-sse") {
     if (isCodexConfig(filePath)) {
       return {
@@ -1237,7 +1281,7 @@ export function validateRegistry(registry) {
         !SERVER_POLICIES.has(server.policy)
       ) {
         errors.push(
-          `registry.servers.${name}.policy must be hosted, gateway-sse, or stdio`,
+          `registry.servers.${name}.policy must be hosted, gateway-sse, gateway-http, or stdio`,
         );
       }
       const transport = server.transport || registry.defaults?.transport;
@@ -1252,7 +1296,7 @@ export function validateRegistry(registry) {
       ) {
         errors.push(`registry.servers.${name}.url must be a non-empty string`);
       }
-      if (policy === "gateway-sse") {
+      if (policy === "gateway-sse" || policy === "gateway-http") {
         const port = Number(server.gateway_port || server.port || 0);
         const hasGatewayUrl =
           typeof server.url === "string" && server.url.trim().length > 0;
@@ -1261,7 +1305,7 @@ export function validateRegistry(registry) {
           (!Number.isInteger(port) || port <= 0 || port > 65535)
         ) {
           errors.push(
-            `registry.servers.${name}.gateway_port must be a valid TCP port for gateway-sse`,
+            `registry.servers.${name}.gateway_port must be a valid TCP port for ${policy}`,
           );
         }
       }
@@ -1913,7 +1957,7 @@ export function addRegistryServer(name, url, options = {}) {
     (transport === "stdio"
       ? "stdio"
       : options.gateway_port || options.port
-        ? "gateway-sse"
+        ? "gateway-http"
         : "hosted");
 
   registry.servers[trimmedName] = {