automata-cli 0.1.0-feature-030-do-work.212 → 0.1.0-feature-030-do-work.216

package/dist/{ConfigWizard-OYNUMRTO.js → ConfigWizard-O25ZZT5R.js}

@@ -9,7 +9,7 @@ import {
   readConfig,
   readRawConfig,
   writeConfig
-} from "./chunk-UA32XYYL.js";
+} from "./chunk-LTCVLM4I.js";
 
 // src/config/ConfigWizard.tsx
 import { useState } from "react";

package/dist/{chunk-UA32XYYL.js → chunk-LTCVLM4I.js}

@@ -9,11 +9,12 @@ var DEFAULT_SONAR_PROMPT = "You are an expert software engineer. You have been g
 var DEFAULT_CHECK_ISSUE_PROMPT = "You are an expert software engineer working on a GitHub issue. Below is the conversation on that issue, restricted to the people allowed to instruct you and your own previous replies. Messages marked as new arrived after your last run: treat them as the current instruction and read the earlier messages only as context. Do what the new messages ask, following the project's existing conventions and style, and make minimal, targeted changes. Run tests and linting before finishing, then reply on the issue with a short summary of what you did.";
 var DEFAULT_DO_WORK = {
   baseBranch: "develop",
+  protectedBranches: ["main", "master"],
   executor: "claude",
   maxRunsPerTick: 0,
   lockStaleMinutes: 120
 };
-var DEFAULT_DO_WORK_ISSUE_DISCUSS_PROMPT = "You are the agent named in the context below, working on a GitHub issue together with the people allowed to instruct you. Answer the messages marked NEW; the earlier messages are context only.\n\nDo not modify, create or delete any file, and do not create a branch or a pull request, UNLESS a message marked NEW explicitly asks you to implement the work. If it does: create a branch off the base branch named below, implement the change following the project's existing conventions, run the tests and the linter, and open a pull request whose body contains `Closes #<issue number>`.\n\nOtherwise do not touch the code at all: reply on the issue with the specification, the plan, or the open questions you need answered. Keep the reply short and concrete, and always post a reply \u2014 silence looks like a crash.";
+var DEFAULT_DO_WORK_ISSUE_DISCUSS_PROMPT = "You are the agent named in the context below, working on a GitHub issue together with the people allowed to instruct you. Answer the messages marked NEW; the earlier messages are context only.\n\nDo not modify, create or delete any file, and do not create a branch or a pull request, UNLESS a message marked NEW explicitly asks you to implement the work. If it does: create a branch off the base branch named below, implement the change following the project's existing conventions, run the tests and the linter, and open a pull request whose body contains `Closes #<issue number>`.\n\nOtherwise do not touch the code at all: reply on the issue with the specification, the plan, or the open questions you need answered. Keep the reply short and concrete.\n\nEither way, always post a reply on the issue before you finish \u2014 including when you implemented and opened a pull request. Silence is indistinguishable from a crash, and the run will be reported as having produced no answer.";
 var DEFAULT_DO_WORK_PR_WORK_PROMPT = "You are the agent named in the context below, working on the pull request for a GitHub issue together with the people allowed to instruct you. Work on the branch named below, which is already checked out and up to date.\n\nAddress every message marked NEW and every unresolved review thread listed. Follow the project's existing conventions, run the tests and the linter, then commit and push to that branch. Do not merge the pull request and do not push to the base branch.\n\nReply on the pull request with a short summary of what you changed, or reply in the review thread when your answer belongs to a specific comment. Always post a reply \u2014 silence looks like a crash.";
 var CONFIG_DIR = ".automata";
 var CONFIG_FILE = "config.json";

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   readConfig,
   readRawConfig,
   writeConfig
-} from "./chunk-UA32XYYL.js";
+} from "./chunk-LTCVLM4I.js";
 
 // src/index.ts
 import { Command as Command7 } from "commander";
