pr-shepherd 0.25.4 → 0.26.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pr-shepherd",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
-  "version": "0.25.4",
+  "version": "0.26.0",
   "author": {
     "name": "Jonathan Ong",
     "email": "jonathanrichardong@gmail.com"

package/README.md

@@ -89,6 +89,7 @@ Direct CLI:
 ```sh
 pr-shepherd 42                         # poll until non-WAIT or timeout
 pr-shepherd 42 --interval 45s --timeout 4m
+pr-shepherd 42 --quiet-status          # print only changed WAIT status snapshots
 pr-shepherd 42 --ready-delay 15m
 pr-shepherd iterate 42                 # single tick
 pr-shepherd poll 42                    # explicit poll command
@@ -167,6 +168,8 @@ After adding the marketplace, install/enable the `pr-shepherd` plugin from Codex
 Create `.pr-shepherdrc.yml` in your project root or an ancestor directory.
 
 ```yaml
+ignoreChecks:
+  - "Kilo Code Review"
 iterate:
   fixAttemptsPerThread: 5
   stallTimeoutMinutes: 60
@@ -189,6 +192,26 @@ Environment variables:
 
 See [docs/configuration.md](docs/configuration.md) for the full reference.
 
+### Classification rules
+
+Drop `.ts` / `.mts` / `.mjs` / `.js` files under `.pr-shepherd/classification/` to suppress and/or auto-resolve specific bot comments — useful for silencing repetitive noise like rate-limit notices from `gemini-code-assist` or "Reviews paused" from `coderabbitai`.
+
+```ts
+// .pr-shepherd/classification/gemini-quota.mts
+import type { ClassifyRule } from "pr-shepherd/classify";
+
+const rule: ClassifyRule = (item) => {
+  if (item.author !== "gemini-code-assist") return null;
+  if (!/You have reached your daily quota limit/i.test(item.body)) return null;
+  return { suppress: true, autoResolve: true };
+};
+export default rule;
+```
+
+`suppress: true` hides the item from agent output. `autoResolve: true` queues it for the minimize/resolve mutation. Both can apply together.
+
+Ready-to-use examples for common patterns are in [`examples/classification/`](examples/classification/).
+
 ## Requirements
 
 - Node.js >= 22.0.0

package/bin/checks/classify.mjs

@@ -9,6 +9,7 @@
  *      pass/fail tally. Report them as "skipped" for transparency but don't block on them.
  */
 import { loadConfig } from "../config/load.mjs";
+import picomatch from "picomatch";
 /**
  * Classify a list of raw check runs into shepherd categories.
  *
@@ -16,8 +17,15 @@ import { loadConfig } from "../config/load.mjs";
  * @returns Classified checks. "filtered" items were excluded from the tally.
  */
 export function classifyChecks(checks) {
-    const relevantEvents = new Set(loadConfig().checks.ciTriggerEvents);
-    return checks.map((c) => classify(c, relevantEvents));
+    const config = loadConfig();
+    const relevantEvents = new Set(config.checks.ciTriggerEvents);
+    const isIgnored = buildIgnoreMatcher(config.ignoreChecks ?? []);
+    return checks.filter((c) => !isIgnored(c.name)).map((c) => classify(c, relevantEvents));
+}
+function buildIgnoreMatcher(patterns) {
+    if (patterns.length === 0)
+        return () => false;
+    return picomatch(patterns, { nocase: true });
 }
 function classify(check, relevantEvents) {
     // Filter: runs from non-PR events don't count toward PR readiness.

package/bin/classify/apply.mjs

@@ -0,0 +1,110 @@
+function applyRules(rules, item) {
+    let autoResolve = false;
+    let suppress = false;
+    for (const { rule, name } of rules) {
+        let action;
+        try {
+            action = rule(item);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`pr-shepherd: classification rule ${name}: threw during evaluation: ${msg} — skipped\n`);
+            continue;
+        }
+        if (!action)
+            continue;
+        if (action.autoResolve)
+            autoResolve = true;
+        if (action.suppress)
+            suppress = true;
+    }
+    return { autoResolve, suppress };
+}
+function threadToItem(t) {
+    return {
+        kind: "review-thread",
+        id: t.id,
+        author: t.author,
+        authorType: t.authorType,
+        body: t.body,
+        url: t.url,
+        path: t.path,
+    };
+}
+function commentToItem(c) {
+    return {
+        kind: "pr-comment",
+        id: c.id,
+        author: c.author,
+        authorType: c.authorType,
+        body: c.body,
+        url: c.url,
+    };
+}
+function reviewSummaryToItem(r) {
+    return {
+        kind: "review-summary",
+        id: r.id,
+        author: r.author,
+        authorType: r.authorType,
+        body: r.body,
+    };
+}
+function changesRequestedToItem(r) {
+    return {
+        kind: "changes-requested",
+        id: r.id,
+        author: r.author,
+        authorType: r.authorType,
+        body: r.body,
+    };
+}
+function addToIndex(id, { suppress, autoResolve }, suppressedIds, autoResolveIds) {
+    if (suppress)
+        suppressedIds.add(id);
+    if (autoResolve)
+        autoResolveIds.add(id);
+}
+export function buildClassifyIndex(rules, batch) {
+    if (rules.length === 0)
+        return { suppressedIds: new Set(), autoResolveIds: new Set() };
+    const suppressedIds = new Set();
+    const autoResolveIds = new Set();
+    for (const t of batch.reviewThreads)
+        addToIndex(t.id, applyRules(rules, threadToItem(t)), suppressedIds, autoResolveIds);
+    for (const c of batch.comments)
+        addToIndex(c.id, applyRules(rules, commentToItem(c)), suppressedIds, autoResolveIds);
+    for (const r of batch.reviewSummaries)
+        addToIndex(r.id, applyRules(rules, reviewSummaryToItem(r)), suppressedIds, autoResolveIds);
+    // autoResolve for changes-requested requires a dismiss message; not supported
+    for (const r of batch.changesRequestedReviews) {
+        if (applyRules(rules, changesRequestedToItem(r)).suppress)
+            suppressedIds.add(r.id);
+    }
+    return { suppressedIds, autoResolveIds };
+}
+export function partitionBatch(index, batch) {
+    const { suppressedIds, autoResolveIds } = index;
+    const suppressedCommentIds = new Set(batch.comments.filter((c) => suppressedIds.has(c.id)).map((c) => c.id));
+    const suppressedThreadIds = new Set(batch.reviewThreads.filter((t) => suppressedIds.has(t.id)).map((t) => t.id));
+    const suppressedReviewSummaryIds = new Set(batch.reviewSummaries.filter((r) => suppressedIds.has(r.id)).map((r) => r.id));
+    const suppressedChangesRequestedIds = new Set(batch.changesRequestedReviews.filter((r) => suppressedIds.has(r.id)).map((r) => r.id));
+    const ruleAutoResolveCommentIds = batch.comments
+        .filter((c) => autoResolveIds.has(c.id))
+        .map((c) => c.id);
+    const ruleAutoResolveThreadIds = batch.reviewThreads
+        .filter((t) => !t.isResolved && !t.isOutdated && autoResolveIds.has(t.id))
+        .map((t) => t.id);
+    const ruleAutoResolveReviewSummaryIds = batch.reviewSummaries
+        .filter((r) => autoResolveIds.has(r.id))
+        .map((r) => r.id);
+    return {
+        suppressedCommentIds,
+        suppressedThreadIds,
+        suppressedReviewSummaryIds,
+        suppressedChangesRequestedIds,
+        ruleAutoResolveCommentIds,
+        ruleAutoResolveThreadIds,
+        ruleAutoResolveReviewSummaryIds,
+    };
+}

package/bin/classify/loader.mjs

@@ -0,0 +1,85 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { readdirSync, statSync } from "node:fs";
+import { join, dirname, extname, basename } from "node:path";
+import { homedir } from "node:os";
+import { pathToFileURL } from "node:url";
+const CLASSIFICATION_DIR = ".pr-shepherd/classification";
+const VALID_EXTENSIONS = new Set([".ts", ".mts", ".mjs", ".js"]);
+export function discoverRuleFiles(cwd) {
+    const home = homedir();
+    let current = cwd;
+    while (true) {
+        const candidate = join(current, CLASSIFICATION_DIR);
+        if (statSync(candidate, { throwIfNoEntry: false })?.isDirectory()) {
+            return collectRuleFiles(candidate);
+        }
+        if (current === home || current === dirname(current))
+            return [];
+        current = dirname(current);
+    }
+}
+function collectRuleFiles(dir) {
+    return readdirSync(dir)
+        .filter((name) => !name.startsWith("_") && !name.startsWith("."))
+        .filter((name) => VALID_EXTENSIONS.has(extname(name)))
+        .map((name) => join(dir, name))
+        .sort();
+}
+let tsxAttempted = false;
+async function ensureTsxRegistered() {
+    if (tsxAttempted)
+        return;
+    tsxAttempted = true;
+    try {
+        const { register } = await import("tsx/esm/api");
+        register();
+        /* c8 ignore start */
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`pr-shepherd: failed to register tsx — .ts/.mts classification rules will not load: ${msg}\n`);
+    }
+    /* c8 ignore stop */
+}
+const ruleCache = new Map();
+export async function loadRules(files) {
+    if (files.length === 0)
+        return [];
+    const cacheKey = [...files].sort((a, b) => a.localeCompare(b)).join("\0");
+    const cached = ruleCache.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    const hasTs = files.some((f) => f.endsWith(".ts") || f.endsWith(".mts"));
+    if (hasTs)
+        await ensureTsxRegistered();
+    const rules = [];
+    for (const file of files) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(file).href)));
+            if (typeof mod.default !== "function") {
+                process.stderr.write(`pr-shepherd: classification rule ${file}: default export is not a function — skipped\n`);
+                continue;
+            }
+            const name = basename(file).replace(/\.[^.]+$/, "");
+            rules.push({ name, file, rule: mod.default });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`pr-shepherd: classification rule ${file}: failed to load: ${msg} — skipped\n`);
+        }
+    }
+    ruleCache.set(cacheKey, rules);
+    return rules;
+}
+/** Reset the rule cache — for use in tests. */
+export function _resetRuleCache() {
+    ruleCache.clear();
+}

