automata-cli 0.11.0-develop.514 → 0.11.0-develop.519

package/dist/index.js

@@ -90,11 +90,11 @@ function writeDoWork(patch) {
   const current = readRawConfig();
   writeConfig({ ...current, doWork: { ...current.doWork, ...patch } });
 }
-function parseNonNegativeInt(value, label) {
+function parseNonNegativeInt(value, label2) {
   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.stderr.write(`Error: ${label2} must be a non-negative integer (got "${value}").
 `);
     process.exit(1);
   }
@@ -1705,7 +1705,7 @@ function formatSonarIssue(issue) {
   const location = formatLocation(issue.path, issue.line);
   if (location) lines.push(`      Location: ${location}`);
   if (issue.severity || issue.type) {
-    const labels = [issue.severity, issue.type].filter((label) => Boolean(label)).map(sanitizeText).join(" / ");
+    const labels = [issue.severity, issue.type].filter((label2) => Boolean(label2)).map(sanitizeText).join(" / ");
     lines.push(`      Classification: ${labels}`);
   }
   if (issue.rule) lines.push(`      Rule: ${sanitizeText(issue.rule)}`);
@@ -1718,7 +1718,7 @@ function formatSonarHotspot(hotspot) {
   if (location) lines.push(`      Location: ${location}`);
   if (hotspot.status) lines.push(`      Status: ${sanitizeText(hotspot.status)}`);
   if (hotspot.vulnerabilityProbability || hotspot.securityCategory) {
-    const labels = [hotspot.vulnerabilityProbability, hotspot.securityCategory].filter((label) => Boolean(label)).map(sanitizeText).join(" / ");
+    const labels = [hotspot.vulnerabilityProbability, hotspot.securityCategory].filter((label2) => Boolean(label2)).map(sanitizeText).join(" / ");
     lines.push(`      Classification: ${labels}`);
   }
   if (hotspot.rule) {
@@ -2368,7 +2368,7 @@ function getIssueSurface(issueNumber) {
     issue: { number: raw.number, title: raw.title, body: raw.body, url: raw.url },
     state: raw.state === "CLOSED" ? "CLOSED" : "OPEN",
     assignees: (raw.assignees ?? []).map(login).filter((name) => name.length > 0),
-    labels: (raw.labels ?? []).map((label) => label.name ?? "").filter((name) => name.length > 0),
+    labels: (raw.labels ?? []).map((label2) => label2.name ?? "").filter((name) => name.length > 0),
     messages
   };
 }
@@ -2427,7 +2427,7 @@ function toPullRequestRef(node) {
 function toOrphanPr(node) {
   return {
     pr: toPullRequestRef(node),
-    labels: (node.labels?.nodes ?? []).map((label) => label.name ?? "").filter((name) => name.length > 0),
+    labels: (node.labels?.nodes ?? []).map((label2) => label2.name ?? "").filter((name) => name.length > 0),
     assignees: (node.assignees?.nodes ?? []).map((assignee) => assignee.login ?? "").filter((login2) => login2.length > 0)
   };
 }
@@ -4489,6 +4489,9 @@ var UNKNOWN_OWNER = {
   command: "unknown",
   token: ""
 };
+function inspectConductorLock(staleMinutes, now = Date.now()) {
+  return inspectRunLock(staleMinutes, now, CONDUCTOR_LOCK_FILE);
+}
 function acquireConductorLock(staleMinutes) {
   return acquireRunLock("conductor", staleMinutes, CONDUCTOR_LOCK_FILE);
 }
@@ -4599,8 +4602,8 @@ function heldForMs(owner, now) {
   const startedAt = Date.parse(owner.startedAt);
   return Number.isNaN(startedAt) ? null : now - startedAt;
 }
-function inspectRunLock(staleMinutes, now = Date.now()) {
-  const path = lockPath();
+function inspectRunLock(staleMinutes, now = Date.now(), lockFile = LOCK_FILE) {
+  const path = lockPath(lockFile);
   try {
     statSync2(path);
   } catch (err) {
@@ -4785,9 +4788,9 @@ function detectRescueTarget(options, now) {
     return { branch: current, createdBranch: false, source: current };
   }
   const source = detached ? "detached HEAD" : current === options.baseBranch ? options.baseBranch : current;
-  const label = detached ? "detached" : flattenBranchName(source);
+  const label2 = detached ? "detached" : flattenBranchName(source);
   return {
-    branch: `${RESCUE_BRANCH_PREFIX}${label}-${utcStamp(now)}`,
+    branch: `${RESCUE_BRANCH_PREFIX}${label2}-${utcStamp(now)}`,
     createdBranch: true,
     source
   };
@@ -5203,9 +5206,9 @@ var RunTranscript = class {
   stderrAtLineStart = true;
   /** A private key began in an earlier line and has not ended yet. */
   inPrivateKey = false;
-  constructor(label, root = process.cwd(), now = /* @__PURE__ */ new Date()) {
+  constructor(label2, root = process.cwd(), now = /* @__PURE__ */ new Date()) {
     const stamp = now.toISOString().replace(/[:.]/g, "-");
-    this.fileName = `${stamp}-${label}.log`;
+    this.fileName = `${stamp}-${label2}.log`;
     const dir = join5(root, RUN_TRANSCRIPT_DIR);
     this.path = join5(dir, this.fileName);
     try {
@@ -6472,12 +6475,12 @@ function gitSection(status) {
   return build("git", lines, problems, { ...status });
 }
 function assembleReport(input) {
-  const byId = new Map(input.sections.map((section) => [section.id, section]));
+  const byId = new Map(input.sections.map((section2) => [section2.id, section2]));
   const ordered = SECTION_ORDER.flatMap((id) => {
-    const section = byId.get(id);
-    return section === void 0 ? [] : [section];
+    const section2 = byId.get(id);
+    return section2 === void 0 ? [] : [section2];
   });
-  const problems = ordered.flatMap((section) => section.problems);
+  const problems = ordered.flatMap((section2) => section2.problems);
   return {
     generatedAt: input.generatedAt,
     repo: input.repo,
@@ -6511,8 +6514,8 @@ function renderProblems(problems) {
 function renderText(report) {
   const head = `automata do-work --check \u2014 ${report.repo ?? "unknown repository"} \u2014 ${report.generatedAt.toISOString()}`;
   const parts = report.blocked === null ? [head, ""] : [`blocked: ${report.blocked.trigger}`, head, ""];
-  for (const section of report.sections) {
-    parts.push(...renderBlock(section.title, section.lines, "(nothing to report)"));
+  for (const section2 of report.sections) {
+    parts.push(...renderBlock(section2.title, section2.lines, "(nothing to report)"));
   }
   if (report.trace !== null) parts.push(...renderTrace(report.trace));
   if (report.problems.length > 0) parts.push(...renderProblems(report.problems));
@@ -6523,12 +6526,12 @@ function renderText(report) {
 }
 function toJson(report) {
   const sections = {};
-  for (const section of report.sections) {
-    sections[section.id] = {
-      title: section.title,
-      lines: section.lines,
-      problems: section.problems,
-      data: section.data
+  for (const section2 of report.sections) {
+    sections[section2.id] = {
+      title: section2.title,
+      lines: section2.lines,
+      problems: section2.problems,
+      data: section2.data
     };
   }
   return {
@@ -6587,14 +6590,14 @@ var SettingsError = class extends Error {
 function failSettings(message) {
   throw new SettingsError(message);
 }
-function parsePositiveInt(value, label) {
+function parsePositiveInt(value, label2) {
   const trimmed2 = value.trim();
   if (!/^\d+$/.test(trimmed2)) {
-    failSettings(`${label} must be a positive integer (got "${value}").`);
+    failSettings(`${label2} must be a positive integer (got "${value}").`);
   }
   const parsed = Number(trimmed2);
   if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-    failSettings(`${label} must be a positive integer within the safe range (got "${value}").`);
+    failSettings(`${label2} must be a positive integer within the safe range (got "${value}").`);
   }
   return parsed;
 }
@@ -6749,14 +6752,14 @@ function planRun(item, settings, execution) {
 }
 function describeAssignment(item, agentUser) {
   return claimStates(item).map((claim) => {
-    const label = claim.surface === "issue" ? "issue" : `pull request #${String(claim.number)}`;
+    const label2 = claim.surface === "issue" ? "issue" : `pull request #${String(claim.number)}`;
     switch (claim.state) {
       case "would-claim":
-        return `would assign ${label} to ${agentUser}`;
+        return `would assign ${label2} to ${agentUser}`;
       case "already-assigned":
-        return `${label} already assigned`;
+        return `${label2} already assigned`;
       case "rule-exempt":
-        return `${label} not claimed (orphan pass)`;
+        return `${label2} not claimed (orphan pass)`;
     }
   }).join(" \xB7 ");
 }
@@ -6832,24 +6835,24 @@ function validateOptionalInt(container, key2, path, min, hint) {
     failSettings(`${path} must be ${hint}, got ${JSON.stringify(value)}.`);
   }
 }
-function validateDoWorkConfig(section) {
-  if (section === void 0 || section === null) return;
-  if (!isPlainObject(section)) {
-    failSettings(`doWork must be an object, got ${JSON.stringify(section)}.`);
+function validateDoWorkConfig(section2) {
+  if (section2 === void 0 || section2 === null) return;
+  if (!isPlainObject(section2)) {
+    failSettings(`doWork must be an object, got ${JSON.stringify(section2)}.`);
   }
-  const executor = section["executor"];
+  const executor = section2["executor"];
   if (executor !== void 0 && executor !== "claude" && executor !== "codex") {
     failSettings(`doWork.executor must be 'claude' or 'codex', got ${JSON.stringify(executor)}.`);
   }
-  validateOptionalString(section, "baseBranch", "doWork.baseBranch");
-  validateOptionalInt(section, "maxRunsPerTick", "doWork.maxRunsPerTick", 0, "a non-negative integer (0 = unlimited)");
-  validateOptionalInt(section, "lockStaleMinutes", "doWork.lockStaleMinutes", 1, "a positive integer");
-  validateOptionalBoolean(section, "dumpOnBlock", "doWork.dumpOnBlock");
-  validateOptionalBoolean(section, "postRunLog", "doWork.postRunLog");
-  validateProtectedBranches(section["protectedBranches"]);
-  validateSettingContainer(section["models"], "models", ["claude", "codex"]);
-  validateSettingContainer(section["effort"], "effort", ["claude", "codex"]);
-  validateSettingContainer(section["prompts"], "prompts", ["issueDiscuss", "prWork", "prOrphan"]);
+  validateOptionalString(section2, "baseBranch", "doWork.baseBranch");
+  validateOptionalInt(section2, "maxRunsPerTick", "doWork.maxRunsPerTick", 0, "a non-negative integer (0 = unlimited)");
+  validateOptionalInt(section2, "lockStaleMinutes", "doWork.lockStaleMinutes", 1, "a positive integer");
+  validateOptionalBoolean(section2, "dumpOnBlock", "doWork.dumpOnBlock");
+  validateOptionalBoolean(section2, "postRunLog", "doWork.postRunLog");
+  validateProtectedBranches(section2["protectedBranches"]);
+  validateSettingContainer(section2["models"], "models", ["claude", "codex"]);
+  validateSettingContainer(section2["effort"], "effort", ["claude", "codex"]);
+  validateSettingContainer(section2["prompts"], "prompts", ["issueDiscuss", "prWork", "prOrphan"]);
 }
 function validateOptionalBoolean(container, key2, path) {
   const value = container[key2];
@@ -6912,7 +6915,7 @@ function matchesDiscoveryFilter(subject, settings) {
   const value = settings.discoveryValue.toLowerCase();
   switch (settings.technique) {
     case "label":
-      return subject.labels.some((label) => label.toLowerCase() === value);
+      return subject.labels.some((label2) => label2.toLowerCase() === value);
     case "assignee":
       return subject.assignees.some((assignee) => assignee.toLowerCase() === value);
     case "title-contains":
@@ -8497,6 +8500,12 @@ function postingInstruction(target) {
     "Post exactly one comment. Do not approve, merge or close anything."
   ].join("\n");
 }
+function dryRunInstruction(target) {
+  return [
+    `Write your reply to ${target.kind === "pr" ? "pull request" : "issue"} #${String(target.number)}. This is a dry run: you cannot post a comment, and you must not try.`,
+    "Make the reply, and nothing else, your final message. Do not approve, merge or close anything."
+  ].join("\n");
+}
 function visible(messages, participants) {
   return analyzeSurface(messages, participants).messages.map((message) => ({
     kind: message.kind,
@@ -8576,7 +8585,7 @@ function composeConductorPrompt(input) {
     "Only the messages above exist. Anything from other accounts has been withheld",
     "deliberately \u2014 do not ask about it.",
     "",
-    postingInstruction(replyTo)
+    input.dryRun === true ? dryRunInstruction(replyTo) : postingInstruction(replyTo)
   );
   return lines.join("\n");
 }
@@ -8667,6 +8676,113 @@ async function conductReply(input) {
   return runError === null ? { kind: "posted-nothing" } : { kind: "run-failed", error: runError };
 }
 
+// src/conductor/checkReport.ts
+function section(title, lines, problems = []) {
+  return { title, lines, problems };
+}
+function label(id, kind) {
+  return `${kind === "pr" ? "PR" : "issue"} #${String(id)}`;
+}
+function lockSection2(status, staleMinutes) {
+  const fix = "remove .automata/conductor.lock once you have confirmed that no conductor runs";
+  switch (status.kind) {
+    case "free":
+      return section("Run lock", ["no conductor is running in this checkout"]);
+    case "held": {
+      const held = status.heldForMs === null ? "" : ` (${describeDuration(status.heldForMs)} so far)`;
+      return section("Run lock", [
+        `a conductor is running: pid ${String(status.owner.pid)} on ${status.owner.host}, started ${status.owner.startedAt}${held}`,
+        "a tick started now would do nothing"
+      ]);
+    }
+    case "suspect":
+      return section(
+        "Run lock",
+        [`held longer than ${String(staleMinutes)} minutes by pid ${String(status.owner.pid)} on ${status.owner.host}`],
+        [{ section: "lock", summary: `the lock looks alive but outlived the stale window, probably a reused pid: ${fix}` }]
+      );
+    case "stale":
+      return section("Run lock", ["a stale lock is present; the next tick takes it over"]);
+    case "unreadable":
+      return section(
+        "Run lock",
+        [`the lock cannot be read: ${status.detail}`],
+        [{ section: "lock", summary: `the lock file cannot be read (${status.detail}); fix its permissions` }]
+      );
+  }
+}
+function decisionLine(decision) {
+  const where = label(decision.surface.number, decision.surface.kind);
+  return decision.kind === "reply" ? `reply on ${where}: ${decision.reason}` : `skip ${where} (${decision.reason}): ${decision.detail}`;
+}
+function watchSections(watched) {
+  const listLines = [];
+  const replyLines = [];
+  const problems = [];
+  for (const entry of watched) {
+    if ("unavailable" in entry) {
+      listLines.push(`#${String(entry.id)}: unavailable (${entry.unavailable}); a tick keeps it and skips it`);
+      problems.push({ section: "watch", summary: `#${String(entry.id)} could not be read: ${entry.unavailable}` });
+      continue;
+    }
+    const name = label(entry.id, entry.kind);
+    if (entry.state === "closed") {
+      listLines.push(`${name}: closed, a tick would drop it from the watch list`);
+      continue;
+    }
+    listLines.push(`${name}: open`);
+    for (const decision of entry.decisions) replyLines.push(decisionLine(decision));
+  }
+  return [
+    section(`Watch list (${String(watched.length)})`, listLines, problems),
+    section("Replies a tick would write", replyLines)
+  ];
+}
+function buildConductorCheck(input) {
+  const sections = input.configProblem === null ? [
+    section("Configuration", [`running as ${input.identity}`, `executor: ${input.execution}`]),
+    lockSection2(input.lock, input.staleMinutes),
+    ...watchSections(input.watched)
+  ] : [
+    section(
+      "Configuration",
+      [input.configProblem],
+      [{ section: "configuration", summary: input.configProblem }]
+    )
+  ];
+  const problems = sections.flatMap((s) => s.problems);
+  const parts = [
+    `automata conductor --check \u2014 ${input.repo ?? "unknown repository"} \u2014 ${input.generatedAt.toISOString()}`,
+    ""
+  ];
+  for (const s of sections) {
+    parts.push(s.title, ...(s.lines.length === 0 ? ["(nothing to report)"] : s.lines).map((l) => `  ${l}`), "");
+  }
+  if (problems.length > 0) {
+    parts.push(`Problems (${String(problems.length)})`, ...problems.map((p) => `  \xB7 ${p.section}: ${p.summary}`), "");
+  }
+  parts.push(problems.length === 0 ? "RESULT: healthy" : `RESULT: ${String(problems.length)} problem(s) found`);
+  return { text: parts.join("\n") + "\n", exitCode: problems.length === 0 ? 0 : 1, problems };
+}
+
+// src/conductor/dryRunReply.ts
+function claudeResult(raw) {
+  let result = null;
+  for (const line of raw.split("\n")) {
+    if (!line.trim().startsWith("{")) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event["type"] === "result" && typeof event["result"] === "string") result = event["result"];
+    } catch {
+    }
+  }
+  return result;
+}
+function extractDryRunReply(executor, stdout) {
+  const text = (executor === "claude" ? claudeResult(stdout) : stdout)?.trim();
+  return text === void 0 || text.length === 0 ? null : text;
+}
+
 // src/conductor/watchList.ts
 function parseWatchId(raw) {
   const text = raw.trim().replace(/^#/, "");
@@ -8726,17 +8842,21 @@ function pruneWatchList(config) {
   if (dropped.length > 0) updateWatch((current) => current.filter((id) => !dropped.includes(id)));
   return watch.filter((id) => !dropped.includes(id));
 }
+function onceLinkMap() {
+  let map = null;
+  return () => map ??= getOpenPrLinkMap();
+}
 function readPr(number) {
   return { surface: getPrSurface(number), checks: getPrChecks(number) };
 }
-function readWatchedItem(id) {
+function readWatchedItem(id, linkMap = getOpenPrLinkMap) {
   const target = getWatchTarget(id);
   if (target.kind === "pr") {
     const pr = readPr(id);
     return { thread: { kind: "pr", prs: [pr] }, conversations: [prConversation(pr.surface)] };
   }
   const issue = getIssueSurface(id);
-  const prs = (getOpenPrLinkMap().byIssue.get(id) ?? []).map((ref) => readPr(ref.number));
+  const prs = (linkMap().byIssue.get(id) ?? []).map((ref) => readPr(ref.number));
   return {
     thread: { kind: "issue", issue, prs },
     conversations: [issueConversation(issue), ...prs.map((pr) => prConversation(pr.surface))]
@@ -8749,30 +8869,62 @@ function runModel(prompt, execution, replyTo) {
   const { owner, repo } = getRepoSlug();
   return runClaude(prompt, { model: execution.model, effort: execution.effort, readOnly: true, replyTo, ghRepo: `${owner}/${repo}` });
 }
-async function conductItem(id, config, login2, participants, execution) {
-  const label = `#${String(id)}`;
+async function runModelForText(prompt, execution) {
+  const { owner, repo } = getRepoSlug();
+  let stdout = "";
+  const sink2 = {
+    output: (stream, text) => {
+      if (stream === "stdout") stdout += text;
+    },
+    exited: () => void 0
+  };
+  const options = { model: execution.model, effort: execution.effort, readOnly: true, ghRepo: `${owner}/${repo}`, sink: sink2 };
+  await runClaude(prompt, options);
+  return extractDryRunReply(execution.executor, stdout);
+}
+function targetKey(target) {
+  return `${target.kind}#${String(target.number)}`;
+}
+async function conductItem(id, config, login2, participants, execution, dryRun) {
+  const label2 = `#${String(id)}`;
   let item;
   try {
-    item = readWatchedItem(id);
+    item = readWatchedItem(id, dryRun?.linkMap);
   } catch (err) {
-    process.stderr.write(`Warning: could not read ${label}, skipping it this tick: ${err.message}
+    process.stderr.write(`Warning: could not read ${label2}, skipping it this tick: ${err.message}
 `);
     return "idle";
   }
   const { thread, conversations } = item;
   const verdict = decideConductorReply(conversations, participants);
-  const owed = verdict.decisions.find((decision) => decision.kind === "reply");
+  const owed = verdict.decisions.find(
+    (decision) => decision.kind === "reply" && dryRun?.answered.has(targetKey(decision.surface)) !== true
+  );
   if (owed === void 0) {
-    process.stdout.write(`Conductor: ${label} needs no reply.
+    process.stdout.write(`Conductor: ${label2} needs no reply.
 `);
     return "idle";
   }
   const replyTo = { kind: owed.surface.kind, number: owed.surface.number };
   const frame = thread.kind === "issue" ? config.conductor?.prompts?.issue ?? DEFAULT_CONDUCTOR_ISSUE_PROMPT : config.conductor?.prompts?.pr ?? DEFAULT_CONDUCTOR_PR_PROMPT;
-  const prompt = composeConductorPrompt({ thread, repo: getRepoSlug(), participants, frame, replyTo });
+  const prompt = composeConductorPrompt({ thread, repo: getRepoSlug(), participants, frame, replyTo, dryRun: dryRun !== void 0 });
   const where = `${replyTo.kind === "pr" ? "pull request" : "issue"} #${String(replyTo.number)}`;
-  process.stdout.write(`Conductor: ${label} needs a reply on ${where}; running ${describeConductorExecution(execution)}.
+  process.stdout.write(`Conductor: ${label2} needs a reply on ${where}; running ${describeConductorExecution(execution)}.
 `);
+  if (dryRun) {
+    const reply = await runModelForText(prompt, execution);
+    if (reply === null) {
+      process.stderr.write(`Error: the dry run for ${label2} produced no reply text.
+`);
+      return "failed";
+    }
+    dryRun.answered.add(targetKey(replyTo));
+    process.stdout.write(`--- Dry run: reply for ${where} (not posted) ---
+${reply}
+---
+`);
+    return "replied";
+  }
   const outcome = await conductReply({
     login: login2,
     read: () => readTargetMessages(replyTo),
@@ -8788,15 +8940,15 @@ async function conductItem(id, config, login2, participants, execution) {
       }
       return "replied";
     case "posted-nothing":
-      process.stderr.write(`Error: the run for ${label} finished but posted no comment on ${where}.
+      process.stderr.write(`Error: the run for ${label2} finished but posted no comment on ${where}.
 `);
       return "failed";
     case "run-failed":
-      process.stderr.write(`Error: the run for ${label} failed and posted no comment on ${where}: ${outcome.error}
+      process.stderr.write(`Error: the run for ${label2} failed and posted no comment on ${where}: ${outcome.error}
 `);
       return "failed";
     case "unverified":
-      process.stderr.write(`Error: could not tell whether ${label} got a reply: ${outcome.error}
+      process.stderr.write(`Error: could not tell whether ${label2} got a reply: ${outcome.error}
 `);
       return "failed";
   }
@@ -8920,9 +9072,89 @@ function preflight() {
     execution: resolveConductorExecution(config.conductor)
   };
 }
-async function runConductor() {
+function staleMinutesOf(config) {
+  return config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes;
+}
+function checkWatched(id, participants, linkMap) {
+  try {
+    const target = getWatchTarget(id);
+    if (isWatchClosed(target.state)) return { id, kind: target.kind, state: "closed", decisions: [] };
+    const { conversations } = readWatchedItem(id, linkMap);
+    return { id, kind: target.kind, state: "open", decisions: decideConductorReply(conversations, participants).decisions };
+  } catch (err) {
+    return { id, unavailable: err.message };
+  }
+}
+function runConductorCheck() {
+  const checked = preflight();
+  const generatedAt = /* @__PURE__ */ new Date();
+  let repo = null;
+  try {
+    const slug = getRepoSlug();
+    repo = `${slug.owner}/${slug.repo}`;
+  } catch {
+  }
+  const linkMap = onceLinkMap();
+  const report = "problem" in checked ? buildConductorCheck({
+    generatedAt,
+    repo,
+    configProblem: checked.problem,
+    identity: "",
+    execution: "",
+    lock: { kind: "free" },
+    staleMinutes: DEFAULT_DO_WORK.lockStaleMinutes,
+    watched: []
+  }) : buildConductorCheck({
+    generatedAt,
+    repo,
+    configProblem: null,
+    identity: checked.login,
+    execution: describeConductorExecution(checked.execution),
+    lock: inspectConductorLock(staleMinutesOf(checked.config)),
+    staleMinutes: staleMinutesOf(checked.config),
+    watched: normalizeWatch(checked.config.conductor?.watch).map((id) => checkWatched(id, checked.participants, linkMap))
+  });
+  process.stdout.write(report.text);
+  return report.exitCode;
+}
+async function runConductorDryRun(checked) {
+  const { config, login: login2, participants, execution } = checked;
+  const lock = inspectConductorLock(staleMinutesOf(config));
+  if (lock.kind === "held" || lock.kind === "suspect") {
+    process.stderr.write(`Warning: a conductor is running here (pid ${String(lock.owner.pid)}); the dry run does not take the lock.
+`);
+  }
+  process.stdout.write(`Conductor: dry run as ${login2}; nothing is posted and the watch list is not changed.
+`);
+  let failed = 0;
+  const context = { linkMap: onceLinkMap(), answered: /* @__PURE__ */ new Set() };
+  for (const id of normalizeWatch(config.conductor?.watch)) {
+    try {
+      if (isWatchClosed(getWatchTarget(id).state)) {
+        process.stdout.write(`Conductor: #${String(id)} is closed; a tick would drop it from the watch list.
+`);
+        continue;
+      }
+    } catch {
+    }
+    try {
+      if (await conductItem(id, config, login2, participants, execution, context) === "failed") failed++;
+    } catch (err) {
+      process.stderr.write(`Error: #${String(id)} could not be conducted: ${err.message}
+`);
+      failed++;
+    }
+  }
+  return failed > 0 ? 1 : 0;
+}
+async function runConductor(options = {}) {
+  if (options.check === true && options.dryRun === true) {
+    return fail2("--check and --dry-run cannot be used together.");
+  }
+  if (options.check === true) return runConductorCheck();
   const checked = preflight();
   if ("problem" in checked) return fail2(checked.problem);
+  if (options.dryRun === true) return runConductorDryRun(checked);
   const { config, login: login2, participants, execution } = checked;
   const staleMinutes = config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes;
   const lock = acquireConductorLock(staleMinutes);
@@ -8962,8 +9194,8 @@ async function runConductor() {
 }
 var conductorCommand = new Command7("conductor").description(
   "Run one conductor tick as an allowed (human) account: verify the identity, take the conductor's own run lock, then act"
-).action(async () => {
-  exitWith(await runConductor());
+).option("--check", "Report what a tick would do, including pending prunes, and change nothing; exit 1 on a problem").option("--dry-run", "Run the model for each owed reply and print it instead of posting; no lock, no prune").action(async (options) => {
+  exitWith(await runConductor(options));
 });
 conductorCommand.command("add <id>").description("Watch an issue or pull request and make do-work pick it up (an issue also follows its linked PR)").action((id) => {
   exitWith(runWatchAdd(id));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.11.0-develop.514",
+  "version": "0.11.0-develop.519",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {