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

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)
   };
 }
@@ -2625,9 +2625,25 @@ function getWatchTarget(id) {
     number: raw.number,
     kind: raw.pull_request === void 0 ? "issue" : "pr",
     state: raw.state === "closed" ? "closed" : "open",
-    title: raw.title
+    title: raw.title,
+    labels: (raw.labels ?? []).map((label2) => typeof label2 === "string" ? label2 : label2.name ?? "").filter((name) => name.length > 0)
   };
 }
+function addLabel(target, name, description) {
+  const edit = target.kind === "pr" ? "pr" : "issue";
+  const args = [edit, "edit", String(target.number), "--add-label", name];
+  let result = run4("gh", args);
+  if (result.status !== 0 && isMissingLabelError(result.stderr)) {
+    const created = run4("gh", ["label", "create", name, "--description", description]);
+    if (created.status !== 0 && !/already exists/i.test(created.stderr)) {
+      throw new Error(created.stderr.trim() || `Failed to create the label ${name}.`);
+    }
+    result = run4("gh", args);
+  }
+  if (result.status !== 0) {
+    throw new Error(result.stderr.trim() || `Failed to add the label ${name} to #${String(target.number)}.`);
+  }
+}
 function applyDiscovery(target, technique, value) {
   const edit = target.kind === "pr" ? "pr" : "issue";
   let flag;
@@ -4489,6 +4505,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 +4618,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 +4804,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 +5222,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 +6491,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 +6530,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 +6542,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 +6606,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 +6768,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 +6851,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 +6931,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":
@@ -8419,6 +8438,44 @@ function toPlanJson(decision) {
 // src/commands/conductor.ts
 import { Command as Command7 } from "commander";
 
+// src/conductor/loopSafety.ts
+var BLOCKED_LABEL = "conductor-blocked";
+var REPLY_MARKER = "<!-- automata:conductor -->";
+var NEEDS_HUMAN_PREFIX = "NEEDS-HUMAN:";
+var DEFAULT_MAX_REPLIES_PER_ITEM = 5;
+function maxRepliesProblem(conductor) {
+  const value = conductor?.maxRepliesPerItem;
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
+    return `conductor.maxRepliesPerItem must be a positive integer, got ${JSON.stringify(value)}.`;
+  }
+  return null;
+}
+function resolveMaxReplies(conductor) {
+  return conductor?.maxRepliesPerItem ?? DEFAULT_MAX_REPLIES_PER_ITEM;
+}
+function countConductorReplies(messages) {
+  return messages.filter(
+    (message) => (message.kind === "issue-comment" || message.kind === "pr-comment") && message.body.includes(REPLY_MARKER)
+  ).length;
+}
+function parseNeedsHuman(output) {
+  const lines = output.trim().split("\n");
+  const last = lines.at(-1)?.trim() ?? "";
+  if (!last.startsWith(NEEDS_HUMAN_PREFIX)) return null;
+  const reason = last.slice(NEEDS_HUMAN_PREFIX.length).trim();
+  return reason.length > 0 ? reason : "no reason given";
+}
+function coveredByWatchedIssue(watch, linkedPrs) {
+  const covered = /* @__PURE__ */ new Map();
+  for (const id of watch) {
+    for (const pr of linkedPrs(id)) {
+      if (pr !== id && watch.includes(pr) && !covered.has(pr)) covered.set(pr, id);
+    }
+  }
+  return covered;
+}
+
 // src/conductor/replyDecision.ts
 function isWatchClosed(state) {
   return state === "closed";
@@ -8479,10 +8536,33 @@ function decideConversation(conversation, p) {
     reason: `${p.agentUser}'s message at ${newest2.createdAt} has no answer from an allowed user`
   };
 }
-function decideConductorReply(conversations, p) {
-  const decisions = conversations.map((conversation) => decideConversation(conversation, p));
+function decideConductorReply(conversations, p, loop) {
+  const decided = conversations.map((conversation) => decideConversation(conversation, p));
+  const stop = loop === void 0 ? null : loopStop(loop);
+  const decisions = decided.map(
+    (decision) => decision.kind === "reply" && stop !== null ? { kind: "skip", surface: decision.surface, reason: stop.reason, detail: stop.detail } : decision
+  );
   return { needsReply: decisions.some((decision) => decision.kind === "reply"), decisions };
 }
+function loopStop(loop) {
+  if (loop.blocked) {
+    return { reason: "blocked", detail: `the item has the ${BLOCKED_LABEL} label; remove it to resume` };
+  }
+  if (loop.replies >= loop.maxReplies) {
+    return {
+      reason: "limit",
+      detail: `the conductor already replied ${String(loop.replies)} times; the limit is conductor.maxRepliesPerItem (${String(loop.maxReplies)})`
+    };
+  }
+  return null;
+}
+function loopStateOf(conversations, labels, maxReplies) {
+  return {
+    blocked: labels.some((label2) => label2.toLowerCase() === BLOCKED_LABEL),
+    replies: countConductorReplies(conversations.flatMap((conversation) => conversation.messages)),
+    maxReplies
+  };
+}
 
 // src/conductor/thread.ts
 function defaultReplyTarget(thread) {
@@ -8494,7 +8574,19 @@ function postingInstruction(target) {
   return [
     `Post your reply as a comment on ${target.kind === "pr" ? "pull request" : "issue"} #${number}. What you print is discarded; only a posted comment counts.`,
     `Run \`gh ${command} comment ${number} --body-file -\` and give the body on standard input, for example with a here-document.`,
-    "Post exactly one comment. Do not approve, merge or close anything."
+    `End the comment body with the line \`${REPLY_MARKER}\` on its own; automata counts the replies with it.`,
+    "Post exactly one comment. Do not approve, merge or close anything.",
+    needsHumanInstruction()
+  ].join("\n");
+}
+function needsHumanInstruction() {
+  return `If you cannot go on without a person, post no comment. Make the last line of your final message \`${NEEDS_HUMAN_PREFIX} <one-line reason>\`; automata then labels the item and stays silent.`;
+}
+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.",
+    needsHumanInstruction()
   ].join("\n");
 }
 function visible(messages, participants) {
@@ -8576,7 +8668,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 +8759,117 @@ 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;
+    }
+    if (entry.coveredBy !== void 0) {
+      listLines.push(`${name}: open, covered by watched issue #${String(entry.coveredBy)}; a tick gives it no separate reply`);
+      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,58 +8929,133 @@ 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)] };
+    return { target, thread: { kind: "pr", prs: [pr] }, conversations: [prConversation(pr.surface)], labels: target.labels };
   }
   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 {
+    target,
     thread: { kind: "issue", issue, prs },
-    conversations: [issueConversation(issue), ...prs.map((pr) => prConversation(pr.surface))]
+    conversations: [issueConversation(issue), ...prs.map((pr) => prConversation(pr.surface))],
+    labels: target.labels
   };
 }
 function readTargetMessages(target) {
   return target.kind === "issue" ? issueConversation(getIssueSurface(target.number)).messages : prConversation(getPrSurface(target.number)).messages;
 }
