thoth-agents 0.2.7 → 0.2.8

package/dist/{chunk-32672NLJ.js → chunk-FM7HCZSW.js}

@@ -3,6 +3,7 @@ import {
   CLAUDE_CODE_PROMPT_DIALECT,
   CLAUDE_CODE_SUBAGENT_NAMESPACE,
   CODEX_PROMPT_DIALECT,
+  CONFIRMED_OPENAI_SUBAGENT_PRESET,
   CONTEXT7_MCP_URL,
   CUSTOM_SKILLS,
   DEFAULT_MODELS,
@@ -26,6 +27,7 @@ import {
   getCustomSkillsDir,
   getExistingConfigPath,
   getExistingLiteConfigPath,
+  getOpenCodeManagedModelStatePath,
   getPrimaryModelId,
   getSkillRegistry,
   installCustomSkills,
@@ -35,7 +37,7 @@ import {
   renderRolePrompt,
   writeConfig,
   writeLiteConfig
-} from "./chunk-N7GFXGFJ.js";
+} from "./chunk-YLRPDTU7.js";
 
 // src/cli/codex-paths.ts
 import { homedir } from "os";
@@ -81,6 +83,18 @@ function resolveCodexTargets(options) {
   };
 }
 
+// src/cli/model-effort.ts
+function normalizeEffortSelection(value) {
+  const normalized = value?.trim() ?? "";
+  if (!normalized || normalized === "inherit" || normalized === "default") {
+    return { kind: "inherit" };
+  }
+  return { kind: "effort", value: normalized };
+}
+function isExplicitEffort(selection) {
+  return selection.kind === "effort";
+}
+
 // src/cli/codex-install.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, rmSync } from "fs";
 import { basename, dirname as dirname4, isAbsolute, join as join5, relative as relative2 } from "path";
@@ -1311,19 +1325,19 @@ function renderCodexSkillLayout(input) {
 }
 
 // src/harness/adapters/codex.ts
-function readRootPackageVersion(context) {
+function readRootPackageVersion(context2) {
   const packageJsonPath = findRootPackageJsonPath([
-    ...hasCodexPackageRoot(context) ? [context.packageRoot] : [],
-    context.projectRoot,
+    ...hasCodexPackageRoot(context2) ? [context2.packageRoot] : [],
+    context2.projectRoot,
     process.cwd(),
     fileURLToPath(new URL(".", import.meta.url))
   ]);
   return readPackageJsonVersion(packageJsonPath);
 }
-function createCodexPluginPackageManifest(context) {
+function createCodexPluginPackageManifest(context2) {
   return {
     name: "thoth-agents",
-    version: readRootPackageVersion(context),
+    version: readRootPackageVersion(context2),
     description: "Delegate-first OpenCode plugin with seven agents, thoth-mem persistence, and bundled SDD skills."
   };
 }
@@ -1367,22 +1381,9 @@ function createCodexBuiltinMcpTomlConfig() {
     mcp_servers: createCodexBuiltinMcpServers()
   };
 }
-var CODEX_SUBAGENT_DEFAULT_MODELS = {
-  oracle: "gpt-5.5",
-  librarian: "gpt-5.4-mini",
-  explorer: "gpt-5.4-mini",
-  designer: "gpt-5.4-mini",
-  quick: "gpt-5.4-mini",
-  deep: "gpt-5.5"
-};
-var CODEX_SUBAGENT_REASONING_EFFORTS = {
-  oracle: "high",
-  explorer: "low",
-  librarian: "medium",
-  designer: "medium",
-  quick: "low",
-  deep: "medium"
-};
+function isCodexSubagentName(name) {
+  return name in CONFIRMED_OPENAI_SUBAGENT_PRESET;
+}
 var CODEX_ROOT_START = "<!-- thoth-agents:codex-root:start -->";
 var CODEX_ROOT_END = "<!-- thoth-agents:codex-root:end -->";
 var CODEX_CAPABILITIES = CODEX_PROMPT_DIALECT.capabilities.capabilities;
@@ -1491,42 +1492,36 @@ function renderCodexRootInstructions(config) {
     "- After receiving a delegated subagent response, close that subagent session unless you will retry or intentionally keep using that exact same session; explorer and librarian sessions must always be closed immediately after their response, and retry sessions must be closed after the retry result unless explicit same-session reuse is still required.",
     "- Use packaged thoth-agents plugin capabilities through Codex plugin, skill, MCP, and hook review surfaces after enabling them with /plugins and /hooks.",
     "- For blocking user decisions in Codex Default mode, use request_user_input after features.default_mode_request_user_input is enabled; do not ask those questions in plain prose.",
+    "- Whenever the root orchestrator calls `request_user_input`, it MUST NEVER set or pass `autoResolutionMs`; omit the field entirely.",
     "- Memory governance, role permissions, provider-per-agent controls, and hooks are instruction-level unless the active Codex runtime documents stronger enforcement.",
     "</codex-runtime>",
     CODEX_ROOT_END,
     ""
   ].join("\n");
 }
-function agentModelReasoningEffort(role) {
-  return isCodexSubagentName(role.name) ? CODEX_SUBAGENT_REASONING_EFFORTS[role.name] : "medium";
-}
-function isCodexSubagentName(name) {
-  return name in CODEX_SUBAGENT_DEFAULT_MODELS;
-}
 function getCodexAgentModel(role, config) {
   if (!isCodexSubagentName(role.name)) return void 0;
-  return getPrimaryModelId(config?.agents?.[role.name]?.model) ?? CODEX_SUBAGENT_DEFAULT_MODELS[role.name];
+  return getPrimaryModelId(config?.agents?.[role.name]?.model) ?? CONFIRMED_OPENAI_SUBAGENT_PRESET[role.name].model;
 }
