diff --git a/.mindspec/docs/domains/execution/architecture.md b/.mindspec/docs/domains/execution/architecture.md
index 8628019..0c4c7d1 100644
--- a/.mindspec/docs/domains/execution/architecture.md
+++ b/.mindspec/docs/domains/execution/architecture.md
@@ -7,27 +7,29 @@
 The `Executor` interface separates enforcement ("what") from execution ("how"):
 
 ```
-Workflow Layer                    Execution Layer
-┌─────────────────┐              ┌──────────────────┐
-│ approve/         │──Executor──▶│ executor/git.go   │
-│ complete/        │   interface │ (GitExecutor)     │
-│ next/            │              │                  │
-│ specinit/        │              │ gitutil/         │
-│ cleanup/         │              │ (low-level ops)  │
-└─────────────────┘              └──────────────────┘
+Workflow Layer                    Execution Engine
+┌─────────────────┐              ┌─────────────────────────────┐
+│ approve/         │──Executor──▶│ executor/mindspec_executor.go│
+│ complete/        │   interface │ (MindspecExecutor)           │
+│ next/            │              │                             │
+│ spec/            │              │ gitutil/                    │
+│ cleanup/         │              │ (low-level ops)             │
+└─────────────────┘              └─────────────────────────────┘
 ```
 
-- **GitExecutor** — concrete implementation wrapping git+worktree operations
+- **MindspecExecutor** — concrete implementation wrapping git+worktree operations (dispatches beads to worktrees, merges completed bead branches, finalizes specs)
 - **MockExecutor** — test double for enforcement testing without git side effects
 - **DI wiring** — `cmd/mindspec/root.go` has `newExecutor(root)` factory
 
+The execution engine reads beads produced by the planning layer. Each bead is a self-contained work packet — requirements, context, dependencies, acceptance criteria — so a fresh agent can pick it up without session history. Beads are the substrate that makes the `Executor` interface pluggable: any orchestrator that can read a bead can dispatch work.
+
 ### withWorkingDir Safety
 
-Worktree removal and branch deletion require CWD to be outside the target worktree. `GitExecutor` uses `withWorkingDir(root, func)` to temporarily chdir to the repo root before destructive operations, then restores the original CWD. This prevents "cannot remove worktree: in use" errors.
+Worktree removal and branch deletion require CWD to be outside the target worktree. `MindspecExecutor` uses `withWorkingDir(root, func)` to temporarily chdir to the repo root before destructive operations, then restores the original CWD. This prevents "cannot remove worktree: in use" errors.
 
 ### Function Injection for Testability
 
-`GitExecutor` exposes function variables (`WorktreeRemoveFn`, `DeleteBranchFn`, `MergeBranchFn`, etc.) that can be replaced in tests. This avoids requiring a real git repository for unit tests while keeping the production code straightforward.
+`MindspecExecutor` exposes function variables (`WorktreeRemoveFn`, `DeleteBranchFn`, `MergeBranchFn`, etc.) that can be replaced in tests. This avoids requiring a real git repository for unit tests while keeping the production code straightforward.
 
 ### Branch Conventions
 