-function runModel(prompt, execution, replyTo) {
+function runModel(prompt, execution, replyTo, sink2) {
+  const { owner, repo } = getRepoSlug();
+  return runClaude(prompt, { model: execution.model, effort: execution.effort, readOnly: true, replyTo, ghRepo: `${owner}/${repo}`, sink: sink2 });
+}
+function captureStdout() {
+  let stdout = "";
+  const sink2 = {
+    output: (stream, text) => {
+      if (stream === "stdout") stdout += text;
+    },
+    exited: () => void 0
+  };
+  return { sink: sink2, text: () => stdout };
+}
+async function runModelForText(prompt, execution) {
   const { owner, repo } = getRepoSlug();
-  return runClaude(prompt, { model: execution.model, effort: execution.effort, readOnly: true, replyTo, ghRepo: `${owner}/${repo}` });
+  const captured = captureStdout();
+  const options = { model: execution.model, effort: execution.effort, readOnly: true, ghRepo: `${owner}/${repo}`, sink: captured.sink };
+  await runClaude(prompt, options);
+  return extractDryRunReply(execution.executor, captured.text());
+}
+function coveredOf(watch, linkMap) {
+  return coveredByWatchedIssue(watch, (id) => (linkMap().byIssue.get(id) ?? []).map((ref) => ref.number));
+}
+function coveredNote(id, issue) {
+  return `Conductor: #${String(id)} is covered by watched issue #${String(issue)} and gets no separate reply.`;
+}
+function targetKey(target) {
+  return `${target.kind}#${String(target.number)}`;
+}
+function blockItem(item, label2, reason) {
+  try {
+    addLabel(item.target, BLOCKED_LABEL, "The conductor stopped and needs a person; remove this label to resume");
+  } catch (err) {
+    process.stderr.write(`Error: ${label2} needs a human (${reason}) but the ${BLOCKED_LABEL} label was not applied: ${err.message}
+`);
+    return "failed";
+  }
+  process.stdout.write(`Conductor: ${label2} needs a human (${reason}); applied the ${BLOCKED_LABEL} label.
+`);
+  return "idle";
+}
+async function conductDryRunItem(prompt, execution, label2, where, replyTo, 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";
+  }
+  const needsHuman = parseNeedsHuman(reply);
+  if (needsHuman !== null) {
+    process.stdout.write(`--- Dry run: ${label2} needs a human (not labelled): ${needsHuman} ---
+`);
+    return "idle";
+  }
+  dryRun.answered.add(targetKey(replyTo));
+  process.stdout.write(`--- Dry run: reply for ${where} (not posted) ---
+${reply}
+---
+`);
+  return "replied";
 }
