triflux 10.19.0 → 10.20.1

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.20.1",
+      "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.20.1"
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "triflux",
+  "version": "10.20.1",
+  "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/bin/triflux.mjs

@@ -77,6 +77,7 @@ import {
   getVersion,
   getWindowsHubAutostartStatus,
   hasProfileSection,
+  isSetupUserStateFile,
   LEGACY_CODEX_MODELS,
   REQUIRED_CODEX_PROFILES,
   replaceProfileSection,
@@ -1206,6 +1207,7 @@ function cmdSetup(options = {}) {
       if (existsSync(refSrc)) {
         mkdirSync(refDst, { recursive: true });
         for (const refFile of readdirSync(refSrc)) {
+          if (isSetupUserStateFile(refFile)) continue;
           const rSrc = join(refSrc, refFile);
           const rDst = join(refDst, refFile);
           if (statSync(rSrc).isFile()) {

package/config/mcp-registry.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "mcp-registry-schema",
+  "version": 1,
+  "description": "MCP 서버 중앙 레지스트리 — 진실의 원천",
+  "defaults": {
+    "transport": "hub-url",
+    "hub_base": "http://127.0.0.1:27888"
+  },
+  "policy_notes": {
+    "transport": "Server transport accepts \"hub-url\" for the existing triflux Hub URL flow or \"http\" for direct Streamable HTTP MCP endpoints. Direct stdio registration via command/args is intentionally unsupported.",
+    "headers": "Optional headers are allowed only for HTTP-compatible transports. Each header value must be a descriptor: {\"value\":\"literal\"} for non-secret static values, {\"env\":\"ENV_VAR_NAME\"} for secrets resolved at sync/runtime, or {\"env\":\"ENV_VAR_NAME\",\"prefix\":\"Bearer \"} for common authorization formats.",
+    "secret_safety": "Resolved secret values must not be written back to this registry file. Missing env vars warn during sync and do not emit empty secret headers.",
+    "sync_denylist": "Array of client:server strings skipped by proactive registry sync, for example gemini:tfx-hub."
+  },
+  "servers": {
+    "tfx-hub": {
+      "transport": "hub-url",
+      "url": "http://127.0.0.1:27888/mcp",
+      "safe": true,
+      "targets": ["claude", "gemini", "codex"],
+      "description": "triflux Hub MCP 서버"
+    },
+    "context7": {
+      "transport": "http",
+      "url": "https://mcp.context7.com/mcp",
+      "safe": true,
+      "targets": ["claude", "gemini", "codex"],
+      "description": "Upstash Context7 — 라이브러리 문서/코드 컨텍스트 (HTTP MCP, API key 불필요)"
+    }
+  },
+  "policies": {
+    "stdio_action": "replace-with-hub",
+    "unknown_server_action": "warn",
+    "sync_denylist": [],
+    "watched_paths": [
+      "~/.gemini/settings.json",
+      "~/.codex/config.toml",
+      "~/.claude/settings.json",
+      "~/.claude/settings.local.json",
+      ".claude/mcp.json",
+      ".mcp.json"
+    ]
+  }
+}

package/hooks/hook-registry.json

@@ -264,6 +264,19 @@
         "blocking": false,
         "description": "서브에이전트 결과 품질 체크"
       }
+    ],
+    "PreCompact": [
+      {
+        "id": "tfx-pre-compact-snapshot",
+        "source": "triflux",
+        "matcher": "*",
+        "command": "node \"${PLUGIN_ROOT}/hooks/pre-compact-snapshot.mjs\"",
+        "priority": 0,
+        "enabled": true,
+        "timeout": 3,
+        "blocking": false,
+        "description": "compact 직전 repo-local 진행 상태 스냅샷 주입 (#245)"
+      }
     ]
   }
 }

package/hooks/hooks.json

@@ -84,6 +84,18 @@
           }
         ]
       }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-orchestrator.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
     ]
   }
 }

