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

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);
@@ -1559,12 +1559,12 @@ function handleExitCode(status, toolName) {
 }
 function resolveEffortOption(value) {
   if (value === void 0) return void 0;
-  const trimmed = value.trim();
-  if (trimmed.length === 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 trimmed;
+  return trimmed2;
 }
 
 // src/cli/childRegistry.ts
@@ -2132,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) => {
@@ -2908,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}
@@ -2976,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();
@@ -3321,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}").`);
   }
@@ -3359,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);
@@ -3373,16 +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],
-    // 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]),
+    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"),
@@ -3415,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(),
@@ -3423,22 +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, effort: settings.effort }) : buildClaudeArgs(prompt, {
+  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: settings.model,
-    effort: settings.effort
+    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 effortNote = settings.effort === void 0 ? "" : ` \xB7 effort ${settings.effort}`;
   const lines = [
     rule,
     `Issue #${String(item.issue.number)} \u2014 ${item.issue.title}`,
@@ -3448,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}${effortNote}`,
+    `  Executor     ${describeExecution(execution)}`,
     "  Permissions  bypassed (do-work always runs unattended)",
     `  Prompt       ${String(run5.prompt.length)} chars \u2014 frame + assembled context`,
     "",
@@ -3464,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);
 }
@@ -3728,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, effort: settings.effort });
+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, effort: settings.effort, printSteps: !silent });
+  await runClaude(prompt, { model: execution.model, effort: execution.effort, printSteps: !silent });
 }
 function repairIssueLink(item, baseBranch) {
   try {
@@ -3765,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}
@@ -3833,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;
   }
@@ -3860,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;
@@ -3896,10 +4040,27 @@ 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(
@@ -4048,32 +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,
-            effort: settings.effort ?? null,
-            bin: run5.bin,
-            args: run5.args,
-            command: run5.command,
-            prompt: run5.prompt
-          }))
+          runs: planned.map(toRunJson)
         },
         null,
         2
@@ -4081,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.257",
+  "version": "0.6.0-develop.273",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {