automata-cli 0.1.0-feature-032-message-tool-model.252 → 0.1.0-feature-032-message-tool-model.258

package/dist/{ConfigWizard-J67TY22Z.js → ConfigWizard-HDHKPY6J.js}

@@ -152,6 +152,8 @@ function ConfigWizard() {
   );
   const [doWorkClaudeModel, setDoWorkClaudeModel] = useState(existing.doWork?.models?.claude ?? "");
   const [doWorkCodexModel, setDoWorkCodexModel] = useState(existing.doWork?.models?.codex ?? "");
+  const [doWorkClaudeEffort, setDoWorkClaudeEffort] = useState(existing.doWork?.effort?.claude ?? "");
+  const [doWorkCodexEffort, setDoWorkCodexEffort] = useState(existing.doWork?.effort?.codex ?? "");
   const [doWorkLockStale, setDoWorkLockStale] = useState(
     String(existing.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes)
   );
@@ -269,13 +271,23 @@ function ConfigWizard() {
     },
     "do-work-claude-model": {
       setValue: setDoWorkClaudeModel,
-      onSubmit: () => setScreen("do-work-codex-model"),
+      onSubmit: () => setScreen("do-work-claude-effort"),
       onBack: () => setScreen("do-work-executor")
     },
+    "do-work-claude-effort": {
+      setValue: setDoWorkClaudeEffort,
+      onSubmit: () => setScreen("do-work-codex-model"),
+      onBack: () => setScreen("do-work-claude-model")
+    },
     "do-work-codex-model": {
       setValue: setDoWorkCodexModel,
+      onSubmit: () => setScreen("do-work-codex-effort"),
+      onBack: () => setScreen("do-work-claude-effort")
+    },
+    "do-work-codex-effort": {
+      setValue: setDoWorkCodexEffort,
       onSubmit: () => setScreen("do-work-max-runs"),
-      onBack: () => setScreen("do-work-claude-model")
+      onBack: () => setScreen("do-work-codex-model")
     },
     "do-work-max-runs": {
       setValue: (update) => {
@@ -291,7 +303,7 @@ function ConfigWizard() {
         setValidationError("");
         setScreen("do-work-lock-stale");
       },
-      onBack: () => setScreen("do-work-codex-model")
+      onBack: () => setScreen("do-work-codex-effort")
     },
     "do-work-lock-stale": {
       setValue: (update) => {
@@ -317,6 +329,10 @@ function ConfigWizard() {
               claude: doWorkClaudeModel.trim() || void 0,
               codex: doWorkCodexModel.trim() || void 0
             },
+            effort: {
+              claude: doWorkClaudeEffort.trim() || void 0,
+              codex: doWorkCodexEffort.trim() || void 0
+            },
             maxRunsPerTick: maxRuns ?? void 0,
             lockStaleMinutes: parsed
           }
@@ -470,12 +486,24 @@ function ConfigWizard() {
       value: doWorkClaudeModel,
       hint: `Type model \xB7 Enter to continue \xB7 ${BACK}`
     },
+    "do-work-claude-effort": {
+      title: "Do Work \u2014 Claude Effort",
+      label: "Default reasoning effort when the executor is Claude (blank = the executor's own default):",
+      value: doWorkClaudeEffort,
+      hint: `Type effort \xB7 Enter to continue \xB7 ${BACK}`
+    },
     "do-work-codex-model": {
       title: "Do Work \u2014 Codex Model",
       label: "Default model when the executor is Codex (blank = the executor's own default):",
       value: doWorkCodexModel,
       hint: `Type model \xB7 Enter to continue \xB7 ${BACK}`
     },
+    "do-work-codex-effort": {
+      title: "Do Work \u2014 Codex Effort",
+      label: "Default reasoning effort when the executor is Codex (blank = the executor's own default):",
+      value: doWorkCodexEffort,
+      hint: `Type effort \xB7 Enter to continue \xB7 ${BACK}`
+    },
     "do-work-max-runs": {
       title: "Do Work \u2014 Max Runs Per Tick",
       label: "Model runs allowed per tick (0 = unlimited):",

package/dist/index.js

@@ -34,9 +34,9 @@ function writeDoWork(patch) {
   writeConfig({ ...current, doWork: { ...current.doWork, ...patch } });
 }
 function parseNonNegativeInt(value, label) {
-  const trimmed = value.trim();
-  const parsed = Number.parseInt(trimmed, 10);
-  if (Number.isNaN(parsed) || parsed < 0 || String(parsed) !== trimmed || !Number.isSafeInteger(parsed)) {
+  const trimmed2 = value.trim();
+  const parsed = Number.parseInt(trimmed2, 10);
+  if (Number.isNaN(parsed) || parsed < 0 || String(parsed) !== trimmed2 || !Number.isSafeInteger(parsed)) {
     process.stderr.write(`Error: ${label} must be a non-negative integer (got "${value}").
 `);
     process.exit(1);
@@ -147,6 +147,24 @@ var configSetDoWorkModel = new Command("do-work-model").description("Set the def
   process.stdout.write(`do-work ${executor} model set to: ${model}
 `);
 });
+var configSetDoWorkEffort = new Command("do-work-effort").description("Set the default reasoning effort `do-work` passes to one executor").argument("<executor>", `Executor: ${VALID_EXECUTORS.join(", ")}`).argument("<value>", "Effort level, forwarded to the executor unchanged").action((executor, value) => {
+  if (!VALID_EXECUTORS.includes(executor)) {
+    process.stderr.write(
+      `Error: invalid executor "${executor}". Must be one of: ${VALID_EXECUTORS.join(", ")}
+`
+    );
+    process.exit(1);
+  }
+  const effort = value.trim();
+  if (effort.length === 0) {
+    process.stderr.write("Error: do-work-effort requires a non-empty effort level.\n");
+    process.exit(1);
+  }
+  const current = readRawConfig();
+  writeDoWork({ effort: { ...current.doWork?.effort, [executor]: effort } });
+  process.stdout.write(`do-work ${executor} effort set to: ${effort}
+`);
+});
 var configSetDoWorkMaxRuns = new Command("do-work-max-runs").description("Set the maximum number of model runs `do-work` performs per tick (0 = unlimited)").argument("<value>", "Non-negative integer").action((value) => {
   const maxRunsPerTick = parseNonNegativeInt(value, "do-work-max-runs");
   writeDoWork({ maxRunsPerTick });
@@ -189,12 +207,12 @@ var configSetDoWorkPrompt = new Command("do-work-prompt").description("Set the t
   process.stdout.write(`do-work ${turnKind} prompt set.
 `);
 });
-var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType).addCommand(configSetIssueDiscoveryTechnique).addCommand(configSetIssueDiscoveryValue).addCommand(configSetClaudeSystemPrompt).addCommand(configSetAllowedUsers).addCommand(configSetAgentUser).addCommand(configSetDoWorkBaseBranch).addCommand(configSetDoWorkProtectedBranches).addCommand(configSetDoWorkExecutor).addCommand(configSetDoWorkModel).addCommand(configSetDoWorkMaxRuns).addCommand(configSetDoWorkLockStaleMinutes).addCommand(configSetDoWorkPrompt);
+var configSet = new Command("set").description("Set a configuration value").addCommand(configSetType).addCommand(configSetIssueDiscoveryTechnique).addCommand(configSetIssueDiscoveryValue).addCommand(configSetClaudeSystemPrompt).addCommand(configSetAllowedUsers).addCommand(configSetAgentUser).addCommand(configSetDoWorkBaseBranch).addCommand(configSetDoWorkProtectedBranches).addCommand(configSetDoWorkExecutor).addCommand(configSetDoWorkModel).addCommand(configSetDoWorkEffort).addCommand(configSetDoWorkMaxRuns).addCommand(configSetDoWorkLockStaleMinutes).addCommand(configSetDoWorkPrompt);
 var configCommand = new Command("config").description("Configure automata settings").addCommand(configSet).action(async () => {
   const [{ render }, React, { ConfigWizard }] = await Promise.all([
     import("ink"),
     import("react"),
-    import("./ConfigWizard-J67TY22Z.js")
+    import("./ConfigWizard-HDHKPY6J.js")
   ]);
   const { waitUntilExit } = render(React.createElement(ConfigWizard));
   await waitUntilExit();
@@ -1539,6 +1557,15 @@ function handleExitCode(status, toolName) {
     process.exit(status);
   }
 }
+function resolveEffortOption(value) {
+  if (value === void 0) return void 0;
+  const trimmed2 = value.trim();
+  if (trimmed2.length === 0) {
+    process.stderr.write("Error: --effort must be a non-empty level.\n");
+    process.exit(1);
+  }
+  return trimmed2;
+}
 
 // src/cli/childRegistry.ts
 var active = /* @__PURE__ */ new Set();
@@ -1595,6 +1622,7 @@ function buildClaudeArgs(prompt, options = {}) {
   const args = [];
   if (options.yolo) args.push("--dangerously-skip-permissions");
   if (options.model) args.push("--model", options.model);
+  if (options.effort) args.push("--effort", options.effort);
   if (options.verbose) args.push("--verbose", "--output-format", "stream-json");
   args.push("-p", prompt);
   return args;
@@ -1602,7 +1630,12 @@ function buildClaudeArgs(prompt, options = {}) {
 function runClaude(prompt, options = {}) {
   return new Promise((resolve2, reject) => {
     const claudeBin = resolveCommand("claude");
-    const args = buildClaudeArgs(prompt, { yolo: true, model: options.model, verbose: true });
+    const args = buildClaudeArgs(prompt, {
+      yolo: true,
+      model: options.model,
+      effort: options.effort,
+      verbose: true
+    });
     const child = spawn(claudeBin, args, { stdio: ["inherit", "pipe", "inherit"] });
     trackChild(child);
     const rl = createInterface({ input: child.stdout });
@@ -1639,21 +1672,21 @@ function runClaude(prompt, options = {}) {
 }
 function invokeClaudeCode(prompt, options = {}) {
   if (options.verbose) {
-    return invokeClaudeCodeVerbose(prompt, options.yolo ?? false, options.model);
+    return invokeClaudeCodeVerbose(prompt, options.yolo ?? false, options.model, options.effort);
   }
-  invokeClaudeCodeSync(prompt, options.yolo ?? false, options.model);
+  invokeClaudeCodeSync(prompt, options.yolo ?? false, options.model, options.effort);
 }
-function invokeClaudeCodeSync(prompt, yolo, model) {
+function invokeClaudeCodeSync(prompt, yolo, model, effort) {
   const claudeBin = resolveCommand("claude");
-  const args = buildClaudeArgs(prompt, { yolo, model, verbose: false });
+  const args = buildClaudeArgs(prompt, { yolo, model, effort, verbose: false });
   const result = spawnSync4(claudeBin, args, { encoding: "utf8", stdio: "inherit" });
   handleSpawnError(result.error, "claude");
   handleExitCode(result.status, "Claude Code");
 }
-function invokeClaudeCodeVerbose(prompt, yolo, model) {
+function invokeClaudeCodeVerbose(prompt, yolo, model, effort) {
   return new Promise((resolve2) => {
     const claudeBin = resolveCommand("claude");
-    const args = buildClaudeArgs(prompt, { yolo, model, verbose: true });
+    const args = buildClaudeArgs(prompt, { yolo, model, effort, verbose: true });
     const child = spawn(claudeBin, args, { stdio: ["inherit", "pipe", "inherit"] });
     const rl = createInterface({ input: child.stdout });
     let turnCount = 0;
@@ -1753,10 +1786,14 @@ function summarizeTool(name, input) {
 
 // src/codex/codexService.ts
 import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
+function toTomlBasicString(value) {
+  return JSON.stringify(value);
+}
 function buildCodexArgs(prompt, options = {}) {
   const args = ["exec"];
   if (options.yolo) args.push("--dangerously-bypass-approvals-and-sandbox");
   if (options.model) args.push("--model", options.model);
+  if (options.effort) args.push("-c", `model_reasoning_effort=${toTomlBasicString(options.effort)}`);
   args.push(prompt);
   return args;
 }
@@ -1764,11 +1801,11 @@ function invokeCodexCode(prompt, options = {}) {
   if (options.verbose) {
     process.stderr.write("Warning: --verbose is not supported for Codex and will be ignored.\n");
   }
-  invokeCodexCodeSync(prompt, options.yolo ?? false, options.model);
+  invokeCodexCodeSync(prompt, options.yolo ?? false, options.model, options.effort);
 }
-function invokeCodexCodeSync(prompt, yolo, model) {
+function invokeCodexCodeSync(prompt, yolo, model, effort) {
   const codexBin = resolveCommand("codex");
-  const args = buildCodexArgs(prompt, { yolo, model });
+  const args = buildCodexArgs(prompt, { yolo, model, effort });
   const result = spawnSync5(codexBin, args, { encoding: "utf8", stdio: "inherit" });
   handleSpawnError(result.error, "codex");
   handleExitCode(result.status, "Codex");
@@ -1776,7 +1813,7 @@ function invokeCodexCodeSync(prompt, yolo, model) {
 function runCodex(prompt, options = {}) {
   return new Promise((resolve2, reject) => {
     const codexBin = resolveCommand("codex");
-    const args = buildCodexArgs(prompt, { yolo: true, model: options.model });
+    const args = buildCodexArgs(prompt, { yolo: true, model: options.model, effort: options.effort });
     const child = spawn2(codexBin, args, { stdio: "inherit" });
     trackChild(child);
     child.on("error", (err) => {
@@ -1881,7 +1918,7 @@ Title:  ${issue.title}
   }
   return issue;
 }
-var implementNextCommand = new Command3("implement-next").description("Find the next open GitHub issue matching the configured filter, claim it, and invoke the AI code assistant (Claude or Codex)").option("--json", "Output issue details as JSON").option("--no-claude", "Skip all AI invocation (Claude or Codex) after claiming the issue").option("--with <executor>", "Executor to use: claude or codex", "claude").option("--query-only", "Print issue content and exit without claiming or invoking any AI tools").option("--yolo", "Launch with --dangerously-skip-permissions (Claude) or --dangerously-bypass-approvals-and-sandbox (Codex)").option("--silent", "Suppress step-by-step Claude output; show only the final summary").option("--model <string>", "Model identifier to pass to the executor").option("--take-first", "When multiple issues match, pick the first without prompting").option("--limit <n>", "Max issues to fetch and display (default: 10)", "10").option("--ask-copilot-review", "Request a Copilot code review on the PR after AI invocation finishes").action(async (options) => {
+var implementNextCommand = new Command3("implement-next").description("Find the next open GitHub issue matching the configured filter, claim it, and invoke the AI code assistant (Claude or Codex)").option("--json", "Output issue details as JSON").option("--no-claude", "Skip all AI invocation (Claude or Codex) after claiming the issue").option("--with <executor>", "Executor to use: claude or codex", "claude").option("--query-only", "Print issue content and exit without claiming or invoking any AI tools").option("--yolo", "Launch with --dangerously-skip-permissions (Claude) or --dangerously-bypass-approvals-and-sandbox (Codex)").option("--silent", "Suppress step-by-step Claude output; show only the final summary").option("--model <string>", "Model identifier to pass to the executor").option("--effort <level>", "Reasoning effort to pass to the executor").option("--take-first", "When multiple issues match, pick the first without prompting").option("--limit <n>", "Max issues to fetch and display (default: 10)", "10").option("--ask-copilot-review", "Request a Copilot code review on the PR after AI invocation finishes").action(async (options) => {
   const config = readConfig();
   validateConfig(config);
   const limit = Number.parseInt(options.limit, 10);
@@ -1919,6 +1956,7 @@ ${issue.body}
 `);
     process.exit(1);
   }
+  const effort = resolveEffortOption(options.effort);
   if (options.claude !== false) {
     const systemPrompt = config.claudeSystemPrompt ?? DEFAULT_CLAUDE_SYSTEM_PROMPT;
     const prompt = `Resolving issue #${issue.number}:
@@ -1930,9 +1968,14 @@ ${issue.body}`;
       if (options.silent) {
         process.stderr.write("Warning: --silent is only supported with Claude and has no effect when used with Codex.\n");
       }
-      invokeCodexCode(prompt, { yolo: options.yolo, model: options.model });
+      invokeCodexCode(prompt, { yolo: options.yolo, model: options.model, effort });
     } else {
-      await invokeClaudeCode(prompt, { yolo: options.yolo, verbose: !options.silent, model: options.model });
+      await invokeClaudeCode(prompt, {
+        yolo: options.yolo,
+        verbose: !options.silent,
+        model: options.model,
+        effort
+      });
     }
   }
   linkPrToIssue(issue.number, commentUrl, options.askCopilotReview === true);
@@ -2021,7 +2064,7 @@ async function resolvePrompt(options) {
   process.stderr.write("Error: No prompt provided. Use --prompt, --file-prompt, or pipe via stdin.\n");
   process.exit(1);
 }
-var executeCommand = new Command4("execute").description("Delegate work to an AI executor").requiredOption("--with <executor>", "Executor to use: claude or codex").option("--prompt <string>", "Prompt to send to the executor").option("--file-prompt <path>", "Path to a file whose content is used as the prompt").option("--silent", "Suppress step-by-step Claude output; show only the final summary").option("--model <string>", "Model identifier to pass to the executor").action(async (options) => {
+var executeCommand = new Command4("execute").description("Delegate work to an AI executor").requiredOption("--with <executor>", "Executor to use: claude or codex").option("--prompt <string>", "Prompt to send to the executor").option("--file-prompt <path>", "Path to a file whose content is used as the prompt").option("--silent", "Suppress step-by-step Claude output; show only the final summary").option("--model <string>", "Model identifier to pass to the executor").option("--effort <level>", "Reasoning effort to pass to the executor").action(async (options) => {
   const executor = options.with.toLowerCase();
   if (executor !== "claude" && executor !== "codex") {
     process.stderr.write(`Error: --with must be 'claude' or 'codex', got '${options.with}'.
@@ -2029,10 +2072,16 @@ var executeCommand = new Command4("execute").description("Delegate work to an AI
     process.exit(1);
   }
   const prompt = await resolvePrompt(options);
+  const effort = resolveEffortOption(options.effort);
   if (executor === "codex") {
-    invokeCodexCode(prompt, { yolo: true, model: options.model });
+    invokeCodexCode(prompt, { yolo: true, model: options.model, effort });
   } else {
-    await invokeClaudeCode(prompt, { yolo: true, verbose: !options.silent, model: options.model });
+    await invokeClaudeCode(prompt, {
+      yolo: true,
+      verbose: !options.silent,
+      model: options.model,
+      effort
+    });
   }
 });
 
@@ -2154,7 +2203,7 @@ function pluralSuffix(count) {
   return count === 1 ? "" : "s";
 }
 function addAiOptions(cmd) {
-  return cmd.requiredOption("--with <executor>", "Executor to use: claude or codex").option("--model <string>", "Model identifier to pass to the executor").option("--silent", "Suppress step-by-step Claude output; show only the final summary").option("--push", "Append instruction to commit and push changes after the AI finishes");
+  return cmd.requiredOption("--with <executor>", "Executor to use: claude or codex").option("--model <string>", "Model identifier to pass to the executor").option("--effort <level>", "Reasoning effort to pass to the executor").option("--silent", "Suppress step-by-step Claude output; show only the final summary").option("--push", "Append instruction to commit and push changes after the AI finishes");
 }
 function resolveExecutor2(withOption) {
   const executor = withOption.toLowerCase();
@@ -2166,11 +2215,17 @@ function resolveExecutor2(withOption) {
   return executor;
 }
 function invokeSelectedExecutor(prompt, executor, options) {
+  const effort = resolveEffortOption(options.effort);
   if (executor === "codex") {
-    invokeCodexCode(prompt, { yolo: true, model: options.model });
+    invokeCodexCode(prompt, { yolo: true, model: options.model, effort });
     return;
   }
-  return invokeClaudeCode(prompt, { yolo: true, verbose: !options.silent, model: options.model });
+  return invokeClaudeCode(prompt, {
+    yolo: true,
+    verbose: !options.silent,
+    model: options.model,
+    effort
+  });
 }
 var executeSonarCmd = addAiOptions(
   new Command5("sonar").description(
@@ -2965,6 +3020,17 @@ function triggeringMessage(item) {
 function isExecutor(value) {
   return VALID_TOOLS.includes(value);
 }
+function trimmed(value) {
+  if (value === void 0) return void 0;
+  const cleaned = value.trim();
+  return cleaned.length === 0 ? void 0 : cleaned;
+}
+function resolvePerExecutor(option, configured, switched) {
+  if (!switched && option !== void 0) return { value: option, source: "option" };
+  const fromConfig = trimmed(configured);
+  if (fromConfig !== void 0) return { value: fromConfig, source: "config" };
+  return { value: void 0, source: "none" };
+}
 function resolveExecution(input) {
   const { directive, withOption, modelOption, configExecutor, configModels } = input;
   if (directive.tool !== void 0 && !isExecutor(directive.tool)) {
@@ -2975,22 +3041,25 @@ function resolveExecution(input) {
   const executor = directive.tool ?? baseline;
   const executorSource = directive.tool === void 0 ? baselineSource : "message";
   const switched = directive.tool !== void 0 && directive.tool !== baseline;
+  const effort = resolvePerExecutor(input.effortOption, input.configEfforts?.[executor], switched);
+  const common = {
+    ok: true,
+    executor,
+    executorSource,
+    effort: effort.value,
+    effortSource: effort.source
+  };
   if (directive.model !== void 0) {
-    return { ok: true, executor, executorSource, model: directive.model, modelSource: "message" };
+    return { ...common, model: directive.model, modelSource: "message" };
   }
-  const configModel = configModels?.[executor];
-  if (!switched && modelOption !== void 0) {
-    return { ok: true, executor, executorSource, model: modelOption, modelSource: "option" };
-  }
-  if (configModel !== void 0) {
-    return { ok: true, executor, executorSource, model: configModel, modelSource: "config" };
-  }
-  return { ok: true, executor, executorSource, model: void 0, modelSource: "none" };
+  const model = resolvePerExecutor(modelOption, configModels?.[executor], switched);
+  return { ...common, model: model.value, modelSource: model.source };
 }
 function describeExecution(execution) {
   const model = execution.model === void 0 ? " (no model override)" : ` \xB7 model ${execution.model}`;
+  const effort = execution.effort === void 0 ? "" : ` \xB7 effort ${execution.effort}`;
   const fromMessage = execution.executorSource === "message" || execution.modelSource === "message" ? " \u2014 from the message" : "";
-  return `${execution.executor}${model}${fromMessage}`;
+  return `${execution.executor}${model}${effort}${fromMessage}`;
 }
 function describeInvalidTool(invalidTool) {
   return `the newest message asks for \`tool:${invalidTool}\`, which is not an executor automata knows (valid values are ${VALID_TOOLS.map((tool) => `\`${tool}\``).join(" and ")})`;
@@ -3341,11 +3410,11 @@ function fail(message) {
   process.exit(1);
 }
 function parsePositiveInt(value, label) {
-  const trimmed = value.trim();
-  if (!/^\d+$/.test(trimmed)) {
+  const trimmed2 = value.trim();
+  if (!/^\d+$/.test(trimmed2)) {
     fail(`${label} must be a positive integer (got "${value}").`);
   }
-  const parsed = Number(trimmed);
+  const parsed = Number(trimmed2);
   if (!Number.isSafeInteger(parsed) || parsed <= 0) {
     fail(`${label} must be a positive integer within the safe range (got "${value}").`);
   }
@@ -3397,6 +3466,12 @@ function resolveSettings(options) {
     modelOption: options.model,
     configExecutor: doWork.executor,
     configModels: doWork.models,
+    // Rejected here rather than per item: an empty `--effort` is an operator
+    // mistake on this invocation, not a property of any one work item. The
+    // configured per-executor defaults are trimmed inside `resolveExecution`,
+    // which is where the executor in use is finally known.
+    effortOption: resolveEffortOption(options.effort),
+    configEfforts: doWork.effort,
     maxRuns: options.maxRuns !== void 0 ? parsePositiveInt(options.maxRuns, "--max-runs") : doWork.maxRunsPerTick ?? DEFAULT_DO_WORK.maxRunsPerTick,
     lockStaleMinutes: doWork.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes,
     limit: parsePositiveInt(options.limit, "--limit"),
@@ -3437,9 +3512,21 @@ function resolveItemExecution(item, settings) {
     modelOption: settings.modelOption,
     configExecutor: settings.configExecutor,
     configModels: settings.configModels,
+    effortOption: settings.effortOption,
+    configEfforts: settings.configEfforts,
     defaultExecutor: DEFAULT_DO_WORK.executor
   });
 }
+function toExecution(resolved) {
+  return {
+    executor: resolved.executor,
+    executorSource: resolved.executorSource,
+    model: resolved.model,
+    modelSource: resolved.modelSource,
+    effort: resolved.effort,
+    effortSource: resolved.effortSource
+  };
+}
 function planRun(item, settings, execution) {
   const prompt = composePrompt({
     item,
@@ -3449,7 +3536,12 @@ function planRun(item, settings, execution) {
     frame: settings.prompts[item.turn]
   });
   const bin = resolveCommand(execution.executor === "codex" ? "codex" : "claude");
-  const args = execution.executor === "codex" ? buildCodexArgs(prompt, { yolo: true, model: execution.model }) : buildClaudeArgs(prompt, { yolo: true, verbose: true, model: execution.model });
+  const args = execution.executor === "codex" ? buildCodexArgs(prompt, { yolo: true, model: execution.model, effort: execution.effort }) : buildClaudeArgs(prompt, {
+    yolo: true,
+    verbose: true,
+    model: execution.model,
+    effort: execution.effort
+  });
   return { prompt, bin, args, command: [bin, ...args].map(shellQuote).join(" ") };
 }
 function describePlannedRun(item, settings, run5, execution) {
@@ -3526,6 +3618,7 @@ function validateDoWorkConfig(section) {
   validateOptionalInt(section, "lockStaleMinutes", "doWork.lockStaleMinutes", 1, "a positive integer");
   validateProtectedBranches(section["protectedBranches"]);
   validateSettingContainer(section["models"], "models", ["claude", "codex"]);
+  validateSettingContainer(section["effort"], "effort", ["claude", "codex"]);
   validateSettingContainer(section["prompts"], "prompts", ["issueDiscuss", "prWork"]);
 }
 function validateProtectedBranches(value) {
@@ -3760,10 +3853,10 @@ function reportNoAnswer(item, marker, runError) {
 }
 async function invokeExecutor(prompt, execution, silent) {
   if (execution.executor === "codex") {
-    await runCodex(prompt, { model: execution.model });
+    await runCodex(prompt, { model: execution.model, effort: execution.effort });
     return;
   }
-  await runClaude(prompt, { model: execution.model, printSteps: !silent });
+  await runClaude(prompt, { model: execution.model, effort: execution.effort, printSteps: !silent });
 }
 function repairIssueLink(item, baseBranch) {
   try {
@@ -3895,12 +3988,7 @@ async function processItem(planned, settings, silent) {
     }
     return { ...base, outcome: "failed", detail };
   }
-  const execution = {
-    executor: resolved.executor,
-    executorSource: resolved.executorSource,
-    model: resolved.model,
-    modelSource: resolved.modelSource
-  };
+  const execution = toExecution(resolved);
   let runError = null;
   try {
     await invokeExecutor(prompt, execution, silent);
@@ -3964,13 +4052,18 @@ function toItemJson(report) {
     ranExecutor: report.ranExecutor ?? false,
     executor: report.execution?.executor ?? null,
     model: report.execution?.model ?? null,
+    effort: report.execution?.effort ?? null,
     executorSource: report.execution?.executorSource ?? null,
-    modelSource: report.execution?.modelSource ?? null
+    modelSource: report.execution?.modelSource ?? null,
+    effortSource: report.execution?.effortSource ?? null
   };
 }
 var doWorkCommand = new Command6("do-work").description(
   "Run one tick of the autonomous loop: find the issues whose newest authorized message the agent has not answered, and answer them"
-).option("--with <executor>", "Executor to use: claude or codex (default: from config, else claude)").option("--model <string>", "Model identifier to pass to the executor, overriding the configured default for it").option("--issue <number>", "Restrict the tick to a single issue").option("--limit <n>", "Maximum number of issues to fetch", "10").option("--max-runs <n>", "Maximum number of model runs this tick").option(
+).option("--with <executor>", "Executor to use: claude or codex (default: from config, else claude)").option("--model <string>", "Model identifier to pass to the executor, overriding the configured default for it").option(
+  "--effort <level>",
+  "Reasoning effort to pass to the executor, overriding the configured default for it"
+).option("--issue <number>", "Restrict the tick to a single issue").option("--limit <n>", "Maximum number of issues to fetch", "10").option("--max-runs <n>", "Maximum number of model runs this tick").option(
   "--dry-run",
   "Print the work plan, plus a summary and the exact command that would be launched for each item, and exit without changing anything"
 ).option("--json", "Emit the work plan and outcomes as JSON on stdout").option("--silent", "Suppress step-by-step Claude output; show only the final summary").action(async (options) => {
@@ -4132,8 +4225,10 @@ function toRunJson(entry) {
       turn: entry.item.turn,
       executor: null,
       model: null,
+      effort: null,
       executorSource: null,
       modelSource: null,
+      effortSource: null,
       refusal: entry.refusal,
       bin: null,
       args: null,
@@ -4146,8 +4241,10 @@ function toRunJson(entry) {
     turn: entry.item.turn,
     executor: entry.execution.executor,
     model: entry.execution.model ?? null,
+    effort: entry.execution.effort ?? null,
     executorSource: entry.execution.executorSource,
     modelSource: entry.execution.modelSource,
+    effortSource: entry.execution.effortSource,
     refusal: null,
     bin: entry.run.bin,
     args: entry.run.args,
@@ -4162,12 +4259,7 @@ function reportDryRun(items, decisions, settings, options) {
     if (!resolved.ok) {
       return { kind: "refused", item, refusal: describeInvalidTool(resolved.invalidTool) };
     }
-    const execution = {
-      executor: resolved.executor,
-      executorSource: resolved.executorSource,
-      model: resolved.model,
-      modelSource: resolved.modelSource
-    };
+    const execution = toExecution(resolved);
     return { kind: "run", item, execution, run: planRun(item, settings, execution) };
   });
   if (options.json) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.1.0-feature-032-message-tool-model.252",
+  "version": "0.1.0-feature-032-message-tool-model.258",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {