automata-cli 0.6.0-develop.256 → 0.6.0-develop.257

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

@@ -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 trimmed = value.trim();
+  if (trimmed.length === 0) {
+    process.stderr.write("Error: --effort must be a non-empty level.\n");
+    process.exit(1);
+  }
+  return trimmed;
+}
 
 // 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(
@@ -3321,6 +3376,13 @@ function resolveSettings(options) {
     executor,
     // --model wins; otherwise take the default for the executor in use.
     model: options.model ?? doWork.models?.[executor],
+    // Same precedence for the reasoning effort, but both candidates go through
+    // the one normaliser: a config value is validated as non-empty when the
+    // file is read, yet nothing trims it, so `" high "` would otherwise reach
+    // the executor with its padding and be silently ignored as an unknown
+    // level. `??` keeps the flag winning — an empty `--effort` is not nullish,
+    // so it is still rejected rather than falling through to the default.
+    effort: resolveEffortOption(options.effort ?? doWork.effort?.[executor]),
     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"),
@@ -3362,7 +3424,12 @@ function planRun(item, settings) {
     frame: settings.prompts[item.turn]
   });
   const bin = resolveCommand(settings.executor === "codex" ? "codex" : "claude");
-  const args = settings.executor === "codex" ? buildCodexArgs(prompt, { yolo: true, model: settings.model }) : buildClaudeArgs(prompt, { yolo: true, verbose: true, model: settings.model });
+  const args = settings.executor === "codex" ? buildCodexArgs(prompt, { yolo: true, model: settings.model, effort: settings.effort }) : buildClaudeArgs(prompt, {
+    yolo: true,
+    verbose: true,
+    model: settings.model,
+    effort: settings.effort
+  });
   return { prompt, bin, args, command: [bin, ...args].map(shellQuote).join(" ") };
 }
 function describePlannedRun(item, settings, run5) {
@@ -3371,6 +3438,7 @@ function describePlannedRun(item, settings, run5) {
   const assignment = item.needsAssignment ? `would assign to ${settings.participants.agentUser}` : "already assigned";
   const markerTarget = item.turn === "pr-work" && item.pr ? `pull request #${String(item.pr.number)}` : `issue #${String(item.issue.number)}`;
   const modelNote = settings.model === void 0 ? " (no model override)" : ` \xB7 model ${settings.model}`;
+  const effortNote = settings.effort === void 0 ? "" : ` \xB7 effort ${settings.effort}`;
   const lines = [
     rule,
     `Issue #${String(item.issue.number)} \u2014 ${item.issue.title}`,
@@ -3380,7 +3448,7 @@ function describePlannedRun(item, settings, run5) {
     `  Branch       ${item.branch} (would check out${branchAction})`,
     `  Assign       ${assignment}`,
     `  Marker       would post on ${markerTarget}`,
-    `  Executor     ${settings.executor}${modelNote}`,
+    `  Executor     ${settings.executor}${modelNote}${effortNote}`,
     "  Permissions  bypassed (do-work always runs unattended)",
     `  Prompt       ${String(run5.prompt.length)} chars \u2014 frame + assembled context`,
     "",
@@ -3427,6 +3495,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) {
@@ -3661,10 +3730,10 @@ function reportNoAnswer(item, marker, runError) {
 }
 async function invokeExecutor(prompt, settings, silent) {
   if (settings.executor === "codex") {
-    await runCodex(prompt, { model: settings.model });
+    await runCodex(prompt, { model: settings.model, effort: settings.effort });
     return;
   }
-  await runClaude(prompt, { model: settings.model, printSteps: !silent });
+  await runClaude(prompt, { model: settings.model, effort: settings.effort, printSteps: !silent });
 }
 function repairIssueLink(item, baseBranch) {
   try {
@@ -3833,7 +3902,10 @@ function summarize(reports) {
 }
 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) => {
@@ -3996,6 +4068,7 @@ function reportDryRun(items, decisions, settings, options) {
             turn: describable[index].turn,
             executor: settings.executor,
             model: settings.model ?? null,
+            effort: settings.effort ?? null,
             bin: run5.bin,
             args: run5.args,
             command: run5.command,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.6.0-develop.256",
+  "version": "0.6.0-develop.257",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {