triflux 10.9.14 → 10.9.16

package/.claude-plugin/marketplace.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "triflux",
+  "description": "CLI-first multi-model orchestrator — Codex/Gemini/Claude routing with DAG execution, auto-triage, and cost optimization",
+  "owner": {
+    "name": "tellang"
+  },
+  "plugins": [
+    {
+      "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",
+      "author": {
+        "name": "tellang"
+      },
+      "source": {
+        "source": "npm",
+        "package": "triflux"
+      },
+      "category": "productivity",
+      "homepage": "https://github.com/tellang/triflux",
+      "tags": [
+        "multi-model",
+        "codex",
+        "gemini",
+        "cli-routing",
+        "orchestration",
+        "cost-optimization",
+        "dag-execution"
+      ]
+    }
+  ],
+  "version": "10.9.14"
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "triflux",
+  "version": "10.3.4",
+  "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
+  "author": {
+    "name": "tellang"
+  },
+  "repository": "https://github.com/tellang/triflux",
+  "homepage": "https://github.com/tellang/triflux",
+  "license": "MIT",
+  "keywords": [
+    "claude-code",
+    "plugin",
+    "codex",
+    "gemini",
+    "cli-routing",
+    "orchestration",
+    "multi-model"
+  ],
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json"
+}

package/config/mcp-registry.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "mcp-registry-schema",
+  "version": 1,
+  "description": "MCP 서버 중앙 레지스트리 — 진실의 원천",
+  "defaults": {
+    "transport": "hub-url",
+    "hub_base": "http://127.0.0.1:27888"
+  },
+  "servers": {
+    "tfx-hub": {
+      "transport": "hub-url",
+      "url": "http://127.0.0.1:27888/mcp",
+      "safe": true,
+      "targets": ["claude", "gemini", "codex"],
+      "description": "triflux Hub MCP 서버"
+    }
+  },
+  "policies": {
+    "stdio_action": "replace-with-hub",
+    "unknown_server_action": "warn",
+    "watched_paths": [
+      "~/.gemini/settings.json",
+      "~/.codex/config.toml",
+      "~/.claude/settings.json",
+      "~/.claude/settings.local.json",
+      ".mcp.json"
+    ]
+  }
+}

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 },
     );
   }
 
@@ -365,7 +378,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 +436,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;
   }
 