diff --git a/.mindspec/docs/domains/execution/interfaces.md b/.mindspec/docs/domains/execution/interfaces.md
index b2dd885..ae34fc0 100644
--- a/.mindspec/docs/domains/execution/interfaces.md
+++ b/.mindspec/docs/domains/execution/interfaces.md
@@ -13,7 +13,7 @@ type Executor interface {
     FinalizeEpic(epicID, specID, specBranch string) (FinalizeResult, error)
     Cleanup(specID string, force bool) error
 
-    // Epic handoff (notification hook — no-op for GitExecutor)
+    // Epic handoff (notification hook — no-op for MindspecExecutor)
     HandoffEpic(epicID, specID string, beadIDs []string) error
 
     // Query methods
@@ -26,7 +26,7 @@ type Executor interface {
 
 ### GitUtil Helpers (`internal/gitutil/gitutil.go`)
 
-Low-level git operations used only by `GitExecutor`:
+Low-level git operations used only by `MindspecExecutor`:
 
 | Function | Purpose |
 |:---------|:--------|
@@ -49,5 +49,5 @@ Low-level git operations used only by `GitExecutor`:
 
 | Type | Package | Purpose |
 |:-----|:--------|:--------|
-| `GitExecutor` | `internal/executor/git.go` | Production: real git+worktree operations |
+| `MindspecExecutor` | `internal/executor/mindspec_executor.go` | Production: real git+worktree operations |
 | `MockExecutor` | `internal/executor/mock.go` | Testing: records calls, returns configured errors |
diff --git a/.mindspec/docs/domains/execution/overview.md b/.mindspec/docs/domains/execution/overview.md
index 2e80cde..82a7ce7 100644
--- a/.mindspec/docs/domains/execution/overview.md
+++ b/.mindspec/docs/domains/execution/overview.md
@@ -2,7 +2,7 @@
 
 ## What This Domain Owns
 
-The **execution** domain owns all git, worktree, and filesystem operations — the "how" layer that performs operations delegated by the workflow layer.
+The **execution engine** owns all git, worktree, and filesystem operations — the "how" layer that implements operations delegated by the workflow layer. It dispatches beads to worktrees, executes code changes, merges results, and finalizes specs.
 
 - **Git operations** — branching, merging, diffstat, commit counting, push/PR creation
 - **Worktree lifecycle** — creating, removing, and switching between isolated workspaces
@@ -14,6 +14,7 @@ The **execution** domain owns all git, worktree, and filesystem operations — t
 Execution does **not** own:
 - Lifecycle phase derivation or mode enforcement (workflow)
 - Approval gates or validation logic (workflow)
+- Plan decomposition or quality assessment (workflow)
 - Beads integration or epic/bead queries (workflow)
 - CLI infrastructure or project health checks (core)
 
@@ -23,9 +24,9 @@ Execution **receives** instructions from the workflow layer via the `Executor` i
 
 | Package | Purpose |
 |:--------|:--------|
-| `internal/executor/` | `Executor` interface + `GitExecutor` + `MockExecutor` |
-| `internal/gitutil/` | Low-level git helpers (branch, merge, PR, diffstat) |
+| `internal/executor/` | `Executor` interface + `MindspecExecutor` (production) + `MockExecutor` (testing) |
+| `internal/gitutil/` | Low-level git helpers (branch, merge, PR, diffstat) — used only by `MindspecExecutor` |
 
 ## Import Rule
 
-Workflow packages (`internal/approve/`, `internal/complete/`, `internal/next/`, `internal/cleanup/`, `internal/specinit/`) MUST call `executor.Executor` methods. They MUST NOT import `internal/gitutil/` directly. This boundary is enforced by convention and checked by `mindspec doctor`.
+Workflow packages (`internal/approve/`, `internal/complete/`, `internal/next/`, `internal/cleanup/`, `internal/spec/`) MUST call `executor.Executor` methods. They MUST NOT import `internal/gitutil/` directly. This boundary is enforced by convention and checked by `mindspec doctor`.
diff --git a/.mindspec/docs/domains/workflow/architecture.md b/.mindspec/docs/domains/workflow/architecture.md
index 97eeaab..ddd5f56 100644
--- a/.mindspec/docs/domains/workflow/architecture.md
+++ b/.mindspec/docs/domains/workflow/architecture.md
@@ -13,7 +13,11 @@ Each mode gates:
 - **Required context** — what must be reviewed before proceeding
 - **Transition gates** — what conditions must hold to advance
 
-### Beads as Single State Store (ADR-0023)
+### Beads as Substrate (ADR-0023)
+
+Beads is both the single state store and the **contract between the planning and execution layers**. Each bead is a self-contained work packet that encapsulates requirements, context (impacted domains, ADR citations), dependencies, and acceptance criteria. A fresh agent picking up a bead doesn't need session history — the bead carries everything it needs.
+
+This is what makes execution pluggable: any orchestrator that can read beads can dispatch work. The planning layer writes beads; the execution engine reads them.
 
 All lifecycle state is derived from Beads — no filesystem state files (no `focus`, no `lifecycle.yaml`):
 
@@ -46,7 +50,19 @@ approve/impl.go   ──▶ exec.FinalizeEpic()
 cleanup/          ──▶ exec.Cleanup()
 ```
 
-**Import rule**: Workflow packages (`approve/`, `complete/`, `next/`, `cleanup/`, `specinit/`) call `executor.Executor` methods. They MUST NOT import `internal/gitutil/` directly.
+**Import rule**: Workflow packages (`approve/`, `complete/`, `next/`, `cleanup/`, `spec/`) call `executor.Executor` methods. They MUST NOT import `internal/gitutil/` directly.
+
+### Plan Quality Responsibility
+
+The workflow layer ensures plans are well-decomposed before handoff to the execution engine. This is critical because AI agents perform significantly better on well-structured, bitesize tasks than on vague or monolithic ones (see [arXiv:2512.08296](https://arxiv.org/abs/2512.08296)).
+
+Workflow enforces:
+- **Bead decomposition** — each bead must be a focused, independently completable unit of work
+- **Clear acceptance criteria** — every bead has verifiable completion conditions
+- **Dependency ordering** — beads declare dependencies so the execution engine dispatches them in the right order
+- **Validation gates** — `internal/validate/` checks structural requirements and ADR compliance before plan approval
+
+The execution engine trusts that approved plans are well-decomposed and simply executes them — it does not assess plan quality.
 
 ### ADR Governance
 
diff --git a/.mindspec/docs/domains/workflow/overview.md b/.mindspec/docs/domains/workflow/overview.md
index 42ccdfc..4cc1e5d 100644
--- a/.mindspec/docs/domains/workflow/overview.md
+++ b/.mindspec/docs/domains/workflow/overview.md
@@ -29,7 +29,7 @@ Workflow **uses** context packs (from context-system) to provide mode-appropriat
 | `internal/approve/` | Spec, plan, and impl approval enforcement |
 | `internal/complete/` | Bead close-out orchestration |
 | `internal/next/` | Work selection, claiming, worktree dispatch |
-| `internal/specinit/` | Spec creation (worktree-first flow) |
+| `internal/spec/` | Spec creation (worktree-first flow) |
 | `internal/cleanup/` | Post-lifecycle worktree/branch cleanup |
 | `internal/phase/` | Phase derivation from beads (ADR-0023) |
 | `internal/resolve/` | Target spec resolution and prefix matching |
diff --git a/.mindspec/docs/specs/081-executor-docs-tests/plan.md b/.mindspec/docs/specs/081-executor-docs-tests/plan.md
new file mode 100644
index 0000000..63bf27b
--- /dev/null
+++ b/.mindspec/docs/specs/081-executor-docs-tests/plan.md
@@ -0,0 +1,235 @@
+---
+approved_at: "2026-03-10T21:18:25Z"
+approved_by: user
+bead_ids:
+    - mindspec-4ya5.1
+    - mindspec-4ya5.2
+    - mindspec-4ya5.3
+    - mindspec-4ya5.4
+    - mindspec-qszb
+last_updated: "2026-03-10"
+spec_id: 081-executor-docs-tests
+status: Approved
+version: 1
+---
+# Plan: 081-executor-docs-tests
+
+## ADR Fitness
+
+- **ADR-0023** (Beads as single state authority): Documentation updates reference beads as the foundation for decomposition and state tracking
+- **ADR-0006** (Protected main with PR-based merging): Execution layer docs reference the branch/merge strategy
+
+## Testing Strategy
+
+- Beads 1-2 (renames): `make build` + `go test ./...` + `go vet ./...` catch all breakage
+- Bead 3 (docs): Grep-based validation proofs confirm no stale terminology
+- Bead 4 (test audit): Run `TestLLM_SingleBead` as smoke test; document all 18 scenario findings
+- Bead 5 (stop behavior): Fix instruct templates + CLI output to prevent agent auto-proceeding
+
+## Bead 1: Rename GitExecutor → MindspecExecutor + purge gitops
+
+Mechanical rename of the executor struct, constructor, and source file. Also purges the last `gitops` reference in live Go code.
+
+**Steps**
+
+1. `git mv internal/executor/git.go internal/executor/mindspec_executor.go`
+2. In `mindspec_executor.go`: rename struct `GitExecutor` → `MindspecExecutor`, constructor `NewGitExecutor` → `NewMindspecExecutor`
+3. In `executor_test.go`: update all `GitExecutor`/`NewGitExecutor` references
+4. In `cmd/mindspec/root.go`: update `newExecutor()` to call `NewMindspecExecutor`
+5. In `internal/adr/store_test.go`: replace `gitops` test fixture tag with `execution`
+6. Update comment in `mindspec_executor.go` referencing `specinit` → `spec`
+
+**Acceptance Criteria**
+
+- [ ] Zero grep hits for `GitExecutor`, `NewGitExecutor`, and `gitops` in `internal/` and `cmd/` Go files
+- [ ] `make build` succeeds and `go test ./internal/executor/... -v` passes
+- [ ] `go vet ./...` clean
+
+**Verification**
+
+- [ ] `grep -r "GitExecutor" internal/ cmd/` → zero hits
+- [ ] `grep -r "NewGitExecutor" internal/ cmd/` → zero hits
+- [ ] `grep -rn "gitops" --include="*.go" internal/` → zero hits
+- [ ] `make build` → exit 0
+- [ ] `go test ./internal/executor/... -v` → all pass
+- [ ] `go vet ./...` → clean
+
+**Depends on**
+
+None
+
+## Bead 2: Rename `internal/specinit/` → `internal/spec/`
+
+Package rename with import path updates. Also renames source files for clarity.
+
+**Steps**
+
+1. `git mv internal/specinit/ internal/spec/` and rename `specinit.go` → `create.go`, `specinit_test.go` → `create_test.go`
+2. Update package declarations: `package specinit` → `package spec`
+3. Update imports and call sites in `cmd/mindspec/spec.go` and `cmd/mindspec/spec_init.go` (`specinit.Run` → `spec.Run`)
+4. Update all comments referencing `specinit` in `internal/executor/mindspec_executor.go`, `internal/lifecycle/scenario_test.go`, and `cmd/mindspec/root.go`
+5. Verify no stale references remain
+
+**Acceptance Criteria**
+
+- [ ] Zero grep hits for `specinit` in Go source files under `internal/` and `cmd/`
+- [ ] `internal/spec/create.go` exists with `package spec`
+- [ ] `make build` succeeds and `go test ./internal/spec/... -v` passes
+
+**Verification**
+
+- [ ] `grep -rn "specinit" --include="*.go" internal/ cmd/` → zero hits
+- [ ] `ls internal/spec/create.go` → exists
+- [ ] `make build` → exit 0
+- [ ] `go test ./internal/spec/... -v` → all pass
+- [ ] `go test ./cmd/mindspec/... -v` → all pass
+- [ ] `go vet ./...` → clean
+
+**Depends on**
+
+Bead 1 (file `mindspec_executor.go` must exist before updating its comments)
+
+## Bead 3: Architecture documentation overhaul
+
+Rewrite documentation to clearly articulate the two-layer architecture and reflect new naming.
+
+**Steps**
+
+1. **AGENTS.md** §138–147: Rewrite "Architecture: Workflow/Execution Boundary":
+   - Workflow layer: spec creation, plan decomposition into bitesize beads, validation against architecture (ADRs, domain boundaries), quality gates (tests, acceptance criteria), phase enforcement
+   - Execution engine (`MindspecExecutor`): dispatching beads to worktrees, implementing code changes, merging results, finalizing the spec
+   - Reference arXiv:2512.08296 for decomposition quality rationale
+   - Update package lists to use `internal/spec/` and `MindspecExecutor`
+
+2. **`.mindspec/docs/domains/execution/overview.md`**: Update key packages table, refine "what this domain owns" with execution engine framing
+
+3. **`.mindspec/docs/domains/execution/architecture.md`**: `GitExecutor` → `MindspecExecutor` throughout
+
+4. **`.mindspec/docs/domains/execution/interfaces.md`**: Update implementation names
+
+5. **`.mindspec/docs/domains/workflow/overview.md`**: `specinit` → `spec` in key packages table
+
+6. **`.mindspec/docs/domains/workflow/architecture.md`**: Add plan quality responsibility section — workflow layer ensures beads are well-decomposed, reviewed, have clear acceptance criteria before handoff to execution engine
+
+7. **Classify `mindspec next` and `mindspec complete` as execution layer commands** in AGENTS.md and domain docs — they create/destroy worktrees and manage branch topology, which is execution concern. The workflow layer (approve commands) decides *when* transitions happen; the execution layer (next/complete) performs them.
+
+8. **Auto-memory** (`MEMORY.md`): Update `GitExecutor` → `MindspecExecutor`, `specinit` → `spec`
+
+**Acceptance Criteria**
+
+- [ ] Zero grep hits for `GitExecutor` and `specinit` in AGENTS.md and `.mindspec/docs/domains/`
+- [ ] AGENTS.md architecture section describes workflow layer (decomposition, validation, quality gates) and execution engine (implementation, merging, finalization)
+- [ ] `go test ./internal/executor/... -v` still passes (no code changes, but confirms docs didn't break anything)
+
+**Verification**
+
+- [ ] `grep -rn "GitExecutor" .mindspec/docs/ AGENTS.md` → zero hits (excluding historical spec 077)
+- [ ] `grep -rn "specinit" AGENTS.md .mindspec/docs/domains/` → zero hits
+- [ ] AGENTS.md architecture section clearly describes both layers
+- [ ] Execution domain docs reference `MindspecExecutor`
+- [ ] Workflow domain docs describe plan quality responsibility
+- [ ] `go test ./internal/executor/... -v` → all pass (regression check)
+
+**Depends on**
+
+Beads 1-2 (docs must reference final names)
+
+## Bead 4: LLM test scenario audit
+
+Review all 18 scenarios for correctness. Document findings in HISTORY.md. Fix any broken expectations.
+
+**Steps**
+
+1. Read every scenario in `internal/harness/scenario.go` — prompts, assertions, setup, expected behavior
+2. Cross-reference with `implement.md` template (lines 49, 94: STOP after complete)
+3. For each scenario assess: prompt validity, assertion correctness, MaxTurns/timeout realism
+4. Scrutinize specifically:
+   - **SpecToIdle**: 100 turns for full manual lifecycle
+   - **MultiBeadDeps**: Expects explicit `mindspec next`
+   - **BlockedBeadTransition**: Mode→plan when only blocked beads remain
+   - **UnmergedBeadGuard**: Recovery flow after close-without-complete
+5. Write "Test Audit (Spec 081)" section in `internal/harness/HISTORY.md` with per-scenario findings
+6. Fix any broken test expectations
+7. Run `TestLLM_SingleBead` as smoke test
+8. **Create stop-behavior LLM test scenarios** — new tests that verify:
+   - After `mindspec approve plan`, agent STOPS (does not auto-implement or write code)
+   - After `mindspec complete`, agent STOPS (does not auto-claim or run `mindspec next`)
+   - Agent uses `mindspec next` to create bead worktree (not working on spec branch directly)
+   These tests are expected to **fail before Bead 5** (which fixes the guidance). Run them to establish the baseline, document failures in HISTORY.md. Bead 5 re-runs them as verification.
+
+**Acceptance Criteria**
+
+- [ ] HISTORY.md contains "Test Audit (Spec 081)" section with findings for all 18 scenarios
+- [ ] Any outdated test expectations fixed
+- [ ] `TestLLM_SingleBead` smoke test passes
+- [ ] Stop-behavior test scenarios created (`TestLLM_StopAfterPlanApprove`, `TestLLM_StopAfterComplete`)
+- [ ] Baseline results documented in HISTORY.md (expected failures before Bead 5)
+
+**Verification**
+
+- [ ] HISTORY.md contains "Test Audit (Spec 081)" section covering all 18 scenarios
+- [ ] Any outdated expectations fixed (if found)
+- [ ] `env -u CLAUDECODE go test ./internal/harness/ -v -run TestLLM_SingleBead -timeout 10m` → passes
+- [ ] Stop-behavior tests exist and run (failures expected — baseline captured)
+
+**Depends on**
+
+Beads 1-2 (code references in scenarios should use new names if applicable)
+
+## Bead 5: Harden phase-transition stop behavior
+
+Fix observed failure: agent auto-proceeded after plan approval and worked on the spec branch instead of using `mindspec next` to create a bead worktree. Root causes: outdated instruct template, insufficiently emphatic CLI output.
+
+**Steps**
+
+1. **Fix `internal/instruct/templates/plan.md`**: Remove false claim "This will approve the plan AND automatically claim the first bead." Replace with clear guidance: after plan approval, STOP, run `/clear`, then `mindspec next`.
+2. **Strengthen plan approve output in `cmd/mindspec/plan_cmd.go`**: Make STOP instruction unmissable with clear separator (e.g., `⛔ STOP` or `---` banner). Emphasize: do NOT proceed, run `/clear` first, then `mindspec next`.
+3. **Strengthen `mindspec complete` output in `internal/complete/complete.go` `FormatResult()`**: When reporting "Next bead ready: X", append explicit instruction: "STOP. Run `/clear`, then `mindspec next` to claim it."
+4. **Remove dead `--no-next` flag** from `cmd/mindspec/approve.go`.
+5. **Update `implement.md` template** if needed — verify STOP guidance is clear and consistent with the CLI output changes.
+
+**Acceptance Criteria**
+
+- [ ] `plan.md` template no longer says "automatically claim the first bead"
+- [ ] Plan approve output includes emphatic STOP + `/clear` + `mindspec next` instructions
+- [ ] `mindspec complete` output includes STOP instruction when next bead is ready
+- [ ] `--no-next` flag removed from `approve.go`
+- [ ] `make build` succeeds and `go test ./cmd/mindspec/... -v` passes
+- [ ] Stop-behavior LLM tests pass (created in Bead 4, expected to fail before this bead)
+
+**Verification**
+
+- [ ] `grep "auto.*claim" internal/instruct/templates/plan.md` → zero hits
+- [ ] `grep "no-next" cmd/mindspec/approve.go` → zero hits
+- [ ] `make build` → exit 0
+- [ ] `go test ./cmd/mindspec/... -v` → all pass
+- [ ] `go vet ./...` → clean
+- [ ] Manual review: `./bin/mindspec approve plan --help` no longer shows `--no-next`
+- [ ] `env -u CLAUDECODE go test ./internal/harness/ -v -run TestLLM_StopAfterPlanApprove -timeout 10m` → passes
+- [ ] `env -u CLAUDECODE go test ./internal/harness/ -v -run TestLLM_StopAfterComplete -timeout 10m` → passes
+
+**Depends on**
+
+Bead 4 (stop-behavior tests must exist before this bead fixes the guidance)
+
+## Provenance
+
+| Acceptance Criterion | Verified By |
+|---------------------|-------------|
+| `GitExecutor` → `MindspecExecutor` (zero grep hits) | Bead 1 verification |
+| `git.go` → `mindspec_executor.go` | Bead 1 verification |
+| `specinit` → `spec` (zero grep hits) | Bead 2 verification |
+| `gitops` purged from live code | Bead 1 verification |
+| `make build` + `go test` + `go vet` pass | Beads 1, 2 verification |
+| AGENTS.md two-layer architecture | Bead 3 verification |
+| Domain docs updated | Bead 3 verification |
+| 18 LLM test scenarios reviewed in HISTORY.md | Bead 4 verification |
+| Outdated test expectations fixed | Bead 4 verification |
+| SingleBead smoke test passes | Bead 4 verification |
+| `plan.md` template no longer claims auto-claim | Bead 5 verification |
+| Plan approve output has emphatic STOP | Bead 5 verification |
+| `mindspec complete` output has STOP for next bead | Bead 5 verification |
+| Dead `--no-next` flag removed | Bead 5 verification |
+| Stop-behavior tests created (baseline) | Bead 4 verification |
+| Stop-behavior tests pass (after fix) | Bead 5 verification |
+| `next`/`complete` classified as execution layer | Bead 3 verification |
diff --git a/.mindspec/docs/specs/081-executor-docs-tests/spec.md b/.mindspec/docs/specs/081-executor-docs-tests/spec.md
new file mode 100644
index 0000000..5ad6e7c
--- /dev/null
+++ b/.mindspec/docs/specs/081-executor-docs-tests/spec.md
@@ -0,0 +1,199 @@
+---
+approved_at: "2026-03-10T21:08:26Z"
+approved_by: user
+status: Approved
+---
+# Spec 081-executor-docs-tests: Executor rename, architecture docs, and LLM test review
+
+## Goal
+
+Rename `GitExecutor` to `MindspecExecutor` (including file rename `git.go` → `mindspec_executor.go`), purge legacy `gitops` and `specinit` terminology from codebase and documentation, update architecture documentation to clearly articulate the two-layer design (Workflow layer + Execution engine), and audit all 18 LLM test scenarios for correctness after the "stop between beads" behavioral change. Test audit findings go in `HISTORY.md`.
+
+## Background
+
+Spec 077 introduced the Executor interface separating workflow enforcement from execution mechanics. The implementation is complete and working, but two issues remain:
+
+1. **Naming**: The production executor is called `GitExecutor`, which implies it's merely a git wrapper. In reality it orchestrates the full MindSpec execution lifecycle — worktree creation, bead dispatch, branch merging, PR creation, and cleanup. The name `MindspecExecutor` better reflects its role as the standard execution engine for the MindSpec workflow.
+
+2. **Documentation gaps**: The architecture documentation doesn't clearly articulate the conceptual model. The Workflow layer is responsible for feeding the Execution engine a plan that has been broken down into bitesize beads — reviewed thoroughly, validated against architecture, with high-quality tests and clear acceptance criteria. The Execution engine is responsible for implementing those beads. This maps to research on scaling agent systems (Kim et al., "Towards a Science of Scaling Agent Systems," arXiv:2512.08296) which demonstrates that task decomposition quality directly impacts agent execution success.
+
+3. **Test staleness**: The recent change to stop between beads (rather than auto-continuing) may have invalidated some LLM test scenario assumptions. All 18 scenarios need a thorough review.
+
+4. **Legacy terminology**: The codebase still contains references to `gitops` (the pre-077 name for `gitutil`) and `specinit` (the package name for spec creation). These legacy names should be cleaned up:
+   - `gitops` appears in test fixtures, historical spec docs, and HISTORY.md
+   - `specinit` is still a live Go package (`internal/specinit/`) — should be renamed to something that reflects the workflow layer's vocabulary (e.g., `internal/spec/` or folded into the `spec create` command path)
+   - Old spec/plan documents (048, 050, 051, 058, 062) reference `gitops` — these are historical artifacts but comments/cross-references in live code should be updated
+
+## Impacted Domains
+
+- **execution**: Rename `GitExecutor` → `MindspecExecutor` across package, tests, docs, and DI wiring
+- **workflow**: Update documentation references to executor naming
+- **context-system**: Update domain docs, architecture descriptions, and AGENTS.md
+- **core**: Update MEMORY.md references (auto-memory files)
+
+## ADR Touchpoints
+
+- [ADR-0023](../../adr/ADR-0023.md): Beads as single state authority — documentation should reference this as foundation for the decomposition model
+- [ADR-0006](../../adr/ADR-0006.md): Protected main with PR-based merging — execution layer documentation should reference this
+
+## Requirements
+
+### R1: Rename GitExecutor → MindspecExecutor
+
+1. Rename file `internal/executor/git.go` → `internal/executor/mindspec_executor.go`
+2. Rename `GitExecutor` struct to `MindspecExecutor`
+3. Rename `NewGitExecutor` constructor to `NewMindspecExecutor`
+4. Update all references in:
+   - `internal/executor/executor_test.go`
+   - `cmd/mindspec/root.go` (DI factory)
+   - Domain documentation (`execution/overview.md`, `execution/architecture.md`, `execution/interfaces.md`)
+   - `AGENTS.md` section on Workflow/Execution Boundary
+   - Auto-memory files referencing `GitExecutor`
+
+### R1b: Purge legacy `gitops` terminology
+
+1. Update `internal/adr/store_test.go` test fixture — replace `gitops` tag with `gitutil` or `execution`
+2. Update comment in `internal/executor/git.go` (line 74) referencing `specinit`
+3. Update any live code comments referencing `gitops` (historical spec docs are left as-is — they're closed artifacts)
+
+### R1c: Rename `specinit` package
+
+1. Rename `internal/specinit/` → `internal/spec/` (or `internal/speccreate/`)
+2. Update all import paths:
+   - `cmd/mindspec/spec.go`
+   - `cmd/mindspec/spec_init.go`
+   - `internal/executor/git.go` (comment reference)
+   - `internal/lifecycle/scenario_test.go` (comments)
+3. Update domain documentation referencing `specinit`
+4. Update AGENTS.md and MEMORY.md references
+5. Update `spec_init.go` backward-compat alias registration in `root.go`
+
+### R2: Architecture documentation overhaul
+
+1. Update `AGENTS.md` §138–147 to clearly describe the two-layer model:
+   - **Workflow layer**: Responsible for spec creation, plan decomposition into bitesize beads, validation against architecture (ADRs, domain boundaries), quality gates (tests, acceptance criteria), and phase enforcement
+   - **Execution engine**: Responsible for implementing the plan — dispatching beads to worktrees, executing code changes, merging results, and finalizing the spec
+2. Update `.mindspec/docs/domains/execution/overview.md` with the refined conceptual model
+3. Update `.mindspec/docs/domains/execution/architecture.md` to reference `MindspecExecutor`
+4. Update `.mindspec/docs/domains/workflow/` docs to describe the workflow layer's responsibility for plan quality
+5. Reference the decomposition research (arXiv:2512.08296) where appropriate
+
+### R4: Harden phase-transition stop behavior
+
+Observed failure mode: after `mindspec approve plan`, the agent auto-proceeded to implement bead 1 on the spec branch instead of stopping, running `/clear`, and using `mindspec next` to create a proper bead worktree. Two root causes:
+
+1. **`plan.md` instruct template is outdated** — still says "This will approve the plan AND automatically claim the first bead" (false since Spec 080)
+2. **Plan approve output is not emphatic enough** — agent ignored the "Run /clear" guidance
+3. **`mindspec complete` output says "Next bead ready: X"** which implicitly invites continuation
+
+Fixes:
+
+1. **Fix `plan.md` template** — remove the "auto-claim" lie. Clearly state: after plan approval, STOP. Run `/clear` or start a fresh agent, then `mindspec next`.
+2. **Strengthen plan approve CLI output** — make the STOP instruction unmissable. Use a clear separator/banner.
+3. **Strengthen `mindspec complete` CLI output** — after reporting "Next bead ready", add explicit STOP instruction: "Run `/clear`, then `mindspec next` to claim it."
+4. **Remove dead `--no-next` flag** from `approve.go` — it's unused and misleading.
+5. **Classify `mindspec next` and `mindspec complete` as execution layer commands** in documentation — they create/destroy worktrees and manage branch topology, which is execution, not workflow.
+
+Note: `mindspec next` already correctly branches from the spec branch via `exec.DispatchBead(beadID, specID)`. No new `--base-branch` parameter needed — the specID already determines the base. The problem was the agent skipping `mindspec next` entirely.
+
+### R3: LLM test scenario audit
+
+Review all 18 scenarios in `internal/harness/scenario.go` and `scenario_test.go`:
+
+1. **Verify each scenario's assumptions** match current behavior (stop between beads, manual `mindspec next`)
+2. **Flag scenarios that are outdated** or test behavior that no longer exists
+3. **Document findings** in `internal/harness/HISTORY.md` as a test audit section
+4. **Fix any broken test expectations** — update assertions, prompts, or setup to match current behavior
+5. Specific scenarios to scrutinize:
+   - `TestLLM_SpecToIdle` — does the 100-turn full lifecycle still work with manual bead transitions?
+   - `TestLLM_MultiBeadDeps` — already expects manual `mindspec next`, should be OK
+   - `TestLLM_BlockedBeadTransition` — mode should be `plan` when only blocked beads remain
+   - `TestLLM_UnmergedBeadGuard` — tests recovery flow, verify assumptions
+   - Any test that previously assumed auto-continuation between beads
+
+## Scope
+
+### In Scope
+
+- `internal/executor/git.go` → `internal/executor/mindspec_executor.go` (file rename + struct/constructor rename)
+- `internal/executor/executor_test.go` — update references
+- `internal/executor/mock.go` — no changes expected (already `MockExecutor`)
+- `cmd/mindspec/root.go` — update DI factory
+- `internal/specinit/` → `internal/spec/` (package rename)
+- `cmd/mindspec/spec.go`, `cmd/mindspec/spec_init.go` — update imports
+- `internal/adr/store_test.go` — update `gitops` test fixture
+- `.mindspec/docs/domains/execution/` — all three docs
+- `.mindspec/docs/domains/workflow/` — architecture and overview updates
+- `AGENTS.md` — architecture section + legacy terminology
+- `internal/harness/scenario.go` — test scenario review and fixes
+- `internal/harness/scenario_test.go` — test function review and fixes
+- `internal/harness/HISTORY.md` — test audit findings
+- `internal/instruct/templates/plan.md` — fix outdated auto-claim guidance
+- `internal/instruct/templates/implement.md` — strengthen STOP after complete
+- `cmd/mindspec/plan_cmd.go` — strengthen plan approve output
+- `cmd/mindspec/complete.go` or `internal/complete/complete.go` — strengthen complete output
+- `cmd/mindspec/approve.go` — remove dead `--no-next` flag
+- Auto-memory files referencing old naming
+
+### Out of Scope
+
+- New Executor implementations (e.g., GastownExecutor)
+- Changes to the `Executor` interface itself
+- New LLM test scenarios (only reviewing/fixing existing ones)
+- Changes to `internal/gitutil/` package
+- Historical spec/plan documents (048, 050, 051, 058, 062, 077 — closed artifacts, left as-is)
+
+## Non-Goals
+
+- Changing the Executor interface methods or signatures
+- Adding new executor capabilities
+- Refactoring the workflow layer's internal logic
+- Writing new LLM test scenarios beyond fixing existing ones
+- Updating historical spec/plan documents that reference `gitops` — these are closed artifacts
+- Renaming `internal/gitutil/` (already correct per Spec 077)
+
+## Acceptance Criteria
+
+- [ ] `GitExecutor` renamed to `MindspecExecutor` everywhere (zero grep hits for `GitExecutor` in live code)
+- [ ] `NewGitExecutor` renamed to `NewMindspecExecutor` everywhere
+- [ ] `git.go` renamed to `mindspec_executor.go`
+- [ ] `internal/specinit/` renamed (zero grep hits for `specinit` in Go imports)
+- [ ] Zero grep hits for `gitops` in live Go code (test fixtures, comments)
+- [ ] `make build` succeeds
+- [ ] `go test ./internal/executor/... -v` passes
+- [ ] `go test ./internal/... -v` passes (catch import path breakage)
+- [ ] `go vet ./...` clean
+- [ ] AGENTS.md clearly describes the two-layer architecture with workflow/execution responsibilities
+- [ ] Domain docs updated with `MindspecExecutor` naming and refined conceptual model
+- [ ] All 18 LLM test scenarios reviewed — findings documented in HISTORY.md
+- [ ] Any outdated test expectations fixed
+- [ ] `go test ./internal/harness/ -run TestLLM_SingleBead -timeout 10m` passes (smoke test)
+- [ ] `plan.md` template no longer claims auto-claim behavior
+- [ ] Plan approve output includes emphatic STOP + `/clear` + `mindspec next` instructions
+- [ ] `mindspec complete` output includes STOP + `/clear` instruction when next bead is ready
+- [ ] Dead `--no-next` flag removed from `approve.go`
+- [ ] Documentation classifies `mindspec next` and `mindspec complete` as execution layer commands
+
+## Validation Proofs
+
+- `grep -r "GitExecutor" internal/ cmd/` → zero results
+- `grep -r "NewGitExecutor" internal/ cmd/` → zero results
+- `grep -rn "specinit" --include="*.go" internal/ cmd/` → zero import hits
+- `grep -rn "gitops" --include="*.go" internal/ cmd/` → zero hits
+- `ls internal/executor/mindspec_executor.go` → exists
+- `ls internal/spec/` → exists (replaces `internal/specinit/`)
+- `make build` → exit 0
+- `go test ./internal/executor/... -v` → all pass
+- `go test ./internal/... -v` → all pass
+- `go vet ./...` → clean
+
+## Open Questions
+
+- [x] Should `internal/specinit/` become `internal/spec/` or `internal/speccreate/`? → **`internal/spec/`** — shorter, natural, no collision risk since it's the only package dealing with spec creation.
+
+## Approval
+
+- **Status**: APPROVED
+- **Approved By**: user
+- **Approval Date**: 2026-03-10
+- **Notes**: Approved via mindspec approve spec
\ No newline at end of file
diff --git a/AGENTS.md b/AGENTS.md
index f03fbdd..c234b85 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -139,10 +139,37 @@ For more details, see README.md and docs/QUICKSTART.md.
 
 MindSpec has a two-layer architecture separating *what* from *how*:
 
-- **Workflow layer** (`internal/approve/`, `internal/complete/`, `internal/next/`, `internal/cleanup/`, `internal/specinit/`) — decides what operations should happen (approval gates, phase transitions, bead selection)
-- **Execution layer** (`internal/executor/`, `internal/gitutil/`) — performs git, worktree, and filesystem operations
+### Workflow Layer (the "what")
 
-**Import rule**: Workflow packages call `executor.Executor` methods. They MUST NOT import `internal/gitutil/` directly. This keeps enforcement logic testable with `MockExecutor` and decouples workflow decisions from git mechanics.
+The workflow layer owns the spec-driven development lifecycle — deciding which operations should happen and enforcing quality at every gate:
+
+- **Spec creation** — `internal/spec/` creates spec branches, worktrees, and template files
+- **Plan decomposition** — breaks specs into bitesize beads with clear acceptance criteria. Well-decomposed plans are critical for AI agent success (see [arXiv:2512.08296](https://arxiv.org/abs/2512.08296) on task decomposition quality)
+- **Validation** — `internal/validate/` checks ADR compliance, doc-sync, and structural requirements
+- **Quality gates** — `internal/approve/` enforces human-in-the-loop approval at spec, plan, and impl transitions
+- **Phase enforcement** — `internal/phase/` derives lifecycle phase from beads epic/child statuses (ADR-0023)
+- **Work selection** — `internal/next/` selects ready beads, `internal/complete/` orchestrates bead close-out
+- **Cleanup** — `internal/cleanup/` handles post-lifecycle worktree/branch removal
+
+Key packages: `internal/approve/`, `internal/complete/`, `internal/next/`, `internal/spec/`, `internal/cleanup/`, `internal/phase/`, `internal/validate/`, `internal/bead/`
+
+### Beads: The Substrate
+
+[Beads](https://github.com/steveyegge/beads) is the interface between the two layers. Each bead is a self-contained work packet — requirements, context, dependencies, acceptance criteria — that a fresh agent can pick up without session history. The planning layer writes beads; the execution engine reads them. This is what makes the `Executor` interface pluggable: any orchestrator that can read a bead can dispatch work.
+
+### Execution Engine (the "how")
+
+The execution engine reads beads and implements them — it never decides *what* should happen:
+
+- **`MindspecExecutor`** (`internal/executor/`) — dispatches beads to worktrees, merges completed bead branches, finalizes specs via PR or direct merge
+- **`MockExecutor`** (`internal/executor/`) — test double for enforcement testing without git side effects
+- **`internal/gitutil/`** — low-level git helpers (branch, merge, PR, diffstat) used only by `MindspecExecutor`
+
+DI wiring: `cmd/mindspec/root.go` has `newExecutor(root)` factory.
+
+### Import Rule
+
+Workflow packages call `executor.Executor` methods. They MUST NOT import `internal/gitutil/` directly. This keeps enforcement logic testable with `MockExecutor` and decouples workflow decisions from git mechanics.
 
 See `.mindspec/docs/domains/execution/` and `.mindspec/docs/domains/workflow/` for full documentation.
 
diff --git a/README.md b/README.md
index be8e9c3..a0df75d 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,14 @@
 # MindSpec
 
-**Spec-driven development and real-time observability for AI coding agents.**
+**A planning and governance layer for AI coding agents.**
 
-AI coding agents are powerful but unstructured. Without guardrails they:
+AI coding agents are powerful executors but poor planners. Without structure, they drift from intent, steamroll architecture decisions, and let scope creep turn a small feature into a three-subsystem refactor.
 
-- **Drift from intent** — the agent builds what it infers, not what you specified
-- **Ignore architecture** — existing design decisions and ADRs get steamrolled
-- **Lose context between sessions** — every conversation starts from scratch
-- **Skip documentation** — code ships, docs rot
-- **Resist scope discipline** — a "small feature" becomes a refactor of three subsystems
+The fix isn't better prompting — it's better planning.
 
-MindSpec treats these as system design problems, not prompting problems. It provides a **gated development lifecycle** where architecture divergence is detected and blocked until explicitly resolved, **bounded contexts** borrowed from domain-driven design to manage what the agent sees — deterministic, token-budgeted context packs assembled from domain docs, ADRs, and the Context Map so the agent gets exactly the right context without manual prompt engineering — and an **observability layer** (AgentMind) that shows you exactly what your agent is doing, spending, and how efficiently it's working.
+MindSpec is the **planning and governance layer** that sits upstream of your agent orchestrator. It breaks work into spec → plan → bitesize beads, validates each bead against your architecture (ADRs, domain boundaries), and enforces quality gates before any code gets written. The result is a structured plan with clear acceptance criteria that any execution engine — Claude Code working solo, a multi-agent orchestrator like [Gastown](https://github.com/steveyegge/gastown), or OpenAI Codex — can implement reliably.
+
+Research on scaling agent systems ([arXiv:2512.08296](https://arxiv.org/abs/2512.08296)) confirms what we've seen in practice: **task decomposition quality is the #1 predictor of agent execution success.** MindSpec exists to get the decomposition right.
 
 <p align="center">
   <img src="agentmind.png" alt="AgentMind — AI Agent Observability UI" width="800" />
@@ -81,6 +79,44 @@ The work graph is tracked by [Beads](https://github.com/steveyegge/beads), a git
 
 Documentation stays current because the system won't let you skip it — beads can't close without doc-sync, architecture decisions are tracked as ADRs that plans must cite, and every spec produces versioned artifacts that persist alongside the code.
 
+## Architecture
+
+MindSpec separates **planning** from **execution**, with [Beads](https://github.com/steveyegge/beads) as the substrate that connects them.
+
+### Planning & Governance Layer
+
+The planning layer owns everything *before* code gets written:
+
+- **Specification** — defines what "done" looks like with acceptance criteria and impacted domains
+- **Decomposition** — breaks specs into bitesize beads, each independently completable with clear scope
+- **Architecture validation** — plans must cite ADRs; divergence is blocked until a human approves a superseding ADR
+- **Quality gates** — every phase transition (spec → plan → implement → review) requires human approval
+- **Context engineering** — deterministic, token-budgeted context packs so the agent gets exactly the right information
+
+The planning layer doesn't write code. It produces a validated plan — a directed graph of beads with dependencies, acceptance criteria, and scoped documentation — then hands it off.
+
+### Beads: The Substrate
+
+[Beads](https://github.com/steveyegge/beads) is the interface between the two layers. Each bead is a self-contained work packet that encapsulates everything a fresh agent needs:
+
+- **Requirements** — what to build, with acceptance criteria and verification steps
+- **Context** — which domains are impacted, which ADRs apply, what dependencies exist
+- **Status** — lifecycle phase, blocking relationships, proof of completion
+
+This is what makes pluggable orchestration possible. The planning layer writes beads; the execution engine reads them. A fresh agent picking up a bead doesn't need session history or tribal knowledge — the bead carries the plan and the context. Any orchestrator that can read a bead can dispatch work.
+
+### Execution Engine
+
+The execution engine implements the plan by reading beads and dispatching agents:
+
+- **Bead dispatch** — each bead runs in an isolated git worktree, scoped to exactly what the plan defined
+- **Merge topology** — bead branches merge into the spec branch; the spec branch merges to main via PR
+- **Finalization** — once all beads close, the spec lifecycle completes with a single PR
+
+MindSpec ships with a built-in execution engine (`MindspecExecutor`) that drives Claude Code, Codex, or Copilot through implementation with human control between steps. But the `Executor` interface is pluggable — MindSpec's planning and governance layer can readily plug into multi-agent orchestrators like [Gastown](https://github.com/steveyegge/gastown), dispatching beads to parallel agents with their own quality gates and auto-finalization.
+
+**MindSpec doesn't compete with agent orchestrators — it makes them better.** An orchestrator running MindSpec-planned beads gets architecture-validated, well-decomposed work packets instead of a vague prompt. The orchestrator focuses on execution; MindSpec ensures there's something worth executing.
+
 ---
 
 ## Quickstart
@@ -151,6 +187,7 @@ MindSpec's workflow is continuously validated by a behavioral test harness that
 6. **Dynamic over static** — runtime guidance beats static files that drift
 7. **CLI-first** — logic lives in testable, versionable Go; IDE integrations are thin shims
 8. **Deterministic context** — token-budgeted context packs, not "go read this file" prompting
+9. **Planning over prompting** — structured decomposition beats prompt engineering at scale
 
 ## Requirements
 
diff --git a/cmd/mindspec/approve.go b/cmd/mindspec/approve.go
index 8faad62..c6452d2 100644
--- a/cmd/mindspec/approve.go
+++ b/cmd/mindspec/approve.go
@@ -38,7 +38,6 @@ var approveImplCmd = &cobra.Command{
 func init() {
 	approveSpecCmd.Flags().String("approved-by", "user", "Identity of the approver")
 	approvePlanCmd.Flags().String("approved-by", "user", "Identity of the approver")
-	approvePlanCmd.Flags().Bool("no-next", false, "Approve without auto-claiming the first bead")
 	approveCmd.AddCommand(approveSpecCmd)
 	approveCmd.AddCommand(approvePlanCmd)
 	approveCmd.AddCommand(approveImplCmd)
diff --git a/cmd/mindspec/root.go b/cmd/mindspec/root.go
index af4b05a..46d04e1 100644
--- a/cmd/mindspec/root.go
+++ b/cmd/mindspec/root.go
@@ -11,10 +11,10 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// newExecutor creates a GitExecutor rooted at the given path.
+// newExecutor creates a MindspecExecutor rooted at the given path.
 // Used as a factory function across CLI commands.
 func newExecutor(root string) executor.Executor {
-	return executor.NewGitExecutor(root)
+	return executor.NewMindspecExecutor(root)
 }
 
 // Set by goreleaser ldflags.
diff --git a/cmd/mindspec/spec.go b/cmd/mindspec/spec.go
index 8f7f9a4..69daf47 100644
--- a/cmd/mindspec/spec.go
+++ b/cmd/mindspec/spec.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/mrmaxsteel/mindspec/internal/approve"
 	"github.com/mrmaxsteel/mindspec/internal/bead"
-	"github.com/mrmaxsteel/mindspec/internal/specinit"
+	"github.com/mrmaxsteel/mindspec/internal/spec"
 	"github.com/mrmaxsteel/mindspec/internal/workspace"
 	"github.com/spf13/cobra"
 )
@@ -33,7 +33,7 @@ creates a branch and worktree, sets state to spec mode, and emits guidance.`,
 		}
 
 		exec := newExecutor(root)
-		result, err := specinit.Run(root, specID, title, exec)
+		result, err := spec.Run(root, specID, title, exec)
 		if err != nil {
 			return err
 		}
diff --git a/cmd/mindspec/spec_init.go b/cmd/mindspec/spec_init.go
index ea306ae..46d49c7 100644
--- a/cmd/mindspec/spec_init.go
+++ b/cmd/mindspec/spec_init.go
@@ -5,7 +5,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/mrmaxsteel/mindspec/internal/specinit"
+	"github.com/mrmaxsteel/mindspec/internal/spec"
 	"github.com/mrmaxsteel/mindspec/internal/workspace"
 	"github.com/spf13/cobra"
 )
