diff --git a/README.md b/README.md
index 1237d82..1140822 100644
--- a/README.md
+++ b/README.md
@@ -40,11 +40,13 @@ gh search issues --label agent-ready
 
 ## What this is
 
-You label a GitHub issue `agent-ready`. The daemon finds it, checks out a fresh git worktree, hands
-the issue to Claude Code running headless, runs the repository's own test suite against whatever
-Claude wrote, pushes a branch, and opens a **draft** PR that says what happened — including if the
-tests failed. A human reviews and merges (or doesn't). The daemon never pushes to `main`, never
-merges, and never touches an issue that isn't opted in.
+You label a GitHub issue `agent-ready`. The daemon finds it, checks out a fresh git worktree, and
+first has Claude Code produce a **plan** — posted as an issue comment, no edits made. A human reviews
+the plan and replies `implement` to approve it (or anything else, which sends it back for a
+revision). Only then does the daemon run the actual change, run the repository's own test suite
+against whatever Claude wrote, push a branch, and open a **draft** PR that says what happened —
+including if the tests failed. A human reviews and merges (or doesn't). The daemon never pushes to
+`main`, never merges, and never touches an issue that isn't opted in.
 
 **Use case:** a backlog of well-scoped, low-risk issues (bug fixes, small features, chores) across
 repositories you own, that you'd rather review as a diff than write yourself — worked on
@@ -98,7 +100,8 @@ sudo systemctl status coding-agent-loop.service # check status of process
 sudo journalctl -u coding-agent-loop # check system daemon logs (or at ~/.agent-loop/logs/)
 ```
 
-Label an issue `agent-ready` in one of the repositories you own, and the next poll picks it up.
+Label an issue `agent-ready` in one of the repositories you own. The next poll posts a plan as a
+comment on the issue; reply `implement` on that comment to have the daemon carry it out.
 
 ## CLI flags
 
@@ -125,9 +128,23 @@ An issue is worked only if **all** of these hold:
 - no previous run delivered a PR for it, and it is not currently backing off after a failure
   (`run.retry_backoff`)
 - no open pull request already closes it
+- the issue's comment history says it's this issue's turn to be worked (see below)
 
-Labels mirror the state (`agent-working` → `agent-done` / `agent-failed`), but the SQLite claim
-table is the source of truth — labels can be edited by humans mid-run, leases cannot.
+**The issue's own comments are what decide the phase**, not a label or a database column. Every
+comment the daemon posts is tagged with an invisible HTML marker, so it can tell its own narration
+apart from a human reply:
+
+- No plan comment yet → **plan**: post a plan, then stop.
+- A plan is posted and nothing from a human has followed it → **wait**: do nothing this poll. This
+  costs one `gh issue view` per poll, never a claim, a worktree, or a Claude run.
+- The newest human reply after the plan is exactly `implement` (trimmed, case-insensitive) →
+  **implement**: run the actual change.
+- The newest human reply after the plan is anything else → **plan**: treat it as feedback and post a
+  revised plan.
+
+Labels mirror this state (`agent-planned` while waiting on a reply, `agent-working` →
+`agent-done` / `agent-failed` around a run), but the SQLite claim table and the issue's own comments
+are the source of truth — labels can be edited by humans mid-run, leases and comment history cannot.
 
 Label edits are reconciled rather than fired blindly: the issue's current labels are read first, the
 edit is reduced to what actually changes, a status label the repository does not define yet is
@@ -142,24 +159,33 @@ flight at a time), controlled by `run.max_concurrent_repos`.
 ## Lifecycle of one issue
 
 1. **Discover** — `gh search issues --label <label> --state open` scoped to `github.owners`, minus
-   `exclude_repos`.
+   `exclude_repos`. The issue is fetched and its comments decide the phase (plan, wait, or
+   implement) before anything is claimed.
 2. **Claim** — an atomic SQLite insert with a lease (`run.lease`); losing the race means another
    worker already has it. The issue gets the `agent-working` label and a `runs` row.
 3. **Workspace** — the repo is cloned once (checkout-less) into `workspace.repos_root`, then a
    `git worktree` is added under `workspace.root` on a fresh `agent/issue-<n>` branch off the
-   default branch.
-4. **Run Claude** — `claude -p --output-format stream-json --permission-mode bypassPermissions`,
-   scoped to the worktree, with a system prompt that hands over the issue and forbids git/GitHub
-   mutation. The lease is renewed periodically while the run is in flight. The CLI's session ID is
-   recorded against the run and the issue as soon as it is announced — before any result, so a
-   killed or timed-out run still leaves one behind — and is queryable later via `GET /sessions`.
-5. **Verify** — the repository's own test command runs (auto-detected, or from `verify.commands`).
+   default branch. Both the plan and implement phases get this same worktree; the plan phase just
+   never writes to it.
+4. **Plan** (skipped once approved) — `claude -p --permission-mode plan` (`claude.plan_permission_mode`)
+   is handed the issue and told to produce a plan, not a change. Its final message is saved to SQLite
+   and posted as an issue comment naming the files and approach it would take. The issue gets the
+   `agent-planned` label and the run ends there — no commit, no verify, no push, no PR. Any human
+   reply that isn't exactly `implement` triggers another plan pass that revises it against that
+   feedback.
+5. **Run Claude** (once approved) — `claude -p --output-format stream-json --permission-mode
+   bypassPermissions`, scoped to the worktree, with a system prompt that hands over the issue and the
+   approved plan and forbids git/GitHub mutation. The lease is renewed periodically while the run is
+   in flight. The CLI's session ID is recorded against the run and the issue as soon as it is
+   announced — before any result, so a killed or timed-out run still leaves one behind — and is
+   queryable later via `GET /sessions`.
+6. **Verify** — the repository's own test command runs (auto-detected, or from `verify.commands`).
    A failing suite does **not** block the PR — it's a draft either way, and the failure is reported
    in the PR body so a human sees it immediately.
-6. **Deliver** — the remote is re-checked, then pushed; a draft PR is opened with `Closes #<n>`,
+7. **Deliver** — the remote is re-checked, then pushed; a draft PR is opened with `Closes #<n>`,
    verification result, model used, and cost; the issue is commented with the PR link;
-   `agent-working` is swapped for `agent-done` or `agent-failed`.
-7. **Cleanup** — the worktree is removed (kept on disk if `workspace.keep_failed` and the run
+   `agent-working` and `agent-planned` are swapped for `agent-done` or `agent-failed`.
+8. **Cleanup** — the worktree is removed (kept on disk if `workspace.keep_failed` and the run
    failed, for post-mortem). The claim is always released, on every exit path.
 
 Failures are retried indefinitely behind an exponential back-off: `run.retry_backoff` after the
@@ -186,6 +212,7 @@ Copy `config.example.json` and edit. Durations are Go duration strings (`"5m"`,
     "working_label": "agent-working",
     "done_label": "agent-done",
     "failed_label": "agent-failed",
+    "plan_label": "agent-planned",
     "owners": ["ableinc"],
     "exclude_repos": [],
     "search_limit": 50,
@@ -210,6 +237,7 @@ Copy `config.example.json` and edit. Durations are Go duration strings (`"5m"`,
   "claude": {
     "binary": "claude",
     "permission_mode": "bypassPermissions",
+    "plan_permission_mode": "plan",
     "extra_args": [],
     "usage_poll_interval": "15m",
     "usage_backoff": "15m",
@@ -238,6 +266,7 @@ Copy `config.example.json` and edit. Durations are Go duration strings (`"5m"`,
 | ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
 | `github.label`                                         | trigger label; **must not be empty**, or every open issue would match                                                              |
 | `github.working_label` / `done_label` / `failed_label` | status labels the daemon swaps `label` for                                                                                         |
+| `github.plan_label`                                    | label added while a posted plan awaits an `implement` reply, removed once the change is delivered                                  |
 | `github.owners`                                        | users/orgs to search; empty means every repo the `gh` token can see (a boot-time warning fires if left empty)                      |
 | `github.exclude_repos`                                 | `owner/name` repos to never touch, even if labelled                                                                                |
 | `github.search_limit`                                  | max issues fetched per discovery pass                                                                                              |
@@ -253,7 +282,8 @@ Copy `config.example.json` and edit. Durations are Go duration strings (`"5m"`,
 | `run.lease`                                            | how long a claim is held before it's considered abandoned; **must exceed `run.timeout`**, or a still-running claim could be stolen |
 | `run.verify_timeout`                                   | wall-clock limit for the test command                                                                                              |
 | `claude.binary`                                        | executable name/path for the Claude Code CLI                                                                                       |
-| `claude.permission_mode`                               | passed through as `--permission-mode`                                                                                              |
+| `claude.permission_mode`                               | passed through as `--permission-mode` for the implement run                                                                        |
+| `claude.plan_permission_mode`                          | passed through as `--permission-mode` for the read-only planning run                                                               |
 | `claude.usage_poll_interval` / `usage_backoff`         | advisory OAuth usage poll cadence and 429 backoff; **must be ≥ 1m**                                                                |
 | `claude.credentials_path`                              | where the CLI's OAuth token lives, read for the advisory usage snapshot                                                            |
 | `verify.auto_detect`                                   | try `Makefile` → `go.mod` → `package.json` → `Cargo.toml` → `pyproject.toml`, in that order                                        |
@@ -275,13 +305,13 @@ hardcoded in Go — this file is the only place to update one.
     {
       "id": "claude-opus-5",
       "alias": "opus",
-      "roles": ["implement"],
+      "roles": ["plan", "implement"],
       "priority": 1
     },
     {
       "id": "claude-sonnet-5",
       "alias": "sonnet",
-      "roles": ["implement"],
+      "roles": ["plan", "implement"],
       "priority": 2
     },
     {
@@ -297,14 +327,17 @@ hardcoded in Go — this file is the only place to update one.
 - `id` is the canonical model identifier, recorded in the `runs` table so history stays meaningful
   even if an alias's meaning shifts later.
 - `alias` is what's passed on the CLI.
-- `roles` — currently `implement` (does the work); `triage` is reserved for a future pre-pass.
+- `roles` — `plan` (writes the plan comment) and `implement` (does the work) each have their own
+  ladder, selected independently per phase; a registry needs at least one model serving each or the
+  loop refuses to start. `triage` is reserved for a future pre-pass and currently unused.
 - `priority` — lower runs first within a role. The head of the priority-ordered list for a role
   becomes `--model`; the rest become `--fallback-model a,b,...`.
 - A model that fails or hits a limit is put on a 30-minute cooldown, so the next attempt starts
-  lower on the ladder. Retries also start one rung lower than the attempt before them, wrapping
-  back to the head once the ladder has been walked, since retries are unbounded. If every
-  candidate is cooled down, the full ladder is used anyway — refusing to run at all is worse; the
-  usage gate is the real brake.
+  lower on the ladder. Retries also start one rung lower for every failure recorded on the issue,
+  wrapping back to the head once the ladder has been walked, since retries are unbounded — a
+  successful plan run does not demote the implement run that follows it, since it isn't a failure.
+  If every candidate is cooled down, the full ladder is used anyway — refusing to run at all is
+  worse; the usage gate is the real brake.
 
 The content above is also **embedded in the binary** (`internal/models/default.json`) as of build
 time, so a `coding-agent-loop` binary copied to a host on its own — no repo checkout, no
diff --git a/cmd/agent.go b/cmd/agent.go
index fb6b0a5..ada4d84 100644
--- a/cmd/agent.go
+++ b/cmd/agent.go
@@ -272,15 +272,19 @@ func bootCheck(cfg config.Config, registry *models.Registry, ghClient *gh.Client
 		return fmt.Errorf("start-up checks failed:\n  - %s", strings.Join(problems, "\n  - "))
 	}
 
-	ladder := registry.Ladder(models.RoleImplement, nil)
-	refs := make([]string, 0, len(ladder))
-	for _, m := range ladder {
-		refs = append(refs, m.ID)
+	ladderRefs := func(role string) string {
+		ladder := registry.Ladder(role, nil)
+		refs := make([]string, 0, len(ladder))
+		for _, m := range ladder {
+			refs = append(refs, m.ID)
+		}
+		return strings.Join(refs, " > ")
 	}
 	log.Info("start-up checks passed",
 		"label", cfg.GitHub.Label,
 		"owners", strings.Join(cfg.GitHub.Owners, ","),
-		"implement_ladder", strings.Join(refs, " > "),
+		"plan_ladder", ladderRefs(models.RolePlan),
+		"implement_ladder", ladderRefs(models.RoleImplement),
 		"store", cfg.Store.Path)
 	return nil
 }
diff --git a/config.example.json b/config.example.json
index 2cb1eb8..f0cc928 100644
--- a/config.example.json
+++ b/config.example.json
@@ -4,6 +4,7 @@
     "working_label": "agent-working",
     "done_label": "agent-done",
     "failed_label": "agent-failed",
+    "plan_label": "agent-planned",
     "owners": ["ableinc"],
     "exclude_repos": [],
     "search_limit": 50,
@@ -28,6 +29,7 @@
   "claude": {
     "binary": "claude",
     "permission_mode": "bypassPermissions",
+    "plan_permission_mode": "plan",
     "extra_args": [],
     "usage_poll_interval": "15m",
     "usage_backoff": "15m",
diff --git a/internal/config/config.go b/internal/config/config.go
index f1e9e1b..45f328b 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -53,10 +53,12 @@ type Config struct {
 type GitHubConfig struct {
 	// Label is the opt-in label an issue must carry to be picked up.
 	Label string `json:"label"`
-	// WorkingLabel/DoneLabel/FailedLabel mirror run state onto the issue.
+	// WorkingLabel/DoneLabel/FailedLabel/PlanLabel mirror run state onto the issue.
 	WorkingLabel string `json:"working_label"`
 	DoneLabel    string `json:"done_label"`
 	FailedLabel  string `json:"failed_label"`
+	// PlanLabel marks an issue that has a plan comment awaiting human approval.
+	PlanLabel string `json:"plan_label"`
 	// Owners scopes discovery. Empty means "every repo the token can see",
 	// which is broad — prefer naming the orgs/users you actually want.
 	Owners []string `json:"owners"`
@@ -106,6 +108,9 @@ type ClaudeConfig struct {
 	Binary         string   `json:"binary"`
 	PermissionMode string   `json:"permission_mode"`
 	ExtraArgs      []string `json:"extra_args"`
+	// PlanPermissionMode governs the read-only planning run, distinct from the
+	// implement run's PermissionMode.
+	PlanPermissionMode string `json:"plan_permission_mode"`
 	// UsagePollInterval throttles the OAuth usage endpoint, which rate-limits
 	// hard. Do not lower this below a few minutes.
 	UsagePollInterval Duration `json:"usage_poll_interval"`
@@ -151,6 +156,7 @@ func Default() Config {
 			WorkingLabel: "agent-working",
 			DoneLabel:    "agent-done",
 			FailedLabel:  "agent-failed",
+			PlanLabel:    "agent-planned",
 			SearchLimit:  50,
 			PollInterval: Duration(5 * time.Minute),
 			Binary:       "gh",
@@ -171,12 +177,13 @@ func Default() Config {
 			RetryBackoffMax:    Duration(24 * time.Hour),
 		},
 		Claude: ClaudeConfig{
-			Binary:            "claude",
-			PermissionMode:    "bypassPermissions",
-			UsagePollInterval: Duration(15 * time.Minute),
-			UsageBackoff:      Duration(15 * time.Minute),
-			CredentialsPath:   "~/.claude/.credentials.json",
-			UsageCachePath:    "~/.agent-loop/usage-cache.json",
+			Binary:             "claude",
+			PermissionMode:     "bypassPermissions",
+			PlanPermissionMode: "plan",
+			UsagePollInterval:  Duration(15 * time.Minute),
+			UsageBackoff:       Duration(15 * time.Minute),
+			CredentialsPath:    "~/.claude/.credentials.json",
+			UsageCachePath:     "~/.agent-loop/usage-cache.json",
 		},
 		Verify:  VerifyConfig{AutoDetect: true, Commands: map[string]string{}},
 		Server:  ServerConfig{Addr: "127.0.0.1:8787"},
diff --git a/internal/discord/notifier.go b/internal/discord/notifier.go
index 23f9711..6eb4f17 100644
--- a/internal/discord/notifier.go
+++ b/internal/discord/notifier.go
@@ -271,6 +271,25 @@ func (n *Notifier) PROpened(r RunRef, prURL string, res *claude.Result, v verify
 	})
 }
 
+// PlanPosted reports that a plan was posted for human review and the run is
+// now waiting on an "implement" reply.
+func (n *Notifier) PlanPosted(r RunRef, res *claude.Result, elapsed time.Duration) {
+	model, cost := "", 0.0
+	if res != nil {
+		model, cost = res.PrimaryModel(), res.TotalCostUSD
+	}
+	n.post(embed{
+		Title:       r.title("Plan posted, awaiting approval"),
+		Description: "Reply `implement` on the issue to start the change.",
+		Color:       colorBlurple,
+		Fields: append(r.fields(),
+			embedField{Name: "Model", Value: orNone(model), Inline: true},
+			embedField{Name: "Cost", Value: money(cost), Inline: true},
+			embedField{Name: "Duration", Value: humanDuration(elapsed), Inline: true},
+		),
+	})
+}
+
 // RunFailed reports a failed run and when it will be tried again. Retries are
 // unbounded, so "when" is the useful number, not "how many are left".
 func (n *Notifier) RunFailed(r RunRef, cause string, nextAttempt time.Time) {
diff --git a/internal/models/default.json b/internal/models/default.json
index 2b51407..a0d4f3e 100644
--- a/internal/models/default.json
+++ b/internal/models/default.json
@@ -1,7 +1,7 @@
 {
   "models": [
-    { "id": "claude-opus-5",    "alias": "opus",   "roles": ["implement"], "priority": 1 },
-    { "id": "claude-sonnet-5",  "alias": "sonnet", "roles": ["implement"], "priority": 2 },
-    { "id": "claude-haiku-4-5", "alias": "haiku",  "roles": ["triage"],    "priority": 1 }
+    { "id": "claude-opus-5",    "alias": "opus",   "roles": ["plan", "implement"], "priority": 1 },
+    { "id": "claude-sonnet-5",  "alias": "sonnet", "roles": ["plan", "implement"], "priority": 2 },
+    { "id": "claude-haiku-4-5", "alias": "haiku",  "roles": ["triage"],            "priority": 1 }
   ]
 }
diff --git a/internal/models/registry.go b/internal/models/registry.go
index 8e24b9e..1894aa1 100644
--- a/internal/models/registry.go
+++ b/internal/models/registry.go
@@ -26,6 +26,7 @@ var defaultModelsJSON []byte
 // Roles a model may be used for.
 const (
 	RoleTriage    = "triage"
+	RolePlan      = "plan"
 	RoleImplement = "implement"
 )
 
@@ -109,16 +110,19 @@ func (r *Registry) Validate() error {
 		seen[m.ID] = true
 		for _, role := range m.Roles {
 			switch strings.ToLower(role) {
-			case RoleTriage, RoleImplement:
+			case RoleTriage, RolePlan, RoleImplement:
 			default:
-				return fmt.Errorf("models[%d] (%s): unknown role %q (want %q or %q)",
-					i, m.ID, role, RoleTriage, RoleImplement)
+				return fmt.Errorf("models[%d] (%s): unknown role %q (want %q, %q, or %q)",
+					i, m.ID, role, RoleTriage, RolePlan, RoleImplement)
 			}
 		}
 	}
 	if len(r.forRole(RoleImplement)) == 0 {
 		return fmt.Errorf("no model serves the %q role, so no work could ever run", RoleImplement)
 	}
+	if len(r.forRole(RolePlan)) == 0 {
+		return fmt.Errorf("no model serves the %q role, so no plan could ever be produced", RolePlan)
+	}
 	return nil
 }
 
diff --git a/internal/models/registry_test.go b/internal/models/registry_test.go
index b093157..9306c39 100644
--- a/internal/models/registry_test.go
+++ b/internal/models/registry_test.go
@@ -16,8 +16,8 @@ func writeModels(t *testing.T, body string) string {
 }
 
 const goodModels = `{"models":[
-	{"id":"claude-opus-5","alias":"opus","roles":["implement"],"priority":1},
-	{"id":"claude-sonnet-5","alias":"sonnet","roles":["implement"],"priority":2},
+	{"id":"claude-opus-5","alias":"opus","roles":["plan","implement"],"priority":1},
+	{"id":"claude-sonnet-5","alias":"sonnet","roles":["plan","implement"],"priority":2},
 	{"id":"claude-haiku-4-5","alias":"haiku","roles":["triage"],"priority":1}
 ]}`
 
@@ -49,6 +49,11 @@ func TestLoadAndLadderOrder(t *testing.T) {
 	if triage := reg.Ladder(RoleTriage, nil); len(triage) != 1 || triage[0].ID != "claude-haiku-4-5" {
 		t.Fatalf("triage ladder wrong: %+v", triage)
 	}
+
+	plan := reg.Ladder(RolePlan, nil)
+	if len(plan) != 2 || plan[0].ID != "claude-opus-5" || plan[1].ID != "claude-sonnet-5" {
+		t.Fatalf("plan ladder wrong: %+v", plan)
+	}
 }
 
 func TestLadderSkipsCooledDownModels(t *testing.T) {
@@ -138,7 +143,7 @@ func TestLoadFallsBackToEmbeddedDefaultWhenFileMissing(t *testing.T) {
 // A file present at path is the whole point of letting an operator customize
 // the ladder without rebuilding — it must win over the embedded default.
 func TestLoadPrefersFileOverEmbeddedDefault(t *testing.T) {
-	reg, err := Load(writeModels(t, `{"models":[{"id":"custom-model","alias":"custom","roles":["implement"],"priority":1}]}`))
+	reg, err := Load(writeModels(t, `{"models":[{"id":"custom-model","alias":"custom","roles":["plan","implement"],"priority":1}]}`))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -155,6 +160,7 @@ func TestValidationRejectsBadRegistries(t *testing.T) {
 		"duplicate id":      `{"models":[{"id":"a","roles":["implement"]},{"id":"a","roles":["implement"]}]}`,
 		"unknown role":      `{"models":[{"id":"a","roles":["deploy"]}]}`,
 		"no implement role": `{"models":[{"id":"a","roles":["triage"]}]}`,
+		"no plan role":      `{"models":[{"id":"a","roles":["implement"]}]}`,
 		"unknown field":     `{"models":[{"id":"a"}],"extra":true}`,
 	}
 	for name, body := range tests {
diff --git a/internal/orchestrator/loop.go b/internal/orchestrator/loop.go
index 27e41e3..fbcec64 100644
--- a/internal/orchestrator/loop.go
+++ b/internal/orchestrator/loop.go
@@ -246,7 +246,12 @@ func (o *Orchestrator) releaseRepo(repo string) {
 	o.mu.Unlock()
 }
 
-// eligible applies the cheap filters before anything is claimed.
+// eligible applies the cheap filters before anything is claimed, then decides
+// the phase from the issue's current comments. An issue waiting on a human
+// (phaseWait) is reported as not eligible, so it costs a fetch but never a
+// claim, a worktree, or a Claude run. execute decides the phase again for
+// itself from a fresh fetch before acting, so the phase decided here is not
+// carried any further.
 func (o *Orchestrator) eligible(ctx context.Context, repo string, issue int) (bool, string) {
 	if o.opts.Config.GitHub.Excluded(repo) {
 		return false, "repo excluded by config"
@@ -279,6 +284,15 @@ func (o *Orchestrator) eligible(ctx context.Context, repo string, issue int) (bo
 		return false, fmt.Sprintf("backing off after %d failed attempt(s), retrying at %s",
 			hist.Failures, next.Format(time.RFC3339))
 	}
+
+	view, err := o.opts.GH.ViewIssue(ctx, repo, issue)
+	if err != nil {
+		o.log.Error("issue view failed", "repo", repo, "issue", issue, "error", err)
+		return false, "issue fetch failed"
+	}
+	if phase, reason := decidePhase(view); phase == phaseWait {
+		return false, reason
+	}
 	return true, ""
 }
 
@@ -433,6 +447,13 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 		return errSkip{"an open pull request already covers this issue: " + existing}
 	}
 
+	// Discovery's phase decision may be stale by the time execution starts;
+	// decide again from the issue fetched just above.
+	phase, phaseReason := decidePhase(issue)
+	if phase == phaseWait {
+		return errSkip{"waiting for approval: " + phaseReason}
+	}
+
 	meta, err := o.repoMetadata(ctx, cand.repo)
 	if err != nil {
 		return fmt.Errorf("repo metadata: %w", err)
@@ -452,19 +473,30 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 	}
 	o.event(ctx, runID, "worktree", worktree)
 
-	// Pick the model.
+	// Pick the model. Plan and implement draw from separate ladders.
+	role := models.RoleImplement
+	if phase == phasePlan {
+		role = models.RolePlan
+	}
 	cooled, err := o.opts.Store.CooledDownModels(ctx)
 	if err != nil {
 		log.Warn("cooldown lookup failed, using full ladder", "error", err)
 		cooled = nil
 	}
-	ladder := o.opts.Registry.Ladder(models.RoleImplement, cooled)
+	ladder := o.opts.Registry.Ladder(role, cooled)
 	// On a retry, start one rung lower: the previous attempt already showed the
 	// model above it did not get there. Retries are unbounded, so this wraps
 	// rather than pinning the issue to the weakest model forever — by the time
 	// the ladder has been walked once, the top of it is worth another try.
+	//
+	// This keys off failures, not the attempt number: a successful plan run
+	// also advances the attempt counter, and demoting the implement run that
+	// follows it for that reason would be wrong.
 	if len(ladder) > 0 {
-		if drop := (attempt - 1) % len(ladder); drop > 0 {
+		hist, err := o.opts.Store.IssueHistory(ctx, cand.repo, cand.number)
+		if err != nil {
+			log.Warn("issue history lookup failed, using full ladder", "error", err)
+		} else if drop := hist.Failures % len(ladder); drop > 0 {
 			ladder = ladder[drop:]
 		}
 	}
@@ -480,12 +512,36 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 		log.Warn("status update failed", "error", err)
 	}
 	// The outcome labels of an earlier attempt are stale the moment this one
-	// starts, so they go in the same edit that marks the issue as working.
-	o.setLabels(ctx, log, cand, runID,
-		[]string{cfg.GitHub.WorkingLabel},
-		[]string{cfg.GitHub.DoneLabel, cfg.GitHub.FailedLabel})
+	// starts, so they go in the same edit that marks the issue as working. A
+	// plan run additionally clears the previous plan's label: the old plan is
+	// stale the moment a re-plan starts.
+	removeLabels := []string{cfg.GitHub.DoneLabel, cfg.GitHub.FailedLabel}
+	if phase == phasePlan {
+		removeLabels = append(removeLabels, cfg.GitHub.PlanLabel)
+	}
+	o.setLabels(ctx, log, cand, runID, []string{cfg.GitHub.WorkingLabel}, removeLabels)
 	o.event(ctx, runID, "model", fmt.Sprintf("%s (fallbacks: %s)", head.ID, orNone(fallbacks)))
-	log.Info("starting claude", "model", head.ID, "branch", branch, "attempt", attempt)
+	log.Info("starting claude", "phase", phase, "model", head.ID, "branch", branch, "attempt", attempt)
+
+	var prompt, sysPrompt, permissionMode string
+	var previousPlan string
+	if phase == phasePlan {
+		previousPlan, err = o.opts.Store.LatestPlan(ctx, cand.repo, cand.number)
+		if err != nil {
+			log.Warn("could not read previous plan, planning from scratch", "error", err)
+		}
+		prompt = planTaskPrompt(cand.repo, issue, previousPlan)
+		sysPrompt = planSystemPrompt(cand.repo, worktree)
+		permissionMode = cfg.Claude.PlanPermissionMode
+	} else {
+		plan, err := o.opts.Store.LatestPlan(ctx, cand.repo, cand.number)
+		if err != nil {
+			log.Warn("could not read approved plan, implementing without it", "error", err)
+		}
+		prompt = implementTaskPrompt(cand.repo, issue, plan)
+		sysPrompt = systemPrompt(cand.repo, branch, worktree)
+		permissionMode = cfg.Claude.PermissionMode
+	}
 
 	// The CLI announces its session ID on the first stream event, long before
 	// the run produces a result. Capturing it there means a run that is killed
@@ -494,11 +550,11 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 	claudeStarted := time.Now()
 	result, runErr := o.opts.Runner.Run(ctx, claude.Options{
 		Binary:         cfg.Claude.Binary,
-		Prompt:         taskPrompt(cand.repo, issue),
-		SystemPrompt:   systemPrompt(cand.repo, branch, worktree),
+		Prompt:         prompt,
+		SystemPrompt:   sysPrompt,
 		Model:          head.Ref(),
 		Fallbacks:      fallbacks,
-		PermissionMode: cfg.Claude.PermissionMode,
+		PermissionMode: permissionMode,
 		WorkDir:        worktree,
 		ExtraArgs:      cfg.Claude.ExtraArgs,
 		LogPath:        logPath,
@@ -519,10 +575,10 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 	})
 
 	// Record spend even on failure: the tokens were burned either way.
+	usedModel := head.ID
 	if result != nil {
-		usedModel := result.PrimaryModel()
-		if usedModel == "" {
-			usedModel = head.ID
+		if m := result.PrimaryModel(); m != "" {
+			usedModel = m
 		}
 		if err := o.opts.Store.RecordUsage(ctx, runID, usedModel, result.SessionID,
 			result.TotalCostUSD, result.TokensIn(), result.TokensOut(), result.NumTurns); err != nil {
@@ -563,6 +619,29 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 	}
 	o.opts.Discord.GateCleared()
 	o.event(ctx, runID, "claude_done", fmt.Sprintf("turns=%d cost=$%.4f", result.NumTurns, result.TotalCostUSD))
+
+	if phase == phasePlan {
+		if strings.TrimSpace(result.Result) == "" {
+			return fmt.Errorf("the plan run produced no plan")
+		}
+		if err := o.opts.Store.SavePlan(ctx, cand.repo, cand.number, runID, result.Result); err != nil {
+			log.Warn("could not save plan", "error", err)
+		}
+		if err := o.opts.GH.Comment(ctx, cand.repo, cand.number,
+			planComment(result.Result, runID, usedModel, result.TotalCostUSD)); err != nil {
+			log.Warn("could not comment on issue", "error", err)
+		}
+		o.setLabels(ctx, log, cand, runID,
+			[]string{cfg.GitHub.PlanLabel}, []string{cfg.GitHub.WorkingLabel})
+		if err := o.opts.Store.SetRunStatus(ctx, runID, store.StatusPlanned); err != nil {
+			log.Warn("status update failed", "error", err)
+		}
+		o.event(ctx, runID, "planned", fmt.Sprintf("turns=%d cost=$%.4f", result.NumTurns, result.TotalCostUSD))
+		o.opts.Discord.PlanPosted(ref, result, time.Since(claudeStarted))
+		o.cleanup(ctx, log, repoPath, worktree, true)
+		return nil
+	}
+
 	o.opts.Discord.ClaudeFinished(ref, result, time.Since(claudeStarted))
 
 	hasWork, err := o.opts.Git.HasWork(ctx, worktree, meta.defaultBranch)
@@ -630,7 +709,7 @@ func (o *Orchestrator) execute(ctx context.Context, log *slog.Logger, cand candi
 	}
 	o.setLabels(ctx, log, cand, runID,
 		[]string{cfg.GitHub.DoneLabel},
-		[]string{cfg.GitHub.WorkingLabel, cfg.GitHub.Label, cfg.GitHub.FailedLabel})
+		[]string{cfg.GitHub.WorkingLabel, cfg.GitHub.Label, cfg.GitHub.FailedLabel, cfg.GitHub.PlanLabel})
 
 	if err := o.opts.Store.SetRunStatus(ctx, runID, store.StatusPROpen); err != nil {
 		log.Warn("status update failed", "error", err)
diff --git a/internal/orchestrator/loop_test.go b/internal/orchestrator/loop_test.go
index 170b3b5..98cc739 100644
--- a/internal/orchestrator/loop_test.go
+++ b/internal/orchestrator/loop_test.go
@@ -178,6 +178,30 @@ func TestIssueComment(t *testing.T) {
 	if !strings.Contains(c, "pull/9") || !strings.Contains(c, "make test") {
 		t.Fatalf("issue comment missing detail:\n%s", c)
 	}
+	// Without the marker, decidePhase would read the harness's own comment
+	// back as human feedback and re-plan forever.
+	if !isAgentComment(c) {
+		t.Fatalf("issue comment must carry the agent marker:\n%s", c)
+	}
+}
+
+func TestFailureCommentCarriesTheAgentMarker(t *testing.T) {
+	c := failureComment("run-1", 1, "boom", time.Time{}, "agent-ready")
+	if !isAgentComment(c) {
+		t.Fatalf("failure comment must carry the agent marker:\n%s", c)
+	}
+}
+
+func TestPlanComment(t *testing.T) {
+	c := planComment("## Plan\n\ndo the thing", "run-1", "claude-opus-5", 0.42)
+	if !isPlanComment(c) {
+		t.Fatalf("plan comment must carry the plan marker:\n%s", c)
+	}
+	for _, want := range []string{"do the thing", "implement", "claude-opus-5", "0.4200"} {
+		if !strings.Contains(c, want) {
+			t.Errorf("plan comment missing %q:\n%s", want, c)
+		}
+	}
 }
 
 func TestSystemPromptStatesTheHarnessBoundary(t *testing.T) {
@@ -204,7 +228,7 @@ func TestTaskPromptIncludesIssueContext(t *testing.T) {
 			{Author: gh.User{Login: "alice"}, Body: "Only for idempotent requests."},
 		},
 	}
-	p := taskPrompt("acme/widgets", issue)
+	p := implementTaskPrompt("acme/widgets", issue, "")
 	for _, want := range []string{"#42", "Add retry logic", "We need retries on 5xx.", "@alice", "Only for idempotent requests.", "agent-ready"} {
 		if !strings.Contains(p, want) {
 			t.Errorf("task prompt missing %q", want)
@@ -213,7 +237,7 @@ func TestTaskPromptIncludesIssueContext(t *testing.T) {
 }
 
 func TestTaskPromptHandlesEmptyBody(t *testing.T) {
-	p := taskPrompt("acme/widgets", gh.Issue{Number: 1, Title: "Do the thing"})
+	p := implementTaskPrompt("acme/widgets", gh.Issue{Number: 1, Title: "Do the thing"}, "")
 	if !strings.Contains(p, "no description") {
 		t.Fatalf("an empty body should be called out:\n%s", p)
 	}
@@ -224,7 +248,7 @@ func TestTaskPromptTrimsLongDiscussions(t *testing.T) {
 	for i := 0; i < 40; i++ {
 		issue.Comments = append(issue.Comments, gh.Comment{Author: gh.User{Login: "u"}, Body: "comment"})
 	}
-	p := taskPrompt("acme/widgets", issue)
+	p := implementTaskPrompt("acme/widgets", issue, "")
 	if !strings.Contains(p, "showing the last") {
 		t.Fatalf("long discussions should be trimmed and say so:\n%s", p)
 	}
diff --git a/internal/orchestrator/phase.go b/internal/orchestrator/phase.go
new file mode 100644
index 0000000..ba1ae4e
--- /dev/null
+++ b/internal/orchestrator/phase.go
@@ -0,0 +1,77 @@
+package orchestrator
+
+import (
+	"strings"
+
+	"github.com/ableinc/coding-agent-loop/internal/gh"
+)
+
+// Phases an issue can be in. Plan and implement are the two phases that ever
+// run Claude; wait means the issue is sitting on a human.
+const (
+	phasePlan      = "plan"
+	phaseImplement = "implement"
+	phaseWait      = "wait"
+)
+
+// approvalKeyword is the exact (trimmed, case-insensitive) comment body that
+// approves a posted plan. Anything else posted after a plan is read as
+// feedback and sends the issue back through another plan pass.
+const approvalKeyword = "implement"
+
+// markerPrefix tags every comment the harness itself writes, so decidePhase
+// can tell harness narration apart from human input. Without it, the
+// harness's own plan/PR/failure comments would be read back as human
+// feedback and the issue would re-plan forever.
+const markerPrefix = "<!-- coding-agent-loop:"
+
+const (
+	markerPlan    = markerPrefix + "plan -->"
+	markerPR      = markerPrefix + "pr -->"
+	markerFailure = markerPrefix + "failure -->"
+)
+
+func isAgentComment(body string) bool {
+	return strings.Contains(body, markerPrefix)
+}
+
+func isPlanComment(body string) bool {
+	return strings.Contains(body, markerPlan)
+}
+
+// decidePhase reads an issue's comment history and reports what should happen
+// next. It is pure: given the same comments it always returns the same
+// answer, so it can run before anything is claimed.
+func decidePhase(issue gh.Issue) (phase string, reason string) {
+	comments := issue.Comments
+
+	planIdx := -1
+	for i, c := range comments {
+		if isPlanComment(c.Body) {
+			planIdx = i
+		}
+	}
+	if planIdx == -1 {
+		return phasePlan, "no plan has been posted yet"
+	}
+
+	lastHumanIdx := -1
+	for i := planIdx + 1; i < len(comments); i++ {
+		if !isAgentComment(comments[i].Body) {
+			lastHumanIdx = i
+		}
+	}
+	if lastHumanIdx == -1 {
+		return phaseWait, "plan posted, awaiting human approval"
+	}
+
+	c := comments[lastHumanIdx]
+	if strings.EqualFold(strings.TrimSpace(c.Body), approvalKeyword) {
+		author := c.Author.Login
+		if author == "" {
+			author = "unknown"
+		}
+		return phaseImplement, "approved by @" + author
+	}
+	return phasePlan, "human feedback received after the plan, re-planning"
+}
diff --git a/internal/orchestrator/phase_test.go b/internal/orchestrator/phase_test.go
new file mode 100644
index 0000000..67b2e1e
--- /dev/null
+++ b/internal/orchestrator/phase_test.go
@@ -0,0 +1,104 @@
+package orchestrator
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ableinc/coding-agent-loop/internal/gh"
+)
+
+func comment(author, body string) gh.Comment {
+	return gh.Comment{Author: gh.User{Login: author}, Body: body}
+}
+
+func TestDecidePhase(t *testing.T) {
+	planComment := comment("agent-bot", markerPlan+"\n\n## Plan\ndo the thing")
+	prComment := comment("agent-bot", markerPR+"\n\nOpened a PR")
+	failureComment := comment("agent-bot", markerFailure+"\n\nfailed")
+
+	tests := []struct {
+		name      string
+		comments  []gh.Comment
+		wantPhase string
+		wantHuman string // substring expected in reason, "" to skip check
+	}{
+		{
+			name:      "no comments at all",
+			comments:  nil,
+			wantPhase: phasePlan,
+		},
+		{
+			name:      "implement requested before any plan exists",
+			comments:  []gh.Comment{comment("alice", "implement")},
+			wantPhase: phasePlan,
+		},
+		{
+			name:      "plan posted, nothing since",
+			comments:  []gh.Comment{planComment},
+			wantPhase: phaseWait,
+		},
+		{
+			name:      "exact approval",
+			comments:  []gh.Comment{planComment, comment("alice", "implement")},
+			wantPhase: phaseImplement,
+			wantHuman: "alice",
+		},
+		{
+			name:      "approval is case-insensitive and trims whitespace",
+			comments:  []gh.Comment{planComment, comment("alice", "  Implement  ")},
+			wantPhase: phaseImplement,
+		},
+		{
+			name:      "a sentence merely containing the word must not approve",
+			comments:  []gh.Comment{planComment, comment("alice", "please implement this soon")},
+			wantPhase: phasePlan,
+		},
+		{
+			name:      "feedback after the plan sends it back to re-plan",
+			comments:  []gh.Comment{planComment, comment("alice", "please also handle the edge case")},
+			wantPhase: phasePlan,
+		},
+		{
+			name:      "the harness's own PR comment after a plan is not human feedback",
+			comments:  []gh.Comment{planComment, prComment},
+			wantPhase: phaseWait,
+		},
+		{
+			name:      "the harness's own failure comment after a plan is not human feedback",
+			comments:  []gh.Comment{planComment, failureComment},
+			wantPhase: phaseWait,
+		},
+		{
+			name: "a second, revised plan resets the wait",
+			comments: []gh.Comment{
+				planComment,
+				comment("alice", "needs more detail"),
+				planComment,
+			},
+			wantPhase: phaseWait,
+		},
+		{
+			name: "approval only counts against the most recent plan",
+			comments: []gh.Comment{
+				planComment,
+				comment("alice", "implement"), // stale approval of an old plan
+				planComment,
+				comment("alice", "one more thing"),
+			},
+			wantPhase: phasePlan,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			issue := gh.Issue{Comments: tt.comments}
+			phase, reason := decidePhase(issue)
+			if phase != tt.wantPhase {
+				t.Fatalf("decidePhase() phase = %q, want %q (reason: %s)", phase, tt.wantPhase, reason)
+			}
+			if tt.wantHuman != "" && !strings.Contains(reason, tt.wantHuman) {
+				t.Fatalf("reason %q should mention %q", reason, tt.wantHuman)
+			}
+		})
+	}
+}
diff --git a/internal/orchestrator/prompt.go b/internal/orchestrator/prompt.go
index b046a36..61e658a 100644
--- a/internal/orchestrator/prompt.go
+++ b/internal/orchestrator/prompt.go
@@ -30,6 +30,10 @@ Working context:
 - Branch: %s (already created and checked out for you)
 - Worktree: %s
 
+A human has already reviewed and approved the plan for this change (see the
+"Approved plan" section of the task below). Follow it; do not re-litigate its
+scope.
+
 The harness, not you, owns version control and GitHub. Specifically:
 - Do NOT run git push, git rebase, git reset --hard, or any force operation.
 - Do NOT create branches, tags, pull requests, or issue comments.
@@ -46,19 +50,52 @@ Scope rules:
 Autonomy:
 - Nobody is watching and nobody can answer a question mid-task. Do not ask for
   confirmation and do not end your turn with a proposal or a plan you did not carry out.
-- If the issue is genuinely ambiguous, choose the most reasonable reading, implement it,
-  and state the assumption in your final message.
+- If the plan turns out to be wrong once you're in the code, deviate only where it is
+  demonstrably wrong, and say so plainly in your final summary.
 - If you conclude the change should not be made, make no edits and explain why.
 
 Finish with a short summary: what you changed, which files, and anything a reviewer
 should look at closely.`, repo, branch, worktree)
 }
 
-// taskPrompt renders the issue into the actual instruction.
-func taskPrompt(repo string, issue gh.Issue) string {
+// planSystemPrompt states the rules for the read-only planning pass: produce
+// a plan, do not touch the repository.
+func planSystemPrompt(repo, worktree string) string {
+	return fmt.Sprintf(`You are running unattended as an automated planning agent.
+
+Working context:
+- Repository: %s
+- Worktree (read-only checkout for reference): %s
+
+Your only job is to produce a plan for the change described below. Do NOT edit any
+files, do NOT run git commands, and do NOT create branches, commits, or pull requests.
+Read whatever parts of the repository you need in order to write a concrete plan.
+
+Autonomy:
+- Nobody is watching and nobody can answer a question mid-task. Do not ask for
+  confirmation.
+- If the issue is genuinely ambiguous, choose the most reasonable reading and
+  say so in the plan, rather than stalling on it.
+
+Your final message IS the plan. Write it in markdown, and make it concrete:
+- Name the actual files you would change and, where relevant, the functions or
+  helpers already in the repository that the change should reuse.
+- Describe the approach step by step, in enough detail that a reviewer can judge it
+  without reading the code themselves.
+- Call out anything risky, ambiguous, or that needs a design decision from the
+  reviewer before implementation starts.
+
+Do not implement anything. Do not include a preamble like "Here is my plan" — the
+final message should be the plan itself, headed by a short one-line summary of the
+change.`, repo, worktree)
+}
+
+// issueContext renders the issue itself: title, labels, description, and
+// recent discussion. Shared by the plan and implement prompts so the two
+// phases see the same view of the issue.
+func issueContext(repo string, issue gh.Issue) string {
 	var b strings.Builder
 
-	fmt.Fprintf(&b, "Implement the change requested by GitHub issue #%d in %s.\n\n", issue.Number, repo)
 	fmt.Fprintf(&b, "## Issue #%d: %s\n\n", issue.Number, issue.Title)
 	if issue.URL != "" {
 		fmt.Fprintf(&b, "<%s>\n\n", issue.URL)
@@ -92,6 +129,49 @@ func taskPrompt(repo string, issue gh.Issue) string {
 		}
 	}
 
+	return b.String()
+}
+
+// planTaskPrompt renders the issue into a planning instruction. When
+// previousPlan is non-empty, this is a re-plan: the model is told to revise
+// it against the newest feedback rather than starting from scratch.
+func planTaskPrompt(repo string, issue gh.Issue, previousPlan string) string {
+	var b strings.Builder
+
+	if previousPlan == "" {
+		fmt.Fprintf(&b, "Write a plan for the change requested by GitHub issue #%d in %s.\n\n", issue.Number, repo)
+	} else {
+		fmt.Fprintf(&b, "Revise the plan for GitHub issue #%d in %s.\n\n", issue.Number, repo)
+	}
+	b.WriteString(issueContext(repo, issue))
+
+	if previousPlan != "" {
+		b.WriteString("\n### Previous plan\n\n")
+		b.WriteString(previousPlan)
+		b.WriteString("\n\nA reviewer replied with feedback (see the newest comment in the discussion above) " +
+			"instead of approving this plan. Revise the plan to address it; keep whatever still holds.\n")
+	}
+
+	b.WriteString("\nRead the relevant parts of the repository, then write the plan.\n")
+	return b.String()
+}
+
+// implementTaskPrompt renders the issue and its approved plan into the
+// implementation instruction.
+func implementTaskPrompt(repo string, issue gh.Issue, plan string) string {
+	var b strings.Builder
+
+	fmt.Fprintf(&b, "Implement the change requested by GitHub issue #%d in %s.\n\n", issue.Number, repo)
+	b.WriteString(issueContext(repo, issue))
+
+	if plan != "" {
+		b.WriteString("\n### Approved plan\n\n")
+		b.WriteString("A human reviewed and approved the following plan. Follow it; deviate only where it is " +
+			"demonstrably wrong, and say so in your final summary.\n\n")
+		b.WriteString(plan)
+		b.WriteString("\n")
+	}
+
 	b.WriteString("\nRead the relevant parts of the repository before editing, then make the change.\n")
 	return b.String()
 }
diff --git a/internal/orchestrator/prompt_test.go b/internal/orchestrator/prompt_test.go
new file mode 100644
index 0000000..00af875
--- /dev/null
+++ b/internal/orchestrator/prompt_test.go
@@ -0,0 +1,62 @@
+package orchestrator
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/ableinc/coding-agent-loop/internal/gh"
+)
+
+func TestImplementTaskPromptCarriesTheApprovedPlanVerbatim(t *testing.T) {
+	issue := gh.Issue{Number: 7, Title: "Add retry logic"}
+	plan := "## Plan\n\nEdit internal/foo/bar.go to add a retry loop."
+
+	p := implementTaskPrompt("acme/widgets", issue, plan)
+	if !strings.Contains(p, plan) {
+		t.Fatalf("implement prompt should carry the approved plan verbatim:\n%s", p)
+	}
+	if !strings.Contains(p, "Approved plan") {
+		t.Fatalf("implement prompt should label the plan section:\n%s", p)
+	}
+}
+
+func TestImplementTaskPromptWithoutAPlan(t *testing.T) {
+	issue := gh.Issue{Number: 7, Title: "Add retry logic"}
+	p := implementTaskPrompt("acme/widgets", issue, "")
+	if strings.Contains(p, "Approved plan") {
+		t.Fatalf("no plan section should appear when there is no plan:\n%s", p)
+	}
+}
+
+func TestPlanTaskPromptWithoutAPreviousPlan(t *testing.T) {
+	issue := gh.Issue{Number: 9, Title: "Support pagination"}
+	p := planTaskPrompt("acme/widgets", issue, "")
+	if !strings.Contains(p, "#9") || !strings.Contains(p, "Support pagination") {
+		t.Fatalf("plan prompt should reference the issue:\n%s", p)
+	}
+	if strings.Contains(p, "Previous plan") {
+		t.Fatalf("a fresh plan prompt should not mention a previous plan:\n%s", p)
+	}
+}
+
+func TestPlanTaskPromptIncludesThePreviousPlanOnReplan(t *testing.T) {
+	issue := gh.Issue{Number: 9, Title: "Support pagination"}
+	previous := "## Plan\n\nAdd a `page` query param."
+
+	p := planTaskPrompt("acme/widgets", issue, previous)
+	if !strings.Contains(p, previous) {
+		t.Fatalf("re-plan prompt should carry the previous plan verbatim:\n%s", p)
+	}
+	if !strings.Contains(p, "Previous plan") {
+		t.Fatalf("re-plan prompt should label the previous plan:\n%s", p)
+	}
+}
+
+func TestPlanSystemPromptForbidsEditing(t *testing.T) {
+	p := planSystemPrompt("acme/widgets", "/work/widgets/issue-9")
+	for _, want := range []string{"Do NOT edit", "Do NOT", "plan"} {
+		if !strings.Contains(p, want) {
+			t.Errorf("plan system prompt missing %q:\n%s", want, p)
+		}
+	}
+}
diff --git a/internal/orchestrator/report.go b/internal/orchestrator/report.go
index b3f4604..0b81a2b 100644
--- a/internal/orchestrator/report.go
+++ b/internal/orchestrator/report.go
@@ -76,6 +76,8 @@ func prBody(r prReport) string {
 // issueComment is the short note left on the issue when a PR is opened.
 func issueComment(prURL, runID string, v verify.Result) string {
 	var b strings.Builder
+	b.WriteString(markerPR)
+	b.WriteString("\n\n")
 	fmt.Fprintf(&b, "Opened a draft pull request for this issue: %s\n\n", prURL)
 	switch v.Status {
 	case store.VerifyPassed:
@@ -94,6 +96,8 @@ func issueComment(prURL, runID string, v verify.Result) string {
 // says what actually stops the retries: taking the trigger label off.
 func failureComment(runID string, attempt int, reason string, nextAttempt time.Time, triggerLabel string) string {
 	var b strings.Builder
+	b.WriteString(markerFailure)
+	b.WriteString("\n\n")
 	fmt.Fprintf(&b, "The coding agent could not complete this issue (attempt %d).\n\n", attempt)
 	b.WriteString("```\n")
 	b.WriteString(strings.TrimSpace(reason))
@@ -108,3 +112,21 @@ func failureComment(runID string, attempt int, reason string, nextAttempt time.T
 	fmt.Fprintf(&b, "\n<sub>coding-agent-loop run `%s`</sub>\n", runID)
 	return b.String()
 }
+
+// maxPlanCommentChars keeps a plan comment under GitHub's ~65536-character
+// comment body limit, leaving room for the marker and footer.
+const maxPlanCommentChars = 60000
+
+// planComment is what gets posted after a planning run: the plan itself, and
+// instructions for how a human moves the issue forward.
+func planComment(plan, runID, modelID string, costUSD float64) string {
+	var b strings.Builder
+	b.WriteString(markerPlan)
+	b.WriteString("\n\n## Plan\n\n")
+	b.WriteString(truncate(strings.TrimSpace(plan), maxPlanCommentChars))
+	b.WriteString("\n\n---\n\n")
+	b.WriteString("Reply with exactly `implement` to approve this plan and start the change. ")
+	b.WriteString("Reply with anything else and the plan will be revised to address it.\n\n")
+	fmt.Fprintf(&b, "<sub>coding-agent-loop run `%s`, model `%s`, cost $%.4f</sub>\n", runID, modelID, costUSD)
+	return b.String()
+}
diff --git a/internal/store/store.go b/internal/store/store.go
index 164d118..742711d 100644
--- a/internal/store/store.go
+++ b/internal/store/store.go
@@ -29,6 +29,7 @@ const (
 	StatusAbandoned = "abandoned" // terminal, skipped: the issue is not workable as it stands
 	StatusCanceled  = "canceled"  // terminal, operator cancelled
 	StatusDeferred  = "deferred"  // terminal, stopped by the usage gate; not the issue's fault
+	StatusPlanned   = "planned"   // terminal, a plan was posted and awaits human approval
 )
 
 // Verify outcomes recorded on a run.
@@ -48,7 +49,7 @@ const (
 // IsTerminal reports whether a run status is final.
 func IsTerminal(status string) bool {
 	switch status {
-	case StatusPROpen, StatusFailed, StatusAbandoned, StatusCanceled, StatusDeferred:
+	case StatusPROpen, StatusFailed, StatusAbandoned, StatusCanceled, StatusDeferred, StatusPlanned:
 		return true
 	}
 	return false
@@ -235,6 +236,18 @@ var migrations = []string{
 	CREATE INDEX IF NOT EXISTS sessions_run ON sessions(run_id);
 	INSERT OR IGNORE INTO sessions (session_id, run_id, repo, issue, model_id, created_at)
 		SELECT session_id, id, repo, issue, model_id, created_at FROM runs WHERE session_id <> '';`,
+
+	// One plan per issue: the latest plan posted, kept so the implement prompt
+	// can carry it verbatim even though the issue comment itself may have been
+	// truncated when it was read back as discussion.
+	`CREATE TABLE IF NOT EXISTS plans (
+		repo       TEXT NOT NULL,
+		issue      INTEGER NOT NULL,
+		run_id     TEXT NOT NULL,
+		body       TEXT NOT NULL,
+		created_at INTEGER NOT NULL,
+		PRIMARY KEY (repo, issue)
+	);`,
 }
 
 func (s *Store) migrate(ctx context.Context) error {
@@ -638,6 +651,40 @@ func (s *Store) IssueHistory(ctx context.Context, repo string, issue int) (Issue
 	return st, nil
 }
 
+// --- plans ------------------------------------------------------------------
+
+// SavePlan records the latest plan posted for an issue, overwriting any
+// previous one: only the most recent plan is ever relevant to an implement run
+// or a re-plan.
+func (s *Store) SavePlan(ctx context.Context, repo string, issue int, runID, body string) error {
+	_, err := s.db.ExecContext(ctx, `
+		INSERT INTO plans (repo, issue, run_id, body, created_at) VALUES (?, ?, ?, ?, ?)
+		ON CONFLICT(repo, issue) DO UPDATE SET
+			run_id     = excluded.run_id,
+			body       = excluded.body,
+			created_at = excluded.created_at`,
+		repo, issue, runID, body, time.Now().Unix())
+	if err != nil {
+		return fmt.Errorf("save plan %s#%d: %w", repo, issue, err)
+	}
+	return nil
+}
+
+// LatestPlan returns the most recent plan body for an issue, or "" when none
+// has been recorded.
+func (s *Store) LatestPlan(ctx context.Context, repo string, issue int) (string, error) {
+	var body string
+	err := s.db.QueryRowContext(ctx,
+		`SELECT body FROM plans WHERE repo = ? AND issue = ?`, repo, issue).Scan(&body)
+	if errors.Is(err, sql.ErrNoRows) {
+		return "", nil
+	}
+	if err != nil {
+		return "", fmt.Errorf("latest plan %s#%d: %w", repo, issue, err)
+	}
+	return body, nil
+}
+
 // --- gate -------------------------------------------------------------------
 
 // SetGate closes a gate until the given time.
diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index 415f9d3..d4c32ad 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -524,3 +524,74 @@ func TestExistingRunSessionsAreBackfilled(t *testing.T) {
 		t.Fatalf("existing sessions should be carried over, got %+v", sessions)
 	}
 }
+
+func TestPlanSaveAndOverwrite(t *testing.T) {
+	ctx := context.Background()
+	st := testStore(t)
+
+	body, err := st.LatestPlan(ctx, "o/r", 5)
+	if err != nil {
+		t.Fatalf("latest plan for unseen issue: %v", err)
+	}
+	if body != "" {
+		t.Fatalf("unseen issue should have no plan, got %q", body)
+	}
+
+	if err := st.SavePlan(ctx, "o/r", 5, "run-1", "## Plan\nfirst draft"); err != nil {
+		t.Fatalf("save plan: %v", err)
+	}
+	body, err = st.LatestPlan(ctx, "o/r", 5)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if body != "## Plan\nfirst draft" {
+		t.Fatalf("plan body = %q", body)
+	}
+
+	// A re-plan overwrites rather than accumulating: only the latest plan
+	// matters to an implement run or the next re-plan.
+	if err := st.SavePlan(ctx, "o/r", 5, "run-2", "## Plan\nrevised"); err != nil {
+		t.Fatalf("overwrite plan: %v", err)
+	}
+	body, err = st.LatestPlan(ctx, "o/r", 5)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if body != "## Plan\nrevised" {
+		t.Fatalf("plan should be overwritten, got %q", body)
+	}
+}
+
+func TestStatusPlannedIsTerminalButNotSuccessOrFailure(t *testing.T) {
+	ctx := context.Background()
+	st := testStore(t)
+
+	if !IsTerminal(StatusPlanned) {
+		t.Fatal("planned must be a terminal status")
+	}
+
+	if err := st.CreateRun(ctx, Run{ID: "p1", Repo: "o/r", Issue: 7, Status: StatusClaimed, StartedAt: time.Now()}); err != nil {
+		t.Fatal(err)
+	}
+	if err := st.SetRunStatus(ctx, "p1", StatusPlanned); err != nil {
+		t.Fatal(err)
+	}
+	got, err := st.GetRun(ctx, "p1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.EndedAt.IsZero() {
+		t.Fatal("terminal status should stamp ended_at")
+	}
+
+	hist, err := st.IssueHistory(ctx, "o/r", 7)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hist.Succeeded {
+		t.Fatal("a planned run must not count as delivering a PR")
+	}
+	if hist.Failures != 0 {
+		t.Fatalf("a planned run must not count as a failure, got %d", hist.Failures)
+	}
+}
diff --git a/models.json b/models.json
index 2b51407..421918d 100644
--- a/models.json
+++ b/models.json
@@ -1,7 +1,29 @@
 {
   "models": [
-    { "id": "claude-opus-5",    "alias": "opus",   "roles": ["implement"], "priority": 1 },
-    { "id": "claude-sonnet-5",  "alias": "sonnet", "roles": ["implement"], "priority": 2 },
-    { "id": "claude-haiku-4-5", "alias": "haiku",  "roles": ["triage"],    "priority": 1 }
+    {
+      "id": "claude-opus-5",
+      "alias": "opus",
+      "roles": [
+        "plan"
+      ],
+      "priority": 1
+    },
+    {
+      "id": "claude-sonnet-5",
+      "alias": "sonnet",
+      "roles": [
+        "plan",
+        "implement"
+      ],
+      "priority": 2
+    },
+    {
+      "id": "claude-haiku-4-5",
+      "alias": "haiku",
+      "roles": [
+        "triage"
+      ],
+      "priority": 1
+    }
   ]
 }