@@ -491,6 +517,10 @@ export default {
   spawn,
   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";
@@ -593,6 +594,20 @@ export async function startHub({
     locks: swarmLocks,
   });
 
+  // Synapse Layer 5: emitter subscribers — bridge events to hub logging
+  synapseEmitter.on("synapse.session.started", ({ sessionId }) => {
+    hubLog.info({ sessionId }, "synapse.session.started");
+  });
+  synapseEmitter.on("synapse.session.heartbeat", ({ sessionId }) => {
+    hubLog.debug({ sessionId }, "synapse.session.heartbeat");
+  });
+  synapseEmitter.on("synapse.session.stale", ({ sessionId }) => {
+    hubLog.warn({ sessionId }, "synapse.session.stale");
+  });
+  synapseEmitter.on("synapse.session.removed", ({ sessionId }) => {
+    hubLog.info({ sessionId }, "synapse.session.removed");
+  });
+
   const hitl = createHitlManager(store, router);
   const pipe = createPipeServer({
     router,
@@ -760,6 +775,82 @@ 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() });
+      }
+
+      if (path === "/synapse/preflight" && req.method === "POST") {
+        const VALID_OPS = new Set(["checkout", "rebase", "cherry-pick", "reset", "stash-pop", "worktree-remove"]);
+        try {
+          const body = await parseBody(req);
+          const { op, args = {}, sessionContext = {} } = body;
+          if (!op || typeof op !== "string") {
+            return writeJson(res, 400, { ok: false, error: "op 필수" });
+          }
+          if (!VALID_OPS.has(op)) {
+            return writeJson(res, 400, { ok: false, error: `invalid op: ${op}` });
+          }
+          const result = gitPreflight.check(op, args, sessionContext);
+          return writeJson(res, 200, { ok: true, ...result });
+        } catch (err) {
+          return writeJson(res, 400, { ok: false, error: String(err?.message || err) });
+        }
+      }
+
       if (path.startsWith("/bridge")) {
         const isBridgeStatusGet =
           path === "/bridge/status" && req.method === "GET";

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({
@@ -66,6 +71,40 @@ const TERMINAL_STATES = new Set([STATES.DEAD, STATES.COMPLETED]);
 const DEFAULT_MAX_RESTARTS = 3;
 const DEFAULT_GRACE_MS = 10_000;
 
+/**
+ * Auth 파일을 lease 소스에서 CLI 대상 경로로 복사.
+ * @param {object} lease — broker lease 객체 (mode, authFile 필수)
+ * @param {'codex'|'gemini'} agent
+ * @param {string} sessionId — 로깅용
+ * @param {object} eventLog — createEventLog 인스턴스
+ */
+function swapAuthFile(lease, agent, sessionId, eventLog) {
+  if (lease?.mode !== "auth" || !lease.authFile) return true;
+  const dests =
+    agent === "codex"
+      ? [join(homedir(), ".codex", "auth.json")]
+      : [
+          join(homedir(), ".gemini", "oauth_creds.json"),
+          join(homedir(), ".gemini", "gemini-credentials.json"),
+        ];
+  let allOk = true;
+  for (const dest of dests) {
+    try {
+      mkdirSync(dirname(dest), { recursive: true });
+      copyFileSync(lease.authFile, dest);
+      eventLog.append("auth_copy", { session: sessionId, agent, dest });
+    } catch (err) {
+      allOk = false;
+      eventLog.append("auth_copy_error", {
+        session: sessionId,
+        dest,
+        error: err.message,
+      });
+    }
+  }
+  return allOk;
+}
+
 /**
  * Conductor 팩토리.
  * @param {object} opts
@@ -73,6 +112,7 @@ const DEFAULT_GRACE_MS = 10_000;
  * @param {number} [opts.maxRestarts=3]
  * @param {number} [opts.graceMs=10000] — shutdown grace period
  * @param {object} [opts.probeOpts] — health-probe 옵션 오버라이드
+ * @param {object} [opts.broker] — AccountBroker 인스턴스 (tierFallback 구독용)
  * @returns {Conductor}
  */
 export function createConductor(opts = {}) {
@@ -81,6 +121,7 @@ export function createConductor(opts = {}) {
     maxRestarts = DEFAULT_MAX_RESTARTS,
     graceMs = DEFAULT_GRACE_MS,
     probeOpts = {},
+    broker: optsBroker,
   } = opts;
 
   if (!logsDir) throw new Error("logsDir is required");
@@ -90,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"));
@@ -130,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();
@@ -536,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}`,
     ];
@@ -739,32 +817,7 @@ export function createConductor(opts = {}) {
       : config;
 
     // auth file copy — broker resolved absolute path, conductor does the actual copy
-    if (lease?.mode === "auth" && lease.authFile) {
-      const dests =
-        config.agent === "codex"
-          ? [join(homedir(), ".codex", "auth.json")]
-          : [
-              join(homedir(), ".gemini", "oauth_creds.json"),
-              join(homedir(), ".gemini", "gemini-credentials.json"),
-            ];
-      for (const dest of dests) {
-        try {
-          mkdirSync(dirname(dest), { recursive: true });
-          copyFileSync(lease.authFile, dest);
-          eventLog.append("auth_copy", {
-            session: config.id,
-            agent: config.agent,
-            dest,
-          });
-        } catch (err) {
-          eventLog.append("auth_copy_error", {
-            session: config.id,
-            dest,
-            error: err.message,
-          });
-        }
-      }
-    }
+    swapAuthFile(lease, config.agent, config.id, eventLog);
 
     // 원격 세션은 launcher 불필요 (이미 원격에서 실행 중)
     const launcher = resolvedConfig.remote
@@ -892,12 +945,44 @@ export function createConductor(opts = {}) {
       });
 
     await Promise.allSettled(cleanups);
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    if (brokerInstance && onTierFallback) {
+      brokerInstance.removeListener("tierFallback", onTierFallback);
+    }
     if (conductor._meshBridge) conductor._meshBridge.detach();
     await eventLog.flush();
     await eventLog.close();
     emitter.emit("shutdown");
   }
 
+  // ── broker tierFallback 구독 ──────────────────────────────────
+  // 토큰 만료 등으로 상위 tier 계정이 불가능해지면, 활성 세션의 auth를 새 lease로 교체.
+  const brokerInstance = optsBroker ?? null;
+  const onTierFallback = brokerInstance
+    ? ({ provider }) => {
+        for (const session of sessions.values()) {
+          if (TERMINAL_STATES.has(session.state)) continue;
+          if (session.config.agent !== provider) continue;
+          if (session.config.remote) continue;
+
+          const newLease = brokerInstance.lease({ provider });
+          if (!newLease) continue;
+
+          swapAuthFile(newLease, provider, session.id, eventLog);
+          eventLog.append("tier_fallback_swap", {
+            session: session.id,
+            agent: provider,
+            newAccount: newLease.id,
+          });
+        }
+      }
+    : null;
+
+  if (brokerInstance && onTierFallback) {
+    brokerInstance.on("tierFallback", onTierFallback);
+  }
+
   // Shutdown traps
   const onSignal = () => {
     void shutdown("signal");