package/bin/classify/types.mjs

@@ -0,0 +1 @@
+export {};

package/bin/cli/args.mjs

@@ -27,6 +27,7 @@ const FLAGS_WITH_VALUES = new Set([
 const BOOLEAN_FLAGS = new Set([
     "--no-auto-mark-ready",
     "--no-auto-cancel-actionable",
+    "--quiet-status",
     "--dry-run",
     "--verbose",
 ]);

package/bin/cli/default-poll.mjs

@@ -12,6 +12,7 @@ const DEFAULT_POLL_BOOLEAN_FLAGS = new Set([
     "--verbose",
     "--no-auto-mark-ready",
     "--no-auto-cancel-actionable",
+    "--quiet-status",
 ]);
 export function isDefaultPollInvocation(subcommand) {
     if (subcommand === "--help" || subcommand === "-h")

package/bin/cli/fix-formatter.mjs

@@ -2,9 +2,8 @@ import { renderResolveCommand } from "../commands/iterate/render.mjs";
 import { joinSections } from "../util/markdown.mjs";
 import { renderSuggestionBlock, renderLineRange } from "./suggestion-renderer.mjs";
 import { renderThreadBullet, renderReviewBullet, renderThreadResolutionStatusTag, renderAuthor, buildFirstLookBullets, renderThreadConversation, blockquote, } from "./list-formatters.mjs";
-import { adaptFixCodeInstructions, numberInstructions } from "./iterate-instructions.mjs";
-export function formatFixCodeResult(header, result, opts) {
-    const readyDelaySuffix = opts?.readyDelaySuffix;
+import { numberInstructions } from "./iterate-instructions.mjs";
+export function formatFixCodeResult(header, result) {
     const sections = [header];
     if (result.fix.threads.length > 0) {
         sections.push("## Review threads");
@@ -128,7 +127,7 @@ export function formatFixCodeResult(header, result, opts) {
     }
     sections.push(postFixLines.join("\n"));
     sections.push("## Instructions");
-    sections.push(numberInstructions(adaptFixCodeInstructions(result.fix.instructions, result.pr, readyDelaySuffix)));
+    sections.push(numberInstructions(result.fix.instructions));
     return joinSections(sections);
 }
 function renderCheckAnnotation(a) {

package/bin/cli/help-command-pages.mjs

@@ -111,6 +111,7 @@ Usage:
 Poll flags:
   --interval <duration>          Sleep between WAIT ticks. Default: 30s.
   --timeout <duration>           Maximum wall-clock wait. Default: 5m.
+  --quiet-status                 During WAIT polling, print only changed status snapshots.
 
 Forwarded iterate flags:
   --ready-delay <duration>       Settle window before a clean PR cancels. Example: 15m.
@@ -122,7 +123,7 @@ Forwarded iterate flags:
   --help, -h                     Print this help and exit before GitHub, git, config, or log I/O.
 
 Durations accept seconds, minutes, or hours: 30s, 2m, 1h, or bare seconds.
-Each WAIT tick writes a single dot to stderr; --verbose emits the detailed per-tick line.
+Each WAIT tick writes a single dot to stderr by default; --quiet-status prints only changed WAIT snapshots, and --verbose emits detailed per-tick lines.
 
 Exit codes:
   0  WAIT timeout or MARK_READY
@@ -154,6 +155,24 @@ Flags:
   --help, -h           Print this help and exit before any cleanup.
 
 Exit code: 0 on success; 1 on validation or cleanup failure.`,
+    journal: `pr-shepherd journal
+
+Append a list item to the ## Shepherd Journal section of a PR body.
+Creates the section at the end if absent. Idempotent — duplicate items are skipped.
+
+Usage:
+  pr-shepherd journal [PR] <item> [--dry-run] [--format text|json]
+
+  PR     PR number or GitHub pull request URL. Defaults to current branch PR.
+  item   Markdown list item: must start with "- " followed by non-whitespace text.
+         Example: '- Rejected suggestion: kept existing pattern for consistency.'
+
+Flags:
+  --dry-run            Preview the new PR body without writing it to GitHub.
+  --format text|json   Output format. Default: text.
+  --help, -h           Print this help and exit before any GitHub I/O.
+
+Exit code: 0 on success (including no-change no-op); 1 on validation, lookup, or mutation failure.`,
     "log-file": `pr-shepherd log-file
 
 Print the per-worktree append-only debug log path for the current repository.

package/bin/cli/help-top-page.mjs

@@ -11,6 +11,7 @@ Usage:
   pr-shepherd resolve [PR] [resolve-flags]
   pr-shepherd commit-suggestion [PR] --thread-id ID --message MSG [flags]
   pr-shepherd mark-files-as-viewed [PR] [files...] [--tests] [--match REGEX]
+  pr-shepherd journal [PR] <item> [--dry-run] [--format text|json]
   pr-shepherd clean <pr|branch|current|repo|all> [value] [flags]
   pr-shepherd log-file [--format text|json]
 
@@ -21,6 +22,7 @@ Commands:
   resolve              Apply review-state mutations (requires at least one action flag).
   commit-suggestion    Convert one GitHub suggestion thread into a patch and commit instructions.
   mark-files-as-viewed Mark PR changed files as viewed in GitHub.
+  journal              Append a list item to the ## Shepherd Journal section of a PR body.
   clean                Remove pr-shepherd state files.
   log-file             Print the per-worktree debug log path.
 
@@ -42,6 +44,7 @@ Iterate flags:
 Poll flags:
   --interval <duration>          Sleep between WAIT ticks. Default: 30s.
   --timeout <duration>           Maximum poll wall-clock wait. Default: 5m.
+  --quiet-status                 During WAIT polling, print only changed status snapshots.
 
 Clean variants:
   pr [number]          Remove state for one PR. Defaults to current branch PR.

package/bin/cli/iterate-formatter.mjs

@@ -1,6 +1,32 @@
 import { formatFixCodeResult } from "./fix-formatter.mjs";
 import { joinSections } from "../util/markdown.mjs";
 import { adaptIterateLog, buildSimpleIterateInstructions, numberInstructions, } from "./iterate-instructions.mjs";
+function formatActivityLine(result) {
+    const activity = result.activity ?? {
+        commitCount: 0,
+        reviewRoundCount: 0,
+        latestCommitCommittedAtUnix: null,
+        reviewItemsSinceLatestCommit: [],
+    };
+    const hasActiveChecks = (result.inProgressChecks?.length ?? 0) > 0;
+    if (activity.commitCount === 0 &&
+        activity.reviewRoundCount === 0 &&
+        activity.reviewItemsSinceLatestCommit.length === 0 &&
+        !hasActiveChecks) {
+        return null;
+    }
+    const parts = [`${activity.commitCount} commits`, `${activity.reviewRoundCount} review rounds`];
+    if (activity.reviewItemsSinceLatestCommit.length > 0) {
+        parts.push(`${activity.reviewItemsSinceLatestCommit.length} review items since latest commit`);
+    }
+    if (hasActiveChecks) {
+        parts.push(`active: ${result
+            .inProgressChecks.slice(0, 5)
+            .map((c) => `\`${c.name}\``)
+            .join(", ")}`);
+    }
+    return `**activity** ${parts.join(" · ")}`;
+}
 /**
  * Format an IterateResult as human-readable Markdown.
  *
@@ -58,6 +84,12 @@ export function formatIterateResult(result, opts) {
         }
         summaryLine = segs.join(" · ");
     }
+    // Surface an explicit `--ready-delay` override (set only when the user passed the flag)
+    // so the active settle window stays visible on every tick. Replaces the rerun command
+    // that previously carried the suffix in the (now removed) recheck instruction.
+    if (readyDelaySuffix) {
+        summaryLine += ` · **ready-delay** \`${readyDelaySuffix}\` (override)`;
+    }
     const bp = result.branchProtection;
     const requiredParts = [];
     if (bp) {
@@ -80,39 +112,42 @@ export function formatIterateResult(result, opts) {
     const headerLines = [heading, "", baseLine, summaryLine];
     if (requiredLine)
         headerLines.push(requiredLine);
+    const activityLine = formatActivityLine(result);
+    if (activityLine)
+        headerLines.push(activityLine);
     const header = headerLines.join("\n");
     switch (result.action) {
         case "wait":
             return joinSections([
                 header,
                 adaptIterateLog(result.log),
-                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, readyDelaySuffix))}`,
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result))}`,
             ]);
         case "mark_ready":
             return joinSections([
                 header,
                 adaptIterateLog(result.log),
-                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, readyDelaySuffix))}`,
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result))}`,
             ]);
         case "cancel": {
             const cancelHeaderLines = [`${heading} — ${result.reason}`, "", baseLine, summaryLine];
             if (requiredLine)
                 cancelHeaderLines.push(requiredLine);
+            if (activityLine)
+                cancelHeaderLines.push(activityLine);
             return joinSections([
                 cancelHeaderLines.join("\n"),
                 adaptIterateLog(result.log),
-                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, readyDelaySuffix))}`,
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result))}`,
             ]);
         }
         case "escalate":
             return joinSections([
                 header,
                 result.escalate.humanMessage,
-                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result, readyDelaySuffix))}`,
+                `## Instructions\n\n${numberInstructions(buildSimpleIterateInstructions(result))}`,
             ]);
         case "fix_code":
