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

package/dist/index.js

@@ -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;
@@ -8422,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";
@@ -8482,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) {
@@ -8497,13 +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."
+    "Make the reply, and nothing else, your final message. Do not approve, merge or close anything.",
+    needsHumanInstruction()
   ].join("\n");
 }
 function visible(messages, participants) {
@@ -8730,6 +8813,10 @@ function watchSections(watched) {
       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));
   }
@@ -8853,24 +8940,25 @@ 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 = (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}` });
+  return runClaude(prompt, { model: execution.model, effort: execution.effort, readOnly: true, replyTo, ghRepo: `${owner}/${repo}`, sink: sink2 });
 }
-async function runModelForText(prompt, execution) {
-  const { owner, repo } = getRepoSlug();
+function captureStdout() {
   let stdout = "";
   const sink2 = {
     output: (stream, text) => {
@@ -8878,30 +8966,76 @@ async function runModelForText(prompt, execution) {
     },
     exited: () => void 0
   };
-  const options = { model: execution.model, effort: execution.effort, readOnly: true, ghRepo: `${owner}/${repo}`, sink: sink2 };
+  return { sink: sink2, text: () => stdout };
+}
+async function runModelForText(prompt, execution) {
+  const { owner, repo } = getRepoSlug();
+  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, stdout);
+  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)}`;
 }
-async function conductItem(id, config, login2, participants, execution, dryRun) {
+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, dryRun, linkMap) {
   const label2 = `#${String(id)}`;
   let item;
   try {
-    item = readWatchedItem(id, dryRun?.linkMap);
+    item = readWatchedItem(id, dryRun?.linkMap ?? linkMap);
   } catch (err) {
     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 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: ${label2} 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";
   }
@@ -8911,25 +9045,17 @@ async function conductItem(id, config, login2, participants, execution, dryRun)
   const where = `${replyTo.kind === "pr" ? "pull request" : "issue"} #${String(replyTo.number)}`;
   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";
-  }
+  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}.
@@ -9062,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." };
   }
@@ -9075,12 +9203,14 @@ function preflight() {
 function staleMinutesOf(config) {
   return config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes;
 }
-function checkWatched(id, participants, linkMap) {
+function checkWatched(id, participants, maxReplies, linkMap, coveredBy) {
   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 };
+    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 };
   }
@@ -9095,6 +9225,8 @@ function runConductorCheck() {
   } 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,
@@ -9112,7 +9244,7 @@ function runConductorCheck() {
     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))
+    watched: watchIds.map((id) => checkWatched(id, checked.participants, resolveMaxReplies(checked.config.conductor), linkMap, covered.get(id)))
   });
   process.stdout.write(report.text);
   return report.exitCode;
@@ -9128,7 +9260,9 @@ async function runConductorDryRun(checked) {
 `);
   let failed = 0;
   const context = { linkMap: onceLinkMap(), answered: /* @__PURE__ */ new Set() };
-  for (const id of normalizeWatch(config.conductor?.watch)) {
+  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.
@@ -9137,6 +9271,12 @@ async function runConductorDryRun(checked) {
       }
     } 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) {
@@ -9147,6 +9287,18 @@ async function runConductorDryRun(checked) {
   }
   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 (!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;
+}
 async function runConductor(options = {}) {
   if (options.check === true && options.dryRun === true) {
     return fail2("--check and --dry-run cannot be used together.");
@@ -9158,29 +9310,23 @@ async function runConductor(options = {}) {
   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.
-`
-    );
-    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.
-`
-      );
-      return 2;
-    }
-    return 0;
-  }
+  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}
 `);

package/package.json

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