@triflux/remote 10.0.0 → 10.1.0

package/hub/index.mjs

@@ -14,8 +14,8 @@ export { createPsmuxSession, startCapture } from './team/psmux.mjs';
 export { createConductor } from './team/conductor.mjs';
 
 // Swarm
-export { createSwarmLocks } from '../../../hub/team/swarm-locks.mjs';
-export { parseShards, buildFileLeaseMap, buildMcpManifest, computeMergeOrder, planSwarm } from '../../../hub/team/swarm-planner.mjs';
-export { createSwarmHypervisor, SWARM_STATES } from '../../../hub/team/swarm-hypervisor.mjs';
-export { reconcile, buildRedundantIds, shouldRunRedundant } from '../../../hub/team/swarm-reconciler.mjs';
-export { ensureWorktree, prepareIntegrationBranch, rebaseShardOntoIntegration, pruneWorktree } from '../../../hub/team/worktree-lifecycle.mjs';
+export { createSwarmLocks } from './team/swarm-locks.mjs';
+export { parseShards, buildFileLeaseMap, buildMcpManifest, computeMergeOrder, planSwarm } from './team/swarm-planner.mjs';
+export { createSwarmHypervisor, SWARM_STATES } from './team/swarm-hypervisor.mjs';
+export { reconcile, buildRedundantIds, shouldRunRedundant } from './team/swarm-reconciler.mjs';
+export { ensureWorktree, prepareIntegrationBranch, rebaseShardOntoIntegration, pruneWorktree, fetchRemoteShard } from './team/worktree-lifecycle.mjs';

package/hub/public/dashboard.html