-            return formatFixCodeResult(header, result, {
-                readyDelaySuffix,
-            });
+            return formatFixCodeResult(header, result);
     }
 }

package/bin/cli/iterate-instructions.mjs

@@ -1,16 +1,10 @@
-import { FIX_INSTRUCTION_STOP } from "../commands/iterate/render.mjs";
-import { buildPrShepherdCommand } from "./runner.mjs";
-function buildRecheckInstruction(rerunCommand, purpose) {
-    return `Recheck: rerun \`${rerunCommand}\` to ${purpose} once after a fresh 30s–4m delay.`;
-}
-export function buildSimpleIterateInstructions(result, readyDelaySuffix) {
-    const rerunCommand = buildIterateCommand(result.pr, readyDelaySuffix);
+export function buildSimpleIterateInstructions(result) {
     switch (result.action) {
         case "wait":
-            return [buildRecheckInstruction(rerunCommand, "continue the active goal")];
+            return ["No action this tick — the poll loop reruns automatically."];
         case "mark_ready":
             return [
-                `The CLI already marked the PR ready for review. ${buildRecheckInstruction(rerunCommand, "recheck")}`,
+                "The CLI already marked the PR ready for review. No further action this tick — the poll loop reruns automatically.",
             ];
         case "cancel":
             return ["Stop — the active goal is complete."];
@@ -20,22 +14,9 @@ export function buildSimpleIterateInstructions(result, readyDelaySuffix) {
             ];
     }
 }
-export function adaptFixCodeInstructions(instructions, pr, readyDelaySuffix) {
-    const rerunCommand = buildIterateCommand(pr, readyDelaySuffix);
-    return instructions.map((instruction) => {
-        if (instruction === FIX_INSTRUCTION_STOP) {
-            return `${instruction} ${buildRecheckInstruction(rerunCommand, "recheck")}`;
-        }
-        return instruction;
-    });
-}
 export function adaptIterateLog(log) {
     return log.replace(/\s+—\s+\d+s until auto-cancel/g, "");
 }
-function buildIterateCommand(pr, readyDelaySuffix) {
-    const suffix = readyDelaySuffix?.trim();
-    return buildPrShepherdCommand([String(pr), ...(suffix ? ["--ready-delay", suffix] : [])]).text;
-}
 export function numberInstructions(instructions) {
     return instructions.map((instruction, i) => `${i + 1}. ${instruction}`).join("\n");
 }

package/bin/cli/iterate-lean.mjs

@@ -1,4 +1,4 @@
-import { adaptIterateLog, adaptFixCodeInstructions, buildSimpleIterateInstructions, } from "./iterate-instructions.mjs";
+import { adaptIterateLog, buildSimpleIterateInstructions } from "./iterate-instructions.mjs";
 /**
  * Project an IterateResult to a lean JSON shape for the default (non-verbose) output.
  * Omits fields that are the trivial default (false, 0, empty) or state-gated fields
@@ -6,7 +6,16 @@ import { adaptIterateLog, adaptFixCodeInstructions, buildSimpleIterateInstructio
  */
 export function projectIterateLean(result, opts) {
     const readyDelaySuffix = opts?.readyDelaySuffix;
-    const simpleInstructions = (r) => buildSimpleIterateInstructions(r, readyDelaySuffix);
+    const simpleInstructions = (r) => buildSimpleIterateInstructions(r);
+    const activity = result.activity ?? {
+        commitCount: 0,
+        reviewRoundCount: 0,
+        latestCommitCommittedAtUnix: null,
+        reviewItemsSinceLatestCommit: [],
+    };
+    const hasActivity = activity.commitCount > 0 ||
+        activity.reviewRoundCount > 0 ||
+        activity.reviewItemsSinceLatestCommit.length > 0;
     const base = {
         action: result.action,
         pr: result.pr,
@@ -14,6 +23,7 @@ export function projectIterateLean(result, opts) {
         status: result.status,
         state: result.state,
         mergeStateStatus: result.mergeStateStatus,
+        ...(readyDelaySuffix && { readyDelayOverride: readyDelaySuffix }),
         ...(result.mergeStatus === "BLOCKED" &&
             result.reviewDecision !== null && { reviewDecision: result.reviewDecision }),
         ...(result.blockingBotReviewInProgress && { blockingBotReviewInProgress: true }),
@@ -24,13 +34,27 @@ export function projectIterateLean(result, opts) {
             ...(result.summary.filtered > 0 && { filtered: result.summary.filtered }),
             ...(result.summary.inProgress > 0 && { inProgress: result.summary.inProgress }),
         },
-        // remainingSeconds: only when the ready-delay timer is actively counting down
         ...(result.status === "READY" &&
             result.remainingSeconds > 0 && {
             remainingSeconds: result.remainingSeconds,
         }),
         ...(result.baseBranch && { baseBranch: result.baseBranch }),
         ...(result.branchProtection !== null && { branchProtection: result.branchProtection }),
+        ...(hasActivity && {
+            activity: {
+                commitCount: activity.commitCount,
+                reviewRoundCount: activity.reviewRoundCount,
+                ...(activity.latestCommitCommittedAtUnix !== null && {
+                    latestCommitCommittedAtUnix: activity.latestCommitCommittedAtUnix,
+                }),
+                ...(activity.reviewItemsSinceLatestCommit.length > 0 && {
+                    reviewItemsSinceLatestCommit: activity.reviewItemsSinceLatestCommit,
+                }),
+            },
+        }),
+        ...((result.inProgressChecks?.length ?? 0) > 0 && {
+            inProgressChecks: result.inProgressChecks,
+        }),
     };
     switch (result.action) {
         case "wait":
@@ -96,7 +120,7 @@ export function projectIterateLean(result, opts) {
                         resolveOnlyCommand: result.fix.resolveOnlyCommand,
                     }),
                     ...(result.fix.instructions.length > 0 && {
-                        instructions: adaptFixCodeInstructions(result.fix.instructions, result.pr, readyDelaySuffix),
+                        instructions: result.fix.instructions,
                     }),
                 },
             };
@@ -131,19 +155,18 @@ export function projectIterateLean(result, opts) {
 }
 export function projectIterateVerbose(result, opts) {
     const readyDelaySuffix = opts?.readyDelaySuffix;
+    const readyDelayOverride = readyDelaySuffix ? { readyDelayOverride: readyDelaySuffix } : {};
     if (result.action === "fix_code") {
         return {
             ...result,
-            fix: {
-                ...result.fix,
-                instructions: adaptFixCodeInstructions(result.fix.instructions, result.pr, readyDelaySuffix),
-            },
+            ...readyDelayOverride,
         };
     }
     const log = "log" in result && typeof result.log === "string" ? { log: adaptIterateLog(result.log) } : {};
     return {
         ...result,
         ...log,
-        instructions: buildSimpleIterateInstructions(result, readyDelaySuffix),
+        ...readyDelayOverride,
+        instructions: buildSimpleIterateInstructions(result),
     };
 }