pr-shepherd 0.7.0 → 0.8.0

package/plugin/skills/monitor/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: monitor
 description: "Start continuous CI monitoring — marks PR ready for review when all checks pass"
-argument-hint: "[PR number or URL] [every <interval>] [--ready-delay <duration>]"
+argument-hint: "[PR number or URL]"
 user-invocable: true
 allowed-tools:
   ["Bash", "Read", "Grep", "Edit", "Write", "Glob", "Skill", "CronCreate", "CronList", "CronDelete"]
@@ -9,72 +9,19 @@ allowed-tools:
 
 # pr-shepherd monitor — Continuous PR Monitor
 
-> Action reference (all 8 actions, JSON fields, examples): [docs/actions.md](../../../docs/actions.md)
-
 ## Arguments: $ARGUMENTS
 
-## Resolve PR number
-
-1. Strip any trailing `every <N> <unit>` interval clause from `$ARGUMENTS` first.
-2. Extract `--ready-delay <duration>` if present (e.g. `--ready-delay 15m`). Default: `10m`. Keep the raw duration string (e.g. `10m`) — do **not** convert to seconds.
-3. If the remaining text contains a PR number or GitHub PR URL, extract the number.
-4. Otherwise, infer: `gh pr list --head "$(git rev-parse --abbrev-ref HEAD)" --json number --jq '.[0].number'`
-5. If no PR found, report an error and stop.
-
-## Start the loop
-
-**Before starting:** List existing cron jobs with `CronList`.
-
-- If any job's prompt contains `# pr-shepherd-loop:pr=<PR_NUMBER>`, **do not cancel+recreate** — perform one iteration now by following the logic in the CronCreate prompt below, then return.
-
-**Run the loop:**
-
-Invoke `/loop <INTERVAL> --max-turns 50 --expires 8h` via the Skill tool. Use the interval from the argument if provided (e.g. `every 30 minutes` → `30m`), otherwise use `4m`. The loop prompt should be:
-
-````
-# pr-shepherd-loop:pr=<PR_NUMBER>
-
-**IMPORTANT — recurrence rules:**
-- **Do NOT call `ScheduleWakeup` or `/loop`.** This session is fired by a recurring cron job. Either call creates a duplicate runner, causing concurrent git operations and `.git/index.lock` collisions.
-- End the turn cleanly after completing the actions below. The cron job handles the next fire.
-
-**Self-dedup:** Run `CronList`. If more than one job contains `# pr-shepherd-loop:pr=<PR_NUMBER>`, keep the lowest job ID and `CronDelete` the rest (ignore errors — a concurrent runner may have already deleted them).
-
-Run in a single Bash call:
-  npx pr-shepherd iterate <PR_NUMBER> --ready-delay <READY_DELAY_DURATION> --no-cache --last-push-time "$(git log -1 --format=%ct HEAD)"
-(`<READY_DELAY_DURATION>` is the raw duration string, e.g. `10m` — never a bare number of seconds)
-
-Exit codes 0–3 are all valid. If the command crashes (non-zero exit, no markdown output starting with `# PR #<N> [`), log the first line of stderr and continue — do not cancel the loop. The next cron fire will retry.
-
-The output is Markdown. The first line is an H1 heading of the form `# PR #<N> [<ACTION>]`. Read the `[<ACTION>]` tag to decide what to do (see [docs/actions.md](../../../docs/actions.md) for full output shapes):
-
-- `[COOLDOWN]` | `[WAIT]` | `[RERUN_CI]` | `[MARK_READY]` → print the output, continue.
-- `[CANCEL]`   → print the output, then invoke `/loop cancel` via Skill tool and stop.
-- `[REBASE]`   → print the output, then extract the shell script from the ` ```bash ` fenced block and run it in Bash.
-- `[ESCALATE]` → print the output, then invoke `/loop cancel` via Skill tool and stop.
-- `[FIX_CODE]` → follow the numbered items under `## Instructions` in order. Only run a `resolve` command if those instructions explicitly include a "Run the `resolve:` command…" step, or if the provided resolve command includes mutation flags. In that case, the `resolve` bullet under `## Rebase` holds the final resolve command inside backticks — strip the backticks and run it, substituting `"$HEAD_SHA"` with the pushed SHA and `$DISMISS_MESSAGE` with a one-sentence description of the actual fix (never generic text like "address review comments"). **Never manually run `gh run cancel` after your push** — stale runs listed under `## Cancelled runs` were already cancelled by the CLI (using the pre-push run IDs, as required by the "cancel CI runs before fixing and pushing" rule); running it again post-push would hit the NEW runs your push just triggered. If you run the resolve command, stop this iteration afterward — CI needs time before the next tick.
-
-````
-
-**Do NOT call ScheduleWakeup** — the cron job handles its own recurrence. Calling ScheduleWakeup with a `/loop` prompt would create a duplicate cron job on the next fire.
-
-The default 4-minute interval is chosen for two reasons:
-
-1. CI checks typically take 2-3 minutes to complete so concurrent agents won't stack.
-2. 4 minutes keeps iterations within the 5-minute prompt cache TTL.
-
-## Each iteration
-
-The loop prompt above handles each iteration directly — no subagent is spawned. The same iterate command can be run manually at any time:
+## Steps
 
