From c70b4fc10c96aea3d6742ce3bd4ba7859538e986 Mon Sep 17 00:00:00 2001
From: Matthew Smith <matthew.smith@apptreesoftware.com>
Date: Mon, 26 Oct 2026 20:54:43 -0700
Subject: [PATCH 1/2] fix(unblock): clear the PR's failing verdicts so Unblock
 does not re-block at once

Unblock removed only the issue's blocked label. The fix-round count stays
spent by design, so when the builder's push returned the issue to In Review
with validator:failed still on the PR, blockActions re-blocked it before any
verdict on the new commit. Unblock now also removes reviewer:changes and
validator:failed from the issue's PR, as the by-hand steps already said.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JrFSqr3eJsNihHcgYph1hB
---
 README.md             | 11 ++++++-----
 src/cli/daemon.ts     |  6 ++++--
 src/needs-you.test.ts | 11 +++++++++--
 src/needs-you.ts      | 14 +++++++++-----
 4 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/README.md b/README.md
index 33ce075..d54fccd 100644
--- a/README.md
+++ b/README.md
@@ -750,9 +750,10 @@ All of these work from any terminal on the Mac. Inside a configured `repoDir` yo
   labels, so `gh issue edit <epic> --add-label <label>` is identical.
 - **Issues waiting on you:** the **Needs you** tab lists every open non-epic issue labelled
   `needs-owner`, `decision` or `blocked`, oldest first, with how long each has waited. `foreman status` prints the same list.
-  A `blocked` row has an **Unblock** button: it removes `blocked`, sets Status **Ready** and
-  comments `unblocked by owner via foreman@<host>` — fix whatever caused the block first, because
-  nothing else about the issue changes.
+  A `blocked` row has an **Unblock** button: it removes `blocked`, removes `reviewer:changes` and
+  `validator:failed` from the issue's PR, sets Status **Ready** and comments
+  `unblocked by owner via foreman@<host>` — fix whatever caused the block first, because nothing
+  else about the issue changes.
 - **Stop the launchd agent entirely:** `launchctl bootout gui/$(id -u)/com.apptreesoftware.foreman.widgets`,
   or `foreman -p widgets launchd uninstall`.
 
@@ -874,8 +875,8 @@ branch.
   (round 2 and later may block only on prior findings still open, regressions in the delta, or a
   real safety issue; anything else becomes a follow-up issue), and a merge conflict is never a
   change request — an approved PR that conflicts gets a rebase round that does not count.