package/hooks/pre-compact-snapshot.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// hooks/pre-compact-snapshot.mjs — PreCompact hook
+//
+// Compaction 직전에 짧은 상태 스냅샷을 주입한다. 민감 데이터는 읽지 않고,
+// repo-local 상태와 git 요약만 3KB 이하로 제한한다.
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const MAX_CONTEXT_BYTES = 3000;
+const STALE_RUN_MS = 30 * 60 * 1000;
+const PROJECT_ROOT = process.env.CLAUDE_CWD || process.cwd();
+
+function readStdinJson() {
+  try {
+    const raw = readFileSync(0, "utf8");
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+function git(args) {
+  try {
+    return execFileSync("git", args, {
+      cwd: PROJECT_ROOT,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3000,
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+function summarizeGit() {
+  const branch =
+    git(["branch", "--show-current"]) || git(["rev-parse", "--short", "HEAD"]);
+  const status = git(["status", "--short"]);
+  const rows = status ? status.split(/\r?\n/).filter(Boolean) : [];
+  return {
+    branch: branch || "unknown",
+    dirty: rows.length,
+    sample: rows.slice(0, 8),
+  };
+}
+
+function readJsonIfSmall(path, maxBytes = 24_000) {
+  try {
+    if (!existsSync(path)) return null;
+    if (statSync(path).size > maxBytes) return null;
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function summarizeModeState(root) {
+  const stateDir = join(root, ".omx", "state");
+  if (!existsSync(stateDir)) return [];
+  try {
+    return readdirSync(stateDir)
+      .filter((name) => name.endsWith("-state.json"))
+      .flatMap((name) => {
+        const state = readJsonIfSmall(join(stateDir, name));
+        if (!state || state.active === false) return [];
+        return [
+          {
+            mode: state.mode || name.replace(/-state\.json$/, ""),
+            phase: state.current_phase || state.phase || null,
+            active: state.active !== false,
+          },
+        ];
+      })
+      .slice(0, 8);
+  } catch {
+    return [];
+  }
+}
+
+function summarizeRetryState(input) {
+  const sessionId = input.session_id || input.sessionId || "";
+  if (!sessionId) return null;
+  const candidates = [
+    join(PROJECT_ROOT, ".omc", "state", `retry-${sessionId}.json`),
+    join(homedir(), ".omc", "state", `retry-${sessionId}.json`),
+  ];
+  for (const path of candidates) {
+    const state = readJsonIfSmall(path);
+    if (!state) continue;
+    return {
+      phase: state.phase || state.current_phase || null,
+      iteration: state.iteration ?? state.retry_count ?? null,
+      max: state.max_iterations ?? state.max ?? null,
+    };
+  }
+  return null;
+}
+
+function countStaleSwarmRuns(nowMs = Date.now()) {
+  const logsRoot = join(PROJECT_ROOT, ".triflux", "swarm-logs");
+  if (!existsSync(logsRoot)) return 0;
+  try {
+    return readdirSync(logsRoot, { withFileTypes: true }).filter((entry) => {
+      if (!entry.isDirectory() || !entry.name.startsWith("run-")) return false;
+      const eventPath = join(logsRoot, entry.name, "swarm-events.jsonl");
+      if (!existsSync(eventPath)) return false;
+      try {
+        return nowMs - statSync(eventPath).mtimeMs > STALE_RUN_MS;
+      } catch {
+        return false;
+      }
+    }).length;
+  } catch {
+    return 0;
+  }
+}
+
+function truncateUtf8(text, maxBytes) {
+  let output = text;
+  while (Buffer.byteLength(output, "utf8") > maxBytes) {
+    output = output.slice(0, Math.max(0, output.length - 200));
+  }
+  return output;
+}
+
+export function buildSnapshot(input = readStdinJson()) {
+  const gitState = summarizeGit();
+  const activeModes = summarizeModeState(PROJECT_ROOT);
+  const retry = summarizeRetryState(input);
+  const staleSwarmRuns = countStaleSwarmRuns();
+
+  const lines = [
+    "[triflux pre-compact snapshot]",
+    `cwd: ${PROJECT_ROOT}`,
+    `git: ${gitState.branch}; dirty=${gitState.dirty}`,
+  ];
+  if (gitState.sample.length) {
+    lines.push(`dirty_sample: ${gitState.sample.join(" | ")}`);
+  }
+  if (activeModes.length) {
+    lines.push(
+      `active_modes: ${activeModes
+        .map((m) => `${m.mode}${m.phase ? `:${m.phase}` : ""}`)
+        .join(", ")}`,
+    );
+  }
+  if (retry) {
+    lines.push(
+      `retry: phase=${retry.phase || "-"} iteration=${retry.iteration ?? "-"}/${retry.max ?? "-"}`,
+    );
+  }
+  if (staleSwarmRuns > 0) {
+    lines.push(`stale_swarm_runs: ${staleSwarmRuns}`);
+  }
+
+  return truncateUtf8(lines.join("\n"), MAX_CONTEXT_BYTES);
+}
+
+function main() {
+  const snapshot = buildSnapshot();
+  if (!snapshot.trim()) return;
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreCompact",
+        additionalContext: snapshot,
+      },
+    }),
+  );
+}
+
+try {
+  if (import.meta.url.endsWith(process.argv[1]?.split(/[\\/]/).pop() || "")) {
+    main();
+  }
+} catch {
+  process.exit(0);
+}

package/hub/team/synapse-cli.mjs

@@ -4,7 +4,7 @@
 // so the CLI works even when Hub is offline.
 
 import { execFile } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 
@@ -15,6 +15,15 @@ const DEFAULT_REGISTRY_CANDIDATES = [
   ".triflux/synapse/registry.json",
   join(homedir(), ".claude", "cache", "tfx-hub", "synapse-registry.json"),
 ];
+const DEFAULT_SWARM_LOGS_DIR = ".triflux/swarm-logs";
+const STALE_AFTER_MS = 30 * 60 * 1000;
+const STATUS_PRIORITY = {
+  active: 3,
+  running: 3,
+  completed: 2,
+  failed: 2,
+  stale: 1,
+};
 
 function gitExec(args, cwd) {
   return new Promise((res, rej) => {
@@ -55,10 +64,228 @@ function loadRegistrySnapshot(path) {
   }
 }
 
+function parseJsonLines(path) {
+  try {
+    return readFileSync(path, "utf8")
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .flatMap((line) => {
+        try {
+          return [JSON.parse(line)];
+        } catch {
+          return [];
+        }
+      });
+  } catch {
+    return [];
+  }
+}
+
+function normalizeRunId(name) {
+  return String(name || "").replace(/^run-/, "");
+}
+
+function eventTimeMs(event) {
+  const ms = Date.parse(String(event?.ts || ""));
+  return Number.isFinite(ms) ? ms : 0;
+}
+
+function deriveLogStatus(events, lastHeartbeatMs, nowMs) {
+  const stateEvents = events.filter((e) => e.event === "swarm_state");
+  const lastState = stateEvents[stateEvents.length - 1]?.to;
+  if (lastState === "completed" || lastState === "failed") return lastState;
+  if (events.some((e) => e.event === "integration_complete")) {
+    const lastIntegration = [...events]
+      .reverse()
+      .find((e) => e.event === "integration_complete");
+    if (
+      Array.isArray(lastIntegration?.failed) &&
+      lastIntegration.failed.length
+    ) {
+      return "failed";
+    }
+    return "completed";
+  }
+  if (nowMs - lastHeartbeatMs > STALE_AFTER_MS) return "stale";
+  return "active";
+}
+
+function buildLogSession(runDir, nowMs = Date.now()) {
+  const eventPath = join(runDir, "swarm-events.jsonl");
+  if (!existsSync(eventPath)) return null;
+  const events = parseJsonLines(eventPath);
+  if (events.length === 0) return null;
+
+  let statMs = 0;
+  try {
+    statMs = statSync(eventPath).mtimeMs;
+  } catch {}
+
+  const eventMs = events.map(eventTimeMs).filter((ms) => ms > 0);
+  const lastEventMs = eventMs.length ? Math.max(...eventMs) : statMs;
+  const launched = new Set();
+  const completed = new Set();
+  const failed = new Set();
+  for (const event of events) {
+    if (event.event === "shard_launched" && event.shard) {
+      launched.add(event.shard);
+    } else if (event.event === "shard_completed" && event.shard) {
+      completed.add(event.shard);
+    } else if (
+      (event.event === "shard_failed" ||
+        event.event === "shard_launch_failed") &&
+      event.shard
+    ) {
+      failed.add(event.shard);
+    }
+  }
+
+  const runId = normalizeRunId(runDir.split(/[\\/]/).pop());
+  const totalShards = launched.size || completed.size + failed.size;
+  const aliveWorkers = [...launched].filter(
+    (name) => !completed.has(name) && !failed.has(name),
+  ).length;
+
+  return {
+    sessionId: runId,
+    runId,
+    host: "-",
+    branch: "-",
+    dirtyFiles: [],
+    status: deriveLogStatus(events, lastEventMs || nowMs, nowMs),
+    taskSummary: "swarm log run",
+    source: "logs",
+    shards: totalShards ? `${completed.size}/${totalShards}` : "-",
+    workers: totalShards ? `${aliveWorkers} alive` : "-",
+    lastHeartbeat: lastEventMs || null,
+    logDir: runDir,
+  };
+}
+
+export function loadSwarmLogSessions(logsDir, opts = {}) {
+  const nowMs = opts.nowMs ?? Date.now();
+  const root = logsDir || DEFAULT_SWARM_LOGS_DIR;
+  if (!existsSync(root)) return [];
+  try {
+    return readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.startsWith("run-"))
+      .map((entry) => buildLogSession(join(root, entry.name), nowMs))
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function statusPriority(status) {
+  return STATUS_PRIORITY[status] || 0;
+}
+
+function mergeSession(existing, next) {
+  const status =
+    statusPriority(next.status) > statusPriority(existing.status)
+      ? next.status
+      : existing.status;
+  const source =
+    existing.source && next.source && existing.source !== next.source
+      ? "synapse + logs"
+      : existing.source || next.source || "synapse";
+  return {
+    ...next,
+    ...existing,
+    status,
+    source,
+    shards: next.shards || existing.shards,
+    workers: next.workers || existing.workers,
+    lastHeartbeat: Math.max(
+      Number(existing.lastHeartbeat || 0),
+      Number(next.lastHeartbeat || 0),
+    ),
+    logDir: existing.logDir || next.logDir,
+  };
+}
+
+export function mergeRegistryAndLogSessions(registrySessions, logSessions) {
+  const merged = new Map();
+  for (const session of registrySessions) {
+    const key = String(session.runId || session.sessionId || "");
+    if (!key) continue;
+    merged.set(key, {
+      ...session,
+      source: session.source || "synapse",
+      lastHeartbeat: session.lastHeartbeat || null,
+    });
+  }
+  for (const session of logSessions) {
+    const key = String(session.runId || session.sessionId || "");
+    if (!key) continue;
+    const existing = merged.get(key);
+    merged.set(key, existing ? mergeSession(existing, session) : session);
+  }
+  return [...merged.values()].sort((left, right) => {
+    const rightTs = Number(right.lastHeartbeat || 0);
+    const leftTs = Number(left.lastHeartbeat || 0);
+    return rightTs - leftTs;
+  });
+}
+
+function formatAge(ts, nowMs = Date.now()) {
+  if (!Number.isFinite(Number(ts)) || Number(ts) <= 0) return "-";
+  const seconds = Math.max(0, Math.round((nowMs - Number(ts)) / 1000));
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  return `${hours}h ago`;
+}
+
+function hasSwarmLogFields(sessions) {
+  return sessions.some(
+    (s) =>
+      s.source === "logs" ||
+      s.source === "synapse + logs" ||
+      s.runId ||
+      s.shards ||
+      s.workers,
+  );
+}
+
+function formatSwarmStatus(sessions) {
+  const nowMs = Date.now();
+  const rows = [];
+  rows.push(
+    "RUN_ID                 STATUS     SHARDS   WORKERS  LAST_HEARTBEAT  SOURCE",
+  );
+  rows.push(
+    "─────────────────────  ─────────  ───────  ───────  ──────────────  ──────────────",
+  );
+  for (const s of sessions) {
+    const id = String(s.runId || s.sessionId || "?")
+      .padEnd(21)
+      .slice(0, 21);
+    const status = String(s.status || "active")
+      .padEnd(9)
+      .slice(0, 9);
+    const shards = String(s.shards || "-")
+      .padEnd(7)
+      .slice(0, 7);
+    const workers = String(s.workers || "-")
+      .padEnd(7)
+      .slice(0, 7);
+    const heartbeat = formatAge(s.lastHeartbeat, nowMs).padEnd(14).slice(0, 14);
+    const source = String(s.source || "synapse").slice(0, 20);
+    rows.push(
+      `${id}  ${status}  ${shards}  ${workers}  ${heartbeat}  ${source}`,
+    );
+  }
+  return rows.join("\n");
+}
+
 function formatStatus(sessions) {
   if (!sessions.length) {
     return "no active sessions (synapse-registry empty)";
   }
+  if (hasSwarmLogFields(sessions)) return formatSwarmStatus(sessions);
   const rows = [];
   rows.push("SESSION                HOST    BRANCH    DIRTY   STATE    TASK");
   rows.push(
@@ -84,13 +311,22 @@ function formatStatus(sessions) {
 export async function cmdSynapseStatus(args = [], opts = {}) {
   const jsonOut = args.includes("--json") || opts.json;
   const explicit = extractFlag(args, "--registry");
+  const explicitLogsDir = extractFlag(args, "--logs-dir");
   const path = locateRegistryPath(explicit);
-  const sessions = loadRegistrySnapshot(path);
+  const registrySessions = loadRegistrySnapshot(path);
+  const logsDir = explicitLogsDir || DEFAULT_SWARM_LOGS_DIR;
+  const logSessions = loadSwarmLogSessions(logsDir);
+  const sessions = mergeRegistryAndLogSessions(registrySessions, logSessions);
 
   if (jsonOut) {
     process.stdout.write(
       JSON.stringify(
-        { registry: path, count: sessions.length, sessions },
+        {
+          registry: path,
+          logsDir: existsSync(logsDir) ? logsDir : null,
+          count: sessions.length,
+          sessions,
+        },
         null,
         2,
       ) + "\n",
@@ -98,13 +334,14 @@ export async function cmdSynapseStatus(args = [], opts = {}) {
     return;
   }
 
-  if (!path) {
+  if (!path && logSessions.length === 0) {
     process.stdout.write(
-      "no registry file found (looked for .triflux/synapse-registry.json)\n",
+      "no registry or swarm logs found (looked for .triflux/synapse-registry.json and .triflux/swarm-logs)\n",
     );
     return;
   }
-  process.stdout.write(`registry: ${path}\n`);
+  if (path) process.stdout.write(`registry: ${path}\n`);
+  if (logSessions.length > 0) process.stdout.write(`swarm logs: ${logsDir}\n`);
   process.stdout.write(`${formatStatus(sessions)}\n`);
 }