@@ -26,7 +26,7 @@ var specInitCmd = &cobra.Command{
 		}
 
 		exec := newExecutor(root)
-		result, err := specinit.Run(root, specID, title, exec)
+		result, err := spec.Run(root, specID, title, exec)
 		if err != nil {
 			return err
 		}
diff --git a/internal/adr/store_test.go b/internal/adr/store_test.go
index ad1cc73..838a7b6 100644
--- a/internal/adr/store_test.go
+++ b/internal/adr/store_test.go
@@ -100,7 +100,7 @@ func TestFileStore_Get(t *testing.T) {
 
 func TestFileStore_Search(t *testing.T) {
 	root := t.TempDir()
-	writeADR(t, root, "ADR-0001", "Worktree Management", "Accepted", []string{"gitops"})
+	writeADR(t, root, "ADR-0001", "Worktree Management", "Accepted", []string{"execution"})
 	writeADR(t, root, "ADR-0002", "Bead Lifecycle", "Accepted", []string{"workflow"})
 
 	store := NewFileStore(root)
diff --git a/internal/approve/plan.go b/internal/approve/plan.go
index be3c3c4..535acd2 100644
--- a/internal/approve/plan.go
+++ b/internal/approve/plan.go
@@ -123,7 +123,7 @@ func ApprovePlan(root, specID, approvedBy string, exec executor.Executor) (*Plan
 	}
 
 	// Step 5: HandoffEpic — notify executor that beads are ready for dispatch.
-	// For GitExecutor this is a no-op. Other executors may use this to schedule work.
+	// For MindspecExecutor this is a no-op. Other executors may use this to schedule work.
 	if parentID != "" && len(result.BeadIDs) > 0 {
 		if err := exec.HandoffEpic(parentID, specID, result.BeadIDs); err != nil {
 			result.Warnings = append(result.Warnings, fmt.Sprintf("handoff epic failed: %v", err))
diff --git a/internal/bead/bdcli.go b/internal/bead/bdcli.go
index 36f53ad..9755523 100644
--- a/internal/bead/bdcli.go
+++ b/internal/bead/bdcli.go
@@ -122,15 +122,12 @@ func WorktreeList() ([]WorktreeListEntry, error) {
 	return entries, nil
 }
 
-// WorktreeRemove removes a worktree via `bd worktree remove`.
-// Beads performs safety checks (uncommitted changes, unpushed commits).
-// When no git remote is configured, --force is passed to skip the
-// unpushed-commits check (which would always fail without a remote).
+// WorktreeRemove removes a worktree via `bd worktree remove --force`.
+// The --force flag skips the "unpushed commits" safety check, which is
+// appropriate because mindspec always merges bead work into the spec
+// branch before removing the worktree.
 func WorktreeRemove(name string) error {
-	args := []string{"worktree", "remove", name}
-	if !hasGitRemote() {
-		args = append(args, "--force")
-	}
+	args := []string{"worktree", "remove", name, "--force"}
 	out, err := tracedCombined("worktree-remove", args)
 	if err != nil {
 		return fmt.Errorf("bd worktree remove failed: %s", string(out))
@@ -138,16 +135,6 @@ func WorktreeRemove(name string) error {
 	return nil
 }
 
-// hasGitRemote returns true if at least one git remote is configured.
-func hasGitRemote() bool {
-	cmd := execCommand("git", "remote")
-	out, err := cmd.Output()
-	if err != nil {
-		return false
-	}
-	return strings.TrimSpace(string(out)) != ""
-}
-
 // ListJSON runs `bd list <args> --json` and returns valid JSON bytes (a JSON array).
 // Works around bd versions where --json is ignored by falling back to
 // parsing IDs from human-readable output and fetching each with `bd show --json`.
diff --git a/internal/bead/bdcli_test.go b/internal/bead/bdcli_test.go
index 6a5a1a9..9788e76 100644
--- a/internal/bead/bdcli_test.go
+++ b/internal/bead/bdcli_test.go
@@ -325,7 +325,7 @@ func TestWorktreeRemove_ArgsConstruction(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	expected := []string{"bd", "worktree", "remove", "worktree-bead-abc"}
+	expected := []string{"bd", "worktree", "remove", "worktree-bead-abc", "--force"}
 	if len(capturedArgs) != len(expected) {
 		t.Fatalf("args: got %v, want %v", capturedArgs, expected)
 	}
diff --git a/internal/complete/complete.go b/internal/complete/complete.go
index 5a1dd9c..65e44cc 100644
--- a/internal/complete/complete.go
+++ b/internal/complete/complete.go
@@ -18,13 +18,14 @@ import (
 
 // Package-level function variables for testability.
 var (
-	closeBeadFn     = bead.Close
-	worktreeListFn  = bead.WorktreeList
-	runBDFn         = bead.RunBD
-	listJSONFn      = bead.ListJSON
-	resolveTargetFn = resolve.ResolveTarget
-	findLocalRootFn = defaultFindLocalRoot
-	fetchBeadByIDFn = next.FetchBeadByID
+	closeBeadFn       = bead.Close
+	worktreeListFn    = bead.WorktreeList
+	runBDFn           = bead.RunBD
+	listJSONFn        = bead.ListJSON
+	resolveTargetFn   = resolve.ResolveTarget
+	findLocalRootFn   = defaultFindLocalRoot
+	fetchBeadByIDFn   = next.FetchBeadByID
+	findEpicForBeadFn = phase.FindEpicForBead
 )
 
 // Result summarizes what mindspec complete did.
@@ -60,6 +61,13 @@ func Run(root, beadID, specIDHint, commitMsg string, exec executor.Executor) (*R
 	if err != nil && localRoot != root {
 		specID, err = resolveTargetFn(root, specIDHint)
 	}
+	// If still ambiguous but we have a bead ID, resolve spec from the bead's parent epic.
+	if err != nil && beadID != "" {
+		if _, derivedSpec, beadErr := findEpicForBeadFn(beadID); beadErr == nil && derivedSpec != "" {
+			specID = derivedSpec
+			err = nil
+		}
+	}
 	if err != nil {
 		return nil, fmt.Errorf("resolving active spec: %w", err)
 	}
@@ -178,6 +186,7 @@ func FormatResult(r *Result) string {
 	case state.ModeImplement:
 		fmt.Fprintf(&sb, "Next bead ready: %s\n", r.NextBead)
 		fmt.Fprintf(&sb, "Mode: implement (spec: %s)\n", r.NextSpec)
+		sb.WriteString("\nSTOP HERE. Do NOT run `mindspec next` or claim another bead.\nReport completion to the user and wait for instructions.\n")
 	case state.ModePlan:
 		fmt.Fprintf(&sb, "Remaining beads are blocked. Mode: plan (spec: %s)\n", r.NextSpec)
 		if r.WorktreeRemoved && r.SpecWorktree != "" {
diff --git a/internal/executor/executor.go b/internal/executor/executor.go
index cdce5d4..16bcccf 100644
--- a/internal/executor/executor.go
+++ b/internal/executor/executor.go
@@ -7,10 +7,10 @@
 package executor
 
 // Executor abstracts workspace lifecycle operations. Implementations include
-// GitExecutor (local git+worktrees) and MockExecutor (testing).
+// MindspecExecutor (local git+worktrees) and MockExecutor (testing).
 //
 // Terminology: "workspace" means an isolated working copy (git worktree in
-// GitExecutor, no-op directory in MockExecutor). "Epic" is a group of beads
+// MindspecExecutor, no-op directory in MockExecutor). "Epic" is a group of beads
 // (implementation tasks) belonging to a single spec lifecycle.
 type Executor interface {
 	// InitSpecWorkspace creates a workspace for spec authoring.
@@ -18,7 +18,7 @@ type Executor interface {
 	InitSpecWorkspace(specID string) (WorkspaceInfo, error)
 
 	// HandoffEpic notifies the execution layer that beads are ready for
-	// dispatch. For GitExecutor this is a no-op (beads are already created
+	// dispatch. For MindspecExecutor this is a no-op (beads are already created
 	// by the enforcement layer). Other executors may use this to schedule
 	// work distribution.
 	HandoffEpic(epicID, specID string, beadIDs []string) error
diff --git a/internal/executor/executor_test.go b/internal/executor/executor_test.go
index a060288..b52b195 100644
--- a/internal/executor/executor_test.go
+++ b/internal/executor/executor_test.go
@@ -13,11 +13,11 @@ import (
 
 // --- Helpers ---
 
-func newTestExecutor(t *testing.T) *GitExecutor {
+func newTestExecutor(t *testing.T) *MindspecExecutor {
 	t.Helper()
 	root := t.TempDir()
 
-	g := &GitExecutor{
+	g := &MindspecExecutor{
 		Root: root,
 		// Defaults: all no-op / success.
 		CreateBranchFn:    func(name, from string) error { return nil },
@@ -43,8 +43,8 @@ func newTestExecutor(t *testing.T) *GitExecutor {
 
 // --- Interface compliance ---
 
-func TestGitExecutorImplementsExecutor(t *testing.T) {
-	var _ Executor = (*GitExecutor)(nil)
+func TestMindspecExecutorImplementsExecutor(t *testing.T) {
+	var _ Executor = (*MindspecExecutor)(nil)
 }
 
 func TestMockExecutorImplementsExecutor(t *testing.T) {
diff --git a/internal/executor/git.go b/internal/executor/mindspec_executor.go
similarity index 88%
rename from internal/executor/git.go
rename to internal/executor/mindspec_executor.go
index c08fa23..0157a8f 100644
--- a/internal/executor/git.go
+++ b/internal/executor/mindspec_executor.go
@@ -12,12 +12,12 @@ import (
 	"github.com/mrmaxsteel/mindspec/internal/gitutil"
 )
 
-// GitExecutor implements Executor using local git operations and beads
+// MindspecExecutor implements Executor using local git operations and beads
 // worktree CLI. It preserves all current behavior: worktree-first creation,
 // --no-ff merges, .gitignore management.
 //
 // Function fields are exposed for testability via injection.
-type GitExecutor struct {
+type MindspecExecutor struct {
 	Root string // Main repo root (absolute path)
 
 	// Git operations (default to gitutil package functions).
@@ -46,9 +46,9 @@ type GitExecutor struct {
 	ExecCommandFn func(name string, arg ...string) *exec.Cmd
 }
 
-// NewGitExecutor creates a GitExecutor with default function bindings.
-func NewGitExecutor(root string) *GitExecutor {
-	return &GitExecutor{
+// NewMindspecExecutor creates a MindspecExecutor with default function bindings.
+func NewMindspecExecutor(root string) *MindspecExecutor {
+	return &MindspecExecutor{
 		Root:              root,
 		CreateBranchFn:    gitutil.CreateBranch,
 		BranchExistsFn:    gitutil.BranchExists,
@@ -71,8 +71,8 @@ func NewGitExecutor(root string) *GitExecutor {
 }
 
 // InitSpecWorkspace creates a workspace for spec authoring.
-// Mirrors the logic in internal/specinit/specinit.go (Phase 1).
-func (g *GitExecutor) InitSpecWorkspace(specID string) (WorkspaceInfo, error) {
+// Mirrors the logic in internal/spec/create.go (Phase 1).
+func (g *MindspecExecutor) InitSpecWorkspace(specID string) (WorkspaceInfo, error) {
 	cfg, err := g.LoadConfigFn(g.Root)
 	if err != nil {
 		return WorkspaceInfo{}, fmt.Errorf("loading config: %w", err)
@@ -106,16 +106,16 @@ func (g *GitExecutor) InitSpecWorkspace(specID string) (WorkspaceInfo, error) {
 	return WorkspaceInfo{Path: wtPath, Branch: specBranch}, nil
 }
 
-// HandoffEpic is a no-op for GitExecutor. Beads are already created by the
+// HandoffEpic is a no-op for MindspecExecutor. Beads are already created by the
 // enforcement layer (plan approve). Other executor implementations (e.g.
 // Gastown) may use this to schedule work distribution.
-func (g *GitExecutor) HandoffEpic(epicID, specID string, beadIDs []string) error {
+func (g *MindspecExecutor) HandoffEpic(epicID, specID string, beadIDs []string) error {
 	return nil
 }
 
 // DispatchBead creates a workspace for a bead implementation.
 // Mirrors the logic in internal/next/beads.go EnsureWorktree().
-func (g *GitExecutor) DispatchBead(beadID, specID string) (WorkspaceInfo, error) {
+func (g *MindspecExecutor) DispatchBead(beadID, specID string) (WorkspaceInfo, error) {
 	cfg, err := g.LoadConfigFn(g.Root)
 	if err != nil {
 		cfg = config.DefaultConfig()
@@ -182,7 +182,7 @@ func (g *GitExecutor) DispatchBead(beadID, specID string) (WorkspaceInfo, error)
 
 // CompleteBead closes out a bead: commits, merges into spec, removes worktree,
 // deletes branch. Mirrors the logic in internal/complete/complete.go.
-func (g *GitExecutor) CompleteBead(beadID, specBranch, msg string) error {
+func (g *MindspecExecutor) CompleteBead(beadID, specBranch, msg string) error {
 	beadBranch := "bead/" + beadID
 	wtName := "worktree-" + beadID
 
@@ -230,6 +230,15 @@ func (g *GitExecutor) CompleteBead(beadID, specBranch, msg string) error {
 		}
 	}
 
+	// Safety check: verify bead branch is merged into spec branch before cleanup.
+	// This prevents data loss if the merge above failed silently.
+	if g.BranchExistsFn(beadBranch) {
+		isAnc, ancErr := g.IsAncestorFn(g.Root, beadBranch, specBranch)
+		if ancErr != nil || !isAnc {
+			return fmt.Errorf("bead branch %s is NOT merged into %s — aborting cleanup to prevent data loss", beadBranch, specBranch)
+		}
+	}
+
 	// Remove worktree and delete branch from repo root (not from inside the
 	// worktree being removed). Matches the pattern in FinalizeEpic().
 	if err := withWorkingDir(g.Root, func() error {
@@ -252,7 +261,7 @@ func (g *GitExecutor) CompleteBead(beadID, specBranch, msg string) error {
 // FinalizeEpic merges the spec branch to main, cleans up workspaces and
 // branches. Handles bead branch auto-merge into the spec branch before
 // cleanup, ensuring all bead work is integrated.
-func (g *GitExecutor) FinalizeEpic(epicID, specID, specBranch string) (FinalizeResult, error) {
+func (g *MindspecExecutor) FinalizeEpic(epicID, specID, specBranch string) (FinalizeResult, error) {
 	result := FinalizeResult{}
 
 	if !g.BranchExistsFn(specBranch) {
@@ -352,7 +361,7 @@ func (g *GitExecutor) FinalizeEpic(epicID, specID, specBranch string) (FinalizeR
 
 // Cleanup removes stale workspaces and branches for a spec.
 // Mirrors the logic in internal/cleanup/cleanup.go.
-func (g *GitExecutor) Cleanup(specID string, force bool) error {
+func (g *MindspecExecutor) Cleanup(specID string, force bool) error {
 	specBranch := "spec/" + specID
 	specWtName := "worktree-spec-" + specID
 
@@ -374,7 +383,7 @@ func (g *GitExecutor) Cleanup(specID string, force bool) error {
 }
 
 // IsTreeClean returns nil if the workspace at path has no uncommitted changes.
-func (g *GitExecutor) IsTreeClean(path string) error {
+func (g *MindspecExecutor) IsTreeClean(path string) error {
 	cmd := g.ExecCommandFn("git", "-C", path, "status", "--porcelain")
 	out, err := cmd.Output()
 	if err != nil {
@@ -387,23 +396,23 @@ func (g *GitExecutor) IsTreeClean(path string) error {
 }
 
 // DiffStat returns a short diffstat summary between two refs.
-func (g *GitExecutor) DiffStat(base, head string) (string, error) {
+func (g *MindspecExecutor) DiffStat(base, head string) (string, error) {
 	return g.DiffStatFn(g.Root, base, head)
 }
 
 // CommitCount returns the number of commits between base and head.
-func (g *GitExecutor) CommitCount(base, head string) (int, error) {
+func (g *MindspecExecutor) CommitCount(base, head string) (int, error) {
 	return g.CommitCountFn(g.Root, base, head)
 }
 
 // CommitAll stages all changes and commits with the given message.
-func (g *GitExecutor) CommitAll(path, msg string) error {
+func (g *MindspecExecutor) CommitAll(path, msg string) error {
 	return g.CommitAllFn(path, msg)
 }
 
 // resolveAnchorRoot returns the spec worktree path if it exists, otherwise
 // the main repo root. Bead worktrees are anchored under the spec worktree.
-func (g *GitExecutor) resolveAnchorRoot(specID string) string {
+func (g *MindspecExecutor) resolveAnchorRoot(specID string) string {
 	if specID == "" {
 		return g.Root
 	}
diff --git a/internal/harness/HISTORY.md b/internal/harness/HISTORY.md
index 2ddc80d..372a969 100644
--- a/internal/harness/HISTORY.md
+++ b/internal/harness/HISTORY.md
@@ -518,6 +518,182 @@ Track each test run with: scenario, date, pass/fail, recorded events count, turn
 - **Key observation**: The `bd close` shortcut issue is intermittent on Opus (both scenarios passed in the previous Opus run). The guidance tells the agent to use `mindspec complete`, but `bd close` also works at the beads level. The agent occasionally takes the shorter path.
 - **Total wall time**: ~35 minutes for 18 scenarios (comparable to previous run).
 
+## Test Audit (Spec 081)
+
+**Date**: 2026-03-10
+**Audited by**: Spec 081 Bead 4
+**Context**: Post-ADR-0023 (beads-derived phases), post-Spec 080 (template `{{.ActiveBead}}` fix), post-Bead 1-2 renames (`GitExecutor` → `MindspecExecutor`, `specinit/` → `spec/`, `gitops` → `gitutil`)
+
+### Methodology
+
+Reviewed all 18 scenarios in `scenario.go` against:
+1. Current implement.md template behavior (STOP after complete, manual `mindspec next`)
+2. ADR-0023 phase derivation rules (beads-derived, no focus files)
+3. Bead 1-2 rename impacts on test code
+4. MaxTurns/timeout realism based on HISTORY data
+5. Assertion correctness vs current CLI behavior
+
+### Per-Scenario Findings
+
+#### 1. SpecToIdle — Full lifecycle (idle → spec → plan → implement → review → idle)
+- **Status**: Current, **design tension identified**
+- **Assumptions**: Prompt says "finish only when the project is back in idle" — agent must power through the entire lifecycle in one session
+- **Tension with STOP instruction**: `implement.md` (lines 49, 94) says "After `mindspec complete` succeeds, STOP. Do NOT automatically continue to the next bead." The prompt intentionally overrides this by asking for idle end-state. For single-bead specs, "next bead" is inapplicable (the agent needs `approve impl`, not `mindspec next`), so the STOP is technically about a different action. But the word "STOP" is ambiguous — Opus reasons past it ("don't continue to next bead" ≠ "don't run approve impl"), while Haiku interprets it as "stop everything." This is likely the root cause of Haiku's consistent SpecToIdle failures.
+- **MaxTurns**: 100 — appropriate. Opus needs ~14-39 turns, Haiku needs up to 53
+- **Assertions**: Comprehensive — branch cleanup, worktree removal, mode=idle, pre-approve merge guard
+- **Recommendation**: Either (a) clarify STOP wording in implement.md to specify "do not claim the next bead" instead of bare "STOP", or (b) accept that SpecToIdle is an Opus-tier test that validates the agent can reconcile prompt-level goals with template guidance. Currently PASS on Opus, consistently FAIL on Haiku.
+- **Note**: `assertCommandRanEither` correctly handles `spec create` vs `spec-init` alias
+
+#### 2. SingleBead — Single pre-approved bead implementation
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent creates file, runs `mindspec complete`, bead closes
+- **MaxTurns**: 20 — appropriate. Typically completes in 3-6 turns
+- **Assertions**: greeting.go artifact (with worktree fallback), complete ran, impl( commit message, merge topology, bead state
+- **Note**: Artifact detection includes event-log git-add fallback — robust against worktree cleanup
+
+#### 3. MultiBeadDeps — Three beads with dependency chain
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent uses `mindspec next` between beads (matches STOP-after-complete behavior)
+- **MaxTurns**: 30 — appropriate for 3 beads
+- **Assertions**: Minimal (only checks `mindspec next` ran) — intentional for cost/reliability
+- **Potential improvement**: Could assert at least 2 beads closed, but Haiku reliability makes this fragile
+
+#### 4. InterruptForBug — Mid-bead interrupt for bug fix
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent can handle interrupts within a bead context
+- **MaxTurns**: 25 — appropriate
+- **Assertions**: feature.go artifact only — doesn't verify bug fix commit, but acceptable scope
+
+#### 5. ResumeAfterCrash — Resume in-progress bead with partial work
+- **Status**: Current, no issues
+- **Assumptions valid**: Bead worktree with partial.go exists, agent completes the function
+- **MaxTurns**: 15 — appropriate
+- **Assertions**: partial.go exists, mindspec complete ran
+
+#### 6. SpecInit — Idle → spec create → spec mode
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent discovers `mindspec spec create` from guidance (not raw git)
+- **MaxTurns**: 20 — appropriate
+- **Assertions**: Robust — detects raw git branch/checkout as violations, verifies spec/ branch, worktree, spec.md
+- **Note**: Handles both `spec-init` and `spec create` command forms
+
+#### 7. SpecApprove — Spec → plan mode transition
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent runs approve spec from worktree context
+- **MaxTurns**: 15 — appropriate
+- **Assertions**: approve ran, spec/ branch persists, worktree persists, mode=plan
+
+#### 8. PlanApprove — Plan → implement mode transition
+- **Status**: Current, no issues
+- **Assumptions valid**: Plan approve auto-claims first bead, `mindspec next` is optional
+- **MaxTurns**: 20 — appropriate
+- **Assertions**: approve plan ran, beads created (min 2), optional next/bead checks
+- **Note**: Correctly handles Opus behavior of completing full lifecycle (approve→impl)
+
+#### 9. ImplApprove — Review → idle transition
+- **Status**: Current, no issues
+- **Assumptions valid**: All beads closed, spec branch merged/deleted, worktree removed
+- **MaxTurns**: 15 — appropriate
+- **Assertions**: approve impl ran, pre-approve merge guard, branch deleted, worktree removed, done.go merged
+- **Note**: `preApproveImplMainMergeOrPRViolation` correctly exempts canonical internal merge pattern
+
+#### 10. SpecStatus — Read-only status check
+- **Status**: Current, no issues
+- **Assumptions valid**: No state changes from status command
+- **MaxTurns**: 10 — appropriate
+- **Assertions**: Thorough — no user files modified, main commit count unchanged, worktrees/branches preserved
+- **Note**: `assertMainCommitCountUnchanged` correctly excludes .beads/ infrastructure commits
+
+#### 11. MultipleActiveSpecs — Two specs active, implement one
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent completes 001-alpha without disrupting 002-beta
+- **MaxTurns**: 30 — appropriate
+- **Assertions**: greeting.go, complete ran, bead closed, merge topology, 002-beta children empty
+- **Note**: `--spec` flag assertion was correctly removed (worktree resolution supersedes)
+
+#### 12. StaleWorktree — Recovery when bead worktree missing
+- **Status**: Current, no issues
+- **Assumptions valid**: Spec worktree exists but bead worktree is missing, agent recovers
+- **MaxTurns**: 20 — appropriate
+- **Assertions**: widget.go created, mindspec complete succeeded
+- **Setup note**: Correctly creates bead branch without worktree via `setupWorktrees(sandbox, specID, "", "spec")` + manual branch creation
+
+#### 13. CompleteFromSpecWorktree — Bead completion from spec worktree CWD
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent can complete bead even when CWD is spec worktree (auto-redirect)
+- **MaxTurns**: 15 — appropriate
+- **Assertions**: complete succeeded, bead closed
+
+#### 14. ApproveSpecFromWorktree — Spec approval with artifacts only in worktree
+- **Status**: Current, no issues
+- **Assumptions valid**: Worktree-aware resolution finds spec artifacts
+- **MaxTurns**: 15 — appropriate
+- **Assertions**: approve spec succeeded, branches/worktrees persist
+
+#### 15. ApprovePlanFromWorktree — Plan approval with artifacts only in worktree
+- **Status**: Current, no issues
+- **Assumptions valid**: Plan approval works from worktree context
+- **MaxTurns**: 15 — appropriate
+- **Assertions**: approve plan succeeded, beads created, branch persists (unless full lifecycle completed)
+- **Note**: Relaxed branch assertion correctly handles Opus completing full lifecycle
+
+#### 16. BugfixBranch — Bug fix on branch + PR, not directly on main
+- **Status**: Current, no issues
+- **Assumptions valid**: Agent creates branch, pushes, opens PR — doesn't commit to main
+- **MaxTurns**: 25 — appropriate
+- **Assertions**: non-main branch, main unchanged, git push, gh pr create
+- **Network dependency**: Uses real GitHub remote (`mrmaxsteel/test-mindspec`) — test may fail if GitHub is unreachable
+- **Cleanup**: `cleanupBugfixBranchPRs` handles PR/branch cleanup after test
+
+#### 17. BlockedBeadTransition — Mode → plan when only blocked beads remain
+- **Status**: Current, no issues
+- **Assumptions valid**: After completing bead-1, mode returns to plan (bead-2 blocked by dependency)
+- **MaxTurns**: 20, **TimeoutMin**: 10 — appropriate
+- **Assertions**: complete ran, bead-1 closed, bead-2 open, **mode=plan** (critical assertion)
+- **Key test**: `assertMindspecMode(t, sandbox, "plan")` catches `bd close` shortcut — bd close skips state transitions
+- **Matches ADR-0023**: "Some children closed, some open, some blocked → plan"
+
+#### 18. UnmergedBeadGuard — Recovery after bd close without mindspec complete
+- **Status**: Current, no issues
+- **Assumptions valid**: `mindspec next` blocks when predecessor bead has unmerged branch, agent runs `mindspec complete` to recover
+- **MaxTurns**: 35, **TimeoutMin**: 10 — appropriate (recovery flow is expensive)
+- **Assertions**: complete ran, bead-1 closed, mindspec next is optional (t.Log not t.Error)
+- **Note**: Product fix (skip dirty-tree check in recovery mode) was needed to make this scenario passable
+
+### Code-Level Findings
+
+| Check | Result |
+|:------|:-------|
+| References to `GitExecutor` in harness code | None found |
+| References to `specinit` in harness code | None found |
+| References to `gitops` in harness code | One in HISTORY.md (historical note, line 686) — left as-is (closed artifact) |
+| `setupWorktrees` helper usage | All 18 scenarios use it correctly |
+| `assertBeadsState` uses `bd show <id> --json` | Correct (avoids known `bd list --json --parent` bug) |
+| `assertMergeTopology` fallback to `--all` | Correct (handles post-impl-approve branch deletion) |
+| `assertMainCommitCountUnchanged` infra exclusion | Correct (excludes .beads/ commits) |
+
+### Overall Assessment
+
+**17/18 scenarios have correct assumptions with no issues. 1 scenario (SpecToIdle) has a design tension** between the implement.md STOP instruction and the prompt's end-to-end lifecycle goal. No scenarios test behavior that no longer exists. No broken test expectations found in scenario code.
+
+**Design tension — SpecToIdle vs STOP instruction:**
+The implement.md template says "STOP" after `mindspec complete`. SpecToIdle asks the agent to continue past this to `approve impl` and return to idle. This works because (a) the STOP is about "next bead" not "next phase", and (b) the prompt explicitly overrides with an idle end-state goal. But the bare "STOP" wording is ambiguous enough to confuse Haiku. Recommended fix: clarify STOP wording to "do not claim the next bead" or "do not run `mindspec next`" rather than a bare "STOP".
+
+**Key behavioral invariants correctly tested:**
+- STOP after `mindspec complete` (implement.md lines 49, 94) — validated by MultiBeadDeps, SpecToIdle
+- Manual `mindspec next` between beads — validated by MultiBeadDeps, SpecToIdle
+- `plan approve` auto-claims first bead — correctly optional `next` in SpecToIdle, PlanApprove
+- `implement → plan` when only blocked beads remain — validated by BlockedBeadTransition
+- Unmerged bead guard — validated by UnmergedBeadGuard
+- Pre-approve merge/PR prohibition — validated by ImplApprove, SpecToIdle
+
+**Haiku vs Opus reliability:**
+- Opus: 16/18 pass rate (latest full suite), reliable lifecycle command adherence
+- Haiku: ~8/18 pass rate, frequently bypasses lifecycle commands (`bd close` shortcut, raw git instead of `mindspec complete`)
+- All Haiku failures are pre-existing behavioral issues, not test design problems
+
+**No changes required.** Scenarios are well-designed and match current behavior.
+
 ### Key Metrics to Track Per Run
 - **Events**: total shim-recorded commands (multiple per turn -- measures total agent activity)
 - **Turns (estimated)**: API round-trips, estimated from event timestamp gaps >2s. The `--max-turns` flag sets the budget; "Reached max turns" means all were consumed
@@ -709,3 +885,17 @@ Haiku in `claude -p` mode tends to be conversational unless strongly directed. R
 ### Worktree CWD Sensitivity (RESOLVED — 2026-03-02)
 **Problem**: Running `git worktree add` from inside an existing worktree can create the new worktree relative to CWD, causing recursive `.worktrees/.../.worktrees/...` nesting and cleanup leakage.
 **Status (2026-03-02)**: Fixed in `internal/next/beads.go`: `mindspec next` now anchors worktree creation to the spec worktree (when active) or main root, independent of caller CWD. Added deterministic unit coverage in `internal/next/next_test.go` and validated with LLM reruns (`SpecToIdle` pass, `CompleteFromSpecWorktree` regression check pass).
+
+### TestLLM_StopAfterComplete (NEW — Spec 081)
+
+| Date | Result | Events | Turns | Time | Model | Change |
+|------|--------|--------|-------|------|-------|--------|
+| 2026-03-10 | FAIL | ~1500 | 40 | ~8m | Haiku | Baseline: Haiku ran `mindspec next` after completing bead (SOP violation). Also closed bead-2 instead of bead-1. |
+| 2026-03-10 | FAIL | ~3500 | 40 | ~8m | Opus | Switched to Opus. Agent still ran `mindspec next` after `mindspec complete`. Issue: `mindspec complete` failed (exit=1) on some beads, agent never saw STOP output. Also, assertion was too broad (caught pre-completion `mindspec next`). |
+| 2026-03-10 | **PASS** | 1671 | 19 | 4m35s | Opus | Fixed temporal assertion (only flag `mindspec next` after first bead closure), strengthened CLI STOP message ("STOP HERE. Do NOT run `mindspec next`..."), removed ambiguous "/clear then mindspec next" hint. 94.7% fwd ratio. |
+
+### TestLLM_StopDoesNotBlockApproveImpl (NEW — Spec 081)
+
+| Date | Result | Events | Turns | Time | Model | Change |
+|------|--------|--------|-------|------|-------|--------|
+| 2026-03-10 | **PASS** | 1871 | 23 | 5m2s | Opus | Baseline: agent completed bead, then correctly continued to `approve impl` (not blocked by STOP instruction). 95.7% fwd ratio. |
diff --git a/internal/harness/scenario.go b/internal/harness/scenario.go
index 4cc0fbb..21c8c95 100644
--- a/internal/harness/scenario.go
+++ b/internal/harness/scenario.go
@@ -47,6 +47,8 @@ func AllScenarios() []Scenario {
 		ScenarioBugfixBranch(),
 		ScenarioBlockedBeadTransition(),
 		ScenarioUnmergedBeadGuard(),
+		ScenarioStopAfterComplete(),
+		ScenarioStopDoesNotBlockApproveImpl(),
 	}
 }
 
@@ -78,10 +80,10 @@ Finish only when the project is back in idle with cleanup complete.`,
 			assertCommandSucceeded(t, events, "mindspec", "approve", "plan")
 			assertCommandSucceeded(t, events, "mindspec", "approve", "impl")
 
-			// `mindspec next` is optional for single-bead specs because
-			// `plan approve` auto-claims the first bead. Log if skipped.
+			// `mindspec next` may be skipped if the agent navigates directly
+			// to the bead worktree created by plan approve + next in sequence.
 			if !commandRanSuccessfully(events, "mindspec", "next") {
-				t.Logf("mindspec next was not called (plan approve auto-claimed first bead)")
+				t.Logf("mindspec next was not explicitly called")
 			}
 
 			// Git state after full lifecycle
@@ -655,13 +657,13 @@ Unit tests via `+"`go test`"+` covering the Plan() function and edge cases.
 			// Beads were created by plan approve (plan has 2 bead sections)
 			assertBeadsMinCount(t, sandbox, epicID, 2)
 
-			// `mindspec next` is optional — plan approve auto-claims the
-			// first bead. If next ran, verify bead branch + worktree too.
+			// `mindspec next` should be called after plan approve to claim a bead.
+			// If next ran, verify bead branch + worktree too.
 			if commandRanSuccessfully(events, "mindspec", "next") {
 				assertHasBranches(t, sandbox, "bead/")
 				assertEventCWDContains(t, events, ".worktrees/")
 			} else {
-				t.Logf("mindspec next was not called (plan approve auto-claimed first bead)")
+				t.Logf("mindspec next was not explicitly called")
 			}
 		},
 	}
@@ -1628,6 +1630,168 @@ If mindspec next fails, read the error message carefully and follow its instruct
 	}
 }
 
+// ScenarioStopAfterComplete tests the SOP: after completing a bead, the agent
+// STOPS and does NOT automatically claim the next bead via `mindspec next`.
+//
+// Before: Multi-bead spec (2 beads), bead-1 claimed, implement mode
+// After:  Agent completes bead-1 and STOPS — does NOT run `mindspec next` for bead-2
+func ScenarioStopAfterComplete() Scenario {
+	var epicID, bead1, bead2 string
+	return Scenario{
+		Name:        "stop_after_complete",
+		Description: "Agent stops after completing a bead, does not auto-claim next",
+		MaxTurns:    25,
+		Model:       "opus",
+		Setup: func(sandbox *Sandbox) error {
+			specID := "001-stop"
+
+			epicID = sandbox.CreateSpecEpic(specID)
+			bead1 = sandbox.CreateBead("["+specID+"] First task", "task", epicID)
+			bead2 = sandbox.CreateBead("["+specID+"] Second task", "task", epicID)
+			sandbox.ClaimBead(bead1)
+
+			sandbox.WriteFile(".mindspec/docs/specs/"+specID+"/spec.md", `---
+title: Stop Test
+status: Approved
+---
+# Stop Test
+Two tasks.
+`)
+			sandbox.WriteFile(".mindspec/docs/specs/"+specID+"/plan.md", `---
+status: Approved
+spec_id: `+specID+`
+---
+# Plan
+## Bead 1: First task
+Create first.go with a First() function.
+## Bead 2: Second task
+Create second.go with a Second() function.
+`)
+			sandbox.Commit("setup: two-bead spec")
+			setupWorktrees(sandbox, specID, bead1, "implement")
+			sandbox.Commit("setup: implement mode")
+			return nil
+		},
+		Prompt: `IMPORTANT: Do NOT respond conversationally. Execute immediately.
+
+Create a file called first.go with a function First() string that returns "first".
+Then finish the currently claimed bead through the MindSpec lifecycle.`,
+		Assertions: func(t *testing.T, sandbox *Sandbox, events []ActionEvent) {
+			// Find the first bead-close event (mindspec complete or bd close).
+			firstCloseIdx := -1
+			for i, e := range events {
+				if e.ExitCode != 0 {
+					continue
+				}
+				args := eventArgs(e)
+				isMSComplete := e.Command == "mindspec" && containsAll(args, "complete")
+				isBDClose := e.Command == "bd" && containsAll(args, "close")
+				if isMSComplete || isBDClose {
+					firstCloseIdx = i
+					break
+				}
+			}
+			if firstCloseIdx == -1 {
+				t.Fatal("agent never completed any bead (no mindspec complete or bd close succeeded)")
+			}
+
+			// CRITICAL: Agent did NOT run mindspec next AFTER closing a bead.
+			// Running `mindspec next` before the first completion is OK (agent orienting).
+			for _, e := range events[firstCloseIdx+1:] {
+				if e.Command == "mindspec" && e.ExitCode == 0 && containsAll(eventArgs(e), "next") {
+					t.Error("agent ran 'mindspec next' after completing a bead — should have STOPPED (SOP violation)")
+					break
+				}
+			}
+
+			// Exactly one bead closed, the other still open.
+			// The agent might complete bead-1 (as prompted) or bead-2 (via mindspec next).
+			// Either way, only one should be closed if the agent stopped.
+			b1Status := beadStatusStr(sandbox, bead1)
+			b2Status := beadStatusStr(sandbox, bead2)
+			closedCount := 0
+			if b1Status == "closed" {
+				closedCount++
+			}
+			if b2Status == "closed" {
+				closedCount++
+			}
+			if closedCount == 0 {
+				t.Error("no beads were closed — agent failed to complete any bead")
+			} else if closedCount == 2 {
+				t.Error("both beads were closed — agent should have STOPPED after closing the first one")
+			}
+
+			// Preferred: agent used mindspec complete (not bd close).
+			if !commandRanSuccessfully(events, "mindspec", "complete") {
+				t.Log("NOTE: agent used bd close instead of mindspec complete")
+			}
+		},
+	}
+}
+
+// ScenarioStopDoesNotBlockApproveImpl tests that the STOP instruction after
+// `mindspec complete` does not prevent the agent from running `approve impl`
+// when the prompt explicitly asks for the spec to reach idle/review.
+//
+// Before: Single-bead spec, bead-1 claimed, implement mode
+// After:  Agent completes bead-1 AND runs approve impl to reach idle
+func ScenarioStopDoesNotBlockApproveImpl() Scenario {
+	var epicID, beadID string
+	return Scenario{
+		Name:        "stop_does_not_block_approve_impl",
+		Description: "STOP after complete does not prevent approve impl when prompted",
+		MaxTurns:    25,
+		Model:       "opus",
+		Setup: func(sandbox *Sandbox) error {
+			specID := "001-approve"
+
+			epicID = sandbox.CreateSpecEpic(specID)
+			beadID = sandbox.CreateBead("["+specID+"] Implement feature", "task", epicID)
+			sandbox.ClaimBead(beadID)
+
+			sandbox.WriteFile(".mindspec/docs/specs/"+specID+"/spec.md", `---
+title: Approve Test
+status: Approved
+---
+# Approve Test
+Single feature.
+`)
+			sandbox.WriteFile(".mindspec/docs/specs/"+specID+"/plan.md", fmt.Sprintf(`---
+status: Approved
+spec_id: %s
+bead_ids:
+- %s
+---
+# Plan
+## Bead 1: Implement feature
+Create feature.go with a Feature() function.
+`, specID, beadID))
+			sandbox.Commit("setup: single-bead spec")
+			setupWorktrees(sandbox, specID, beadID, "implement")
+			sandbox.Commit("setup: implement mode")
+			return nil
+		},
+		Prompt: `IMPORTANT: Do NOT respond conversationally. Execute immediately.
+
+Create a file called feature.go with a function Feature() string that returns "feature".
+Finish the bead and take this spec all the way to idle — complete the bead, then
+approve the implementation so the project returns to idle mode.`,
+		Assertions: func(t *testing.T, sandbox *Sandbox, events []ActionEvent) {
+			// Agent completed the bead
+			assertCommandRan(t, events, "mindspec", "complete")
+
+			// Agent continued past STOP to run approve impl
+			assertCommandSucceeded(t, events, "mindspec", "approve", "impl")
+
+			// Bead was closed
+			assertBeadsState(t, sandbox, epicID, map[string]string{
+				beadID: "closed",
+			})
+		},
+	}
+}
+
 // gitBranchExists checks if a git branch exists in the sandbox.
 func gitBranchExists(sandbox *Sandbox, branch string) bool {
 	cmd := exec.Command("git", "rev-parse", "--verify", branch)
@@ -2060,6 +2224,19 @@ type beadStatus struct {
 	Title  string `json:"title"`
 }
 
+// beadStatusStr returns the status of a bead by ID, or "unknown" on error.
+func beadStatusStr(sandbox *Sandbox, beadID string) string {
+	out, err := sandbox.runBD("show", beadID, "--json")
+	if err != nil {
+		return "unknown"
+	}
+	var infos []beadStatus
+	if err := json.Unmarshal([]byte(out), &infos); err != nil || len(infos) == 0 {
+		return "unknown"
+	}
+	return strings.TrimSpace(strings.ToLower(infos[0].Status))
+}
+
 // assertBeadsMinCount verifies that at least minCount child beads exist under
 // the given epicID. Useful when bead IDs are created dynamically (e.g. by plan approve).
 func assertBeadsMinCount(t testing.TB, sandbox *Sandbox, epicID string, minCount int) {
diff --git a/internal/harness/scenario_test.go b/internal/harness/scenario_test.go
index cadd825..e1ab62f 100644
--- a/internal/harness/scenario_test.go
+++ b/internal/harness/scenario_test.go
@@ -282,6 +282,28 @@ func TestLLM_UnmergedBeadGuard(t *testing.T) {
 	}
 }
 
+// --- Stop behavior scenarios ---
+
+func TestLLM_StopAfterComplete(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping LLM test in short mode")
+	}
+	report, _ := runScenario(t, ScenarioStopAfterComplete())
+	if len(report.WrongActions) > 0 {
+		t.Errorf("unexpected wrong actions: %d", len(report.WrongActions))
+	}
+}
+
+func TestLLM_StopDoesNotBlockApproveImpl(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping LLM test in short mode")
+	}
+	report, _ := runScenario(t, ScenarioStopDoesNotBlockApproveImpl())
+	if len(report.WrongActions) > 0 {
+		t.Errorf("unexpected wrong actions: %d", len(report.WrongActions))
+	}
+}
+
 // --- Assertion helper unit tests ---
 
 func TestAssertMergeTopology(t *testing.T) {
diff --git a/internal/instruct/templates/ambiguous.md b/internal/instruct/templates/ambiguous.md
index bf3432a..8e88f22 100644
--- a/internal/instruct/templates/ambiguous.md
+++ b/internal/instruct/templates/ambiguous.md
@@ -20,7 +20,7 @@ idle ── spec ── plan ── implement ── review ── idle
 |-------|---------|--------------|
 | idle → spec | `mindspec spec create <slug>` | Creates branch + worktree + spec template |
 | spec → plan | `mindspec spec approve <id>` | Validates spec, auto-commits |
-| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads, auto-claims first bead |
+| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads. STOP after this — run `/clear` then `mindspec next` |
 | per bead | `mindspec next` | Claims next bead, creates bead worktree |
 | bead done | `mindspec complete <bead-id> "msg"` | Auto-commits, closes bead, merges bead→spec, removes worktree |
 | review → idle | `mindspec impl approve <id>` | Merges spec→main, removes all worktrees + branches |
diff --git a/internal/instruct/templates/idle.md b/internal/instruct/templates/idle.md
index 23035dc..06f6185 100644
--- a/internal/instruct/templates/idle.md
+++ b/internal/instruct/templates/idle.md
@@ -12,7 +12,7 @@ You are not currently working on any spec or bead.
 |-------|---------|--------------|
 | idle → spec | `mindspec spec create <slug>` | Creates branch + worktree + spec template |
 | spec → plan | `mindspec spec approve <id>` | Validates spec, auto-commits |
-| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads, auto-claims first bead |
+| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads. STOP after this — run `/clear` then `mindspec next` |
 | per bead | `mindspec next` | Claims next bead, creates bead worktree |
 | bead done | `mindspec complete <bead-id> "msg"` | Auto-commits, closes bead, merges bead→spec, removes worktree |
 | review → idle | `mindspec impl approve <id>` | Merges spec→main, removes all worktrees + branches |
diff --git a/internal/instruct/templates/implement.md b/internal/instruct/templates/implement.md
index 4cdff2e..65552d0 100644
--- a/internal/instruct/templates/implement.md
+++ b/internal/instruct/templates/implement.md
@@ -16,7 +16,7 @@ idle ── spec ── plan ──── >>> implement ── review ── idl
 |-------|---------|--------------|
 | idle → spec | `mindspec spec create <slug>` | Creates branch + worktree + spec template |
 | spec → plan | `mindspec spec approve <id>` | Validates spec, auto-commits |
-| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads, auto-claims first bead |
+| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads. STOP after this — run `/clear` then `mindspec next` |
 | per bead | `mindspec next` | Claims next bead, creates bead worktree |
 | bead done | `mindspec complete <bead-id> "msg"` | Auto-commits, closes bead, merges bead→spec, removes worktree |
 | review → idle | `mindspec impl approve <id>` | Merges spec→main, removes all worktrees + branches |
@@ -46,7 +46,7 @@ Run `cd {{.ActiveWorktree}}` to enter the bead worktree. All code changes go the
 {{- end}}
 
 Do NOT create manual workflow branches/worktrees in implement mode.
-After `mindspec complete` succeeds, STOP. Do NOT automatically continue to the next bead — let the user decide when to proceed.
+After `mindspec complete` succeeds, do NOT run `mindspec next` or claim another bead. Report completion and let the user decide when to proceed.
 If the user asks for an interrupt fix (urgent bug + continue feature), do both:
 1. Apply and commit the urgent fix.
 2. Resume bead scope and produce the requested feature artifact(s).
@@ -91,7 +91,7 @@ When the bead is done:
 1. Run verification steps and capture evidence
 2. Update documentation (doc-sync)
 3. Run `mindspec complete {{.ActiveBead}} "describe what you did"` — auto-commits all changes, closes the bead, merges bead→spec, removes the worktree, and advances state
-4. **STOP and report completion** — do NOT automatically continue to the next bead. The user will run `mindspec next` when ready
+4. **Report completion** — do NOT run `mindspec next` or claim another bead. The user will run `mindspec next` when ready
 
 **Do NOT use `bd close` to finish a bead.** It skips merge topology, worktree cleanup, and state transitions. Always use `mindspec complete`.
 **Do NOT use `bd update` on lifecycle epics.** Phase metadata is managed automatically by `mindspec complete`.
diff --git a/internal/instruct/templates/plan.md b/internal/instruct/templates/plan.md
index c985fb4..7ef5b04 100644
--- a/internal/instruct/templates/plan.md
+++ b/internal/instruct/templates/plan.md
@@ -15,7 +15,7 @@ idle ── spec ──── >>> plan ── implement ── review ── idl
 |-------|---------|--------------|
 | idle → spec | `mindspec spec create <slug>` | Creates branch + worktree + spec template |
 | spec → plan | `mindspec spec approve <id>` | Validates spec, auto-commits |
-| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads, auto-claims first bead |
+| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads. STOP after this — run `/clear` then `mindspec next` |
 | per bead | `mindspec next` | Claims next bead, creates bead worktree |
 | bead done | `mindspec complete <bead-id> "msg"` | Auto-commits, closes bead, merges bead→spec, removes worktree |
 | review → idle | `mindspec impl approve <id>` | Merges spec→main, removes all worktrees + branches |
@@ -115,5 +115,5 @@ Apply these research-backed questions while decomposing the spec into beads (see
 Plan is approved. Run `mindspec next` to claim the next bead.
 {{- else}}
 
-Complete the plan at `.mindspec/docs/specs/{{.ActiveSpec}}/plan.md`, then run `mindspec plan approve {{.ActiveSpec}}`. This will approve the plan AND automatically claim the first bead.
+Complete the plan at `.mindspec/docs/specs/{{.ActiveSpec}}/plan.md`, then run `mindspec plan approve {{.ActiveSpec}}`. After approval, STOP — run `/clear`, then `mindspec next` to claim your first bead.
 {{- end}}
diff --git a/internal/instruct/templates/review.md b/internal/instruct/templates/review.md
index 154b52e..232e82e 100644
--- a/internal/instruct/templates/review.md
+++ b/internal/instruct/templates/review.md
@@ -15,7 +15,7 @@ idle ── spec ── plan ── implement ──── >>> review ── idl
 |-------|---------|--------------|
 | idle → spec | `mindspec spec create <slug>` | Creates branch + worktree + spec template |
 | spec → plan | `mindspec spec approve <id>` | Validates spec, auto-commits |
-| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads, auto-claims first bead |
+| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads. STOP after this — run `/clear` then `mindspec next` |
 | per bead | `mindspec next` | Claims next bead, creates bead worktree |
 | bead done | `mindspec complete <bead-id> "msg"` | Auto-commits, closes bead, merges bead→spec, removes worktree |
 | review → idle | `mindspec impl approve <id>` | Merges spec→main, removes all worktrees + branches |
diff --git a/internal/instruct/templates/spec.md b/internal/instruct/templates/spec.md
index bb14651..1d2251c 100644
--- a/internal/instruct/templates/spec.md
+++ b/internal/instruct/templates/spec.md
@@ -15,7 +15,7 @@ idle ──── >>> spec ── plan ── implement ── review ── idl
 |-------|---------|--------------|
 | idle → spec | `mindspec spec create <slug>` | Creates branch + worktree + spec template |
 | spec → plan | `mindspec spec approve <id>` | Validates spec, auto-commits |
-| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads, auto-claims first bead |
+| plan → impl | `mindspec plan approve <id>` | Validates plan, auto-creates beads. STOP after this — run `/clear` then `mindspec next` |
 | per bead | `mindspec next` | Claims next bead, creates bead worktree |
 | bead done | `mindspec complete <bead-id> "msg"` | Auto-commits, closes bead, merges bead→spec, removes worktree |
 | review → idle | `mindspec impl approve <id>` | Merges spec→main, removes all worktrees + branches |
diff --git a/internal/lifecycle/scenario_test.go b/internal/lifecycle/scenario_test.go
index c93041a..daf546e 100644
--- a/internal/lifecycle/scenario_test.go
+++ b/internal/lifecycle/scenario_test.go
@@ -241,7 +241,7 @@ Bead 1
 `, specID, specID)
 }
 
-// simulateSpecInit creates the spec directory and files that specinit.Run
+// simulateSpecInit creates the spec directory and files that spec.Run
 // would produce, without calling bd or creating worktrees.
 func simulateSpecInit(t *testing.T, root, specID string) {
 	t.Helper()
@@ -286,7 +286,7 @@ func TestScenario_HappyPath(t *testing.T) {
 	root := testRepo(t)
 	specID := "001-test-feature"
 
-	// Phase 1: Spec Init (simulated — specinit.Run needs bd + worktree mocks)
+	// Phase 1: Spec Init (simulated — spec.Run needs bd + worktree mocks)
 	simulateSpecInit(t, root, specID)
 	assertState(t, root, specID, state.ModeSpec, "spec")
 
diff --git a/internal/phase/derive.go b/internal/phase/derive.go
index 71ad8e2..a8fe3c6 100644
--- a/internal/phase/derive.go
+++ b/internal/phase/derive.go
@@ -289,7 +289,7 @@ func ResolveContextFromDir(root, dir string) (*Context, error) {
 	switch kind {
 	case workspace.WorktreeBead:
 		ctx.BeadID = beadID
-		epicID, derivedSpecID, err := findEpicForBead(beadID)
+		epicID, derivedSpecID, err := FindEpicForBead(beadID)
 		if err == nil && derivedSpecID != "" {
 			ctx.SpecID = derivedSpecID
 			ctx.EpicID = epicID
@@ -525,7 +525,9 @@ func ParseSpecFromTitle(title string) (int, string) {
 	return num, slug
 }
 
-func findEpicForBead(beadID string) (epicID, specID string, err error) {
+// FindEpicForBead looks up the parent epic for a bead and returns the epic ID
+// and derived spec ID. Used by complete to resolve the spec from just a bead ID.
+func FindEpicForBead(beadID string) (epicID, specID string, err error) {
 	out, err := runBDFn("show", beadID, "--json")
 	if err != nil {
 		return "", "", fmt.Errorf("bd show %s failed: %w", beadID, err)
diff --git a/internal/specinit/specinit.go b/internal/spec/create.go
similarity index 99%
rename from internal/specinit/specinit.go
rename to internal/spec/create.go
index e433445..a030eb8 100644
--- a/internal/specinit/specinit.go
+++ b/internal/spec/create.go
@@ -1,4 +1,4 @@
-package specinit
+package spec
 
 import (
 	"fmt"
diff --git a/internal/specinit/specinit_test.go b/internal/spec/create_test.go
similarity index 99%
rename from internal/specinit/specinit_test.go
rename to internal/spec/create_test.go
index abf1481..580014e 100644
--- a/internal/specinit/specinit_test.go
+++ b/internal/spec/create_test.go
@@ -1,4 +1,4 @@
-package specinit
+package spec
 
 import (
 	"os"