-function codexSurfaceHasField(surfaceId, field) {
-  return getCodexSurface(surfaceId)?.fields.includes(field) ?? false;
+function getCodexAgentEffort(role, config) {
+  if (!isCodexSubagentName(role.name)) return void 0;
+  if (getPrimaryModelId(config?.agents?.[role.name]?.model)) return void 0;
+  return CONFIRMED_OPENAI_SUBAGENT_PRESET[role.name].effort;
 }
-function hasCodexConfig(context) {
-  return "config" in context;
+function hasCodexConfig(context2) {
+  return "config" in context2;
 }
-function hasCodexPackageRoot(context) {
-  return "packageRoot" in context && typeof context.packageRoot === "string" && context.packageRoot.length > 0;
+function hasCodexPackageRoot(context2) {
+  return "packageRoot" in context2 && typeof context2.packageRoot === "string" && context2.packageRoot.length > 0;
 }
 function renderAgentArtifacts({ config }) {
   const artifacts = [];
   const diagnostics = [];
-  const supportsReasoningEffort = codexSurfaceHasField(
-    "project-agent-toml",
-    "model_reasoning_effort"
-  );
   for (const role of getAgentPackContract().roles.filter(
     (candidate) => candidate.name !== "orchestrator"
   )) {
     const model = getCodexAgentModel(role, config);
+    const effort = getCodexAgentEffort(role, config);
     const toml = renderCodexToml({
       surfaceId: "project-agent-toml",
       values: {
@@ -1534,7 +1529,7 @@ function renderAgentArtifacts({ config }) {
         description: role.responsibility,
         developer_instructions: roleInstructions(role, config),
         ...model ? { model } : {},
-        ...supportsReasoningEffort ? { model_reasoning_effort: agentModelReasoningEffort(role) } : {},
+        ...effort ? { model_reasoning_effort: effort } : {},
         sandbox_mode: role.canMutateWorkspace ? "workspace-write" : "read-only"
       }
     });
@@ -1621,27 +1616,27 @@ function hookReadinessDiagnostics() {
     }
   ];
 }
-function resolveSkillOutputModes(context) {
-  return context.options?.codexSkillOutputModes ?? ["plugin-package"];
+function resolveSkillOutputModes(context2) {
+  return context2.options?.codexSkillOutputModes ?? ["plugin-package"];
 }
 var codexAdapter = {
   id: "codex",
   displayName: "Codex",
   capabilities: CODEX_CAPABILITIES,
-  render(context) {
-    const config = hasCodexConfig(context) ? context.config : void 0;
+  render(context2) {
+    const config = hasCodexConfig(context2) ? context2.config : void 0;
     const agentArtifacts = renderAgentArtifacts({ config });
     const configArtifacts = renderConfigArtifacts();
-    const skillOutputModes = resolveSkillOutputModes(context);
+    const skillOutputModes = resolveSkillOutputModes(context2);
     const skillLayout = renderCodexSkillLayout({
-      projectRoot: context.projectRoot,
-      ...hasCodexPackageRoot(context) ? { packageRoot: context.packageRoot } : {},
+      projectRoot: context2.projectRoot,
+      ...hasCodexPackageRoot(context2) ? { packageRoot: context2.packageRoot } : {},
       skills: getSkillRegistry(),
       surfaceId: "plugin-skills-directory",
       outputModes: skillOutputModes
     });
     const pluginPackage = renderCodexPluginPackage({
-      manifest: createCodexPluginPackageManifest(context),
+      manifest: createCodexPluginPackageManifest(context2),
       assets: [
         {
           surfaceId: "plugin-skills-directory",
@@ -1849,6 +1844,7 @@ import {
   writeFileSync as writeFileSync2
 } from "fs";
 import { dirname as dirname3 } from "path";
+import { z } from "zod";
 function writeTextWithBackup(path4, content) {
   mkdirSync2(dirname3(path4), { recursive: true });
   if (existsSync4(path4) && readFileSync4(path4, "utf8") === content) return false;
@@ -1871,21 +1867,37 @@ function stringRecord(value) {
     )
   );
 }
+var managedModelStateSchema = z.object({
+  version: z.number(),
+  models: z.record(z.string(), z.unknown()),
+  configuredModels: z.unknown().optional(),
+  configuredEfforts: z.unknown().optional()
+}).passthrough();
+function effortRecord(value) {
+  return Object.fromEntries(
+    Object.entries(stringRecord(value)).filter(
+      ([, effort]) => isExplicitEffort(normalizeEffortSelection(effort))
+    )
+  );
+}
 function emptyManagedModelState(version) {
   return { version, models: {} };
 }
 function parseManagedModelStateJson(text, version) {
   if (!text) return emptyManagedModelState(version);
   try {
-    const parsed = JSON.parse(text);
-    if (parsed.version !== version || !parsed.models || typeof parsed.models !== "object" || Array.isArray(parsed.models)) {
+    const input = JSON.parse(text);
+    const result = managedModelStateSchema.safeParse(input);
+    if (!result.success || result.data.version !== version) {
       return emptyManagedModelState(version);
     }
-    const configuredModels = stringRecord(parsed.configuredModels);
+    const configuredModels = stringRecord(result.data.configuredModels);
+    const configuredEfforts = effortRecord(result.data.configuredEfforts);
     return {
       version,
-      models: stringRecord(parsed.models),
-      ...Object.keys(configuredModels).length > 0 ? { configuredModels } : {}
+      models: stringRecord(result.data.models),
+      ...Object.keys(configuredModels).length > 0 ? { configuredModels } : {},
+      ...Object.keys(configuredEfforts).length > 0 ? { configuredEfforts } : {}
     };
   } catch {
     return emptyManagedModelState(version);
@@ -1963,6 +1975,26 @@ function replaceRoleTomlModel(content, model) {
   return `${rendered}
 ${content}`;
 }
+function parseRoleTomlEffort(content) {
+  return /^model_reasoning_effort\s*=\s*"([^"\\]+)"\s*$/m.exec(content)?.[1];
+}
+function replaceRoleTomlEffort(content, effort) {
+  const pattern = /^model_reasoning_effort\s*=\s*"[^"\\]+"\s*\r?\n?/m;
+  if (effort === void 0) return content.replace(pattern, "");
+  const rendered = `model_reasoning_effort = "${escapeTomlString2(effort)}"`;
+  if (pattern.test(content)) return content.replace(pattern, `${rendered}
+`);
+  const modelPattern = /^model\s*=\s*"(?:\\.|[^"\\])*"\s*\r?\n?/m;
+  if (modelPattern.test(content)) {
+    return content.replace(
+      modelPattern,
+      (modelLine) => `${modelLine}${rendered}
+`
+    );
+  }
+  return `${rendered}
+${content}`;
+}
 function roleManagedModelStateKey(path4) {
   return basename(path4);
 }
@@ -1998,7 +2030,8 @@ function applyCodexManagedModelOverrides(config, overrides) {
   const nextState = {
     version: MANAGED_MODEL_STATE_VERSION,
     models: { ...state.models },
-    ...state.configuredModels ? { configuredModels: { ...state.configuredModels } } : {}
+    ...state.configuredModels ? { configuredModels: { ...state.configuredModels } } : {},
+    ...state.configuredEfforts ? { configuredEfforts: { ...state.configuredEfforts } } : {}
   };
   try {
     for (const override of overrides) {
@@ -2011,7 +2044,12 @@ function applyCodexManagedModelOverrides(config, overrides) {
         );
       }
       const before = existsSync5(roleItem.targetPath) ? readFileSync5(roleItem.targetPath, "utf8") : roleItem.content;
-      const updated = replaceRoleTomlModel(before, override.model);
+      let updated = replaceRoleTomlModel(before, override.model);
+      if (override.clearEffort) {
+        updated = replaceRoleTomlEffort(updated, void 0);
+      } else if (override.effort !== void 0) {
+        updated = replaceRoleTomlEffort(updated, override.effort);
+      }
       if (writeTextWithBackup(roleItem.targetPath, updated)) {
         changed.push(roleItem.targetPath);
       }
@@ -2019,6 +2057,14 @@ function applyCodexManagedModelOverrides(config, overrides) {
       nextState.models[key] = parseRoleTomlModel(roleItem.content) ?? override.model;
       nextState.configuredModels ??= {};
       nextState.configuredModels[key] = override.model;
+      if (override.clearEffort) {
+        if (nextState.configuredEfforts) {
+          delete nextState.configuredEfforts[key];
+        }
+      } else if (override.effort !== void 0) {
+        nextState.configuredEfforts ??= {};
+        nextState.configuredEfforts[key] = override.effort;
+      }
     }
     if (writeTextWithBackup(statePath, stableJson3(nextState))) {
       changed.push(statePath);
@@ -2042,6 +2088,11 @@ function resolveRoleTomlContent(options) {
   const key = roleManagedModelStateKey(options.targetPath);
   if (!renderedModel) return options.renderedContent;
   const configuredModel = options.reset ? void 0 : options.state.configuredModels?.[key];
+  const configuredEffort = options.reset ? void 0 : options.state.configuredEfforts?.[key];
+  if (configuredEffort !== void 0) {
+    options.nextState.configuredEfforts ??= {};
+    options.nextState.configuredEfforts[key] = configuredEffort;
+  }
   if (options.reset || !existsSync5(options.targetPath)) {
     options.nextState.models[key] = renderedModel;
     if (configuredModel !== void 0) {
@@ -2051,16 +2102,19 @@ function resolveRoleTomlContent(options) {
     }
     return options.renderedContent;
   }
-  const currentModel = parseRoleTomlModel(
-    readFileSync5(options.targetPath, "utf8")
-  );
+  const installedContent = readFileSync5(options.targetPath, "utf8");
+  const currentModel = parseRoleTomlModel(installedContent);
+  const currentEffort = parseRoleTomlEffort(installedContent);
   if (configuredModel !== void 0) {
     options.nextState.models[key] = renderedModel;
     options.nextState.configuredModels ??= {};
     options.nextState.configuredModels[key] = configuredModel;
-    return replaceRoleTomlModel(
-      options.renderedContent,
-      currentModel && currentModel !== configuredModel ? currentModel : configuredModel
+    return replaceRoleTomlEffort(
+      replaceRoleTomlModel(
+        options.renderedContent,
+        currentModel && currentModel !== configuredModel ? currentModel : configuredModel
+      ),
+      currentEffort
     );
   }
   const trackedModel = options.state.models[key];
@@ -2068,10 +2122,13 @@ function resolveRoleTomlContent(options) {
   if (isUserOwned) {
     if (trackedModel !== void 0)
       options.nextState.models[key] = trackedModel;
-    return replaceRoleTomlModel(options.renderedContent, currentModel);
+    return replaceRoleTomlEffort(
+      replaceRoleTomlModel(options.renderedContent, currentModel),
+      currentEffort
+    );
   }
   options.nextState.models[key] = renderedModel;
-  return options.renderedContent;
+  return replaceRoleTomlEffort(options.renderedContent, currentEffort);
 }
 function mergePersonalMarketplace(existing, homeDir, personalPluginRoot) {
   const parsed = existing.trim() ? JSON.parse(existing) : {};
@@ -2445,6 +2502,7 @@ function renderClaudeCodeSubagent(input) {
     `name: ${yamlScalar(input.name)}`,
     `description: ${yamlScalar(input.description)}`,
     `model: ${input.model}`,
+    ...input.effort !== void 0 ? [`effort: ${input.effort}`] : [],
     ...input.tools !== void 0 ? [`tools: ${yamlScalar(input.tools)}`] : [],
     "---"
   ].join("\n");
@@ -2584,25 +2642,25 @@ function stableJson5(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
-function readRootPackageVersion2(context) {
+function readRootPackageVersion2(context2) {
   const packageJsonPath = findRootPackageJsonPath([
-    ...hasPackageRoot(context) ? [context.packageRoot] : [],
-    context.projectRoot,
+    ...hasPackageRoot(context2) ? [context2.packageRoot] : [],
+    context2.projectRoot,
     process.cwd(),
     fileURLToPath3(new URL(".", import.meta.url))
   ]);
   return readPackageJsonVersion(packageJsonPath);
 }
-function hasConfig(context) {
-  return "config" in context;
+function hasConfig(context2) {
+  return "config" in context2;
 }
-function hasPackageRoot(context) {
-  return "packageRoot" in context && typeof context.packageRoot === "string" && context.packageRoot.length > 0;
+function hasPackageRoot(context2) {
+  return "packageRoot" in context2 && typeof context2.packageRoot === "string" && context2.packageRoot.length > 0;
 }
-function createPluginManifest(context) {
+function createPluginManifest(context2) {
   return {
     name: "thoth-agents",
-    version: readRootPackageVersion2(context),
+    version: readRootPackageVersion2(context2),
     description: "Delegate-first agent pack with seven roles, thoth-mem persistence, and bundled SDD skills, packaged for Claude Code.",
     author: { name: "thoth-agents" }
   };
@@ -2650,8 +2708,8 @@ var claudeCodeAdapter = {
   id: "claude",
   displayName: "Claude Code",
   capabilities: CLAUDE_CODE_CAPABILITIES,
-  render(context) {
-    const config = hasConfig(context) ? context.config : void 0;
+  render(context2) {
+    const config = hasConfig(context2) ? context2.config : void 0;
     const componentArtifacts = [
       ...renderSubagentArtifacts(config),
       renderOrchestratorArtifact(config),
@@ -2671,13 +2729,13 @@ var claudeCodeAdapter = {
       }
     ];
     const skillLayout = renderClaudeCodeSkillLayout({
-      projectRoot: context.projectRoot,
-      ...hasPackageRoot(context) ? { packageRoot: context.packageRoot } : {},
+      projectRoot: context2.projectRoot,
+      ...hasPackageRoot(context2) ? { packageRoot: context2.packageRoot } : {},
       skills: getSkillRegistry()
     });
     componentArtifacts.push(...skillLayout.artifacts);
     const pluginPackage = renderClaudeCodePluginPackage({
-      manifest: createPluginManifest(context),
+      manifest: createPluginManifest(context2),
       componentArtifacts
     });
     return {
@@ -2734,6 +2792,19 @@ function replaceSubagentModel(content, model) {
   }
   return content;
 }
+function parseSubagentEffort(content) {
+  return /^effort:\s*(\S+)\s*$/m.exec(content)?.[1];
+}
+function replaceSubagentEffort(content, effort) {
+  if (effort === void 0) {
+    return content.replace(/^effort:\s*\S+\s*\n/m, "");
+  }
+  if (/^effort:\s*\S+\s*$/m.test(content)) {
+    return content.replace(/^effort:\s*\S+\s*$/m, `effort: ${effort}`);
+  }
+  return content.replace(/^(model:\s*\S+\s*)$/m, `$1
+effort: ${effort}`);
+}
 function emptyManagedModelState3() {
   return emptyManagedModelState(CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION);
 }
@@ -2769,15 +2840,29 @@ function roleForArtifact(artifact) {
   const name = match?.[1];
   return name && CLAUDE_CODE_ROLE_NAMES.includes(name) ? name : void 0;
 }
-function applyConfiguredModel(content, role, state, nextState, reset) {
+function applyConfiguredModel(content, targetPath, role, state, nextState, reset) {
   const renderedModel = parseSubagentModel(content);
   if (!role || !renderedModel) return content;
   nextState.models[role] = renderedModel;
   const configured = reset ? void 0 : state.configuredModels?.[role];
-  if (configured === void 0) return content;
-  nextState.configuredModels ??= {};
-  nextState.configuredModels[role] = configured;
-  return replaceSubagentModel(content, configured);
+  let updated = content;
+  if (configured !== void 0) {
+    nextState.configuredModels ??= {};
+    nextState.configuredModels[role] = configured;
+    updated = replaceSubagentModel(updated, configured);
+  }
+  const configuredEffort = reset ? void 0 : state.configuredEfforts?.[role];
+  if (configuredEffort !== void 0) {
+    nextState.configuredEfforts ??= {};
+    nextState.configuredEfforts[role] = configuredEffort;
+  }
+  if (!reset && existsSync6(targetPath)) {
+    const installedEffort = parseSubagentEffort(
+      readFileSync7(targetPath, "utf8")
+    );
+    updated = replaceSubagentEffort(updated, installedEffort);
+  }
+  return updated;
 }
 function buildClaudeCodeSetupPlan(config) {
   const targets = resolveClaudeCodeTargets({
@@ -2795,8 +2880,15 @@ function buildClaudeCodeSetupPlan(config) {
   const items = render.artifacts.map((artifact) => {
     const role = roleForArtifact(artifact);
     const rendered = String(artifact.content ?? "");
-    const content = role !== void 0 ? applyConfiguredModel(rendered, role, state, nextState, config.reset) : rendered;
     const targetPath = join8(targets.pluginRoot, artifact.path);
+    const content = role !== void 0 ? applyConfiguredModel(
+      rendered,
+      targetPath,
+      role,
+      state,
+      nextState,
+      config.reset
+    ) : rendered;
     return {
       kind: targetKindForArtifact(artifact),
       action: "write-plugin-file",
@@ -2892,11 +2984,12 @@ function applyClaudeCodeManagedModelOverrides(config, overrides) {
   const nextState = {
     version: CLAUDE_CODE_MANAGED_MODEL_STATE_VERSION,
     models: { ...state.models },
-    ...state.configuredModels ? { configuredModels: { ...state.configuredModels } } : {}
+    ...state.configuredModels ? { configuredModels: { ...state.configuredModels } } : {},
+    ...state.configuredEfforts ? { configuredEfforts: { ...state.configuredEfforts } } : {}
   };
   try {
     for (const override of overrides) {
-      if (!isClaudeCodeModelAlias(override.model)) {
+      if (!isClaudeCodeModelAlias(override.model) && override.catalogId !== override.model) {
         throw new Error(
           `Unsupported Claude Code model "${override.model}" for ${override.role}; use sonnet, opus, haiku, or inherit.`
         );
@@ -2908,12 +3001,25 @@ function applyClaudeCodeManagedModelOverrides(config, overrides) {
         throw new Error(`Missing Claude Code subagent for ${override.role}.`);
       }
       const before = existsSync6(roleItem.targetPath) ? readFileSync7(roleItem.targetPath, "utf8") : roleItem.content;
-      const updated = replaceSubagentModel(before, override.model);
+      let updated = replaceSubagentModel(before, override.model);
+      if (override.clearEffort) {
+        updated = replaceSubagentEffort(updated, void 0);
+      } else if (override.effort !== void 0) {
+        updated = replaceSubagentEffort(updated, override.effort);
+      }
       if (writeTextWithBackup(roleItem.targetPath, updated)) {
         changed.push(roleItem.targetPath);
       }
       nextState.configuredModels ??= {};
       nextState.configuredModels[override.role] = override.model;
+      if (override.clearEffort) {
+        if (nextState.configuredEfforts) {
+          delete nextState.configuredEfforts[override.role];
+        }
+      } else if (override.effort !== void 0) {
+        nextState.configuredEfforts ??= {};
+        nextState.configuredEfforts[override.role] = override.effort;
+      }
     }
     if (writeTextWithBackup(statePath, stableJson3(nextState))) {
       changed.push(statePath);
@@ -2939,6 +3045,31 @@ function formatClaudeCodeSetupPlan(plan) {
 var CLAUDE_CODE_DISPLAY_NAME = "Claude Code";
 var claudeCodePlanSources = /* @__PURE__ */ new WeakMap();
 var claudeCodeModelSources = /* @__PURE__ */ new WeakMap();
+var CLAUDE_CODE_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
+function resolveClaudeCodeEffort(input) {
+  if (!input.effort || input.effort.kind === "inherit") {
+    return { ok: true, effort: void 0 };
+  }
+  const effort = input.effort.value;
+  if (!CLAUDE_CODE_EFFORTS.has(effort)) {
+    return {
+      ok: false,
+      code: "claude-code-effort-runtime-unsupported",
+      message: `Claude Code does not support effort ${effort}.`
+    };
+  }
+  if (isClaudeCodeModelAlias(input.model) && input.model !== "inherit") {
+    return { ok: true, effort };
+  }
+  if (input.catalogId === input.model && input.availableEfforts?.includes(effort)) {
+    return { ok: true, effort };
+  }
+  return {
+    ok: false,
+    code: "claude-code-effort-catalog-unsupported",
+    message: `Effort ${effort} is not supported by ${input.catalogId ?? input.model} in the models.dev catalog.`
+  };
+}
 var claudeCodeActions = [
   {
     id: "claude-code-status",
@@ -3002,16 +3133,16 @@ var claudeCodeOperationAdapter = {
   description: "Claude Code plugin package and managed subagent surfaces.",
   actions: claudeCodeActions
 };
-function claudeCodeConfig(context = { cwd: process.cwd() }, dryRun) {
+function claudeCodeConfig(context2 = { cwd: process.cwd() }, dryRun) {
   return {
     dryRun,
     reset: false,
     // Match the installer (install.ts uses 'user') so post-install status,
     // update, sync, and model commands resolve the same plugin root.
-    scope: context.scope ?? "user",
-    projectRoot: context.cwd,
-    homeDir: context.homeDir,
-    packageRoot: context.packageRoot
+    scope: context2.scope ?? "user",
+    projectRoot: context2.cwd,
+    homeDir: context2.homeDir,
+    packageRoot: context2.packageRoot
   };
 }
 function claudeCodeDisclaimers() {
@@ -3131,10 +3262,10 @@ function statusFromSetupPlan(plan) {
     ]
   };
 }
-function getClaudeCodeStatus(context = { cwd: process.cwd() }) {
+function getClaudeCodeStatus(context2 = { cwd: process.cwd() }) {
   let plan;
   try {
-    plan = buildClaudeCodeSetupPlan(claudeCodeConfig(context, true));
+    plan = buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return {
@@ -3192,53 +3323,71 @@ function planFromSetup(id, action, title, summary, setupPlan) {
   claudeCodePlanSources.set(plan, setupPlan);
   return plan;
 }
-function buildClaudeCodeInstallPlan(context = { cwd: process.cwd() }) {
+function buildClaudeCodeInstallPlan(context2 = { cwd: process.cwd() }) {
   return planFromSetup(
     "claude-code-install-preview",
     "install",
     "Install Claude Code plugin package",
     "Preview Claude Code plugin package install using buildClaudeCodeSetupPlan().",
-    buildClaudeCodeSetupPlan(claudeCodeConfig(context, true))
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true))
   );
 }
-function buildClaudeCodeUpdatePlan(context = { cwd: process.cwd() }) {
+function buildClaudeCodeUpdatePlan(context2 = { cwd: process.cwd() }) {
   return planFromSetup(
     "claude-code-update-preview",
     "update",
     "Update Claude Code plugin package",
     "Preview Claude Code managed plugin refresh using buildClaudeCodeSetupPlan().",
-    buildClaudeCodeSetupPlan(claudeCodeConfig(context, true))
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true))
   );
 }
-function buildClaudeCodeSyncPlan(context = { cwd: process.cwd() }) {
+function buildClaudeCodeSyncPlan(context2 = { cwd: process.cwd() }) {
   return planFromSetup(
     "claude-code-sync-preview",
     "sync",
     "Sync Claude Code plugin package",
     "Preview Claude Code managed plugin subagents, MCP, hooks, and skills.",
-    buildClaudeCodeSetupPlan(claudeCodeConfig(context, true))
+    buildClaudeCodeSetupPlan(claudeCodeConfig(context2, true))
   );
 }
 function isClaudeCodeRole(role) {
   return CLAUDE_CODE_ROLE_NAMES.includes(role);
 }
-function buildClaudeCodeModelPlan(input, context = { cwd: process.cwd() }) {
-  const status = getClaudeCodeStatus(context);
-  const supportedRoles = input.roles.filter((role) => isClaudeCodeRole(role.role)).filter((role) => isClaudeCodeModelAlias(role.model)).map((role) => ({
+function buildClaudeCodeModelPlan(input, context2 = { cwd: process.cwd() }) {
+  const status = getClaudeCodeStatus(context2);
+  const resolvedRoles = input.roles.map((role) => ({
+    role,
+    effort: resolveClaudeCodeEffort(role),
+    validRole: isClaudeCodeRole(role.role),
+    validModel: isClaudeCodeModelAlias(role.model) || role.catalogId === role.model
+  }));
+  const supportedRoles = resolvedRoles.filter((entry) => entry.validRole && entry.validModel && entry.effort.ok).map(({ role, effort }) => ({
     role: role.role,
-    model: role.model
+    model: role.model,
+    ...role.catalogId ? { catalogId: role.catalogId } : {},
+    ...effort.ok && effort.effort !== void 0 ? { effort: effort.effort } : {},
+    ...role.effort?.kind === "inherit" ? { clearEffort: true } : {}
   }));
-  const rejectedRoles = input.roles.filter(
-    (role) => !isClaudeCodeRole(role.role) || !isClaudeCodeModelAlias(role.model)
+  const rejectedRoles = resolvedRoles.filter(
+    (entry) => !entry.validRole || !entry.validModel
+  );
+  const effortErrors = resolvedRoles.filter(
+    (entry) => entry.validRole && entry.validModel && !entry.effort.ok
   );
   const warnings = [
     ...status.diagnostics,
     ...input.warnings ?? [],
     ...rejectedRoles.map(
-      (role) => warning(
+      ({ role }) => warning(
         `Claude Code does not accept role "${role.role}" with model "${role.model}"; roles must be one of ${CLAUDE_CODE_ROLE_NAMES.join(", ")} and models must be sonnet, opus, haiku, or inherit.`,
         "claude-code-unsupported-model-role"
       )
+    ),
+    ...effortErrors.map(
+      ({ effort }) => warning(
+        effort.ok ? "Unknown Claude Code effort error." : effort.message,
+        effort.ok ? "claude-code-effort-unknown" : effort.code
+      )
     )
   ];
   if (input.harness !== "claude") {
@@ -3269,7 +3418,7 @@ function buildClaudeCodeModelPlan(input, context = { cwd: process.cwd() }) {
     title: "Configure Claude Code subagent model lines",
     summary: "Preview model changes for generated Claude Code subagent files and managed model state only.",
     dryRun: true,
-    canApply: input.harness === "claude" && supportedRoles.length > 0 && status.state !== "unknown",
+    canApply: input.harness === "claude" && supportedRoles.length > 0 && effortErrors.length === 0 && status.state !== "unknown",
     targets: [...targets, ...stateTarget ? [stateTarget] : []],
     surfaces: targets.map((target) => ({
       id: `claude-code-model:${target.label}`,
@@ -3282,7 +3431,7 @@ function buildClaudeCodeModelPlan(input, context = { cwd: process.cwd() }) {
       strategy: "managed-backup-file",
       description: "Existing subagent files and managed model state are backed up by the managed write helper."
     },
-    items: supportedRoles.map(({ role, model }) => ({
+    items: supportedRoles.map(({ role, model, effort }) => ({
       title: `Set ${role} Claude Code subagent model line`,
       target: targets.find(
         (target) => target.path?.endsWith(`agents${pathSep()}${role}.md`)
@@ -3290,7 +3439,7 @@ function buildClaudeCodeModelPlan(input, context = { cwd: process.cwd() }) {
         kind: "generated-artifact",
         label: `Claude Code ${role} subagent`
       },
-      preview: JSON.stringify({ role, model }),
+      preview: JSON.stringify({ role, model, effort: effort ?? null }),
       backup: { required: true, strategy: "managed-backup-file" }
     })),
     warnings,
@@ -3304,7 +3453,7 @@ function buildClaudeCodeModelPlan(input, context = { cwd: process.cwd() }) {
     ]
   };
   claudeCodeModelSources.set(plan, {
-    config: claudeCodeConfig(context, false),
+    config: claudeCodeConfig(context2, false),
     roles: supportedRoles
   });
   return plan;
@@ -3360,7 +3509,10 @@ function applyClaudeCodePlan(plan) {
       source.config,
       source.roles.map((role) => ({
         role: role.role,
-        model: role.model
+        model: role.model,
+        ...role.catalogId ? { catalogId: role.catalogId } : {},
+        ...role.effort ? { effort: role.effort } : {},
+        ...role.clearEffort ? { clearEffort: true } : {}
       }))
     );
     return {
@@ -3479,16 +3631,16 @@ var codexOperationAdapter = {
   description: "Codex agent-pack and managed subagent surfaces.",
   actions: codexActions
 };
-function codexConfig(context = { cwd: process.cwd() }, dryRun) {
+function codexConfig(context2 = { cwd: process.cwd() }, dryRun) {
   return {
     dryRun,
     reset: false,
-    scope: context.scope ?? "user",
-    projectRoot: context.cwd,
-    homeDir: context.homeDir,
-    codexHome: context.codexHome,
-    packageRoot: context.packageRoot,
-    pluginId: context.pluginId
+    scope: context2.scope ?? "user",
+    projectRoot: context2.cwd,
+    homeDir: context2.homeDir,
+    codexHome: context2.codexHome,
+    packageRoot: context2.packageRoot,
+    pluginId: context2.pluginId
   };
 }
 function codexDisclaimers() {
@@ -3654,10 +3806,10 @@ function statusSummary2(state) {
       return "Codex managed setup could not be classified safely.";
   }
 }
-function getCodexStatus(context = { cwd: process.cwd() }) {
+function getCodexStatus(context2 = { cwd: process.cwd() }) {
   let plan;
   try {
-    plan = buildCodexSetupPlan(codexConfig(context, true));
+    plan = buildCodexSetupPlan(codexConfig(context2, true));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return {
@@ -3708,8 +3860,8 @@ function planItemFromSetup2(item) {
     backup: backupForItem2(item)
   };
 }
-function planFromSetup2(id, action, title, summary, setupPlan, context) {
-  const status = getCodexStatus(context);
+function planFromSetup2(id, action, title, summary, setupPlan, context2) {
+  const status = getCodexStatus(context2);
   const canApply = status.state === "installed" || status.state === "missing" || status.state === "outdated";
   const plan = {
     id,
@@ -3744,37 +3896,37 @@ function planFromSetup2(id, action, title, summary, setupPlan, context) {
   codexPlanSources.set(plan, setupPlan);
   return plan;
 }
-function buildCodexUpdatePlan(context = { cwd: process.cwd() }) {
-  const setupPlan = buildCodexSetupPlan(codexConfig(context, true));
+function buildCodexUpdatePlan(context2 = { cwd: process.cwd() }) {
+  const setupPlan = buildCodexSetupPlan(codexConfig(context2, true));
   return planFromSetup2(
     "codex-update-preview",
     "update",
     "Update Codex managed setup",
     "Preview Codex managed setup refresh using buildCodexSetupPlan().",
     setupPlan,
-    context
+    context2
   );
 }
-function buildCodexSyncPlan(context = { cwd: process.cwd() }) {
-  const setupPlan = buildCodexSetupPlan(codexConfig(context, true));
+function buildCodexSyncPlan(context2 = { cwd: process.cwd() }) {
+  const setupPlan = buildCodexSetupPlan(codexConfig(context2, true));
   return planFromSetup2(
     "codex-sync-preview",
     "sync",
     "Sync Codex managed configuration",
     "Preview Codex managed root instructions, subagents, plugin source, marketplace entry, and feature gates.",
     setupPlan,
-    context
+    context2
   );
 }
-function buildCodexInstallPlan(context = { cwd: process.cwd() }) {
-  const setupPlan = buildCodexSetupPlan(codexConfig(context, true));
+function buildCodexInstallPlan(context2 = { cwd: process.cwd() }) {
+  const setupPlan = buildCodexSetupPlan(codexConfig(context2, true));
   return planFromSetup2(
     "codex-install-preview",
     "install",
     "Install Codex managed setup",
     "Preview Codex managed agent-pack setup using buildCodexSetupPlan().",
     setupPlan,
-    context
+    context2
   );
 }
 function normalizeCodexModel(input) {
@@ -3783,15 +3935,55 @@ function normalizeCodexModel(input) {
   }
   return input.model;
 }
+var CODEX_DOCUMENTED_EFFORTS = /* @__PURE__ */ new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
+]);
+function resolveCodexEffort(input) {
+  if (!input.effort || input.effort.kind === "inherit") {
+    return { ok: true, value: void 0 };
+  }
+  const value = input.effort.value;
+  if (!CODEX_DOCUMENTED_EFFORTS.has(value)) {
+    return {
+      ok: false,
+      code: "codex-effort-undocumented",
+      message: `Codex does not document reasoning effort "${value}".`
+    };
+  }
+  if (!input.catalogId?.startsWith("openai/") || !input.availableEfforts?.includes(value)) {
+    return {
+      ok: false,
+      code: "codex-effort-model-unsupported",
+      message: `Model ${input.catalogId ?? input.model} does not publish Codex effort "${value}".`
+    };
+  }
+  return { ok: true, value };
+}
 function isCodexRole(role) {
   return CODEX_ROLE_NAMES.includes(role);
 }
-function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
-  const status = getCodexStatus(context);
-  const supportedRoles = input.roles.filter((role) => isCodexRole(role.role)).map((role) => ({
+function buildCodexModelPlan(input, context2 = { cwd: process.cwd() }) {
+  const status = getCodexStatus(context2);
+  const candidateRoles = input.roles.filter((role) => isCodexRole(role.role)).map((role) => ({
     role: role.role,
-    model: normalizeCodexModel(role)
+    model: normalizeCodexModel(role),
+    effort: resolveCodexEffort(role),
+    clearEffort: role.effort?.kind === "inherit"
   }));
+  const supportedRoles = candidateRoles.filter((role) => role.effort.ok).map((role) => ({
+    role: role.role,
+    model: role.model,
+    ...role.effort.value ? { effort: role.effort.value } : {},
+    ...role.clearEffort ? { clearEffort: true } : {}
+  }));
+  const effortErrors = candidateRoles.filter((role) => !role.effort.ok);
   const unsupportedRoles = input.roles.filter(
     (role) => !isCodexRole(role.role)
   );
@@ -3803,6 +3995,12 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
         `Codex does not expose a supported generated model surface for ${role.role}; this plan will not write that role.`,
         "codex-unsupported-model-role"
       )
+    ),
+    ...effortErrors.map(
+      (role) => warning2(
+        role.effort.message,
+        role.effort.code
+      )
     )
   ];
   if (input.harness !== "codex") {
@@ -3823,7 +4021,7 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
       state: "missing"
     };
   });
-  const config = codexConfig(context, false);
+  const config = codexConfig(context2, false);
   const stateTarget = status.targets.find(
     (target) => target.path?.endsWith(".thoth-agents-managed-models.json")
   );
@@ -3834,7 +4032,7 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
     title: "Configure Codex subagent model lines",
     summary: "Preview model changes for generated Codex subagent TOML files and .thoth-agents-managed-models.json only.",
     dryRun: true,
-    canApply: input.harness === "codex" && supportedRoles.length > 0 && status.state !== "unknown",
+    canApply: input.harness === "codex" && supportedRoles.length > 0 && effortErrors.length === 0 && status.state !== "unknown",
     targets: [...targets, ...stateTarget ? [stateTarget] : []],
     surfaces: targets.map((target) => ({
       id: `codex-model:${target.label}`,
@@ -3847,7 +4045,7 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
       strategy: "managed-backup-file",
       description: "Existing subagent TOML and managed model state files are backed up by the managed write helper."
     },
-    items: supportedRoles.map(({ role, model }) => ({
+    items: supportedRoles.map(({ role, model, effort }) => ({
       title: `Set ${role} Codex subagent model line`,
       target: targets.find(
         (target) => target.path?.endsWith(`thoth-agents-${role}.toml`)
@@ -3855,7 +4053,7 @@ function buildCodexModelPlan(input, context = { cwd: process.cwd() }) {
         kind: "generated-artifact",
         label: `Codex ${role} subagent`
       },
-      preview: JSON.stringify({ role, model }),
+      preview: JSON.stringify({ role, model, effort }),
       backup: {
         required: true,
         strategy: "managed-backup-file"
@@ -3971,6 +4169,36 @@ function applyCodexPlan(plan) {
 import { existsSync as existsSync10 } from "fs";
 import { join as join10 } from "path";
 
+// src/cli/opencode-effort.ts
+var OPENAI_GPT_RUNTIME_VARIANTS = /* @__PURE__ */ new Set([
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+function resolveOpenCodeEffort(input) {
+  if (!input.effort || input.effort.kind === "inherit") {
+    return { ok: true, variant: void 0 };
+  }
+  const variant = input.effort.value;
+  if (!input.availableEfforts?.includes(variant)) {
+    return {
+      ok: false,
+      code: "opencode-effort-catalog-unsupported",
+      message: `Effort ${variant} is not supported by ${input.catalogId ?? input.model} in the models.dev catalog.`
+    };
+  }
+  if (input.catalogId?.startsWith("openai/gpt-") && OPENAI_GPT_RUNTIME_VARIANTS.has(variant)) {
+    return { ok: true, variant };
+  }
+  return {
+    ok: false,
+    code: "opencode-effort-runtime-unconfirmed",
+    message: `Effort ${variant} is catalogued for ${input.catalogId ?? input.model}, but the OpenCode runtime mapping is not confirmed.`
+  };
+}
+
 // src/cli/skills.ts
 import { spawnSync } from "child_process";
 import { existsSync as existsSync9 } from "fs";
@@ -4141,11 +4369,11 @@ function titleCaseSkillName(value) {
     return `${part.charAt(0).toUpperCase()}${part.slice(1).toLowerCase()}`;
   }).join("-");
 }
-function homeDirFromContext(context) {
-  return context.env?.HOME ?? context.env?.USERPROFILE;
+function homeDirFromContext(context2) {
+  return context2.env?.HOME ?? context2.env?.USERPROFILE;
 }
-function openCodeSkillTargets(context) {
-  const homeDir = homeDirFromContext(context);
+function openCodeSkillTargets(context2) {
+  const homeDir = homeDirFromContext(context2);
   const recommendedTargets = RECOMMENDED_SKILLS.map(
     (skill) => {
       const path4 = getRecommendedSkillPath(skill, homeDir);
@@ -4226,13 +4454,13 @@ function hasSevenAgentPreset(config) {
 function classifyApplySafety(state) {
   return state === "missing" || state === "installed";
 }
-function getOpenCodeStatus(context = { cwd: process.cwd() }) {
+function getOpenCodeStatus(context2 = { cwd: process.cwd() }) {
   const mainPath = getExistingConfigPath();
   const litePath = getExistingLiteConfigPath();
   const main = parseConfig(mainPath);
   const lite = parseConfig(litePath);
   const diagnostics = [];
-  const skillStatus = openCodeSkillTargets(context);
+  const skillStatus = openCodeSkillTargets(context2);
   if (main.error) {
     diagnostics.push({
       severity: "critical",
@@ -4554,11 +4782,26 @@ function normalizeRoleModel(input) {
 function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
   const items = input.roles.map((role) => {
     const model = normalizeRoleModel(role);
+    const effort = resolveOpenCodeEffort(role);
     return {
       title: `Set ${role.role} OpenCode model override`,
       target: targetForLiteConfig(),
-      preview: JSON.stringify({ [role.role]: { model } }),
-      backup: defaultBackup(getExistingLiteConfigPath())
+      preview: JSON.stringify({
+        [role.role]: {
+          model,
+          variant: effort.ok ? effort.variant ?? null : null
+        }
+      }),
+      backup: defaultBackup(getExistingLiteConfigPath()),
+      ...!effort.ok ? {
+        warnings: [
+          {
+            severity: "critical",
+            code: effort.code,
+            message: effort.message
+          }
+        ]
+      } : {}
     };
   });
   const plan = planFromItems(
@@ -4568,6 +4811,11 @@ function buildOpenCodeModelPlan(input, _context = { cwd: process.cwd() }) {
     "Preview thoth-agents role model overrides in the plugin config agents map.",
     items
   );
+  const effortWarnings = items.flatMap((item) => item.warnings ?? []);
+  if (effortWarnings.length > 0) {
+    plan.canApply = false;
+    plan.warnings.push(...effortWarnings);
+  }
   if (input.harness !== "opencode") {
     return {
       ...plan,
@@ -4693,13 +4941,14 @@ function applyModelPlan(plan) {
     }
     const role = match[1] ?? "";
     const model = parsed2[role]?.model;
-    if (!ROLE_NAMES.includes(role) || typeof model !== "string") {
+    const variant = parsed2[role]?.variant;
+    if (!ROLE_NAMES.includes(role) || typeof model !== "string" || variant !== null && typeof variant !== "string") {
       return rejectPlan3(
         plan,
         "OpenCode model plan contains an invalid role or model."
       );
     }
-    roleModels.set(role, model);
+    roleModels.set(role, { model, variant });
   }
   if (roleModels.size === 0) {
     return rejectPlan3(
@@ -4719,14 +4968,44 @@ function applyModelPlan(plan) {
     reset: false
   });
   const agents = base.agents && typeof base.agents === "object" ? { ...base.agents } : {};
-  for (const role of roleModels.keys()) {
-    agents[role] = {
-      ...agents[role] ?? {},
-      model: roleModels.get(role)
+  const statePath = getOpenCodeManagedModelStatePath();
+  const state = readManagedModelState(statePath, 1);
+  const configuredEfforts = { ...state.configuredEfforts ?? {} };
+  const warnings = [];
+  for (const [role, override] of roleModels) {
+    const current = {
+      ...agents[role] ?? {}
     };
+    const currentVariant = typeof current.variant === "string" ? current.variant : void 0;
+    const trackedVariant = configuredEfforts[role];
+    const userOwnsVariant = override.variant === null && currentVariant !== void 0 && (trackedVariant === void 0 || currentVariant !== trackedVariant);
+    current.model = override.model;
+    if (userOwnsVariant) {
+      delete configuredEfforts[role];
+      warnings.push({
+        severity: "important",
+        code: "opencode-effort-user-owned",
+        message: `Preserved user-owned OpenCode variant ${currentVariant} for ${role}.`
+      });
+    } else if (override.variant === null) {
+      delete current.variant;
+      delete configuredEfforts[role];
+    } else {
+      current.variant = override.variant;
+      configuredEfforts[role] = override.variant;
+    }
+    agents[role] = current;
   }
   base.agents = agents;
   writeConfig(targetPath, base);
+  writeTextWithBackup(
+    statePath,
+    stableJson3({
+      version: 1,
+      models: state.models,
+      ...Object.keys(configuredEfforts).length > 0 ? { configuredEfforts } : {}
+    })
+  );
   return {
     harness: "opencode",
     action: "model-config",
@@ -4739,7 +5018,7 @@ function applyModelPlan(plan) {
       }
     ],
     backups: existsSync10(`${targetPath}.bak`) ? [{ path: `${targetPath}.bak`, label: "managed backup" }] : [],
-    warnings: [],
+    warnings,
     disclaimers: defaultDisclaimers()
   };
 }
@@ -4868,23 +5147,571 @@ function getOperationHarness(harness) {
   return OPERATION_HARNESSES[harness];
 }
 
+// src/cli/tui/model-catalog.ts
+import { execFileSync } from "child_process";
+
+// src/cli/model-catalog/cache.ts
+import {
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync10,
+  renameSync as renameSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname5, posix, win32 } from "path";
+import { z as z2 } from "zod";
+var modelCatalogSourceSchema = z2.enum(["remote", "lkg", "manual"]);
+var cachedModelOptionSchema = z2.object({
+  id: z2.string().min(1),
+  catalogId: z2.string().min(1).optional(),
+  label: z2.string().min(1),
+  provider: z2.string().min(1),
+  efforts: z2.array(z2.string().min(1)),
+  source: modelCatalogSourceSchema
+}).passthrough();
+var modelsDevCacheSchema = z2.object({
+  version: z2.literal(1),
+  etag: z2.string().optional(),
+  fetchedAt: z2.string().datetime(),
+  catalog: z2.object({ models: z2.array(cachedModelOptionSchema) }).passthrough()
+}).passthrough();
+function resolveModelsDevCachePath(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const home = options.homeDir ?? homedir4();
+  if (platform === "win32") {
+    const path4 = win32;
+    const base2 = env.LOCALAPPDATA ?? env.APPDATA ?? path4.join(home, "AppData", "Local");
+    return path4.join(base2, "thoth-agents", "models-dev-v1.json");
+  }
+  const base = env.XDG_CACHE_HOME ?? posix.join(home, ".cache");
+  return posix.join(base, "thoth-agents", "models-dev-v1.json");
+}
+function readModelsDevCache(cachePath) {
+  if (!existsSync11(cachePath)) return void 0;
+  try {
+    const input = JSON.parse(readFileSync10(cachePath, "utf8"));
+    const parsed = modelsDevCacheSchema.safeParse(input);
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeModelsDevCacheAtomic(cachePath, cache) {
+  const validated = modelsDevCacheSchema.safeParse(cache);
+  if (!validated.success) {
+    throw new Error(`Invalid models.dev cache: ${validated.error.message}`);
+  }
+  mkdirSync3(dirname5(cachePath), { recursive: true });
+  const temporaryPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync3(
+      temporaryPath,
+      `${JSON.stringify(validated.data, null, 2)}
+`
+    );
+    renameSync2(temporaryPath, cachePath);
+  } catch (error) {
+    if (existsSync11(temporaryPath)) unlinkSync(temporaryPath);
+    throw error;
+  }
+}
+
+// src/cli/model-catalog/models-dev.ts
+import { z as z3 } from "zod";
+var modelsDevModelSchema = z3.object({
+  id: z3.string().min(1).optional(),
+  name: z3.string().min(1).optional(),
+  reasoning: z3.boolean().optional(),
+  reasoning_options: z3.array(z3.unknown()).optional()
+}).passthrough();
+var modelsDevProviderSchema = z3.object({
+  models: z3.record(z3.string(), modelsDevModelSchema)
+}).passthrough();
+var modelsDevCatalogSchema = z3.record(
+  z3.string(),
+  modelsDevProviderSchema
+);
+var effortOptionSchema = z3.object({
+  type: z3.literal("effort"),
+  values: z3.array(z3.string().min(1))
+}).passthrough();
+function normalizedCatalogId(provider, modelKey, declaredId) {
+  const candidate = (declaredId ?? modelKey).trim().toLowerCase();
+  return candidate.includes("/") ? candidate : `${provider}/${candidate}`;
+}
+function runtimeModelId(provider, catalogId) {
+  const prefix = `${provider}/`;
+  return catalogId.startsWith(prefix) ? catalogId.slice(prefix.length) : catalogId;
+}
+function effortValues(options) {
+  const values = /* @__PURE__ */ new Set();
+  for (const option of options ?? []) {
+    const parsed = effortOptionSchema.safeParse(option);
+    if (!parsed.success) continue;
+    for (const value of parsed.data.values) {
+      const normalized = value.trim();
+      if (normalized) values.add(normalized);
+    }
+  }
+  return [...values];
+}
+function normalizeModelsDevCatalog(input) {
+  const parsed = modelsDevCatalogSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      ok: false,
+      issues: parsed.error.issues.map(
+        (issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`
+      )
+    };
+  }
+  const models = [];
+  for (const [rawProvider, provider] of Object.entries(parsed.data)) {
+    const providerId = rawProvider.trim().toLowerCase();
+    for (const [modelKey, model] of Object.entries(provider.models)) {
+      const catalogId = normalizedCatalogId(providerId, modelKey, model.id);
+      const id = runtimeModelId(providerId, catalogId);
+      models.push({
+        id,
+        catalogId,
+        label: model.name ?? id,
+        provider: providerId,
+        efforts: effortValues(model.reasoning_options),
+        source: "remote"
+      });
+    }
+  }
+  return { ok: true, catalog: { models } };
+}
+
+// src/cli/model-catalog/index.ts
+var MODELS_DEV_URL = "https://models.dev/api.json";
+var MODELS_DEV_MAX_BYTES = 8 * 1024 * 1024;
+var MODELS_DEV_TIMEOUT_MS = 5e3;
+function ownsCatalogKey(model, key) {
+  const separator = key.indexOf("/");
+  return separator > 0 && model.provider === key.slice(0, separator);
+}
+function mergeModelCatalog(dynamic, manual) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const model of dynamic) {
+    const key = model.catalogId ?? model.id;
+    const existing = merged.get(key);
+    if (existing && ownsCatalogKey(existing, key) && !ownsCatalogKey(model, key)) {
+      continue;
+    }
+    merged.set(key, model);
+  }
+  for (const model of manual) {
+    const key = model.catalogId ?? model.id;
+    if (!merged.has(key)) merged.set(key, model);
+  }
+  return [...merged.values()];
+}
+function lkgModels(models) {
+  return models.map((model) => ({
+    ...model,
+    efforts: [...model.efforts],
+    source: "lkg"
+  }));
+}
+async function loadModelsDevCatalog(options = {}) {
+  const cachePath = options.cachePath ?? resolveModelsDevCachePath();
+  const manual = options.manual ?? [];
+  const fetcher = options.fetcher ?? fetch;
+  const checkedAt = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  const cached = readModelsDevCache(cachePath);
+  const warnings = [];
+  try {
+    const headers = new Headers({ Accept: "application/json" });
+    if (cached?.etag) headers.set("If-None-Match", cached.etag);
+    const response = await fetcher(MODELS_DEV_URL, {
+      headers,
+      signal: AbortSignal.timeout(MODELS_DEV_TIMEOUT_MS)
+    });
+    if (response.status === 304) {
+      if (!cached)
+        throw new Error("models.dev returned 304 without an LKG cache");
+      return {
+        models: mergeModelCatalog(lkgModels(cached.catalog.models), manual),
+        source: "lkg",
+        stale: false,
+        checkedAt,
+        warnings
+      };
+    }
+    if (!response.ok)
+      throw new Error(`models.dev returned HTTP ${response.status}`);
+    const text = await response.text();
+    if (Buffer.byteLength(text, "utf8") > MODELS_DEV_MAX_BYTES) {
+      throw new Error("models.dev response exceeded the maximum size");
+    }
+    const input = JSON.parse(text);
+    const normalized = normalizeModelsDevCatalog(input);
+    if (!normalized.ok) {
+      throw new Error(
+        `models.dev validation failed: ${normalized.issues.join("; ")}`
+      );
+    }
+    const remoteModels = normalized.catalog.models.map((model) => ({
+      ...model,
+      source: "remote"
+    }));
+    writeModelsDevCacheAtomic(cachePath, {
+      version: 1,
+      ...response.headers.get("etag") ? { etag: response.headers.get("etag") ?? void 0 } : {},
+      fetchedAt: checkedAt,
+      catalog: { models: lkgModels(remoteModels) }
+    });
+    return {
+      models: mergeModelCatalog(remoteModels, manual),
+      source: "remote",
+      stale: false,
+      checkedAt,
+      warnings
+    };
+  } catch (error) {
+    warnings.push(error instanceof Error ? error.message : String(error));
+  }
+  if (cached) {
+    return {
+      models: mergeModelCatalog(lkgModels(cached.catalog.models), manual),
+      source: "lkg",
+      stale: true,
+      checkedAt,
+      warnings
+    };
+  }
+  return {
+    models: [...manual],
+    source: "manual",
+    stale: true,
+    checkedAt,
+    warnings
+  };
+}
+
+// src/cli/tui/model-catalog.ts
+var MODEL_CATALOG_TIMEOUT_MS = 5e3;
+var CODEX_DOCUMENTED_EFFORTS2 = /* @__PURE__ */ new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
+]);
+var CLAUDE_CODE_EFFORTS2 = ["low", "medium", "high", "xhigh", "max"];
+function parseOpenCodeModels(output) {
+  const seen = /* @__PURE__ */ new Set();
+  const options = [];
+  for (const line of output.split(/\r?\n/)) {
+    const match = line.trim().match(/^([a-z0-9_-]+)\/([^\s{]+)/i);
+    if (!match) continue;
+    const id = `${match[1]}/${match[2]}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    options.push({
+      id,
+      catalogId: id,
+      label: id,
+      provider: match[1] ?? "unknown",
+      efforts: [],
+      source: "manual"
+    });
+  }
+  return options;
+}
+function isCodexOpenAiModelId(id) {
+  const match = id.match(/^gpt-(\d+)(?:[.-]|$)/);
+  return match?.[1] !== void 0 && Number(match[1]) >= 5;
+}
+function writableEfforts(harness, option) {
+  if (harness === "codex") {
+    return option.efforts.filter(
+      (effort) => CODEX_DOCUMENTED_EFFORTS2.has(effort)
+    );
+  }
+  if (harness === "claude") {
+    return option.efforts.filter(
+      (effort) => CLAUDE_CODE_EFFORTS2.includes(effort)
+    );
+  }
+  return option.efforts.filter(
+    (effort) => resolveOpenCodeEffort({
+      model: option.id,
+      catalogId: option.catalogId,
+      availableEfforts: option.efforts,
+      effort: { kind: "effort", value: effort }
+    }).ok
+  );
+}
+function effortChoicesForModel(option) {
+  return ["inherit", ...option?.efforts ?? []];
+}
+function getOpenCodeModelsInvocation(platform = process.platform) {
+  const options = {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: MODEL_CATALOG_TIMEOUT_MS
+  };
+  if (platform === "win32") {
+    return {
+      command: "opencode models",
+      args: [],
+      options: { ...options, shell: true }
+    };
+  }
+  return { command: "opencode", args: ["models"], options };
+}
+function getNativeOpenCodeOptions() {
+  try {
+    const invocation = getOpenCodeModelsInvocation();
+    return parseOpenCodeModels(
+      execFileSync(invocation.command, invocation.args, invocation.options)
+    );
+  } catch {
+    return [];
+  }
+}
+var CLAUDE_CODE_MODEL_OPTIONS = [
+  { id: "sonnet", label: "sonnet", provider: "anthropic" },
+  { id: "opus", label: "opus", provider: "anthropic" },
+  { id: "haiku", label: "haiku", provider: "anthropic" },
+  {
+    id: "inherit",
+    label: "inherit (main session model)",
+    provider: "anthropic"
+  }
+].map((option) => ({
+  ...option,
+  efforts: option.id === "inherit" ? [] : [...CLAUDE_CODE_EFFORTS2],
+  source: "manual"
+}));
+async function getModelOptions(harness) {
+  const native = harness === "opencode" ? getNativeOpenCodeOptions() : [];
+  const loaded = await loadModelsDevCatalog({ manual: native });
+  if (harness === "claude") {
+    const aliases = CLAUDE_CODE_MODEL_OPTIONS.map((option) => ({
+      ...option,
+      efforts: [...option.efforts]
+    }));
+    const concrete = loaded.models.filter((option) => option.provider === "anthropic").map((option) => ({
+      ...option,
+      id: option.catalogId ?? option.id,
+      efforts: writableEfforts(harness, option)
+    }));
+    return [...aliases, ...concrete];
+  }
+  if (harness === "codex") {
+    return loaded.models.filter(
+      (option) => option.provider === "openai" && isCodexOpenAiModelId(option.id)
+    ).map((option) => ({
+      ...option,
+      efforts: writableEfforts(harness, option)
+    }));
+  }
+  const catalogById = new Map(
+    loaded.models.map((option) => [option.catalogId ?? option.id, option])
+  );
+  return native.map((option) => {
+    const catalog = catalogById.get(option.catalogId ?? option.id);
+    const enriched = catalog ? { ...catalog, id: option.id, catalogId: option.catalogId } : option;
+    return { ...enriched, efforts: writableEfforts(harness, enriched) };
+  });
+}
+
+// src/cli/tui/operations.ts
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+var context = { cwd: process.cwd() };
+var codexContext = { cwd: process.cwd() };
+var claudeCodeContext = {
+  cwd: process.cwd(),
+  scope: "user"
+};
+var opencodeModelRoles = ALL_AGENT_NAMES.map(
+  (role) => ({
+    role,
+    model: DEFAULT_MODELS[role] ?? "openai/gpt-5.4"
+  })
+);
+var codexModelRoles = CODEX_ROLE_NAMES.map(
+  (role) => ({
+    role,
+    model: "gpt-5.4-mini"
+  })
+);
+var codexDefaultModels = new Map(
+  codexModelRoles.map((role) => [role.role, role.model])
+);
+function codexInstallConfig(source, dryRun) {
+  return {
+    dryRun,
+    reset: false,
+    scope: source.scope ?? "user",
+    projectRoot: source.cwd,
+    homeDir: source.homeDir,
+    codexHome: source.codexHome,
+    packageRoot: source.packageRoot,
+    pluginId: source.pluginId
+  };
+}
+function getCodexModelRoles(source = codexContext) {
+  try {
+    const plan = buildCodexSetupPlan(codexInstallConfig(source, true));
+    return CODEX_ROLE_NAMES.map((role) => {
+      const item = plan.items.find(
+        (candidate) => candidate.action === "write-role-toml" && candidate.role === role
+      );
+      const content = item && existsSync12(item.targetPath) ? readFileSync11(item.targetPath, "utf8") : item?.content;
+      const effort = content ? parseRoleTomlEffort(content) : void 0;
+      return {
+        role,
+        model: (content ? parseRoleTomlModel(content) : void 0) ?? codexDefaultModels.get(role) ?? "gpt-5.4-mini",
+        effort: effort ? { kind: "effort", value: effort } : { kind: "inherit" }
+      };
+    });
+  } catch {
+    return codexModelRoles.map((role) => ({ ...role }));
+  }
+}
+function getClaudeCodeModelRoles(source = claudeCodeContext) {
+  try {
+    const plan = buildClaudeCodeSetupPlan({
+      dryRun: true,
+      reset: false,
+      scope: source.scope ?? "user",
+      projectRoot: source.cwd,
+      homeDir: source.homeDir,
+      packageRoot: source.packageRoot
+    });
+    return CLAUDE_CODE_ROLE_NAMES.map((role) => {
+      const item = plan.items.find(
+        (candidate) => candidate.kind === "subagent" && candidate.role === role
+      );
+      const content = item && existsSync12(item.targetPath) ? readFileSync11(item.targetPath, "utf8") : item?.content;
+      const model = content ? parseSubagentModel(content) : void 0;
+      const effort = content ? parseSubagentEffort(content) : void 0;
+      return {
+        role,
+        model: model ?? "inherit",
+        effort: effort ? { kind: "effort", value: effort } : { kind: "inherit" }
+      };
+    });
+  } catch {
+    return defaultClaudeCodeModelRoles();
+  }
+}
+function readRoleField(config, role, field) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return void 0;
+  }
+  const record = config;
+  const value = record[role];
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const fieldValue = value[field];
+  return typeof fieldValue === "string" && fieldValue.length > 0 ? fieldValue : void 0;
+}
+function getOpenCodeModelRoles() {
+  const parsed = parseConfig(getExistingLiteConfigPath());
+  const agents = parsed.config?.agents && typeof parsed.config.agents === "object" ? parsed.config.agents : void 0;
+  const presets = parsed.config?.presets && typeof parsed.config.presets === "object" ? parsed.config.presets : {};
+  const openaiPreset = presets.openai && typeof presets.openai === "object" ? presets.openai : void 0;
+  return ALL_AGENT_NAMES.map((role) => {
+    const variant = readRoleField(agents, role, "variant") ?? readRoleField(openaiPreset, role, "variant");
+    return {
+      role,
+      model: readRoleField(agents, role, "model") ?? readRoleField(openaiPreset, role, "model") ?? DEFAULT_MODELS[role] ?? "openai/gpt-5.4",
+      effort: variant ? { kind: "effort", value: variant } : { kind: "inherit" }
+    };
+  });
+}
+function buildTuiModelPlan(harness, roles) {
+  if (harness === "opencode") {
+    return buildOpenCodeModelPlan({ harness, dryRun: true, roles }, context);
+  }
+  if (harness === "claude") {
+    return buildClaudeCodeModelPlan(
+      { harness, dryRun: true, roles },
+      claudeCodeContext
+    );
+  }
+  return buildCodexModelPlan({ harness, dryRun: true, roles }, codexContext);
+}
+var defaultTuiOperations = {
+  status(harness) {
+    if (harness === "opencode") return getOpenCodeStatus(context);
+    if (harness === "claude") {
+      return getClaudeCodeStatus(claudeCodeContext);
+    }
+    return getCodexStatus(codexContext);
+  },
+  modelRoles(harness) {
+    if (harness === "opencode") return getOpenCodeModelRoles();
+    if (harness === "claude") {
+      return getClaudeCodeModelRoles(claudeCodeContext);
+    }
+    return getCodexModelRoles(codexContext);
+  },
+  modelOptions(harness) {
+    return getModelOptions(harness);
+  },
+  plan(harness, action) {
+    if (harness === "opencode") {
+      if (action === "install") return buildOpenCodeInstallPlan(context);
+      if (action === "update") return buildOpenCodeUpdatePlan(context);
+      if (action === "sync") return buildOpenCodeSyncPlan(context);
+      return buildTuiModelPlan(harness, getOpenCodeModelRoles());
+    }
+    if (harness === "claude") {
+      if (action === "install") {
+        return buildClaudeCodeInstallPlan(claudeCodeContext);
+      }
+      if (action === "update") {
+        return buildClaudeCodeUpdatePlan(claudeCodeContext);
+      }
+      if (action === "sync") return buildClaudeCodeSyncPlan(claudeCodeContext);
+      return buildTuiModelPlan(
+        harness,
+        getClaudeCodeModelRoles(claudeCodeContext)
+      );
+    }
+    if (action === "install") return buildCodexInstallPlan(codexContext);
+    if (action === "update") return buildCodexUpdatePlan(codexContext);
+    if (action === "sync") return buildCodexSyncPlan(codexContext);
+    return buildTuiModelPlan(harness, getCodexModelRoles(codexContext));
+  },
+  modelPlan(harness, roles) {
+    return buildTuiModelPlan(harness, roles);
+  },
+  apply(plan) {
+    if (plan.harness === "opencode") return applyOpenCodePlan(plan);
+    if (plan.harness === "claude") return applyClaudeCodePlan(plan);
+    return applyCodexPlan(plan);
+  }
+};
+
 export {
   claudeCodeAdapter,
   codexAdapter,
   CODEX_ROLE_NAMES,
-  parseRoleTomlModel,
+  normalizeEffortSelection,
   buildCodexSetupPlan,
   formatCodexSetupPlan,
   applyCodexSetup,
-  CLAUDE_CODE_ROLE_NAMES,
-  parseSubagentModel,
   buildClaudeCodeSetupPlan,
   applyClaudeCodeSetup,
   formatClaudeCodeSetupPlan,
   RECOMMENDED_SKILLS,
   installRecommendedSkill,
   getClaudeCodeStatus,
-  buildClaudeCodeInstallPlan,
   buildClaudeCodeUpdatePlan,
   buildClaudeCodeSyncPlan,
   buildClaudeCodeModelPlan,
@@ -4893,16 +5720,20 @@ export {
   getCodexStatus,
   buildCodexUpdatePlan,
   buildCodexSyncPlan,
-  buildCodexInstallPlan,
   buildCodexModelPlan,
   applyCodexPlan,
   getOpenCodeStatus,
   buildOpenCodeUpdatePlan,
   buildOpenCodeSyncPlan,
-  buildOpenCodeInstallPlan,
   buildOpenCodeModelPlan,
   applyOpenCodePlan,
   SUPPORTED_OPERATION_HARNESSES,
   listOperationHarnesses,
-  getOperationHarness
+  getOperationHarness,
+  effortChoicesForModel,
+  getModelOptions,
+  getCodexModelRoles,
+  getClaudeCodeModelRoles,
+  getOpenCodeModelRoles,
+  defaultTuiOperations
 };