triflux 10.2.0 → 10.3.0

package/hub/team/swarm-hypervisor.mjs

@@ -10,45 +10,92 @@
 //   F4: File lease violation  → revert worker changes, flag shard as failed
 //   F5: Merge conflict        → retry integration with conflict resolution
 
-import { EventEmitter } from 'node:events';
-import { join } from 'node:path';
-import { mkdirSync, readFileSync, existsSync } from 'node:fs';
-
-import { createConductor, STATES } from './conductor.mjs';
-import { createSwarmLocks } from './swarm-locks.mjs';
-import { createEventLog } from './event-log.mjs';
-import { probeRemoteEnv, resolveRemoteDir } from './remote-session.mjs';
-import { fetchRemoteShard } from './worktree-lifecycle.mjs';
-import { getHostConfig } from '../lib/ssh-command.mjs';
+import { EventEmitter } from "node:events";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getHostConfig } from "../lib/ssh-command.mjs";
+import { createConductor, STATES } from "./conductor.mjs";
+import { ensureConductorRegistry } from "./conductor-registry.mjs";
+import { createEventLog } from "./event-log.mjs";
+import { probeRemoteEnv, resolveRemoteDir } from "./remote-session.mjs";
+import { createSwarmLocks } from "./swarm-locks.mjs";
+import { fetchRemoteShard } from "./worktree-lifecycle.mjs";
+
+let importedCreateRegistry = null;
+let meshRegistryImportError = null;
+try {
+  ({ createRegistry: importedCreateRegistry } = await import(
+    "../../mesh/mesh-registry.mjs"
+  ));
+} catch (err) {
+  meshRegistryImportError = err;
+}
 
 // ── Swarm states ──────────────────────────────────────────────
 
 export const SWARM_STATES = Object.freeze({
-  PLANNING:     'planning',
-  LAUNCHING:    'launching',
-  RUNNING:      'running',
-  INTEGRATING:  'integrating',
-  VALIDATING:   'validating',
-  COMPLETED:    'completed',
-  FAILED:       'failed',
+  PLANNING: "planning",
+  LAUNCHING: "launching",
+  RUNNING: "running",
+  INTEGRATING: "integrating",
+  VALIDATING: "validating",
+  COMPLETED: "completed",
+  FAILED: "failed",
 });
 
 // ── Failure mode classification ───────────────────────────────
 
 const FAILURE_MODES = Object.freeze({
-  F1_CRASH:       'F1_crash',
-  F2_RATE_LIMIT:  'F2_rate_limit',
-  F3_STALL:       'F3_stall',
-  F4_LEASE_VIOLATION: 'F4_lease_violation',
-  F5_MERGE_CONFLICT:  'F5_merge_conflict',
+  F1_CRASH: "F1_crash",
+  F2_RATE_LIMIT: "F2_rate_limit",
+  F3_STALL: "F3_stall",
+  F4_LEASE_VIOLATION: "F4_lease_violation",
+  F5_MERGE_CONFLICT: "F5_merge_conflict",
 });
 
 const FALLBACK_AGENTS = Object.freeze({
-  codex: 'gemini',
-  gemini: 'codex',
-  claude: 'codex',
+  codex: "gemini",
+  gemini: "codex",
+  claude: "codex",
 });
 
