automata-cli 0.12.0-develop.554 → 0.12.0-develop.567

package/dist/index.js

@@ -5435,6 +5435,44 @@ async function scrubExcerpt(execution, excerpt, timeoutMs = SECOND_OPINION_TIMEO
   return result.ok ? interpretScrubOutput(result.stdout, excerpt) : result;
 }
 
+// src/run/claudeAuth.ts
+var CLAUDE_AUTH_PATTERNS = [
+  /Failed to authenticate/i,
+  /OAuth (?:session|token) (?:has )?expired/i,
+  /Invalid API key\s*[·\-:]\s*Please run \/login/i,
+  /Please run \/login/i
+];
+var CLAUDE_AUTH_MARKER = "<!-- automata:claude-auth -->";
+function detectClaudeAuthFailure(text) {
+  return CLAUDE_AUTH_PATTERNS.some((pattern) => pattern.test(text));
+}
+var CLAUDE_AUTH_TAIL_MAX = 8192;
+var ClaudeAuthTail = class {
+  text = "";
+  output(_stream, chunk) {
+    this.text = (this.text + chunk).slice(-CLAUDE_AUTH_TAIL_MAX);
+  }
+  exited() {
+  }
+  get tail() {
+    return this.text;
+  }
+};
+var CLAUDE_AUTH_REASON = "Claude Code is not signed in (its login expired and could not be refreshed)";
+var CLAUDE_AUTH_REMEDY = "Run `claude /login` again on the machine that runs automata (inside the devcontainer, if it runs there), then reply to have another attempt made.";
+function renderClaudeAuthComment(surface, excerpt) {
+  const lines = [
+    `automata do-work: the agent run stopped before it posted an answer on ${surface}. ${CLAUDE_AUTH_REASON}.`,
+    CLAUDE_AUTH_REMEDY,
+    "This comment is posted once. Automata does not post it again while the problem remains."
+  ];
+  if (excerpt.trim() !== "") {
+    lines.push("", "Last lines of the agent's output:", "```text", excerpt.replaceAll("```", "'''"), "```");
+  }
+  return `${lines.join("\n")}
+${CLAUDE_AUTH_MARKER}`;
+}
+
 // src/run/answerRecovery.ts
 import { closeSync, fstatSync, openSync, readSync } from "fs";
 var RECOVERY_TIMEOUT_MS = 3e5;
@@ -6259,6 +6297,14 @@ function describeTickHistory(ticks, cadence, now, logPath, lines, problems) {
       )
     );
   }
+  if (ticks[0].note === "claude-auth") {
+    problems.push(
+      finding(
+        `${CLAUDE_AUTH_REASON}, so the last tick stopped before it answered; ${CLAUDE_AUTH_REMEDY}`,
+        "claude /login"
+      )
+    );
+  }
   const lockHeld = ticks.filter((tick) => tick.note === "lock-held").length;
   const withRuns = ticks.filter((tick) => tick.runs > 0).length;
   lines.push(
@@ -6638,14 +6684,20 @@ function requireParticipants(config) {
     );
   }
   if (!config.issueDiscoveryTechnique) {
-    failSettings("No issue discovery technique configured. Run `automata config set issue-discovery-technique <value>`.");
+    failSettings(
+      "No issue discovery technique configured. Run `automata config set issue-discovery-technique <value>`."
+    );
   }
   if (!config.issueDiscoveryValue) {
-    failSettings("No issue discovery value configured. Run `automata config set issue-discovery-value <value>`.");
+    failSettings(
+      "No issue discovery value configured. Run `automata config set issue-discovery-value <value>`."
+    );
   }
   const allowedUsers = (config.allowedUsers ?? []).filter((user) => user.trim().length > 0);
   if (allowedUsers.length === 0) {
-    failSettings("No allowed users configured. Run `automata config set allowed-users <user1,user2>`.");
+    failSettings(
+      "No allowed users configured. Run `automata config set allowed-users <user1,user2>`."
+    );
   }
   const agentUser = (config.agentUser ?? "").trim();
   if (agentUser.length === 0) {
@@ -6864,8 +6916,20 @@ function validateDoWorkConfig(section2) {
     failSettings(`doWork.executor must be 'claude' or 'codex', got ${JSON.stringify(executor)}.`);
   }
   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");
+  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"]);
@@ -6897,7 +6961,9 @@ function validateSettingContainer(value, container, keys) {
   }
   for (const key2 of Object.keys(value)) {
     if (!keys.includes(key2)) {
-      failSettings(`doWork.${container}.${key2} is not a recognised setting; expected one of: ${keys.join(", ")}.`);
+      failSettings(
+        `doWork.${container}.${key2} is not a recognised setting; expected one of: ${keys.join(", ")}.`
+      );
     }
   }
 }