-```bash
-npx pr-shepherd iterate <PR_NUMBER> --ready-delay <READY_DELAY_DURATION> --no-cache --last-push-time "$(git log -1 --format=%ct HEAD)"
-```
+1. **Resolve PR number:**
+   - If `$ARGUMENTS` contains a PR number or GitHub PR URL, extract the number.
+   - Otherwise, infer: `gh pr list --head "$(git rev-parse --abbrev-ref HEAD)" --json number --jq '.[0].number'`
+   - If no PR found, report an error and stop.
 
-To stop monitoring manually, use `/loop cancel` or close the session.
+2. **Run the bootstrap command and follow its instructions:**
 
-## Handling multiple PRs
+   ```bash
+   npx pr-shepherd monitor <PR_NUMBER>
+   ```
 
-To monitor several PRs simultaneously, run `/pr-shepherd:monitor <PR>` once per PR.
-Each call creates its own cron job. Before creating a new loop, run `CronList`
-to verify a loop for that PR doesn't already exist.
+   Print the full output. Follow the `## Instructions` section exactly.

package/plugin/skills/resolve/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: resolve
 description: "Resolve all inline review comments on the current PR"
-argument-hint: "[PR number or URL] [--thread-id ID | --comment-id ID] [--require-sha SHA]"
+argument-hint: "[PR number or URL]"
 user-invocable: true
 allowed-tools: ["Bash", "Read", "Grep", "Edit", "Write", "Glob", "Skill"]
 ---
@@ -14,89 +14,23 @@ Resolve unresolved review threads and minimize PR comments on the current PR —
 
 ## Steps
 
-1. **Resolve PR number and get context:**
+1. **Resolve PR number:**
+   - If `$ARGUMENTS` contains a PR number or GitHub PR URL, extract the number.
+   - Otherwise, infer: `gh pr list --head "$(git rev-parse --abbrev-ref HEAD)" --json number --jq '.[0].number'`
+   - If no PR found, report an error and stop.
 
-   Parse `$ARGUMENTS`:
-   1. Extract and remove any `--thread-id ID` or `--comment-id ID` flags.
-   2. Extract and remove any `--require-sha SHA` flag.
-   3. Look for a PR number or GitHub PR URL in the remaining text.
-   4. If not found, infer: `gh pr list --head "$(git rev-parse --abbrev-ref HEAD)" --json number --jq '.[0].number'`
-   5. If no PR found, report an error and stop.
-
-   ```bash
-   BRANCH=$(git rev-parse --abbrev-ref HEAD)
-   LAST_PUSH=$(git log -1 --format=%ct HEAD)
-   BASE_BRANCH=$(gh pr view <N> --json baseRefName --jq '.baseRefName')
-   ```
-
-   Check if the PR is already merged:
+2. **Short-circuit if merged:**
 
    ```bash
    gh pr view <N> --json state --jq '.state'
    ```
 
