agentloom 0.1.12 → 0.1.13

package/README.md

@@ -202,13 +202,24 @@ claude:
   model: sonnet
 codex:
   model: gpt-5-codex
-  reasoningEffort: medium
-  webSearch: true
+  model_reasoning_effort: medium
+  web_search: true
 ---
 
 You are a strict reviewer...
 ```
 
+For Codex, provider-native config keys are passed through to the generated
+`.codex/agents/<role>.toml` as a thin layer. Prefer Codex's native snake_case
+keys such as `approval_policy`, `approvals_reviewer`, or `web_search`. Existing
+camelCase aliases like `reasoningEffort` are still normalized for
+backward-compatibility.
+
+Current `codex-cli 0.121.0` exposes spawn-time controls such as `fork_context` and
+`fork_turns` only on the `spawn_agent` tool path, not in static role/config
+files, so Codex itself will warn or ignore them if you place them under
+`codex:` in canonical frontmatter today.
+
 ## Command schema
 
 Canonical commands are markdown files. Frontmatter is optional. When present,

package/dist/core/codex.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeCodexConfigForToml(providerConfig: Record<string, unknown>): Record<string, unknown>;
+export declare function cloneCodexProviderConfig(providerConfig: Record<string, unknown>): Record<string, unknown>;
+export declare function stripManagedCodexInstructionKeys(providerConfig: Record<string, unknown>): Record<string, unknown>;

package/dist/core/codex.js

@@ -0,0 +1,72 @@
+import { isObject } from "./fs.js";
+const MANAGED_INSTRUCTION_KEYS = new Set([
+    "developerInstructions",
+    "developer_instructions",
+    "modelInstructionsFile",
+    "model_instructions_file",
+]);
+const LEGACY_CODEX_ALIASES = {
+    approvalPolicy: "approval_policy",
+    reasoningEffort: "model_reasoning_effort",
+    reasoningSummary: "model_reasoning_summary",
+    sandboxMode: "sandbox_mode",
+    verbosity: "model_verbosity",
+    webSearch: "web_search",
+};
+export function normalizeCodexConfigForToml(providerConfig) {
+    const normalized = normalizeCodexValueForToml(providerConfig);
+    if (!isObject(normalized)) {
+        return {};
+    }
+    for (const key of MANAGED_INSTRUCTION_KEYS) {
+        delete normalized[key];
+    }
+    return normalized;
+}
+export function cloneCodexProviderConfig(providerConfig) {
+    const cloned = cloneCodexValue(providerConfig);
+    if (!isObject(cloned)) {
+        return {};
+    }
+    return cloned;
+}
+export function stripManagedCodexInstructionKeys(providerConfig) {
+    const cleaned = cloneCodexProviderConfig(providerConfig);
+    for (const key of MANAGED_INSTRUCTION_KEYS) {
+        delete cleaned[key];
+    }
+    return cleaned;
+}
+function normalizeCodexValueForToml(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeCodexValueForToml(entry));
+    }
+    if (!isObject(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        toSnakeCase(key),
+        normalizeCodexValueForToml(entry),
+    ]));
+}
+function cloneCodexValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneCodexValue(entry));
+    }
+    if (!isObject(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneCodexValue(entry)]));
+}
+function toSnakeCase(key) {
+    if (Object.prototype.hasOwnProperty.call(LEGACY_CODEX_ALIASES, key)) {
+        return LEGACY_CODEX_ALIASES[key];
+    }
+    if (!/[A-Z]/.test(key)) {
+        return key;
+    }
+    return key
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase();
+}

package/dist/core/migration.js

@@ -6,6 +6,7 @@ import TOML from "@iarna/toml";
 import matter from "gray-matter";
 import YAML from "yaml";
 import { buildAgentMarkdown, parseAgentsDir } from "./agents.js";
+import { cloneCodexProviderConfig, stripManagedCodexInstructionKeys, } from "./codex.js";
 import { normalizeCommandArgumentsForCanonical, parseCommandsDir, } from "./commands.js";
 import { ensureDir, isObject, readJsonIfExists, slugify } from "./fs.js";
 import { readLockfile, writeLockfile } from "./lockfile.js";
@@ -394,33 +395,7 @@ function readCodexProviderAgents(paths) {
         const description = isObject(roleEntry) && typeof roleEntry.description === "string"
             ? roleEntry.description.trim()
             : roleName;
-        const providerConfig = {};
-        if (typeof roleToml.model === "string") {
-            providerConfig.model = roleToml.model;
-        }
-        if (typeof roleToml.model_reasoning_effort === "string") {
-            providerConfig.reasoningEffort = roleToml.model_reasoning_effort;
-        }
-        if (typeof roleToml.model_reasoning_summary === "string") {
-            providerConfig.reasoningSummary = roleToml.model_reasoning_summary;
-        }
-        if (typeof roleToml.model_verbosity === "string") {
-            providerConfig.verbosity = roleToml.model_verbosity;
-        }
-        if (typeof roleToml.approval_policy === "string") {
-            providerConfig.approvalPolicy = roleToml.approval_policy;
-        }
-        if (typeof roleToml.sandbox_mode === "string") {
-            providerConfig.sandboxMode = roleToml.sandbox_mode;
-        }
-        if (typeof roleToml.web_search === "boolean") {
-            providerConfig.webSearch = roleToml.web_search;
-        }
-        if (typeof providerConfig.webSearch !== "boolean" &&
-            isObject(roleToml.tools) &&
-            typeof roleToml.tools.web_search === "boolean") {
-            providerConfig.webSearch = roleToml.tools.web_search;
-        }
+        const providerConfig = stripManagedCodexInstructionKeys(cloneCodexProviderConfig(roleToml));
         records.push({
             provider: "codex",
             sourcePath: roleTomlPath,

package/dist/sync/index.js

@@ -6,6 +6,7 @@ import YAML from "yaml";
 import { ALL_PROVIDERS } from "../types.js";
 import { getProviderConfig, isProviderEnabled, parseAgentsDir, } from "../core/agents.js";
 import { parseCommandsDir, renderCommandForProvider, } from "../core/commands.js";
+import { normalizeCodexConfigForToml } from "../core/codex.js";
 import { parseRulesDir, renderRuleForCursor, upsertManagedRuleBlocks, } from "../core/rules.js";
 import { ensureDir, isObject, readJsonIfExists, readTextIfExists, relativePosix, removeFileIfExists, slugify, toPosixPath, writeJsonAtomic, writeTextAtomic, } from "../core/fs.js";
 import { readManifest, writeManifest } from "../core/manifest.js";
@@ -869,33 +870,15 @@ function resolveCodexDeveloperInstructions(agentBody, providerConfig) {
         providerConfig.developerInstructions.trim() !== "") {
         return providerConfig.developerInstructions.trim();
     }
+    if (typeof providerConfig.developer_instructions === "string" &&
+        providerConfig.developer_instructions.trim() !== "") {
+        return providerConfig.developer_instructions.trim();
+    }
     return agentBody.trimStart().trimEnd();
 }
 function buildCodexRoleToml(developerInstructions, providerConfig) {
-    const roleToml = {
-        developer_instructions: developerInstructions,
-    };
-    if (typeof providerConfig.model === "string") {
-        roleToml.model = providerConfig.model;
-    }
-    if (typeof providerConfig.reasoningEffort === "string") {
-        roleToml.model_reasoning_effort = providerConfig.reasoningEffort;
-    }
-    if (typeof providerConfig.reasoningSummary === "string") {
-        roleToml.model_reasoning_summary = providerConfig.reasoningSummary;
-    }
-    if (typeof providerConfig.verbosity === "string") {
-        roleToml.model_verbosity = providerConfig.verbosity;
-    }
-    if (typeof providerConfig.approvalPolicy === "string") {
-        roleToml.approval_policy = providerConfig.approvalPolicy;
-    }
-    if (typeof providerConfig.sandboxMode === "string") {
-        roleToml.sandbox_mode = providerConfig.sandboxMode;
-    }
-    if (typeof providerConfig.webSearch === "boolean") {
-        roleToml.web_search = providerConfig.webSearch;
-    }
+    const roleToml = normalizeCodexConfigForToml(providerConfig);
+    roleToml.developer_instructions = developerInstructions;
     return roleToml;
 }
 function mapMcpServers(servers, allowedKeys) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentloom",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Unified agent and MCP sync CLI for multi-provider AI tooling",
   "type": "module",
   "bin": {