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

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
+    });
   }
 });
 
@@ -2083,8 +2132,8 @@ function analyzeSurface(messages, p) {
 }
 function lastAuthorClass(messages, p) {
   if (messages.length === 0) return "none";
-  const newest = [...messages].sort(byCreatedAt).at(-1);
-  return newest === void 0 ? "none" : classify(newest.author, p);
+  const newest2 = [...messages].sort(byCreatedAt).at(-1);
+  return newest2 === void 0 ? "none" : classify(newest2.author, p);
 }
 function formatMessages(messages) {
   return messages.map((message) => {
@@ -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(
@@ -2853,9 +2908,9 @@ function selectLinkedPr(linkedPrs) {
 function formatThreads(threads) {
   return threads.map((thread) => {
     const location = thread.line === null ? `${thread.path}:(file)` : `${thread.path}:${String(thread.line)}`;
-    const newest = thread.comments.at(-1);
-    const author = newest?.author ?? "unknown";
-    const body = newest?.body ?? "";
+    const newest2 = thread.comments.at(-1);
+    const author = newest2?.author ?? "unknown";
+    const body = newest2?.body ?? "";
     const link = thread.url === null ? "" : `
 ${thread.url}`;
     return `[${author}] ${location}${link}
@@ -2921,6 +2976,101 @@ function composePrompt(input) {
   return lines.join("\n");
 }
 
+// src/github/runDirective.ts
+var VALID_TOOLS = ["claude", "codex"];
+var TOOL_PATTERN = /(?<![a-z0-9_:-])tool:([a-z0-9._-]+)/gi;
+var MODEL_PATTERN = /(?<![a-z0-9_:-])model:([a-z0-9._/+@-]+)/gi;
+function lastCapture(body, pattern) {
+  const matches = [...body.matchAll(new RegExp(pattern.source, pattern.flags))];
+  return matches.at(-1)?.[1];
+}
+function parseRunDirective(body) {
+  const tool = lastCapture(body, TOOL_PATTERN);
+  return {
+    tool: tool === void 0 ? void 0 : tool.toLowerCase(),
+    model: lastCapture(body, MODEL_PATTERN)
+  };
+}
+function newest(messages) {
+  let found = null;
+  for (const message of messages) {
+    if (found === null || message.createdAt >= found.createdAt) found = message;
+  }
+  return found;
+}
+function triggeringMessage(item) {
+  if (item.turn === "issue-discuss") return newest(item.issueAnalysis.newMessages);
+  const prLastAgentAt = item.prAnalysis?.lastAgentAt ?? null;
+  const threadComments = item.actionableThreads.flatMap(
+    (thread) => (
+      // The thread's comments are already filtered to authorized and agent
+      // accounts; the agent's own are not a trigger, and anything the agent has
+      // since answered is not either.
+      thread.comments.filter(
+        (comment) => prLastAgentAt === null || comment.createdAt > prLastAgentAt
+      )
+    )
+  );
+  return newest([
+    ...item.issueAnalysis.newMessages,
+    ...item.prAnalysis?.newMessages ?? [],
+    ...threadComments
+  ]);
+}
+function isExecutor(value) {
+  return VALID_TOOLS.includes(value);
+}
+function baselineExecutorSource(withOption, configExecutor) {
+  if (withOption !== void 0) return "option";
+  if (configExecutor !== void 0) return "config";
+  return "default";
+}
+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)) {
+    return { ok: false, invalidTool: directive.tool };
+  }
+  const baseline = withOption ?? configExecutor ?? input.defaultExecutor;
+  const baselineSource = baselineExecutorSource(withOption, configExecutor);
+  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 { ...common, model: directive.model, modelSource: "message" };
+  }
+  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}${effort}${fromMessage}`;
+}
+function describeInvalidTool(invalidTool) {
+  const valid = VALID_TOOLS.map((tool) => `\`${tool}\``).join(" and ");
+  return `the newest message asks for \`tool:${invalidTool}\`, which is not an executor automata knows (valid values are ${valid})`;
+}
+
 // src/github/markerReconciliation.ts
 function isAuthorized(author, p) {
   const login2 = author.toLowerCase();
@@ -3266,11 +3416,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}").`);
   }
@@ -3304,13 +3454,13 @@ function resolveSettings(options) {
   }
   validateDoWorkConfig(config.doWork);
   const doWork = config.doWork ?? {};
-  let executor = doWork.executor ?? DEFAULT_DO_WORK.executor;
+  let withOption;
   if (options.with !== void 0) {
     const requested = options.with.toLowerCase();
     if (requested !== "claude" && requested !== "codex") {
       fail(`--with must be 'claude' or 'codex', got '${options.with}'.`);
     }
-    executor = requested;
+    withOption = requested;
   }
   if (options.dryRun !== true) {
     checkAuthenticatedIdentity(agentUser, allowedUsers);
@@ -3318,9 +3468,16 @@ function resolveSettings(options) {
   return {
     baseBranch: doWork.baseBranch ?? DEFAULT_DO_WORK.baseBranch,
     protectedBranches: doWork.protectedBranches ?? DEFAULT_DO_WORK.protectedBranches,
-    executor,
-    // --model wins; otherwise take the default for the executor in use.
-    model: options.model ?? doWork.models?.[executor],
+    withOption,
+    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"),
@@ -3353,7 +3510,30 @@ function checkAuthenticatedIdentity(agentUser, allowedUsers) {
     `\`gh\` is authenticated as "${login2}" but agentUser is "${agentUser}". Comments posted under that identity are neither the agent's nor an authorized user's, so they are filtered out of the conversation: the answer boundary would never advance and the same message would start a run on every tick. Authenticate \`gh\` as the agent account (${agentUser}) in this environment, or correct \`agentUser\`.`
   );
 }
-function planRun(item, settings) {
+function resolveItemExecution(item, settings) {
+  const trigger = triggeringMessage(item);
+  return resolveExecution({
+    directive: trigger === null ? { tool: void 0, model: void 0 } : parseRunDirective(trigger.body),
+    withOption: settings.withOption,
+    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,
     repo: getRepoSlug(),
@@ -3361,16 +3541,20 @@ function planRun(item, settings) {
     baseBranch: settings.baseBranch,
     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 bin = resolveCommand(execution.executor === "codex" ? "codex" : "claude");
+  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) {
+function describePlannedRun(item, settings, run5, execution) {
   const rule = "\u2500".repeat(72);
   const branchAction = item.turn === "pr-work" ? " and fast-forward" : " and pull";
   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 lines = [
     rule,
     `Issue #${String(item.issue.number)} \u2014 ${item.issue.title}`,
@@ -3380,7 +3564,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     ${describeExecution(execution)}`,
     "  Permissions  bypassed (do-work always runs unattended)",
     `  Prompt       ${String(run5.prompt.length)} chars \u2014 frame + assembled context`,
     "",
@@ -3396,6 +3580,19 @@ function describePlannedRun(item, settings, run5) {
   ];
   return lines.join("\n") + "\n";
 }
+function describeRefusedRun(item, refusal) {
+  const rule = "\u2500".repeat(72);
+  return [
+    rule,
+    `Issue #${String(item.issue.number)} \u2014 ${item.issue.title}`,
+    rule,
+    `  Turn         ${item.turn}`,
+    `  Why          ${item.reason}`,
+    `  Executor     refused \u2014 ${refusal}`,
+    "  Command      none; a real tick would post the working marker and then replace it with this refusal",
+    ""
+  ].join("\n") + "\n";
+}
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -3427,6 +3624,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) {
@@ -3659,12 +3857,12 @@ function reportNoAnswer(item, marker, runError) {
   }
   return runError === null ? { outcome: "answered-no-reply", detail: "run finished but posted no answer", reason: "no-answer" } : { outcome: "failed", detail: `run failed: ${runError.message}`, reason: "no-answer" };
 }
-async function invokeExecutor(prompt, settings, silent) {
-  if (settings.executor === "codex") {
-    await runCodex(prompt, { model: settings.model });
+async function invokeExecutor(prompt, execution, silent) {
+  if (execution.executor === "codex") {
+    await runCodex(prompt, { model: execution.model, effort: execution.effort });
     return;
   }
-  await runClaude(prompt, { model: settings.model, printSteps: !silent });
+  await runClaude(prompt, { model: execution.model, effort: execution.effort, printSteps: !silent });
 }
 function repairIssueLink(item, baseBranch) {
   try {
@@ -3696,6 +3894,18 @@ function repairIssueLink(item, baseBranch) {
     return false;
   }
 }
+function refuseBeforeRun(base, marker, detail, markerText) {
+  progress(`  failed: ${detail}
+`);
+  inFlightMarker = null;
+  try {
+    updateMarker(marker, markerText);
+  } catch (err) {
+    progress(`  warning: could not update the marker comment: ${err.message}
+`);
+  }
+  return { ...base, outcome: "failed", detail };
+}
 async function processItem(planned, settings, silent) {
   progress(`
 #${String(planned.issue.number)} ${planned.turn}: ${planned.reason}
@@ -3764,24 +3974,27 @@ async function processItem(planned, settings, silent) {
   });
   const oversized = describeOversizedPrompt(prompt);
   if (oversized !== null) {
-    const detail = oversized;
-    progress(`  failed: ${detail}
-`);
-    inFlightMarker = null;
-    try {
-      updateMarker(
-        marker,
-        `automata do-work: could not start a run because ${detail} Summarise the discussion in a new issue, or shorten the thread, and try again.`
-      );
-    } catch (err) {
-      progress(`  warning: could not update the marker comment: ${err.message}
-`);
-    }
-    return { ...base, outcome: "failed", detail };
+    return refuseBeforeRun(
+      base,
+      marker,
+      oversized,
+      `automata do-work: could not start a run because ${oversized} Summarise the discussion in a new issue, or shorten the thread, and try again.`
+    );
   }
+  const resolved = resolveItemExecution(item, settings);
+  if (!resolved.ok) {
+    const detail = describeInvalidTool(resolved.invalidTool);
+    return refuseBeforeRun(
+      base,
+      marker,
+      detail,
+      `automata do-work: ${detail}. No run was started. Reply here with a corrected directive, or none at all, to have another attempt made.`
+    );
+  }
+  const execution = toExecution(resolved);
   let runError = null;
   try {
-    await invokeExecutor(prompt, settings, silent);
+    await invokeExecutor(prompt, execution, silent);
   } catch (err) {
     runError = err;
   }
@@ -3791,7 +4004,7 @@ async function processItem(planned, settings, silent) {
   progress(`  ${reconciled.detail}
 `);
   const outcome = adjustOutcome(reconciled, item, settings, buriedByNote);
-  return { ...base, outcome: outcome.outcome, detail: outcome.detail, ranExecutor };
+  return { ...base, outcome: outcome.outcome, detail: outcome.detail, ranExecutor, execution };
 }
 function describeOversizedPrompt(prompt) {
   const MAX_PROMPT_BYTES = 96 * 1024;
@@ -3827,13 +4040,33 @@ function summarize(reports) {
     return;
   }
   for (const report of reports) {
-    out(`  #${String(report.issue)} ${report.turn ?? "-"} ${report.outcome} \u2014 ${report.detail}
+    const ran = report.execution === void 0 ? "" : ` \xB7 ${describeExecution(report.execution)}`;
+    out(`  #${String(report.issue)} ${report.turn ?? "-"} ${report.outcome} \u2014 ${report.detail}${ran}
 `);
   }
 }
+function toItemJson(report) {
+  return {
+    issue: report.issue,
+    title: report.title,
+    turn: report.turn,
+    outcome: report.outcome,
+    detail: report.detail,
+    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,
+    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) => {
@@ -3976,31 +4209,69 @@ ${describePlan(decisions)}`;
   const degraded = reports.some((report) => report.outcome !== "answered");
   const exitCode = degraded ? 2 : 0;
   if (options.json) {
-    out(JSON.stringify({ dryRun: false, plan: decisions.map(toPlanJson), items: reports, exitCode }, null, 2) + "\n");
+    out(
+      JSON.stringify(
+        { dryRun: false, plan: decisions.map(toPlanJson), items: reports.map(toItemJson), exitCode },
+        null,
+        2
+      ) + "\n"
+    );
   } else {
     summarize(reports);
   }
   return exitCode;
 }
+function toRunJson(entry) {
+  if (entry.kind === "refused") {
+    return {
+      issue: entry.item.issue.number,
+      turn: entry.item.turn,
+      executor: null,
+      model: null,
+      effort: null,
+      executorSource: null,
+      modelSource: null,
+      effortSource: null,
+      refusal: entry.refusal,
+      bin: null,
+      args: null,
+      command: null,
+      prompt: null
+    };
+  }
+  return {
+    issue: entry.item.issue.number,
+    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,
+    command: entry.run.command,
+    prompt: entry.run.prompt
+  };
+}
 function reportDryRun(items, decisions, settings, options) {
   const describable = settings.maxRuns > 0 ? items.slice(0, settings.maxRuns) : items;
-  const planned = describable.map((item) => planRun(item, settings));
+  const planned = describable.map((item) => {
+    const resolved = resolveItemExecution(item, settings);
+    if (!resolved.ok) {
+      return { kind: "refused", item, refusal: describeInvalidTool(resolved.invalidTool) };
+    }
+    const execution = toExecution(resolved);
+    return { kind: "run", item, execution, run: planRun(item, settings, execution) };
+  });
   if (options.json) {
     out(
       JSON.stringify(
         {
           dryRun: true,
           plan: decisions.map(toPlanJson),
-          runs: planned.map((run5, index) => ({
-            issue: describable[index].issue.number,
-            turn: describable[index].turn,
-            executor: settings.executor,
-            model: settings.model ?? null,
-            bin: run5.bin,
-            args: run5.args,
-            command: run5.command,
-            prompt: run5.prompt
-          }))
+          runs: planned.map(toRunJson)
         },
         null,
         2
@@ -4008,8 +4279,10 @@ function reportDryRun(items, decisions, settings, options) {
     );
     return;
   }
-  for (const [index, run5] of planned.entries()) {
-    out("\n" + describePlannedRun(describable[index], settings, run5));
+  for (const entry of planned) {
+    out(
+      "\n" + (entry.kind === "refused" ? describeRefusedRun(entry.item, entry.refusal) : describePlannedRun(entry.item, settings, entry.run, entry.execution))
+    );
   }
   const deferred = items.length - describable.length;
   if (deferred > 0) {

package/package.json

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