triflux 10.43.0 → 10.44.0

package/hub/team/conductor.mjs

@@ -19,6 +19,8 @@ import {
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createRegistry } from "../../mesh/mesh-registry.mjs";
+import { resolveNestedCodexAgentProfile } from "../../scripts/lib/cli-codex.mjs";
+import { codexProfileConfigOverrides } from "../../scripts/lib/codex-profile-config.mjs";
 import { broker } from "../account-broker.mjs";
 import { runPreflight as runCodexPreflight } from "../codex-preflight.mjs";
 import {
@@ -608,7 +610,9 @@ export function createConductor(opts = {}) {
       cli: session.config.agent,
       prompt: session.config.prompt,
       profile: session.config.profile,
+      role: session.config.role,
       model: session.config.model,
+      env: session.config.env,
       mcpServers: session.config.mcpServers,
       excludeMcpServers,
       resolveCommand: opts.deps?.resolveCliExecutable,
@@ -902,8 +906,25 @@ export function createConductor(opts = {}) {
     } else if (agent === "gemini") {
       remoteBin = "gemini -y";
     } else {
-      remoteBin =
-        "codex exec -s danger-full-access --dangerously-bypass-approvals-and-sandbox";
+      const codexHome = session.config.env?.CODEX_HOME;
+      const profile = resolveNestedCodexAgentProfile(
+        session.config.role || "executor",
+        {
+          profileOverride: session.config.profile ?? "auto",
+          globalProfile:
+            session.config.env?.TFX_CODEX_PROFILE ??
+            process.env.TFX_CODEX_PROFILE,
+          codexHome,
+        },
+      );
+      const configArgs = codexProfileConfigOverrides(profile, {
+        codexHome,
+        disallowUltra: true,
+        enforceCanonicalProfile: true,
+      })
+        .map((override) => `-c '${override.replace(/'/g, `'\\''`)}'`)
+        .join(" ");
+      remoteBin = `codex exec${configArgs ? ` ${configArgs}` : ""} -s danger-full-access --dangerously-bypass-approvals-and-sandbox`;
     }
 
     // prompt는 stdin으로 전달 — 셸 이스케이프 문제 완전 회피

package/hub/team/execution-mode.mjs

@@ -2,7 +2,7 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve as pathResolve } from "node:path";
-
+import { resolveNestedCodexAgentProfile } from "../../scripts/lib/cli-codex.mjs";
 import { codexProfileConfigOverrides } from "../../scripts/lib/codex-profile-config.mjs";
 import { whichCommand } from "../platform.mjs";
 
@@ -160,7 +160,17 @@ export function buildSpawnSpecForMode(mode, opts = {}) {
   // 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)) {
+  const codexHome = opts.env?.CODEX_HOME;
+  const codexProfile = resolveNestedCodexAgentProfile(opts.role || "executor", {
+    profileOverride: opts.profile ?? "auto",
+    globalProfile: opts.env?.TFX_CODEX_PROFILE ?? process.env.TFX_CODEX_PROFILE,
+    codexHome,
+  });
+  for (const override of codexProfileConfigOverrides(codexProfile, {
+    codexHome,
+    disallowUltra: true,
+    enforceCanonicalProfile: true,
+  })) {
     args.push("-c", override);
   }
   if (Array.isArray(opts.mcpServers)) {

package/hub/team/headless.mjs

@@ -20,6 +20,7 @@ import net from "node:net";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolveNestedCodexAgentProfile } from "../../scripts/lib/cli-codex.mjs";
 import { requestJson } from "../bridge.mjs";
 import { escapePwshSingleQuoted } from "../cli-adapter-base.mjs";
 import { getMaxSpawnPerSec } from "../lib/spawn-trace.mjs";
@@ -366,6 +367,14 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
   writeFileSync(promptFile, fullPrompt, "utf8");
   void IS_WINDOWS; // referenced for diagnostic guard chain below
 
+  const codexProfile =
+    resolvedCli === "codex"
+      ? resolveNestedCodexAgentProfile(opts.role || cli, {
+          profileOverride: opts.profile ?? "auto",
+          globalProfile: process.env.TFX_CODEX_PROFILE,
+          codexHome: process.env.CODEX_HOME,
+        })
+      : undefined;
   const backendCommand =
     resolvedCli === "antigravity"
       ? buildRouteBackedHeadlessCommand(resolvedCli, promptFile, resultFile, {
@@ -375,6 +384,10 @@ export function buildHeadlessCommand(cli, prompt, resultFile, opts = {}) {
       : getBackend(resolvedCli).buildArgs(fullPrompt, resultFile, {
           ...opts,
           model,
+          profile: codexProfile,
+          codexHome: process.env.CODEX_HOME,
+          disallowUltra: true,
+          enforceCanonicalProfile: true,
           promptFile,
         });
   const safeCwd =
@@ -994,6 +1007,7 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
         mcp: assignment.mcp,
         role: assignment.role,
         model: assignment.model,
+        profile: assignment.profile,
         cwd: assignment.cwd || assignment.workdir,
       },
     );
@@ -1076,6 +1090,7 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
           mcp: assignment.mcp,
           role: assignment.role,
           model: assignment.model,
+          profile: assignment.profile,
           cwd: assignment.cwd || assignment.workdir,
         },
       );
@@ -1139,6 +1154,7 @@ async function dispatchDaemonBatch(sessionName, assignments, opts = {}) {
           mcp: assignment.mcp,
           role: assignment.role,
           model: assignment.model,
+          profile: assignment.profile,
           cwd: assignment.cwd || assignment.workdir,
         },
       );

package/hub/team/retry-state-machine.mjs

@@ -41,13 +41,13 @@ export const MODES = Object.freeze({
 const ESCALATION_CHAIN_CONFIG_PATH = ".triflux/config/escalation-chain.json";
 
 // Escalation chain (2026-05-27 정책):
-//   1. codex gpt-5.6-sol — 기존 최상위 Codex escalation 단계
+//   1. codex gpt-5.6-sol max — 최난도 단일 작업용 Codex escalation 단계
 //   2. claude opus-4-8 — 최종 수단
 const DEFAULT_ESCALATION_CHAIN = Object.freeze([
   Object.freeze({
     cli: "codex",
     model: "gpt-5.6-sol",
-    profile: "gpt56_sol_xhigh",
+    profile: "gpt56_sol_max",
   }),
   Object.freeze({ cli: "claude", model: "opus-4-8" }),
 ]);
@@ -295,7 +295,12 @@ function normalizeEscalationChainEntry(entry, index, source) {
     model: entry.model,
   };
   if (typeof entry.profile === "string" && entry.profile.trim() !== "") {
-    normalized.profile = entry.profile;
+    const profile = entry.profile.trim();
+    normalized.profile =
+      entry.cli === "codex" &&
+      (profile === "ultra" || profile === "gpt56_sol_ultra")
+        ? "gpt56_sol_max"
+        : profile;
   }
   return normalized;
 }

package/hub/team/swarm-hypervisor.mjs

@@ -678,6 +678,7 @@ export function createSwarmHypervisor(opts) {
     const config = {
       id: buildSwarmSessionId(shard),
       agent: shard.agent,
+      role: shard.role,
       // #125: append Completion Protocol appendix so workers emit a
       // sentinel-framed JSON payload that conductor can reliably capture.
       prompt: buildWorkerPrompt(shard.prompt, {

package/hub/team/swarm-preflight.mjs

@@ -1,6 +1,7 @@
 // hub/team/swarm-preflight.mjs — PRD swarm preflight report/gate (#188)
 // Predicts launch-time blockers before any worker session or worktree spawn.
 
+import { execFileSync } from "node:child_process";
 import { resolve } from "node:path";
 import { readHosts, resolveHost } from "../lib/hosts-compat.mjs";
 import { whichCommand } from "../platform.mjs";
@@ -83,6 +84,44 @@ function checkSensitive(plan, sensitiveDeny) {
   return makeCheck("sensitiveDeny", true, { matches });
 }
 
+function parseTrackedStatus(rawStatus) {
+  const files = [];
+  const records = String(rawStatus || "").split("\0");
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    if (record.length < 4) continue;
+    const status = record.slice(0, 2);
+    files.push(normalizePath(record.slice(3)));
+    if (/[RC]/u.test(status) && records[index + 1]) {
+      files.push(normalizePath(records[++index]));
+    }
+  }
+  return unique(files);
+}
+
+function checkRootDirtyLease(plan, repoRoot, deps = {}) {
+  const gitStatus =
+    deps.gitStatus ||
+    ((cwd) =>
+      execFileSync(
+        "git",
+        ["status", "--porcelain=v1", "-z", "--untracked-files=no"],
+        { cwd, encoding: "utf8", windowsHide: true },
+      ));
+  const dirtyFiles = parseTrackedStatus(gitStatus(repoRoot));
+  const leasedFiles = unique(
+    [...plan.leaseMap.values()].flat().map(normalizePath),
+  );
+  const leaseSet = new Set(leasedFiles);
+  const overlappingFiles = dirtyFiles.filter((file) => leaseSet.has(file));
+
+  return makeCheck("rootDirtyLease", overlappingFiles.length === 0, {
+    dirtyFiles,
+    leasedFiles,
+    overlappingFiles,
+  });
+}
+
 function checkHosts(plan, repoRoot) {
   const registry = readHosts(repoRoot);
   const missing = [];
@@ -216,6 +255,13 @@ function collectMessages(checks) {
     );
   }
 
+  const rootDirtyLease = checks.rootDirtyLease;
+  if (rootDirtyLease && !rootDirtyLease.ok) {
+    errors.push(
+      `rootDir tracked changes overlap shard leases: ${rootDirtyLease.overlappingFiles.join(", ")}`,
+    );
+  }
+
   return { errors: unique(errors), warnings: unique(warnings) };
 }
 
@@ -258,6 +304,7 @@ export function runSwarmPreflight(prdPath, opts = {}) {
     leases: makeCheck("leases", plan.conflicts.length === 0, {
       conflicts: [...plan.conflicts],
     }),
+    rootDirtyLease: checkRootDirtyLease(plan, repoRoot, opts.deps),
     sensitiveDeny: checkSensitive(plan, sensitiveDeny),
     hosts: checkHosts(plan, repoRoot),
     workerCli: checkLocalWorkerClis(plan, opts.deps),

package/hub/team/synapse-http.mjs

@@ -1,6 +1,9 @@
-import { readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { dirname, join } from "node:path";
+import { normalizeRoleKey } from "../role-contract.mjs";
 
 const HUB_DEFAULT_PORT = 27888;
 // Same token file as hub/bridge.mjs (HUB_TOKEN_FILE). Kept inline rather than
@@ -21,6 +24,144 @@ function normalizeToken(raw) {
   return token || null;
 }
 
+function opaqueId(prefix, value) {
+  return `${prefix}_${createHash("sha256")
+    .update(String(value || ""))
+    .digest("base64url")
+    .slice(0, 22)}`;
+}
+
+function normalizedProjectId(value) {
+  try {
+    return normalizeRoleKey({ project_id: value, role_kind: "cto" }).project_id;
+  } catch {
+    return "";
+  }
+}
+
+function resolveProjectId(cwd, meta, opts = {}) {
+  const explicit = meta?.project_id || process.env.TFX_PROJECT_ID;
+  if (explicit) return normalizedProjectId(explicit);
+  if (typeof opts.resolveProjectId === "function") {
+    return normalizedProjectId(opts.resolveProjectId(cwd));
+  }
+  let current = cwd;
+  while (current) {
+    const manifest = join(current, ".triflux", "project.json");
+    if (existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        if (parsed?.schema_version !== "tfx.project.v1") return "";
+        return normalizedProjectId(parsed.project_id);
+      } catch {
+        return "";
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return "";
+}
+
+function inferSessionCli(meta, opts = {}) {
+  const explicit = String(meta?.cli || meta?.actor_cli || "")
+    .trim()
+    .toLowerCase();
+  if (explicit === "codex" || explicit === "claude") return explicit;
+  const entrypoint = String(opts.entrypoint ?? process.argv[1] ?? "");
+  if (entrypoint.includes("codex-session-hook")) return "codex";
+  if (entrypoint.includes("agy-session-hook")) return "other";
+  return "claude";
+}
+
+function resolveTmuxSession(meta, opts = {}) {
+  const explicit =
+    meta?.tmux_session || meta?.session_name || process.env.TFX_TMUX_SESSION;
+  if (explicit) return String(explicit).trim();
+  if (!process.env.TMUX) return "";
+  try {
+    const run =
+      opts.tmuxSessionName ||
+      (() =>
+        execFileSync("tmux", ["display-message", "-p", "#{session_name}"], {
+          encoding: "utf8",
+          timeout: 200,
+          windowsHide: true,
+        }));
+    return String(run() || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+export function buildSynapseRegistrationMeta(meta, opts = {}) {
+  if (!meta || meta.sessionKind !== "interactive") return meta;
+  const sessionId = String(meta.sessionId || "").trim();
+  if (!sessionId) return meta;
+  const cwd = typeof meta.cwd === "string" ? meta.cwd : process.cwd();
+  const cli = inferSessionCli(meta, opts);
+  const hostId = String(
+    meta.host_id ||
+      process.env.TFX_HOST_ID ||
+      opaqueId("hst", opts.hostname?.() || hostname()),
+  ).trim();
+  const expiresAtMs = Number(opts.nowMs?.() ?? Date.now()) + 299000;
+  const transportLocators = [];
+  if (cli === "claude") {
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `claude-uds:${hostId}:${sessionId}`),
+      kind: "claude-uds",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: 100,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_id: sessionId,
+        bridge_id: String(
+          meta.bridge_id || process.env.TFX_BRIDGE_ID || "local-hub",
+        ),
+      },
+    });
+  }
+  const tmuxSession = resolveTmuxSession(meta, opts);
+  if (tmuxSession) {
+    const muxServerSource =
+      meta.mux_server_id ||
+      process.env.TFX_MUX_SERVER_ID ||
+      String(process.env.TMUX || "default").split(",", 1)[0];
+    transportLocators.push({
+      schema_version: "tfx.transport-locator.v1",
+      transport_id: opaqueId("trn", `tmux:${hostId}:${tmuxSession}`),
+      kind: "tmux",
+      host_id: hostId,
+      capabilities: ["probe", "wake", "activate", "interrupt"],
+      priority: cli === "codex" ? 100 : 50,
+      expires_at_ms: expiresAtMs,
+      locator: {
+        session_name: tmuxSession,
+        mux_server_id: opaqueId("mux", muxServerSource),
+      },
+    });
+  }
+  const directAgentId = `session:${sessionId}`;
+  return {
+    ...meta,
+    agent_id:
+      meta.agent_id ||
+      (directAgentId.length <= 64 && /^[a-zA-Z0-9._:-]+$/u.test(directAgentId)
+        ? directAgentId
+        : opaqueId("session", sessionId)),
+    cli,
+    project_id: resolveProjectId(cwd, meta, opts) || undefined,
+    session_id: meta.session_id || sessionId,
+    host_id: hostId,
+    transport_locators_json:
+      meta.transport_locators_json ?? JSON.stringify(transportLocators),
+  };
+}
+
 // Mirrors hub/bridge.mjs:readHubToken — env override first, then the token file.
 // Missing token → null (backward-compatible with token-less hubs).
 function readHubToken() {
@@ -139,7 +280,11 @@ export function drainPendingSynapse(timeoutMs = 1000) {
 }
 
 export function registerSynapseSession(meta, opts = {}) {
-  return fireAndForgetSynapse("/synapse/register", meta, opts);
+  return fireAndForgetSynapse(
+    "/synapse/register",
+    buildSynapseRegistrationMeta(meta, opts),
+    opts,
+  );
 }
 
 export function heartbeatSynapseSession(

package/hub/team/worktree-lifecycle.mjs

@@ -4,8 +4,16 @@
 // Remote support: host option → SSH-based git operations via remote-session.mjs.
 
 import { execFile } from "node:child_process";
-import { access, mkdir, readdir, realpath, rm } from "node:fs/promises";
-import { normalize, relative, resolve } from "node:path";
+import {
+  access,
+  mkdir,
+  mkdtemp,
+  readdir,
+  realpath,
+  rm,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, normalize, relative, resolve } from "node:path";
 import { remoteGit, validateHost } from "./remote-session.mjs";
 
 const SWARM_ROOT = ".codex-swarm";
@@ -327,24 +335,23 @@ export async function rebaseShardOntoIntegration({
     }
   }
 
-  // #127 BUG-E: capture caller's branch BEFORE any checkout. Without
-  // restoring it in finally, this function leaks main repo HEAD onto
-  // integrationBranch and every subsequent Edit/commit lands on the swarm
-  // temp branch silently (observed 2026-04-20: probe + edits + commits all
-  // ended up on swarm/.../merge while user thought they were on main).
-  let originalBranch = null;
-  try {
-    const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], rootDir);
-    if (head && head !== "HEAD") originalBranch = head;
-  } catch {
-    /* detached HEAD or unknown — skip restore */
-  }
-
-  // Backup integration HEAD for rollback
+  // #127 BUG-E accident history: this function used to checkout the
+  // integration branch in rootDir, leak rootDir HEAD, and redirect later user
+  // edits/commits into swarm/.../merge. Integration now happens exclusively in
+  // a disposable worktree, so rootDir HEAD never moves and needs no restore.
+  //
+  // #129 BUG-J accident history: checkout failure was followed by a blind
+  // reset --hard (or branch -f rollback) against rootDir, which rewound the
+  // caller branch. Rollback now resets only the disposable worktree; there is
+  // no rootDir reset path and therefore no stash-create last-resort path.
   const backupCommit = await git(["rev-parse", integrationBranch], rootDir);
 
   let shaList = [];
   let ffError = null;
+  let integrationWorktreeAdded = false;
+  const integrationWorktree = await mkdtemp(
+    join(tmpdir(), "tfx-swarm-integration-"),
+  );
 
   try {
     const log = await git(
@@ -361,11 +368,15 @@ export async function rebaseShardOntoIntegration({
       .map((s) => s.trim())
       .filter(Boolean);
 
-    await git(["checkout", integrationBranch], rootDir);
+    await git(
+      ["worktree", "add", "--quiet", integrationWorktree, integrationBranch],
+      rootDir,
+    );
+    integrationWorktreeAdded = true;
 
     try {
-      await git(["merge", "--ff-only", shardBranch], rootDir);
-      const headCommit = await git(["rev-parse", "HEAD"], rootDir);
+      await git(["merge", "--ff-only", shardBranch], integrationWorktree);
+      const headCommit = await git(["rev-parse", "HEAD"], integrationWorktree);
       return {
         ok: true,
         headCommit,
@@ -376,12 +387,15 @@ export async function rebaseShardOntoIntegration({
     } catch (err) {
       ffError = err;
       try {
-        await git(["merge", "--abort"], rootDir);
+        await git(["merge", "--abort"], integrationWorktree);
       } catch {
         /* ff-only usually leaves no merge state */
       }
       try {
-        await git(["reset", "--hard", backupCommit], rootDir);
+        // Safe destructive operation: this cwd is the disposable integration
+        // worktree, never rootDir. It restores the integration ref before the
+        // cherry-pick fallback without touching user files.
+        await git(["reset", "--hard", backupCommit], integrationWorktree);
       } catch {
         /* fallback below will report if cherry-pick also fails */
       }
@@ -391,10 +405,10 @@ export async function rebaseShardOntoIntegration({
     // fail when histories diverge or a shard branch is checked out by a swarm
     // worktree. Cherry-pick reads commits without moving the shard branch ref.
     for (const sha of shaList) {
-      await git(["cherry-pick", sha], rootDir);
+      await git(["cherry-pick", sha], integrationWorktree);
     }
 
-    const headCommit = await git(["rev-parse", "HEAD"], rootDir);
+    const headCommit = await git(["rev-parse", "HEAD"], integrationWorktree);
     return {
       ok: true,
       headCommit,
@@ -406,42 +420,17 @@ export async function rebaseShardOntoIntegration({
         : "cherry-pick fallback",
     };
   } catch (err) {
-    try {
-      await git(["cherry-pick", "--abort"], rootDir);
-    } catch {
-      /* already clean */
-    }
-
-    // #129 BUG-J: Roll back integrationBranch without mutating whatever
-    // branch HEAD currently points at. The previous implementation did a
-    // blind `reset --hard backupCommit` on current HEAD — if the earlier
-    // `git checkout integrationBranch` inside the try block failed (e.g.
-    // integrationBranch was already checked out by a swarm worktree) the
-    // caller's branch silently rewound to integrationBranch's backup commit.
-    // Observed 2026-04-20: fix branch tree lost to main HEAD during swarm
-    // probe, requiring `git merge --ff-only origin/<branch>` recovery.
-    let currentBranch = null;
-    try {
-      const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], rootDir);
-      if (head && head !== "HEAD") currentBranch = head;
-    } catch {
-      /* detached — fall through to ref-only update */
-    }
-
-    if (currentBranch === integrationBranch) {
-      // HEAD is on integrationBranch — reset advances this branch only.
+    if (integrationWorktreeAdded) {
       try {
-        await git(["reset", "--hard", backupCommit], rootDir);
+        await git(["cherry-pick", "--abort"], integrationWorktree);
       } catch {
-        /* best-effort */
+        /* already clean */
       }
-    } else {
-      // HEAD is elsewhere (originalBranch, detached, or another branch).
-      // Update the integrationBranch ref directly; never touch current HEAD.
       try {
-        await git(["branch", "-f", integrationBranch, backupCommit], rootDir);
+        // #129 rollback is now local to the disposable integration worktree.
+        await git(["reset", "--hard", backupCommit], integrationWorktree);
       } catch {
-        /* best-effort: branch may be checked out in another worktree */
+        /* best-effort */
       }
     }
 
@@ -453,14 +442,22 @@ export async function rebaseShardOntoIntegration({
       fallbackReason: ffError?.message || null,
     };
   } finally {
-    // Always restore caller's branch. Skip if originalBranch is null
-    // (detached HEAD case) or already on target.
-    if (originalBranch) {
+    if (integrationWorktreeAdded) {
       try {
-        await git(["checkout", originalBranch], rootDir);
+        await git(
+          ["worktree", "remove", "--force", integrationWorktree],
+          rootDir,
+        );
       } catch {
-        /* best-effort — caller will see HEAD on integrationBranch */
+        await rm(integrationWorktree, { recursive: true, force: true });
+        try {
+          await git(["worktree", "prune"], rootDir);
+        } catch {
+          /* best-effort metadata cleanup */
+        }
       }
+    } else {
+      await rm(integrationWorktree, { recursive: true, force: true });
     }
   }
 }

package/hub/tools.mjs

@@ -153,6 +153,17 @@ export function createTools(store, router, hitl, pipe = null) {
           },
           topics: { type: "array", items: { type: "string" }, maxItems: 64 },
           metadata: { type: "object" },
+          project_id: { type: "string", pattern: "^prj_[A-Za-z0-9_-]{22}$" },
+          session_id: { type: "string", minLength: 1, maxLength: 256 },
+          host_id: { type: "string", pattern: "^hst_[A-Za-z0-9_-]+$" },
+          transport_locators_json: {
+            description:
+              "tfx.transport-locator.v1 객체 배열 또는 그 JSON 문자열",
+            oneOf: [
+              { type: "array", items: { type: "object" } },
+              { type: "string" },
+            ],
+          },
           heartbeat_ttl_ms: {
             type: "integer",
             minimum: 10000,

package/hub/workers/codex-mcp.mjs

@@ -146,9 +146,11 @@ export function resolveCodexProfileConfig(profileName) {
   } catch {
     // Profile file absent (non-file alias). Derive effort from the naming
     // convention; leave model unset so codex uses its config.toml default.
-    const suffix = /_(xhigh|high|med|medium|low)$/.exec(profileName);
+    const suffix = /_(ultra|max|xhigh|high|med|medium|low)$/.exec(profileName);
     if (suffix) {
       const map = {
+        ultra: "ultra",
+        max: "max",
         xhigh: "xhigh",
         high: "high",
         med: "medium",
@@ -193,16 +195,27 @@ export function buildCodexArguments(prompt, opts = {}) {
   // profile effort merges on top of any opts.config.
   if (typeof opts.profile === "string" && opts.profile) {
     const resolved = resolveCodexProfileConfig(opts.profile);
-    if (resolved.model && typeof args.model !== "string") {
-      args.model = resolved.model;
+    const profileDerivedUltra =
+      resolved.reasoningEffort?.toLowerCase() === "ultra";
+    if (typeof args.model !== "string") {
+      if (profileDerivedUltra) args.model = "gpt-5.6-sol";
+      else if (resolved.model) args.model = resolved.model;
     }
     if (resolved.reasoningEffort) {
       args.config = {
         ...(args.config || {}),
-        model_reasoning_effort: resolved.reasoningEffort,
+        model_reasoning_effort: profileDerivedUltra
+          ? "max"
+          : resolved.reasoningEffort,
       };
     }
   }
+  if (typeof opts.reasoningEffort === "string" && opts.reasoningEffort) {
+    args.config = {
+      ...(args.config || {}),
+      model_reasoning_effort: opts.reasoningEffort,
+    };
+  }
 
   return args;
 }
@@ -694,6 +707,9 @@ function parseCliArgs(argv) {
       case "--model":
         options.model = next();
         break;
+      case "--reasoning-effort":
+        options.reasoningEffort = next();
+        break;
       case "--approval-policy":
         options.approvalPolicy = next();
         break;