@triflux/remote 10.39.0 → 10.40.0

package/cto/status.mjs

@@ -55,6 +55,17 @@ export function deriveRepoRootFromCwd(cwd) {
   if (cwd.includes("\\") || /^[A-Za-z]:/u.test(cwd)) return cwd;
 
   const normalized = cwd.replace(/\/+$/u, "");
+  const gitWorktreeMarker = "/.worktrees/";
+  const gitWorktreeIndex = normalized.indexOf(gitWorktreeMarker);
+  if (gitWorktreeIndex > 0) {
+    const suffix = normalized.slice(
+      gitWorktreeIndex + gitWorktreeMarker.length,
+    );
+    if (/^[^/]+(?:\/|$)/u.test(suffix)) {
+      return normalized.slice(0, gitWorktreeIndex);
+    }
+  }
+
   const claudeMarker = "/.claude/worktrees/";
   const claudeIndex = normalized.indexOf(claudeMarker);
   if (claudeIndex > 0) {

package/hub/pipe.mjs

@@ -29,6 +29,17 @@ function normalizeTopics(topics) {
   return topics.map((topic) => String(topic || "").trim()).filter(Boolean);
 }
 
+function normalizeReplayTopics(topics) {
+  if (Array.isArray(topics)) return normalizeTopics(topics);
+  if (typeof topics === "string") {
+    return topics
+      .split(/[,\s]+/u)
+      .map((topic) => topic.trim())
+      .filter(Boolean);
+  }
+  return [];
+}
+
 function getTeamBridgeMethod(methodName) {
   const method = getTeamBridge()?.[methodName];
   return typeof method === "function" ? method : null;
@@ -266,6 +277,12 @@ export function createPipeServer({
         return result;
       }
 
+      case "takeover_role": {
+        const result = router.takeoverRole(payload);
+        if (client) touchClient(client);
+        return result;
+      }
+
       case "handoff": {
         const result = router.handleHandoff(payload);
         if (client) touchClient(client);
@@ -454,13 +471,34 @@ export function createPipeServer({
       return pending.slice(0, maxMessages);
     }
 
+    const requestedTopics = normalizeReplayTopics(payload.topics);
+    const auditTopics = new Set(requestedTopics);
+    if (auditTopics.size === 0) {
+      const persistedTopics = store?.getAgent?.(agentId)?.topics || [];
+      for (const topic of persistedTopics) auditTopics.add(topic);
+      if (
+        typeof router.canReplayMessageForAgent === "function" &&
+        router.canReplayMessageForAgent(agentId, {
+          to_agent: "topic:cto",
+          topic: "cto",
+        })
+      ) {
+        auditTopics.add("cto");
+      }
+    }
+
     const audit = store.getAuditMessagesForAgent(agentId, {
       max_messages: maxMessages,
-      include_topics: payload.topics,
+      include_topics: Array.from(auditTopics),
     });
     const byId = new Map();
     for (const message of [...pending, ...audit]) {
       if (!message?.id || byId.has(message.id)) continue;
+      if (
+        typeof router.canReplayMessageForAgent === "function" &&
+        !router.canReplayMessageForAgent(agentId, message)
+      )
+        continue;
       byId.set(message.id, message);
     }
     return Array.from(byId.values())

package/hub/public/tray.html

@@ -259,27 +259,31 @@
       `;
     }
 
-    function liveFallbackRows(live) {
-      return live.map(session => ({
-        sessionId: session.sessionId,
-        status: session.phase || 'active',
-        agent_id: session.agent_id || session.agent?.id || '',
-        agent: session.agent || null,
-        promptText: session.promptText || '',
-        prompt: session.prompt || '',
-        userPrompt: session.userPrompt || '',
-        handoffPrompt: session.handoffPrompt || '',
-        command: session.command || '',
+        function liveFallbackRows(live) {
+          return live.map(session => ({
+            sessionId: session.sessionId,
+            status: session.phase || 'active',
+            agent_id: session.agent_id || session.agent?.id || '',
+            agent: session.agent || null,
+            role: session.role || '',
+            roles: session.roles || [],
+            metadata: session.metadata || {},
+            promptText: session.promptText || '',
+            prompt: session.prompt || '',
+            userPrompt: session.userPrompt || '',
+            handoffPrompt: session.handoffPrompt || '',
+            command: session.command || '',
         source: session.source || '',
         conversationId: session.conversationId || '',
         focusable: session.focusable !== false,
-        taskSummary: session.taskSummary || session.command || (session.pid ? `PID ${session.pid}` : ''),
-        pid: session.pid || '',
-        cwd: session.cwd || session.host || 'local runtime',
-        elapsed: session.elapsed || '',
-        started_at: session.started_at || null,
-      }));
-    }
+            taskSummary: session.taskSummary || session.command || (session.pid ? `PID ${session.pid}` : ''),
+            pid: session.pid || '',
+            cwd: session.cwd || session.host || 'local runtime',
+            worktreePath: session.worktreePath || '',
+            elapsed: session.elapsed || '',
+            started_at: session.started_at || null,
+          }));
+        }
 
     function compactText(value, fallback = '') {
       const text = String(value ?? '').replace(/\s+/g, ' ').trim();
@@ -293,12 +297,20 @@
       return path.replace(/^\/Users\/[^/]+/, '~');
     }
 
-    function normalizeProjectPath(value) {
-      const path = String(value || '').trim();
-      if (!path) return '';
-      if (path === '/' || /^\/+$/u.test(path) || /^[A-Za-z]:[\\/]$/u.test(path)) return path;
-      return path.replace(/[\\/]+$/u, '') || path;
-    }
+        function normalizeProjectPath(value) {
+          const path = String(value || '').trim();
+          if (!path) return '';
+          if (path === '/' || /^\/+$/u.test(path) || /^[A-Za-z]:[\\/]$/u.test(path)) return path;
+          return path.replace(/[\\/]+$/u, '') || path;
+        }
+
+        function worktreeFamilyRoot(path) {
+          const normalized = normalizeProjectPath(path);
+          const parts = normalized.split(/[\\/]/u);
+          const index = parts.lastIndexOf('.worktrees');
+          if (index <= 0) return '';
+          return parts.slice(0, index).join(normalized.includes('\\') ? '\\' : '/') || '';
+        }
 
     function projectName(value) {
       const path = normalizeProjectPath(value);
@@ -306,12 +318,14 @@
       return path.split(/[\\/]/u).filter(Boolean).pop() || path;
     }
 
-    function projectPathFor(row, hub, fallback = '') {
-      const cwd = String(row?.cwd || row?.worktreePath || '').trim();
-      if (cwd && cwd !== 'local' && cwd !== 'local runtime') return normalizeProjectPath(cwd);
-      const root = String(hub?.projectRoot || fallback || '').trim();
-      return normalizeProjectPath(root || cwd || 'local');
-    }
+        function projectPathFor(row, hub, fallback = '') {
+          const cwd = normalizeProjectPath(String(row?.cwd || row?.worktreePath || '').trim());
+          const rawRoot = normalizeProjectPath(String(hub?.projectRoot || fallback || '').trim());
+          const familyRoot = worktreeFamilyRoot(rawRoot) || rawRoot;
+          if (familyRoot && cwd && (cwd === familyRoot || cwd.startsWith(`${familyRoot}/.worktrees/`) || cwd.startsWith(`${familyRoot}/worktrees/`))) return familyRoot;
+          if (cwd && cwd !== 'local' && cwd !== 'local runtime') return worktreeFamilyRoot(cwd) || cwd;
+          return normalizeProjectPath(familyRoot || cwd || 'local');
+        }
 
     function getProjectGroup(groups, projectPath) {
       const key = normalizeProjectPath(projectPath) || 'local';
@@ -319,33 +333,86 @@
       return groups.get(key);
     }
 
-    function buildProjectGroups(activeSessions, liveRows, hub) {
-      const groups = new Map();
-      const fallbackProject = hub.projectRoot || activeSessions[0]?.cwd || activeSessions[0]?.worktreePath || 'local';
-      for (const session of activeSessions) {
-        getProjectGroup(groups, projectPathFor(session, hub, fallbackProject)).ctos.push(session);
-      }
+        function ctoRoleFromPayload(cto) {
+          return cto?.roles?.cto || cto?.succession?.cto || null;
+        }
 
-      const ctoIds = new Set(activeSessions.map(session => session.sessionId).filter(Boolean));
-      for (const worker of liveRows) {
-        if (ctoIds.has(worker.sessionId)) continue;
-        getProjectGroup(groups, projectPathFor(worker, hub, fallbackProject)).workers.push(worker);
-      }
+        function normalizedRoleValue(value) {
+          return String(value || '').trim().toLowerCase();
+        }
 
-      if (groups.size === 0 && fallbackProject) getProjectGroup(groups, fallbackProject);
-      for (const group of groups.values()) {
-        if (group.ctos.length === 0 && group.workers.length > 0) {
-          group.ctos.push({
-            sessionId: `cto-${shortId(hub.id || group.projectPath)}`,
-            status: 'active',
-            cwd: group.projectPath,
-            taskSummary: 'CTO runtime overlay',
+    function rowHasCtoRole(row, ctoRole) {
+      const sid = String(row?.sessionId || '').trim();
+      const agentId = String(row?.agent_id || row?.agent?.id || '').trim();
+      const leader = String(ctoRole?.leader_agent_id || '').trim();
+      if (leader) return Boolean(agentId === leader || sid === leader || sid === `cto:${leader}`);
+      if (ctoRole) return false;
+      const role = normalizedRoleValue(row?.role || row?.metadata?.role || row?.sessionKind);
+      const roles = Array.isArray(row?.roles || row?.metadata?.roles)
+        ? (row.roles || row.metadata.roles).map(normalizedRoleValue)
+        : String(row?.roles || row?.metadata?.roles || '').split(/[,\s]+/u).map(normalizedRoleValue);
+      if (role === 'cto' || roles.includes('cto') || row?.metadata?.cto === true) return true;
+      if (agentId === 'cto') return true;
+      if (/^cto[:._-]/iu.test(sid)) return true;
+      return false;
+    }
+
+        function ctoRoleRow(ctoRole, hub, fallbackProject) {
+          if (!ctoRole) return null;
+          const status = ctoRole.status === 'active' ? 'active' : 'offline';
+          const leader = ctoRole.leader_agent_id || ctoRole.previous_leader_agent_id || 'unassigned';
+          return {
+            sessionId: ctoRole.leader_agent_id ? `cto:${ctoRole.leader_agent_id}` : `cto:${shortId(hub.id || fallbackProject || 'role')}`,
+            status,
+            cwd: hub.projectRoot || fallbackProject || 'local',
+            taskSummary: status === 'active'
+              ? `CTO leader ${leader} · epoch ${ctoRole.leader_epoch || 0} · pending ${ctoRole.pending_count || 0}`
+              : `CTO offline · previous ${leader} · candidates ${ctoRole.live_candidate_count || 0}`,
             synthetic: true,
-          });
+            roleStatus: ctoRole,
+          };
+        }
+
+        function buildProjectGroups(activeSessions, liveRows, hub, ctoRole = null) {
+          const groups = new Map();
+          const fallbackProject = hub.projectRoot || activeSessions[0]?.cwd || activeSessions[0]?.worktreePath || 'local';
+          for (const session of activeSessions) {
+            const group = getProjectGroup(groups, projectPathFor(session, hub, fallbackProject));
+            if (rowHasCtoRole(session, ctoRole)) group.ctos.push(session);
+            else group.workers.push(session);
+          }
+
+          const activeSessionIds = new Set(
+            activeSessions
+              .map(session => session.sessionId)
+              .filter(Boolean)
+          );
+          for (const worker of liveRows) {
+            if (activeSessionIds.has(worker.sessionId)) continue;
+            const group = getProjectGroup(groups, projectPathFor(worker, hub, fallbackProject));
+            if (rowHasCtoRole(worker, ctoRole)) group.ctos.push(worker);
+            else group.workers.push(worker);
+          }
+
+          if (groups.size === 0 && fallbackProject) getProjectGroup(groups, fallbackProject);
+          const roleRow = ctoRoleRow(ctoRole, hub, fallbackProject);
+          if (roleRow) {
+            const project = projectPathFor(roleRow, hub, fallbackProject);
+            const group = getProjectGroup(groups, project);
+            const leader = String(ctoRole?.leader_agent_id || '').trim();
+            const existing = group.ctos.find(row => {
+              const sid = String(row?.sessionId || '').trim();
+              const agentId = String(row?.agent_id || row?.agent?.id || '').trim();
+              return sid === roleRow.sessionId || (leader && (sid === leader || agentId === leader));
+            });
+            if (existing) {
+              existing.roleStatus = ctoRole;
+            } else {
+              group.ctos.unshift(roleRow);
+            }
+          }
+          return [...groups.values()].sort((a, b) => a.projectPath.localeCompare(b.projectPath));
         }
-      }
-      return [...groups.values()].sort((a, b) => a.projectPath.localeCompare(b.projectPath));
-    }
 
     function explicitPromptText(row) {
       return String(row?.promptText || row?.prompt || row?.userPrompt || row?.handoffPrompt || '').trim();
@@ -443,20 +510,24 @@
       `;
     }
 
-    function renderCtoChat(ctoRow, workers) {
-      const status = ctoRow.status || ctoRow.phase || 'active';
-      const title = compactText(ctoRow.sessionId || ctoRow.taskSummary || 'Session', 'Session');
-      const subtitle = compactText(hasPromptText(ctoRow) ? ctoRow.taskSummary || ctoRow.sessionKind || '' : displayPath(ctoRow.cwd || ctoRow.worktreePath || ''), '');
-      const promptHtml = hasPromptText(ctoRow)
-        ? `<div class="detail-section"><div class="detail-label">Prompt</div>${renderChatBubble(ctoRow, { side: 'cto' })}</div>`
-        : '';
-      const agentRows = workers.map(worker => hasPromptText(worker) ? renderChatBubble(worker, { side: 'worker' }) : renderRuntimeCard(worker)).join('');
-      const agentsHtml = workers.length
-        ? `<div class="detail-section"><div class="detail-label">Agents</div><div class="runtime-list">${agentRows}</div></div>`
-        : '';
-      const emptyHtml = promptHtml || agentsHtml ? '' : '<div class="detail-empty">No session details yet</div>';
-      return `
-        <details class="session-card" data-open-key="cto:${dataAttr(ctoRow.sessionId || title)}">
+        function renderCtoChat(ctoRow, workers) {
+          const status = ctoRow.status || ctoRow.phase || 'active';
+          const title = compactText(ctoRow.sessionId || ctoRow.taskSummary || 'Session', 'Session');
+          const subtitle = compactText(hasPromptText(ctoRow) ? ctoRow.taskSummary || ctoRow.sessionKind || '' : displayPath(ctoRow.cwd || ctoRow.worktreePath || ''), '');
+          const role = ctoRow.roleStatus || null;
+          const roleHtml = role
+            ? `<div class="detail-section"><div class="detail-label">Succession</div><div class="path-text">leader ${escapeHtml(role.leader_agent_id || 'none')} · epoch ${escapeHtml(role.leader_epoch || 0)} · pending ${escapeHtml(role.pending_count || 0)} · candidates ${escapeHtml(role.live_candidate_count || 0)}/${escapeHtml(role.candidate_count || 0)}</div></div>`
+            : '';
+          const promptHtml = hasPromptText(ctoRow)
+            ? `<div class="detail-section"><div class="detail-label">Prompt</div>${renderChatBubble(ctoRow, { side: 'cto' })}</div>`
+            : '';
+          const agentRows = workers.map(worker => hasPromptText(worker) ? renderChatBubble(worker, { side: 'worker' }) : renderRuntimeCard(worker)).join('');
+          const agentsHtml = workers.length
+            ? `<div class="detail-section"><div class="detail-label">Agents</div><div class="runtime-list">${agentRows}</div></div>`
+            : '';
+          const emptyHtml = roleHtml || promptHtml || agentsHtml ? '' : '<div class="detail-empty">No session details yet</div>';
+          return `
+            <details class="session-card" data-open-key="cto:${dataAttr(ctoRow.sessionId || title)}">
           <summary class="session-summary">
             <span class="agent-badge">T</span>
             <div style="min-width:0;">
@@ -465,10 +536,11 @@
             </div>
             <div class="agent-state ${escapeHtml(status)}">${escapeHtml(status)}</div>
           </summary>
-          <div class="session-detail">
-            ${promptHtml}
-            ${agentsHtml}
-            ${emptyHtml}
+              <div class="session-detail">
+                ${roleHtml}
+                ${promptHtml}
+                ${agentsHtml}
+                ${emptyHtml}
           </div>
         </details>
       `;
@@ -478,14 +550,15 @@
       return `${count} ${count === 1 ? one : many}`;
     }
 
-    function renderProjectGroup(group) {
-      const projectDisplayPath = displayPath(group.projectPath);
-      const projectLabel = projectName(group.projectPath);
-      const sessionCount = group.ctos.filter(row => !isSyntheticCto(row)).length;
-      const agentCount = group.workers.length;
-      const projectCount = [sessionCount ? pluralize(sessionCount, 'session') : '', agentCount ? pluralize(agentCount, 'agent') : '']
-        .filter(Boolean)
-        .join(' · ') || 'empty';
+        function renderProjectGroup(group) {
+          const projectDisplayPath = displayPath(group.projectPath);
+          const projectLabel = projectName(group.projectPath);
+          const sessionCount = group.ctos.filter(row => !isSyntheticCto(row)).length;
+          const agentCount = group.workers.length;
+          const ctoCount = group.ctos.length;
+          const projectCount = [ctoCount ? pluralize(ctoCount, 'CTO') : '', sessionCount ? pluralize(sessionCount, 'session') : '', agentCount ? pluralize(agentCount, 'agent') : '']
+            .filter(Boolean)
+            .join(' · ') || 'empty';
       let html = `
         <details class="project-group" data-open-key="project:${dataAttr(group.projectPath)}">
           <summary class="project-summary">
@@ -496,26 +569,49 @@
           <div class="project-path">${escapeHtml(projectDisplayPath)}</div>
           <div class="project-body">
       `;
-      const ctos = group.ctos.slice(0, 6);
-      const workers = group.workers.slice(0, 10);
-      for (const [index, ctoRow] of ctos.entries()) {
-        html += renderCtoChat(ctoRow, index === 0 ? workers : []);
-      }
-      html += '</div></details>';
-      return html;
-    }
+          const ctos = group.ctos.slice(0, 6);
+          const workers = group.workers.slice(0, 10);
+          for (const [index, ctoRow] of ctos.entries()) {
+            html += renderCtoChat(ctoRow, index === 0 ? workers : []);
+          }
+          if (ctos.length === 0 && workers.length > 0) {
+            const agentRows = workers.map(worker => hasPromptText(worker) ? renderChatBubble(worker, { side: 'worker' }) : renderRuntimeCard(worker)).join('');
+            html += `<div class="detail-section"><div class="detail-label">Agents</div><div class="runtime-list">${agentRows}</div></div>`;
+          }
+          html += '</div></details>';
+          return html;
+        }
+
+        function renderCtoRoleBanner(ctoRole) {
+          if (!ctoRole) return '';
+          const status = ctoRole.status || 'offline';
+          const leader = ctoRole.leader_agent_id || ctoRole.previous_leader_agent_id || 'none';
+          return `
+            <div class="section">
+              <div class="section-title">CTO Succession</div>
+              <div class="mini-card">
+                <div style="display:flex;align-items:center;gap:8px;justify-content:space-between;">
+                  <div class="mini-title"><span class="agent-badge">T</span> ${escapeHtml(leader)}</div>
+                  <div class="value-pill status-text ${escapeHtml(status)}">${escapeHtml(status)}</div>
+                </div>
+                <div class="path-text">epoch ${escapeHtml(ctoRole.leader_epoch || 0)} · pending ${escapeHtml(ctoRole.pending_count || 0)} · candidates ${escapeHtml(ctoRole.live_candidate_count || 0)}/${escapeHtml(ctoRole.candidate_count || 0)}${ctoRole.candidate_source ? ` · ${escapeHtml(ctoRole.candidate_source)}` : ''}</div>
+              </div>
+            </div>
+          `;
+        }
 
     function renderSessions(data) {
       const container = document.getElementById('tab-sessions');
       const openKeys = collectOpenDetailKeys(container);
       const hub = data?.hub || {};
       const sessions = Array.isArray(data?.sessions) ? data.sessions : [];
-      const cto = data?.cto || {};
-      const live = Array.isArray(cto.live_sessions) ? cto.live_sessions : [];
-      const runtime = data?.runtime || {};
-      const activeSessions = sessions.filter(s => s.status !== 'stale');
-      const liveRows = liveFallbackRows(live);
-      const projectGroups = buildProjectGroups(activeSessions.slice(0, 10), liveRows, hub);
+          const cto = data?.cto || {};
+          const ctoRole = ctoRoleFromPayload(cto);
+          const live = Array.isArray(cto.live_sessions) ? cto.live_sessions : [];
+          const runtime = data?.runtime || {};
+          const activeSessions = sessions.filter(s => s.status !== 'stale');
+          const liveRows = liveFallbackRows(live);
+          const projectGroups = buildProjectGroups(activeSessions.slice(0, 10), liveRows, hub, ctoRole);
       const activeCount = activeSessions.filter(s => s.status === 'active').length;
       const idleCount = activeSessions.filter(s => s.status === 'idle').length;
       const staleCount = sessions.filter(s => s.status === 'stale').length;
@@ -530,11 +626,12 @@
           </div>
           <div class="path-text">${projectGroups.length} ${projectGroups.length === 1 ? 'workspace' : 'workspaces'} · ${cto.active_shards?.length || 0} shards · ${renderCopyChip('Hub', hub.id || String(hub.pid || ''))}</div>
         </div>
-        <div class="section">
-          <div class="section-title">Agent Mix</div>
-          <div class="models-list">${renderRuntimeClients(runtime)}</div>
-        </div>
-        ${renderCtoHygiene(cto.hygiene)}
+            <div class="section">
+              <div class="section-title">Agent Mix</div>
+              <div class="models-list">${renderRuntimeClients(runtime)}</div>
+            </div>
+            ${renderCtoRoleBanner(ctoRole)}
+            ${renderCtoHygiene(cto.hygiene)}
         <div class="section">
           <div class="section-title">Workspaces</div>
           <div class="agent-view">

package/hub/server.mjs

@@ -22,6 +22,7 @@ import {
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { runCollect } from "../cto/collect.mjs";
+import { resolveLakeRootDir } from "../cto/lake-root.mjs";
 import { runStatus as runCtoStatus } from "../cto/status.mjs";
 import { createModuleLogger } from "../scripts/lib/logger.mjs";
 import {
@@ -95,6 +96,7 @@ const LOOPBACK_REMOTE_ADDRESSES = new Set([
 const ALLOWED_ORIGIN_RE =
   /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/i;
 const PROJECT_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const CANONICAL_PROJECT_ROOT = resolveLakeRootDir(PROJECT_ROOT) || PROJECT_ROOT;
 const PUBLIC_DIR = resolve(join(PROJECT_ROOT, "hub", "public"));
 const CACHE_DIR = join(homedir(), ".claude", "cache");
 const HUB_DEFAULT_PORT = 27888;
@@ -865,7 +867,7 @@ function getBrokerPublicSnapshot(currentBroker = brokerInstance) {
 async function getTrayCtoStatus() {
   try {
     return await runCtoStatus(["--json"], {
-      rootDir: PROJECT_ROOT,
+      rootDir: CANONICAL_PROJECT_ROOT,
       stdout: { write() {} },
     });
   } catch (error) {
@@ -1446,12 +1448,22 @@ export async function startHub({
         const synapseSnapshot = synapseRegistry.snapshot();
         const broker = getBrokerPublicSnapshot(brokerInstance);
         const runtimeStatus = getRuntimeStatus({
-          projectRoots: [PROJECT_ROOT],
+          projectRoots: [
+            ...new Set([CANONICAL_PROJECT_ROOT, PROJECT_ROOT].filter(Boolean)),
+          ],
         });
-        const [ctoStatus, mcpStatus] = await Promise.all([
+        const [ctoStatus, mcpStatus, hubStatus] = await Promise.all([
           getTrayCtoStatus(),
           Promise.resolve(getTrayMcpStatus()),
+          pipe.executeQuery("status", {
+            scope: "hub",
+            include_metrics: true,
+          }),
         ]);
+        const mergedCtoStatus = {
+          ...(ctoStatus || {}),
+          roles: hubStatus?.data?.roles || ctoStatus?.roles || {},
+        };
 
         return writeJson(
           res,
@@ -1462,12 +1474,12 @@ export async function startHub({
               pid: process.pid,
               port,
               url: buildHubUrl(host, port),
-              projectRoot: PROJECT_ROOT,
+              projectRoot: CANONICAL_PROJECT_ROOT,
             },
             qos,
             synapseSnapshot,
             broker,
-            ctoStatus,
+            ctoStatus: mergedCtoStatus,
             mcpStatus,
             runtimeStatus,
           }),
@@ -1652,6 +1664,28 @@ export async function startHub({
             return writeJson(res, result.ok ? 200 : 400, result);
           }
 
+          if (path === "/bridge/takeover-role" && req.method === "POST") {
+            const {
+              role = "cto",
+              agent_id,
+              reason = "manual",
+              requested_by = "http",
+            } = body;
+            if (!role || !agent_id) {
+              return writeJson(res, 400, {
+                ok: false,
+                error: "role, agent_id 필수",
+              });
+            }
+            const result = await pipe.executeCommand("takeover_role", {
+              role,
+              agent_id,
+              reason,
+              requested_by,
+            });
+            return writeJson(res, result.ok ? 200 : 409, result);
+          }
+
           if (path === "/bridge/register" && req.method === "POST") {
             const {
               agent_id,

package/hub/team/execution-mode.mjs

@@ -3,6 +3,12 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve as pathResolve } from "node:path";
 
+// scripts/lib is bundled into @triflux/remote itself (package.json files), so
+// import the local mirror relatively rather than via @triflux/core. The core
+// peer range (^10.0.0-alpha.1) could resolve to a build that predates this
+// export, which would fail at import time; the bundled copy is version-skew
+// safe and always carries the matching codexProfileConfigOverrides.
+import { codexProfileConfigOverrides } from "../../scripts/lib/codex-profile-config.mjs";
 import { whichCommand } from "@triflux/core/hub/platform.mjs";
 
 const WIN32_EXT_PRECEDENCE = [".cmd", ".exe", ".bat", ".ps1"];
@@ -147,7 +153,6 @@ export function buildSpawnSpecForMode(mode, opts = {}) {
   }
 
   const args = [];
-  pushFlag(args, "--profile", opts.profile);
   args.push(
     "exec",
     "--dangerously-bypass-approvals-and-sandbox",
@@ -155,6 +160,14 @@ export function buildSpawnSpecForMode(mode, opts = {}) {
     "--color",
     "never",
   );
+  // Select the effort profile via `-c` config overrides instead of
+  // `--profile <name>`: codex 0.134+ rejects `--profile X` whenever config.toml
+  // still contains an inline [profiles.X] table (which codex re-injects on
+  // config rewrite). These go straight to spawn argv (shell: false), so push
+  // the raw TOML-scalar overrides without shell-quoting.
+  for (const override of codexProfileConfigOverrides(opts.profile)) {
+    args.push("-c", override);
+  }
   if (Array.isArray(opts.mcpServers)) {
     const excludedMcpServers = new Set(
       (Array.isArray(opts.excludeMcpServers) ? opts.excludeMcpServers : [])

package/hub/tools.mjs

@@ -183,6 +183,26 @@ export function createTools(store, router, hitl, pipe = null) {
       }),
     },
 
+    // ── 2-1. takeover_role ──
+    {
+      name: "takeover_role",
+      description:
+        "CTO 같은 허브 역할의 active leader를 명시적으로 승계하고 미처리 역할 메시지를 새 leader에게 이전합니다",
+      inputSchema: {
+        type: "object",
+        required: ["role", "agent_id"],
+        properties: {
+          role: { type: "string", enum: ["cto"], default: "cto" },
+          agent_id: { type: "string", pattern: "^[a-zA-Z0-9._:-]{3,64}$" },
+          reason: { type: "string" },
+          requested_by: { type: "string" },
+        },
+      },
+      handler: wrap("TAKEOVER_ROLE_FAILED", (args) => {
+        return router.takeoverRole(args);
+      }),
+    },
+
     // ── 3. publish ──
     {
       name: "publish",
@@ -841,7 +861,7 @@ export function createTools(store, router, hitl, pipe = null) {
       }),
     },
 
-    // ── 21. send_input ──
+    // ── 22. send_input ──
     {
       name: "send_input",
       description: "Send input text to a worker in INPUT_WAIT state",

package/hub/tray-state.mjs

@@ -49,6 +49,10 @@ function normalizeAgentId(value) {
   return "";
 }
 
+function rawAgentId(value) {
+  return String(value ?? "").trim();
+}
+
 function inferAgentId(value = {}) {
   const direct = normalizeAgentId(
     value.agent_id ??
@@ -84,7 +88,11 @@ function agentMeta(agentId) {
 export function normalizeTraySessions(snapshot) {
   return readSynapseSessions(snapshot)
     .map((session) => {
-      const agentId = inferAgentId(session);
+      const directAgentId = session?.agent_id ?? session?.agentId;
+      const agentId =
+        normalizeAgentId(directAgentId) ||
+        rawAgentId(directAgentId) ||
+        inferAgentId(session);
       return {
         sessionId: String(session?.sessionId || ""),
         host: typeof session?.host === "string" ? session.host : "local",
@@ -368,7 +376,11 @@ function runtimeToLiveOverlay(runtime) {
 }
 
 function normalizeLiveSession(session = {}) {
-  const agentId = inferAgentId(session);
+  const directAgentId = session.agent_id ?? session.agentId;
+  const agentId =
+    normalizeAgentId(directAgentId) ||
+    rawAgentId(directAgentId) ||
+    inferAgentId(session);
   return {
     ...session,
     sessionId: String(session.sessionId || ""),
@@ -460,11 +472,21 @@ function normalizeCtoStatus(ctoStatus = {}, sessions = [], runtime = {}) {
     ? ctoStatus.active_shards
     : [];
   const hygiene = normalizeCtoHygiene(ctoStatus);
+  const roles =
+    ctoStatus?.roles && typeof ctoStatus.roles === "object"
+      ? ctoStatus.roles
+      : null;
+  const succession =
+    ctoStatus?.succession && typeof ctoStatus.succession === "object"
+      ? ctoStatus.succession
+      : null;
   return {
     schema_version: String(ctoStatus?.schema_version || "cto-lake.v1"),
     generated_at: ctoStatus?.generated_at || null,
     live_sessions: normalizedLiveSessions,
     active_shards: activeShards,
+    ...(roles ? { roles } : {}),
+    ...(succession ? { succession } : {}),
     ...(hygiene ? { hygiene } : {}),
     summary: {
       live_session_count: normalizedLiveSessions.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.39.0",
+  "version": "10.40.0",
   "description": "triflux remote — team mode, psmux, MCP workers, SQLite store.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/codex-profile-config.mjs

@@ -1,6 +1,77 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
+const EFFORT_BY_SUFFIX = {
+  xhigh: "xhigh",
+  high: "high",
+  med: "medium",
+  medium: "medium",
+  low: "low",
+};
+
+function readProfileScalar(raw, key) {
+  const match = String(raw).match(
+    new RegExp(
+      `^\\s*${key}\\s*=\\s*(?:"([^"\\n]*)"|'([^'\\n]*)'|([^#\\n]*?))\\s*(?:#.*)?$`,
+      "m",
+    ),
+  );
+  if (!match) return null;
+  const value = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+  return value || null;
+}
+
+/**
+ * Resolve a Codex effort profile name (e.g. "gpt55_high") to the `-c key=value`
+ * config overrides that `codex exec` accepts, so the headless CLI lanes can
+ * select a profile WITHOUT `codex exec --profile <name>`. codex 0.134+ rejects
+ * `--profile X` whenever config.toml still contains an inline `[profiles.X]`
+ * table (which codex itself re-injects when it rewrites config.toml), so the
+ * `-c` form is immune and needs no config mutation / sanitize race.
+ *
+ * SSOT = the per-profile file `~/.codex/<name>.config.toml` written by
+ * `tfx setup`; falls back to deriving the effort from the `<...>_<effort>`
+ * naming convention when the file is absent. Returns the keys that resolve, in
+ * `key="value"` TOML-scalar form ready to be shell-quoted by the caller.
+ *
+ * NOTE: the Codex MCP transport does the structured-arg equivalent in
+ * hub/workers/codex-mcp.mjs (resolveCodexProfileConfig → model + config object);
+ * this returns the CLI `-c` string form for the same per-profile file.
+ *
+ * @param {string} profileName
+ * @param {{ codexHome?: string }} [opts]
+ * @returns {string[]} e.g. ['model="gpt-5.5"', 'model_reasoning_effort="high"']
+ */
+export function codexProfileConfigOverrides(profileName, opts = {}) {
+  if (typeof profileName !== "string" || !profileName) return [];
+  const codexHome =
+    opts.codexHome || process.env.CODEX_HOME || join(homedir(), ".codex");
+  let model = null;
+  let effort = null;
+  try {
+    const raw = readFileSync(
+      join(codexHome, `${profileName}.config.toml`),
+      "utf8",
+    );
+    model = readProfileScalar(raw, "model");
+    effort = readProfileScalar(raw, "model_reasoning_effort");
+  } catch {
+    const suffix = /_(xhigh|high|med|medium|low)$/.exec(profileName);
+    if (suffix) effort = EFFORT_BY_SUFFIX[suffix[1]] || null;
+  }
+  const overrides = [];
+  if (model) overrides.push(`model="${model}"`);
+  if (effort) overrides.push(`model_reasoning_effort="${effort}"`);
+  return overrides;
+}
+
 const PROFILE_SECTION_PREFIX = "profiles.";
 const SAFE_PROFILE_FILE_RE = /^[A-Za-z0-9_.-]+$/;
 
@@ -137,6 +208,16 @@ export function sanitizeCodexProfileConfigFile(
   const sanitized = sanitizeCodexProfileConfig(source, { codexHome });
   if (!sanitized.changed) return sanitized;
   writeFileSync(`${configPath}.${backupPrefix}-${stamp(now)}`, source, "utf8");
-  writeFileSync(configPath, sanitized.toml, "utf8");
+  // Atomic replace. config.toml is shared global state: a codex session may be
+  // reading it while another entry point (tfx-route, the codex session hook, or
+  // a parallel swarm worker) sanitizes it. Write the sanitized content to a
+  // unique temp file in the same directory, then rename — rename is atomic on
+  // the same filesystem, so no reader ever observes a torn/half-written config.
+  // Concurrent sanitizers each rename their own complete temp; last writer wins
+  // without corruption (the content is identical anyway since the migration is
+  // deterministic). The pid keeps temp names unique across separate processes.
+  const tmpPath = `${configPath}.tmp-${process.pid}-${stamp(now)}`;
+  writeFileSync(tmpPath, sanitized.toml, "utf8");
+  renameSync(tmpPath, configPath);
   return sanitized;
 }