-async function conductItem(id, config, login2, participants, execution) {
-  const label = `#${String(id)}`;
+async function conductItem(id, config, login2, participants, execution, dryRun, linkMap) {
+  const label2 = `#${String(id)}`;
   let item;
   try {
-    item = readWatchedItem(id);
+    item = readWatchedItem(id, dryRun?.linkMap ?? 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 loop = loopStateOf(conversations, item.labels, resolveMaxReplies(config.conductor));
+  const verdict = decideConductorReply(conversations, participants, loop);
+  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.
+    const stopped = verdict.decisions.find((decision) => decision.kind === "skip" && (decision.reason === "blocked" || decision.reason === "limit"));
+    const why = stopped?.kind === "skip" ? `Conductor: ${label2} gets no reply: ${stopped.detail}.` : `Conductor: ${label2} needs no reply.`;
+    process.stdout.write(`${why}
 `);
     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) return conductDryRunItem(prompt, execution, label2, where, replyTo, dryRun);
+  const captured = captureStdout();
   const outcome = await conductReply({
     login: login2,
     read: () => readTargetMessages(replyTo),
-    run: () => runModel(prompt, execution, replyTo)
+    run: () => runModel(prompt, execution, replyTo, captured.sink)
   });
+  const needsHuman = parseNeedsHuman(extractDryRunReply(execution.executor, captured.text()) ?? "");
+  if (needsHuman !== null && outcome.kind !== "run-failed" && outcome.kind !== "unverified") {
+    return blockItem(item, label2, needsHuman);
+  }
   switch (outcome.kind) {
     case "posted":
       process.stdout.write(`Conductor: posted a reply on ${where}.
@@ -8788,15 +9066,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";
   }
@@ -8910,6 +9188,8 @@ function preflight() {
   }
   const executionProblem = conductorExecutionProblem(config.conductor);
   if (executionProblem !== null) return { problem: executionProblem };
+  const maxReplies = maxRepliesProblem(config.conductor);
+  if (maxReplies !== null) return { problem: maxReplies };
   if (config.conductor?.executor === "codex") {
     return { problem: "conductor.executor codex is not supported: Codex cannot be limited to comments on the reply target. Use claude." };
   }
@@ -8920,35 +9200,133 @@ function preflight() {
     execution: resolveConductorExecution(config.conductor)
   };
 }
-async function runConductor() {
+function staleMinutesOf(config) {
+  return config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes;
+}
+function checkWatched(id, participants, maxReplies, linkMap, coveredBy) {
+  try {
+    const target = getWatchTarget(id);
+    if (isWatchClosed(target.state)) return { id, kind: target.kind, state: "closed", decisions: [] };
+    if (coveredBy !== void 0) return { id, kind: target.kind, state: "open", decisions: [], coveredBy };
+    const { conversations, labels } = readWatchedItem(id, linkMap);
+    const loop = loopStateOf(conversations, labels, maxReplies);
+    return { id, kind: target.kind, state: "open", decisions: decideConductorReply(conversations, participants, loop).decisions };
+  } catch (err) {
+    return { id, unavailable: err.message };
+  }
+}
+function runConductorCheck() {
   const checked = preflight();
-  if ("problem" in checked) return fail2(checked.problem);
+  const generatedAt = /* @__PURE__ */ new Date();
+  let repo = null;
+  try {
+    const slug = getRepoSlug();
+    repo = `${slug.owner}/${slug.repo}`;
+  } catch {
+  }
+  const linkMap = onceLinkMap();
+  const watchIds = "problem" in checked ? [] : normalizeWatch(checked.config.conductor?.watch);
+  const covered = "problem" in checked ? /* @__PURE__ */ new Map() : coveredOf(watchIds, linkMap);
+  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: watchIds.map((id) => checkWatched(id, checked.participants, resolveMaxReplies(checked.config.conductor), linkMap, covered.get(id)))
+  });
+  process.stdout.write(report.text);
+  return report.exitCode;
+}
+async function runConductorDryRun(checked) {
   const { config, login: login2, participants, execution } = checked;
-  const staleMinutes = config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes;
-  const lock = acquireConductorLock(staleMinutes);
-  if (!lock.ok) {
-    const held = lock.heldBy;
-    process.stdout.write(
-      `Another conductor is already running here (pid ${String(held.pid)} on ${held.host}, started ${held.startedAt}). Doing nothing.
+  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() };
+  const watchIds = normalizeWatch(config.conductor?.watch);
+  const covered = coveredOf(watchIds, context.linkMap);
+  for (const id of watchIds) {
+    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 {
+    }
+    const coveredBy = covered.get(id);
+    if (coveredBy !== void 0) {
+      process.stdout.write(`${coveredNote(id, coveredBy)}
+`);
+      continue;
+    }
+    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;
+}
+function reportHeldLock(held, suspect, staleMinutes) {
+  process.stdout.write(
+    `Another conductor is already running here (pid ${String(held.pid)} on ${held.host}, started ${held.startedAt}). Doing nothing.
 `
-    );
-    if (lock.suspect) {
-      process.stderr.write(
-        `Warning: that lock has been held longer than ${String(staleMinutes)} minutes. If no tick is really running, its process id was probably reused; remove ${CONDUCTOR_LOCK_RELATIVE_PATH} once you have confirmed that.
+  );
+  if (!suspect) return 0;
+  process.stderr.write(
+    `Warning: that lock has been held longer than ${String(staleMinutes)} minutes. If no tick is really running, its process id was probably reused; remove ${CONDUCTOR_LOCK_RELATIVE_PATH} once you have confirmed that.
 `
-      );
-      return 2;
-    }
-    return 0;
+  );
+  return 2;
+}
+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);
+  if (!lock.ok) return reportHeldLock(lock.heldBy, lock.suspect, staleMinutes);
   try {
     process.stdout.write(`Conductor: running as ${login2}.
 `);
     const watch = pruneWatchList(config);
     let failed = 0;
+    const linkMap = onceLinkMap();
+    const covered = coveredOf(watch, linkMap);
     for (const id of watch) {
+      const coveredBy = covered.get(id);
+      if (coveredBy !== void 0) {
+        process.stdout.write(`${coveredNote(id, coveredBy)}
+`);
+        continue;
+      }
       try {
-        if (await conductItem(id, config, login2, participants, execution) === "failed") failed++;
+        if (await conductItem(id, config, login2, participants, execution, void 0, linkMap) === "failed") failed++;
       } catch (err) {
         process.stderr.write(`Error: #${String(id)} could not be conducted: ${err.message}
 `);
@@ -8962,8 +9340,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.526",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {