bosun 0.34.5 → 0.34.7

package/agent-hook-bridge.mjs

@@ -2,6 +2,7 @@
 
 import { readFileSync } from "node:fs";
 import { executeBlockingHooks, executeHooks, loadHooks, registerBuiltinHooks } from "./agent-hooks.mjs";
+import { shouldRunAgentHookBridge } from "./task-context.mjs";
 
 const TAG = "[agent-hook-bridge]";
 
@@ -161,12 +162,11 @@ function mapEvents(sourceEvent, payload) {
 }
 
 async function run() {
-  // ── VE_MANAGED guard ──────────────────────────────────────────────────────
-  // Only execute hooks for sessions managed by bosun.
-  // bosun sets VE_MANAGED=1 in all spawned agent environments.
-  // If this env var is missing, we're running inside a standalone agent session
-  // that just happens to have the hook files in its config — exit silently.
-  if (!process.env.VE_MANAGED && !process.env.BOSUN_HOOKS_FORCE) {
+  // ── task-context guard ────────────────────────────────────────────────────
+  // Execute hooks only for active Bosun task sessions.
+  // This prevents globally scaffolded hook configs from affecting standalone
+  // sessions in user repos. BOSUN_HOOKS_FORCE remains an explicit override.
+  if (!shouldRunAgentHookBridge(process.env)) {
     process.exit(0);
   }
 

package/agent-pool.mjs

@@ -45,6 +45,16 @@ import { loadConfig } from "./config.mjs";
 import { resolveRepoRoot, resolveAgentRepoRoot } from "./repo-root.mjs";
 import { resolveCodexProfileRuntime } from "./codex-model-profiles.mjs";
 
+// Lazy-load MCP registry to avoid circular dependencies.
+// Cached at module scope per AGENTS.md hard rules.
+let _mcpRegistry = null;
+async function getMcpRegistry() {
+  if (!_mcpRegistry) {
+    _mcpRegistry = await import("./mcp-registry.mjs");
+  }
+  return _mcpRegistry;
+}
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
@@ -897,7 +907,7 @@ async function launchCodexThread(prompt, cwd, timeoutMs, extra = {}) {
  * Build CLI arguments for ephemeral Copilot agent-pool sessions.
  * Mirrors copilot-shell.mjs buildCliArgs() for feature parity.
  */
-function buildPoolCopilotCliArgs() {
+function buildPoolCopilotCliArgs(mcpConfigPath) {
   const args = [];
   if (!envFlagEnabled(process.env.COPILOT_NO_EXPERIMENTAL)) {
     args.push("--experimental");
@@ -915,9 +925,10 @@ function buildPoolCopilotCliArgs() {
   if (envFlagEnabled(process.env.COPILOT_DISABLE_BUILTIN_MCPS)) {
     args.push("--disable-builtin-mcps");
   }
-  const mcpConfigPath = process.env.COPILOT_ADDITIONAL_MCP_CONFIG;
-  if (mcpConfigPath) {
-    args.push("--additional-mcp-config", mcpConfigPath);
+  // MCP config: prefer per-launch resolved config, fall back to env var
+  const effectiveMcpConfig = mcpConfigPath || process.env.COPILOT_ADDITIONAL_MCP_CONFIG;
+  if (effectiveMcpConfig) {
+    args.push("--additional-mcp-config", effectiveMcpConfig);
   }
   return args;
 }
@@ -1024,7 +1035,17 @@ async function launchCopilotThread(prompt, cwd, timeoutMs, extra = {}) {
         clientOpts = { cliUrl, env: clientEnv };
       } else {
         // Local mode (default): stdio for full capability
-        const cliArgs = buildPoolCopilotCliArgs();
+        // Write temp MCP config if resolved MCP servers are available
+        let mcpConfigPath = null;
+        if (extra._resolvedMcpServers?.length) {
+          try {
+            const registry = await getMcpRegistry();
+            mcpConfigPath = registry.writeTempCopilotMcpConfig(cwd, extra._resolvedMcpServers);
+          } catch (mcpErr) {
+            console.warn(`${TAG} copilot MCP config write failed (non-fatal): ${mcpErr.message}`);
+          }
+        }
+        const cliArgs = buildPoolCopilotCliArgs(mcpConfigPath);
         clientOpts = {
           cwd,
           env: clientEnv,
@@ -1465,6 +1486,27 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
   }
 
   // ── 4. Execute query ─────────────────────────────────────────────────────
+  // Inject MCP server config for Claude via environment variable
+  let _claudeMcpEnvCleanup = null;
+  if (extra._resolvedMcpServers?.length) {
+    try {
+      const registry = await getMcpRegistry();
+      const { envVar } = registry.buildClaudeMcpEnv(extra._resolvedMcpServers);
+      if (envVar) {
+        const prev = process.env.CLAUDE_MCP_SERVERS;
+        process.env.CLAUDE_MCP_SERVERS = envVar;
+        _claudeMcpEnvCleanup = () => {
+          if (prev === undefined) {
+            delete process.env.CLAUDE_MCP_SERVERS;
+          } else {
+            process.env.CLAUDE_MCP_SERVERS = prev;
+          }
+        };
+      }
+    } catch (mcpErr) {
+      console.warn(`${TAG} claude MCP env setup failed (non-fatal): ${mcpErr.message}`);
+    }
+  }
   try {
     const msgQueue = createMessageQueue();
 
@@ -1596,6 +1638,7 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
 
     const output =
       finalResponse.trim() || "(Agent completed with no text output)";
+    if (typeof _claudeMcpEnvCleanup === "function") _claudeMcpEnvCleanup();
     return {
       success: true,
       output,
@@ -1605,6 +1648,7 @@ async function launchClaudeThread(prompt, cwd, timeoutMs, extra = {}) {
       threadId: activeClaudeSessionId,
     };
   } catch (err) {
+    if (typeof _claudeMcpEnvCleanup === "function") _claudeMcpEnvCleanup();
     clearAbortScope();
     if (hardTimer) clearTimeout(hardTimer);
     if (steerKey) unregisterActiveSession(steerKey);
@@ -1714,6 +1758,32 @@ export async function launchEphemeralThread(
   timeoutMs = DEFAULT_TIMEOUT_MS,
   extra = {},
 ) {
+  // ── Resolve MCP servers for this launch ──────────────────────────────────
+  try {
+    if (!extra._mcpResolved) {
+      const cfg = loadConfig();
+      const mcpCfg = cfg.mcpServers || {};
+      if (mcpCfg.enabled !== false) {
+        const requestedIds = extra.mcpServers || [];
+        const defaultIds = mcpCfg.defaultServers || [];
+        if (requestedIds.length || defaultIds.length) {
+          const registry = await getMcpRegistry();
+          const resolved = await registry.resolveMcpServersForAgent(
+            cwd,
+            requestedIds,
+            { defaultServers: defaultIds, catalogOverrides: mcpCfg.catalogOverrides || {} },
+          );
+          if (resolved.length) {
+            extra._resolvedMcpServers = resolved;
+          }
+        }
+      }
+      extra._mcpResolved = true;
+    }
+  } catch (mcpErr) {
+    console.warn(`${TAG} MCP server resolution failed (non-fatal): ${mcpErr.message}`);
+  }
+
   // Determine the primary SDK to try
   const requestedSdk = extra.sdk
     ? String(extra.sdk).trim().toLowerCase()

package/bosun.schema.json

@@ -606,6 +606,37 @@
       "type": "object",
       "description": "Hook definitions loaded by agent-hooks.mjs (event -> hook list).",
       "additionalProperties": true
+    },
+    "mcpServers": {
+      "type": "object",
+      "description": "MCP (Model Context Protocol) server management. Controls which MCP servers are available to agents.",
+      "additionalProperties": false,
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable MCP server integration for agent launches"
+        },
+        "defaultServers": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "MCP server IDs attached to every agent launch by default (e.g. [\"context7\", \"microsoft-docs\"])"
+        },
+        "catalogOverrides": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "description": "Per-server environment variable overrides",
+            "additionalProperties": { "type": "string" }
+          },
+          "description": "Environment variable overrides keyed by MCP server ID"
+        },
+        "autoInstallDefaults": {
+          "type": "boolean",
+          "default": true,
+          "description": "Automatically install defaultServers from catalog if not already installed"
+        }
+      }
     }
   }
 }

package/cli.mjs

@@ -1484,14 +1484,21 @@ function detectExistingMonitorLockOwner(excludePid = null) {
   return null;
 }
 
-function runMonitor() {
+function runMonitor({ restartReason = "" } = {}) {
   return new Promise((resolve, reject) => {
     const monitorPath = fileURLToPath(
       new URL("./monitor.mjs", import.meta.url),
     );
+    const childEnv = { ...process.env };
+    if (restartReason) {
+      childEnv.BOSUN_MONITOR_RESTART_REASON = restartReason;
+    } else {
+      delete childEnv.BOSUN_MONITOR_RESTART_REASON;
+    }
     monitorChild = fork(monitorPath, process.argv.slice(2), {
       stdio: "inherit",
       execArgv: ["--max-old-space-size=4096"],
+      env: childEnv,
       windowsHide: IS_DAEMON_CHILD && process.platform === "win32",
     });
     daemonCrashTracker.markStart();
@@ -1504,7 +1511,7 @@ function runMonitor() {
           "\n  \u21BB Monitor restarting with fresh modules...\n",
         );
         // Small delay to let file writes / port releases settle
-        setTimeout(() => resolve(runMonitor()), 2000);
+        setTimeout(() => resolve(runMonitor({ restartReason: "self-restart" })), 2000);
       } else {
         const exitCode = code ?? (signal ? 1 : 0);
         const existingOwner =
@@ -1572,7 +1579,15 @@ function runMonitor() {
             restartAttempt: daemonRestartCount,
             maxRestarts: IS_DAEMON_CHILD ? DAEMON_MAX_RESTARTS : 0,
           }).catch(() => {});
-          setTimeout(() => resolve(runMonitor()), delayMs);
+          setTimeout(
+            () =>
+              resolve(
+                runMonitor({
+                  restartReason: isOSKill ? "os-kill" : "crash",
+                }),
+              ),
+            delayMs,
+          );
           return;
         }
 

package/codex-config.mjs

@@ -2,12 +2,15 @@
  * codex-config.mjs — Manages the Codex CLI config (~/.codex/config.toml)
  *
  * Ensures the user's Codex CLI configuration has:
- *   1. A vibe_kanban MCP server section with the correct env vars
- *   2. Sufficient stream_idle_timeout_ms on all model providers
- *   3. Recommended defaults for long-running agentic workloads
- *   4. Feature flags for sub-agents, memory, undo, collaboration
- *   5. Sandbox permissions and shell environment policy
- *   6. Common MCP servers (context7, microsoft-docs)
+ *   1. Sufficient stream_idle_timeout_ms on all model providers
+ *   2. Recommended defaults for long-running agentic workloads
+ *   3. Feature flags for sub-agents, memory, undo, collaboration
+ *   4. Sandbox permissions and shell environment policy
+ *   5. Common MCP servers (context7, microsoft-docs)
+ *
+ * NOTE: Vibe-Kanban MCP is workspace-scoped and managed by repo-config.mjs
+ * inside each repo's `.codex/config.toml`. Global config no longer auto-adds
+ * `[mcp_servers.vibe_kanban]`.
  *
  * SCOPE: This manages the GLOBAL ~/.codex/config.toml which contains:
  *   - Model provider configs (API keys, base URLs) — MUST be global
@@ -887,14 +890,17 @@ export function buildCommonMcpBlocks() {
     "",
     "# ── Common MCP servers (added by bosun) ──",
     "[mcp_servers.context7]",
+    "startup_timeout_sec = 120",
     'command = "npx"',
     'args = ["-y", "@upstash/context7-mcp"]',
     "",
     "[mcp_servers.sequential-thinking]",
+    "startup_timeout_sec = 120",
     'command = "npx"',
     'args = ["-y", "@modelcontextprotocol/server-sequential-thinking"]',
     "",
     "[mcp_servers.playwright]",
+    "startup_timeout_sec = 120",
     'command = "npx"',
     'args = ["-y", "@playwright/mcp@latest"]',
     "",
@@ -914,6 +920,44 @@ function hasNamedMcpServer(toml, name) {
   );
 }
 
+function ensureMcpStartupTimeout(toml, name, timeoutSec = 120) {
+  const header = `[mcp_servers.${name}]`;
+  const headerIdx = toml.indexOf(header);
+  if (headerIdx === -1) return { toml, changed: false };
+
+  const afterHeader = headerIdx + header.length;
+  const nextSection = toml.indexOf("\n[", afterHeader);
+  const sectionEnd = nextSection === -1 ? toml.length : nextSection;
+  let section = toml.substring(afterHeader, sectionEnd);
+
+  const timeoutRegex = /^startup_timeout_sec\s*=\s*\d+.*$/m;
+  let changed = false;
+  if (timeoutRegex.test(section)) {
+    const desired = `startup_timeout_sec = ${timeoutSec}`;
+    const updated = section.replace(timeoutRegex, desired);
+    if (updated !== section) {
+      section = updated;
+      changed = true;
+    }
+  } else {
+    section = section.trimEnd() + `\nstartup_timeout_sec = ${timeoutSec}\n`;
+    changed = true;
+  }
+
+  if (!changed) return { toml, changed: false };
+  return {
+    toml: toml.substring(0, afterHeader) + section + toml.substring(sectionEnd),
+    changed: true,
+  };
+}
+
+function stripDeprecatedSandboxPermissions(toml) {
+  return String(toml || "").replace(
+    /^\s*sandbox_permissions\s*=.*(?:\r?\n)?/gim,
+    "",
+  );
+}
+
 // ── Public API ───────────────────────────────────────────────────────────────
 
 /**
@@ -1264,13 +1308,15 @@ export function ensureRetrySettings(toml, providerName) {
  * @param {object} opts
  * @param {string}  [opts.vkBaseUrl]
  * @param {boolean} [opts.skipVk]
+ * @param {boolean} [opts.manageVkMcp]  Explicit opt-in to manage VK MCP in global config
  * @param {boolean} [opts.dryRun]  If true, returns result without writing
  * @param {object}  [opts.env]     Environment overrides (defaults to process.env)
  * @param {string}  [opts.primarySdk]  Primary agent SDK: "codex", "copilot", or "claude"
  */
 export function ensureCodexConfig({
   vkBaseUrl = "http://127.0.0.1:54089",
-  skipVk = false,
+  skipVk = true,
+  manageVkMcp = false,
   dryRun = false,
   env = process.env,
   primarySdk,
@@ -1298,6 +1344,208 @@ export function ensureCodexConfig({
     noChanges: true,
   };
 
+  const configExisted = existsSync(CONFIG_PATH);
+  const originalToml = readCodexConfig();
+  let toml = stripDeprecatedSandboxPermissions(originalToml);
+  if (!configExisted) {
+    result.created = true;
+    toml = "";
+  }
+
+  const sandboxModeResult = ensureTopLevelSandboxMode(
+    toml,
+    env.CODEX_SANDBOX_MODE,
+  );
+  toml = sandboxModeResult.toml;
+  if (sandboxModeResult.changed) {
+    result.sandboxAdded = true;
+  }
+
+  const repoRoot =
+    env.BOSUN_AGENT_REPO_ROOT ||
+    env.REPO_ROOT ||
+    env.BOSUN_HOME ||
+    process.cwd();
+  const additionalRoots = env.BOSUN_WORKSPACES_DIR
+    ? [env.BOSUN_WORKSPACES_DIR]
+    : [];
+  const sandboxWorkspaceResult = ensureSandboxWorkspaceWrite(toml, {
+    repoRoot,
+    additionalRoots,
+    writableRoots: env.CODEX_SANDBOX_WRITABLE_ROOTS,
+  });
+  toml = sandboxWorkspaceResult.toml;
+  result.sandboxWorkspaceAdded = sandboxWorkspaceResult.added;
+  result.sandboxWorkspaceUpdated =
+    sandboxWorkspaceResult.changed && !sandboxWorkspaceResult.added;
+  result.sandboxWorkspaceRootsAdded = sandboxWorkspaceResult.rootsAdded;
+
+  const pruneResult = pruneStaleSandboxRoots(toml);
+  toml = pruneResult.toml;
+  result.sandboxStaleRootsRemoved = pruneResult.removed;
+
+  if (!hasShellEnvPolicy(toml)) {
+    toml += buildShellEnvPolicy(env.CODEX_SHELL_ENV_POLICY || "all");
+    result.shellEnvAdded = true;
+  }
+
+  const rawPrimary = String(primarySdk || env.PRIMARY_AGENT || "codex")
+    .trim()
+    .toLowerCase();
+  const normalizedPrimary =
+    rawPrimary === "copilot" || rawPrimary.includes("copilot")
+      ? "copilot"
+      : rawPrimary === "claude" || rawPrimary.includes("claude")
+        ? "claude"
+        : rawPrimary === "codex" || rawPrimary.includes("codex")
+          ? "codex"
+          : "codex";
+  if (!hasAgentSdkConfig(toml)) {
+    toml += buildAgentSdkBlock({ primary: normalizedPrimary });
+    result.agentSdkAdded = true;
+  }
+
+  const maxThreads = resolveAgentMaxThreads(env);
+  if (maxThreads.explicit && !maxThreads.value) {
+    result.agentMaxThreadsSkipped = String(maxThreads.raw);
+  } else {
+    const maxThreadsResult = ensureAgentMaxThreads(toml, {
+      maxThreads: maxThreads.value,
+      overwrite: maxThreads.explicit,
+    });
+    toml = maxThreadsResult.toml;
+    if (maxThreadsResult.changed && !maxThreadsResult.skipped) {
+      result.agentMaxThreads = {
+        from: maxThreadsResult.existing,
+        to: maxThreadsResult.applied,
+        explicit: maxThreads.explicit,
+      };
+    } else if (maxThreadsResult.skipped && maxThreads.explicit) {
+      result.agentMaxThreadsSkipped = String(maxThreads.raw);
+    }
+  }
+
+  const featureResult = ensureFeatureFlags(toml, env);
+  result.featuresAdded = featureResult.added;
+  toml = featureResult.toml;
+
+  const shouldManageGlobalVkMcp = Boolean(manageVkMcp) && !skipVk;
+  if (!shouldManageGlobalVkMcp) {
+    if (hasVibeKanbanMcp(toml)) {
+      toml = removeVibeKanbanMcp(toml);
+      result.vkRemoved = true;
+    }
+  } else if (!hasVibeKanbanMcp(toml)) {
+    toml += buildVibeKanbanBlock({ vkBaseUrl });
+    result.vkAdded = true;
+  } else {
+    const vkEnvValues = {
+      VK_BASE_URL: vkBaseUrl,
+      VK_ENDPOINT_URL: vkBaseUrl,
+    };
+    const beforeVkEnv = toml;
+    if (!hasVibeKanbanEnv(toml)) {
+      toml =
+        toml.trimEnd() +
+        "\n\n[mcp_servers.vibe_kanban.env]\n" +
+        `VK_BASE_URL = "${vkBaseUrl}"\n` +
+        `VK_ENDPOINT_URL = "${vkBaseUrl}"\n`;
+    } else {
+      toml = updateVibeKanbanEnv(toml, vkEnvValues);
+    }
+    if (toml !== beforeVkEnv) {
+      result.vkEnvUpdated = true;
+    }
+  }
+
+  const commonMcpBlocks = [
+    {
+      present: hasContext7Mcp(toml),
+      block: [
+        "",
+        "# ── Common MCP servers (added by bosun) ──",
+        "[mcp_servers.context7]",
+        "startup_timeout_sec = 120",
+        'command = "npx"',
+        'args = ["-y", "@upstash/context7-mcp"]',
+        "",
+      ].join("\n"),
+    },
+    {
+      present: hasNamedMcpServer(toml, "sequential-thinking"),
+      block: [
+        "",
+        "[mcp_servers.sequential-thinking]",
+        "startup_timeout_sec = 120",
+        'command = "npx"',
+        'args = ["-y", "@modelcontextprotocol/server-sequential-thinking"]',
+        "",
+      ].join("\n"),
+    },
+    {
+      present: hasNamedMcpServer(toml, "playwright"),
+      block: [
+        "",
+        "[mcp_servers.playwright]",
+        "startup_timeout_sec = 120",
+        'command = "npx"',
+        'args = ["-y", "@playwright/mcp@latest"]',
+        "",
+      ].join("\n"),
+    },
+    {
+      present: hasMicrosoftDocsMcp(toml),
+      block: [
+        "",
+        "[mcp_servers.microsoft-docs]",
+        'url = "https://learn.microsoft.com/api/mcp"',
+        'tools = ["microsoft_docs_search", "microsoft_code_sample_search"]',
+        "",
+      ].join("\n"),
+    },
+  ];
+  for (const item of commonMcpBlocks) {
+    if (item.present) continue;
+    toml += item.block;
+    result.commonMcpAdded = true;
+  }
+
+  for (const serverName of ["context7", "sequential-thinking", "playwright"]) {
+    const timeoutResult = ensureMcpStartupTimeout(toml, serverName, 120);
+    toml = timeoutResult.toml;
+  }
+
+  const providerResult = ensureModelProviderSectionsFromEnv(toml, env);
+  toml = providerResult.toml;
+  result.profileProvidersAdded = providerResult.added;
+
+  const timeoutAudit = auditStreamTimeouts(toml);
+  for (const item of timeoutAudit) {
+    if (!item.needsUpdate) continue;
+    toml = setStreamTimeout(toml, item.provider, RECOMMENDED_STREAM_IDLE_TIMEOUT_MS);
+    result.timeoutsFixed.push({
+      provider: item.provider,
+      from: item.currentValue,
+      to: RECOMMENDED_STREAM_IDLE_TIMEOUT_MS,
+    });
+  }
+
+  const providers = auditStreamTimeouts(toml).map((item) => item.provider);
+  for (const provider of providers) {
+    const beforeRetry = toml;
+    toml = ensureRetrySettings(toml, provider);
+    if (toml !== beforeRetry) {
+      result.retriesAdded.push(provider);
+    }
+  }
+
+  const changed = toml !== originalToml;
+  result.noChanges = !result.created && !changed;
+
+  if (!dryRun && (result.created || changed)) {
+    writeCodexConfig(toml);
+  }
+
   return result;
 }
 
@@ -1322,7 +1570,7 @@ export function printConfigSummary(result, log = console.log) {
   }
 
   if (result.vkRemoved) {
-    log("  🗑️  Removed Vibe-Kanban MCP server (VK backend not active)");
+    log("  🗑️  Removed Vibe-Kanban MCP server from global config (workspace-scoped only)");
   }
 
   if (result.vkEnvUpdated) {

package/config.mjs

@@ -29,6 +29,7 @@ import { applyAllCompatibility } from "./compat.mjs";
 import {
   normalizeExecutorKey,
   getModelsForExecutor,
+  MODEL_ALIASES,
 } from "./task-complexity.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -408,13 +409,43 @@ function parseListValue(value) {
     .filter(Boolean);
 }
 
-function normalizeExecutorModels(executor, models) {
+function inferExecutorModelsFromVariant(executor, variant) {
+  const normalizedExecutor = normalizeExecutorKey(executor);
+  if (!normalizedExecutor) return [];
+  const normalizedVariant = String(variant || "DEFAULT")
+    .trim()
+    .toUpperCase();
+  if (!normalizedVariant || normalizedVariant === "DEFAULT") return [];
+
+  const known = getModelsForExecutor(normalizedExecutor);
+  const inferred = known.filter((model) => {
+    const alias = MODEL_ALIASES[model];
+    return (
+      String(alias?.variant || "")
+        .trim()
+        .toUpperCase() === normalizedVariant
+    );
+  });
+  if (inferred.length > 0) return inferred;
+
+  // Fallback for variants encoded as model slug with underscores.
+  const slugGuess = normalizedVariant.toLowerCase().replaceAll("_", "-");
+  if (known.includes(slugGuess)) return [slugGuess];
+
+  return [];
+}
+
+function normalizeExecutorModels(executor, models, variant = "DEFAULT") {
   const normalizedExecutor = normalizeExecutorKey(executor);
   if (!normalizedExecutor) return [];
   const input = parseListValue(models);
   const known = new Set(getModelsForExecutor(normalizedExecutor));
   if (input.length === 0) {
-    return [...known];
+    const inferred = inferExecutorModelsFromVariant(
+      normalizedExecutor,
+      variant,
+    );
+    return inferred.length > 0 ? inferred : [...known];
   }
   return input.filter((model) => known.has(model));
 }
@@ -433,7 +464,7 @@ function normalizeExecutorEntry(entry, index = 0, total = 1) {
   const name =
     String(entry.name || "").trim() ||
     `${normalized}-${String(variant || "default").toLowerCase()}`;
-  const models = normalizeExecutorModels(executorType, entry.models);
+  const models = normalizeExecutorModels(executorType, entry.models, variant);
   const codexProfile = String(
     entry.codexProfile || entry.modelProfile || "",
   ).trim();
@@ -723,7 +754,11 @@ function parseExecutorsFromEnv() {
     const parts = entries[i].split(":");
     if (parts.length < 2) continue;
     const executorType = parts[0].toUpperCase();
-    const models = normalizeExecutorModels(executorType, parts[3] || "");
+    const models = normalizeExecutorModels(
+      executorType,
+      parts[3] || "",
+      parts[1] || "DEFAULT",
+    );
     executors.push({
       name: `${parts[0].toLowerCase()}-${parts[1].toLowerCase()}`,
       executor: executorType,
@@ -857,12 +892,23 @@ function loadExecutorConfig(configDir, configData) {
 
     for (let index = 0; index < executors.length; index++) {
       const current = executors[index];
-      if (current.codexProfile) continue;
       const match = findExecutorMetadataMatch(current, fileExecutors, index);
-      if (!match?.codexProfile) continue;
+      if (!match) continue;
+      const merged = { ...current };
+      if (typeof match.name === "string" && match.name.trim()) {
+        merged.name = match.name.trim();
+      }
+      if (typeof match.enabled === "boolean") {
+        merged.enabled = match.enabled;
+      }
+      if (Array.isArray(match.models) && match.models.length > 0) {
+        merged.models = [...new Set(match.models)];
+      }
+      if (match.codexProfile) {
+        merged.codexProfile = match.codexProfile;
+      }
       executors[index] = {
-        ...current,
-        codexProfile: match.codexProfile,
+        ...merged,
       };
     }
   }