-   If `MERGED`, invoke `/loop cancel` via Skill tool (to stop any active loop), output merged message, and stop.
-
-2. **Fetch comments:**
-
-   ```bash
-   npx pr-shepherd resolve <N> --fetch --last-push-time "$LAST_PUSH" --format=json
-   ```
-
-   The CLI auto-resolves outdated threads.
-   Parse the JSON for `actionableThreads`, `actionableComments`, `changesRequestedReviews`, `reviewSummaries`.
-
-3. **Triage each actionable item** into exactly one of these five buckets. Before classifying, read the comment body and — for threads — the referenced file and line.
-   - **Fixed** — already addressed in a prior commit; no new work needed.
-   - **Actionable** — real issue, not yet fixed; proceed to step 4.
-   - **Not relevant** — does not apply to this PR (e.g. comment is about unrelated code).
-   - **Outdated** — refers to code that no longer exists.
-   - **Acknowledge** — real comment, intentionally not acting on it (e.g. reviewer flagged it as "won't fix" or "not worth it," scope-out decision, deferring to a follow-up PR). Record the one-sentence reason — you will include it in the step 7 report so the user can override.
+   If `MERGED`, invoke `/loop cancel` via the Skill tool, output a merged message, and stop.
 
-   Every item returned by step 2 **must** land in one of these buckets. Do not carry an item forward as "unclassified" or silently skip it. If you genuinely can't decide, that's the Acknowledge bucket with reason "unclear — flagging for human review."
-
-   **Review summaries** (`reviewSummaries`): these are PR-level overview bodies from COMMENTED reviews. Bot-generated summaries (authors like `copilot-pull-request-reviewer`, `gemini-code-assist`, or other bot accounts) are almost always noise — default them to **Acknowledge** with reason "bot summary — no actionable content" unless the body explicitly calls out an unaddressed issue. Human-authored review summaries should be read carefully and classified like any other item.
-
-4. **Fix actionable items.** For each Actionable item:
-   - Read the relevant file(s) and apply the fix (Edit/Write tools)
-   - Re-classify as **Fixed**
-   - If too complex: leave as Actionable, report to user
-
-5. **Commit and push** (only if code was changed):
-   - `git add <file1> <file2> …` (NOT `git add -A`)
-   - `git commit -m "<appropriate commit message>"`
-   - If the fixes alter the PR's scope or intent, run `gh pr edit <N> --title "<new title>" --body "<new body>"` to keep the PR title and description in sync with what was committed. Skip if the existing text still accurately describes the PR.
-   - `git fetch origin && git rebase origin/$BASE_BRANCH && git push --force-with-lease`
-   - Cancel stale CI runs: `gh run list --branch "$BRANCH" --status in_progress --json databaseId --jq '.[].databaseId' | xargs -I{} gh run cancel {}`
-
-6. **Resolve all verified items** — **only if at least one of the three ID lists is non-empty.** If all lists are empty, skip this step entirely (running resolve with no mutation IDs enters fetch mode as a side effect). Build the command from the non-empty ID lists; omit any flag whose list is empty. For Fixed items, this step runs only after the push; Acknowledge / Not relevant / Outdated items can be resolved without a push (and therefore without `--require-sha`).
-
-   Each bucket maps to a mutation flag:
-   - **Fixed** threads → `--resolve-thread-ids`; Fixed comments → `--minimize-comment-ids`; Fixed reviews (CHANGES_REQUESTED) → `--dismiss-review-ids --message "<what you changed>"`.
-   - **Acknowledge / Not relevant / Outdated** threads → `--resolve-thread-ids`; same-bucket comments → `--minimize-comment-ids`; same-bucket reviews (CHANGES_REQUESTED) → `--dismiss-review-ids --message "<why you're not acting>"`.
-   - **Review summaries** in any bucket (Fixed, Acknowledge, Not relevant, Outdated) → `--minimize-comment-ids`. Review summary IDs (`PRR_…` from `reviewSummaries`) are passed here, not to `--dismiss-review-ids`. Do not pass review summary IDs to `--dismiss-review-ids` — that flag is only for CHANGES_REQUESTED reviews.
+3. **Fetch and follow instructions:**
 
    ```bash
-   npx pr-shepherd resolve <N> \
-     --resolve-thread-ids <comma-separated-IDs> \
-     --minimize-comment-ids <comma-separated-IDs> \
-     --dismiss-review-ids <comma-separated-IDs> \
-     --message "<specific description of the fix OR the reason you're not acting>" \
-     --require-sha $(git rev-parse HEAD)
+   npx pr-shepherd resolve <N> --fetch
    ```
 
