triflux 10.35.0 → 10.35.2

package/bin/tfx-live.mjs

@@ -2,9 +2,15 @@
 import { execFile } from "node:child_process";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { join as pathJoin } from "node:path";
+import { join as pathJoin, resolve as pathResolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import {
+  escapePwshSingleQuoted as escapeRemotePwshSingleQuoted,
+  probeRemoteEnv as probeRemoteHostEnv,
+  shellQuote as remoteShellQuote,
+  validateHost as validateRemoteHost,
+} from "../hub/team/remote-session.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -23,6 +29,7 @@ const BRIDGE_TIMEOUT_BUFFER_MS = 15_000;
 // spill the JSON to a temp file and pass --payload-file instead.
 const PAYLOAD_FILE_THRESHOLD = 96 * 1024;
 const VALID_TRANSPORTS = ["tmux", "uds", "auto"];
+const BOOLEAN_FLAGS = new Set(["json"]);
 // uds-fallback diagnostics land here, written async so a failed daemon attach
 // never blocks the tmux fallback path (see writeUdsBugReport / doAskAuto).
 const BUG_REPORT_DIR =
@@ -65,6 +72,11 @@ function parseCli(argv) {
       throw new Error("Empty flag is not valid");
     }
 
+    if (BOOLEAN_FLAGS.has(key)) {
+      flags[key] = "1";
+      continue;
+    }
+
     const value = rest[index + 1];
     if (value === undefined) {
       throw new Error(`Missing value for --${key}`);
@@ -168,6 +180,152 @@ function buildTmuxCommand(remote, tmuxArgs) {
   };
 }
 
+function timeoutSeconds(timeoutMs) {
+  return String(Math.max(1, Math.ceil((timeoutMs ?? 1000) / 1000)));
+}
+
+function buildRemoteLiveArgv(verb, opts) {
+  const args = [
+    "tfx-live",
+    verb,
+    "--cli",
+    "claude",
+    "--transport",
+    opts.transport ?? "uds",
+  ];
+  if (opts.short) args.push("--short", opts.short);
+  if (opts.sessionId) args.push("--session-id", opts.sessionId);
+  if (opts.session) args.push("--session", opts.session);
+  if (opts.configDir) args.push("--config-dir", opts.configDir);
+  if (verb === "ask") args.push("--prompt", opts.prompt ?? "");
+  args.push("--timeout", timeoutSeconds(opts.timeoutMs));
+  if (verb === "ask" && opts.settleMs) {
+    args.push("--settle", String(opts.settleMs));
+  }
+  if (verb === "ask" && opts.pollIntervalMs) {
+    args.push("--poll-interval", String(opts.pollIntervalMs));
+  }
+  return args;
+}
+
+function buildRemoteLiveCommand(host, verb, opts, env = {}) {
+  validateRemoteHost(host);
+  const argv = buildRemoteLiveArgv(verb, opts);
+  if (env.os === "win32") {
+    const [commandPath, ...args] = argv;
+    const command = [
+      `& '${escapeRemotePwshSingleQuoted(commandPath)}'`,
+      ...args.map((arg) => `'${escapeRemotePwshSingleQuoted(arg)}'`),
+    ].join(" ");
+    // Live-unverified for Windows remotes; apply the same SSH single-argument
+    // contract proven on darwin so the remote login shell does not re-split it.
+    const remoteCmd = `pwsh -NoProfile -Command ${remoteShellQuote(command)}`;
+    return {
+      command: "ssh",
+      args: [host, remoteCmd],
+    };
+  }
+
+  const shell = env.os === "darwin" && env.shell === "zsh" ? "zsh" : "sh";
+  const inner = argv.map(remoteShellQuote).join(" ");
+  const remoteCmd = `${shell} -lc ${remoteShellQuote(inner)}`;
+  return {
+    command: "ssh",
+    args: [host, remoteCmd],
+  };
+}
+
+function tryParseJsonObject(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function parseRemoteLiveJson(stdout) {
+  const text = String(stdout).trim();
+  if (!text) {
+    throw new Error("remote tfx-live returned empty output");
+  }
+
+  const direct = tryParseJsonObject(text);
+  if (direct && typeof direct === "object" && !Array.isArray(direct)) {
+    return direct;
+  }
+
+  let parsed = null;
+  for (let start = 0; start < text.length; start += 1) {
+    if (text[start] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let end = start; end < text.length; end += 1) {
+      const char = text[end];
+      if (inString) {
+        if (escaped) {
+          escaped = false;
+        } else if (char === "\\") {
+          escaped = true;
+        } else if (char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (char === '"') {
+        inString = true;
+      } else if (char === "{") {
+        depth += 1;
+      } else if (char === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          const candidate = tryParseJsonObject(text.slice(start, end + 1));
+          if (
+            candidate &&
+            typeof candidate === "object" &&
+            !Array.isArray(candidate)
+          ) {
+            parsed = candidate;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  if (parsed) return parsed;
+  throw new Error(`remote tfx-live output is not JSON: ${text.slice(0, 200)}`);
+}
+
+async function callRemoteLive(verb, opts, deps = {}) {
+  const host = validateRemoteHost(opts.remote);
+  const probeRemoteEnv = deps.probeRemoteEnv ?? probeRemoteHostEnv;
+  const execRemote = deps.sshExec ?? execFileAsync;
+  const env = await probeRemoteEnv(host);
+  const plan = buildRemoteLiveCommand(host, verb, opts, env);
+  const execOptions = {
+    timeout: (opts.timeoutMs ?? DEFAULT_ANSWER_TIMEOUT_MS) + 30_000,
+    maxBuffer: MAX_BUFFER,
+  };
+
+  try {
+    const { stdout } = await execRemote(plan.command, plan.args, execOptions);
+    return parseRemoteLiveJson(stdout);
+  } catch (error) {
+    if (error?.stdout) {
+      try {
+        return parseRemoteLiveJson(error.stdout);
+      } catch {
+        // stdout was not a tfx-live JSON result; fall through.
+      }
+    }
+    const stderr = error?.stderr ? String(error.stderr).trim() : "";
+    throw new Error(
+      `remote tfx-live ${verb} failed: ${stderr || error.message}`,
+    );
+  }
+}
+
 async function runTmux(remote, tmuxArgs, options = {}) {
   const { command, args } = buildTmuxCommand(remote, tmuxArgs);
   try {
@@ -397,6 +555,144 @@ function extractAssistantResponse(adapter, text, prompt = null) {
   return response.join("\n").trim();
 }
 
+function normalizeClaudeTaskText(text) {
+  return String(text)
+    .replace(/[.…]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+function isTaskListBoundary(line) {
+  const trimmed = line.trim();
+  return (
+    !trimmed ||
+    trimmed === "Working" ||
+    trimmed === "Completed" ||
+    /^[─-]{8,}$/.test(trimmed) ||
+    hasClaudeComposerPrompt(line) ||
+    /enter to open|space to reply|ctrl\+x to delete|\? for shortcuts/i.test(
+      trimmed,
+    )
+  );
+}
+
+function parseClaudeCompletedTaskListEntries(text) {
+  const lines = String(text)
+    .split("\n")
+    .map((line) => line.replace(/\s+$/g, ""));
+  const entries = [];
+  let inCompleted = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "Completed") {
+      inCompleted = true;
+      continue;
+    }
+    if (!inCompleted) {
+      continue;
+    }
+    if (isTaskListBoundary(line)) {
+      if (trimmed) {
+        inCompleted = false;
+      }
+      continue;
+    }
+    if (!/^\s*✻\s+/.test(line)) {
+      continue;
+    }
+
+    const body = trimmed.replace(/^✻\s+/, "");
+    const columns = body
+      .split(/\s{2,}/)
+      .map((column) => column.trim())
+      .filter(Boolean);
+    if (columns.length < 2) {
+      continue;
+    }
+
+    let responseIndex = columns.length - 1;
+    const tail = columns[responseIndex];
+    if (/^(?:\d+\s*[smhdw]|now|just now)$/i.test(tail)) {
+      responseIndex -= 1;
+    }
+    if (responseIndex <= 0) {
+      continue;
+    }
+
+    const summary = columns.slice(0, responseIndex).join(" ").trim();
+    const response = columns[responseIndex].trim();
+    if (!summary || !response) {
+      continue;
+    }
+    entries.push({
+      summary,
+      response,
+      key: `${normalizeClaudeTaskText(summary)}\0${normalizeClaudeTaskText(
+        response,
+      )}`,
+    });
+  }
+
+  return entries;
+}
+
+function claudeTaskMatchesPrompt(entry, prompt) {
+  if (!prompt) {
+    return true;
+  }
+  const summary = normalizeClaudeTaskText(entry.summary);
+  const normalizedPrompt = normalizeClaudeTaskText(prompt);
+  return (
+    Boolean(summary && normalizedPrompt) &&
+    (summary.includes(normalizedPrompt) || normalizedPrompt.includes(summary))
+  );
+}
+
+function extractClaudeCompletedTaskListResponse(text, options = {}) {
+  const beforeEntries = parseClaudeCompletedTaskListEntries(options.beforeText);
+  const beforeKeys = new Set(beforeEntries.map((entry) => entry.key));
+  const newEntries = parseClaudeCompletedTaskListEntries(text).filter(
+    (entry) => !beforeKeys.has(entry.key),
+  );
+  if (newEntries.length === 0) {
+    return "";
+  }
+  const promptMatches = options.prompt
+    ? newEntries.filter((entry) =>
+        claudeTaskMatchesPrompt(entry, options.prompt),
+      )
+    : [];
+  if (promptMatches.length > 0) {
+    return promptMatches[0].response;
+  }
+  if (newEntries.length === 1) {
+    return newEntries[0].response;
+  }
+  return newEntries.at(-1).response;
+}
+
+function hasClaudeCompletedTaskListResponse(text, options = {}) {
+  return extractClaudeCompletedTaskListResponse(text, options).length > 0;
+}
+
+function hasTmuxAssistantResponseAfterPrompt(
+  adapter,
+  text,
+  prompt,
+  beforeText,
+) {
+  return (
+    hasAssistantResponseAfterPrompt(adapter, text, prompt) ||
+    (adapter.cli === "claude" &&
+      hasClaudeCompletedTaskListResponse(text, {
+        beforeText,
+        prompt,
+      }))
+  );
+}
+
 async function capturePane(remote, session) {
   const { stdout } = await runTmux(remote, [
     "capture-pane",
@@ -805,6 +1101,63 @@ async function probeDaemon(bridgePath, ref, timeoutMs) {
   }
 }
 
+async function hasTmuxSession(adapter, opts) {
+  if (!opts.session) return false;
+  try {
+    await runTmux(opts.remote, ["has-session", "-t", opts.session]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function daemonProbeUnavailableReason(probe, targetAttachable) {
+  if (targetAttachable) return null;
+  if (!probe?.ok) return probe?.reason ?? "probe-failed";
+  return "target-not-found";
+}
+
+async function resolveAskTransport(adapter, opts, deps = {}) {
+  const transport = opts.transport ?? "tmux";
+  if (transport !== "auto") {
+    return {
+      transport,
+      transportSelected: transport,
+      transportProbe: null,
+    };
+  }
+
+  const tmuxProbe = deps.hasTmuxSession ?? hasTmuxSession;
+  const daemonProbe = deps.probeDaemon ?? probeDaemon;
+  const [tmux, probe] = await Promise.all([
+    tmuxProbe(adapter, opts),
+    daemonProbe(
+      opts.bridgePath,
+      {
+        short: opts.short,
+        sessionId: opts.sessionId,
+        configDir: opts.configDir,
+      },
+      opts.timeoutMs,
+    ),
+  ]);
+  const daemon = daemonProbeTargetAttachable(probe, opts);
+  const daemonReason = daemonProbeUnavailableReason(probe, daemon);
+  const transportProbe = {
+    tmux: tmux === true,
+    daemon,
+    ...(daemonReason ? { daemonReason } : {}),
+  };
+
+  return {
+    transport: "auto",
+    transportSelected: daemon ? "uds" : tmux ? "tmux" : "none",
+    transportProbe,
+    daemonProbe: probe,
+    daemonConfigDir: opts.configDir ?? probe?.raw?.daemon?.configDir ?? null,
+  };
+}
+
 async function doStart(adapter, opts) {
   const {
     session,
@@ -880,7 +1233,7 @@ async function doAskViaTmux(adapter, opts) {
     const doneSignal =
       !adapter.isBusy(visible) &&
       ready &&
-      hasAssistantResponseAfterPrompt(adapter, visible, prompt);
+      hasTmuxAssistantResponseAfterPrompt(adapter, visible, prompt, beforeRaw);
     if (doneSignal && quietPolls >= FALLBACK_QUIET_POLLS) {
       done = true;
       break;
@@ -891,6 +1244,15 @@ async function doAskViaTmux(adapter, opts) {
 
   raw = await capturePane(remote, session);
   response = extractAssistantResponse(adapter, raw, prompt);
+  if (!response && adapter.cli === "claude") {
+    response = extractClaudeCompletedTaskListResponse(raw, {
+      beforeText: beforeRaw,
+      prompt,
+    });
+    if (response) {
+      done = true;
+    }
+  }
   contextPctAfter = adapter.contextPct(raw);
 
   return addLoginGuard(adapter, raw, {
@@ -901,6 +1263,7 @@ async function doAskViaTmux(adapter, opts) {
     response,
     contextPctBefore,
     contextPctAfter,
+    matchedCompletion: done,
     done,
     raw,
   });
@@ -924,6 +1287,10 @@ async function doAsk(adapter, opts) {
     );
   }
 
+  if (opts.remote) {
+    return doAskViaRemoteLive(adapter, opts);
+  }
+
   if (transport === "uds") {
     if (!opts.bridgePath) {
       throw new Error(
@@ -936,6 +1303,16 @@ async function doAsk(adapter, opts) {
   return doAskAuto(adapter, opts);
 }
 
+async function doAskViaRemoteLive(adapter, opts, deps = {}) {
+  const result = await callRemoteLive("ask", opts, deps);
+  return {
+    ...result,
+    cli: result.cli ?? adapter.cli,
+    remote: opts.remote,
+    remoteRelay: true,
+  };
+}
+
 async function doAskViaDaemon(opts, meta = {}) {
   const { bridgePath, prompt, timeoutMs, short, sessionId, configDir } = opts;
   const payload = { prompt, timeoutMs };
@@ -1087,23 +1464,26 @@ async function runTmuxFallback(adapter, opts, reason, udsResult) {
 }
 
 async function doAskAuto(adapter, opts) {
-  const probe = await probeDaemon(
-    opts.bridgePath,
-    { short: opts.short, sessionId: opts.sessionId, configDir: opts.configDir },
-    opts.timeoutMs,
-  );
-  // daemon-probe returns the full session list (it does not filter by the
-  // requested short), so confirm the target is actually attachable here rather
-  // than firing a doomed attach at a missing short.
-  const targetAttachable = daemonProbeTargetAttachable(probe, opts);
+  const resolution = await resolveAskTransport(adapter, opts);
+  const probe = resolution.daemonProbe;
 
-  if (targetAttachable) {
-    const daemonConfigDir = opts.configDir ?? probe.raw?.daemon?.configDir;
+  if (resolution.transportSelected === "tmux") {
+    const tmuxResult = await doAskViaTmux(adapter, opts);
+    return {
+      ...tmuxResult,
+      transport: "auto",
+      transportSelected: "tmux",
+      transportProbe: resolution.transportProbe,
+    };
+  }
+
+  if (resolution.transportSelected === "uds") {
+    const daemonConfigDir = resolution.daemonConfigDir;
     const udsResult = await doAskViaDaemon(
       { ...opts, configDir: daemonConfigDir },
       {
         transportSelected: "uds",
-        transportProbe: "ok",
+        transportProbe: resolution.transportProbe,
       },
     );
     if (udsResult.matchedCompletion) {
@@ -1123,27 +1503,48 @@ async function doAskAuto(adapter, opts) {
       probe,
       attachError,
     });
-    const fallback = await runTmuxFallback(
-      adapter,
-      opts,
-      "uds-attach-incomplete",
-      udsResult,
-    );
+    const fallback =
+      resolution.transportProbe?.tmux === true
+        ? await runTmuxFallback(
+            adapter,
+            opts,
+            "uds-attach-incomplete",
+            udsResult,
+          )
+        : {
+            cli: adapter.cli,
+            transport: "auto",
+            transportSelected: "none",
+            transportProbe: resolution.transportProbe,
+            response: "",
+            done: false,
+            error:
+              "uds unavailable (uds-attach-incomplete) and no tmux session for fallback",
+            udsError: udsResult.error ?? attachError,
+          };
     await reportPromise.catch(() => {});
     return fallback;
   }
 
   // uds is unavailable: daemon unreachable, or reachable but target not listed.
-  const reason = !probe.ok
-    ? (probe.reason ?? "probe-failed")
-    : "target-not-found";
+  const reason = resolution.transportProbe?.daemonReason ?? "target-not-found";
   const reportPromise = writeUdsBugReport(reason, {
     short: opts.short,
     sessionId: opts.sessionId,
     bridgePath: opts.bridgePath,
     probe,
   });
-  const fallback = await runTmuxFallback(adapter, opts, reason, null);
+  const fallback = {
+    cli: adapter.cli,
+    transport: "auto",
+    transportSelected: "none",
+    transportProbe: resolution.transportProbe,
+    response: "",
+    done: false,
+    error: opts.session
+      ? `uds unavailable (${reason}) and tmux session unavailable`
+      : `uds unavailable (${reason}) and no --session for tmux fallback`,
+  };
   await reportPromise.catch(() => {});
   return fallback;
 }
@@ -1206,6 +1607,16 @@ async function doInterruptViaDaemon(opts, meta = {}) {
   };
 }
 
+async function doInterruptViaRemoteLive(adapter, opts, deps = {}) {
+  const result = await callRemoteLive("interrupt", opts, deps);
+  return {
+    ...result,
+    cli: result.cli ?? adapter.cli,
+    remote: opts.remote,
+    remoteRelay: true,
+  };
+}
+
 async function doInterrupt(adapter, opts) {
   const transport = opts.transport ?? "tmux";
   if (transport === "tmux") {
@@ -1221,6 +1632,9 @@ async function doInterrupt(adapter, opts) {
       `--transport ${transport} requires --short or --session-id`,
     );
   }
+  if (opts.remote) {
+    return doInterruptViaRemoteLive(adapter, opts);
+  }
   if (!opts.bridgePath) {
     throw new Error(
       `--transport ${transport} requires a bridge path (--bridge, TFX_BRIDGE, or TFX_REPO_ROOT)`,
@@ -1811,10 +2225,27 @@ async function main() {
   }
 }
 
-main().catch((error) => {
-  printJson({
-    ok: false,
-    error: error.message,
+export {
+  ADAPTERS,
+  buildRemoteLiveCommand,
+  callRemoteLive,
+  extractAssistantResponse,
+  extractClaudeCompletedTaskListResponse,
+  hasClaudeCompletedTaskListResponse,
+  parseRemoteLiveJson,
+  resolveAskTransport,
+};
+
+const isDirectRun =
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === pathResolve(process.argv[1]);
+
+if (isDirectRun) {
+  main().catch((error) => {
+    printJson({
+      ok: false,
+      error: error.message,
+    });
+    process.exitCode = 1;
   });
-  process.exitCode = 1;
-});
+}

package/bin/triflux.mjs

@@ -3328,72 +3328,42 @@ async function cmdDoctor(options = {}) {
       }
     }
 
-    // 4.5 Serena MCP
+    // 4.5 Serena MCP — 2026-06-10 core 에서 제거됨([Serena Core Removal]).
+    // serena 부재가 정상 상태이며, 잔존 시 부활로 간주해 제거를 권고한다(should-be-absent).
     section("Serena MCP");
     if (existsSync(CODEX_CONFIG_PATH)) {
       const codexConfig = readFileSync(CODEX_CONFIG_PATH, "utf8");
       const serenaConfig = inspectSerenaMcpConfig(codexConfig);
       if (!serenaConfig.present) {
-        warn("serena MCP 설정 없음");
-        info(
-          "권장: [mcp_servers.serena]에 --project-from-cwd, --context codex, startup_timeout_sec=30+ 설정",
-        );
+        ok("serena 미설정 (정상 — 2026-06-10 core 제거)");
         addDoctorCheck(report, {
           name: "serena-mcp",
-          status: "missing",
+          status: "ok",
           path: CODEX_CONFIG_PATH,
-          fix: "Codex config에 Serena MCP 설정을 추가하세요.",
+          note: "serena removed from core 2026-06-10; absence is expected.",
         });
-        issues++;
       } else {
-        const hasSerenaIssues =
-          !serenaConfig.hasProjectBinding || !serenaConfig.timeoutRecommended;
-
-        if (serenaConfig.hasProjectBinding) ok("project binding: 정상");
-        else {
-          warn("project binding 없음");
-          info("권장: --project-from-cwd 또는 --project <path>");
-          issues++;
-        }
-
-        if (serenaConfig.hasContextCodex) info("context codex: 설정됨");
-        else info("context codex: 미설정");
-
-        if (serenaConfig.startupTimeoutSec === null) {
-          warn("startup_timeout_sec 미설정");
-          info("권장: startup_timeout_sec = 30 이상");
-          issues++;
-        } else if (serenaConfig.timeoutRecommended) {
-          ok(`startup timeout: ${serenaConfig.startupTimeoutSec}s`);
-        } else {
-          warn(`startup timeout 낮음: ${serenaConfig.startupTimeoutSec}s`);
-          info("권장: startup_timeout_sec = 30 이상");
-          issues++;
-        }
-
+        // 제거 결정 이후 serena 가 다시 나타났다 — 부활 감지(should-be-absent 위반).
+        warn("serena MCP 설정 잔존 — core 에서 제거됨(2026-06-10). 부활 감지");
+        info("제거 권장: ~/.codex/config.toml 의 [mcp_servers.serena] 삭제");
         addDoctorCheck(report, {
           name: "serena-mcp",
-          status: hasSerenaIssues ? "issues" : "ok",
+          status: "issues",
           path: CODEX_CONFIG_PATH,
-          project_binding: serenaConfig.hasProjectBinding,
-          context_codex: serenaConfig.hasContextCodex,
-          startup_timeout_sec: serenaConfig.startupTimeoutSec,
-          ...(hasSerenaIssues
-            ? {
-                fix: "Serena MCP에 --project-from-cwd 와 startup_timeout_sec=30+ 를 설정하세요.",
-              }
-            : {}),
+          resurrected: true,
+          fix: "serena 는 core 에서 제거되었습니다. ~/.codex/config.toml 의 [mcp_servers.serena] 항목을 삭제하세요.",
         });
+        issues++;
       }
     } else {
+      // config.toml 미존재 — serena 부재는 정상. 이슈로 집계하지 않는다.
+      ok("config.toml 미존재 — serena 진단 불필요");
       addDoctorCheck(report, {
         name: "serena-mcp",
-        status: "missing",
+        status: "ok",
         path: CODEX_CONFIG_PATH,
-        fix: "Codex config를 생성하고 Serena MCP 설정을 추가하세요.",
+        note: "config.toml absent; serena not required.",
       });
-      warn("config.toml 미존재 — Serena MCP 진단 건너뜀");
-      issues++;
     }
 
     // 5. Antigravity CLI

package/hooks/claude-cwd-projection-refresh.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -8,7 +8,7 @@ import { refreshClaudeSessionProjectionCwd } from "../hub/team/claude-session-pr
 
 function readStdin() {
   try {
-    return fs.readFile(0, "utf8");
+    return Promise.resolve(readFileSync(0, "utf8"));
   } catch {
     return Promise.resolve("");
   }

package/hub/mac-tray.swift

@@ -47,6 +47,8 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSPopoverDelegate {
 class WebViewController: NSViewController, WKNavigationDelegate, WKScriptMessageHandler {
     var webView: WKWebView!
     var port: String = "27888"
+    let canonicalPort = "27888"
+    var consecutiveFailures = 0
     var retryWorkItem: DispatchWorkItem?
     var onFocusComplete: (() -> Void)?
 
@@ -101,6 +103,14 @@ class WebViewController: NSViewController, WKNavigationDelegate, WKScriptMessage
 
     func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) {
         logError("Failed to load: \(error.localizedDescription)")
+        consecutiveFailures += 1
+        if consecutiveFailures >= 3 && port != canonicalPort {
+            port = canonicalPort
+            consecutiveFailures = 0
+            logError("Switching to canonical port \(canonicalPort) after repeated failures")
+            loadTray()
+            return
+        }
         let retry = DispatchWorkItem { [weak self] in
             self?.loadTray()
         }
@@ -111,6 +121,7 @@ class WebViewController: NSViewController, WKNavigationDelegate, WKScriptMessage
     func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
         retryWorkItem?.cancel()
         retryWorkItem = nil
+        consecutiveFailures = 0
         logError("Successfully loaded URL")
     }
 

package/hub/server.mjs

@@ -517,7 +517,7 @@ function getRequestPath(url = "/") {
   }
 }
 
-function isLoopbackRemoteAddress(remoteAddress) {
+export function isLoopbackRemoteAddress(remoteAddress) {
   return (
     typeof remoteAddress === "string" &&
     LOOPBACK_REMOTE_ADDRESSES.has(remoteAddress)
@@ -563,7 +563,7 @@ function safeTokenCompare(a, b) {
   return timingSafeEqual(ha, hb);
 }
 
-function isAuthorizedRequest(req, path, hubToken) {
+export function isAuthorizedRequest(req, path, hubToken) {
   if (!hubToken) {
     return isLoopbackRemoteAddress(req.socket.remoteAddress);
   }

package/hub/tray.mjs

@@ -9,12 +9,26 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveHubPortForContext } from "./hub-lifecycle.mjs";
 import { IS_MAC, IS_WINDOWS } from "./platform.mjs";
 import { ensureHubForTray } from "./tray-lifecycle.mjs";
 
 const HUB_PID_FILE = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
 const DEFAULT_HUB_PORT = "27888";
 
+export function resolveTrayHubPort({
+  env = process.env,
+  cwd = process.cwd(),
+} = {}) {
+  return String(
+    resolveHubPortForContext({
+      env,
+      cwd,
+      defaultPort: Number(DEFAULT_HUB_PORT),
+    }),
+  );
+}
+
 function sleep(ms) {
   return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
 }
@@ -416,7 +430,7 @@ async function shutdown(reason = "shutdown") {
 export async function startTray() {
   if (IS_MAC) {
     const trayScript = fileURLToPath(import.meta.url);
-    const port = process.env.TFX_HUB_PORT || DEFAULT_HUB_PORT;
+    const port = resolveTrayHubPort();
     const serverPath = join(dirname(trayScript), "server.mjs");
     await ensureHubForTray({ port, serverPath });
     const reaped = reapExistingMacTrayProcesses({ scriptPath: trayScript });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.35.0",
+  "version": "10.35.2",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Antigravity, and Claude",
   "type": "module",
   "bin": {

package/scripts/setup.mjs

@@ -1374,13 +1374,25 @@ function ensureCriticalSetup() {
 
   try {
     ensureCodexProfiles();
-  } catch {}
+  } catch (error) {
+    process.stderr.write(
+      `[tfx-setup] ensureCodexProfiles 실패: ${error?.message || error}\n`,
+    );
+  }
   try {
     ensureCodexHooks();
-  } catch {}
+  } catch (error) {
+    process.stderr.write(
+      `[tfx-setup] ensureCodexHooks 실패: ${error?.message || error}\n`,
+    );
+  }
   try {
     ensureAgyHooks();
-  } catch {}
+  } catch (error) {
+    process.stderr.write(
+      `[tfx-setup] ensureAgyHooks 실패: ${error?.message || error}\n`,
+    );
+  }
 }
 
 export {

package/skills/tfx-ship/SKILL.md

@@ -1,8 +1,9 @@
 ---
 name: tfx-ship
 description: >
-  triflux 전용 릴리즈 자동화. 기존 scripts/release/* 래퍼 + AskUserQuestion 기반 버전 선택 +
-  CHANGELOG 편집 게이트 + Co-Authored-By/AI trailer 금지 강제. 'ship', '배포', '릴리즈',
+  triflux 전용 릴리즈 자동화. **GitHub Actions(release.yml dispatch / npm-publish.yml) 기반 CI 릴리즈가 기본 경로 —
+  npm publish 는 OIDC Trusted Publishing 으로 CI 가 수행하므로 로컬 npm login 불필요.** scripts/release/* 래퍼 +
+  AskUserQuestion 기반 버전 선택 + CHANGELOG 편집 게이트 + Co-Authored-By/AI trailer 금지 강제. 'ship', '배포', '릴리즈',
   'release', 'tfx-ship', 'publish' 같은 요청에 반드시 사용.
 argument-hint: "[patch|minor|major|<version>] [--skip-tests] [--no-publish] [--dry-run]"
 ---
@@ -27,10 +28,11 @@ triflux 는 아래 3채널로 동시 배포. 각 채널의 버전은 반드시
 | # | 채널 | 명령 | 우선순위 |
 |---|------|------|---------|
 | 1 | **GitHub Releases** | `gh release create vX.Y.Z --notes-file <notes>` | 공지 + changelog 공식 소스 |
-| 2 | **npm registry** | `node scripts/release/publish.mjs --execute` | primary distribution |
+| 2 | **npm registry** | **CI `npm-publish.yml`** (`v*` 태그 push 자동 / OIDC Trusted Publishing, `NPM_TOKEN` secret) | primary distribution |
 | 3 | **Claude Code marketplace** | `.claude-plugin/marketplace.json` (`source: npm` 참조) | `claude plugin add triflux` |
 | 4 | **pypi** (future, 비활성) | 현재 `pyproject.toml` 없음 | 활성화 시 Step 10.5 신설 |
 
+- **npm publish 는 로컬에서 하지 않는다** — `release.yml` dispatch 또는 `v*` 태그 push 시 `npm-publish.yml` 이 OIDC 로 발행한다. 로컬 `publish.mjs --execute` 는 CI 불가 시 폴백 전용.
 - marketplace 는 자체 publish 명령이 없음. marketplace.json 의 version 만 갱신하면 git push 로 반영됨 (GitHub 호스팅).
 - `release:check-sync` 가 package.json + marketplace.json + package-lock.json 3곳 version 일치를 강제한다.
 - pypi 는 triflux 가 Python 모듈을 가지게 되면 활성화. 현 단계는 플레이스홀더.
@@ -40,12 +42,47 @@ triflux 는 아래 3채널로 동시 배포. 각 채널의 버전은 반드시
 ## 전제 조건
 
 - `~/.claude/scripts/tfx-route.sh` 불필요 (CLI 워커 호출 없음)
-- `gh` CLI 인증됨 (`gh auth status`)
-- `npm` 사용 가능 + npm login 완료
-- 현재 브랜치: `main` (feature 브랜치에서는 차단)
-- `origin/main` 과 동기화된 상태 (behind 면 먼저 pull)
+- `gh` CLI 인증됨 (`gh auth status`) — `release.yml` dispatch / GitHub release 에 필요. 깨졌으면 웹 UI 대체
+- **npm 인증 불필요** — npm publish 는 CI(`npm-publish.yml`)가 OIDC/`NPM_TOKEN` 으로 수행 (로컬 `npm login` 필요 없음)
+- 릴리즈할 코드가 `origin/main` 에 있을 것 (CI 는 `--ref main` 으로 origin 을 checkout)
 
-## 실행 플로우
+## 기본 경로 — CI 릴리즈 (권장)
+
+> **npm publish 는 로컬에서 하지 않는다.** GitHub Actions 가 OIDC(Trusted Publishing)로 발행한다.
+> 워크플로우: `.github/workflows/{release,npm-publish,ci}.yml`
+
+- **`release.yml`** (`workflow_dispatch`, inputs: `version`, `channel`): 한 번의 dispatch 로 prepare(테스트/버전 bump) → 태그 + GitHub release(`publish.mjs --skip-npm`) → `npm-publish.yml` dispatch → npm publish 완료 대기 → `verify.mjs` 까지 전부 CI(ubuntu, node 24)에서 수행.
+- **`npm-publish.yml`** (`on: push tags ['v*']` + dispatch): `v*` 태그가 push 되면 자동 npm publish (`--provenance --access public`, `NPM_TOKEN` secret). 루트/core/triflux 3패키지 각각, 이미 게시된 버전은 skip.
+
+### 권장 실행 — release.yml 디스패치
+
+```bash
+gh workflow run release.yml --ref main -f version=<X.Y.Z> -f channel=stable
+# 진행 관찰
+gh run list --workflow release.yml -L1
+gh run watch "$(gh run list --workflow release.yml -L1 --json databaseId -q '.[0].databaseId')"
+```
+
+- gh 인증이 없는 환경(예: SSH→m2, hosts.yml PAT 만료)이면 **gh 가 정상인 머신(m5)에서** dispatch 하거나 **GitHub 웹 UI**(Actions → release → Run workflow)로 대체.
+- CHANGELOG 가 필요하면 dispatch 전에 main 에 별도 커밋으로 반영(아래 로컬 플로우 Step 4 양식 참조).
+
+### 경량 경로 — 태그만 push
+
+이미 검증된 hotfix 등 prepare/verify 없이 npm publish 만 트리거하려면:
+
+```bash
+# main 에서 bump 커밋(버전 3곳 동기화) 후
+git tag v<X.Y.Z> && git push origin v<X.Y.Z>   # → npm-publish.yml 자동 발동
+```
+
+> ⚠️ 이 경로는 GitHub release / verify 를 건너뛴다. 버전 동기화(package.json + marketplace.json + lock)는 직접 보장.
+
+---
+
+## 로컬 수동 플로우 (폴백 — CI 불가 시에만)
+
+> CI 가 정석이다. 아래는 Actions 가 막혔거나 로컬 디버깅 시의 수동 절차다.
+> **Step 10 의 로컬 `npm publish` 는 CI 와 중복이므로 평상시 실행 금지.**
 
 ### Step 0 — 환경 확인
 
@@ -205,21 +242,15 @@ gh release create "v${TARGET_VERSION}" \
 - 노트 본문 검증: Co-Authored-By / AI trailer 포함됐는지 grep 후 제거
 - `--draft` 로 초안 생성 후 수동 publish 도 가능 (안전 모드)
 
-### Step 10 — npm publish
+### Step 10 — npm publish (= CI 가 수행, 로컬 금지가 기본)
 
-`--no-publish` 플래그 없으면 **AskUserQuestion**:
+> **평상시 로컬에서 `npm publish` 하지 않는다.** Step 8 에서 `git push origin v<X.Y.Z>` 로 태그가 올라가면 `npm-publish.yml` 이 OIDC 로 자동 발행한다.
+> CI run 관찰: `gh run list --workflow npm-publish.yml -L1` → `gh run watch <id>`
 
-```
-npm registry 에 배포하시겠습니까?
-
-A) node scripts/release/publish.mjs --execute
-B) dry-run 으로 먼저 검증 (node scripts/release/publish.mjs --dry-run)
-C) 건너뜀 (수동 배포)
-```
+CI 가 완전히 불가능한 비상시에만, npm 인증을 갖춘 환경에서 수동 폴백:
 
-선택 A:
 ```bash
-node scripts/release/publish.mjs --execute
+node scripts/release/publish.mjs --execute   # 비상 폴백 전용 — 중복 publish 주의
 ```
 
 ### Step 10.5 — pypi publish (future, 현재 비활성)
@@ -277,14 +308,14 @@ github:  https://github.com/tellang/triflux/releases/tag/v${TARGET_VERSION}
 | Step 7 | commit 메시지에 AI trailer 감지 | 하드 차단 + 재작성 요청 |
 | Step 8 | push 거부 (remote 변경됨) | `git pull --rebase origin main` 후 재시도 |
 | Step 9 | gh release create 실패 | `gh auth status` 확인, 수동 재시도 |
-| Step 10 | npm publish 실패 | `npm login` 확인, 수동 재시도 |
+| Step 10 | npm publish(CI) 실패 | `gh run view <id> --log-failed` 로 `npm-publish.yml` 로그 확인. `NPM_TOKEN` secret / OIDC 설정 점검 |
 
 ## 플래그
 
 | 플래그 | 동작 |
 |--------|------|
 | `--skip-tests` | Step 5 의 `npm test` 건너뜀. stderr 경고 출력. 긴급 hotfix 전용 |
-| `--no-publish` | Step 10 의 `npm publish` 건너뜀. git push + GitHub release 만 |
+| `--no-publish` | 태그를 push 하지 않아 `npm-publish.yml` 미발동. main 커밋 + (수동) GitHub release 만 |
 | `--dry-run` | 모든 git push / publish 호출을 출력만 하고 skip. 검증 전용 |
 
 ## AI trailer 방지 상세
@@ -313,6 +344,6 @@ github:  https://github.com/tellang/triflux/releases/tag/v${TARGET_VERSION}
 
 - 버전 불일치: `npm run release:check-sync --fix`
 - pack CRLF 경고: 실제 변경 파일만 선별 `git add packages/triflux/...`
-- gh CLI 미인증: `gh auth login`
-- npm login 필요: `npm login`
+- gh CLI 미인증: `gh auth login` (또는 gh 정상인 머신/웹 UI 로 release.yml dispatch)
+- npm publish 는 CI(`npm-publish.yml`, OIDC)가 수행 — 로컬 `npm login` 불필요. CI 실패 시 `gh run view <id> --log-failed`
 - prepare.mjs stall: `scripts/release/prepare.mjs` 가 `stdio: ["ignore","pipe","pipe"]` + 10분 timeout 적용됨 (v10.9.32 fix 739da2d)