@@ -6909,7 +6975,11 @@ function orphanPassEnabled(settings) {
 }
 function discoverIssues(settings) {
   if (!issuePassEnabled(settings)) return [];
-  const candidates = listCandidateIssues(settings.technique, settings.discoveryValue, settings.limit);
+  const candidates = listCandidateIssues(
+    settings.technique,
+    settings.discoveryValue,
+    settings.limit
+  );
   if (settings.onlyIssue === void 0) {
     if (candidates.length === settings.limit) {
       progress(
@@ -7006,11 +7076,15 @@ function claimIssue(item, settings) {
   if (!item.needsAssignment || item.issue === null) return;
   try {
     assignIssueToAgent(item.issue.number, settings.participants.agentUser);
-    progress(`  assigned issue #${String(item.issue.number)} to ${settings.participants.agentUser}.
-`);
+    progress(
+      `  assigned issue #${String(item.issue.number)} to ${settings.participants.agentUser}.
+`
+    );
   } catch (err) {
-    progress(`  warning: could not assign issue #${String(item.issue.number)}: ${err.message}
-`);
+    progress(
+      `  warning: could not assign issue #${String(item.issue.number)}: ${err.message}
+`
+    );
   }
 }
 function claimPr(prNumber, agentUser) {
@@ -7019,8 +7093,10 @@ function claimPr(prNumber, agentUser) {
     progress(`  assigned pull request #${String(prNumber)} to ${agentUser}.
 `);
   } catch (err) {
-    progress(`  warning: could not assign pull request #${String(prNumber)}: ${err.message}
-`);
+    progress(
+      `  warning: could not assign pull request #${String(prNumber)}: ${err.message}
+`
+    );
   }
 }
 function notePickupOnIssue(item, marker) {
@@ -7033,13 +7109,17 @@ function notePickupOnIssue(item, marker) {
       `automata do-work: picked this up on pull request #${String(item.pr.number)} \u2014 ${item.pr.url}`
     );
   } catch (err) {
-    progress(`  skipped: could not note the pickup on issue #${String(item.issue.number)} \u2014 ${err.message}
-`);
+    progress(
+      `  skipped: could not note the pickup on issue #${String(item.issue.number)} \u2014 ${err.message}
+`
+    );
     try {
       deleteMarker(marker);
     } catch (deleteErr) {
-      progress(`  warning: could not withdraw the working marker: ${deleteErr.message}
-`);
+      progress(
+        `  warning: could not withdraw the working marker: ${deleteErr.message}
+`
+      );
     }
     return false;
   }
@@ -7052,8 +7132,10 @@ function reportIssueMessagesBuriedByNote(item, note, participants) {
     const messages = getIssueSurface(item.issue.number).messages;
     buried = messagesBetween(messages, participants, watermark, note.createdAt);
   } catch (err) {
-    progress(`  warning: could not re-read issue #${String(item.issue.number)}: ${err.message}
-`);
+    progress(
+      `  warning: could not re-read issue #${String(item.issue.number)}: ${err.message}
+`
+    );
     return 0;
   }
   if (buried.length === 0) return 0;
@@ -7065,8 +7147,10 @@ function reportIssueMessagesBuriedByNote(item, note, participants) {
       `automata do-work: ${authors} posted here while this issue was being picked up, so ${buried.length === 1 ? "that message was" : "those messages were"} not included in the run. Please post again to have them acted on.`
     );
   } catch (err) {
-    progress(`  warning: could not report the buried issue message(s): ${err.message}
-`);
+    progress(
+      `  warning: could not report the buried issue message(s): ${err.message}
+`
+    );
   }
   return buried.length;
 }
@@ -7084,7 +7168,9 @@ function refreshOrphanItem(item, linkMap, settings, policy) {
   const number = item.pr?.number ?? 0;
   const stillOrphan = linkMap.orphans.some((candidate) => candidate.pr.number === number);
   if (!stillOrphan) {
-    const linkedTo = issuesClosedBy(linkMap, number).map((issueNumber) => `#${String(issueNumber)}`);
+    const linkedTo = issuesClosedBy(linkMap, number).map(
+      (issueNumber) => `#${String(issueNumber)}`
+    );
     return {
       kind: "skip",
       issue: null,
@@ -7126,7 +7212,8 @@ function reportOvertakenMessages(item, analysis) {
 `);
   }
 }
-async function reconcileMarker(item, marker, participants, watermark, runError, diagnostics, recovery = null) {
+async function reconcileMarker(item, marker, participants, watermark, run5) {
+  const { runError, diagnostics, recovery, claudeAuth } = run5;
   let analysis;
   try {
     analysis = analyseAnswer(readAnsweringSurface(item), participants, marker, watermark);
@@ -7139,7 +7226,8 @@ async function reconcileMarker(item, marker, participants, watermark, runError,
   }
   let recoveryNote = null;
   let recovered = false;
-  if (analysis.answeredAt === null && runError === null && recovery !== null) {
+  const canRecover = runError === null && recovery !== null && claudeAuth === null;
+  if (analysis.answeredAt === null && canRecover) {
     const attempt = await attemptRecovery(item, marker, participants, watermark, recovery);
     if ("analysis" in attempt) {
       analysis = attempt.analysis;
@@ -7149,31 +7237,74 @@ async function reconcileMarker(item, marker, participants, watermark, runError,
     }
   }
   if (analysis.answeredAt !== null) {
-    reportOvertakenMessages(item, analysis);
-    try {
-      deleteMarker(marker);
-    } catch (err) {
-      progress(`  warning: could not delete the marker comment: ${err.message}
-`);
-    }
-    if (analysis.missed.length > 0) {
-      return {
-        outcome: "answered-no-reply",
-        detail: `answered (${String(analysis.toReport.length)} message(s) arrived mid-run and were flagged)`,
-        reason: "flagged"
-      };
-    }
-    if (recovered) {
-      return { outcome: "answered", detail: "answered (recovered from the run transcript)", reason: "answered" };
-    }
-    return runError === null ? { outcome: "answered", detail: "answered", reason: "answered" } : { outcome: "answered", detail: `answered, but the run reported: ${runError.message}`, reason: "answered" };
+    return reportAnswered(item, marker, analysis, runError, recovered);
   }
+  if (claudeAuth !== null) return reportClaudeAuth(item, marker, participants, claudeAuth);
   return reportNoAnswer(item, marker, runError, diagnostics, recoveryNote);
 }
+function reportAnswered(item, marker, analysis, runError, recovered) {
+  reportOvertakenMessages(item, analysis);
+  try {
+    deleteMarker(marker);
+  } catch (err) {
+    progress(`  warning: could not delete the marker comment: ${err.message}
+`);
+  }
+  if (analysis.missed.length > 0) {
+    return {
+      outcome: "answered-no-reply",
+      detail: `answered (${String(analysis.toReport.length)} message(s) arrived mid-run and were flagged)`,
+      reason: "flagged"
+    };
+  }
+  if (recovered) {
+    return {
+      outcome: "answered",
+      detail: "answered (recovered from the run transcript)",
+      reason: "answered"
+    };
+  }
+  return runError === null ? { outcome: "answered", detail: "answered", reason: "answered" } : {
+    outcome: "answered",
+    detail: `answered, but the run reported: ${runError.message}`,
+    reason: "answered"
+  };
+}
+function hasClaudeAuthComment(item, marker, participants) {
+  try {
+    const before = new Date(marker.createdAt).getTime();
+    const agent = participants.agentUser.toLowerCase();
+    const last = readAnsweringSurface(item).findLast(
+      (message) => message.author.toLowerCase() === agent && new Date(message.createdAt).getTime() < before
+    );
+    return last?.body.includes(CLAUDE_AUTH_MARKER) === true;
+  } catch {
+    return false;
+  }
+}
+function reportClaudeAuth(item, marker, participants, excerpt) {
+  const surface = markerSurfaceLabel(item);
+  const result = {
+    outcome: "failed",
+    detail: `${CLAUDE_AUTH_REASON}. ${CLAUDE_AUTH_REMEDY}`,
+    reason: "no-answer",
+    claudeAuth: true
+  };
+  const alreadyTold = hasClaudeAuthComment(item, marker, participants);
+  try {
+    if (alreadyTold) deleteMarker(marker);
+    else updateMarker(marker, renderClaudeAuthComment(surface, excerpt));
+  } catch (err) {
+    warnMarkerNotUpdated(surface, err, "that Claude Code is not signed in");
+  }
+  return result;
+}
 async function attemptRecovery(item, marker, participants, watermark, recovery) {
   const surface = markerSurfaceLabel(item);
-  progress(`  recovery: the run posted no answer on ${surface}; asking the model to write it from the transcript.
-`);
+  progress(
+    `  recovery: the run posted no answer on ${surface}; asking the model to write it from the transcript.
+`
+  );
   const reread = () => analyseAnswer(readAnsweringSurface(item), participants, marker, watermark);
   const fail3 = (reason) => {
     progress(`  recovery: failed \u2014 ${reason}
@@ -7205,12 +7336,15 @@ async function attemptRecovery(item, marker, participants, watermark, recovery)
   }
   try {
     const verified2 = reread();
-    if (verified2.answeredAt === null) return fail3(`the recovered answer is not visible on ${surface} after posting`);
+    if (verified2.answeredAt === null)
+      return fail3(`the recovered answer is not visible on ${surface} after posting`);
     progress(`  recovery: posted the answer recovered from the run transcript on ${surface}.
 `);
     return { analysis: verified2, posted: true };
   } catch (err) {
-    return fail3(`could not re-read ${surface} to verify the recovered answer: ${err.message}`);
+    return fail3(
+      `could not re-read ${surface} to verify the recovered answer: ${err.message}`
+    );
   }
 }
 function reportUnverified(item, marker) {
@@ -7230,6 +7364,13 @@ function reportUnverified(item, marker) {
     reason: "unverified"
   };
 }
+function warnMarkerNotUpdated(surface, err, what) {
+  progress(
+    `  warning: could not update the marker comment on ${surface}: ${err.message}
+  the humans have not been told ${what}.
+`
+  );
+}
 async function reportNoAnswer(item, marker, runError, diagnostics, recoveryNote = null) {
   const surface = markerSurfaceLabel(item);
   const sideEffects = item.turn === "issue-discuss" ? "It may still have created a branch or opened a pull request \u2014 check before assuming otherwise." : `It may still have changed the branch \`${item.branch}\` \u2014 check it before assuming otherwise.`;
@@ -7238,13 +7379,13 @@ async function reportNoAnswer(item, marker, runError, diagnostics, recoveryNote
   try {
     updateMarker(marker, explanation + recovery + (await diagnostics?.() ?? ""));
   } catch (err) {
-    progress(
-      `  warning: could not update the marker comment on ${surface}: ${err.message}
-  the humans have not been told that this run produced no answer.
-`
-    );
+    warnMarkerNotUpdated(surface, err, "that this run produced no answer");
   }
-  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" };
+  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, execution, silent, sink2) {
   beat({
@@ -7256,7 +7397,12 @@ async function invokeExecutor(prompt, execution, silent, sink2) {
     await runCodex(prompt, { model: execution.model, effort: execution.effort, sink: sink2 });
     return;
   }
-  await runClaude(prompt, { model: execution.model, effort: execution.effort, printSteps: !silent, sink: sink2 });
+  await runClaude(prompt, {
+    model: execution.model,
+    effort: execution.effort,
+    printSteps: !silent,
+    sink: sink2
+  });
 }
 function repairIssueLink(item, baseBranch, agentUser) {
   const issue = item.issue;
@@ -7264,8 +7410,10 @@ function repairIssueLink(item, baseBranch, agentUser) {
   try {
     const branch = getCurrentBranch();
     if (branch === baseBranch) {
-      progress(`  issue #${String(issue.number)} is still in discussion (no branch was created).
-`);
+      progress(
+        `  issue #${String(issue.number)} is still in discussion (no branch was created).
+`
+      );
       return false;
     }
     const pr = getCurrentBranchPr();
@@ -7277,10 +7425,15 @@ function repairIssueLink(item, baseBranch, agentUser) {
     if (pr.assignees.length === 0) {
       claimPr(pr.number, agentUser);
     }
-    const closesRef = new RegExp(String.raw`\bcloses\s+#` + String(issue.number) + String.raw`\b`, "i");
+    const closesRef = new RegExp(
+      String.raw`\bcloses\s+#` + String(issue.number) + String.raw`\b`,
+      "i"
+    );
     if (closesRef.test(pr.body)) {
-      progress(`  pull request #${String(pr.number)} already closes issue #${String(issue.number)}.
-`);
+      progress(
+        `  pull request #${String(pr.number)} already closes issue #${String(issue.number)}.
+`
+      );
       return true;
     }
     addClosesRefToPr(pr.number, issue.number);
@@ -7288,8 +7441,10 @@ function repairIssueLink(item, baseBranch, agentUser) {
 `);
     return true;
   } catch (err) {
-    progress(`  warning: could not link a pull request to issue #${String(issue.number)}: ${err.message}
-`);
+    progress(
+      `  warning: could not link a pull request to issue #${String(issue.number)}: ${err.message}
+`
+    );
     return false;
   }
 }
@@ -7378,8 +7533,10 @@ ${itemLabel(planned)} ${planned.turn}: ${planned.reason}
   }
   let buriedByNote = 0;
   if (note !== null) {
-    progress(`  noted on issue #${String(item.issue?.number ?? 0)} that the work is on pull request #${String(item.pr?.number ?? 0)}.
-`);
+    progress(
+      `  noted on issue #${String(item.issue?.number ?? 0)} that the work is on pull request #${String(item.pr?.number ?? 0)}.
+`
+    );
     buriedByNote = reportIssueMessagesBuriedByNote(item, note, settings.participants);
   }
   const watermark = promptWatermark([
@@ -7414,43 +7571,64 @@ ${itemLabel(planned)} ${planned.turn}: ${planned.reason}
     );
   }
   const execution = toExecution(resolved);
-  const { runError, diagnostics, recovery } = await runRecorded(item, prompt, execution, settings, silent);
+  const { runError, diagnostics, recovery, claudeAuth } = await runRecorded(
+    item,
+    prompt,
+    execution,
+    settings,
+    silent
+  );
   const ranExecutor = true;
   let reconciled;
   try {
-    reconciled = await reconcileMarker(
-      item,
-      marker,
-      settings.participants,
-      watermark,
+    reconciled = await reconcileMarker(item, marker, settings.participants, watermark, {
       runError,
       diagnostics,
-      recovery
-    );
+      recovery,
+      claudeAuth
+    });
   } finally {
     inFlightMarker = null;
   }
   progress(`  ${reconciled.detail}
 `);
   const outcome = adjustOutcome(reconciled, item, settings, buriedByNote);
-  return { ...base, outcome: outcome.outcome, detail: outcome.detail, ranExecutor, execution };
+  return {
+    ...base,
+    outcome: outcome.outcome,
+    detail: outcome.detail,
+    ranExecutor,
+    execution,
+    claudeAuth: outcome.claudeAuth
+  };
 }
 async function runRecorded(item, prompt, execution, settings, silent) {
   const transcript = settings.postRunLog ? new RunTranscript(transcriptLabel(item)) : null;
   const before = transcript === null ? null : snapshotCheckout();
+  const authTail = transcript === null && execution.executor === "claude" ? new ClaudeAuthTail() : null;
   let runError = null;
   try {
-    await invokeExecutor(prompt, execution, silent, transcript ?? void 0);
+    await invokeExecutor(prompt, execution, silent, transcript ?? authTail ?? void 0);
   } catch (err) {
     runError = err;
   }
-  if (transcript === null) return { runError, diagnostics: null, recovery: null };
+  if (transcript === null) {
+    const claudeAuth2 = runError !== null && authTail !== null && detectClaudeAuthFailure(authTail.tail) ? "" : null;
+    return { runError, diagnostics: null, recovery: null, claudeAuth: claudeAuth2 };
+  }
+  const tail = transcript.excerpt();
+  const claudeAuth = runError !== null && execution.executor === "claude" && detectClaudeAuthFailure(tail) ? tail : null;
   return {
     runError,
+    claudeAuth,
     recovery: async () => {
       const text = (transcript.saved ? readTranscriptTail(transcript.path) : null) ?? transcript.excerpt();
       if (text.trim() === "") return { ok: false, reason: "the run transcript is empty" };
-      return recoverAnswer(execution, { subject: markerSurfaceLabel(item), transcript: text, conversation: prompt });
+      return recoverAnswer(execution, {
+        subject: markerSurfaceLabel(item),
+        transcript: text,
+        conversation: prompt
+      });
     },
     diagnostics: async () => {
       const excerpt = transcript.excerpt();
@@ -7530,8 +7708,10 @@ function summarize(reports) {
   }
   for (const report of reports) {
     const ran = report.execution === void 0 ? "" : ` \xB7 ${describeExecution(report.execution)}`;
-    out(`  ${reportLabel(report)} ${report.turn ?? "-"} ${report.outcome} \u2014 ${report.detail}${ran}
-`);
+    out(
+      `  ${reportLabel(report)} ${report.turn ?? "-"} ${report.outcome} \u2014 ${report.detail}${ran}
+`
+    );
   }
 }
 function toItemJson(report) {
@@ -7553,7 +7733,13 @@ function toItemJson(report) {
 }
 var doWorkCommand = new Command6("do-work").description(
   "Run one tick of the autonomous loop: answer the issues whose newest authorized message the agent has not answered, then the open pull requests that close no issue of this repository and have one"
-).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(
+).option(
+  "--with <executor>",
+  "Executor to use: claude or codex (default: from config, else claude)"
+).option(
+  "--model <string>",
+  "Model identifier to pass to the executor, overriding the configured default for it"
+).option(
   "--effort <level>",
   "Reasoning effort to pass to the executor, overriding the configured default for it"
 ).option("--issue <number>", "Restrict the tick to a single issue").option(
@@ -7619,7 +7805,12 @@ async function runDoWorkTraced(options) {
     return exitCode2;
   }
   const { exitCode, reports } = await runTickUnderLock(lock.handle, settings, options);
-  logTick(reports, exitCode, startedAt);
+  logTick(
+    reports,
+    exitCode,
+    startedAt,
+    reports.some((report) => report.claudeAuth === true) ? "claude-auth" : void 0
+  );
   return exitCode;
 }
 async function runTickUnderLock(handle, settings, options) {
@@ -7685,6 +7876,20 @@ function buildSelectionEvidence(settings, issues, linkMap, decisions, verbose) {
     })) : null
   };
 }
+function decideAll(settings, issues, linkMap, policy) {
+  return skipDuplicateHeadBranches([
+    ...issues.map(
+      (issue) => decideWork(buildIssueState(issue, linkMap), settings.participants, policy)
+    ),
+    ...discoverOrphanPrs(settings, linkMap).map(
+      (candidate) => decideOrphanPrWork(
+        { prSurface: getPrSurface(candidate.pr.number) },
+        settings.participants,
+        policy
+      )
+    )
+  ]);
+}
 function collectSelection(settings, verbose) {
   const issues = discoverIssues(settings);
   const linkMap = getOpenPrLinkMap();
@@ -7693,12 +7898,7 @@ function collectSelection(settings, verbose) {
     defaultBranch: linkMap.defaultBranch,
     protectedBranches: settings.protectedBranches
   };
-  const decisions = skipDuplicateHeadBranches([
-    ...issues.map((issue) => decideWork(buildIssueState(issue, linkMap), settings.participants, policy)),
-    ...discoverOrphanPrs(settings, linkMap).map(
-      (candidate) => decideOrphanPrWork({ prSurface: getPrSurface(candidate.pr.number) }, settings.participants, policy)
-    )
-  ]);
+  const decisions = decideAll(settings, issues, linkMap, policy);
   return buildSelectionEvidence(settings, issues, linkMap, decisions, verbose);
 }
 function makeSelectionSection(lines, problems, data) {
@@ -7730,7 +7930,12 @@ function describeIssueEvidence(settings, evidence) {
     `discovery query: ${settings.technique} = ${settings.discoveryValue}, limit ${String(settings.limit)}${restriction}`
   ];
   if (evidence.issues === null) return lines;
-  lines.push(heading(`discovery returned ${String(evidence.issues.length)} issue(s)`, evidence.issues.length));
+  lines.push(
+    heading(
+      `discovery returned ${String(evidence.issues.length)} issue(s)`,
+      evidence.issues.length
+    )
+  );
   for (const issue of evidence.issues) {
     lines.push(`    #${String(issue.number)} ${issue.title}`);
   }
@@ -7812,11 +8017,11 @@ function selectionData(evidence) {
 }
 function selectionSectionFromEvidence(settings, evidence, verbose) {
   if (evidence === null) {
-    return makeSelectionSection(
-      ["not run: the tick was blocked before discovery"],
-      [],
-      { ran: false, detail: "blocked before discovery", plan: [] }
-    );
+    return makeSelectionSection(["not run: the tick was blocked before discovery"], [], {
+      ran: false,
+      detail: "blocked before discovery",
+      plan: []
+    });
   }
   const lines = [];
   if (verbose && settings !== null) describeSelectionEvidence(settings, evidence, lines);
@@ -8051,6 +8256,9 @@ function dumpBlocked(options, context) {
   }
 }
 function classifyBlocked(hygiene, decisions, items, reports) {
+  if (reports.some((report) => report.claudeAuth === true)) {
+    return { reason: "claude-auth", trigger: `${CLAUDE_AUTH_REASON}; run \`claude /login\` again` };
+  }
   const ran = reports.some((report) => report.ranExecutor === true);
   if (ran) return null;
   if (hygiene.degraded) {
@@ -8168,12 +8376,7 @@ async function runTick(settings, options) {
     defaultBranch: linkMap.defaultBranch,
     protectedBranches: settings.protectedBranches
   };
-  const decisions = skipDuplicateHeadBranches([
-    ...issues.map((issue) => decideWork(buildIssueState(issue, linkMap), settings.participants, policy)),
-    ...discoverOrphanPrs(settings, linkMap).map(
-      (candidate) => decideOrphanPrWork({ prSurface: getPrSurface(candidate.pr.number) }, settings.participants, policy)
-    )
-  ]);
+  const decisions = decideAll(settings, issues, linkMap, policy);
   const items = decisions.flatMap((decision) => decision.kind === "work" ? [decision.item] : []);
   const planText = `Work plan (${String(items.length)} of ${String(decisions.length)} candidates need an answer):
 ${describePlan(decisions)}`;
@@ -8222,9 +8425,23 @@ async function processItems(items, settings, options, hygiene) {
     const report = await reportForItem(item, settings, options, preflightCauses);
     if (report.ranExecutor === true) runsUsed++;
     reports.push(report);
+    if (report.claudeAuth === true) {
+      reports.push(...items.slice(index + 1).map((rest) => skipForClaudeAuth(rest)));
+      break;
+    }
   }
   return { reports, deferred };
 }
+function skipForClaudeAuth(item) {
+  return {
+    issue: item.issue?.number ?? null,
+    pr: item.pr?.number ?? null,
+    title: itemTitle(item),
+    turn: item.turn,
+    outcome: "skipped",
+    detail: `${CLAUDE_AUTH_REASON}; run \`claude /login\` again`
+  };
+}
 async function reportForItem(item, settings, options, preflightCauses) {
   try {
     return await processItem(item, settings, options.silent === true, preflightCauses);
@@ -8479,6 +8696,39 @@ function coveredByWatchedIssue(watch, linkedPrs) {
   return covered;
 }
 
+// src/conductor/copilot.ts
+function isCopilotAuthor(author) {
+  return author.toLowerCase().includes("copilot");
+}
+function openCopilotThreads(surface) {
+  return surface.threads.filter(
+    (thread) => !thread.isResolved && thread.comments.length > 0 && isCopilotAuthor(thread.comments[0].author)
+  );
+}
+function newestCopilotAt(threads) {
+  let newest2 = null;
+  for (const comment of threads.flatMap((thread) => thread.comments)) {
+    if (isCopilotAuthor(comment.author) && (newest2 === null || comment.createdAt > newest2)) newest2 = comment.createdAt;
+  }
+  return newest2;
+}
+function renderCopilotBlock(number, threads, agentUser) {
+  const items = threads.map((thread) => {
+    const location = thread.line === null ? `${thread.path}:(file)` : `${thread.path}:${String(thread.line)}`;
+    const first = thread.comments[0];
+    const link = thread.url === null ? "" : ` (${thread.url})`;
+    return `- ${location}${link}
+  ${first.author}: ${first.body.trim().replaceAll("\n", "\n  ")}`;
+  });
+  return [
+    `Open Copilot review comments on pull request #${String(number)}:`,
+    "",
+    items.join("\n"),
+    "",
+    `Add to your reply an instruction to ${agentUser}: fix each comment above, and then resolve its review thread. Do not resolve a thread yourself.`
+  ].join("\n");
+}
+
 // src/conductor/replyDecision.ts
 function isWatchClosed(state) {
   return state === "closed";
@@ -8496,10 +8746,32 @@ function prConversation(surface) {
     kind: "pr",
     number: surface.pr.number,
     state: surface.pr.state === "OPEN" ? "open" : "closed",
-    messages: [...surface.messages, ...surface.threads.flatMap((thread) => thread.comments)]
+    messages: [...surface.messages, ...surface.threads.flatMap((thread) => thread.comments)],
+    copilotAt: newestCopilotAt(openCopilotThreads(surface))
   };
 }
 function decideConversation(conversation, p) {
+  const decision = decideByAgentMessage(conversation, p);
+  if (decision.kind === "reply") return decision;
+  return copilotTurn(conversation) ?? decision;
+}
+function copilotTurn(conversation) {
+  const copilotAt = conversation.copilotAt ?? null;
+  if (copilotAt === null || isWatchClosed(conversation.state)) return null;
+  let lastReply = "";
+  for (const message of conversation.messages) {
+    if (message.body.includes(REPLY_MARKER) && message.createdAt > lastReply) lastReply = message.createdAt;
+  }
+  if (copilotAt <= lastReply) return null;
+  return {
+    kind: "reply",
+    surface: conversation,
+    agentMessageAt: copilotAt,
+    copilot: true,
+    reason: `an unresolved Copilot review thread has a comment at ${copilotAt} that no conductor reply follows`
+  };
+}
+function decideByAgentMessage(conversation, p) {
   if (isWatchClosed(conversation.state)) {
     return { kind: "skip", surface: conversation, reason: "closed", detail: "the item is closed or merged" };
   }
@@ -8641,6 +8913,8 @@ function prSection(pr, participants) {
     lines.push("", `Unresolved review threads on pull request #${number}:`, "", threads.join("\n\n"));
   }
   lines.push("", `CI status of pull request #${number}:`, "", renderChecks(checks));
+  const copilot = openCopilotThreads(surface);
+  if (copilot.length > 0) lines.push("", renderCopilotBlock(surface.pr.number, copilot, participants.agentUser));
   return lines;
 }
 function composeConductorPrompt(input) {
@@ -8719,6 +8993,35 @@ function describeConductorExecution(execution) {
   return `${execution.executor}${model}${effort}`;
 }
 
+// src/conductor/automatic.ts
+var DEFAULT_INTERVAL_SECONDS = 60;
+function parseInterval(raw) {
+  if (raw === void 0) return DEFAULT_INTERVAL_SECONDS;
+  if (!/^\d+$/.test(raw.trim()) || !Number.isSafeInteger(Number(raw)) || Number(raw) < 1) {
+    return `--interval must be a positive whole number of seconds, got "${raw}".`;
+  }
+  return Number(raw);
+}
+async function runAutomatic(loop) {
+  if (loop.stopped()) {
+    loop.log("Conductor: stopped.");
+    return 0;
+  }
+  const result = await loop.tick();
+  if (result.open === 0) {
+    loop.log("Conductor: no open item is watched any more; leaving the loop.");
+    return 0;
+  }
+  if (loop.stopped()) {
+    loop.log("Conductor: stopped.");
+    return 0;
+  }
+  if (result.code !== 0) loop.log(`Conductor: the tick ended with exit code ${String(result.code)}; the next tick runs anyway.`);
+  loop.log(`Conductor: next tick in ${String(loop.intervalSeconds)} s.`);
+  await loop.sleep(loop.intervalSeconds);
+  return runAutomatic(loop);
+}
+
 // src/conductor/reply.ts
 function isComment(message) {
   return message.kind === "issue-comment" || message.kind === "pr-comment";
@@ -9087,6 +9390,10 @@ ${reply}
 `);
   return "replied";
 }
+function agentIsWorking(config) {
+  const status = inspectRunLock(config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes);
+  return status.kind === "held" || status.kind === "suspect";
+}
 async function conductItem(id, config, login2, participants, execution, dryRun, linkMap) {
   const label2 = `#${String(id)}`;
   let item;
@@ -9107,6 +9414,11 @@ async function conductItem(id, config, login2, participants, execution, dryRun,
     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";
+  }
+  if (owed.kind === "reply" && owed.copilot === true && dryRun === void 0 && agentIsWorking(config)) {
+    process.stdout.write(`Conductor: ${label2} has open Copilot review threads, but the agent is working (the do-work run lock is held); waiting.
 `);
     return "idle";
   }
@@ -9383,17 +9695,63 @@ async function runConductor(options = {}) {
   }
 }
 async function runConductorTick(options) {
-  if (options.check === true && options.dryRun === true) {
-    return fail2("--check and --dry-run cannot be used together.");
-  }
+  const problem = optionsProblem(options);
+  if (problem !== null) return fail2(problem);
+  if (options.automatic === true) return runConductorAutomatic(options.interval);
   if (options.check === true) return runConductorCheck();
+  return (await runTick2(options)).code;
+}
+function optionsProblem(options) {
+  if (options.check === true && options.dryRun === true) return "--check and --dry-run cannot be used together.";
+  if (options.automatic !== true) {
+    return options.interval === void 0 ? null : "--interval needs --automatic.";
+  }
+  if (options.check === true || options.dryRun === true) return "--automatic cannot be used with --check or --dry-run.";
+  const interval = parseInterval(options.interval);
+  return typeof interval === "string" ? interval : null;
+}
+async function runConductorAutomatic(rawInterval) {
+  const intervalSeconds = parseInterval(rawInterval);
+  let stop = false;
+  let wake = null;
+  const onSignal = () => {
+    if (stop) process.exit(130);
+    stop = true;
+    process.stdout.write("Conductor: stopping after the current tick.\n");
+    wake?.();
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  try {
+    process.stdout.write(`Conductor: automatic mode, one tick every ${String(intervalSeconds)} s. Press Ctrl+C to stop.
+`);
+    return await runAutomatic({
+      intervalSeconds,
+      tick: () => runTick2({}),
+      stopped: () => stop,
+      log: (line) => process.stdout.write(`${line}
+`),
+      sleep: (seconds) => new Promise((resolve2) => {
+        const timer = setTimeout(resolve2, seconds * 1e3);
+        wake = () => {
+          clearTimeout(timer);
+          resolve2();
+        };
+      })
+    });
+  } finally {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+  }
+}
+async function runTick2(options) {
   const checked = preflight();
-  if ("problem" in checked) return fail2(checked.problem);
-  if (options.dryRun === true) return runConductorDryRun(checked);
+  if ("problem" in checked) return { code: fail2(checked.problem), open: null };
+  if (options.dryRun === true) return { code: await runConductorDryRun(checked), open: null };
   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);
+  if (!lock.ok) return { code: reportHeldLock(lock.heldBy, lock.suspect, staleMinutes), open: null };
   try {
     process.stdout.write(`Conductor: running as ${login2}.
 `);
@@ -9416,7 +9774,7 @@ async function runConductorTick(options) {
         failed++;
       }
     }
-    return failed > 0 ? 1 : 0;
+    return { code: failed > 0 ? 1 : 0, open: watch.length };
   } finally {
     lock.handle.release();
   }
@@ -9426,7 +9784,7 @@ var conductorCommand = new Command7("conductor").description(
 ).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").option(
   "--verbose",
   "Trace every `git` and `gh` call with its duration and exit code, show the model's steps, and list the tool calls the run was denied"
-).action(async (options) => {
+).option("--automatic", "Run a tick every --interval seconds until no open item is watched (Ctrl+C stops it)").option("--interval <seconds>", "Seconds between two ticks with --automatic (default 60)").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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.12.0-develop.554",
+  "version": "0.12.0-develop.567",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {