triflux 10.9.15 → 10.9.17

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "triflux",
       "description": "Tri-CLI orchestrator for Claude Code. Routes tasks across Claude + Codex + Gemini with consensus intelligence, natural language routing, 42 skills, and cross-model review.",
-      "version": "10.9.6",
+      "version": "10.9.17",
       "author": {
         "name": "tellang"
       },
@@ -30,5 +30,5 @@
       ]
     }
   ],
-  "version": "10.9.14"
+  "version": "10.9.17"
 }

package/hub/lib/spawn-trace.mjs

@@ -7,7 +7,7 @@ import { join } from "node:path";
 const LOG_DIR = join(homedir(), ".triflux", "logs");
 const DEDUPE_WINDOW_MS = 5_000;
 const RATE_WINDOW_MS = 1_000;
-export const MAX_SPAWN_PER_SEC = resolvePositiveInteger(
+export let MAX_SPAWN_PER_SEC = resolvePositiveInteger(
   process.env.TRIFLUX_MAX_SPAWN_RATE,
   30,
 );
@@ -149,6 +149,18 @@ function createPolicyError(reasonCode, message, meta = {}) {
   return error;
 }
 
+export function getMaxSpawnPerSec() {
+  return MAX_SPAWN_PER_SEC;
+}
+
+export function reload() {
+  MAX_SPAWN_PER_SEC = resolvePositiveInteger(
+    process.env.TRIFLUX_MAX_SPAWN_RATE,
+    30,
+  );
+  return getMaxSpawnPerSec();
+}
+
 function logBlocked(traceId, command, args, options, error, extra = {}) {
   appendTrace({
     event: "blocked",
@@ -167,6 +179,7 @@ function enforceGuards(command, args, options) {
   const now = Date.now();
   trimRecentSpawnTimes(now);
   trimDedupeEntries(now);
+  const maxSpawnPerSec = getMaxSpawnPerSec();
 
   const dedupeKey = getDedupeKey(options);
   if (dedupeKey) {
@@ -180,11 +193,11 @@ function enforceGuards(command, args, options) {
     }
   }
 
-  if (recentSpawnTimes.length >= MAX_SPAWN_PER_SEC) {
+  if (recentSpawnTimes.length >= maxSpawnPerSec) {
     return createPolicyError(
       "rate_limit",
-      `spawn-trace rate limit exceeded (${MAX_SPAWN_PER_SEC}/sec)`,
-      { maxPerSec: MAX_SPAWN_PER_SEC },
+      `spawn-trace rate limit exceeded (${maxSpawnPerSec}/sec)`,
+      { maxPerSec: maxSpawnPerSec },
     );
   }
 
@@ -318,6 +331,10 @@ function normalizeExecFileArgs(args, options, callback) {
   };
 }
 
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 export function spawn(command, args, options) {
   const { argsList, options: normalizedOptions } = normalizeSpawnArgs(
     args,
@@ -356,6 +373,32 @@ export function spawn(command, args, options) {
   });
 }
 
+export async function spawnWithBackoff(command, args, options, maxRetries = 1) {
+  const retryLimit =
+    Number.isInteger(maxRetries) && maxRetries >= 0 ? maxRetries : 1;
+  let originalRateLimitError = null;
+
+  for (let attempt = 0; attempt <= retryLimit; attempt += 1) {
+    try {
+      return spawn(command, args, options);
+    } catch (error) {
+      if (error?.reasonCode !== "rate_limit") {
+        throw error;
+      }
+
+      originalRateLimitError ??= error;
+
+      if (attempt >= retryLimit) {
+        throw originalRateLimitError;
+      }
+
+      await wait(RATE_WINDOW_MS);
+    }
+  }
+
+  throw originalRateLimitError;
+}
+
 export function execFile(file, args, options, callback) {
   const normalized = normalizeExecFileArgs(args, options, callback);
   const traceId = nextTraceId();
@@ -365,7 +408,13 @@ export function execFile(file, args, options, callback) {
     normalized.options,
   );
   if (blockedError) {
-    logBlocked(traceId, file, normalized.argsList, normalized.options, blockedError);
+    logBlocked(
+      traceId,
+      file,
+      normalized.argsList,
+      normalized.options,
+      blockedError,
+    );
     if (typeof normalized.callback === "function") {
       queueMicrotask(() => normalized.callback(blockedError, "", ""));
       return createRejectedChild(file, normalized.argsList, blockedError);
@@ -417,9 +466,16 @@ export function execFileSync(file, args, options) {
     normalized.options,
   );
   if (blockedError) {
-    logBlocked(traceId, file, normalized.argsList, normalized.options, blockedError, {
-      sync: true,
-    });
+    logBlocked(
+      traceId,
+      file,
+      normalized.argsList,
+      normalized.options,
+      blockedError,
+      {
+        sync: true,
+      },
+    );
     throw blockedError;
   }
 
@@ -489,8 +545,13 @@ export const spawnSync = childProcess.spawnSync;
 export default {
   ...childProcess,
   spawn,
+  spawnWithBackoff,
   execFile,
   execFileSync,
-  MAX_SPAWN_PER_SEC,
+  get MAX_SPAWN_PER_SEC() {
+    return MAX_SPAWN_PER_SEC;
+  },
   MAX_TOTAL_DESCENDANTS,
+  getMaxSpawnPerSec,
+  reload,
 };

package/hub/server.mjs

@@ -28,6 +28,7 @@ import { createAssignCallbackServer } from "./assign-callbacks.mjs";
 import { DelegatorService } from "./delegator/index.mjs";
 import { createHitlManager } from "./hitl.mjs";
 import { cleanupOrphanNodeProcesses } from "./lib/process-utils.mjs";
+import * as spawnTrace from "./lib/spawn-trace.mjs";
 import { wrapRequestHandler } from "./middleware/request-logger.mjs";
 import { createPipeServer } from "./pipe.mjs";
 import { createRouter } from "./router.mjs";
@@ -718,6 +719,11 @@ export async function startHub({
           pipe: pipe.getStatus(),
           assign_callback_pipe_path: assignCallbacks.path,
           assign_callback_pipe: assignCallbacks.getStatus(),
+          spawn_trace: {
+            max_per_sec: spawnTrace.getMaxSpawnPerSec(),
+            max_total_descendants: spawnTrace.MAX_TOTAL_DESCENDANTS,
+          },
+          version,
         });
       }
 
@@ -774,11 +780,60 @@ export async function startHub({
         return writeJson(res, 200, { ok: true, accounts });
       }
 
+      if (path === "/spawn-trace/reload" && req.method === "POST") {
+        return writeJson(res, 200, {
+          ok: true,
+          max_spawn_per_sec: spawnTrace.reload(),
+        });
+      }
+
       // ── Synapse Layer 5: session registry + locks + preflight routes ──
       if (path === "/synapse/sessions" && req.method === "GET") {
         return writeJson(res, 200, { ok: true, ...synapseRegistry.snapshot(), ts: Date.now() });
       }
 
+      if (path === "/synapse/register" && req.method === "POST") {
+        try {
+          const body = await parseBody(req);
+          const { sessionId } = body || {};
+          const result = synapseRegistry.register(sessionId, body);
+          if (!result?.ok) {
+            throw new Error(result?.reason || "register failed");
+          }
+          return writeJson(res, 200, { ok: true, sessionId: result.sessionId || sessionId });
+        } catch (err) {
+          return writeJson(res, 400, { ok: false, error: String(err?.message || err) });
+        }
+      }
+
+      if (path === "/synapse/heartbeat" && req.method === "POST") {
+        try {
+          const body = await parseBody(req);
+          const { sessionId, partial } = body || {};
+          const ok = synapseRegistry.heartbeat(sessionId, partial);
+          if (!ok) {
+            throw new Error("heartbeat failed");
+          }
+          return writeJson(res, 200, { ok: true });
+        } catch (err) {
+          return writeJson(res, 400, { ok: false, error: String(err?.message || err) });
+        }
+      }
+
+      if (path === "/synapse/unregister" && req.method === "POST") {
+        try {
+          const body = await parseBody(req);
+          const { sessionId } = body || {};
+          const ok = synapseRegistry.unregister(sessionId);
+          if (!ok) {
+            throw new Error("unregister failed");
+          }
+          return writeJson(res, 200, { ok: true });
+        } catch (err) {
+          return writeJson(res, 400, { ok: false, error: String(err?.message || err) });
+        }
+      }
+
       if (path === "/synapse/locks" && req.method === "GET") {
         return writeJson(res, 200, { ok: true, locks: swarmLocks.snapshot(), ts: Date.now() });
       }

package/hub/team/backend.mjs

@@ -41,7 +41,7 @@ export class GeminiBackend {
   }
 
   buildArgs(prompt, resultFile, opts = {}) {
-    return `gemini --prompt ${prompt} --output-format text > '${resultFile}' 2>'${resultFile}.err'`;
+    return `$null | gemini --prompt ${prompt} --output-format text > '${resultFile}' 2>'${resultFile}.err'`;
   }
 
   env() {

package/hub/team/conductor.mjs

@@ -8,7 +8,6 @@
 // 3. Auto-restart (maxRestarts=3)
 // 4. JSONL event log (블랙박스 리코더)
 
-import { execFile, spawn } from "../lib/spawn-trace.mjs";
 import { EventEmitter } from "node:events";
 import {
   copyFileSync,
@@ -20,6 +19,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createRegistry } from "../../mesh/mesh-registry.mjs";
 import { broker } from "../account-broker.mjs";
+import { execFile, spawn } from "../lib/spawn-trace.mjs";
 import { killProcess } from "../platform.mjs";
 import { createConductorMeshBridge } from "./conductor-mesh-bridge.mjs";
 import {
@@ -28,8 +28,13 @@ import {
 } from "./conductor-registry.mjs";
 import { createEventLog } from "./event-log.mjs";
 import { createHealthProbe } from "./health-probe.mjs";
-import { buildLauncher, getAdapter } from "./launcher-template.mjs";
-import { createRemoteProbe } from "./remote-probe.mjs";
+import { buildLauncher } from "./launcher-template.mjs";
+import {
+  buildSynapseTaskSummary,
+  heartbeatSynapseSession,
+  registerSynapseSession,
+  unregisterSynapseSession,
+} from "./synapse-http.mjs";
 
 /** 세션 상태 */
 export const STATES = Object.freeze({
@@ -126,6 +131,25 @@ export function createConductor(opts = {}) {
   const sessions = new Map();
   let shuttingDown = false;
   const publicApi = null;
+  const synapseOpts = {
+    baseUrl: opts.synapseBaseUrl,
+    fetchImpl: opts.synapseFetch,
+  };
+
+  function buildSynapseMeta(session, state = session.state, reason = "") {
+    return {
+      sessionId: session.id,
+      host:
+        typeof session.config.host === "string" &&
+        session.config.host.length > 0
+          ? session.config.host
+          : "local",
+      taskSummary: buildSynapseTaskSummary(session.config.prompt),
+      status: state,
+      reason,
+      isRemote: Boolean(session.config.remote),
+    };
+  }
 
   // 공유 event log (모든 세션 이벤트를 하나의 JSONL에)
   const eventLog = createEventLog(join(logsDir, "conductor-events.jsonl"));
@@ -166,6 +190,21 @@ export function createConductor(opts = {}) {
       reason,
     });
 
+    if (nextState === STATES.HEALTHY) {
+      registerSynapseSession(
+        buildSynapseMeta(session, nextState, reason),
+        synapseOpts,
+      );
+    }
+    heartbeatSynapseSession(
+      session.id,
+      buildSynapseMeta(session, nextState, reason),
+      synapseOpts,
+    );
+    if (nextState === STATES.COMPLETED || nextState === STATES.DEAD) {
+      unregisterSynapseSession(session.id, synapseOpts);
+    }
+
     // Terminal state cleanup
     if (TERMINAL_STATES.has(nextState)) {
       session.probe?.stop();
@@ -572,13 +611,16 @@ export function createConductor(opts = {}) {
     } else if (agent === "gemini") {
       remoteBin = "gemini -y";
     } else {
-      remoteBin = "codex exec -s danger-full-access --dangerously-bypass-approvals-and-sandbox";
+      remoteBin =
+        "codex exec -s danger-full-access --dangerously-bypass-approvals-and-sandbox";
     }
 
     // prompt는 stdin으로 전달 — 셸 이스케이프 문제 완전 회피
     const sshArgs = [
-      "-o", "ConnectTimeout=30",
-      "-o", "BatchMode=yes",
+      "-o",
+      "ConnectTimeout=30",
+      "-o",
+      "BatchMode=yes",
       host,
       `${cdPrefix}${remoteBin}`,
     ];

package/hub/team/headless.mjs

@@ -5,7 +5,6 @@
 // 의존성: psmux.mjs (Node.js 내장 모듈만 사용)
 
 import { execSync } from "node:child_process";
-import { spawn } from "../lib/spawn-trace.mjs";
 import { randomUUID } from "node:crypto";
 import {
   existsSync,
@@ -19,6 +18,7 @@ import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { requestJson } from "../bridge.mjs";
+import { getMaxSpawnPerSec } from "../lib/spawn-trace.mjs";
 import { escapePwshSingleQuoted } from "../cli-adapter-base.mjs";
 import { getBackend } from "./backend.mjs";
 import { resolveDashboardLayout } from "./dashboard-layout.mjs";
@@ -33,6 +33,11 @@ import {
   startCapture,
   waitForCompletion,
 } from "./psmux.mjs";
+import {
+  buildSynapseTaskSummary,
+  registerSynapseSession,
+  unregisterSynapseSession,
+} from "./synapse-http.mjs";
 import { createLogDashboard } from "./tui.mjs";
 import { createWtManager } from "./wt-manager.mjs";
 
@@ -119,6 +124,18 @@ export async function deregisterHeadlessWorkers(
   );
 }
 
+function registerHeadlessSynapseWorker(workerId, prompt) {
+  registerSynapseSession({
+    sessionId: workerId,
+    host: "local",
+    taskSummary: buildSynapseTaskSummary(prompt),
+  });
+}
+
+function unregisterHeadlessSynapseWorker(workerId) {
+  unregisterSynapseSession(workerId);
+}
+
 /** MCP 프로필별 프롬프트 힌트 (tfx-route.sh resolve_mcp_policy의 경량 미러) */
 const MCP_PROFILE_HINTS = {
   implement:
@@ -554,6 +571,7 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
     // pane 간 pipe-pane EBUSY 방지 — 이벤트 루프 해방하며 순차 대기
     if (i > 0) await new Promise((r) => setTimeout(r, 300));
     const dispatch = dispatchCommand(sessionName, newPaneId, cmd);
+    registerHeadlessSynapseWorker(workerId, assignment.prompt);
 
     if (safeProgress)
       safeProgress({ type: "dispatched", paneName, cli: assignment.cli });
@@ -626,6 +644,7 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
         scriptDir,
         scriptName: paneName,
       });
+      registerHeadlessSynapseWorker(workerId, assignment.prompt);
 
       // P1 fix: 비-progressive에서는 pane 리네임 금지 — 캡처 로그 경로가 타이틀 기반이므로
       // 리네임하면 waitForCompletion이 "codex (role).log"를 찾지만 실제는 "worker-N.log"로 불일치
@@ -754,6 +773,7 @@ async function awaitAll(
       const output = completion.matched
         ? readResult(d.resultFile, d.paneId)
         : "";
+      unregisterHeadlessSynapseWorker(d.workerId);
 
       if (safeProgress) {
         safeProgress({
@@ -861,6 +881,35 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
 
   mkdirSync(RESULT_DIR, { recursive: true });
 
+  // Hub version skew pre-flight (fail-open, best-effort)
+  requestJson("/status", { method: "GET", timeoutMs: 500 })
+    .then((status) => {
+      const hubRate = status?.spawn_trace?.max_per_sec;
+      const localRate = getMaxSpawnPerSec();
+      if (typeof hubRate === "number" && hubRate !== localRate) {
+        console.warn(
+          `[headless] Hub version skew detected: hub spawn rate=${hubRate}/s, local=${localRate}/s. Restart hub to sync.`,
+        );
+      }
+    })
+    .catch(() => {});
+
+  // Synapse: 세션 registration (fire-and-forget, hub 미응답 시 무시)
+  const synapseIds = assignments.map((_, i) => `${sessionName}-worker-${i + 1}`);
+  for (let i = 0; i < assignments.length; i++) {
+    const a = assignments[i];
+    requestJson("/synapse/register", {
+      method: "POST",
+      body: {
+        sessionId: synapseIds[i],
+        host: "local",
+        taskSummary: String(a.prompt || "").slice(0, 100),
+        isRemote: false,
+      },
+      timeoutMs: 1000,
+    }).catch(() => {});
+  }
+
   // in-process TUI: dashboard=true이고 stdout이 TTY일 때 직접 구동
   let tui = null;
   const resolvedLayout = resolveDashboardLayout(
@@ -918,9 +967,25 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     }
   }
 
+  // Synapse heartbeat: progress 이벤트마다 해당 워커의 세션 갱신
+  const feedSynapse = (event) => {
+    if (!event?.paneName) return;
+    const match = event.paneName.match(/worker-(\d+)/);
+    if (!match) return;
+    const idx = parseInt(match[1], 10) - 1;
+    const sid = synapseIds[idx];
+    if (!sid) return;
+    requestJson("/synapse/heartbeat", {
+      method: "POST",
+      body: { sessionId: sid, partial: { taskSummary: (event.snapshot || "").slice(0, 100) } },
+      timeoutMs: 500,
+    }).catch(() => {});
+  };
+
   // onProgress 예외를 삼켜 실행 흐름 보호 (onPoll과 동일 패턴)
   const combinedProgress = (event) => {
     feedTui(event);
+    feedSynapse(event);
     if (onProgress) {
       try {
         onProgress(event);
@@ -981,6 +1046,15 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     tui.close();
   }
 
+  // Synapse: 세션 unregister (fire-and-forget)
+  for (const sid of synapseIds) {
+    requestJson("/synapse/unregister", {
+      method: "POST",
+      body: { sessionId: sid },
+      timeoutMs: 1000,
+    }).catch(() => {});
+  }
+
   return { sessionName, results: collected };
 }
 
@@ -999,6 +1073,11 @@ export async function runHeadlessWithCleanup(assignments, opts = {}) {
   try {
     return await runHeadless(sessionName, assignments, runOpts);
   } finally {
+    for (let index = 0; index < assignments.length; index++) {
+      unregisterHeadlessSynapseWorker(
+        getHeadlessWorkerAgentId(sessionName, index),
+      );
+    }
     await deregisterHeadlessWorkers(sessionName, assignments.length);
     try {
       killPsmuxSession(sessionName);
@@ -1056,7 +1135,7 @@ export function applyTrifluxTheme(sessionName) {
  * WT 기본 프로필의 폰트 크기를 읽는다.
  * @returns {number} 기본 폰트 크기 (못 읽으면 12)
  */
-function getWtDefaultFontSize() {
+function _getWtDefaultFontSize() {
   const settingsPaths = [
     join(
       process.env.LOCALAPPDATA || "",
@@ -1096,7 +1175,7 @@ function getWtDefaultFontSize() {
  * @param {string} filePath — 대상 파일 경로
  * @param {string} data — 쓸 내용
  */
-function atomicWriteSync(filePath, data) {
+function _atomicWriteSync(filePath, data) {
   const tmpPath = `${filePath}.${process.pid}.tmp`;
   try {
     writeFileSync(tmpPath, data, "utf8");
@@ -1131,7 +1210,11 @@ function buildAttachTitle(sessionName, suffix = "") {
  * @param {number} [workerCount=2]
  * @returns {Promise<boolean>} 성공 여부
  */
-export async function autoAttachTerminal(sessionName, opts = {}, workerCount = 2) {
+export async function autoAttachTerminal(
+  sessionName,
+  opts = {},
+  workerCount = 2,
+) {
   if (!process.env.WT_SESSION) return false;
   try {
     execSync("where wt.exe", { stdio: "ignore" });
@@ -1145,8 +1228,14 @@ export async function autoAttachTerminal(sessionName, opts = {}, workerCount = 2
   try {
     const safeSession = sanitizeSessionName(sessionName);
     if (workerCount >= 5) {
-      const resolvedLayout = resolveDashboardLayout(opts.dashboardLayout || "single", workerCount);
-      const viewerPath = join(import.meta.dirname, "tui-viewer.mjs").replace(/\\/g, "/");
+      const resolvedLayout = resolveDashboardLayout(
+        opts.dashboardLayout || "single",
+        workerCount,
+      );
+      const viewerPath = join(import.meta.dirname, "tui-viewer.mjs").replace(
+        /\\/g,
+        "/",
+      );
       await wt.createTab({
         title: buildAttachTitle(safeSession, "dashboard"),
         profile: "triflux",
@@ -1220,7 +1309,10 @@ export async function attachDashboardTab(
   try {
     const safeSession = sanitizeSessionName(sessionName);
     const resolvedLayout = resolveDashboardLayout(dashboardLayout, workerCount);
-    const viewerPath = join(import.meta.dirname, "tui-viewer.mjs").replace(/\\/g, "/");
+    const viewerPath = join(import.meta.dirname, "tui-viewer.mjs").replace(
+      /\\/g,
+      "/",
+    );
 
     await wt.createTab({
       title: buildAttachTitle(safeSession, "dashboard"),
@@ -1233,7 +1325,6 @@ export async function attachDashboardTab(
   }
 }
 
-
 /**
  * 모든 워커 pane의 현재 스냅샷을 수집한다.
  *
@@ -1415,6 +1506,11 @@ export async function runHeadlessInteractive(
     kill() {
       if (this._killed) return;
       this._killed = true;
+      for (let index = 0; index < assignments.length; index++) {
+        unregisterHeadlessSynapseWorker(
+          getHeadlessWorkerAgentId(sessionName, index),
+        );
+      }
       void deregisterHeadlessWorkers(sessionName, assignments.length);
       try {
         killPsmuxSession(sessionName);

package/hub/team/synapse-http.mjs

@@ -0,0 +1,59 @@
+const DEFAULT_SYNAPSE_BASE_URL = "http://127.0.0.1:27888";
+
+function resolveSynapseFetch(fetchImpl) {
+  if (typeof fetchImpl === "function") return fetchImpl;
+  if (typeof globalThis.fetch === "function") {
+    return globalThis.fetch.bind(globalThis);
+  }
+  return null;
+}
+
+export function buildSynapseTaskSummary(prompt, maxLength = 100) {
+  if (maxLength <= 0) return "";
+  return String(prompt ?? "").slice(0, maxLength);
+}
+
+export function fireAndForgetSynapse(path, payload, opts = {}) {
+  const fetchImpl = resolveSynapseFetch(opts.fetchImpl);
+  if (!fetchImpl) return false;
+
+  try {
+    const url = new URL(
+      path,
+      opts.baseUrl || DEFAULT_SYNAPSE_BASE_URL,
+    ).toString();
+    Promise.resolve(
+      fetchImpl(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(payload),
+      }),
+    ).catch(() => {});
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function registerSynapseSession(meta, opts = {}) {
+  return fireAndForgetSynapse("/synapse/register", meta, opts);
+}
+
+export function heartbeatSynapseSession(
+  sessionId,
+  partialMeta = {},
+  opts = {},
+) {
+  return fireAndForgetSynapse(
+    "/synapse/heartbeat",
+    {
+      sessionId,
+      ...(partialMeta && typeof partialMeta === "object" ? partialMeta : {}),
+    },
+    opts,
+  );
+}
+
+export function unregisterSynapseSession(sessionId, opts = {}) {
+  return fireAndForgetSynapse("/synapse/unregister", { sessionId }, opts);
+}

package/hub/team/synapse-registry.mjs

@@ -165,8 +165,12 @@ export function createSynapseRegistry(opts = {}) {
     startMonitor(sessionId);
   }
 
-  function register(meta) {
-    const sessionId = normalizeSessionId(meta?.sessionId);
+  function register(sessionIdOrMeta, meta = null) {
+    const normalizedMeta =
+      meta && typeof meta === "object"
+        ? { ...meta, sessionId: sessionIdOrMeta }
+        : sessionIdOrMeta;
+    const sessionId = normalizeSessionId(normalizedMeta?.sessionId);
     if (!sessionId) {
       return { ok: false, sessionId, reason: "invalid_id" };
     }
@@ -178,7 +182,7 @@ export function createSynapseRegistry(opts = {}) {
 
     const session = sanitizeSession(
       {
-        ...meta,
+        ...normalizedMeta,
         sessionId,
         status: "active",
         lastHeartbeat: now(),

package/package.json

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

package/scripts/__tests__/spawn-trace.test.mjs

@@ -1,10 +1,21 @@
 import assert from "node:assert/strict";
-import { after, before, describe, it, mock } from "node:test";
-import { join } from "node:path";
-import { mkdirSync, rmSync, readFileSync, existsSync } from "node:fs";
+import { mkdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { after, before, describe, it } from "node:test";
 
 const TEST_LOG_DIR = join(tmpdir(), `spawn-trace-test-${Date.now()}`);
+let importSequence = 0;
+
+async function loadSpawnTraceModule() {
+  importSequence += 1;
+  return import(`../../hub/lib/spawn-trace.mjs?test=${importSequence}`);
+}
+
+function waitForClose(child) {
+  return new Promise((resolve) => child.once("close", resolve));
+}
 
 describe("spawn-trace", () => {
   before(() => {
@@ -12,12 +23,17 @@ describe("spawn-trace", () => {
   });
 
   after(() => {
-    try { rmSync(TEST_LOG_DIR, { recursive: true, force: true }); } catch { /* ignore */ }
+    try {
+      rmSync(TEST_LOG_DIR, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
   });
 
   it("exports child_process-compatible API surface", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const mod = await loadSpawnTraceModule();
     assert.equal(typeof mod.spawn, "function");
+    assert.equal(typeof mod.spawnWithBackoff, "function");
     assert.equal(typeof mod.execFile, "function");
     assert.equal(typeof mod.execFileSync, "function");
     assert.equal(typeof mod.exec, "function");
@@ -27,13 +43,35 @@ describe("spawn-trace", () => {
   });
 
   it("exports guard constants", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const mod = await loadSpawnTraceModule();
     assert.equal(typeof mod.MAX_SPAWN_PER_SEC, "number");
     assert.equal(typeof mod.MAX_TOTAL_DESCENDANTS, "number");
+    assert.equal(typeof mod.getMaxSpawnPerSec, "function");
+    assert.equal(typeof mod.reload, "function");
+  });
+
+  it("reload re-evaluates TRIFLUX_MAX_SPAWN_RATE", async () => {
+    const mod = await loadSpawnTraceModule();
+    const original = process.env.TRIFLUX_MAX_SPAWN_RATE;
+
+    try {
+      process.env.TRIFLUX_MAX_SPAWN_RATE = "7";
+      assert.equal(mod.reload(), 7);
+      assert.equal(mod.getMaxSpawnPerSec(), 7);
+      assert.equal(mod.MAX_SPAWN_PER_SEC, 7);
+      assert.equal(mod.default.MAX_SPAWN_PER_SEC, 7);
+    } finally {
+      if (original == null) {
+        delete process.env.TRIFLUX_MAX_SPAWN_RATE;
+      } else {
+        process.env.TRIFLUX_MAX_SPAWN_RATE = original;
+      }
+      mod.reload();
+    }
   });
 
   it("spawn returns a ChildProcess-like object", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const mod = await loadSpawnTraceModule();
     const child = mod.spawn("node", ["-e", "process.exit(0)"], {
       windowsHide: true,
     });
@@ -45,16 +83,20 @@ describe("spawn-trace", () => {
   });
 
   it("execFileSync returns stdout buffer", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
-    const result = mod.execFileSync("node", ["-e", 'process.stdout.write("hello")'], {
-      encoding: "utf8",
-      windowsHide: true,
-    });
+    const mod = await loadSpawnTraceModule();
+    const result = mod.execFileSync(
+      "node",
+      ["-e", 'process.stdout.write("hello")'],
+      {
+        encoding: "utf8",
+        windowsHide: true,
+      },
+    );
     assert.equal(result.trim(), "hello");
   });
 
   it("execFileSync throws on non-zero exit", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const mod = await loadSpawnTraceModule();
     assert.throws(() => {
       mod.execFileSync("node", ["-e", "process.exit(1)"], {
         windowsHide: true,
@@ -63,7 +105,7 @@ describe("spawn-trace", () => {
   });
 
   it("execFile with callback receives stdout", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const mod = await loadSpawnTraceModule();
     const result = await new Promise((resolve, reject) => {
       mod.execFile(
         "node",
@@ -79,22 +121,133 @@ describe("spawn-trace", () => {
   });
 
   it("strips trace-specific options before passing to child_process", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const mod = await loadSpawnTraceModule();
     // reason and dedupe should not cause child_process to error
-    const result = mod.execFileSync("node", ["-e", 'process.stdout.write("ok")'], {
-      encoding: "utf8",
-      windowsHide: true,
-      reason: "test:strip-options",
-      dedupe: "test-key",
-    });
+    const result = mod.execFileSync(
+      "node",
+      ["-e", 'process.stdout.write("ok")'],
+      {
+        encoding: "utf8",
+        windowsHide: true,
+        reason: "test:strip-options",
+        dedupe: "test-key",
+      },
+    );
     assert.equal(result.trim(), "ok");
   });
 
   it("default export includes spawn/execFile/execFileSync", async () => {
-    const mod = await import("../../hub/lib/spawn-trace.mjs");
+    const mod = await loadSpawnTraceModule();
     assert.equal(typeof mod.default.spawn, "function");
+    assert.equal(typeof mod.default.spawnWithBackoff, "function");
     assert.equal(typeof mod.default.execFile, "function");
     assert.equal(typeof mod.default.execFileSync, "function");
     assert.equal(typeof mod.default.MAX_SPAWN_PER_SEC, "number");
+    assert.equal(typeof mod.default.getMaxSpawnPerSec, "function");
+    assert.equal(typeof mod.default.reload, "function");
+  });
+
+  it("waits for RATE_WINDOW_MS and retries once after a rate limit error", async () => {
+    const original = process.env.TRIFLUX_MAX_SPAWN_RATE;
+    process.env.TRIFLUX_MAX_SPAWN_RATE = "1";
+
+    try {
+      const mod = await loadSpawnTraceModule();
+      const blocker = mod.spawn(
+        "node",
+        ["-e", "setTimeout(() => process.exit(0), 1500)"],
+        { windowsHide: true },
+      );
+
+      const startedAt = performance.now();
+      const child = await mod.spawnWithBackoff(
+        "node",
+        ["-e", "process.exit(0)"],
+        { windowsHide: true },
+      );
+      const elapsedMs = performance.now() - startedAt;
+
+      assert.ok(elapsedMs >= 900, `expected retry delay, got ${elapsedMs}ms`);
+      assert.equal(typeof child.pid, "number");
+
+      await waitForClose(child);
+      await waitForClose(blocker);
+    } finally {
+      if (original == null) {
+        delete process.env.TRIFLUX_MAX_SPAWN_RATE;
+      } else {
+        process.env.TRIFLUX_MAX_SPAWN_RATE = original;
+      }
+    }
+  });
+
+  it("rethrows the original rate limit error when the retry also hits the limit", async () => {
+    const originalEnv = process.env.TRIFLUX_MAX_SPAWN_RATE;
+    const originalDateNow = Date.now;
+    process.env.TRIFLUX_MAX_SPAWN_RATE = "1";
+    Date.now = () => 1_000;
+
+    try {
+      const mod = await loadSpawnTraceModule();
+      const blocker = mod.spawn(
+        "node",
+        ["-e", "setTimeout(() => process.exit(0), 1500)"],
+        { windowsHide: true },
+      );
+
+      const startedAt = performance.now();
+      await assert.rejects(
+        () =>
+          mod.spawnWithBackoff("node", ["-e", "process.exit(0)"], {
+            windowsHide: true,
+          }),
+        (error) => {
+          assert.equal(error?.reasonCode, "rate_limit");
+          assert.equal(error?.maxPerSec, 1);
+          return true;
+        },
+      );
+      const elapsedMs = performance.now() - startedAt;
+      assert.ok(elapsedMs >= 900, `expected retry delay, got ${elapsedMs}ms`);
+
+      blocker.kill();
+      await waitForClose(blocker);
+    } finally {
+      Date.now = originalDateNow;
+      if (originalEnv == null) {
+        delete process.env.TRIFLUX_MAX_SPAWN_RATE;
+      } else {
+        process.env.TRIFLUX_MAX_SPAWN_RATE = originalEnv;
+      }
+    }
+  });
+
+  it("throws non-rate-limit guard errors immediately", async () => {
+    const mod = await loadSpawnTraceModule();
+    const blocker = mod.spawn(
+      "node",
+      ["-e", "setTimeout(() => process.exit(0), 250)"],
+      { dedupe: "same-key", windowsHide: true },
+    );
+
+    const startedAt = performance.now();
+    await assert.rejects(
+      () =>
+        mod.spawnWithBackoff("node", ["-e", "process.exit(0)"], {
+          dedupe: "same-key",
+          windowsHide: true,
+        }),
+      (error) => {
+        assert.equal(error?.reasonCode, "dedupe");
+        return true;
+      },
+    );
+    const elapsedMs = performance.now() - startedAt;
+    assert.ok(
+      elapsedMs < 500,
+      `expected immediate failure, got ${elapsedMs}ms`,
+    );
+
+    await waitForClose(blocker);
   });
 });

package/scripts/tfx-route.sh

@@ -1795,6 +1795,12 @@ EOF
       team_complete_task "success" "$output_preview"
     elif [[ "$exit_code" -eq 124 ]]; then
       team_complete_task "timeout" "타임아웃 (${TIMEOUT_SEC}초)"
+    elif [[ "$exit_code" -eq 143 ]]; then
+      team_complete_task "timeout" "외부 시그널로 종료 (SIGTERM, ${TIMEOUT_SEC}초)"
+    elif [[ "$exit_code" -eq 137 ]]; then
+      team_complete_task "timeout" "외부 시그널로 종료 (SIGKILL, ${TIMEOUT_SEC}초)"
+    elif [[ "$exit_code" -eq 130 ]]; then
+      team_complete_task "failed" "사용자 인터럽트 (SIGINT)"
     else
       local err_preview
       err_preview=$(tail -c 1024 "$STDERR_LOG" 2>/dev/null || echo "에러 정보 없음")