+function createNoopRegistry() {
+  return Object.freeze({
+    register() {},
+    unregister() {},
+    discover() {
+      return [];
+    },
+    getAgent() {
+      return null;
+    },
+    listAll() {
+      return [];
+    },
+    clear() {},
+  });
+}
+
+function createSharedRegistry(factory) {
+  if (typeof factory !== "function") {
+    return {
+      registry: createNoopRegistry(),
+      fallbackReason: meshRegistryImportError
+        ? `mesh_import_failed:${meshRegistryImportError.message}`
+        : "mesh_registry_unavailable",
+    };
+  }
+
+  try {
+    return { registry: factory(), fallbackReason: null };
+  } catch (err) {
+    return {
+      registry: createNoopRegistry(),
+      fallbackReason: `mesh_registry_init_failed:${err.message}`,
+    };
+  }
+}
+
 /**
  * Create a swarm hypervisor.
  * @param {object} opts
@@ -72,13 +119,18 @@ export function createSwarmHypervisor(opts) {
     _deps = {},
   } = opts;
 
-  if (!workdir) throw new Error('workdir is required');
-  if (!logsDir) throw new Error('logsDir is required');
+  if (!workdir) throw new Error("workdir is required");
+  if (!logsDir) throw new Error("logsDir is required");
 
   mkdirSync(logsDir, { recursive: true });
+  ensureConductorRegistry();
 
+  const createConductorImpl = _deps.createConductor || createConductor;
+  const createRegistryImpl = _deps.createRegistry || importedCreateRegistry;
   const emitter = new EventEmitter();
-  const eventLog = createEventLog(join(logsDir, 'swarm-events.jsonl'));
+  const eventLog = createEventLog(join(logsDir, "swarm-events.jsonl"));
+  const { registry: sharedRegistry, fallbackReason: meshRegistryFallback } =
+    createSharedRegistry(createRegistryImpl);
 
   let state = SWARM_STATES.PLANNING;
   let plan = null;
@@ -90,16 +142,20 @@ export function createSwarmHypervisor(opts) {
   /** @type {Map<string, { conductor, shardConfig }>} redundant workers for critical shards */
   const redundantWorkers = new Map();
 
-  const results = new Map();     // shardName → validated result
-  const failures = new Map();    // shardName → failure info
+  const results = new Map(); // shardName → validated result
+  const failures = new Map(); // shardName → failure info
+
+  if (meshRegistryFallback) {
+    eventLog.append("mesh_registry_fallback", { reason: meshRegistryFallback });
+  }
 
   // ── State machine ───────────────────────────────────────────
 