@@ -42,7 +42,7 @@ body{background:#0d1117;color:#c9d1d9;font-family:system-ui,-apple-system,sans-s
 .token-item .calls{font-size:.78rem;color:#8b949e;margin-top:2px}
 
 .chart-wrap{position:relative;width:100%;height:160px}
-.chart-wrap canvas{width:100%!important;height:100%!important}
+.chart-wrap canvas{width:100%;height:100%}
 .chart-legend{display:flex;gap:14px;margin-top:8px;font-size:.78rem;color:#8b949e}
 .legend-dot{width:8px;height:8px;border-radius:50%;display:inline-block;margin-right:4px;vertical-align:middle}
 
@@ -152,7 +152,7 @@ body{background:#0d1117;color:#c9d1d9;font-family:system-ui,-apple-system,sans-s
   function remain(rt) {
     if (!rt) return '';
     var ts = typeof rt === 'number' && rt < 1e10 ? rt * 1000 : new Date(rt).getTime();
-    if (!isFinite(ts)) return '';
+    if (!Number.isFinite(ts)) return '';
     var ms = ts - Date.now();
     if (ms <= 0) return '만료됨';
     var h = Math.floor(ms / 3600000);
@@ -199,7 +199,7 @@ body{background:#0d1117;color:#c9d1d9;font-family:system-ui,-apple-system,sans-s
     var s = '';
 
     // Claude
-    var cl = d.claude && d.claude.data;
+    var cl = d.claude?.data;
     if (cl) {
       s += quotaBlock('Claude (c)', '#d19a66', [
         ['5시간', cl.fiveHourPercent || 0],
@@ -208,16 +208,16 @@ body{background:#0d1117;color:#c9d1d9;font-family:system-ui,-apple-system,sans-s
     }
 
     // Codex
-    var cx2 = d.codex && d.codex.buckets && d.codex.buckets.codex;
+    var cx2 = d.codex?.buckets?.codex;
     if (cx2) {
       s += quotaBlock('Codex (x)', '#ffffff', [
         ['Primary', cx2.primary ? cx2.primary.used_percent || 0 : 0],
         ['Secondary', cx2.secondary ? cx2.secondary.used_percent || 0 : 0]
-      ], cx2.primary && cx2.primary.resets_at);
+      ], cx2.primary?.resets_at);
     }
 
     // Gemini
-    var gm = d.gemini && d.gemini.buckets;
+    var gm = d.gemini?.buckets;
     if (gm && gm.length > 0) {
       var frac = gm[0].remainingFraction;
       s += quotaBlock('Gemini (g)', '#61afef', [
@@ -330,7 +330,7 @@ body{background:#0d1117;color:#c9d1d9;font-family:system-ui,-apple-system,sans-s
         gauge(data.aimd ? data.aimd.batchSize : 0);
         renderQuota(data);
 
-        cachedEvents = (data.aimd && data.aimd.events) || [];
+        cachedEvents = (data.aimd?.events) || [];
         drawEvents(cachedEvents);
 
         renderTokens(data.accumulator);

package/hub/server.mjs

@@ -63,6 +63,53 @@ const STATIC_CONTENT_TYPES = Object.freeze({
 // Each entry is an array of request timestamps within the current window.
 const rateLimitMap = new Map();
 
+function formatHostForUrl(host = '127.0.0.1') {
+  return String(host).includes(':') ? `[${host}]` : host;
+}
+
+function buildHubUrl(host, port) {
+  return `http://${formatHostForUrl(host || '127.0.0.1')}:${port}/mcp`;
+}
+
+function isPidAlive(pid, killFn = process.kill) {
+  const resolvedPid = Number(pid);
+  if (!Number.isFinite(resolvedPid) || resolvedPid <= 0) return false;
+  try {
+    killFn(resolvedPid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function tryReuseExistingHub({
+  port,
+  host = '127.0.0.1',
+  readCurrentState = readState,
+  readInfo = getHubInfo,
+  checkHealth = isServerHealthy,
+  killFn = process.kill,
+} = {}) {
+  const existing = readCurrentState();
+  const existingPort = Number(existing?.port);
+  if (!isPidAlive(existing?.pid, killFn) || !Number.isFinite(existingPort) || existingPort <= 0) {
+    return null;
+  }
+  if (Number.isFinite(Number(port)) && existingPort !== Number(port)) return null;
+  if (!(await checkHealth(existingPort))) return null;
+
+  const info = readInfo() ?? existing;
+  const infoHost = typeof info?.host === 'string' ? info.host : host;
+  return {
+    reused: true,
+    external: true,
+    port: existingPort,
+    pid: Number(existing.pid),
+    url: info?.url ?? buildHubUrl(infoHost, existingPort),
+    stop: async () => false,
+  };
+}
+
 function checkRateLimit(ip) {
   const now = Date.now();
   const cutoff = now - RATE_LIMIT_WINDOW_MS;
@@ -314,24 +361,8 @@ export async function startHub({
 } = {}) {
   const port = portOpt ?? parseInt(process.env.TFX_HUB_PORT || '27888', 10);
 
-  // Singleton reuse: if a healthy hub is already running on the target port, return a lightweight handle
-  const existingState = readState();
-  if (existingState?.pid && Number(existingState.port) === Number(port)) {
-    const pidAlive = (() => {
-      try { process.kill(Number(existingState.pid), 0); return true; } catch { return false; }
-    })();
-    if (pidAlive && await isServerHealthy(port)) {
-      const existingInfo = getHubInfo();
-      return {
-        reused: true,
-        external: true,
-        port: Number(port),
-        pid: Number(existingState.pid),
-        url: existingInfo?.url ?? `http://${host}:${port}/mcp`,
-        stop: async () => false,
-      };
-    }
-  }
+  const existingHub = await tryReuseExistingHub({ port, host });
+  if (existingHub) return existingHub;
 
   const hubIdleTimeoutMs = parsePositiveInt(process.env.TFX_HUB_IDLE_TIMEOUT_MS, HUB_IDLE_TIMEOUT_DEFAULT_MS);
   const hubIdleSweepMs = parsePositiveInt(
@@ -365,6 +396,12 @@ export async function startHub({
     lockHeld = false;
   };
 
+  const lockedExistingHub = await tryReuseExistingHub({ port, host });
+  if (lockedExistingHub) {
+    releaseStartupLock();
+    return lockedExistingHub;
+  }
+
   const HUB_TOKEN = process.env.TFX_HUB_TOKEN?.trim() || null;
   if (HUB_TOKEN) {
     mkdirSync(join(homedir(), '.claude'), { recursive: true });
@@ -381,6 +418,29 @@ export async function startHub({
   const adaptiveEngine = createAdaptiveEngine({ repoRoot: PROJECT_ROOT, fingerprintService });
   adaptiveEngine.startSession();
 
+  // safety-guard → reflexion 패널티 승격 + 적응형 규칙 유지보수
+  const projectSlug = PROJECT_ROOT.split(/[\\/]/).pop();
+  try {
+    const { promotePenalties } = await import("./promote-penalties.mjs");
+    const result = promotePenalties(store, { projectSlug });
+    if (result.promoted > 0) {
+      console.log(`[reflexion] ${result.promoted} penalties promoted to adaptive rules`);
+    }
+  } catch { /* promote-penalties 실패는 Hub 시작을 막지 않음 */ }
+
+  // stale adaptive_rules 정리 (30일 초과 + confidence 0.2 미만)
+  try {
+    const pruned = store.pruneStaleRules();
+    if (pruned > 0) console.log(`[reflexion] ${pruned} stale adaptive rules pruned`);
+  } catch { /* prune 실패 무시 */ }
+
+  // adaptive rule confidence decay (7일 이상 미관측 규칙 -0.1 감소)
+  try {
+    const { decayRules } = await import("./reflexion.mjs");
+    const decay = decayRules(store, adaptiveEngine.sessionCount?.() || 1, projectSlug);
+    if (decay.deleted.length > 0) console.log(`[reflexion] ${decay.deleted.length} low-confidence rules removed`);
+  } catch { /* decay 실패 무시 */ }
+
   // Delegator MCP resident service 초기화
   const delegatorWorker = createDelegatorWorker({ cwd: PROJECT_ROOT });
   try {
@@ -1019,7 +1079,7 @@ export async function startHub({
           pid: process.pid,
           hubToken: HUB_TOKEN,
           authMode: HUB_TOKEN ? 'token-required' : 'localhost-only',
-          url: `http://${host}:${port}/mcp`,
+          url: buildHubUrl(host, port),
           pipe_path: pipe.path,
           pipePath: pipe.path,
           assign_callback_pipe_path: assignCallbacks.path,
@@ -1029,7 +1089,7 @@ export async function startHub({
           idleTimeoutMs: hubIdleTimeoutMs,
         };
 
-        writeFileSync(PID_FILE, JSON.stringify({
+        writeState({
           pid: process.pid,
           port,
           host,
@@ -1038,16 +1098,13 @@ export async function startHub({
           pipe_path: pipe.path,
           pipePath: pipe.path,
           assign_callback_pipe_path: assignCallbacks.path,
+          assignCallbackPipePath: assignCallbacks.path,
+          authMode: HUB_TOKEN ? 'token-required' : 'localhost-only',
+          startedAt,
           started: startedAtMs,
           version,
-          session_id: sessionId,
-        }));
-        writeState({
-          pid: process.pid,
-          port,
-          version,
           sessionId,
-          startedAt,
+          session_id: sessionId,
         });
         releaseStartupLock();
 
@@ -1128,12 +1185,7 @@ export async function startHub({
 }
 
 export function getHubInfo() {
-  if (!existsSync(PID_FILE)) return null;
-  try {
-    return JSON.parse(readFileSync(PID_FILE, 'utf8'));
-  } catch {
-    return null;
-  }
+  return readState();
 }
 
 /**
@@ -1146,29 +1198,19 @@ export function getHubInfo() {
  */
 export async function getOrCreateServer(opts = {}) {
   const { _deps, ...startOpts } = opts;
-  const checkHealth = _deps?.isHealthy ?? isServerHealthy;
-  const readInfo = _deps?.getInfo ?? getHubInfo;
-  const readCurrentState = _deps?.readState ?? readState;
+  const existingHub = await tryReuseExistingHub({
+    port: startOpts.port,
+    host: startOpts.host,
+    checkHealth: _deps?.isHealthy ?? isServerHealthy,
+    readInfo: _deps?.getInfo ?? getHubInfo,
+    readCurrentState: _deps?.readState ?? readState,
+  });
   const boot = _deps?.startHub ?? startHub;
 
-  const existing = readCurrentState();
-  if (existing?.pid && existing?.port) {
-    const pidAlive = (() => {
-      try { process.kill(Number(existing.pid), 0); return true; } catch { return false; }
-    })();
-
-    if (pidAlive && await checkHealth(existing.port)) {
-      return {
-        reused: true,
-        port: existing.port,
-        pid: existing.pid,
-        url: readInfo()?.url ?? `http://127.0.0.1:${existing.port}/mcp`,
-      };
-    }
-  }
+  if (existingHub) return existingHub;
 
   const server = await boot(startOpts);
-  return { reused: false, ...server };
+  return server.reused === true ? server : { reused: false, ...server };
 }
 
 /**

package/hub/store-adapter.mjs

@@ -15,23 +15,35 @@ export { createMemoryStore };
 function ensureAdaptiveRulesSchema(db) {
   const schemaKey = 'adaptive_rules_schema_version';
   const currentVersion = db.prepare('SELECT value FROM _meta WHERE key = ?').pluck().get(schemaKey);
-  if (currentVersion === '1') return;
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS adaptive_rules (
-      project_slug TEXT NOT NULL,
-      pattern TEXT NOT NULL,
-      confidence REAL NOT NULL DEFAULT 0.5,
-      hit_count INTEGER NOT NULL DEFAULT 1,
-      last_seen_ms INTEGER NOT NULL,
-      created_ms INTEGER NOT NULL,
-      PRIMARY KEY (project_slug, pattern)
-    );
-    CREATE INDEX IF NOT EXISTS idx_adaptive_rules_last_seen
-      ON adaptive_rules(project_slug, last_seen_ms DESC);
-    CREATE INDEX IF NOT EXISTS idx_adaptive_rules_confidence
-      ON adaptive_rules(project_slug, confidence DESC);
-  `);
-  db.prepare('INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)').run(schemaKey, '1');
+  if (currentVersion === '2') return;
+  if (!currentVersion) {
+    // 신규 생성
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS adaptive_rules (
+        project_slug TEXT NOT NULL,
+        pattern TEXT NOT NULL,
+        confidence REAL NOT NULL DEFAULT 0.5,
+        hit_count INTEGER NOT NULL DEFAULT 1,
+        last_seen_ms INTEGER NOT NULL,
+        created_ms INTEGER NOT NULL,
+        error_message TEXT,
+        solution TEXT,
+        context TEXT,
+        PRIMARY KEY (project_slug, pattern)
+      );
+      CREATE INDEX IF NOT EXISTS idx_adaptive_rules_last_seen
+        ON adaptive_rules(project_slug, last_seen_ms DESC);
+      CREATE INDEX IF NOT EXISTS idx_adaptive_rules_confidence
+        ON adaptive_rules(project_slug, confidence DESC);
+    `);
+  } else {
+    // v1 → v2 마이그레이션: 컬럼 추가
+    const cols = db.pragma('table_info(adaptive_rules)').map(c => c.name);
+    if (!cols.includes('error_message')) db.exec('ALTER TABLE adaptive_rules ADD COLUMN error_message TEXT');
+    if (!cols.includes('solution')) db.exec('ALTER TABLE adaptive_rules ADD COLUMN solution TEXT');
+    if (!cols.includes('context')) db.exec('ALTER TABLE adaptive_rules ADD COLUMN context TEXT');
+  }
+  db.prepare('INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)').run(schemaKey, '2');
 }
 
 function attachAdaptiveRuleStore(store) {
@@ -40,15 +52,20 @@ function attachAdaptiveRuleStore(store) {
   const statements = {
     upsertRule: store.db.prepare(`
       INSERT INTO adaptive_rules (
-        project_slug, pattern, confidence, hit_count, last_seen_ms, created_ms
+        project_slug, pattern, confidence, hit_count, last_seen_ms, created_ms,
+        error_message, solution, context
       ) VALUES (
-        @project_slug, @pattern, @confidence, @hit_count, @last_seen_ms, @created_ms
+        @project_slug, @pattern, @confidence, @hit_count, @last_seen_ms, @created_ms,
+        @error_message, @solution, @context
       )
       ON CONFLICT(project_slug, pattern) DO UPDATE SET
         confidence = excluded.confidence,
         hit_count = excluded.hit_count,
         last_seen_ms = excluded.last_seen_ms,
-        created_ms = MIN(adaptive_rules.created_ms, excluded.created_ms)`),
+        created_ms = MIN(adaptive_rules.created_ms, excluded.created_ms),
+        error_message = COALESCE(excluded.error_message, adaptive_rules.error_message),
+        solution = COALESCE(excluded.solution, adaptive_rules.solution),
+        context = COALESCE(excluded.context, adaptive_rules.context)`),
     getRule: store.db.prepare('SELECT * FROM adaptive_rules WHERE project_slug = ? AND pattern = ?'),
     updateRule: store.db.prepare(`
       UPDATE adaptive_rules SET
@@ -93,6 +110,20 @@ function attachAdaptiveRuleStore(store) {
     return statements.pruneRules.run(cutoff, minConfidence).changes;
   };
 
+  // listAdaptiveRules: decayRules/getActiveAdaptiveRules에서 사용
+  const listStmt = store.db.prepare('SELECT * FROM adaptive_rules WHERE project_slug = ? ORDER BY confidence DESC');
+  const listAllStmt = store.db.prepare('SELECT * FROM adaptive_rules ORDER BY confidence DESC');
+  const deleteRuleStmt = store.db.prepare('DELETE FROM adaptive_rules WHERE project_slug = ? AND pattern = ?');
+
+  store.listAdaptiveRules = function listAdaptiveRules(projectSlug) {
+    if (projectSlug) return listStmt.all(projectSlug).map(clone);
+    return listAllStmt.all().map(clone);
+  };
+
+  store.deleteAdaptiveRule = function deleteAdaptiveRule(projectSlug, pattern) {
+    return deleteRuleStmt.run(projectSlug, pattern).changes > 0;
+  };
+
   return store;
 }
 

package/hub/store.mjs

@@ -551,7 +551,7 @@ export function createStore(dbPath, options = {}) {
         ttl_ms: clampDuration(patch.ttl_ms ?? current.ttl_ms, current.ttl_ms || nextTimeout),
         timeout_ms: nextTimeout,
         deadline_ms: (() => {
-          if (Object.prototype.hasOwnProperty.call(patch, 'deadline_ms')) {
+          if (Object.hasOwn(patch, 'deadline_ms')) {
             return patch.deadline_ms == null ? null : Math.trunc(Number(patch.deadline_ms));
           }
           if (isTerminal) return null;
@@ -560,23 +560,23 @@ export function createStore(dbPath, options = {}) {
         })(),
         trace_id: patch.trace_id ?? current.trace_id,
         correlation_id: patch.correlation_id ?? current.correlation_id,
-        last_message_id: Object.prototype.hasOwnProperty.call(patch, 'last_message_id')
+        last_message_id: Object.hasOwn(patch, 'last_message_id')
           ? patch.last_message_id
           : current.last_message_id,
-        result_json: Object.prototype.hasOwnProperty.call(patch, 'result')
+        result_json: Object.hasOwn(patch, 'result')
           ? (patch.result == null ? null : JSON.stringify(patch.result))
           : (current.result == null ? null : JSON.stringify(current.result)),
-        error_json: Object.prototype.hasOwnProperty.call(patch, 'error')
+        error_json: Object.hasOwn(patch, 'error')
           ? (patch.error == null ? null : JSON.stringify(patch.error))
           : (current.error == null ? null : JSON.stringify(current.error)),
         updated_at_ms: now,
-        started_at_ms: Object.prototype.hasOwnProperty.call(patch, 'started_at_ms')
+        started_at_ms: Object.hasOwn(patch, 'started_at_ms')
           ? patch.started_at_ms
           : (nextStatus === 'running' ? (current.started_at_ms || now) : current.started_at_ms),
-        completed_at_ms: Object.prototype.hasOwnProperty.call(patch, 'completed_at_ms')
+        completed_at_ms: Object.hasOwn(patch, 'completed_at_ms')
           ? patch.completed_at_ms
           : (isTerminal ? (current.completed_at_ms || now) : current.completed_at_ms),
-        last_retry_at_ms: Object.prototype.hasOwnProperty.call(patch, 'last_retry_at_ms')
+        last_retry_at_ms: Object.hasOwn(patch, 'last_retry_at_ms')
           ? patch.last_retry_at_ms
           : current.last_retry_at_ms,
       };
@@ -661,7 +661,7 @@ export function createStore(dbPath, options = {}) {
         started_at_ms: null,
         last_retry_at_ms: Date.now(),
         result: patch.result ?? null,
-        error: Object.prototype.hasOwnProperty.call(patch, 'error') ? patch.error : current.error,
+        error: Object.hasOwn(patch, 'error') ? patch.error : current.error,
         last_message_id: null,
       });
     },

package/hub/team/cli/commands/start/start-headless.mjs

@@ -1,6 +1,6 @@
-import { BOLD, DIM, GREEN, RESET, AMBER } from "../../../shared.mjs";
+import { DIM, GREEN, RESET, AMBER } from "../../../shared.mjs";
 import { runHeadlessInteractive, resolveCliType } from "../../../headless.mjs";
-import { ok, warn } from "../../render.mjs";
+import { ok, } from "../../render.mjs";
 import { buildTasks } from "../../services/task-model.mjs";
 import { clearTeamState } from "../../services/state-store.mjs";
 
@@ -10,7 +10,7 @@ export async function startHeadlessTeam({ sessionId, task, lead, agents, subtask
     ? assigns.map((a, i) => ({ cli: resolveCliType(a.cli), prompt: a.prompt, role: a.role || `worker-${i + 1}`, mcp: mcpProfile, model }))
     : subtasks.map((subtask, i) => ({ cli: resolveCliType(agents[i] || agents[0]), prompt: subtask, role: `worker-${i + 1}`, mcp: mcpProfile, model }));
 
-  const startedAt = Date.now();
+  const _startedAt = Date.now();
   ok(`headless ${assignments.length}워커 시작`);
 
   const handle = await runHeadlessInteractive(sessionId, assignments, {
@@ -46,6 +46,8 @@ export async function startHeadlessTeam({ sessionId, task, lead, agents, subtask
   const failed = results.filter((r) => !r.matched || r.exitCode !== 0);
 
   ok(`헤드리스 완료: ${succeeded.length}성공 / ${failed.length}실패 / ${results.length}전체`);
+  // 머신 파싱용 완료 마커 — background task에서 결과 회수 시점 판단에 사용
+  console.log(`=== HEADLESS_COMPLETE succeeded=${succeeded.length} failed=${failed.length} total=${results.length} ===`);
 
   if (failed.length > 0) {
     for (const r of failed) console.log(`  ${AMBER}✗${RESET} ${r.paneName} (${r.cli}) exit=${r.exitCode}`);

package/hub/team/cli/services/hub-client.mjs

@@ -154,7 +154,7 @@ export async function ensureHubAlive(maxRetries = 3) {
     }
     // 다음 재시도 전 대기: 1초, 2초, 4초 (마지막 시도 후에는 대기 없음)
     if (i < maxRetries - 1) {
-      const backoffMs = Math.pow(2, i) * 1000; // i=0: 1초, i=1: 2초, i=2: 4초
+      const backoffMs = 2 ** i * 1000; // i=0: 1초, i=1: 2초, i=2: 4초
       await new Promise((resolve) => setTimeout(resolve, backoffMs));
     }
   }

package/hub/team/conductor-mesh-bridge.mjs

@@ -0,0 +1,121 @@
+import { createMessage, MSG_TYPES } from "../../mesh/mesh-protocol.mjs";
+
+const BRIDGE_AGENT_ID = "conductor";
+
+/**
+ * Creates a bridge that converts Conductor EventEmitter events
+ * into Mesh protocol messages and keeps the registry in sync.
+ *
+ * @param {object} conductor - A conductor instance (with on/off)
+ * @param {object} registry  - A mesh-registry instance
+ * @param {object} [opts]
+ * @param {string} [opts.bridgeAgentId="conductor"] - Agent ID for the bridge
+ * @param {function} [opts.onMessage] - Called with each generated mesh message
+ * @returns {object} Bridge API
+ */
+export function createConductorMeshBridge(conductor, registry, opts = {}) {
+  const {
+    bridgeAgentId = BRIDGE_AGENT_ID,
+    onMessage,
+  } = opts;
+
+  const sessionAgentMap = new Map();
+  let attached = false;
+
+  function emit(message) {
+    if (typeof onMessage === "function") {
+      onMessage(message);
+    }
+  }
+
+  function agentIdForSession(sessionId) {
+    return `session:${sessionId}`;
+  }
+
+  /**
+   * Handle conductor stateChange events.
+   * - starting → register agent in registry
+   * - terminal states → unregister agent
+   * - all transitions → emit mesh EVENT message
+   */
+  function handleStateChange(event) {
+    const { sessionId, from, to, reason } = event;
+    const agentId = agentIdForSession(sessionId);
+
+    // Register on first starting transition
+    if (to === "starting" && !sessionAgentMap.has(sessionId)) {
+      registry.register(agentId, ["session"]);
+      sessionAgentMap.set(sessionId, agentId);
+    }
+
+    // Emit mesh event
+    const msg = createMessage(
+      MSG_TYPES.EVENT,
+      bridgeAgentId,
+      "*",
+      { event: "stateChange", sessionId, from, to, reason },
+    );
+    emit(msg);
+
+    // Unregister on terminal states
+    if (to === "dead" || to === "completed") {
+      registry.unregister(agentId);
+      sessionAgentMap.delete(sessionId);
+    }
+  }
+
+  /**
+   * Handle conductor completed events.
+   */
+  function handleCompleted(event) {
+    const msg = createMessage(
+      MSG_TYPES.EVENT,
+      bridgeAgentId,
+      "*",
+      { event: "completed", sessionId: event.sessionId },
+    );
+    emit(msg);
+  }
+
+  /**
+   * Handle conductor dead events.
+   */
+  function handleDead(event) {
+    const msg = createMessage(
+      MSG_TYPES.EVENT,
+      bridgeAgentId,
+      "*",
+      { event: "dead", sessionId: event.sessionId, reason: event.reason },
+    );
+    emit(msg);
+  }
+
+  /**
+   * Attaches event listeners to the conductor.
+   */
+  function attach() {
+    if (attached) return;
+    conductor.on("stateChange", handleStateChange);
+    conductor.on("completed", handleCompleted);
+    conductor.on("dead", handleDead);
+    attached = true;
+  }
+
+  /**
+   * Detaches event listeners and cleans up registry entries.
+   */
+  function detach() {
+    if (!attached) return;
+    conductor.off("stateChange", handleStateChange);
+    conductor.off("completed", handleCompleted);
+    conductor.off("dead", handleDead);
+
+    for (const [, agentId] of sessionAgentMap) {
+      registry.unregister(agentId);
+    }
+    sessionAgentMap.clear();
+    attached = false;
+  }
+
+  return { attach, detach, get isAttached() { return attached; } };
+}