@@ -184,7 +184,7 @@ var configCommand = new Command("config").description("Configure automata settin
   const [{ render }, React, { ConfigWizard }] = await Promise.all([
     import("ink"),
     import("react"),
-    import("./ConfigWizard-OYNUMRTO.js")
+    import("./ConfigWizard-O25ZZT5R.js")
   ]);
   const { waitUntilExit } = render(React.createElement(ConfigWizard));
   await waitUntilExit();
@@ -2350,6 +2350,10 @@ function login(author) {
 function byCreatedAt2(a, b) {
   return a.createdAt.localeCompare(b.createdAt);
 }
+function visibleAt(createdAt, submittedAt) {
+  if (submittedAt === null || submittedAt === void 0) return createdAt;
+  return submittedAt > createdAt ? submittedAt : createdAt;
+}
 function getRepoSlug() {
   const { stdout, status } = run4("git", ["remote", "get-url", "origin"]);
   if (status !== 0) {
@@ -2428,6 +2432,7 @@ function getIssueSurface(issueNumber) {
 var LINK_MAP_QUERY = `
 query($owner:String!,$repo:String!,$cursor:String){
   repository(owner:$owner,name:$repo){
+    defaultBranchRef{ name }
     pullRequests(states:OPEN, first:100, after:$cursor, orderBy:{field:UPDATED_AT, direction:DESC}){
       pageInfo{ hasNextPage endCursor }
       nodes{
@@ -2471,17 +2476,19 @@ function indexPullRequest(map, node, nameWithOwner) {
 function getOpenPrLinkMap() {
   const { owner, repo } = getRepoSlug();
   const map = /* @__PURE__ */ new Map();
+  let defaultBranch = null;
   let cursor = null;
   for (let page = 0; page < MAX_LINK_MAP_PAGES; page++) {
     const args = ["api", "graphql", "-f", `query=${LINK_MAP_QUERY}`, "-f", `owner=${owner}`, "-f", `repo=${repo}`];
     if (cursor !== null) args.push("-f", `cursor=${cursor}`);
     const response = ghJson(args, "query open pull requests");
+    defaultBranch = response.data.repository.defaultBranchRef?.name ?? defaultBranch;
     const connection = response.data.repository.pullRequests;
     for (const node of connection.nodes) {
       indexPullRequest(map, node, `${owner}/${repo}`);
     }
     if (!connection.pageInfo?.hasNextPage || connection.pageInfo.endCursor === null) {
-      return map;
+      return { byIssue: map, defaultBranch };
     }
     cursor = connection.pageInfo.endCursor;
   }
@@ -2499,7 +2506,7 @@ query($owner:String!,$repo:String!,$prNumber:Int!,$cursor:String){
           isResolved isOutdated path line
           comments(last:100){
             pageInfo{ hasPreviousPage }
-            nodes{ author{login} body createdAt }
+            nodes{ author{login} body createdAt url pullRequestReview{ submittedAt } }
           }
         }
       }
@@ -2545,11 +2552,19 @@ function getReviewThreads(prNumber) {
         path: node.path,
         line: node.line ?? null,
         isResolved: node.isResolved,
+        url: node.comments.nodes.at(-1)?.url ?? null,
         comments: node.comments.nodes.map((comment) => ({
           kind: "thread-comment",
           author: login(comment.author),
           body: comment.body,
-          createdAt: comment.createdAt
+          // When the comment became *visible*, not when it was drafted.
+          // GitHub stamps `createdAt` the moment a comment is added to a
+          // pending review, and it only becomes visible when the review is
+          // submitted — minutes later for a human working through a diff.
+          // Using `createdAt` let an agent answer posted in between look newer
+          // than the review, which marked every one of its threads answered
+          // and discarded the whole review silently.
+          createdAt: visibleAt(comment.createdAt, comment.pullRequestReview?.submittedAt)
         })).sort(byCreatedAt2)
       });
     }
@@ -2667,12 +2682,16 @@ function isAssignedToAgent(assignees, agentUser) {
   const agent = agentUser.toLowerCase();
   return assignees.some((name) => name.toLowerCase() === agent);
 }
-function findActionableThreads(threads, p) {
+function findActionableThreads(threads, p, prLastAgentAt) {
   const actionable = [];
   for (const thread of threads) {
     if (thread.isResolved) continue;
     const comments = thread.comments.filter((comment) => classifyForThread(comment.author, p) !== "other");
     if (lastAuthorClass(comments, p) !== "authorized") continue;
+    const newestAuthorized = comments.at(-1)?.createdAt;
+    if (newestAuthorized !== void 0 && prLastAgentAt !== null && prLastAgentAt > newestAuthorized) {
+      continue;
+    }
     actionable.push({ ...thread, comments });
   }
   return actionable;
@@ -2688,7 +2707,32 @@ function newestPr(prs) {
 function plural(count, noun) {
   return `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
 }
-function decideWork(state, p, baseBranch) {
+function protectedHeads(policy) {
+  return [policy.baseBranch, policy.defaultBranch ?? "", ...policy.protectedBranches ?? []].filter(
+    (branch) => branch.length > 0
+  );
+}
+function unsafeBranchSkip(pr, issue, policy) {
+  if (pr.isCrossRepository) {
+    return {
+      kind: "skip",
+      issue,
+      reason: "unsafe-pr-branch",
+      detail: `pull request #${String(pr.number)} comes from a fork; its head branch is not in this repository`
+    };
+  }
+  if (protectedHeads(policy).includes(pr.headRefName)) {
+    return {
+      kind: "skip",
+      issue,
+      reason: "unsafe-pr-branch",
+      detail: `pull request #${String(pr.number)} has a protected branch (${pr.headRefName}) as its head, so a turn would have to push to it`
+    };
+  }
+  return null;
+}
+function decideWork(state, p, policy) {
+  const baseBranch = policy.baseBranch;
   const { issueSurface, prSurface } = state;
   const issue = issueSurface.issue;
   if (issueSurface.state === "CLOSED") {
@@ -2724,25 +2768,11 @@ function decideWork(state, p, baseBranch) {
     };
   }
   const surface = prSurface;
-  if (surface.pr.isCrossRepository) {
-    return {
-      kind: "skip",
-      issue,
-      reason: "unsafe-pr-branch",
-      detail: `pull request #${String(surface.pr.number)} comes from a fork; its head branch is not in this repository`
-    };
-  }
-  if (surface.pr.headRefName === baseBranch) {
-    return {
-      kind: "skip",
-      issue,
-      reason: "unsafe-pr-branch",
-      detail: `pull request #${String(surface.pr.number)} has the base branch (${baseBranch}) as its head`
-    };
-  }
+  const unsafe = unsafeBranchSkip(surface.pr, issue, policy);
+  if (unsafe !== null) return unsafe;
   const agentThreadMessages = surface.threads.flatMap((thread) => thread.comments).filter((comment) => comment.author.toLowerCase() === p.agentUser.toLowerCase());
   const prAnalysis = analyzeSurface([...surface.messages, ...agentThreadMessages], p);
-  const actionableThreads = findActionableThreads(surface.threads, p);
+  const actionableThreads = findActionableThreads(surface.threads, p, prAnalysis.lastAgentAt);
   const hasPrWork = prAnalysis.hasNewMessage || actionableThreads.length > 0;
   if (!hasPrWork && !issueAnalysis.hasNewMessage) {
     return {
@@ -2784,12 +2814,6 @@ function selectLinkedPr(linkedPrs) {
   const open = linkedPrs.filter((pr) => pr.state === "OPEN");
   return open.length === 0 ? null : newestPr(open);
 }
-function agentAnsweredAfter(messages, agentUser, marker) {
-  const agent = agentUser.toLowerCase();
-  return messages.some(
-    (message) => message.author.toLowerCase() === agent && message.kind !== "issue-body" && message.createdAt > marker.createdAt
-  );
-}
 
 // src/github/workPrompt.ts
 function formatThreads(threads) {
@@ -2798,7 +2822,9 @@ function formatThreads(threads) {
     const newest = thread.comments.at(-1);
     const author = newest?.author ?? "unknown";
     const body = newest?.body ?? "";
-    return `[${author}] ${location}
+    const link = thread.url === null ? "" : `
+${thread.url}`;
+    return `[${author}] ${location}${link}
 ${body}`;
   }).join("\n\n");
 }
@@ -2861,8 +2887,44 @@ function composePrompt(input) {
   return lines.join("\n");
 }
 
+// src/github/markerReconciliation.ts
+function isAuthorized(author, p) {
+  const login2 = author.toLowerCase();
+  return login2 !== p.agentUser.toLowerCase() && p.allowedUsers.some((user) => user.toLowerCase() === login2);
+}
+function promptWatermark(messageSets) {
+  let watermark = null;
+  for (const messages of messageSets) {
+    for (const message of messages) {
+      if (watermark === null || message.createdAt > watermark) watermark = message.createdAt;
+    }
+  }
+  return watermark;
+}
+function messagesBetween(messages, p, watermark, until) {
+  const since = watermark ?? "";
+  return messages.filter(
+    (message) => isAuthorized(message.author, p) && message.createdAt > since && message.createdAt <= until
+  );
+}
+function analyseAnswer(messages, p, marker, watermark) {
+  let answeredAt = null;
+  for (const message of messages) {
+    if (message.kind === "issue-body") continue;
+    if (message.author.toLowerCase() !== p.agentUser.toLowerCase()) continue;
+    if (message.createdAt <= marker.createdAt) continue;
+    if (answeredAt === null || message.createdAt > answeredAt) answeredAt = message.createdAt;
+  }
+  const since = watermark ?? marker.createdAt;
+  const toReport = messages.filter(
+    (message) => isAuthorized(message.author, p) && message.createdAt > since
+  );
+  const missed = answeredAt === null ? [] : toReport.filter((message) => message.createdAt <= answeredAt);
+  return { answeredAt, missed, toReport };
+}
+
 // src/run/runLock.ts
-import { writeFileSync, readFileSync as readFileSync3, unlinkSync, mkdirSync, renameSync, linkSync } from "fs";
+import { writeFileSync, readFileSync as readFileSync3, unlinkSync, mkdirSync, renameSync, linkSync, statSync } from "fs";
 import { randomUUID } from "crypto";
 import { hostname } from "os";
 import { join as join2 } from "path";
@@ -3022,20 +3084,81 @@ function claimStaleLock(path, token, expected) {
   }
   return true;
 }
-function reclaim(path, command, token, expected) {
-  if (!claimStaleLock(path, token, expected)) {
-    return { ok: false, heldBy: readOwner(path) ?? UNKNOWN_OWNER, suspect: false };
-  }
-  const claimed = `${path}.stale.${token}`;
+var CLAIM_STALE_MS = 6e4;
+function acquireClaim(path) {
+  const claimPath = `${path}.claim`;
   try {
-    write(path, command, token, "wx");
-    return { ok: true, handle: makeHandle(path, token) };
+    writeFileSync(claimPath, JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() }), {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    return claimPath;
   } catch (err) {
     if (err.code !== "EEXIST") throw err;
-    return { ok: false, heldBy: readOwner(path) ?? UNKNOWN_OWNER, suspect: false };
+  }
+  if (!claimIsAbandoned(claimPath)) return null;
+  try {
+    renameSync(claimPath, `${claimPath}.abandoned.${String(process.pid)}`);
+  } catch {
+    return null;
+  }
+  try {
+    unlinkSync(`${claimPath}.abandoned.${String(process.pid)}`);
+  } catch {
+  }
+  try {
+    writeFileSync(claimPath, JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() }), {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    return claimPath;
+  } catch {
+    return null;
+  }
+}
+function claimIsAbandoned(claimPath) {
+  let at = Number.NaN;
+  try {
+    const raw = JSON.parse(readFileSync3(claimPath, "utf8"));
+    if (raw.at !== void 0) at = Date.parse(raw.at);
+  } catch {
+  }
+  if (Number.isNaN(at)) {
+    try {
+      at = statSync(claimPath).mtimeMs;
+    } catch {
+      return true;
+    }
+  }
+  return Date.now() - at >= CLAIM_STALE_MS;
+}
+function reclaim(path, command, token, expected) {
+  const claimPath = acquireClaim(path);
+  if (claimPath === null) {
+    const owner = readOwner(path);
+    const ownerDead = owner !== null && owner.host === hostname() && !isAlive(owner.pid);
+    return { ok: false, heldBy: owner ?? UNKNOWN_OWNER, suspect: ownerDead };
+  }
+  try {
+    if (!claimStaleLock(path, token, expected)) {
+      return { ok: false, heldBy: readOwner(path) ?? UNKNOWN_OWNER, suspect: false };
+    }
+    const claimed = `${path}.stale.${token}`;
+    try {
+      write(path, command, token, "wx");
+      return { ok: true, handle: makeHandle(path, token) };
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      return { ok: false, heldBy: readOwner(path) ?? UNKNOWN_OWNER, suspect: false };
+    } finally {
+      try {
+        unlinkSync(claimed);
+      } catch {
+      }
+    }
   } finally {
     try {
-      unlinkSync(claimed);
+      unlinkSync(claimPath);
     } catch {
     }
   }
@@ -3147,6 +3270,7 @@ function resolveSettings(options) {
   }
   return {
     baseBranch: doWork.baseBranch ?? DEFAULT_DO_WORK.baseBranch,
+    protectedBranches: doWork.protectedBranches ?? DEFAULT_DO_WORK.protectedBranches,
     executor,
     // --model wins; otherwise take the default for the executor in use.
     model: options.model ?? doWork.models?.[executor],
@@ -3254,6 +3378,12 @@ function validateDoWorkConfig(section) {
   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");
+  const protectedBranches = section["protectedBranches"];
+  if (protectedBranches !== void 0 && protectedBranches !== null) {
+    if (!Array.isArray(protectedBranches) || protectedBranches.some((b) => typeof b !== "string" || b.trim().length === 0)) {
+      fail("doWork.protectedBranches must be an array of non-empty strings.");
+    }
+  }
   for (const container of ["models", "prompts"]) {
     const value = section[container];
     if (value === void 0 || value === null) continue;
@@ -3306,7 +3436,7 @@ function issueMatchesFilter(surface, settings) {
 }
 function buildIssueState(issue, linkMap) {
   const issueSurface = getIssueSurface(issue.number);
-  const linkedPrs = linkMap.get(issue.number) ?? [];
+  const linkedPrs = linkMap.byIssue.get(issue.number) ?? [];
   const selected = selectLinkedPr(linkedPrs);
   return {
     issueSurface,
@@ -3337,16 +3467,13 @@ function claimIssue(item, settings) {
   }
 }
 function notePickupOnIssue(item, marker) {
-  if (item.turn !== "pr-work" || item.pr === null || !item.issueAnalysis.hasNewMessage) return true;
+  if (item.turn !== "pr-work" || item.pr === null || !item.issueAnalysis.hasNewMessage) return null;
   try {
-    postMarker(
+    return postMarker(
       "issue",
       item.issue.number,
       `automata do-work: picked this up on pull request #${String(item.pr.number)} \u2014 ${item.pr.url}`
     );
-    progress(`  noted on issue #${String(item.issue.number)} that the work is on pull request #${String(item.pr.number)}.
-`);
-    return true;
   } catch (err) {
     progress(`  skipped: could not note the pickup on issue #${String(item.issue.number)} \u2014 ${err.message}
 `);
@@ -3359,20 +3486,37 @@ function notePickupOnIssue(item, marker) {
     return false;
   }
 }
+function reportIssueMessagesBuriedByNote(item, note, participants) {
+  const watermark = promptWatermark([item.issueAnalysis.messages]);
+  let buried;
+  try {
+    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}
+`);
+    return 0;
+  }
+  if (buried.length === 0) return 0;
+  const authors = [...new Set(buried.map((message) => message.author))].join(", ");
+  try {
+    postMarker(
+      "issue",
+      item.issue.number,
+      `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}
+`);
+  }
+  return buried.length;
+}
 function refreshItem(item, settings) {
   const linkMap = getOpenPrLinkMap();
-  return decideWork(
-    buildIssueState(item.issue, linkMap),
-    settings.participants,
-    settings.baseBranch
-  );
-}
-function authorizedMessagesSince(messages, participants, marker) {
-  const allowed = participants.allowedUsers.map((user) => user.toLowerCase());
-  const agent = participants.agentUser.toLowerCase();
-  return messages.filter((message) => {
-    const author = message.author.toLowerCase();
-    return author !== agent && allowed.includes(author) && message.createdAt > marker.createdAt;
+  return decideWork(buildIssueState(item.issue, linkMap), settings.participants, {
+    baseBranch: settings.baseBranch,
+    defaultBranch: linkMap.defaultBranch,
+    protectedBranches: settings.protectedBranches
   });
 }
 function readAnsweringSurface(item) {
@@ -3385,62 +3529,76 @@ function readAnsweringSurface(item) {
 function markerSurfaceLabel(item) {
   return item.turn === "pr-work" && item.pr ? `pull request #${String(item.pr.number)}` : `issue #${String(item.issue.number)}`;
 }
-function reconcileMarker(item, marker, participants, runError) {
-  const agentUser = participants.agentUser;
-  let surfaceMessages = [];
-  let answered;
+function markerSurfaceTarget(item) {
+  return item.turn === "pr-work" && item.pr ? { surface: "pr", number: item.pr.number } : { surface: "issue", number: item.issue.number };
+}
+function reportOvertakenMessages(item, analysis) {
+  if (analysis.missed.length === 0) return;
+  const authors = [...new Set(analysis.toReport.map((message) => message.author))].join(", ");
+  const count = analysis.toReport.length;
+  const target = markerSurfaceTarget(item);
   try {
-    surfaceMessages = readAnsweringSurface(item);
-    answered = agentAnsweredAfter(surfaceMessages, agentUser, marker);
+    postMarker(
+      target.surface,
+      target.number,
+      `automata do-work: ${authors} posted here while this run was already in progress, so ${count === 1 ? "that message was" : "those messages were"} not included in it. Please post again to have them acted on.`
+    );
+  } catch (err) {
+    progress(`  warning: could not report the overtaken message(s): ${err.message}
+`);
+  }
+}
+function reconcileMarker(item, marker, participants, watermark, runError) {
+  let analysis;
+  try {
+    analysis = analyseAnswer(readAnsweringSurface(item), participants, marker, watermark);
   } catch (err) {
     progress(
       `  warning: could not re-read issue #${String(item.issue.number)} to check for an answer: ${err.message}
 `
     );
-    answered = "unknown";
-  }
-  if (answered === "unknown") {
-    const surface2 = markerSurfaceLabel(item);
-    try {
-      updateMarker(
-        marker,
-        `automata do-work: the agent run finished, but automata could not read ${surface2} afterwards to confirm whether an answer was posted. Check this thread and the branch before assuming either. Reply here to have another attempt made.`
-      );
-    } catch (updateErr) {
-      progress(`  warning: could not update the marker comment: ${updateErr.message}
-`);
-    }
-    return { outcome: "answered-no-reply", detail: "could not verify whether an answer was posted" };
+    return reportUnverified(item, marker);
   }
-  if (answered) {
-    const interleaved = authorizedMessagesSince(surfaceMessages, participants, marker);
-    if (interleaved.length > 0) {
-      const authors = [...new Set(interleaved.map((message) => message.author))].join(", ");
-      try {
-        postMarker(
-          item.turn === "pr-work" ? "pr" : "issue",
-          item.turn === "pr-work" && item.pr ? item.pr.number : item.issue.number,
-          `automata do-work: ${authors} posted here while this run was already in progress, so ${interleaved.length === 1 ? "that message was" : "those messages were"} not included in it. Please post again to have them acted on.`
-        );
-      } catch (err) {
-        progress(`  warning: could not report the interleaved message(s): ${err.message}
-`);
-      }
-    }
+  if (analysis.answeredAt !== null) {
+    reportOvertakenMessages(item, analysis);
     try {
       deleteMarker(marker);
     } catch (err) {
       progress(`  warning: could not delete the marker comment: ${err.message}
 `);
     }
-    const noted = interleaved.length > 0 ? ` (${String(interleaved.length)} message(s) arrived mid-run and were flagged)` : "";
-    if (interleaved.length > 0) {
-      return { outcome: "answered-no-reply", detail: `answered${noted}` };
+    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"
+      };
     }
-    return runError === null ? { outcome: "answered", detail: "answered" } : { outcome: "answered", detail: `answered, but the run reported: ${runError.message}` };
+    return runError === null ? { outcome: "answered", detail: "answered", reason: "answered" } : { outcome: "answered", detail: `answered, but the run reported: ${runError.message}`, reason: "answered" };
   }
+  return reportNoAnswer(item, marker, runError);
+}
+function reportUnverified(item, marker) {
   const surface = markerSurfaceLabel(item);
-  const explanation = runError === null ? `automata do-work: the agent run finished without posting an answer on ${surface}. It may still have changed the branch \`${item.branch}\` \u2014 check it before assuming otherwise. Reply on ${surface} to have another attempt made.` : `automata do-work: the agent run failed before posting an answer (${runError.message}). It may have left partial changes on the branch \`${item.branch}\`. Reply on ${surface} to have another attempt made.`;
+  try {
+    updateMarker(
+      marker,
+      `automata do-work: the agent run finished, but automata could not read ${surface} afterwards to confirm whether an answer was posted. Check this thread and the branch before assuming either. Reply here to have another attempt made.`
+    );
+  } catch (err) {
+    progress(`  warning: could not update the marker comment: ${err.message}
+`);
+  }
+  return {
+    outcome: "answered-no-reply",
+    detail: "could not verify whether an answer was posted",
+    reason: "unverified"
+  };
+}
+function reportNoAnswer(item, marker, runError) {
+  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.`;
+  const explanation = runError === null ? `automata do-work: the agent run finished without posting an answer on ${surface}. ${sideEffects} Reply on ${surface} to have another attempt made.` : `automata do-work: the agent run failed before posting an answer (${runError.message}). ${sideEffects} Reply on ${surface} to have another attempt made.`;
   try {
     updateMarker(marker, explanation);
   } catch (err) {
@@ -3450,7 +3608,7 @@ function reconcileMarker(item, marker, participants, runError) {
 `
     );
   }
-  return runError === null ? { outcome: "answered-no-reply", detail: "run finished but posted no answer" } : { outcome: "failed", detail: `run failed: ${runError.message}` };
+  return runError === null ? { outcome: "answered-no-reply", detail: "run finished but posted no answer", reason: "no-answer" } : { outcome: "failed", detail: `run failed: ${runError.message}`, reason: "no-answer" };
 }
 async function invokeExecutor(prompt, settings, silent) {
   if (settings.executor === "codex") {
@@ -3465,26 +3623,28 @@ function repairIssueLink(item, baseBranch) {
     if (branch === baseBranch) {
       progress(`  issue #${String(item.issue.number)} is still in discussion (no branch was created).
 `);
-      return;
+      return false;
     }
     const pr = getCurrentBranchPr();
     if (!pr) {
       progress(`  issue #${String(item.issue.number)} is still in discussion (no pull request).
 `);
-      return;
+      return false;
     }
     const closesRef = new RegExp(String.raw`\bcloses\s+#` + String(item.issue.number) + String.raw`\b`, "i");
     if (closesRef.test(pr.body)) {
       progress(`  pull request #${String(pr.number)} already closes issue #${String(item.issue.number)}.
 `);
-      return;
+      return true;
     }
     addClosesRefToPr(pr.number, item.issue.number);
     progress(`  linked pull request #${String(pr.number)} to issue #${String(item.issue.number)}.
 `);
+    return true;
   } catch (err) {
     progress(`  warning: could not link a pull request to issue #${String(item.issue.number)}: ${err.message}
 `);
+    return false;
   }
 }
 async function processItem(planned, settings, silent) {
@@ -3530,10 +3690,22 @@ async function processItem(planned, settings, silent) {
     return { ...base, outcome: "skipped", detail: `marker failed: ${err.message}` };
   }
   inFlightMarker = { marker, item };
-  if (!notePickupOnIssue(item, marker)) {
+  const note = notePickupOnIssue(item, marker);
+  if (note === false) {
     inFlightMarker = null;
     return { ...base, outcome: "skipped", detail: "issue pickup note failed" };
   }
+  let buriedByNote = 0;
+  if (note !== null) {
+    progress(`  noted on issue #${String(item.issue.number)} that the work is on pull request #${String(item.pr?.number ?? 0)}.
+`);
+    buriedByNote = reportIssueMessagesBuriedByNote(item, note, settings.participants);
+  }
+  const watermark = promptWatermark([
+    item.issueAnalysis.messages,
+    item.prAnalysis?.messages ?? [],
+    item.actionableThreads.flatMap((thread) => thread.comments)
+  ]);
   const prompt = composePrompt({
     item,
     repo: getRepoSlug(),
@@ -3567,13 +3739,29 @@ async function processItem(planned, settings, silent) {
   }
   const ranExecutor = true;
   inFlightMarker = null;
-  const reconciled = reconcileMarker(item, marker, settings.participants, runError);
+  const reconciled = reconcileMarker(item, marker, settings.participants, watermark, runError);
   progress(`  ${reconciled.detail}
 `);
+  let outcome = reconciled;
+  if (buriedByNote > 0 && outcome.outcome === "answered") {
+    outcome = {
+      outcome: "answered-no-reply",
+      detail: `${outcome.detail} (${String(buriedByNote)} issue message(s) were buried by the pickup note and flagged)`,
+      reason: "flagged"
+    };
+  }
   if (item.turn === "issue-discuss") {
-    repairIssueLink(item, settings.baseBranch);
+    const linked = repairIssueLink(item, settings.baseBranch);
+    if (linked && outcome.reason === "no-answer") {
+      outcome = {
+        outcome: "answered",
+        detail: "opened a pull request (no issue comment)",
+        reason: "answered"
+      };
+      progress("  a pull request was opened, so the turn is counted as answered.\n");
+    }
   }
-  return { ...base, outcome: reconciled.outcome, detail: reconciled.detail, ranExecutor };
+  return { ...base, outcome: outcome.outcome, detail: outcome.detail, ranExecutor };
 }
 function summarize(reports) {
   out("\nTick summary:\n");
@@ -3670,7 +3858,13 @@ var doWorkCommand = new Command6("do-work").description(
 async function runTick(settings, options) {
   const issues = discoverIssues(settings);
   const linkMap = getOpenPrLinkMap();
-  const decisions = issues.map((issue) => decideWork(buildIssueState(issue, linkMap), settings.participants, settings.baseBranch));
+  const decisions = issues.map(
+    (issue) => decideWork(buildIssueState(issue, linkMap), settings.participants, {
+      baseBranch: settings.baseBranch,
+      defaultBranch: linkMap.defaultBranch,
+      protectedBranches: settings.protectedBranches
+    })
+  );
   const items = decisions.flatMap((decision) => decision.kind === "work" ? [decision.item] : []);
   const planText = `Work plan (${String(items.length)} of ${String(issues.length)} issues need an answer):
 ${describePlan(decisions)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.1.0-feature-030-do-work.212",
+  "version": "0.1.0-feature-030-do-work.216",
   "description": "Automata CLI tool",
   "type": "module",
   "bin": {