-  function setState(next, reason = '') {
+  function setState(next, reason = "") {
     const prev = state;
     state = next;
-    eventLog.append('swarm_state', { from: prev, to: next, reason });
-    emitter.emit('stateChange', { from: prev, to: next, reason });
+    eventLog.append("swarm_state", { from: prev, to: next, reason });
+    emitter.emit("stateChange", { from: prev, to: next, reason });
   }
 
   // ── Worker lifecycle ────────────────────────────────────────
@@ -130,7 +186,10 @@ export function createSwarmHypervisor(opts) {
   }
 
   function launchShard(shard, isRedundant = false) {
-    const shardLogsDir = join(logsDir, isRedundant ? `${shard.name}-redundant` : shard.name);
+    const shardLogsDir = join(
+      logsDir,
+      isRedundant ? `${shard.name}-redundant` : shard.name,
+    );
     mkdirSync(shardLogsDir, { recursive: true });
 
     // Remote shard: probe environment before conductor creation
@@ -138,24 +197,44 @@ export function createSwarmHypervisor(opts) {
       try {
         shard._remoteEnv = probeRemoteEnv(shard.host);
         if (!shard._remoteEnv.claudePath) {
-          eventLog.append('remote_probe_no_claude', { shard: shard.name, host: shard.host });
-          failures.set(shard.name, { mode: FAILURE_MODES.F1_CRASH, reason: `claude not found on ${shard.host}` });
+          eventLog.append("remote_probe_no_claude", {
+            shard: shard.name,
+            host: shard.host,
+          });
+          failures.set(shard.name, {
+            mode: FAILURE_MODES.F1_CRASH,
+            reason: `claude not found on ${shard.host}`,
+          });
           return null;
         }
-        eventLog.append('remote_probe_ok', { shard: shard.name, host: shard.host, env: shard._remoteEnv });
+        eventLog.append("remote_probe_ok", {
+          shard: shard.name,
+          host: shard.host,
+          env: shard._remoteEnv,
+        });
       } catch (err) {
-        eventLog.append('remote_probe_failed', { shard: shard.name, host: shard.host, error: err.message });
-        failures.set(shard.name, { mode: FAILURE_MODES.F1_CRASH, reason: `remote probe failed: ${err.message}` });
+        eventLog.append("remote_probe_failed", {
+          shard: shard.name,
+          host: shard.host,
+          error: err.message,
+        });
+        failures.set(shard.name, {
+          mode: FAILURE_MODES.F1_CRASH,
+          reason: `remote probe failed: ${err.message}`,
+        });
         return null;
       }
     }
 
-    const conductor = createConductor({
+    const conductor = createConductorImpl({
       logsDir: shardLogsDir,
       maxRestarts,
       graceMs,
       probeOpts,
-      onCompleted: (sessionId) => handleShardCompleted(shard.name, sessionId, isRedundant),
+      meshRegistry: sharedRegistry,
+      enableMesh: true,
+      onCompleted: (sessionId) =>
+        handleShardCompleted(shard.name, sessionId, isRedundant),
     });
 
     const sessionConfig = buildSessionConfig(shard);
@@ -164,7 +243,7 @@ export function createSwarmHypervisor(opts) {
     if (!isRedundant) {
       const leaseResult = lockManager.acquire(shard.name, shard.files);
       if (!leaseResult.ok) {
-        eventLog.append('lease_denied', {
+        eventLog.append("lease_denied", {
           shard: shard.name,
           conflicts: leaseResult.conflicts,
         });
@@ -178,7 +257,7 @@ export function createSwarmHypervisor(opts) {
 
     conductor.spawnSession(sessionConfig);
 
-    eventLog.append('shard_launched', {
+    eventLog.append("shard_launched", {
       shard: shard.name,
       agent: shard.agent,
       sessionId: sessionConfig.id,
@@ -188,7 +267,12 @@ export function createSwarmHypervisor(opts) {
       host: shard.host || null,
     });
 
-    const entry = { conductor, shardConfig: shard, sessionConfig, startedAt: Date.now() };
+    const entry = {
+      conductor,
+      shardConfig: shard,
+      sessionConfig,
+      startedAt: Date.now(),
+    };
 
     if (isRedundant) {
       redundantWorkers.set(shard.name, entry);
@@ -197,7 +281,7 @@ export function createSwarmHypervisor(opts) {
     }
 
     // Listen for dead events (F1/F2/F3)
-    conductor.on('dead', ({ sessionId, reason }) => {
+    conductor.on("dead", ({ sessionId, reason }) => {
       handleShardFailed(shard.name, sessionId, reason, isRedundant);
     });
 
@@ -207,31 +291,35 @@ export function createSwarmHypervisor(opts) {
   // ── Completion handling ─────────────────────────────────────
 
   function handleShardCompleted(shardName, sessionId, isRedundant) {
-    eventLog.append('shard_completed', { shard: shardName, sessionId, isRedundant });
+    eventLog.append("shard_completed", {
+      shard: shardName,
+      sessionId,
+      isRedundant,
+    });
 
     if (isRedundant) {
       // Redundant worker completed first — kill primary if still running
       const primary = workers.get(shardName);
       if (primary && !isTerminal(primary)) {
-        eventLog.append('redundant_wins', { shard: shardName });
-        void primary.conductor.shutdown('redundant_completed_first');
+        eventLog.append("redundant_wins", { shard: shardName });
+        void primary.conductor.shutdown("redundant_completed_first");
       }
     } else {
       // Primary completed — kill redundant if exists
       const redundant = redundantWorkers.get(shardName);
       if (redundant) {
-        void redundant.conductor.shutdown('primary_completed_first');
+        void redundant.conductor.shutdown("primary_completed_first");
       }
     }
 
-    emitter.emit('shardCompleted', { shardName, sessionId, isRedundant });
+    emitter.emit("shardCompleted", { shardName, sessionId, isRedundant });
     checkAllShardsCompleted();
   }
 
   function handleShardFailed(shardName, sessionId, reason, isRedundant) {
     const failureMode = classifyFailure(reason);
 
-    eventLog.append('shard_failed', {
+    eventLog.append("shard_failed", {
       shard: shardName,
       sessionId,
       reason,
@@ -247,7 +335,7 @@ export function createSwarmHypervisor(opts) {
       if (shard) {
         const fallbackAgent = FALLBACK_AGENTS[shard.agent];
         if (fallbackAgent) {
-          eventLog.append('fallback_agent', {
+          eventLog.append("fallback_agent", {
             shard: shardName,
             from: shard.agent,
             to: fallbackAgent,
@@ -263,7 +351,7 @@ export function createSwarmHypervisor(opts) {
     failures.set(shardName, { mode: failureMode, reason, sessionId });
     lockManager.release(shardName);
 
-    emitter.emit('shardFailed', { shardName, failureMode, reason });
+    emitter.emit("shardFailed", { shardName, failureMode, reason });
     checkAllShardsCompleted();
   }
 
@@ -279,7 +367,9 @@ export function createSwarmHypervisor(opts) {
 
   function isTerminal(entry) {
     const snap = entry.conductor.getSnapshot();
-    return snap.every((s) => s.state === STATES.COMPLETED || s.state === STATES.DEAD);
+    return snap.every(
+      (s) => s.state === STATES.COMPLETED || s.state === STATES.DEAD,
+    );
   }
 
   // ── Integration ─────────────────────────────────────────────
@@ -306,7 +396,7 @@ export function createSwarmHypervisor(opts) {
   function validateResult(shardName, changedFiles) {
     const violations = lockManager.validateChanges(shardName, changedFiles);
 
-    eventLog.append('validate_result', {
+    eventLog.append("validate_result", {
       shard: shardName,
       changedFiles,
       violations,
@@ -324,14 +414,14 @@ export function createSwarmHypervisor(opts) {
    * Uses git operations for conflict detection.
    */
   async function integrateResults() {
-    setState(SWARM_STATES.INTEGRATING, 'all_shards_done');
+    setState(SWARM_STATES.INTEGRATING, "all_shards_done");
 
     const integrated = [];
     const integrationFailures = [];
 
     for (const shardName of plan.mergeOrder) {
       if (failures.has(shardName)) {
-        eventLog.append('skip_failed_shard', { shard: shardName });
+        eventLog.append("skip_failed_shard", { shard: shardName });
         continue;
       }
 
@@ -343,7 +433,10 @@ export function createSwarmHypervisor(opts) {
       if (shard?.host && shard._remoteEnv) {
         const hostConfig = getHostConfig(shard.host, config.rootDir);
         const sshUser = hostConfig?.ssh_user || shard.host;
-        const remoteRepoPath = resolveRemoteDir(config.rootDir || process.cwd(), shard._remoteEnv);
+        const remoteRepoPath = resolveRemoteDir(
+          config.rootDir || process.cwd(),
+          shard._remoteEnv,
+        );
         const fetchResult = await fetchRemoteShard({
           host: shard.host,
           sshUser,
@@ -353,11 +446,17 @@ export function createSwarmHypervisor(opts) {
         });
 
         if (!fetchResult.ok) {
-          eventLog.append('remote_fetch_failed', { shard: shardName, error: fetchResult.error });
+          eventLog.append("remote_fetch_failed", {
+            shard: shardName,
+            error: fetchResult.error,
+          });
           integrationFailures.push(shardName);
           continue;
         }
-        eventLog.append('remote_fetch_ok', { shard: shardName, headCommit: fetchResult.headCommit });
+        eventLog.append("remote_fetch_ok", {
+          shard: shardName,
+          headCommit: fetchResult.headCommit,
+        });
       }
 
       // Read shard output log for changed files
@@ -370,7 +469,7 @@ export function createSwarmHypervisor(opts) {
           mode: FAILURE_MODES.F4_LEASE_VIOLATION,
           violations: validation.violations,
         });
-        eventLog.append('lease_violation_revert', {
+        eventLog.append("lease_violation_revert", {
           shard: shardName,
           violations: validation.violations,
         });
@@ -386,19 +485,24 @@ export function createSwarmHypervisor(opts) {
       integrated.push(shardName);
     }
 
-    eventLog.append('integration_complete', {
+    eventLog.append("integration_complete", {
       integrated,
       failed: integrationFailures,
-      skipped: [...failures.keys()].filter((n) => !integrationFailures.includes(n)),
+      skipped: [...failures.keys()].filter(
+        (n) => !integrationFailures.includes(n),
+      ),
     });
 
     if (integrationFailures.length > 0 && integrated.length === 0) {
-      setState(SWARM_STATES.FAILED, 'all_shards_failed_integration');
+      setState(SWARM_STATES.FAILED, "all_shards_failed_integration");
     } else {
-      setState(SWARM_STATES.COMPLETED, `${integrated.length}/${plan.shards.length} integrated`);
+      setState(
+        SWARM_STATES.COMPLETED,
+        `${integrated.length}/${plan.shards.length} integrated`,
+      );
     }
 
-    emitter.emit('integrationComplete', {
+    emitter.emit("integrationComplete", {
       integrated,
       failed: integrationFailures,
       results: [...results.values()],
@@ -419,11 +523,16 @@ export function createSwarmHypervisor(opts) {
       const snap = worker.conductor.getSnapshot();
       for (const session of snap) {
         if (session.outPath && existsSync(session.outPath)) {
-          const output = readFileSync(session.outPath, 'utf8');
-          return extractFilePathsFromOutput(output, plan.leaseMap.get(shardName) || []);
+          const output = readFileSync(session.outPath, "utf8");
+          return extractFilePathsFromOutput(
+            output,
+            plan.leaseMap.get(shardName) || [],
+          );
         }
       }
-    } catch { /* best-effort */ }
+    } catch {
+      /* best-effort */
+    }
 
     // Fallback: trust the lease map (shard was allowed these files)
     return plan.leaseMap.get(shardName) || [];
@@ -446,8 +555,8 @@ export function createSwarmHypervisor(opts) {
       // Match common patterns
       const patterns = [
         /(?:wrote|created|modified|updated|edited)\s+['"]?([^\s'"]+\.\w+)/i,
-        /^[+-]{3}\s+[ab]\/(.+)/,           // diff headers
-        /^diff --git a\/(.+)\s+b\//,        // git diff headers
+        /^[+-]{3}\s+[ab]\/(.+)/, // diff headers
+        /^diff --git a\/(.+)\s+b\//, // git diff headers
       ];
 
       for (const re of patterns) {
@@ -458,9 +567,9 @@ export function createSwarmHypervisor(opts) {
 
     // Intersect with allowed files if we found anything
     if (found.size > 0) {
-      return [...found].filter((f) => allowedFiles.some(
-        (a) => f.endsWith(a) || a.endsWith(f) || f === a,
-      ));
+      return [...found].filter((f) =>
+        allowedFiles.some((a) => f.endsWith(a) || a.endsWith(f) || f === a),
+      );
     }
 
     return allowedFiles;
@@ -515,9 +624,9 @@ export function createSwarmHypervisor(opts) {
 
     // Warn about file conflicts but don't block
     if (plan.conflicts.length > 0) {
-      eventLog.append('file_conflicts_warning', { conflicts: plan.conflicts });
-      emitter.emit('warning', {
-        type: 'file_conflicts',
+      eventLog.append("file_conflicts_warning", { conflicts: plan.conflicts });
+      emitter.emit("warning", {
+        type: "file_conflicts",
         conflicts: plan.conflicts,
       });
     }
@@ -525,7 +634,7 @@ export function createSwarmHypervisor(opts) {
     // Initialize lock manager
     lockManager = createSwarmLocks({
       repoRoot: workdir,
-      persistPath: join(workdir, '.triflux', 'swarm-locks.json'),
+      persistPath: join(workdir, ".triflux", "swarm-locks.json"),
     });
 
     setState(SWARM_STATES.LAUNCHING, `${plan.shards.length} shards`);
@@ -561,11 +670,14 @@ export function createSwarmHypervisor(opts) {
     launchReady();
 
     // Re-check pending on each shard completion (dependency chains)
-    emitter.on('shardCompleted', () => {
+    emitter.on("shardCompleted", () => {
       if (pending.size > 0) launchReady();
     });
 
-    setState(SWARM_STATES.RUNNING, `${launched.size} launched, ${pending.size} pending deps`);
+    setState(
+      SWARM_STATES.RUNNING,
+      `${launched.size} launched, ${pending.size} pending deps`,
+    );
 
     return getStatus();
   }
@@ -574,8 +686,8 @@ export function createSwarmHypervisor(opts) {
    * Graceful shutdown — kill all workers and release locks.
    * @param {string} [reason]
    */
-  async function shutdown(reason = 'shutdown') {
-    eventLog.append('swarm_shutdown', { reason, state });
+  async function shutdown(reason = "shutdown") {
+    eventLog.append("swarm_shutdown", { reason, state });
 
     const shutdowns = [];
     for (const [, w] of workers) {
@@ -587,6 +699,7 @@ export function createSwarmHypervisor(opts) {
 
     await Promise.allSettled(shutdowns);
 
+    sharedRegistry.clear();
     lockManager?.releaseAll();
     await eventLog.flush();
     await eventLog.close();
@@ -595,18 +708,27 @@ export function createSwarmHypervisor(opts) {
       setState(SWARM_STATES.FAILED, reason);
     }
 
-    emitter.emit('shutdown', { reason });
+    emitter.emit("shutdown", { reason });
   }
 
   return Object.freeze({
     launch,
     shutdown,
     getStatus,
+    getMeshRegistry() {
+      return sharedRegistry;
+    },
     validateResult,
     on: emitter.on.bind(emitter),
     off: emitter.off.bind(emitter),
-    get state() { return state; },
-    get plan() { return plan; },
-    get eventLogPath() { return eventLog.filePath; },
+    get state() {
+      return state;
+    },
+    get plan() {
+      return plan;
+    },
+    get eventLogPath() {
+      return eventLog.filePath;
+    },
   });
 }

package/hub/team/tui-lite.mjs

@@ -128,7 +128,7 @@ function buildHeader(width, names, workers, pipeline, startedAt) {
     else if (status === "running" || status === "in_progress") counts.running++;
   }
   const elapsed = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
-  const line1 = color(` triflux ${VERSION} `, FG.black, BG.header)
+  const line1 = color(` triflux ${VERSION} `, FG.white, BG.header)
     + ` ${bold(`phase ${pipeline.phase || "exec"}`)}`
     + ` ${dim(`+${elapsed}s`)} ${names.length} workers`;
   const line2 = `${color(`ok ${counts.ok}`, MOCHA.ok)}  ${color(`partial ${counts.partial}`, MOCHA.partial)}  ${color(`failed ${counts.failed}`, MOCHA.fail)}  ${color(`running ${counts.running}`, MOCHA.executing)}`;
@@ -210,6 +210,7 @@ export function createLiteDashboard(opts = {}) {
   let focusTab = "log";
   let helpVisible = false;
   let prevFrame = [];
+  let prevWidth = 0;
   let inputAttached = false;
   let rawModeEnabled = false;
 
@@ -264,7 +265,14 @@ export function createLiteDashboard(opts = {}) {
       return;
     }
     if (key === "\r" || key === "\n") {
-      triggerOpenSelected();
+      if (typeof onOpenSelectedWorker !== "function") {
+        // 콜백 없으면 탭 순환 (기본 동작)
+        const tabs = ["log", "detail", "files"];
+        focusTab = tabs[(tabs.indexOf(focusTab) + 1) % tabs.length];
+      } else {
+        triggerOpenSelected();
+      }
+      render();
       return;
     }
     if (key === "\x1b[13;2u" || key === "\x1b[27;13;2~" || key === "\x1b\r" || key === "\x1b\n") {
@@ -339,6 +347,13 @@ export function createLiteDashboard(opts = {}) {
     if (isTTY) {
       const width = viewportColumns();
       const padded = rowsOut.map((line) => padRight(String(line ?? ""), width));
+      // Full redraw on first frame or terminal resize to avoid artifacts
+      if (prevFrame.length === 0 || width !== prevWidth) {
+        prevWidth = width;
+        write(cursorHome + padded.map((l) => l + clearToEnd).join("\n") + eraseBelow);
+        prevFrame = padded;
+        return;
+      }
       // Diff-based rendering: only rewrite lines that actually changed
       let buf = "";
       for (let i = 0; i < padded.length; i++) {
@@ -361,6 +376,7 @@ export function createLiteDashboard(opts = {}) {
     if (rawModeEnabled && typeof input?.setRawMode === "function") input.setRawMode(false);
     if (inputAttached && typeof input?.pause === "function") input.pause();
     if (isTTY) write(cursorShow + altScreenOff);
+    prevFrame = [];
     closed = true;
   }
 

package/hub/token-mode.mjs

@@ -2,6 +2,7 @@
 // GAP 분석 P2 #7: 심볼 통신 + 약어로 30-50% 토큰 절감
 
 /**
+ * @experimental 런타임 미연결 — 향후 통합 예정
  * @experimental
  * @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>}
  */