-   `--message` belongs **only** with `--dismiss-review-ids`. Omit it entirely when not dismissing a review. When you are dismissing, write one sentence — either describing the actual fix (for Fixed) or the concrete reason for not acting (for Acknowledge). The text is sent to GitHub as the dismissal reason and is shown to the reviewer. Generic text like `"Addressed in <SHA>"` or `"address review comments"` is not acceptable.
-
-   Include `--require-sha $(git rev-parse HEAD)` whenever a push happened in step 5 (it gates the whole command, not per-item — safe to mix Fixed and Acknowledge IDs under one `--require-sha`). Omit it when no code changed.
-
-7. **Report results.** Echo the CLI's output, then append a one-line summary per Acknowledge item: `Acknowledged <threadId|commentId|reviewId> (@<author>): <reason>`. This surfaces the decisions so the user can override any that were wrong.
-
-   If any fetched item was neither resolved nor acknowledged (step 3 is supposed to prevent this, but guard against it), **stop and escalate** to the user: `<N> item(s) fetched but not acted on or acknowledged — need human direction before closing`. Do not silently drop items.
-
-## Rules
-
-- NEVER resolve **Fixed** threads before pushing the fix (use `--require-sha`). Acknowledge / Not relevant / Outdated do not require a push and omit `--require-sha`.
-- NEVER blindly resolve items — always read and verify first.
-- NEVER silently skip a fetched item. Every item must be resolved, acknowledged with a reason, or escalated.
-- Resolve from ALL authors — bots, AI reviewers, and humans alike.
-- `--message` is required when using `--dismiss-review-ids`, and must NOT be passed otherwise. The CLI throws if it is missing during dismissal. The message must describe the specific change that addressed the review or the concrete reason for not acting (e.g. `"Added null check in handler.ts:42"`, or `"Acknowledged as won't-fix — reviewer noted not worth refactoring"`); generic boilerplate like `"address review comments"` or `"Addressed in <SHA>"` is reviewer-hostile and forbidden.
+   Print the full output. Follow the `## Instructions` section exactly.

package/bin/cache/file-cache.mjs

