@triflux/remote 10.53.0 → 10.55.0

package/hub/team/remote-session.mjs

@@ -3,8 +3,10 @@
 
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import {
   basename,
+  isAbsolute,
   join,
   posix as posixPath,
   win32 as win32Path,
@@ -21,12 +23,25 @@ export function shellQuote(value) {
   return `'${String(value).replace(/'/g, "'\\''")}'`;
 }
 
+// PowerShell 은 ‘ ’ ‚ ‛ 도 작은따옴표로 읽는다. 따옴표 문자를 모두 겹쳐 써야 인용이 안 끝난다.
 export function escapePwshSingleQuoted(value) {
-  return String(value).replace(/'/g, "''");
+  return String(value).replace(/['\u2018\u2019\u201A\u201B]/g, "$&$&");
 }
 
+// 큰따옴표 안에서는 $ 가 확장되고 “ ” „ 도 따옴표로 읽힌다. 모두 백틱으로 막는다.
 export function escapePwshDoubleQuoted(value) {
-  return String(value).replace(/`/g, "``").replace(/"/g, '`"');
+  return String(value).replace(/[`$"\u201C\u201D\u201E]/g, "`$&");
+}
+
+// ssh 는 원격 명령 인자를 공백으로 이어 원격 셸에 다시 넘긴다. 스크립트는 인용한 문자열 하나로 만든다.
+export function posixRemoteCommand(script) {
+  return `sh -lc ${shellQuote(script)}`;
+}
+
+// pwsh 스크립트는 base64 로 넘겨 원격 기본 셸(cmd 나 pwsh)이 따옴표와 파이프를 해석하지 않게 한다.
+export function pwshRemoteCommand(script) {
+  const encoded = Buffer.from(script, "utf16le").toString("base64");
+  return `pwsh -NoProfile -EncodedCommand ${encoded}`;
 }
 
 function normalizeCommandPath(value) {
@@ -146,6 +161,24 @@ function probeRemoteEnvViaPosix(host) {
 
 // ── Cache ───────────────────────────────────────────────────────
 
+// cwd 의 .omc 에 두면 실행한 저장소마다 원격 홈 경로가 흩어져 남는다. 사용자 상태 경로에 둔다.
+export function tfxStateDir(env = process.env) {
+  // XDG 명세대로 상대 경로는 무시한다. 받아들이면 캐시가 다시 cwd 아래로 간다.
+  const xdgState = isAbsolute(env.XDG_STATE_HOME || "")
+    ? env.XDG_STATE_HOME
+    : "";
+  const stateRoot =
+    xdgState ||
+    (process.platform === "win32"
+      ? env.LOCALAPPDATA || join(homedir(), "AppData", "Local")
+      : join(homedir(), ".local", "state"));
+  return join(stateRoot, "triflux");
+}
+
+export function remoteEnvCacheDir(env = process.env) {
+  return join(tfxStateDir(env), "remote-env");
+}
+
 function getEnvCachePath(host, cacheDir) {
   return join(cacheDir, `${host}.json`);
 }
@@ -161,13 +194,11 @@ function readEnvCache(host, cacheDir) {
   }
 }
 
-function isEnvCacheFresh(entry) {
-  return Boolean(
-    entry &&
-      typeof entry.cachedAt === "number" &&
-      entry.env &&
-      Date.now() - entry.cachedAt < REMOTE_ENV_TTL_MS,
-  );
+export function isEnvCacheFresh(entry, now = Date.now()) {
+  if (!entry?.env || typeof entry.cachedAt !== "number") return false;
+  const age = now - entry.cachedAt;
+  // 미래 시각을 허용하면 그 캐시가 영원히 신선하게 남는다.
+  return age >= 0 && age < REMOTE_ENV_TTL_MS;
 }
 
 function writeEnvCache(host, env, cacheDir) {
@@ -186,13 +217,13 @@ function writeEnvCache(host, env, cacheDir) {
  * @param {string} host — SSH host
  * @param {object} [opts]
  * @param {boolean} [opts.force=false] — bypass cache
- * @param {string} [opts.cacheDir] — cache directory (default: .omc/state/remote-env)
+ * @param {string} [opts.cacheDir]: cache directory (default: remoteEnvCacheDir())
  * @returns {Readonly<RemoteEnv>}
  */
 export function probeRemoteEnv(host, opts = {}) {
   validateHost(host);
   const force = opts.force === true;
-  const cacheDir = opts.cacheDir || join(".omc", "state", "remote-env");
+  const cacheDir = opts.cacheDir || remoteEnvCacheDir();
 
   if (!force) {
     const cached = readEnvCache(host, cacheDir);
@@ -266,26 +297,13 @@ export function resolveRemoteStageDir(env, stageId) {
  * @param {string} remoteStageDir
  */
 export function ensureRemoteStageDir(host, env, remoteStageDir) {
-  if (env.os === "win32") {
-    const safePath = escapePwshSingleQuoted(remoteStageDir);
-    execFileSync(
-      "ssh",
-      [
-        host,
-        "pwsh",
-        "-NoProfile",
-        "-Command",
-        `New-Item -ItemType Directory -Path '${safePath}' -Force | Out-Null`,
-      ],
-      { timeout: 10000, stdio: "pipe" },
-    );
-    return;
-  }
-  execFileSync(
-    "ssh",
-    [host, "sh", "-lc", `mkdir -p ${shellQuote(remoteStageDir)}`],
-    { timeout: 10000, stdio: "pipe" },
-  );
+  const command =
+    env.os === "win32"
+      ? pwshRemoteCommand(
+          `New-Item -ItemType Directory -Path '${escapePwshSingleQuoted(remoteStageDir)}' -Force | Out-Null`,
+        )
+      : posixRemoteCommand(`mkdir -p ${shellQuote(remoteStageDir)}`);
+  execFileSync("ssh", [host, command], { timeout: 10000, stdio: "pipe" });
 }
 
 /**
@@ -342,29 +360,21 @@ export function stageRemotePromptFiles(host, env, transferCandidates, stageId) {
  * @returns {string} stdout
  */
 export function remoteGit(host, env, gitArgs, cwd) {
-  const gitCmd = ["git", ...gitArgs].map((a) => shellQuote(a)).join(" ");
-
-  if (env.os === "win32") {
-    const cdPath = escapePwshSingleQuoted(cwd);
-    const command = `Set-Location '${cdPath}'; ${gitCmd}`;
-    return execFileSync(
-      "ssh",
-      [host, "pwsh", "-NoProfile", "-Command", command],
-      {
-        encoding: "utf8",
-        timeout: 30_000,
-        stdio: ["pipe", "pipe", "pipe"],
-      },
-    ).trim();
-  }
-
-  return execFileSync(
-    "ssh",
-    [host, "sh", "-lc", `cd ${shellQuote(cwd)} && ${gitCmd}`],
-    {
-      encoding: "utf8",
-      timeout: 30_000,
-      stdio: ["pipe", "pipe", "pipe"],
-    },
-  ).trim();
+  const command =
+    env.os === "win32"
+      ? pwshRemoteCommand(
+          [
+            `Set-Location '${escapePwshSingleQuoted(cwd)}';`,
+            "git",
+            ...gitArgs.map((arg) => `'${escapePwshSingleQuoted(arg)}'`),
+          ].join(" "),
+        )
+      : posixRemoteCommand(
+          `cd ${shellQuote(cwd)} && ${["git", ...gitArgs].map(shellQuote).join(" ")}`,
+        );
+  return execFileSync("ssh", [host, command], {
+    encoding: "utf8",
+    timeout: 30_000,
+    stdio: ["pipe", "pipe", "pipe"],
+  }).trim();
 }

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

@@ -1,6 +1,6 @@
 // hub/team/retry-state-machine.mjs
 // Phase 3 Step A — true ralph / auto-escalate retry state machine.
-// 설계 문서: .triflux/plans/phase3-lead-codex-ralph-escalate.md
+// 설계: 구현 커밋 565a2bad 메시지, 규칙은 .claude/rules/tfx-escalation-chain.md
 //
 // Modes:
 //   bounded       — --retry 1 (기본): maxIterations 도달 시 BUDGET_EXCEEDED.

package/hub/team/session.mjs

@@ -1,5 +1,5 @@
 // tmux/psmux 세션 생명주기 관리
-import { execSync, spawnSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { resolveGitBashExecutable } from "@triflux/core/hub/lib/bash-path.mjs";
 import { getEnvironment } from "@triflux/core/hub/lib/env-detect.mjs";
 import {
@@ -14,6 +14,7 @@ import {
   listPsmuxSessions,
   psmuxExec,
   psmuxSessionExists,
+  tokenizeCommand,
 } from "./psmux.mjs";
 
 /** Windows Terminal 실행 파일 존재 여부 */
@@ -29,7 +30,11 @@ export function hasWindowsTerminalSession() {
 /** tmux 실행 가능 여부 확인 */
 function hasTmux() {
   try {
-    execSync("tmux -V", { stdio: "ignore", timeout: 3000, windowsHide: true });
+    execFileSync("tmux", ["-V"], {
+      stdio: "ignore",
+      timeout: 3000,
+      windowsHide: true,
+    });
     return true;
   } catch {
     return false;
@@ -100,10 +105,16 @@ export function detectMultiplexer() {
   return _cachedMux;
 }
 
+function bashArg(value) {
+  return /^[\w@%+=:,./-]+$/u.test(value)
+    ? value
+    : `'${value.replace(/'/g, "'\\''")}'`;
+}
+
 /**
  * tmux/psmux 커맨드 실행
- * @param {string} args — tmux 서브커맨드 + 인자
- * @param {object} opts — execSync 옵션
+ * @param {string[]|string} args: tmux 서브커맨드 + 인자. 문자열은 psmux 와 같은 규칙으로 쪼갠다.
+ * @param {object} opts: execFileSync 옵션
  * @returns {string} stdout
  */
 function tmux(args, opts = {}) {
@@ -120,16 +131,22 @@ function tmux(args, opts = {}) {
   if (mux === "psmux") {
     return psmuxExec(args, opts);
   }
+  // 셸을 거치지 않게 인자 배열로 넘긴다. 세션 이름이나 pane 대상이 셸 문법으로 읽히지 않는다.
+  const argv = Array.isArray(args) ? args.map(String) : tokenizeCommand(args);
   if (mux === "git-bash-tmux") {
     const bash = resolveGitBashExecutable();
     if (!bash) throw new Error("git-bash-tmux 감지 실패");
-    const r = spawnSync(bash, ["-lc", `tmux ${args}`], {
-      encoding: "utf8",
-      timeout: 10000,
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true,
-      ...opts,
-    });
+    const r = spawnSync(
+      bash,
+      ["-lc", ["tmux", ...argv.map(bashArg)].join(" ")],
+      {
+        encoding: "utf8",
+        timeout: 10000,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        ...opts,
+      },
+    );
     if ((r.status ?? 1) !== 0) {
       const e = new Error(r.stderr || "tmux command failed");
       e.status = r.status;
@@ -138,7 +155,7 @@ function tmux(args, opts = {}) {
     return (r.stdout || "").trim();
   }
 
-  const result = execSync(`tmux ${args}`, {
+  const result = execFileSync("tmux", argv, {
     encoding: "utf8",
     timeout: 10000,
     stdio: ["pipe", "pipe", "pipe"],
@@ -150,7 +167,7 @@ function tmux(args, opts = {}) {
 
 /**
  * tmux 명령 직접 실행 (고수준 모듈에서 재사용)
- * @param {string} args
+ * @param {string[]|string} args
  * @param {object} opts
  * @returns {string}
  */
@@ -181,7 +198,7 @@ export function resolveAttachCommand(sessionName, opts = {}) {
     if (!bash) throw new Error("git-bash-tmux 감지 실패");
     return {
       command: bash,
-      args: ["-lc", `tmux attach-session -t ${sessionName}`],
+      args: ["-lc", `tmux attach-session -t ${bashArg(sessionName)}`],
     };
   }
 
@@ -213,17 +230,17 @@ export function createSession(sessionName, opts = {}) {
   }
 
   // 새 세션 생성 (detached)
-  tmux(`new-session -d -s ${sessionName} -x 220 -y 55`);
+  tmux(["new-session", "-d", "-s", sessionName, "-x", "220", "-y", "55"]);
 
   const panes = [`${sessionName}:0.0`];
 
   if (layout === "2x2" && paneCount >= 3) {
     // 3-pane 기본: lead 왼쪽, workers 오른쪽 상/하
     // 4-pane: 좌/우 각각 상/하(균등 2x2)
-    tmux(`split-window -h -t ${sessionName}:0.0`);
-    tmux(`split-window -v -t ${sessionName}:0.1`);
+    tmux(["split-window", "-h", "-t", `${sessionName}:0.0`]);
+    tmux(["split-window", "-v", "-t", `${sessionName}:0.1`]);
     if (paneCount >= 4) {
-      tmux(`split-window -v -t ${sessionName}:0.0`);
+      tmux(["split-window", "-v", "-t", `${sessionName}:0.0`]);
     }
     // pane ID 재수집
     panes.length = 0;
@@ -233,9 +250,9 @@ export function createSession(sessionName, opts = {}) {
   } else if (layout === "1xN") {
     // 세로 분할(좌/우 컬럼 확장)
     for (let i = 1; i < paneCount; i++) {
-      tmux(`split-window -h -t ${sessionName}:0`);
+      tmux(["split-window", "-h", "-t", `${sessionName}:0`]);
     }
-    tmux(`select-layout -t ${sessionName}:0 even-horizontal`);
+    tmux(["select-layout", "-t", `${sessionName}:0`, "even-horizontal"]);
     panes.length = 0;
     for (let i = 0; i < paneCount; i++) {
       panes.push(`${sessionName}:0.${i}`);
@@ -243,9 +260,9 @@ export function createSession(sessionName, opts = {}) {
   } else {
     // Nx1 가로 분할(상/하 스택)
     for (let i = 1; i < paneCount; i++) {
-      tmux(`split-window -v -t ${sessionName}:0`);
+      tmux(["split-window", "-v", "-t", `${sessionName}:0`]);
     }
-    tmux(`select-layout -t ${sessionName}:0 even-vertical`);
+    tmux(["select-layout", "-t", `${sessionName}:0`, "even-vertical"]);
     panes.length = 0;
     for (let i = 0; i < paneCount; i++) {
       panes.push(`${sessionName}:0.${i}`);
@@ -263,10 +280,10 @@ export function createSession(sessionName, opts = {}) {
  */
 export function focusPane(target, opts = {}) {
   const { zoom = false } = opts;
-  tmux(`select-pane -t ${target}`);
+  tmux(["select-pane", "-t", target]);
   if (zoom) {
     try {
-      tmux(`resize-pane -t ${target} -Z`);
+      tmux(["resize-pane", "-t", target, "-Z"]);
     } catch {}
   }
 }
@@ -296,45 +313,46 @@ export function configureTeammateKeybindings(sessionName, opts = {}) {
   // Shift+Up이 터미널/호스트 조합에 따라 전달되지 않는 경우가 있어
   // 좌/우/Shift+Tab 대체 키를 함께 바인딩한다.
   const bindNext = inProcess
-    ? `'select-pane -t :.+ \\; resize-pane -Z'`
-    : `'select-pane -t :.+'`;
+    ? "select-pane -t :.+ \\; resize-pane -Z"
+    : "select-pane -t :.+";
   const bindPrev = inProcess
-    ? `'select-pane -t :.- \\; resize-pane -Z'`
-    : `'select-pane -t :.-'`;
-
-  tmux(
-    `bind-key -T root -n S-Down if-shell -F '${cond}' ${bindNext} 'send-keys S-Down'`,
-  );
-  tmux(
-    `bind-key -T root -n S-Up if-shell -F '${cond}' ${bindPrev} 'send-keys S-Up'`,
-  );
+    ? "select-pane -t :.- \\; resize-pane -Z"
+    : "select-pane -t :.-";
+  const bindIf = (key, onMatch, otherwise) =>
+    tmux([
+      "bind-key",
+      "-T",
+      "root",
+      "-n",
+      key,
+      "if-shell",
+      "-F",
+      cond,
+      onMatch,
+      otherwise,
+    ]);
+
+  bindIf("S-Down", bindNext, "send-keys S-Down");
+  bindIf("S-Up", bindPrev, "send-keys S-Up");
 
   // 대체 키: 일부 환경에서 S-Up이 누락될 때 사용
-  tmux(
-    `bind-key -T root -n S-Right if-shell -F '${cond}' ${bindNext} 'send-keys S-Right'`,
-  );
-  tmux(
-    `bind-key -T root -n S-Left if-shell -F '${cond}' ${bindPrev} 'send-keys S-Left'`,
-  );
-  tmux(
-    `bind-key -T root -n BTab if-shell -F '${cond}' ${bindPrev} 'send-keys BTab'`,
-  );
+  bindIf("S-Right", bindNext, "send-keys S-Right");
+  bindIf("S-Left", bindPrev, "send-keys S-Left");
+  bindIf("BTab", bindPrev, "send-keys BTab");
 
   // 현재 활성 pane 인터럽트
-  tmux(
-    `bind-key -T root -n Escape if-shell -F '${cond}' 'send-keys C-c' 'send-keys Escape'`,
-  );
+  bindIf("Escape", "send-keys C-c", "send-keys Escape");
 
   // 태스크 목록 토글 (tmux 3.2+ popup 우선, 실패 시 안내 메시지)
   if (taskListCommand) {
     const escaped = taskListCommand.replace(/'/g, "'\\''");
     try {
-      tmux(
-        `bind-key -T root -n C-t if-shell -F '${cond}' "display-popup -E '${escaped}'" "send-keys C-t"`,
-      );
+      bindIf("C-t", `display-popup -E '${escaped}'`, "send-keys C-t");
     } catch {
-      tmux(
-        `bind-key -T root -n C-t if-shell -F '${cond}' 'display-message "tfx multi tasks 명령으로 태스크 확인"' 'send-keys C-t'`,
+      bindIf(
+        "C-t",
+        'display-message "tfx multi tasks 명령으로 태스크 확인"',
+        "send-keys C-t",
       );
     }
   }
@@ -432,7 +450,8 @@ export function sessionExists(sessionName) {
   }
 
   try {
-    tmux(`has-session -t ${sessionName}`, { stdio: "ignore" });
+    // '=' 가 없으면 tmux 가 접두사로 다른 세션을 잡는다(#548).
+    tmux(["has-session", "-t", `=${sessionName}`], { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -450,7 +469,7 @@ export function killSession(sessionName) {
   }
 
   try {
-    tmux(`kill-session -t ${sessionName}`, { stdio: "ignore" });
+    tmux(["kill-session", "-t", `=${sessionName}`], { stdio: "ignore" });
   } catch {
     // 이미 종료된 세션 — 무시
   }
@@ -466,7 +485,7 @@ export function listSessions() {
   }
 
   try {
-    const output = tmux('list-sessions -F "#{session_name}"');
+    const output = tmux(["list-sessions", "-F", "#{session_name}"]);
     return output.split("\n").filter((s) => s.startsWith("tfx-multi-"));
   } catch {
     return [];
@@ -484,9 +503,11 @@ export function getSessionAttachedCount(sessionName) {
   }
 
   try {
-    const output = tmux(
-      'list-sessions -F "#{session_name} #{session_attached}"',
-    );
+    const output = tmux([
+      "list-sessions",
+      "-F",
+      "#{session_name} #{session_attached}",
+    ]);
     const line = output
       .split("\n")
       .find((l) => l.startsWith(`${sessionName} `));
@@ -511,7 +532,7 @@ export function capturePaneOutput(target, lines = 5) {
 
   try {
     // -l 플래그는 일부 tmux 빌드(MSYS2)에서 미지원 → 전체 캡처 후 JS에서 절삭
-    const full = tmux(`capture-pane -t ${target} -p`);
+    const full = tmux(["capture-pane", "-t", target, "-p"]);
     const nonEmpty = full.split("\n").filter((l) => l.trim() !== "");
     return nonEmpty.slice(-lines).join("\n");
   } catch {

package/hub/team/terminal-opener.mjs

@@ -1,4 +1,4 @@
-import { exec as defaultExec, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { platform as osPlatform } from "node:os";
 import { psmuxExec as defaultPsmuxExec } from "./psmux.mjs";
 import { tmuxExec as defaultTmuxExec, detectMultiplexer } from "./session.mjs";
@@ -17,8 +17,9 @@ export function shellQuote(value) {
   return `'${String(value).replace(/'/g, "'\\''")}'`;
 }
 
+// PowerShell 은 ‘ ’ ‚ ‛ 도 작은따옴표로 읽는다. 따옴표 문자를 모두 겹쳐 써야 인용이 안 끝난다.
 export function powershellSingleQuote(value) {
-  return `'${String(value).replace(/'/g, "''")}'`;
+  return `'${String(value).replace(/['\u2018\u2019\u201A\u201B]/g, "$&$&")}'`;
 }
 
 export function buildCommandString({ cwd, command }) {
@@ -48,14 +49,6 @@ function createTabSpec(spec, title) {
   };
 }
 
-function execOpenTerminal(execFn) {
-  return new Promise((resolve) => {
-    execFn("open -a Terminal", { timeout: 5000 }, (error) => {
-      resolve(!error);
-    });
-  });
-}
-
 function isTmuxLikeMux(mux) {
   return TMUX_LIKE_MUXES.has(mux);
 }
@@ -125,7 +118,6 @@ export function createTerminalOpener(deps = {}) {
   const platform = resolvePlatform(deps);
   const tmuxExec = deps.tmuxExec || defaultTmuxExec;
   const psmuxExec = deps.psmuxExec || defaultPsmuxExec;
-  const exec = deps.exec || defaultExec;
   const createWtManager = deps.createWtManager || defaultCreateWtManager;
 
   async function openCommand(spec = {}) {
@@ -162,10 +154,8 @@ export function createTerminalOpener(deps = {}) {
       }
     }
 
-    if (platform === "darwin") {
-      return execOpenTerminal(exec);
-    }
-
+    // 멀티플렉서가 없으면 명령을 실을 경로가 없다. 빈 Terminal 창을 띄우고
+    // 성공이라 하지 않고 실패를 돌려준다(macOS 포함).
     return false;
   }
 
@@ -238,10 +228,6 @@ export function createTerminalOpener(deps = {}) {
   return { openCommand, openSession, focusPane };
 }
 
-export function openSessionTarget(sessionName, opts = {}) {
-  return createTerminalOpener(opts._deps).openSession(sessionName, opts);
-}
-
 export function focusSessionPane(sessionName, workerNumber, opts = {}) {
   return createTerminalOpener(opts._deps).focusPane(sessionName, workerNumber);
 }

package/hub/team/tui-viewer.mjs

@@ -6,9 +6,9 @@
 
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { formatPsmuxInstallGuidance } from "../../scripts/lib/psmux-info.mjs";
+import { privateTmpDir } from "@triflux/core/hub/lib/private-tmp.mjs";
 import { openHeadlessDashboardTarget } from "./dashboard-open.mjs";
 import { processHandoff } from "./handoff.mjs";
 import { getMultiplexerType } from "./psmux.mjs";
@@ -23,7 +23,7 @@ function argVal(flag) {
 }
 
 const SESSION = argVal("--session");
-const RESULT_DIR = argVal("--result-dir") ?? join(tmpdir(), "tfx-headless");
+const RESULT_DIR = argVal("--result-dir") ?? privateTmpDir("tfx-headless");
 const LAYOUT = argVal("--layout") ?? "single";
 const LEAD_PANE = argVal("--lead-pane");
 const MUX_BIN = getMultiplexerType();

package/hub/team/tui.mjs

@@ -290,8 +290,6 @@ const SUMMARY_KEYS = [
   "partial_output",
 ];
 
-// 텍스트/상태/색상 유틸은 tui-core.mjs에서 import (위 참조)
-
 // ── MOCHA RGB (gradual fade 보간용) ──
 const MOCHA_RGB = {
   ok: { r: 166, g: 227, b: 161 },
@@ -380,8 +378,6 @@ function dedupeRole(role, name, cli) {
   return r;
 }
 
-// wrapLine, wrapTextAll → tui-core.mjs에서 import
-
 // ── virtual row buffer ────────────────────────────────────────────────────
 class RowBuffer {
   constructor() {
@@ -415,8 +411,6 @@ class RowBuffer {
   }
 }
 
-// countStatuses → tui-core.mjs에서 import
-
 // ── Tier1: 상단 고정 1행 ─────────────────────────────────────────────────
 function phaseColor(phase, time = Date.now()) {
   const shimmer = currentShimmer(time);

package/hub/workers/factory.mjs

@@ -1,13 +1,8 @@
 // hub/workers/factory.mjs — Worker 생성 팩토리
-//
-// Supported worker types:
-//   - 'claude' → ClaudeWorker
-//   - 'codex'  → CodexMcpWorker
-//
 import { ClaudeWorker } from "./claude-worker.mjs";
 
 /**
- * @param {'claude'|'codex'} type
+ * @param {'claude'} type
  * @param {object} [opts]
  * @returns {Promise<import('./interface.mjs').IWorker>}
  */
@@ -15,10 +10,6 @@ export async function createWorker(type, opts = {}) {
   switch (type) {
     case "claude":
       return new ClaudeWorker(opts);
-    case "codex": {
-      const { CodexMcpWorker } = await import("./codex-mcp.mjs");
-      return new CodexMcpWorker(opts);
-    }
     default:
       throw new Error(`Unknown worker type: ${type}`);
   }

package/hub/workers/interface.mjs

@@ -59,10 +59,3 @@
  * @property {() => boolean} isReady
  * @property {'codex'|'gemini'|'antigravity'|'claude'} type
  */
-
-export const WORKER_TYPES = Object.freeze([
-  "codex",
-  "gemini",
-  "antigravity",
-  "claude",
-]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.53.0",
+  "version": "10.55.0",
   "description": "triflux remote — team mode, psmux, MCP workers.",
   "type": "module",
   "main": "hub/index.mjs",
@@ -9,17 +9,13 @@
     "./hub/*": "./hub/*"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "peerDependencies": {
     "@triflux/core": "^10.0.0-alpha.1"
   },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1"
-  },
   "files": [
     "hub",
-    "cto",
     "scripts/lib"
   ],
   "keywords": [