-- **To unblock a task by hand:** fix or rebase the branch, push, remove `reviewer:changes` from the
-  PR and `blocked` from the issue (or use the page's **Unblock** button). The fix-round counter
+- **To unblock a task by hand:** fix or rebase the branch, push, remove `reviewer:changes` and
+  `validator:failed` from the PR and `blocked` from the issue (or use the page's **Unblock** button). The fix-round counter
   stays where it was, so the next reviewer verdict must be an approval or the task is blocked
   again.
 
diff --git a/src/cli/daemon.ts b/src/cli/daemon.ts
index 960ae35..c7de766 100644
--- a/src/cli/daemon.ts
+++ b/src/cli/daemon.ts
@@ -276,13 +276,15 @@ export async function runDaemon(
     },
     needsYouItems: () => store.get().board?.needsYou ?? [],
     unblock: async (issue) => {
-      // The stored row carries the project item id the tick already read, so the gate costs one
-      // label edit, one status write and one comment — no extra GitHub read.
+      // The stored board carries the project item id and the PR the tick already read, so the
+      // gate costs label edits, one status write and one comment — no extra GitHub read.
       const item = store.get().board?.needsYou.find((n) => n.issue === issue) ?? null;
+      const pr = store.get().board?.issues.find((n) => n.issue === issue)?.pr ?? null;
       const message = await applyUnblock(gh, {
         issue,
         itemId: item?.itemId ?? null,
         host: cfg.host,
+        pr,
       });
       log("info", "unblocked", { issue });
       // Same reason as the owner gate: reflect it locally so the button goes now, and wake
diff --git a/src/needs-you.test.ts b/src/needs-you.test.ts
index 53dff44..e2ab55f 100644
--- a/src/needs-you.test.ts
+++ b/src/needs-you.test.ts
@@ -128,7 +128,7 @@ describe("applyUnblock", () => {
 
   it("drops the label, sets Status Ready and leaves a ledger comment", async () => {
     const { gh, calls } = fakeGh();
-    const message = await applyUnblock(gh, { issue: 5, itemId: "PVTI_5", host: "mac-a" });
+    const message = await applyUnblock(gh, { issue: 5, itemId: "PVTI_5", host: "mac-a", pr: null });
     expect(calls).toEqual([
       "removeLabels issue 5 blocked",
       "setStatus PVTI_5 Ready",
@@ -138,10 +138,17 @@ describe("applyUnblock", () => {
   });
   it("adds an off-board issue to the project first", async () => {
     const { gh, calls } = fakeGh();
-    await applyUnblock(gh, { issue: 8, itemId: null, host: "mac-a" });
+    await applyUnblock(gh, { issue: 8, itemId: null, host: "mac-a", pr: null });
     expect(calls).toContain("addToProject 8");
     expect(calls).toContain("setStatus PVTI_new_8 Ready");
   });
+  it("clears the failing verdicts on the issue's PR so the block does not fire again", async () => {
+    // Without this, the builder's push returns the issue to In Review with `validator:failed`
+    // still on the PR and the fix-round count spent, and blockActions re-blocks it at once.
+    const { gh, calls } = fakeGh();
+    await applyUnblock(gh, { issue: 5, itemId: "PVTI_5", host: "mac-a", pr: 12 });
+    expect(calls).toContain("removeLabels pr 12 reviewer:changes,validator:failed");
+  });
 });
 
 describe("applyUnblockToBoard", () => {
diff --git a/src/needs-you.ts b/src/needs-you.ts
index 2521a29..b3325e4 100644
--- a/src/needs-you.ts
+++ b/src/needs-you.ts
@@ -29,16 +29,20 @@ export function needsYouItems(s: Snapshot): NeedsYouItem[] {
 export type UnblockGh = Pick<GitHubApi, "removeLabels" | "comment" | "setStatus" | "addToProject">;
 
 /**
- * The Unblock gate: the two GitHub edits an owner otherwise makes by hand (drop the label, set
- * Status Ready) plus a ledger comment, so the picker considers the issue again on the next tick.
- * The issue is not un-assigned or re-labelled `agent-ready` — whatever the builder left is what
- * the next session picks up.
+ * The Unblock gate: the GitHub edits an owner otherwise makes by hand (drop the label, clear the
+ * failing verdicts on the PR, set Status Ready) plus a ledger comment, so the picker considers the
+ * issue again on the next tick. The issue is not un-assigned or re-labelled `agent-ready` —
+ * whatever the builder left is what the next session picks up.
  */
 export async function applyUnblock(
   gh: UnblockGh,
-  i: { issue: number; itemId: string | null; host: string },
+  i: { issue: number; itemId: string | null; host: string; pr: number | null },
 ): Promise<string> {
   await gh.removeLabels("issue", i.issue, ["blocked"]);
+  // The fix-round count stays spent, so a `reviewer:changes` or `validator:failed` left on the PR
+  // re-blocks the issue the moment the builder's push returns it to In Review, before any verdict
+  // on the new commit. Cleared, the next verdict decides.
+  if (i.pr !== null) await gh.removeLabels("pr", i.pr, ["reviewer:changes", "validator:failed"]);
   // An issue that is somehow off the project board has no status to set until it is on it.
   const itemId = i.itemId ?? (await gh.addToProject(i.issue));
   await gh.setStatus(itemId, "Ready");

From 5b9ca4b9ea304d8ed5c882beeaa29ea59d756c8b Mon Sep 17 00:00:00 2001
From: Matthew Smith <matthew.smith@apptreesoftware.com>
Date: Mon, 26 Oct 2026 21:02:57 -0700
Subject: [PATCH 2/2] feat(plan): approving a plan merges its plan PR and
 applies it at once

Approve plan only added plan-approved; the plan PR still had to be merged by
hand, and until then apply_plan logged 'approved plan file not on origin/main'
every tick. apply_plan also ran only on a tick with nothing claimable, so an
approval waited behind every review and validation.

The foreman now finds the epic's open docs(plan) PR and squash-merges it when
its checks are green or absent, then applies the plan in the same tick. Running
checks wait a tick; red checks or a conflict get one comment on the epic per
head commit and a row on Needs you. These actions start no session, so they run
ahead of the pick.

An approved plan not applied yet also no longer offers Sign off, which would
have closed the epic before it had any tasks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JrFSqr3eJsNihHcgYph1hB
---
 README.md             | 43 ++++++++++++--------
 src/attention.test.ts | 10 +++++
 src/attention.ts      |  6 +--
 src/ledger.test.ts    | 31 ++++++++++++++-
 src/ledger.ts         | 12 ++++++
 src/loop.test.ts      | 21 ++++++++++
 src/loop.ts           | 18 +++++++++
 src/next.ts           |  4 ++
 src/owner.test.ts     | 34 ++++++++++++++--
 src/owner.ts          | 22 ++++++++--
 src/phase.test.ts     | 93 +++++++++++++++++++++++++++++++++++++++++--
 src/phase.ts          | 84 +++++++++++++++++++++++++++++++++-----
 src/state-file.ts     |  2 +
 src/state.test.ts     | 21 +++++++++-
 src/state.ts          |  5 ++-
 src/types.ts          |  4 ++
 src/waiting.test.ts   | 20 ++++++++++
 src/waiting.ts        | 23 ++++++++++-
 src/web.html          |  8 +++-
 src/web.test.ts       |  1 +
 20 files changed, 415 insertions(+), 47 deletions(-)

diff --git a/README.md b/README.md
index d54fccd..c3fd6d8 100644
--- a/README.md
+++ b/README.md
@@ -186,7 +186,16 @@ Every `pollSeconds` (default 300) the daemon wakes and runs one iteration:
    most failures are flakes, and a rerun costs runner time and no model tokens. The expensive half
    is in the pick — a red PR whose rerun is spent gets a builder **fix** round, ahead of review and
    validation, bounded by `limits.fixRounds` like any other, and `blocked` after that.
-5. **Pick.** Candidates are issues with Status Ready, label `agent-ready`, a `Parent epic: #N`
+5. **Approved plans.** For every open epic labelled `plan-approved` whose plan is not applied yet
+   (no `plan applied by foreman@<host>` comment), the foreman looks for its open plan PR, titled
+   `docs(plan): phase NN plan (#<epic>)`. Green checks, or none at all: it squash-merges the PR
+   and applies the plan in the same tick. Checks still running: it waits for the next tick. Red
+   checks or a conflict with the default branch: it comments
+   `plan PR #<pr> cannot merge at <sha>: <reason>. Fix it or merge it by hand (foreman@<host>)` on
+   the epic once per head commit, and the epic shows on **Needs you** until the PR is fixed or
+   merged. With no plan PR open, it applies the plan straight away. None of this starts a session,
+   so it runs ahead of the pick and an approval never waits behind a review.
+6. **Pick.** Candidates are issues with Status Ready, label `agent-ready`, a `Parent epic: #N`
    line in the body, no open claim, every "Depends on" issue closed, and a phase epic that is not
    `foreman:pause`d. Open PRs needing review or validation are candidates too, and so is an
    approved PR whose branch GitHub reports as `CONFLICTING`: that gets a **rebase** round — a
@@ -198,12 +207,12 @@ Every `pollSeconds` (default 300) the daemon wakes and runs one iteration:
    or more open `blocked` tasks starts **no new builds** until the owner unblocks one — review,
    fix, validate and rebase jobs still run there — because every blocked task is owner work and
    stacking more branches on the same files only breeds conflicts.
-6. **Claim.** The foreman comments `claimed by <host> at <iso> role=<role> round=<n>`, assigns
+7. **Claim.** The foreman comments `claimed by <host> at <iso> role=<role> round=<n>`, assigns
    itself, and (for a first-round build) sets Status In Progress. If another host's claim comment
    landed in the same window, the alphabetically first host keeps it; the others comment `released
    by <host>: conflict` and unassign. The ledger — issue comments, not the GitHub assignee — is
    authoritative, so two Macs can share one GitHub login.
-7. **Dispatch.** Creates or reuses a git worktree at `<workDir>/<issue>` — by default
+8. **Dispatch.** Creates or reuses a git worktree at `<workDir>/<issue>` — by default
    `<repoDir>/.worktrees/<issue>`, so worktrees stay inside the clone — on branch
    `feat/<issue>-<slug>`, runs the repository's `setup` command, composes the role prompt and the
    headless settings from the worktree's `.foreman/` (§5), runs the `session-env` and
@@ -212,23 +221,23 @@ Every `pollSeconds` (default 300) the daemon wakes and runs one iteration:
    `effort:<level>` label, else `high`) and a `wallClockMinutes` timeout.
    It posts `session <id> on <host> role=<role> attempt=<n>` before each attempt and runs
    `after-session` when the child ends, however it ends.
-8. **Outcome.** Parses the session's structured JSON outcome —
+9. **Outcome.** Parses the session's structured JSON outcome —
    `{"outcome": ..., "pr": <number|null>, "notes": "..."}` — and applies the labels and Status in
    the table below. On a validator `passed`/`failed` it first copies
    `<worktree>/.validation-artifacts/<pr>/` to `~/.foreman/<name>/artifacts/<pr>/`, because a
    headless session cannot write outside its worktree and the worktree is removed at merge. A
    session that ends without a valid outcome is retried up to `limits.attempts` (3) times; if all
    fail, the issue is labelled `blocked` with a log excerpt and unassigned.
-9. **Phase check.** If every task under a phase epic is closed, the phase-closer is dispatched.
+10. **Phase check.** If every task under a phase epic is closed, the phase-closer is dispatched.
    Then the planner, which is gated three ways: the epic must carry **`agent-ready`** (the owner's
    go-ahead — without it the foreman never plans anything), no approved phase may still be
    building, and no other epic's drafted plan may be waiting on the owner. When it dispatches, the
    epic is assigned and set In Progress so the hour-long session is visible on the board;
    `plan_drafted` then sets the epic In Review, adds `needs-owner`, removes `agent-ready` and
-   unassigns. Labelling the epic `plan-approved` applies the plan, clears `needs-owner` and puts
-   the epic back In Progress. Re-adding `agent-ready` asks for a re-plan. Applying a plan reads
-   `<plans.dir>/<date>-phase-NN-plan.issues.json` from the default branch on `origin`, so merging
-   the plan PR is enough — the clone never has to be pulled by hand. If the file is not there yet,
+   unassigns. Labelling the epic `plan-approved` merges the plan PR and applies the plan (step 5),
+   clears `needs-owner` and puts the epic back In Progress. Re-adding `agent-ready` asks for a
+   re-plan. Applying a plan reads `<plans.dir>/<date>-phase-NN-plan.issues.json` from the default
+   branch on `origin`, so the clone never has to be pulled by hand. If the file is not there yet,
    the foreman logs and retries next tick rather than recording the plan as applied.
 
 These run in order and stop after the first action that would start a `claude -p` session, so at
@@ -260,7 +269,7 @@ plan on retry instead of duplicating it.
 | (foreman) red CI, rerun budget unspent | rerun the failed jobs, `ci rerun by foreman@<host> for <sha>` (no session) |
 | (foreman) red CI, rerun spent | builder fix round; `blocked` once `limits.fixRounds` are gone |
 | phase-closer `phase_closed` | epic → In Review, `needs-owner` |
-| planner `plan_drafted` | epic → In Review, `needs-owner`, `agent-ready` removed, unassigned; nothing else until `plan-approved`, which applies the plan (tasks `agent-ready` + Ready), clears `needs-owner` and returns the epic to In Progress |
+| planner `plan_drafted` | epic → In Review, `needs-owner`, `agent-ready` removed, unassigned; nothing else until `plan-approved`, which merges the plan PR, applies the plan (tasks `agent-ready` + Ready), clears `needs-owner` and returns the epic to In Progress |
 
 ### Labels
 
@@ -275,7 +284,7 @@ Fixed names; `foreman init` creates them all.
 | `blocked` | Cannot proceed; the reason is a comment. Owner work. |
 | `needs-owner` | Waiting on the owner. |
 | `decision` | A question a role session could not answer. |
-| `plan-approved` | The owner approved the drafted plan; the next tick applies it. |
+| `plan-approved` | The owner approved the drafted plan; the next tick merges the plan PR and applies it. |
 | `signed-off` | The owner signed the phase off. |
 | `foreman:pause` | On an epic: no new claims under that phase, on any Mac. |
 | `reviewer:approved` / `reviewer:changes` | The reviewer's verdict, on the PR. |
@@ -330,6 +339,7 @@ reclaimed from <host> by <host> at <iso>
 merged by foreman@<host>
 ci rerun by foreman@<host> for <sha>
 unblocked by owner via foreman@<host>
+plan PR #<pr> cannot merge at <sha>: <reason>. Fix it or merge it by hand (foreman@<host>)
 ```
 
 `session … finished`, `released by`, `reclaimed from` and `merged by` are terminal: they close an
@@ -684,7 +694,8 @@ All of these work from any terminal on the Mac. Inside a configured `repoDir` yo
     bookkeeping), the running session, the in-flight pipeline (build → review → validate → CI →
     merge per issue) and the live event feed.
   - **Needs you** — every decision only the owner can make, grouped by the action: approve a
-    plan, sign off a phase, ready to plan, unblock, answer or close. The sidebar badge counts them,
+    plan, fix a plan PR that cannot merge, sign off a phase, ready to plan, unblock, answer or
+    close. The sidebar badge counts them,
     Ready to plan excepted.
   - **Waiting on** — what the foreman is waiting for by itself: CI, review rounds, dependencies,
     another Mac's claim, the phase gate, and setup problems to fix on GitHub.
@@ -906,7 +917,8 @@ branch.
   ever produce one. Add any CI workflow. `checks none` is not `checks failure`: it earns no rerun
   and no fix round either, so the PR simply sits there.
 - **`approved plan file not on origin/main; retrying next tick`, for ever.** The plan PR really is
-  not merged yet, or the plan file's `NN` does not match the epic's `phase:N` label. The foreman
+  not merged yet — its title is not `docs(plan): phase NN plan (#<epic>)`, so the foreman did not
+  find it to merge — or the plan file's `NN` does not match the epic's `phase:N` label. The foreman
   looks for `<plans.dir>/<date>-phase-NN-plan.issues.json` where `NN` is that label, zero-padded;
   the planner is told the same rule, so a mismatch means the plan was hand-edited.
 - **`~/.foreman/<name>/artifacts/<pr>/` is empty after a validation run.** The foreman only copies
@@ -984,12 +996,11 @@ foreman -p sandbox run --once        # the planner claims the epic and drafts a
 ```
 
 Expect `claimed by <host> … role=planner`, then a plan PR against the sandbox and the epic at
-**In Review** with `needs-owner`. Merge the plan PR, approve the plan, and let the loop apply it:
+**In Review** with `needs-owner`. Approve the plan and let the loop merge the plan PR and apply it:
 
 ```bash
-gh pr merge <plan pr> --squash --repo acme/foreman-sandbox
 gh issue edit 1 --repo acme/foreman-sandbox --add-label plan-approved
-foreman -p sandbox run --once        # applies the plan: task issues at Ready, agent-ready
+foreman -p sandbox run --once        # merges the plan PR, then task issues at Ready, agent-ready
 foreman -p sandbox run --once        # claims the first task for a builder
 foreman -p sandbox start
 foreman -p sandbox status --watch    # or: foreman -p sandbox logs -f
diff --git a/src/attention.test.ts b/src/attention.test.ts
index 14d41ca..40f8828 100644
--- a/src/attention.test.ts
+++ b/src/attention.test.ts
@@ -24,6 +24,7 @@ const owner = (epic: number, actions: OwnerItem["actions"]): OwnerItem => ({
   actions,
   since: null,
   review: null,
+  planPr: null,
 });
 
 const needs = (issue: number, over: Partial<NeedsYouItem> = {}): NeedsYouItem => ({
@@ -50,6 +51,15 @@ const wait = (
 });
 
 describe("describeAttention", () => {
+  it("counts an approved plan whose PR cannot merge, and lists its wait only on Needs you", () => {
+    const b = board({
+      owner: [{ ...owner(9, ["pause"]), planPr: 279, detail: "plan PR #279 cannot merge" }],
+      waiting: [wait("human", "epic #9", "epic #9 plan PR #279 cannot merge: checks failed")],
+    });
+    const a = describeAttention(b);
+    expect(a.needsYou).toBe(1);
+    expect(a.waitRows).toEqual([]);
+  });
   it("counts approve and sign-off epics and unpaired needs-you issues, not start_planning", () => {
     const b = board({
       owner: [
diff --git a/src/attention.ts b/src/attention.ts
index f0af52e..e86f634 100644
--- a/src/attention.ts
+++ b/src/attention.ts
@@ -28,14 +28,14 @@ const list = (ns: string[]) =>
  */
 export function describeAttention(board: Board | null): Attention {
   if (!board) return { needsYou: 0, waiting: 0, banners: [], waitRows: [] };
-  const gated = board.owner.filter((o) =>
-    o.actions.some((a) => a === "approve_plan" || a === "sign_off"),
+  const gated = board.owner.filter(
+    (o) => o.planPr !== null || o.actions.some((a) => a === "approve_plan" || a === "sign_off"),
   );
   const needsYou = gated.length + board.needsYou.filter((n) => n.reviewOf === null).length;
   // Every issue or epic that has a row of its own on Needs you, Ready to plan included.
   const onNeedsYou = new Set([
     ...board.owner
-      .filter((o) => o.actions.some((a) => a !== "pause" && a !== "unpause"))
+      .filter((o) => o.planPr !== null || o.actions.some((a) => a !== "pause" && a !== "unpause"))
       .map((o) => o.epic),
     ...board.needsYou.map((n) => n.issue),
   ]);
diff --git a/src/ledger.test.ts b/src/ledger.test.ts
index 579500d..d3cb316 100644
--- a/src/ledger.test.ts
+++ b/src/ledger.test.ts
@@ -1,6 +1,14 @@
 import { describe, expect, it } from "vitest";
 import { comment, hoursAgo } from "../test/helpers.ts";
-import { ciRerunCount, fixRound, fmt, lastActivityAt, openClaim, parseClaim } from "./ledger.ts";
+import {
+  ciRerunCount,
+  fixRound,
+  fmt,
+  lastActivityAt,
+  openClaim,
+  parseClaim,
+  planPrStuckReported,
+} from "./ledger.ts";
 
 describe("ledger", () => {
   it("round-trips a claim", () => {
@@ -94,3 +102,24 @@ describe("ci rerun ledger", () => {
     expect(openClaim(cs)?.claim.role).toBe("builder");
   });
 });
+
+describe("plan PR stuck ledger", () => {
+  const sha = "0123456789abcdef0123456789abcdef01234567";
+  it("formats the line and finds it again by PR and head commit", () => {
+    const line = fmt.planPrStuck("mac-a", 279, sha, "checks failed");
+    expect(line).toBe(
+      `plan PR #279 cannot merge at ${sha}: checks failed. Fix it or merge it by hand (foreman@mac-a)`,
+    );
+    const cs = [comment(line)];
+    expect(planPrStuckReported(cs, 279, sha)).toBe(true);
+    expect(planPrStuckReported(cs, 279, "f".repeat(40))).toBe(false);
+    expect(planPrStuckReported(cs, 280, sha)).toBe(false);
+  });
+  it("does not close an open claim", () => {
+    const cs = [
+      comment(fmt.claimed("mac-a", hoursAgo(2), "planner", 1), hoursAgo(2)),
+      comment(fmt.planPrStuck("mac-a", 279, sha, "checks failed"), hoursAgo(1)),
+    ];
+    expect(openClaim(cs)).not.toBeNull();
+  });
+});
diff --git a/src/ledger.ts b/src/ledger.ts
index e1dcc70..2342b36 100644
--- a/src/ledger.ts
+++ b/src/ledger.ts
@@ -30,6 +30,8 @@ export const fmt = {
     `session ${id} interrupted on ${host}: stopped by operator after ${minutes}m`,
   aborted: (host: string) => `released by ${host}: aborted by operator`,
   unblocked: (host: string) => `unblocked by owner via foreman@${host}`,
+  planPrStuck: (host: string, pr: number, sha: string, reason: string) =>
+    `plan PR #${pr} cannot merge at ${sha}: ${reason}. Fix it or merge it by hand (foreman@${host})`,
 };
 
 const CLAIM =
@@ -90,6 +92,16 @@ export function ciRerunCount(comments: Comment[], sha: string): number {
   return comments.filter((c) => CI_RERUN.exec(c.body.trim())?.[1] === sha).length;
 }
 
+const PLAN_PR_STUCK = /^plan PR #(\d+) cannot merge at ([0-9a-f]{7,40}):/;
+
+/** Whether the owner was already told this plan PR head cannot merge; one comment per push. */
+export function planPrStuckReported(comments: Comment[], pr: number, sha: string): boolean {
+  return comments.some((c) => {
+    const m = PLAN_PR_STUCK.exec(c.body.trim());
+    return m?.[1] === String(pr) && m[2] === sha;
+  });
+}
+
 export function lastActivityAt(comments: Comment[]): string | null {
   return (
     comments
diff --git a/src/loop.test.ts b/src/loop.test.ts
index 01b5281..734c4ac 100644
--- a/src/loop.test.ts
+++ b/src/loop.test.ts
@@ -659,6 +659,27 @@ describe("execute", () => {
     expect(calls).toContain("setStatus PVTI_200 In Review");
     expect(calls).toContain("addLabels issue 200 needs-owner");
   });
+  it("merge_plan squash-merges the plan PR and goes on to apply it in the same tick", async () => {
+    const { gh, calls } = fakeGh([
+      issue({ number: 200, labels: ["epic", "phase:2", "plan-approved"] }),
+    ]);
+    const r = await execute({ type: "merge_plan", epic: 200, pr: 279 }, ctx({ gh }));
+    expect(r).toBe("continue");
+    expect(calls).toEqual(["mergePR 279"]);
+  });
+  it("plan_pr_stuck tells the owner on the epic why the plan PR cannot merge", async () => {
+    const { gh, calls } = fakeGh([
+      issue({ number: 200, labels: ["epic", "phase:2", "plan-approved"] }),
+    ]);
+    const sha = "0123456789abcdef0123456789abcdef01234567";
+    await execute(
+      { type: "plan_pr_stuck", epic: 200, pr: 279, sha, reason: "checks failed" },
+      ctx({ gh }),
+    );
+    expect(calls).toEqual([
+      `comment issue 200 ${fmt.planPrStuck("mac-a", 279, sha, "checks failed")}`,
+    ]);
+  });
   it("apply_plan leaves the epic alone when the plan is not on origin/main yet", async () => {
     const { gh, calls } = fakeGh([
       issue({ number: 200, labels: ["epic", "phase:2", "plan-approved"] }),
diff --git a/src/loop.ts b/src/loop.ts
index 13d1ff8..92a6f5d 100644
--- a/src/loop.ts
+++ b/src/loop.ts
@@ -1011,6 +1011,24 @@ export async function execute(
       await runRole(ctx, { issue, role, pr: null, round: 1, resumeSessionId: null, notes: "" });
       return "stop";
     }
+    case "merge_plan":
+      // The owner's approval is the review; the apply_plan queued after this one fetches origin
+      // and finds the plan file in the same tick.
+      await gh.mergePR(action.pr);
+      log("info", "plan PR merged", { epic: action.epic, pr: action.pr });
+      return "continue";
+    case "plan_pr_stuck":
+      await gh.comment(
+        "issue",
+        action.epic,
+        fmt.planPrStuck(cfg.host, action.pr, action.sha, action.reason),
+      );
+      log("warn", "plan PR cannot merge", {
+        epic: action.epic,
+        pr: action.pr,
+        reason: action.reason,
+      });
+      return "continue";
     case "apply_plan":
       // A plan whose file is not on origin/main yet is left for the next tick, and that is not
       // work: counting it would make the loop hot until the plan PR merges.
diff --git a/src/next.ts b/src/next.ts
index 6af44e1..e52b848 100644
--- a/src/next.ts
+++ b/src/next.ts
@@ -34,6 +34,10 @@ function explain(a: Action, s: Snapshot, repo: RepoConfig): string {
       return `${actionName(a)}: phase-closer on epic #${a.epic} "${title(a.epic)}" (every task closed)`;
     case "apply_plan":
       return `${actionName(a)}: create/update task issues from the approved plan of epic #${a.epic}`;
+    case "merge_plan":
+      return `${actionName(a)}: squash-merge plan PR #${a.pr} of approved epic #${a.epic}`;
+    case "plan_pr_stuck":
+      return `${actionName(a)}: tell the owner plan PR #${a.pr} cannot merge (${a.reason})`;
     case "claim":
       return `${actionName(a)}: ${a.role} on #${a.issue} "${title(a.issue)}" ${a.rebase ? "rebase" : `round ${a.round}`}${a.pr ? ` (PR #${a.pr})` : ""}`;
     case "resume":
diff --git a/src/owner.test.ts b/src/owner.test.ts
index 1c15c1a..bca779a 100644
--- a/src/owner.test.ts
+++ b/src/owner.test.ts
@@ -1,13 +1,15 @@
 import { describe, expect, it } from "vitest";
-import { comment, epic, issue, snapshot } from "../test/helpers.ts";
+import { comment, epic, issue, pr, snapshot } from "../test/helpers.ts";
+import { fmt } from "./ledger.ts";
 import { applyOwnerAction, applyOwnerActionToBoard, ownerItems } from "./owner.ts";
 
 const e = (over = {}) => epic({ number: 200, phase: 2, labels: ["epic", "phase:2"], ...over });
-const snap = (epics: ReturnType<typeof epic>[]) =>
+const applied = [comment(fmt.planApplied("mac-a"))];
+const snap = (epics: ReturnType<typeof epic>[], comments = applied) =>
   snapshot({
     epics,
     issues: epics.map((x) =>
-      issue({ number: x.number, title: `Phase ${x.phase}`, labels: x.labels }),
+      issue({ number: x.number, title: `Phase ${x.phase}`, labels: x.labels, comments }),
     ),
   });
 
@@ -20,6 +22,28 @@ describe("ownerItems", () => {
     expect(items[0]?.actions).toEqual(["sign_off", "pause"]);
     expect(items[0]?.detail).toContain("sign-off");
   });
+  it("never offers sign-off on an approved plan that is not applied yet", () => {
+    // `needs-owner` stays on the epic until the plan is applied, so without this an approved plan
+    // still waiting on its PR offered Sign off, which closes the epic before it has any tasks.
+    const approved = e({ labels: ["epic", "phase:2", "plan-approved", "needs-owner"] });
+    const items = ownerItems(snap([approved], []));
+    expect(items[0]?.actions).toEqual(["pause"]);
+    expect(items[0]?.detail).toBe("plan approved; the tasks are created on the next tick");
+    expect(items[0]?.planPr).toBeNull();
+  });
+  it("names an approved plan's PR while its checks run, and asks the owner when it is stuck", () => {
+    const approved = e({ labels: ["epic", "phase:2", "plan-approved", "needs-owner"] });
+    const planPr = (over = {}) =>
+      pr({ number: 279, title: "docs(plan): phase 02 plan (#200)", issue: null, ...over });
+    const withPr = (p: ReturnType<typeof pr>) => ({ ...snap([approved], []), prs: [p] });
+    const pending = ownerItems(withPr(planPr({ checks: "pending" })))[0];
+    expect(pending?.detail).toBe("plan approved; plan PR #279 merges when its checks pass");
+    expect(pending?.planPr).toBeNull();
+    const red = ownerItems(withPr(planPr({ checks: "failure" })))[0];
+    expect(red?.detail).toBe("plan PR #279 cannot merge: checks failed");
+    expect(red?.planPr).toBe(279);
+    expect(red?.actions).toEqual(["pause"]);
+  });
   it("offers plan approval on a drafted plan", () => {
     const items = ownerItems(snap([e({ labels: ["epic", "phase:2", "needs-owner"] })]));
     expect(items[0]?.actions).toEqual(["approve_plan", "pause"]);
@@ -46,7 +70,7 @@ describe("ownerItems", () => {
           title: "Phase 2: Things",
           labels: signOff.labels,
           updatedAt: "2026-09-01T00:00:00Z",
-          comments: [comment("Phase review: #250")],
+          comments: [...applied, comment("Phase review: #250")],
         }),
         issue({ number: 250, title: "Phase 2 review: Things", labels: ["phase:2", "needs-owner"] }),
       ],
@@ -140,6 +164,7 @@ describe("applyOwnerActionToBoard", () => {
         actions: ["sign_off" as const, "pause" as const],
         since: null,
         review: null,
+        planPr: null,
       },
       {
         epic: 26,
@@ -149,6 +174,7 @@ describe("applyOwnerActionToBoard", () => {
         actions: ["start_planning" as const, "pause" as const],
         since: null,
         review: null,
+        planPr: null,
       },
     ],
     needsYou: [],
diff --git a/src/owner.ts b/src/owner.ts
index 125e901..c7bfebd 100644
--- a/src/owner.ts
+++ b/src/owner.ts
@@ -1,3 +1,4 @@
+import { planPR, planPrState, planUnapplied } from "./phase.ts";
 import { pairReviews } from "./review-pairing.ts";
 import type { Board, OwnerAction, OwnerItem } from "./state-file.ts";
 import type { Snapshot } from "./types.ts";
@@ -30,18 +31,31 @@ export function ownerItems(s: Snapshot): OwnerItem[] {
     .map((e) => {
       const has = (l: string) => e.labels.includes(l);
       const actions: OwnerAction[] = [];
+      // An approved plan keeps needs-owner until it is applied; it is not a sign-off, which
+      // would close the epic before it has a single task.
+      const unapplied = planUnapplied(e, s.issues);
       // needs-owner means two different things; plan-approved is what tells them apart.
-      if (has("needs-owner")) actions.push(has("plan-approved") ? "sign_off" : "approve_plan");
+      if (has("needs-owner") && !unapplied)
+        actions.push(has("plan-approved") ? "sign_off" : "approve_plan");
       else if (!has("plan-approved") && !has("agent-ready")) actions.push("start_planning");
       actions.push(has("foreman:pause") ? "unpause" : "pause");
+      const p = unapplied ? planPR(s, e.number) : null;
+      const st = p ? planPrState(p) : null;
       return {
         epic: e.number,
         title: titleOf(e.number),
         phase: e.phase,
-        detail: DETAIL[actions[0] as OwnerAction],
+        detail: !unapplied
+          ? DETAIL[actions[0] as OwnerAction]
+          : p && st?.state === "stuck"
+            ? `plan PR #${p.number} cannot merge: ${st.reason}`
+            : p && st?.state === "pending"
+              ? `plan approved; plan PR #${p.number} merges when its checks pass`
+              : "plan approved; the tasks are created on the next tick",
         actions,
         since: s.issues.find((i) => i.number === e.number)?.updatedAt ?? null,
         review: actions.includes("sign_off") ? (reviewOf.get(e.number) ?? null) : null,
+        planPr: p && st?.state === "stuck" ? p.number : null,
       };
     });
 }
@@ -97,9 +111,9 @@ export async function applyOwnerAction(
       await gh.closeIssue(epic);
       return `#${epic} signed off and closed`;
     case "approve_plan":
-      // Only the label: the foreman's apply_plan creates the task issues on its next tick.
+      // Only the label: on its next tick the foreman merges the plan PR and creates the tasks.
       await gh.addLabels("issue", epic, ["plan-approved"]);
-      return `#${epic} labelled plan-approved; the plan is applied on the next tick`;
+      return `#${epic} labelled plan-approved; the plan PR is merged and applied on the next tick`;
     case "start_planning":
       await gh.addLabels("issue", epic, ["agent-ready"]);
       return `#${epic} labelled agent-ready; the planner runs when nothing else is in flight`;
diff --git a/src/phase.test.ts b/src/phase.test.ts
index b5b7250..fb160c0 100644
--- a/src/phase.test.ts
+++ b/src/phase.test.ts
@@ -1,7 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { comment, epic, hoursAgo, issue, snapshot } from "../test/helpers.ts";
+import { comment, epic, hoursAgo, issue, pr, snapshot } from "../test/helpers.ts";
 import { fmt } from "./ledger.ts";
 import {
+  applyPlanActions,
   nextUnplannedEpic,
   PlanIssuesSchema,
   parseDirectionCritical,
@@ -104,7 +105,7 @@ describe("phaseActions", () => {
     expect(nextUnplannedEpic([next])).toBeNull();
     expect(phaseActions(snapshot({ epics: [next], issues: [] }))).toEqual([]);
   });
-  it("applies an approved plan once", () => {
+  it("leaves an approved plan to applyPlanActions", () => {
     const approved = epic({
       number: 200,
       phase: 2,
@@ -112,7 +113,7 @@ describe("phaseActions", () => {
       status: "Backlog",
     });
     expect(
-      phaseActions(
+      applyPlanActions(
         snapshot({
           epics: [approved],
           issues: [issue({ number: 200, labels: ["epic", "phase:2", "plan-approved"] })],
@@ -124,7 +125,91 @@ describe("phaseActions", () => {
       labels: ["epic", "phase:2", "plan-approved"],
       comments: [comment(fmt.planApplied("mac-a"))],
     });
-    expect(phaseActions(snapshot({ epics: [approved], issues: [applied] }))).toEqual([]);
+    expect(applyPlanActions(snapshot({ epics: [approved], issues: [applied] }))).toEqual([]);
+    // phaseActions never offers anything else for an approved epic still waiting on its plan.
+    expect(
+      phaseActions(
+        snapshot({
+          epics: [approved],
+          issues: [issue({ number: 200, labels: ["epic", "phase:2", "plan-approved"] })],
+        }),
+      ),
+    ).toEqual([]);
+  });
+});
+
+describe("applyPlanActions", () => {
+  const approved = epic({
+    number: 200,
+    phase: 9,
+    labels: ["epic", "phase:9", "plan-approved", "needs-owner"],
+    status: "In Review",
+  });
+  const epicIssue = issue({ number: 200, labels: ["epic", "phase:9", "plan-approved"] });
+  const planPr = (over = {}) =>
+    pr({
+      number: 279,
+      title: "docs(plan): phase 09 plan (#200)",
+      body: "Refs #200",
+      issue: null,
+      ...over,
+    });
+  const run = (prs: ReturnType<typeof pr>[], issues = [epicIssue]) =>
+    applyPlanActions(snapshot({ epics: [approved], issues, prs }));
+
+  it("merges the plan PR and applies the plan in the same tick when its checks are green", () => {
+    expect(run([planPr()])).toEqual([
+      { type: "merge_plan", epic: 200, pr: 279 },
+      { type: "apply_plan", epic: 200 },
+    ]);
+  });
+  it("merges a plan PR on a repository with no CI at all", () => {
+    expect(run([planPr({ checks: "none" })])[0]).toEqual({
+      type: "merge_plan",
+      epic: 200,
+      pr: 279,
+    });
+  });
+  it("waits while the plan PR's checks are pending", () => {
+    expect(run([planPr({ checks: "pending" })])).toEqual([]);
+  });
+  it("reports a red plan PR on the epic once per head commit", () => {
+    const red = planPr({ checks: "failure" });
+    expect(run([red])).toEqual([
+      { type: "plan_pr_stuck", epic: 200, pr: 279, sha: red.headSha, reason: "checks failed" },
+    ]);
+    const reported = issue({
+      ...epicIssue,
+      comments: [comment(fmt.planPrStuck("mac-a", 279, red.headSha, "checks failed"))],
+    });
+    expect(run([red], [reported])).toEqual([]);
+    // A new push is a new chance, and a new report if it is red too.
+    expect(run([planPr({ checks: "failure", headSha: "f".repeat(40) })], [reported])).toHaveLength(
+      1,
+    );
+  });
+  it("reports a plan PR that conflicts with main", () => {
+    expect(run([planPr({ mergeable: "CONFLICTING" })])[0]).toMatchObject({
+      type: "plan_pr_stuck",
+      reason: "conflicts with main",
+    });
+  });
+  it("applies straight away when no plan PR is open, as when it was merged by hand", () => {
+    expect(run([pr({ number: 300, issue: 201 })])).toEqual([{ type: "apply_plan", epic: 200 }]);
+  });
+  it("ignores another epic's plan PR", () => {
+    expect(run([planPr({ title: "docs(plan): phase 10 plan (#201)" })])).toEqual([
+      { type: "apply_plan", epic: 200 },
+    ]);
+  });
+  it("does nothing once the plan is applied or while the epic is claimed", () => {
+    const applied = issue({ ...epicIssue, comments: [comment(fmt.planApplied("mac-a"))] });
+    expect(run([planPr()], [applied])).toEqual([]);
+    const claimed = issue({
+      ...epicIssue,
+      comments: [comment(fmt.claimed("mac-a", hoursAgo(1), "planner", 1))],
+    });
+    expect(run([planPr()], [claimed])).toEqual([]);
   });
 });
 
diff --git a/src/phase.ts b/src/phase.ts
index e4c91ec..c971587 100644
--- a/src/phase.ts
+++ b/src/phase.ts
@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { openClaim, planApplied } from "./ledger.ts";
-import type { Action, Epic, Issue, Snapshot } from "./types.ts";
+import { openClaim, planApplied, planPrStuckReported } from "./ledger.ts";
+import type { Action, Epic, Issue, PullRequest, Snapshot } from "./types.ts";
 
 export const PlanIssuesSchema = z.object({
   epic: z.number().int(),
@@ -112,20 +112,84 @@ export function nextUnplannedEpic(epics: Epic[]): Epic | null {
   );
 }
 
-export function phaseActions(s: Snapshot): Action[] {
+/** An epic the owner approved whose plan has not been turned into task issues yet. */
+export function planUnapplied(e: Epic, issues: Issue[]): boolean {
+  const ei = epicIssue(e, issues);
+  return (
+    e.state === "OPEN" && e.labels.includes("plan-approved") && !!ei && !planApplied(ei.comments)
+  );
+}
+
+/**
+ * The open PR the planner opened for this epic, by the title `planner.md` prescribes:
+ * `docs(plan): phase NN plan (#<epic>)`. The newest wins when a re-plan left two open.
+ */
+export function planPR(s: Snapshot, epic: number): PullRequest | null {
+  return (
+    s.prs
+      .filter((p) => p.title.startsWith("docs(plan):") && p.title.includes(`(#${epic})`))
+      .sort((a, b) => b.number - a.number)[0] ?? null
+  );
+}
+
+export type PlanPrState =
+  | { state: "ready" }
+  | { state: "pending" }
+  | { state: "stuck"; reason: string };
+
+/**
+ * Whether an approved plan's PR can be merged now. The owner's approval is the review, so only
+ * GitHub's own verdicts gate it: green or absent checks merge, running checks wait a tick, and red
+ * checks or a conflict need the owner.
+ */
+export function planPrState(pr: PullRequest): PlanPrState {
+  if (pr.mergeable === "CONFLICTING") return { state: "stuck", reason: "conflicts with main" };
+  if (pr.checks === "failure") return { state: "stuck", reason: "checks failed" };
+  if (pr.checks === "pending") return { state: "pending" };
+  return { state: "ready" };
+}
+
+/**
+ * Approved plans: merge the plan PR if one is open, then create the tasks. These cost no session,
+ * so `plan()` runs them ahead of the pick — an approved plan once waited behind every review and
+ * validation that could be claimed, and the owner's approval did nothing visible for an hour.
+ */
+export function applyPlanActions(s: Snapshot): Action[] {
   const out: Action[] = [];
   for (const e of [...s.epics].sort((a, b) => a.phase - b.phase)) {
     const ei = epicIssue(e, s.issues);
-    if (ei && openClaim(ei.comments)) continue;
-    if (
-      e.state === "OPEN" &&
-      e.labels.includes("plan-approved") &&
-      ei &&
-      !planApplied(ei.comments)
-    ) {
+    if (!ei || openClaim(ei.comments) || !planUnapplied(e, s.issues)) continue;
+    const p = planPR(s, e.number);
+    if (!p) {
+      // Merged already, by hand or on an earlier tick; apply_plan reads the file from origin.
       out.push({ type: "apply_plan", epic: e.number });
       continue;
     }
+    const st = planPrState(p);
+    if (st.state === "ready")
+      out.push(
+        { type: "merge_plan", epic: e.number, pr: p.number },
+        { type: "apply_plan", epic: e.number },
+      );
+    else if (st.state === "stuck" && !planPrStuckReported(ei.comments, p.number, p.headSha))
+      out.push({
+        type: "plan_pr_stuck",
+        epic: e.number,
+        pr: p.number,
+        sha: p.headSha,
+        reason: st.reason,
+      });
+  }
+  return out;
+}
+
+export function phaseActions(s: Snapshot): Action[] {
+  const out: Action[] = [];
+  for (const e of [...s.epics].sort((a, b) => a.phase - b.phase)) {
+    const ei = epicIssue(e, s.issues);
+    if (ei && openClaim(ei.comments)) continue;
+    // applyPlanActions owns an approved epic until its plan is applied.
+    if (planUnapplied(e, s.issues)) continue;
     if (
       e.state === "OPEN" &&
       e.status !== "In Review" &&
diff --git a/src/state-file.ts b/src/state-file.ts
index a2ed29a..6315baa 100644
--- a/src/state-file.ts
+++ b/src/state-file.ts
@@ -150,6 +150,8 @@ export const OwnerItemSchema = z.object({
   since: z.string().nullable().default(null),
   /** The phase review issue paired with this epic; set only when it offers `sign_off`. */
   review: z.number().int().nullable().default(null),
+  /** An approved plan's PR that cannot merge without the owner (red checks or a conflict). */
+  planPr: z.number().int().nullable().default(null),
 });
 export type OwnerItem = z.infer<typeof OwnerItemSchema>;
 
diff --git a/src/state.test.ts b/src/state.test.ts
index 1868b0a..24b9fff 100644
--- a/src/state.test.ts
+++ b/src/state.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { comment, hoursAgo, issue, pr, snapshot } from "../test/helpers.ts";
+import { comment, epic, hoursAgo, issue, pr, snapshot } from "../test/helpers.ts";
 import { fmt } from "./ledger.ts";
 import { defaultRepoConfig } from "./repo-config.ts";
 import { plan } from "./state.ts";
@@ -20,6 +20,25 @@ describe("plan", () => {
     expect(actions).toHaveLength(1);
     expect(actions[0]?.type).toBe("resume");
   });
+  it("applies an approved plan before claiming a session, not after", () => {
+    // Applying costs no session, so it must not wait behind a review that runs for 20 minutes.
+    const approved = epic({
+      number: 200,
+      phase: 2,
+      labels: ["epic", "phase:2", "plan-approved", "needs-owner"],
+      status: "In Review",
+    });
+    const actions = plan(
+      snapshot({
+        epics: [approved],
+        issues: [
+          issue({ number: 200, labels: ["epic", "phase:2", "plan-approved"] }),
+          issue({ number: 2 }),
+        ],
+      }),
+    );
+    expect(actions.map((a) => a.type)).toEqual(["apply_plan", "claim"]);
+  });
   it("emits one claim for the best candidate", () => {
     const actions = plan(
       snapshot({
diff --git a/src/state.ts b/src/state.ts
index e34ef1e..233f620 100644
--- a/src/state.ts
+++ b/src/state.ts
@@ -1,7 +1,7 @@
 import { ciActions } from "./ci.ts";
 import { reclaimActions, resumeAction } from "./claim.ts";
 import { blockActions, mergeActions, skipValidatorActions } from "./merge.ts";
-import { phaseActions } from "./phase.ts";
+import { applyPlanActions, phaseActions } from "./phase.ts";
 import { type Kind, pick } from "./pick.ts";
 import { defaultRepoConfig, type RepoConfig } from "./repo-config.ts";
 import type { Action, Role, Snapshot } from "./types.ts";
@@ -22,6 +22,9 @@ export function plan(s: Snapshot, repo: RepoConfig = defaultRepoConfig()): Actio
     ...skipValidatorActions(s, repo),
     ...reclaimActions(s, repo.limits.staleHours),
     ...blockActions(s, repo),
+    // Ahead of the pick: merging and applying an approved plan starts no session, and the claim
+    // after it would otherwise end the tick for the length of a review or a build.
+    ...applyPlanActions(s),
   ];
   const c = pick(s, repo);
   if (c)
diff --git a/src/types.ts b/src/types.ts
index 657b28f..b3632eb 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -85,4 +85,8 @@ export type Action =
   | { type: "phase_close"; epic: number }
   | { type: "plan"; epic: number }
   | { type: "apply_plan"; epic: number }
+  /** Squash-merge an approved epic's plan PR so the apply_plan after it finds the plan file. */
+  | { type: "merge_plan"; epic: number; pr: number }
+  /** Tell the owner, once per head commit, that an approved plan's PR cannot merge. */
+  | { type: "plan_pr_stuck"; epic: number; pr: number; sha: string; reason: string }
   | { type: "idle"; reason: string };
diff --git a/src/waiting.test.ts b/src/waiting.test.ts
index fb009f6..1da46ff 100644
--- a/src/waiting.test.ts
+++ b/src/waiting.test.ts
@@ -122,6 +122,7 @@ describe("describeWaiting", () => {
     const e12 = issue({
       number: 12,
       labels: ["epic", "phase:0", "plan-approved", "needs-owner"],
+      comments: [comment("plan applied by foreman@mac-a")],
     });
     const b = issue({
       number: 5,
@@ -151,6 +152,25 @@ describe("describeWaiting", () => {
       "#5 blocked: migration conflicts",
     ]);
   });
+  it("an approved plan waits on its plan PR, and on the owner only when the PR is stuck", () => {
+    const approved = epic({
+      number: 12,
+      phase: 0,
+      labels: ["epic", "phase:0", "plan-approved", "needs-owner"],
+    });
+    const s = (checks: "pending" | "failure") =>
+      snapshot({
+        issues: [issue({ number: 12, labels: approved.labels })],
+        epics: [approved],
+        prs: [pr({ number: 279, title: "docs(plan): phase 00 plan (#12)", issue: null, checks })],
+      });
+    expect(describeWaiting(s("pending"), base).map((x) => [x.kind, x.detail])).toEqual([
+      ["ci", "epic #12 plan PR #279 merges when its checks pass"],
+    ]);
+    expect(describeWaiting(s("failure"), base).map((x) => [x.kind, x.detail])).toEqual([
+      ["human", "epic #12 plan PR #279 cannot merge: checks failed"],
+    ]);
+  });
   it("human: a non-epic needs-owner or decision issue, with its title", () => {
     const s = snapshot({
       issues: [
diff --git a/src/waiting.ts b/src/waiting.ts
index 51a085f..2e1a3f8 100644
--- a/src/waiting.ts
+++ b/src/waiting.ts
@@ -1,6 +1,6 @@
 import { parentEpicOf, parseDependsOn } from "./github.ts";
 import { fixRound, openClaim } from "./ledger.ts";
-import { buildingEpic, planAwaitingOwner } from "./phase.ts";
+import { buildingEpic, planAwaitingOwner, planPR, planPrState, planUnapplied } from "./phase.ts";
 import { heldPhases, issuePhase } from "./pick.ts";
 import { defaultRepoConfig, type RepoConfig } from "./repo-config.ts";
 import { WAIT_KINDS, type WaitItem } from "./state-file.ts";
@@ -76,6 +76,27 @@ export function describeWaiting(
   for (const e of [...s.epics].sort((a, b) => a.phase - b.phase)) {
     if (e.state !== "OPEN") continue;
     const ei = byNumber.get(e.number);
+    // An approved plan waits on its PR, not on the owner — unless that PR cannot merge. With no
+    // plan PR open, or a green one, the next tick applies it and nothing is waiting.
+    if (planUnapplied(e, s.issues)) {
+      const p = planPR(s, e.number);
+      const st = p ? planPrState(p) : null;
+      if (p && st?.state === "stuck")
+        out.push({
+          kind: "human",
+          subject: `epic #${e.number}`,
+          detail: `epic #${e.number} plan PR #${p.number} cannot merge: ${st.reason}`,
+          since: p.updatedAt,
+        });
+      else if (p && st?.state === "pending")
+        out.push({
+          kind: "ci",
+          subject: `epic #${e.number}`,
+          detail: `epic #${e.number} plan PR #${p.number} merges when its checks pass`,
+          since: p.updatedAt,
+        });
+      continue;
+    }
     // A drafted plan and a closed phase both park the epic on `needs-owner`; `plan-approved`
     // is what tells them apart, and the plan case also holds every other epic.
     if (e.labels.includes("needs-owner"))
diff --git a/src/web.html b/src/web.html
index 633c3b0..47c7473 100644
--- a/src/web.html
+++ b/src/web.html
@@ -572,7 +572,7 @@ <h2>${link("issues", c.issue)} · ${esc(c.title)}</h2>
   // mis-click here closes a phase or starts a $5 planning session.
   const OWNER = {
     sign_off:       { label: "Sign off",       cls: "signoff", ask: (n) => `Sign off #${n}?\n\nAdds signed-off, removes needs-owner, and closes the epic.` },
-    approve_plan:   { label: "Approve plan",   cls: "approve", ask: (n) => `Approve the plan on #${n}?\n\nAdds plan-approved. The foreman then creates the task issues and starts building.` },
+    approve_plan:   { label: "Approve plan",   cls: "approve", ask: (n) => `Approve the plan on #${n}?\n\nAdds plan-approved. The foreman then merges the plan PR, creates the task issues and starts building.` },
     start_planning: { label: "Start planning", cls: "plan",    ask: (n) => `Start planning #${n}?\n\nAdds agent-ready. A planner session costs roughly $5.` },
     pause:          { label: "Pause",          cls: "",        ask: (n) => `Pause #${n}?\n\nAdds foreman:pause. No new claims under this phase on any Mac.` },
     unpause:        { label: "Resume",         cls: "",        ask: (n) => `Resume #${n}?\n\nRemoves foreman:pause.` },
@@ -602,6 +602,9 @@ <h2>${link("issues", c.issue)} · ${esc(c.title)}</h2>
     const by = (action) => owner.filter((o) => o.actions.includes(action)).sort(oldestFirst);
     const row = (age, title, sub, acts) => `<div class="it">${age}<div><div class="t">${title}</div>${sub ? `<div class="s">${sub}</div>` : ""}</div><div class="acts">${acts}</div></div>`;
     const approve = by("approve_plan").map((o) => row(ageCell(o.since), `<span class="num">${link("issues", o.epic)}</span>${esc(o.title)}`, `plan drafted · ${link("issues", o.epic, "read the plan")}`, ownerButton(o.epic, "approve_plan")));
+    // An approved plan whose PR cannot merge (red checks, a conflict) has no button: the fix is on
+    // the PR, so the row links there.
+    const stuck = owner.filter((o) => o.planPr != null).sort(oldestFirst).map((o) => row(ageCell(o.since), `<span class="num">${link("issues", o.epic)}</span>${esc(o.title)}`, `<span>${esc(o.detail)}</span>`, repo ? `<a class="tag" href="${gh("pull", o.planPr)}" target="_blank" rel="noopener">Open PR ↗</a>` : ""));
     const signOff = by("sign_off").map((o) => {
       const p = phases.get(o.epic);
       const progress = p ? `<span class="mini"><span class="b"><i style="width:${p.tasksTotal ? Math.round((p.tasksDone / p.tasksTotal) * 100) : 0}%"></i></span>${p.tasksDone}/${p.tasksTotal} tasks</span><span>${usd(p.spendUsd)}</span>` : "";
@@ -614,10 +617,11 @@ <h2>${link("issues", c.issue)} · ${esc(c.title)}</h2>
       return row(ageCell(n.since), `<span class="num">${link("issues", n.issue)}</span>${esc(n.title)}`, `${tags(n)}${why ? `<span>${esc(why)}</span>` : ""}`, `<button type="button" data-unblock="${esc(n.issue)}">Unblock</button>`);
     });
     const answer = needs.filter((n) => !n.labels.includes("blocked")).map((n) => row(ageCell(n.since), `<span class="num">${link("issues", n.issue)}</span>${esc(n.title)}`, `${tags(n)}${n.phaseReview ? "<span>epic already closed</span>" : ""}`, repo ? `<a class="tag" href="${gh("issues", n.issue)}" target="_blank" rel="noopener">Open ↗</a>` : ""));
-    const counted = approve.length + signOff.length + blocked.length + answer.length;
+    const counted = approve.length + stuck.length + signOff.length + blocked.length + answer.length;
     $("needsMeta").textContent = counted ? `${counted} waiting on you · oldest first in each group` : "";
     const html = [
       group("Approve a plan", "var(--primary)", "the planner drafted these; building starts after approval", approve),
+      group("Fix a plan PR", "var(--bad)", "approved, but the plan PR cannot merge; fix it or merge it by hand", stuck),
       group("Sign off a phase", "var(--signoff)", "phase review is done; signing off closes the epic", signOff),
       group("Ready to plan", "var(--warn)", "not counted in the badge · a planner session costs about $5", plan),
       group("Unblock", "", "fix the cause first; Unblock moves it back to Ready", blocked),
diff --git a/src/web.test.ts b/src/web.test.ts
index fd38763..06d9ddd 100644
--- a/src/web.test.ts
+++ b/src/web.test.ts
@@ -92,6 +92,7 @@ describe("web server", () => {
         actions: ["sign_off", "pause"],
         since: null,
         review: null,
+        planPr: null,
       },
     ],
     needsYouItems: () => [