@@ -1,79 +0,0 @@
-/**
- * Simple filesystem-based cache for shepherd batch reads.
- *
- * Cache entries live in `${TMPDIR}/pr-shepherd-cache/<owner>-<repo>/<pr>/<shape>.json`.
- * TTL defaults to 5 minutes (configurable via PR_SHEPHERD_CACHE_TTL_SECONDS or --cache-ttl).
- *
- * Mutations are never cached — this module is read-path only.
- */
-import { readFile, writeFile, rename, mkdir, stat } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { loadConfig } from "../config/load.mjs";
-import { SAFE_SEGMENT } from "../util/path-segment.mjs";
-/**
- * Read a value from the cache. Returns null on miss or expiry.
- */
-export async function cacheGet(key, opts = {}) {
-    if (opts.disabled)
-        return null;
-    const ttl = opts.ttlSeconds ?? ttlFromEnv() ?? loadConfig().cache.ttlSeconds;
-    // A TTL of 0 (or negative) means "always expired" — skip the filesystem read entirely.
-    if (ttl <= 0)
-        return null;
-    try {
-        const path = resolvePath(key);
-        const stats = await stat(path);
-        const ageSeconds = (Date.now() - stats.mtimeMs) / 1000;
-        if (ageSeconds >= ttl)
-            return null;
-        const raw = await readFile(path, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Write a value to the cache. Errors are swallowed — callers can await
- * to know when the write is done, but the write never rejects.
- */
-export async function cacheSet(key, value, opts = {}) {
-    if (opts.disabled)
-        return;
-    try {
-        const path = resolvePath(key);
-        const tmp = `${path}.${randomUUID()}.tmp`;
-        await mkdir(dirname(path), { recursive: true });
-        await writeFile(tmp, JSON.stringify(value), "utf8");
-        // Atomic rename — prevents a partial read if two processes write concurrently.
-        await rename(tmp, path);
-    }
-    catch {
-        // Cache writes are best-effort.
-    }
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function resolvePath(key) {
-    for (const [field, value] of [
-        ["owner", key.owner],
-        ["repo", key.repo],
-        ["shape", key.shape],
-    ]) {
-        if (!SAFE_SEGMENT.test(value)) {
-            throw new Error(`Invalid cache key segment "${field}": ${value}`);
-        }
-    }
-    const base = process.env["PR_SHEPHERD_CACHE_DIR"] ?? join(tmpdir(), "pr-shepherd-cache");
-    return join(base, `${key.owner}-${key.repo}`, String(key.pr), `${key.shape}.json`);
-}
-function ttlFromEnv() {
-    const raw = process.env["PR_SHEPHERD_CACHE_TTL_SECONDS"];
-    if (!raw)
-        return undefined;
-    const parsed = parseInt(raw, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}

package/bin/cli.mjs

@@ -1,286 +0,0 @@
-/**
- * CLI argument parsing and subcommand dispatch for pr-shepherd.
- *
- * Usage:
- *   pr-shepherd check [PR] [--format text|json] [--no-cache] [--cache-ttl N]
- *   pr-shepherd resolve [PR] [--fetch] [--resolve-thread-ids A,B] [--minimize-comment-ids X,Y]
- *                            [--dismiss-review-ids Q] [--message MSG] [--require-sha SHA]
- *                            [--last-push-time N]
- *   pr-shepherd iterate [PR] [--format text|json] [--cooldown-seconds N] [--ready-delay Nm] [--last-push-time N]
- *   pr-shepherd status PR1 [PR2 …]
- */
-import { runCheck } from "./commands/check.mjs";
-import { runResolveFetch, runResolveMutate } from "./commands/resolve.mjs";
-import { runIterate, renderResolveCommand } from "./commands/iterate.mjs";
-import { runStatus, formatStatusTable } from "./commands/status.mjs";
-import { getRepoInfo } from "./github/client.mjs";
-import { formatJson } from "./reporters/json.mjs";
-import { formatText } from "./reporters/text.mjs";
-import { loadConfig } from "./config/load.mjs";
-import { parseCommonArgs, getFlag, hasFlag, parseList, parseStatusPrNumbers, parseDurationToMinutes, parseIntStrict, statusToExitCode, iterateActionToExitCode, deriveSimpleReady, } from "./cli/args.mjs";
-// ---------------------------------------------------------------------------
-// Entry
-// ---------------------------------------------------------------------------
-export async function main(argv) {
-    const args = argv.slice(2); // strip node + script path
-    const subcommand = args[0];
-    switch (subcommand) {
-        case "check":
-            await handleCheck(args.slice(1));
-            break;
-        case "resolve":
-            await handleResolve(args.slice(1));
-            break;
-        case "iterate":
-            await handleIterate(args.slice(1));
-            break;
-        case "status":
-            await handleStatus(args.slice(1));
-            break;
-        default:
-            process.stderr.write(`Unknown subcommand: ${subcommand ?? "(none)"}\n`);
-            process.stderr.write("Usage: pr-shepherd <check|resolve|iterate|status> [options]\n");
-            process.exitCode = 1;
-            return;
-    }
-}
-// ---------------------------------------------------------------------------
-// Subcommand handlers
-// ---------------------------------------------------------------------------
-async function handleCheck(args) {
-    const { prNumber, global: globalOpts } = parseCommonArgs(args);
-    const report = await runCheck({ ...globalOpts, prNumber, autoResolve: false });
-    const output = globalOpts.format === "json" ? formatJson(report) : formatText(report);
-    process.stdout.write(`${output}\n`);
-    process.exitCode = statusToExitCode(report.status);
-    return;
-}
-async function handleResolve(args) {
-    const { prNumber, global: globalOpts, extra } = parseCommonArgs(args);
-    const resolveThreadIds = parseList(getFlag(extra, "--resolve-thread-ids"));
-    const minimizeCommentIds = parseList(getFlag(extra, "--minimize-comment-ids"));
-    const dismissReviewIds = parseList(getFlag(extra, "--dismiss-review-ids"));
-    const dismissMessage = getFlag(extra, "--message") ?? undefined;
-    const requireSha = getFlag(extra, "--require-sha") ?? undefined;
-    const fetchMode = hasFlag(extra, "--fetch") ||
-        (resolveThreadIds.length === 0 &&
-            minimizeCommentIds.length === 0 &&
-            dismissReviewIds.length === 0);
-    if (fetchMode) {
-        const result = await runResolveFetch({ ...globalOpts, prNumber });
-        process.stdout.write(globalOpts.format === "json"
-            ? `${JSON.stringify(result, null, 2)}\n`
-            : formatFetchResult(result));
-    }
-    else {
-        const result = await runResolveMutate({
-            ...globalOpts,
-            prNumber,
-            resolveThreadIds,
-            minimizeCommentIds,
-            dismissReviewIds,
-            dismissMessage,
-            requireSha,
-        });
-        process.stdout.write(globalOpts.format === "json"
-            ? `${JSON.stringify(result, null, 2)}\n`
-            : formatMutateResult(result));
-    }
-}
-async function handleIterate(args) {
-    const { prNumber, global: globalOpts, extra } = parseCommonArgs(args);
-    const lastPushTimeStr = getFlag(extra, "--last-push-time");
-    const lastPushTime = lastPushTimeStr
-        ? parseIntStrict(lastPushTimeStr, "--last-push-time")
-        : undefined;
-    const readyDelayStr = getFlag(extra, "--ready-delay");
-    const cfg = loadConfig();
-    const readyDelaySeconds = parseDurationToMinutes(readyDelayStr ?? "", cfg.watch.readyDelayMinutes) * 60;
-    const cooldownSecondsStr = getFlag(extra, "--cooldown-seconds");
-    const cooldownSeconds = cooldownSecondsStr
-        ? parseIntStrict(cooldownSecondsStr, "--cooldown-seconds")
-        : cfg.iterate.cooldownSeconds;
-    const noAutoRerun = hasFlag(extra, "--no-auto-rerun");
-    const noAutoMarkReady = hasFlag(extra, "--no-auto-mark-ready");
-    const noAutoCancelActionable = hasFlag(extra, "--no-auto-cancel-actionable");
-    const result = await runIterate({
-        ...globalOpts,
-        prNumber,
-        lastPushTime,
-        readyDelaySeconds,
-        cooldownSeconds,
-        noAutoRerun,
-        noAutoMarkReady,
-        noAutoCancelActionable,
-    });
-    if (globalOpts.format === "json") {
-        process.stdout.write(`${JSON.stringify(result)}\n`);
-    }
-    else {
-        process.stdout.write(`${formatIterateResult(result)}\n`);
-    }
-    process.exitCode = iterateActionToExitCode(result.action);
-    return;
-}
-async function handleStatus(args) {
-    const { global: globalOpts } = parseCommonArgs(args);
-    const prNumbers = parseStatusPrNumbers(args);
-    if (prNumbers.length === 0) {
-        process.stderr.write("Usage: pr-shepherd status PR1 [PR2 …]\n");
-        process.exitCode = 1;
-        return;
-    }
-    const repo = await getRepoInfo();
-    const summaries = await runStatus({ ...globalOpts, prNumbers });
-    const output = globalOpts.format === "json"
-        ? JSON.stringify(summaries, null, 2)
-        : formatStatusTable(summaries, `${repo.owner}/${repo.name}`);
-    process.stdout.write(`${output}\n`);
-    const allReady = summaries.every((s) => deriveSimpleReady(s));
-    process.exitCode = allReady ? 0 : 1;
-    return;
-}
-// ---------------------------------------------------------------------------
-// Output formatters
-// ---------------------------------------------------------------------------
-function formatFetchResult(result) {
-    const lines = [];
-    if (result.actionableThreads.length > 0) {
-        lines.push(`\nActionable Review Threads (${result.actionableThreads.length}):`);
-        for (const t of result.actionableThreads) {
-            lines.push(`  - threadId=${t.id} ${t.path ?? ""}:${t.line ?? "?"} (@${t.author}): ${t.body.split("\n")[0]?.slice(0, 100) ?? ""}`);
-        }
-    }
-    if (result.actionableComments.length > 0) {
-        lines.push(`\nActionable PR Comments (${result.actionableComments.length}):`);
-        for (const c of result.actionableComments) {
-            lines.push(`  - commentId=${c.id} (@${c.author}): ${c.body.split("\n")[0]?.slice(0, 100) ?? ""}`);
-        }
-    }
-    if (result.changesRequestedReviews.length > 0) {
-        lines.push(`\nPending CHANGES_REQUESTED reviews (${result.changesRequestedReviews.length}):`);
-        for (const r of result.changesRequestedReviews) {
-            lines.push(`  - reviewId=${r.id} (@${r.author})`);
-        }
-    }
-    if (result.reviewSummaries.length > 0) {
-        lines.push(`\nReview summaries (${result.reviewSummaries.length}):`);
-        for (const r of result.reviewSummaries) {
-            lines.push(`  - reviewId=${r.id} (@${r.author}): ${r.body.split("\n")[0].slice(0, 100)}`);
-        }
-    }
-    const total = result.actionableThreads.length +
-        result.actionableComments.length +
-        result.changesRequestedReviews.length +
-        result.reviewSummaries.length;
-    lines.push(`\nSummary: ${total === 0 ? "0 actionable — all threads resolved/minimized" : `${total} actionable item(s)`}`);
-    return `${lines.join("\n")}\n`;
-}
-function formatMutateResult(result) {
-    const lines = [];
-    if (result.resolvedThreads.length)
-        lines.push(`Resolved threads (${result.resolvedThreads.length}): ${result.resolvedThreads.join(", ")}`);
-    if (result.minimizedComments.length)
-        lines.push(`Minimized comments (${result.minimizedComments.length}): ${result.minimizedComments.join(", ")}`);
-    if (result.dismissedReviews.length)
-        lines.push(`Dismissed reviews (${result.dismissedReviews.length}): ${result.dismissedReviews.join(", ")}`);
-    if (result.errors.length)
-        lines.push(`Errors:\n  ${result.errors.join("\n  ")}`);
-    return `${lines.join("\n")}\n`;
-}
-/**
- * Format an IterateResult as human-readable Markdown.
- *
- * Load-bearing conventions the monitor SKILL relies on:
- *   1. The H1 heading on line 1 contains `[<ACTION>]` — the SKILL greps this tag.
- *   2. The `resolve` bullet under `## Rebase` wraps the command in backticks —
- *      the SKILL extracts the backticked content for execution.
- *   3. The shell script under `[REBASE]` is inside a ```bash fenced block.
- *   4. `## Instructions` items are numbered `1.`, `2.`, … and executed in order.
- */
-function formatIterateResult(result) {
-    const heading = `# PR #${result.pr} [${result.action.toUpperCase()}]`;
-    const baseLine = `**status** \`${result.status}\` · **merge** \`${result.mergeStateStatus}\` · **state** \`${result.state}\` · **repo** \`${result.repo}\``;
-    const summaryLine = `**summary** ${result.summary.passing} passing, ${result.summary.skipped} skipped, ${result.summary.filtered} filtered, ${result.summary.inProgress} inProgress · **remainingSeconds** ${result.remainingSeconds} · **copilotReviewInProgress** ${result.copilotReviewInProgress} · **isDraft** ${result.isDraft} · **shouldCancel** ${result.shouldCancel}`;
-    const header = [heading, "", baseLine, summaryLine].join("\n");
-    switch (result.action) {
-        case "cooldown":
-        case "wait":
-        case "cancel":
-        case "rerun_ci":
-        case "mark_ready":
-            return [header, "", result.log].join("\n");
-        case "rebase":
-            return [
-                header,
-                "",
-                result.rebase.reason,
-                "",
-                "```bash",
-                result.rebase.shellScript,
-                "```",
-            ].join("\n");
-        case "escalate":
-            return [header, "", result.escalate.humanMessage].join("\n");
-        case "fix_code":
-            return formatFixCodeResult(header, result);
-    }
-}
-function formatFixCodeResult(header, result) {
-    const sections = [header];
-    if (result.fix.threads.length > 0) {
-        sections.push("## Review threads");
-        for (const t of result.fix.threads) {
-            const loc = t.path ? `\`${t.path}:${t.line ?? "?"}\`` : "(no location)";
-            sections.push(`### \`${t.id}\` — ${loc} (@${t.author})`);
-            sections.push(blockquote(t.body));
-        }
-    }
-    if (result.fix.actionableComments.length > 0) {
-        sections.push("## Actionable comments");
-        for (const c of result.fix.actionableComments) {
-            sections.push(`### \`${c.id}\` (@${c.author})`);
-            sections.push(blockquote(c.body));
-        }
-    }
-    if (result.fix.checks.length > 0) {
-        sections.push("## Failing checks");
-        const bullets = result.fix.checks.map((ch) => {
-            const kind = ch.failureKind ?? "actionable";
-            if (ch.runId)
-                return `- \`${ch.runId}\` — \`${ch.name}\` (${kind})`;
-            if (ch.detailsUrl)
-                return `- external \`${ch.detailsUrl}\` — \`${ch.name}\` (${kind})`;
-            return `- (no runId) — \`${ch.name}\` (${kind})`;
-        });
-        sections.push(bullets.join("\n"));
-    }
-    if (result.fix.changesRequestedReviews.length > 0) {
-        sections.push("## Changes-requested reviews");
-        sections.push(result.fix.changesRequestedReviews.map((r) => `- \`${r.id}\` (@${r.author})`).join("\n"));
-    }
-    if (result.fix.noiseCommentIds.length > 0) {
-        sections.push("## Noise (minimize only)");
-        sections.push(result.fix.noiseCommentIds.map((id) => `\`${id}\``).join(", "));
-    }
-    if (result.cancelled.length > 0) {
-        sections.push("## Cancelled runs");
-        sections.push(result.cancelled.map((id) => `\`${id}\``).join(", "));
-    }
-    sections.push("## Rebase");
-    sections.push([
-        `- base: \`${result.baseBranch}\``,
-        `- resolve: \`${renderResolveCommand(result.fix.resolveCommand)}\``,
-    ].join("\n"));
-    if (result.fix.instructions.length > 0) {
-        sections.push("## Instructions");
-        sections.push(result.fix.instructions.map((inst, i) => `${i + 1}. ${inst}`).join("\n"));
-    }
-    return sections.join("\n\n");
-}
-function blockquote(body) {
-    return body
-        .split("\n")
-        .map((line) => (line === "" ? ">" : `> ${line}`))
-        .join("\n");
-}