@triflux/core 10.39.0 → 10.40.0

package/hub/bridge.mjs

@@ -119,6 +119,11 @@ const HUB_OPERATIONS = Object.freeze({
     action: "publish",
     httpPath: "/bridge/publish",
   },
+  takeoverRole: {
+    transport: "command",
+    action: "takeover_role",
+    httpPath: "/bridge/takeover-role",
+  },
   sendInput: {
     transport: "command",
     action: "send_input",
@@ -365,6 +370,7 @@ export function parseArgs(argv) {
     args: argv,
     options: {
       agent: { type: "string" },
+      "agent-id": { type: "string" },
       cli: { type: "string" },
       timeout: { type: "string" },
       topics: { type: "string" },
@@ -387,6 +393,7 @@ export function parseArgs(argv) {
       claim: { type: "boolean" },
       actor: { type: "string" },
       command: { type: "string" },
+      role: { type: "string" },
       "session-id": { type: "string" },
       reason: { type: "string" },
       type: { type: "string" },
@@ -703,6 +710,19 @@ async function cmdPublish(args) {
   return emitJson(result || unavailableResult());
 }
 
+async function cmdTakeoverRole(args) {
+  const role = args.role || args[1] || "cto";
+  const agentId = args.agent || args["agent-id"] || args[2];
+  const outcome = await requestHub(HUB_OPERATIONS.takeoverRole, {
+    role,
+    agent_id: agentId,
+    reason: args.reason || "manual",
+    requested_by: args["requested-by"] || "bridge",
+  });
+  const result = outcome?.result;
+  return emitJson(result || unavailableResult());
+}
+
 async function cmdSendInput(args) {
   const outcome = await requestHub(HUB_OPERATIONS.sendInput, {
     session_id: args["session-id"],
@@ -1554,6 +1574,8 @@ export async function main(argv = process.argv.slice(2)) {
       return await cmdHandoff(args);
     case "publish":
       return await cmdPublish(args);
+    case "takeover-role":
+      return await cmdTakeoverRole(args);
     case "send-input":
       return await cmdSendInput(args);
     case "context":
@@ -1610,7 +1632,7 @@ export async function main(argv = process.argv.slice(2)) {
       return await cmdRetryStatus(args);
     default:
       console.error(
-        "사용법: bridge.mjs <register|result|control|handoff|publish|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending|daemon-probe|daemon-attach|daemon-interrupt|retry-run|retry-status> [--옵션]",
+        "사용법: bridge.mjs <register|result|control|handoff|publish|takeover-role|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending|daemon-probe|daemon-attach|daemon-interrupt|retry-run|retry-status> [--옵션]",
       );
       process.exit(1);
   }

package/hub/cli-adapter-base.mjs

@@ -4,6 +4,7 @@
 import { execSync, spawn } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 
+import { codexProfileConfigOverrides } from "../scripts/lib/codex-profile-config.mjs";
 import { writePromptToTmpFile } from "./lib/prompt-tmp.mjs";
 import { IS_WINDOWS, killProcess } from "./platform.mjs";
 
@@ -172,7 +173,12 @@ export function buildExecCommand(prompt, resultFile = null, opts = {}) {
   } = opts;
 
   const parts = ["codex"];
-  if (profile) parts.push("--profile", profile);
+  // 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 (and codex re-injects such
+  // tables when it rewrites config.toml), so the `-c model=.. -c
+  // model_reasoning_effort=..` form is immune and mutates no config.
+  const profileOverrides = profile ? codexProfileConfigOverrides(profile) : [];
 
   if (FEATURES.execSubcommand) {
     parts.push("exec");
@@ -182,6 +188,8 @@ export function buildExecCommand(prompt, resultFile = null, opts = {}) {
       parts.push("--output-last-message", resultFile);
     }
     if (FEATURES.colorNever) parts.push("--color", "never");
+    for (const override of profileOverrides)
+      parts.push("-c", shellQuote(override));
     // NOTE: `codex exec`는 --cwd 플래그를 지원하지 않는다. Node spawn의 cwd
     // 옵션으로 child process의 working directory를 제어한다 (conductor.mjs 참조).
     // opts.cwd는 기록용으로만 받아두고 CLI command에는 반영하지 않는다.
@@ -194,6 +202,8 @@ export function buildExecCommand(prompt, resultFile = null, opts = {}) {
   } else {
     parts.push("--dangerously-bypass-approvals-and-sandbox");
     if (skipGitRepoCheck) parts.push("--skip-git-repo-check");
+    for (const override of profileOverrides)
+      parts.push("-c", shellQuote(override));
   }
 
   const useStdin = resolveStdinPromptMode(stdinPrompt);

package/hub/codex-adapter.mjs

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
+import { codexProfileConfigOverrides } from "../scripts/lib/codex-profile-config.mjs";
 import {
   buildExecCommand,
   createResult,
@@ -72,14 +73,21 @@ function buildAttempts(opts, preflight) {
 // ── Launch script ───────────────────────────────────────────────
 
 function createLaunchScriptText(opts) {
-  const parts = ["codex"];
-  if (opts.profile) parts.push("--profile", shellQuote(opts.profile));
-  parts.push(
+  const parts = [
+    "codex",
     "exec",
     "--dangerously-bypass-approvals-and-sandbox",
     "--skip-git-repo-check",
-    '$(cat "$PROMPT_FILE")',
-  );
+  ];
+  // Select the effort profile via `-c` config overrides instead of
+  // `--profile <name>` (see buildExecCommand): codex 0.134+ rejects `--profile
+  // X` whenever config.toml still contains an inline [profiles.X] table.
+  if (opts.profile) {
+    for (const override of codexProfileConfigOverrides(opts.profile)) {
+      parts.push("-c", shellQuote(override));
+    }
+  }
+  parts.push('$(cat "$PROMPT_FILE")');
   return [
     "#!/usr/bin/env bash",
     "set -euo pipefail",

package/hub/router.mjs

@@ -4,6 +4,11 @@ import { EventEmitter, once } from "node:events";
 import { uuidv7 } from "./lib/uuidv7.mjs";
 
 const ASSIGN_PENDING_STATUSES = new Set(["queued", "running"]);
+const ROLE_TOPICS = new Set(["cto"]);
+const ROLE_SOURCE_RANK = Object.freeze({
+  explicit: 2,
+  "topic-fallback": 1,
+});
 
 function uniqueStrings(values = []) {
   return Array.from(
@@ -13,6 +18,37 @@ function uniqueStrings(values = []) {
   );
 }
 
+function normalizeRoleName(value) {
+  const role = String(value || "")
+    .trim()
+    .toLowerCase();
+  return ROLE_TOPICS.has(role) ? role : "";
+}
+
+function normalizeRoleValues(value) {
+  if (Array.isArray(value))
+    return uniqueStrings(value).map((item) => item.toLowerCase());
+  if (typeof value === "string") {
+    return uniqueStrings(value.split(/[,\s]+/u)).map((item) =>
+      item.toLowerCase(),
+    );
+  }
+  return [];
+}
+
+function rolePriority(metadata = {}, roleName = "") {
+  const candidates = [
+    metadata?.[`${roleName}_priority`],
+    metadata?.role_priority,
+    metadata?.priority,
+  ];
+  for (const value of candidates) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+  }
+  return 0;
+}
+
 function clampAssignDuration(
   value,
   fallback = 600000,
@@ -90,6 +126,7 @@ export function createRouter(store) {
   const runtimeTopics = new Map();
   const queuesByAgent = new Map();
   const liveMessages = new Map();
+  const roleStates = new Map();
   const MAX_LATENCY_SAMPLES = 100;
   let latencyIdx = 0;
   const deliveryLatencies = new Array(MAX_LATENCY_SAMPLES).fill(0);
@@ -123,6 +160,340 @@ export function createRouter(store) {
     return normalizeAgentTopics(store, agentId, runtimeTopics.get(agentId));
   }
 
+  function ensureRoleState(roleName) {
+    const role = normalizeRoleName(roleName);
+    if (!role) return null;
+    if (!roleStates.has(role)) {
+      roleStates.set(role, {
+        role,
+        leaderAgentId: null,
+        previousLeaderAgentId: null,
+        leaderEpoch: 0,
+        leaderSource: null,
+        status: "offline",
+        candidates: new Map(),
+        lastTransitionMs: null,
+        lastReason: "init",
+        transferredCount: 0,
+      });
+    }
+    return roleStates.get(role);
+  }
+
+  function hasRoleCapability(capabilities = [], roleName) {
+    const normalized = normalizeRoleValues(capabilities);
+    return normalized.some(
+      (capability) =>
+        capability === roleName ||
+        capability === `role:${roleName}` ||
+        capability === `${roleName}:leader` ||
+        capability === `${roleName}:candidate`,
+    );
+  }
+
+  function getRoleCandidateSource(agent, topics, roleName) {
+    if (!agent) return null;
+    const metadata = agent.metadata || {};
+    const roles = [
+      ...normalizeRoleValues(metadata.role),
+      ...normalizeRoleValues(metadata.roles),
+    ];
+    const explicit =
+      roles.includes(roleName) ||
+      metadata?.[roleName] === true ||
+      metadata?.is_cto === true ||
+      hasRoleCapability(agent.capabilities, roleName);
+    if (explicit) return "explicit";
+    return topics.includes(roleName) ? "topic-fallback" : null;
+  }
+
+  function buildRoleCandidate(agentId, roleName) {
+    const role = normalizeRoleName(roleName);
+    if (!agentId || !role) return null;
+    const agent = store.getAgent(agentId);
+    if (!agent) return null;
+    const topics = listRuntimeTopics(agentId);
+    const source = getRoleCandidateSource(agent, topics, role);
+    if (!source) return null;
+    return {
+      agent_id: agent.agent_id,
+      status: agent.status,
+      source,
+      priority: rolePriority(agent.metadata, role),
+      last_seen_ms: agent.last_seen_ms || 0,
+      lease_expires_ms: agent.lease_expires_ms || 0,
+      topics,
+      capabilities: agent.capabilities || [],
+    };
+  }
+
+  function refreshRoleCandidateForAgent(agentId) {
+    if (!agentId) return;
+    for (const roleName of ROLE_TOPICS) {
+      const role = ensureRoleState(roleName);
+      const candidate = buildRoleCandidate(agentId, roleName);
+      if (candidate) role.candidates.set(agentId, candidate);
+      else role.candidates.delete(agentId);
+    }
+  }
+
+  function refreshRoleCandidates(roleName) {
+    const role = ensureRoleState(roleName);
+    if (!role) return [];
+    const ids = new Set(role.candidates.keys());
+    for (const [agentId, topics] of runtimeTopics) {
+      if (topics.has(role.role)) ids.add(agentId);
+    }
+    for (const agent of store.getAgentsByTopic(role.role)) {
+      ids.add(agent.agent_id);
+    }
+    if (typeof store.listAllAgents === "function") {
+      for (const agent of store.listAllAgents()) ids.add(agent.agent_id);
+    }
+    for (const agentId of ids) refreshRoleCandidateForAgent(agentId);
+    return Array.from(role.candidates.values());
+  }
+
+  function isCandidateLive(candidate, now = Date.now()) {
+    return (
+      candidate?.status === "online" && Number(candidate.lease_expires_ms) > now
+    );
+  }
+
+  function sortRoleCandidates(candidates = []) {
+    return [...candidates].sort((left, right) => {
+      const sourceDelta =
+        (ROLE_SOURCE_RANK[right.source] || 0) -
+        (ROLE_SOURCE_RANK[left.source] || 0);
+      if (sourceDelta !== 0) return sourceDelta;
+      const priorityDelta =
+        Number(right.priority || 0) - Number(left.priority || 0);
+      if (priorityDelta !== 0) return priorityDelta;
+      const seenDelta =
+        Number(right.last_seen_ms || 0) - Number(left.last_seen_ms || 0);
+      if (seenDelta !== 0) return seenDelta;
+      return String(left.agent_id).localeCompare(String(right.agent_id));
+    });
+  }
+
+  function chooseRoleLeader(roleName) {
+    const now = Date.now();
+    return (
+      sortRoleCandidates(refreshRoleCandidates(roleName)).find((candidate) =>
+        isCandidateLive(candidate, now),
+      ) || null
+    );
+  }
+
+  function messageMatchesRole(record, roleName) {
+    const message = record?.message || {};
+    const to = message.to_agent ?? message.to;
+    return to === `topic:${roleName}`;
+  }
+
+  function roleTopicForMessage(message = {}) {
+    const to = message?.to_agent ?? message?.to;
+    if (!String(to || "").startsWith("topic:")) return "";
+    return normalizeRoleName(String(to).slice(6));
+  }
+
+  function isReplayAllowedForAgent(agentId, message = {}) {
+    const roleName = roleTopicForMessage(message);
+    if (!roleName) return true;
+    const targetAgentId = String(agentId || "").trim();
+    if (!targetAgentId) return false;
+    const role = getRoleSnapshot(roleName);
+    return role?.leader_agent_id === targetAgentId;
+  }
+
+  function shouldTrackWithoutRecipients(message) {
+    const to = message?.to_agent ?? message?.to;
+    if (!String(to || "").startsWith("topic:")) return false;
+    return ROLE_TOPICS.has(String(to).slice(6));
+  }
+
+  function isRoleMessageFullyHandled(record, roleName) {
+    if (!messageMatchesRole(record, roleName)) return true;
+    return (
+      record.recipients.size > 0 &&
+      record.ackedBy.size >= record.recipients.size
+    );
+  }
+
+  function isRoleRecipient(agentId, roleName, previousLeaderAgentId = null) {
+    if (!agentId) return false;
+    if (agentId === previousLeaderAgentId) return true;
+    return Boolean(buildRoleCandidate(agentId, roleName));
+  }
+
+  function countPendingForRole(roleName) {
+    const now = Date.now();
+    let count = 0;
+    for (const record of liveMessages.values()) {
+      if (!messageMatchesRole(record, roleName)) continue;
+      if (record.message.expires_at_ms <= now) continue;
+      if (isRoleMessageFullyHandled(record, roleName)) continue;
+      count += 1;
+    }
+    return count;
+  }
+
+  function transferRoleBacklog(
+    roleName,
+    newLeaderAgentId,
+    previousLeaderAgentId,
+  ) {
+    const role = ensureRoleState(roleName);
+    const now = Date.now();
+    const stats = { transferred_count: 0, skipped_count: 0, removed_count: 0 };
+    if (!role || !newLeaderAgentId) return stats;
+
+    for (const record of liveMessages.values()) {
+      const { message, recipients, ackedBy } = record;
+      if (!messageMatchesRole(record, role.role)) continue;
+      if (message.expires_at_ms <= now) {
+        stats.skipped_count += 1;
+        continue;
+      }
+      if (isRoleMessageFullyHandled(record, role.role)) {
+        stats.skipped_count += 1;
+        continue;
+      }
+
+      for (const recipient of Array.from(recipients)) {
+        if (
+          recipient !== newLeaderAgentId &&
+          isRoleRecipient(recipient, role.role, previousLeaderAgentId)
+        ) {
+          queuesByAgent.get(recipient)?.delete(message.id);
+          recipients.delete(recipient);
+          ackedBy.delete(recipient);
+          stats.removed_count += 1;
+        }
+      }
+
+      recipients.add(newLeaderAgentId);
+      const alreadyQueued = queuesByAgent
+        .get(newLeaderAgentId)
+        ?.has(message.id);
+      if (!alreadyQueued && !ackedBy.has(newLeaderAgentId)) {
+        queueMessage(newLeaderAgentId, message);
+        stats.transferred_count += 1;
+      } else {
+        stats.skipped_count += 1;
+      }
+      message.status = "delivered";
+      store.updateMessageStatus(message.id, "delivered");
+    }
+
+    role.transferredCount += stats.transferred_count;
+    return stats;
+  }
+
+  function buildRoleSnapshot(roleName, { refreshCandidates = true } = {}) {
+    const role = ensureRoleState(roleName);
+    if (!role) return null;
+    const now = Date.now();
+    const candidates = sortRoleCandidates(
+      refreshCandidates
+        ? refreshRoleCandidates(role.role)
+        : Array.from(role.candidates.values()),
+    );
+    const leader =
+      role.leaderAgentId && buildRoleCandidate(role.leaderAgentId, role.role);
+    const leaderLive = isCandidateLive(leader, now);
+    const liveCandidates = candidates.filter((candidate) =>
+      isCandidateLive(candidate, now),
+    );
+    return {
+      role: role.role,
+      status: leaderLive
+        ? "active"
+        : liveCandidates.length
+          ? "electable"
+          : "offline",
+      leader_agent_id: leaderLive ? role.leaderAgentId : null,
+      previous_leader_agent_id: role.previousLeaderAgentId || null,
+      leader_epoch: role.leaderEpoch,
+      lease_expires_ms: leaderLive ? leader.lease_expires_ms : null,
+      candidate_source: leaderLive
+        ? leader.source
+        : liveCandidates[0]?.source || null,
+      candidate_count: candidates.length,
+      live_candidate_count: liveCandidates.length,
+      pending_count: countPendingForRole(role.role),
+      transferred_count: role.transferredCount,
+      last_transition_ms: role.lastTransitionMs,
+      last_reason: role.lastReason,
+      candidates: candidates.slice(0, 16).map((candidate) => ({
+        agent_id: candidate.agent_id,
+        status: isCandidateLive(candidate, now) ? "online" : candidate.status,
+        source: candidate.source,
+        priority: candidate.priority,
+        last_seen_ms: candidate.last_seen_ms,
+        lease_expires_ms: candidate.lease_expires_ms,
+      })),
+    };
+  }
+
+  function ensureRoleLeader(
+    roleName,
+    { reason = "ensure", transferBacklog = true } = {},
+  ) {
+    const role = ensureRoleState(roleName);
+    if (!role) return null;
+    const now = Date.now();
+    const current =
+      role.leaderAgentId && buildRoleCandidate(role.leaderAgentId, role.role);
+    const best = chooseRoleLeader(role.role);
+    const currentLive = isCandidateLive(current, now);
+    const shouldPreemptFallback =
+      currentLive &&
+      current?.source === "topic-fallback" &&
+      best?.source === "explicit" &&
+      best.agent_id !== current.agent_id;
+
+    if (currentLive && !shouldPreemptFallback) {
+      role.status = "active";
+      role.leaderSource = current.source;
+      return buildRoleSnapshot(role.role);
+    }
+
+    if (!best) {
+      if (role.leaderAgentId) {
+        role.previousLeaderAgentId = role.leaderAgentId;
+        role.leaderAgentId = null;
+        role.leaderSource = null;
+        role.leaderEpoch += 1;
+        role.lastTransitionMs = Date.now();
+        role.lastReason = reason;
+      }
+      role.status = "offline";
+      return buildRoleSnapshot(role.role);
+    }
+
+    if (role.leaderAgentId !== best.agent_id) {
+      const previousLeaderAgentId = role.leaderAgentId;
+      role.previousLeaderAgentId =
+        previousLeaderAgentId || role.previousLeaderAgentId;
+      role.leaderAgentId = best.agent_id;
+      role.leaderSource = best.source;
+      role.leaderEpoch += 1;
+      role.status = "active";
+      role.lastTransitionMs = Date.now();
+      role.lastReason = reason;
+      if (transferBacklog) {
+        transferRoleBacklog(role.role, best.agent_id, previousLeaderAgentId);
+      }
+    }
+
+    return buildRoleSnapshot(role.role);
+  }
+
+  function getRoleSnapshot(roleName) {
+    return buildRoleSnapshot(roleName, { refreshCandidates: true });
+  }
+
   function trackMessage(message, recipients) {
     liveMessages.set(message.id, {
       message,
@@ -162,6 +533,14 @@ export function createRouter(store) {
     }
 
     const topic = to.slice(6);
+    if (ROLE_TOPICS.has(topic)) {
+      const role = ensureRoleLeader(topic, {
+        reason: "route",
+        transferBacklog: true,
+      });
+      return role?.leader_agent_id ? [role.leader_agent_id] : [];
+    }
+
     const recipients = new Set();
     for (const [agentId, topics] of runtimeTopics) {
       if (topics.has(topic)) recipients.add(agentId);
@@ -258,8 +637,10 @@ export function createRouter(store) {
       correlation_id,
     });
     const recipients = uniqueStrings(resolveRecipients(msg));
-    if (recipients.length) {
+    if (recipients.length || shouldTrackWithoutRecipients(msg)) {
       trackMessage(msg, recipients);
+    }
+    if (recipients.length) {
       for (const agentId of recipients) {
         queueMessage(agentId, msg);
       }
@@ -422,15 +803,37 @@ export function createRouter(store) {
     registerAgent(args) {
       const result = store.registerAgent(args);
       upsertRuntimeTopics(args.agent_id, args.topics || [], { replace: true });
+      refreshRoleCandidateForAgent(args.agent_id);
+      for (const roleName of ROLE_TOPICS) {
+        ensureRoleLeader(roleName, {
+          reason: "register",
+          transferBacklog: true,
+        });
+      }
       return result;
     },
 
     refreshAgentLease(agentId, ttlMs = 30000) {
-      return store.refreshLease(agentId, ttlMs);
+      const result = store.refreshLease(agentId, ttlMs);
+      refreshRoleCandidateForAgent(agentId);
+      for (const roleName of ROLE_TOPICS) {
+        ensureRoleLeader(roleName, {
+          reason: "heartbeat",
+          transferBacklog: true,
+        });
+      }
+      return result;
     },
 
     subscribeAgent(agentId, topics, { replace = false } = {}) {
       const nextTopics = upsertRuntimeTopics(agentId, topics, { replace });
+      refreshRoleCandidateForAgent(agentId);
+      for (const roleName of ROLE_TOPICS) {
+        ensureRoleLeader(roleName, {
+          reason: "subscribe",
+          transferBacklog: true,
+        });
+      }
       return { agent_id: agentId, topics: nextTopics };
     },
 
@@ -442,12 +845,25 @@ export function createRouter(store) {
       if (status === "offline") {
         runtimeTopics.delete(agentId);
       }
-      return store.updateAgentStatus(agentId, status);
+      const updated = store.updateAgentStatus(agentId, status);
+      refreshRoleCandidateForAgent(agentId);
+      for (const roleName of ROLE_TOPICS) {
+        ensureRoleLeader(roleName, {
+          reason: `status:${status}`,
+          transferBacklog: true,
+        });
+      }
+      return updated;
     },
 
     route(msg) {
       const recipients = uniqueStrings(resolveRecipients(msg));
-      if (!recipients.length) return 0;
+      if (!recipients.length) {
+        if (shouldTrackWithoutRecipients(msg) && !getMessageRecord(msg.id)) {
+          trackMessage(msg, []);
+        }
+        return 0;
+      }
       if (!getMessageRecord(msg.id)) {
         trackMessage(msg, recipients);
       }
@@ -462,6 +878,10 @@ export function createRouter(store) {
       return sortedPending(agentId, options);
     },
 
+    canReplayMessageForAgent(agentId, message) {
+      return isReplayAllowedForAgent(agentId, message);
+    },
+
     countPendingMessages(agentId) {
       const queue = ensureAgentQueue(agentId);
       const now = Date.now();
@@ -610,6 +1030,87 @@ export function createRouter(store) {
           message_id: msg.id,
           fanout_count: recipients.length,
           expires_at_ms: msg.expires_at_ms,
+          role: to === "topic:cto" ? getRoleSnapshot("cto") : undefined,
+        },
+      };
+    },
+
+    takeoverRole({
+      role = "cto",
+      agent_id,
+      reason = "manual",
+      requested_by = "manual",
+    } = {}) {
+      const roleName = normalizeRoleName(role);
+      if (!roleName) {
+        return {
+          ok: false,
+          error: {
+            code: "ROLE_NOT_SUPPORTED",
+            message: `unsupported role: ${role}`,
+          },
+        };
+      }
+      const targetAgentId = String(agent_id || "").trim();
+      if (!targetAgentId) {
+        return {
+          ok: false,
+          error: {
+            code: "AGENT_ID_REQUIRED",
+            message: "agent_id required",
+          },
+        };
+      }
+
+      refreshRoleCandidates(roleName);
+      const roleState = ensureRoleState(roleName);
+      const candidate = buildRoleCandidate(targetAgentId, roleName);
+      if (!isCandidateLive(candidate)) {
+        return {
+          ok: false,
+          error: {
+            code: "ROLE_CANDIDATE_UNAVAILABLE",
+            message: `${targetAgentId} is not a live ${roleName} candidate`,
+          },
+          data: {
+            role: buildRoleSnapshot(roleName),
+          },
+        };
+      }
+
+      const previousLeaderAgentId =
+        roleState.leaderAgentId && roleState.leaderAgentId !== targetAgentId
+          ? roleState.leaderAgentId
+          : roleState.previousLeaderAgentId || null;
+      const changed = roleState.leaderAgentId !== targetAgentId;
+      if (changed) {
+        roleState.previousLeaderAgentId = previousLeaderAgentId || null;
+        roleState.leaderAgentId = targetAgentId;
+        roleState.leaderSource = candidate.source;
+        roleState.leaderEpoch += 1;
+        roleState.status = "active";
+        roleState.lastTransitionMs = Date.now();
+        roleState.lastReason = reason || "manual";
+      }
+
+      const transfer = transferRoleBacklog(
+        roleName,
+        targetAgentId,
+        previousLeaderAgentId,
+      );
+      const snapshot = buildRoleSnapshot(roleName);
+      return {
+        ok: true,
+        data: {
+          role: roleName,
+          requested_by,
+          reason,
+          changed,
+          previous_leader_agent_id: previousLeaderAgentId,
+          leader_agent_id: snapshot.leader_agent_id,
+          leader_epoch: snapshot.leader_epoch,
+          ...transfer,
+          status: snapshot,
         },
       };
     },
@@ -897,6 +1398,9 @@ export function createRouter(store) {
           realtime_transport: "named-pipe",
           audit_store: store.type || "sqlite",
         };
+        data.roles = {
+          cto: getRoleSnapshot("cto"),
+        };
         if (include_metrics) {
           const depths = router.getQueueDepths();
           const stats = router.getDeliveryStats();
@@ -919,6 +1423,7 @@ export function createRouter(store) {
       if (scope === "agent" && agent_id) {
         const agent = store.getAgent(agent_id);
         if (agent) {
+          refreshRoleCandidateForAgent(agent_id);
           data.agent = {
             agent_id: agent.agent_id,
             status: agent.status,
@@ -926,6 +1431,18 @@ export function createRouter(store) {
             last_seen_ms: agent.last_seen_ms,
             topics: listRuntimeTopics(agent_id),
           };
+          const roles = {};
+          for (const roleName of ROLE_TOPICS) {
+            const candidate = buildRoleCandidate(agent_id, roleName);
+            if (candidate) {
+              roles[roleName] = {
+                candidate_source: candidate.source,
+                priority: candidate.priority,
+                leader: getRoleSnapshot(roleName)?.leader_agent_id === agent_id,
+              };
+            }
+          }
+          if (Object.keys(roles).length) data.agent.roles = roles;
         }
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/core",
-  "version": "10.39.0",
+  "version": "10.40.0",
   "description": "triflux core — CLI routing, pipeline, adapters. Zero native dependencies.",
   "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;
 }