@c-d-cc/reap 0.10.3 → 0.11.0

package/dist/templates/commands/reap.merge.completion.md

@@ -2,58 +2,4 @@
 description: "REAP Merge Completion — Finalize the merge generation with archiving"
 ---
 
-# Merge Completion
-
-Finalize the merge generation after validation passes.
-
-## Gate
-- Verify current generation is type: merge and stage: completion
-- Verify `05-validation.md` exists
-
-## Steps
-
-1. Write `06-completion.md` with:
-   - Summary of what was merged
-   - Genome changes applied
-   - Lessons learned
-
-### Hook Execution + Archiving + Commit
-
-**This phase handles hook execution, archiving, and commit (previously done by `reap.next`).**
-
-2. **Hook Execution** (before archiving, before commit):
-   Execute hooks for event `onMergeCompleted` following the Hook System protocol:
-   - Scan `.reap/hooks/` for `onMergeCompleted.*` files
-   - Sort by frontmatter `order`, then alphabetically
-   - Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-   - All hook outputs are included in the same generation commit
-
-3. **Archiving**:
-   - Add the current timestamp to `completedAt` in `current.yml`
-   - Create the lineage directory: `.reap/lineage/[gen-id]-[goal-slug]/`
-     - Goal slug: lowercase, non-alphanumeric/hangul replaced with `-`, max 30 chars
-   - **Write `meta.yml`** in the lineage directory with DAG metadata:
-     ```yaml
-     id: [gen-id]
-     type: merge
-     parents: [parent generation IDs from current.yml]
-     goal: [goal from current.yml]
-     genomeHash: [genomeHash from current.yml, or compute from .reap/genome/]
-     startedAt: [startedAt from current.yml]
-     completedAt: [current ISO 8601]
-     ```
-   - Move artifact files (`01-*.md` through `06-*.md`) from `.reap/life/` to the lineage directory
-   - Process backlog files from `.reap/life/backlog/`:
-     - Create `.reap/lineage/[gen-id]-[goal-slug]/backlog/` directory
-     - Files with `status: consumed` → move to lineage backlog
-     - Files with `status: pending` or no status field → copy to lineage backlog, carry over to `.reap/life/backlog/`
-   - Clear `current.yml` (write empty content)
-   - Recreate `.reap/life/backlog/` directory (with carried-over pending items)
-
-4. **Commit** (source + archiving in a single commit):
-   - **Submodule check**: If any git submodule has uncommitted changes, commit and push inside the submodule first, then stage the updated submodule pointer in the parent repo
-   - Stage all changed files (merged source + genome changes + `.reap/` artifacts + hook outputs)
-   - Commit message format: `merge(gen-NNN-hash): [generation goal summary]`
-
-## Completion
-- "Merge generation [id] complete and archived. Run `/reap.start` to begin a new generation."
+Run `reap run merge-completion` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.detect.md

@@ -2,26 +2,4 @@
 description: "REAP Merge Detect — Analyze divergence between branches"
 ---
 
-# Merge Detect
-
-Analyze the divergence between the current branch and the target branch.
-
-## Gate
-- Verify current generation is type: merge and stage: detect
-
-## Steps
-
-1. Read `01-detect.md` (created by `reap merge` CLI)
-2. Review the divergence report with the human:
-   - Common ancestor
-   - Genome changes on each side
-   - Conflicts (WRITE-WRITE, CROSS-FILE)
-3. If the detect needs to be re-run, use `reap merge {branch}` again
-4. When satisfied, execute hooks and proceed with `/reap.next`
-
-### Hook Execution
-Execute hooks for event `onMergeDetected` following the Hook System protocol:
-- Scan `.reap/hooks/` for `onMergeDetected.*` files
-- Sort by frontmatter `order`, then alphabetically
-- Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-- All hooks run BEFORE any commit (hook outputs included in the same commit)
+Run `reap run merge-detect` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.evolve.md

@@ -2,40 +2,4 @@
 description: "REAP Merge Evolve — Run the full merge lifecycle automatically"
 ---
 
-# Merge Evolve
-
-Run the entire merge lifecycle from the current stage to completion.
-
-## Gate
-- Verify current generation is type: merge
-
-## Hook Auto-Execution
-Each merge stage command automatically executes its own hook at completion:
-- `/reap.merge.detect` → `onMergeDetected`
-- `/reap.merge.mate` → `onMergeMated`
-- `/reap.merge.merge` → `onMergeMerged`
-- `/reap.merge.sync` → `onMergeSynced`
-- `/reap.merge.validation` → `onMergeValidated`
-- `/reap.merge.completion` → `onMergeCompleted` (before archiving and commit)
-
-`/reap.next` only handles stage transitions — it does NOT execute hooks or archiving.
-`/reap.merge.completion` handles archiving and the final commit.
-
-## Steps
-
-Execute the merge lifecycle loop:
-1. Read `current.yml` to determine stage
-2. Execute the corresponding merge stage command:
-   - `detect` → `/reap.merge.detect`
-   - `mate` → `/reap.merge.mate`
-   - `merge` → `/reap.merge.merge`
-   - `sync` → `/reap.merge.sync`
-   - `validation` → `/reap.merge.validation`
-   - `completion` → `/reap.merge.completion`
-3. When a stage command completes (hooks already executed by the stage command):
-   - If the current stage is `completion`: `/reap.merge.completion` handles archiving and commit internally. The loop ends.
-   - Otherwise: run `/reap.next` to advance, then return to step 1.
-
-## Autonomous Override
-Same rules as `/reap.evolve` — skip routine confirmations, stop only when genuinely blocked.
-**Exception**: `/reap.merge.sync` inconsistencies always require user confirmation even in autonomous mode.
+Run `reap run merge-evolve` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.mate.md

@@ -2,33 +2,4 @@
 description: "REAP Merge Mate — Resolve genome conflicts through mating"
 ---
 
-# Merge Mate (Genome Mating)
-
-Resolve genome conflicts identified in the detect stage. The genome must be fully finalized before source merge.
-
-## Gate
-- Verify current generation is type: merge and stage: mate
-- Verify `01-detect.md` exists
-
-## Steps
-
-1. Read conflicts from `01-detect.md`
-2. For each WRITE-WRITE conflict:
-   - Show both versions to the human
-   - Ask: keep A, keep B, or merge manually
-3. For each CROSS-FILE conflict:
-   - Show the changes and ask if they are logically compatible
-4. Apply the resolved genome to `.reap/genome/`
-5. Record all decisions in `02-mate.md`
-6. Execute hooks and proceed with `/reap.next`
-
-### Hook Execution
-Execute hooks for event `onMergeMated` following the Hook System protocol:
-- Scan `.reap/hooks/` for `onMergeMated.*` files
-- Sort by frontmatter `order`, then alphabetically
-- Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-- All hooks run BEFORE any commit (hook outputs included in the same commit)
-
-## Escalation
-- If conflicts are complex or ambiguous, STOP and ask the human
-- Never auto-resolve WRITE-WRITE conflicts
+Run `reap run merge-mate` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.md

@@ -2,46 +2,4 @@
 description: "REAP Merge — Run a full merge generation for a local branch"
 ---
 
-# Merge
-
-Run a full merge generation lifecycle for a local branch. This is the local/worktree equivalent of `/reap.pull` — no fetch needed.
-
-If the target branch already includes all local work (fast-forward), skip the merge lifecycle entirely.
-
-## Gate (Preconditions)
-- Verify no active generation exists (`.reap/life/current.yml` must be empty)
-- If an active generation exists: ERROR — "Complete the current generation before merging."
-
-## Arguments
-- `{branch}` — Target local branch to merge (required)
-
-## Steps
-
-### Phase 1: Detect
-1. Verify the target branch exists: `git rev-parse --verify {branch}`
-   - If not found: ERROR — "Branch {branch} does not exist."
-2. Scan the target branch's `.reap/lineage/` via git refs
-3. Compare with local lineage to identify new generations
-4. If no new generations: "Already up to date." → STOP
-
-### Phase 2: Fast-Forward Check
-5. Determine the local latest generation ID and the target branch's latest generation ID
-6. Build a combined DAG from both lineage metadata
-7. Check if the local latest generation is an ancestor of the target's latest generation:
-   - **If yes (fast-forward possible)**:
-     - Run `git merge --ff {branch}`
-     - Report: "Fast-forwarded to {branch}. No merge generation needed."
-     - **STOP**
-   - **If same generation**: "Already up to date." → **STOP**
-   - **If no (diverged)**: Continue to Phase 3
-
-### Phase 3: Merge Generation
-8. Execute `/reap.merge.start` with the target branch
-   - This creates the merge generation and runs detect (01-detect.md)
-9. Execute `/reap.merge.evolve` to run the full merge lifecycle:
-   - Detect → Mate → Merge → Sync → Validation → Completion
-10. The merge generation is archived upon completion
-
-## Completion
-- Fast-forward: "Fast-forwarded to {branch}. No merge generation needed."
-- Full merge: "Merge complete. Merged {branch} into {current-branch}. Generation {id} archived."
+Run `reap run merge` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.merge.md

@@ -2,28 +2,4 @@
 description: "REAP Merge Merge — Merge source code with finalized genome as guide"
 ---
 
-# Merge Merge (Source Merge)
-
-Merge the source code from the target branch, using the finalized genome as the authoritative guide.
-
-## Gate
-- Verify current generation is type: merge and stage: merge
-- Verify `02-mate.md` exists
-
-## Steps
-
-1. Run `git merge --no-commit {target-branch}` to start the source merge
-2. If git merge conflicts exist:
-   - Resolve each conflict guided by the finalized genome
-   - Record resolutions in `03-merge.md`
-3. If no git conflicts:
-   - Check for semantic conflicts (code that compiles but contradicts the genome)
-4. Do NOT commit yet — sync and validation must pass first
-5. Execute hooks and proceed with `/reap.next`
-
-### Hook Execution
-Execute hooks for event `onMergeMerged` following the Hook System protocol:
-- Scan `.reap/hooks/` for `onMergeMerged.*` files
-- Sort by frontmatter `order`, then alphabetically
-- Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-- All hooks run BEFORE any commit (hook outputs included in the same commit)
+Run `reap run merge-merge` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.start.md

@@ -2,28 +2,4 @@
 description: "REAP Merge Start — Start a merge generation to combine divergent branches"
 ---
 
-# Merge Start
-
-Start a merge generation by specifying a target branch to merge into the current branch.
-
-## Gate
-- Verify no active generation exists
-- Verify the target branch exists (`git rev-parse --verify {branch}`)
-- Verify that the common ancestor is NOT inside `epoch.md`. If it is: ERROR — "The common ancestor has been epoch-compressed and cannot be used as a merge base. The generation is archived in epoch.md for historical reference only."
-
-## Steps
-
-1. Ask the human for the target branch name (if not provided)
-2. Run detect: scan target branch genome/lineage via git refs, find common ancestor, extract diffs
-3. Create merge generation in `current.yml` (type: merge, stage: detect)
-4. Generate `01-detect.md` artifact with divergence report
-5. Report: parents, common ancestor, conflict count
-6. If genome conflicts exist: proceed to `/reap.merge.mate`
-7. If no genome conflicts: mate can auto-pass, proceed to `/reap.merge.merge`
-
-### Hook Execution
-Execute hooks for event `onMergeStarted` following the Hook System protocol:
-- Scan `.reap/hooks/` for `onMergeStarted.*` files
-- Sort by frontmatter `order`, then alphabetically
-- Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-- All hooks run BEFORE any commit (hook outputs included in the same commit)
+Run `reap run merge-start` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.sync.md

@@ -2,38 +2,4 @@
 description: "REAP Merge Sync — Verify genome-source consistency"
 ---
 
-# Merge Sync (Genome-Source Consistency)
-
-Verify that the merged source code is consistent with the finalized genome. This is NOT validation (tests/build) — this is a semantic check that the code matches the genome's rules and decisions.
-
-## Gate
-- Verify current generation is type: merge and stage: sync
-- Verify `03-merge.md` exists
-
-## Steps
-
-1. Read the finalized genome (`.reap/genome/`)
-2. Compare genome rules against the merged source code:
-   - **conventions.md**: Are naming conventions, code style, and patterns followed?
-   - **constraints.md**: Are tech stack choices and constraints respected?
-   - **principles.md**: Are architecture decisions reflected in the code?
-   - **domain/**: Are business rules implemented correctly?
-   - **source-map.md**: Do documented components match actual files?
-3. For each inconsistency found:
-   - **STOP and present to the human**
-   - Ask: fix the source, update the genome, or accept as-is with rationale
-   - Record the decision in `04-sync.md`
-4. If no inconsistencies: record "All consistent" in `04-sync.md`
-5. Execute hooks and proceed with `/reap.next`
-
-### Hook Execution
-Execute hooks for event `onMergeSynced` following the Hook System protocol:
-- Scan `.reap/hooks/` for `onMergeSynced.*` files
-- Sort by frontmatter `order`, then alphabetically
-- Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-- All hooks run BEFORE any commit (hook outputs included in the same commit)
-
-## Escalation
-- **Every inconsistency requires user confirmation** — do NOT auto-resolve
-- If fixing requires significant code changes, consider `/reap.back merge`
-- If fixing requires genome changes, consider `/reap.back mate`
+Run `reap run merge-sync` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.merge.validation.md

@@ -2,32 +2,4 @@
 description: "REAP Merge Validation — Run tests, type check, and build"
 ---
 
-# Merge Validation
-
-Run all validation commands to verify the merged code works correctly. Same as normal generation validation.
-
-## Gate
-- Verify current generation is type: merge and stage: validation
-- Verify `04-sync.md` exists
-
-## Steps
-
-1. Read validation commands from `.reap/genome/constraints.md`
-2. Execute all commands in order:
-   - Tests (`bun test`)
-   - Type check (`bunx tsc --noEmit`)
-   - Build (`npm run build`)
-3. Record results in `05-validation.md`
-4. If all pass: execute hooks and proceed with `/reap.next`
-5. If any fail:
-   - Analyze the failure
-   - `/reap.back merge` to fix source issues
-   - Or `/reap.back mate` if the genome needs adjustment
-
-### Hook Execution
-Execute hooks for event `onMergeValidated` following the Hook System protocol:
-- Scan `.reap/hooks/` for `onMergeValidated.*` files
-- Sort by frontmatter `order`, then alphabetically
-- Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-- All hooks run BEFORE any commit (hook outputs included in the same commit)
-- **Only execute on pass** — do NOT execute hooks if validation fails
+Run `reap run merge-validation` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.next.md

@@ -2,35 +2,4 @@
 description: "REAP Next — Advance to the next lifecycle stage"
 ---
 
-# Next Stage
-
-This command is the **ONLY legitimate way** to advance the lifecycle stage. All stage transitions MUST go through this command. Direct modification of `current.yml` is strictly prohibited.
-
-## Gate (Preconditions)
-- Read `.reap/life/current.yml`
-- If no active Generation: ERROR — "No active Generation. Run `/reap.start` first." **STOP**
-
-## Steps
-
-### Stage Transition
-- Stage order (normal): objective → planning → implementation → validation → completion
-- Stage order (merge): detect → mate → merge → sync → validation → completion
-- Update the `stage` in `current.yml` to the next stage
-- Add an entry to `timeline`:
-  ```yaml
-  - stage: [next stage]
-    at: [current ISO 8601]
-  ```
-- Immediately create the next stage's artifact file from template (empty, ready to fill)
-
-**Note**: Stage-specific hooks (e.g., `onLifeObjected`) are handled by each stage command at its own completion, NOT by this command. Archiving is handled by `reap.completion` (normal) or `reap.merge.completion` (merge).
-
-### Hook Execution (Transition)
-After updating `current.yml`, execute the generic transition hook based on generation type:
-- If `type` is `merge` (or current stage is a merge stage): execute hooks for event `onMergeTransited`
-- Otherwise (normal): execute hooks for event `onLifeTransited`
-
-Scan `.reap/hooks/` for `{event}.*` files, sort by frontmatter `order` then alphabetically, evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script).
-
-## Completion
-- "Advanced to [next stage]. Proceed with `/reap.[next stage]`."
+Run `reap run next` and follow the stdout instructions exactly.

package/dist/templates/commands/reap.objective.md

@@ -2,262 +2,4 @@
 description: "REAP Objective — Define the goal and specification for this Generation"
 ---
 
-# Objective (Goal Definition + Brainstorming Design)
-
-<HARD-GATE>
-Do NOT write any code until the artifact (01-objective.md) has been confirmed by the human.
-If the goal is ambiguous, do NOT guess — STOP and ask the human. This is non-negotiable.
-Brainstorming is triggered based on goal complexity — simple tasks skip it, complex tasks require it. The human can always override the AI's assessment.
-</HARD-GATE>
-
-## Gate (Preconditions)
-- Read `.reap/life/current.yml` and verify that stage is `objective`
-- If not met: ERROR — "Current stage is not objective. Start a new Generation with `/reap.start` or check the current state with `reap status`." then **STOP**
-
-## Context (Generation Info)
-- Read `.reap/life/current.yml` for the current generation info (id, goal, genomeVersion)
-- Reference this info in all subsequent artifacts and conversations
-
-## Re-entry Check
-- If `.reap/life/01-objective.md` already exists, this is a **re-entry due to regression**
-- Read the existing artifact; if a `## Regression` section exists, understand the regression reason
-- Use the existing content as reference, but overwrite it with modifications that address the regression reason
-
-## Steps
-
-### 1. Environment Check
-- Read `.reap/environment/summary.md`
-- If summary.md exists: review it for relevant context to this generation's goal
-- **If empty or missing**: inform the user — "Environment가 설정되지 않았습니다. `/reap.sync.environment`로 외부 환경 정보를 설정할 수 있습니다."
-  - Do NOT block — proceed with the objective. Environment is optional but recommended.
-
-### 2. Previous Generation Reference
-- If a `05-completion.md` exists for the most recent generation in `.reap/lineage/`, read it
-- Reference lessons learned and next-generation suggestions from the previous generation
-
-### 3. Backlog Review
-- Read all files in `.reap/life/backlog/`
-- Review deferred tasks and planned goals
-
-### 4. Genome Health Check
-- Read all files in `.reap/genome/` (principles.md, conventions.md, constraints.md, domain/)
-- Read `.reap/config.yml` to determine the `entryMode` (greenfield, migration, adoption)
-
-- **If this is the first generation** (`.reap/lineage/` is empty):
-  - This is the sole exception to the Genome immutability principle: **direct genome authoring is permitted only during the first generation's Objective**
-  - **Brief the human on what Genome means**:
-    > "Genome is where we record this project's **design and knowledge** — things the team decides and controls internally.
-    > Architecture principles, business rules, development conventions, and technical constraints.
-    > It's the project's DNA that evolves across generations."
-
-  - **If entryMode is `greenfield`** (new project):
-    1. Ask about the application first:
-       - "What application do you want to build? Give me a brief introduction."
-       - "Who are the primary users? What problem does it solve?"
-    2. Based on the app description, **recommend a tech stack**:
-       - Propose 2-3 options with pros/cons based on the app type (web, API, CLI, mobile, etc.)
-       - If the human already has a preferred stack, respect that
-    3. After stack is decided, ask additional questions:
-       - "Any architecture principles or design decisions already in mind?"
-       - "Any development conventions? (coding style, branch strategy, test policy, etc.)"
-       - "Any technical constraints? (performance requirements, compatibility, dependency restrictions, etc.)"
-    4. Populate `principles.md`, `conventions.md`, `constraints.md` with collected information
-
-  - **If entryMode is `adoption`** (existing codebase):
-    1. **Validate REAP root**:
-       - Check for project root signals (package.json, go.mod, .git, etc.)
-       - If parent directory has root signals, warn: "This may be a subdirectory. Is [parent] the actual project root?"
-       - If workspace config exists in parent (pnpm-workspace.yaml, lerna.json, etc.), ask: "Monorepo detected. Init for the whole repo or just this package?"
-       - If sibling directories contain other sub-projects, suggest: "Other sub-projects found at the same level. Consider init from the parent directory."
-       - Proceed after human confirmation (intentional subdirectory init is allowed)
-    2. **Scan for existing documentation**:
-       - Search for README.md, CONTRIBUTING.md, ARCHITECTURE.md, docs/, CLAUDE.md, AGENTS.md, ADR directories
-       - Show discovered documents to the human and ask for each: "Is this still current?"
-         - Current → use as genome source
-         - Partially outdated → use as reference, prioritize code analysis
-         - No longer valid → skip
-    3. **Analyze existing source code**:
-       - Infer tech stack from config files (package.json, tsconfig, Dockerfile, etc.)
-       - Infer architecture patterns from directory structure
-       - Extract conventions from linter/formatter configs
-       - Identify test strategy from test configs
-    4. **Present combined analysis** (verified docs + code analysis) as genome draft:
-       - "Based on existing documents and source analysis, here's the proposed Genome. Please review."
-       - Human confirms/modifies each section
-    5. Ask about anything not derivable from code or docs (business context, team decisions, etc.)
-    6. Populate genome files with confirmed information
-
-  - **If entryMode is `migration`**: Follow the `adoption` flow for analysis of the existing system, but note that the new project may diverge in architecture
-
-- **For subsequent generations**:
-  - Evaluate the health of each file:
-    - **Files with only placeholders** → flag as "genome needs enhancement"
-    - **Files exceeding 100 lines** → flag as "needs extraction to domain/"
-    - **domain/ has only README.md and no rule files** → flag as "domain rules undefined"
-    - **constraints.md has empty Validation Commands** → flag as "test commands undefined"
-- Report the genome health status to the human
-
-### 5. Goal + Spec Definition (with optional Brainstorming)
-
-Before entering brainstorming, evaluate whether the goal requires it.
-
-#### Complexity Gate
-Assess the goal's complexity based on these criteria:
-
-**Skip brainstorming** (proceed directly to Step 6 with simple goal+spec definition):
-- Simple bugfix with clear cause and fix
-- Configuration change or settings adjustment
-- Documentation-only changes
-- Single-file refactoring with obvious approach
-- Tasks where the "what" and "how" are both already clear
-
-**Enter brainstorming** (follow sub-steps 5a–5e):
-- New feature development spanning multiple components
-- Architecture changes or new module design
-- Tasks with multiple valid implementation approaches
-- Requirements that need further exploration or clarification
-- Integration with external systems or complex data flows
-
-**Under Autonomous Override**: Assess automatically. If the goal from `current.yml` clearly fits "skip" criteria, skip brainstorming.
-**Human override**: The human can always request brainstorming ("let's brainstorm this") or skip it ("just do it", "skip brainstorming") regardless of the AI's assessment.
-
-When skipping brainstorming, converse with the human to refine the goal:
-- Criteria for a good goal: achievable within a single Generation, verifiable completion criteria (no vague wording), relevant genome areas identified
-- Then proceed directly to Step 6 (Genome Gap Analysis)
-
-When entering brainstorming, follow the structured brainstorming process below to produce a well-designed objective. Follow the sub-steps in order.
-
-#### 5a. Visual Companion Proposal
-- Evaluate whether this generation's goal involves visual questions (UI design, architecture diagrams, layout comparisons, etc.)
-- If visual questions are likely, propose the Visual Companion in a **standalone message** (do NOT combine with other questions):
-  > "이번 설계에서 목업이나 다이어그램으로 보여드리면 이해하기 쉬운 부분이 있을 수 있습니다.
-  > 브라우저에서 시각 자료를 보여드릴 수 있는 비주얼 컴패니언을 사용할까요?
-  > (로컬 서버를 띄워 브라우저에서 확인하는 방식입니다)"
-- If the human accepts: start the brainstorm server (`bash` the start script in `.reap/brainstorm/start-server.sh` or `node` the server directly). Read `src/templates/brainstorm/visual-companion-guide.md` for usage rules.
-- If the human declines: proceed terminal-only. Do NOT offer again.
-- **This step applies even under `/reap.evolve` Autonomous Override** — only skip if the human has explicitly declined.
-
-#### 5b. Clarifying Questions (One at a Time)
-- **CRITICAL**: Ask only ONE question per message. Never bundle multiple questions.
-- Prefer **multiple choice** over open-ended questions when possible.
-- Goal: understand purpose, constraints, success criteria, and scope.
-- Continue asking until you have enough information to propose approaches.
-- Good question flow:
-  1. Purpose/motivation: "What problem does this solve?"
-  2. Users/stakeholders: "Who benefits from this?"
-  3. Constraints: "Are there any hard constraints?" (with examples as choices)
-  4. Success criteria: "How will you know this is done?"
-- Under Autonomous Override: Use existing context (genome, backlog, goal from `current.yml`) to answer these questions yourself. Only STOP and ask if genuinely ambiguous.
-
-#### 5c. Approach Exploration (2-3 Alternatives)
-- Propose **2-3 approaches** with clear trade-offs.
-- Present as a comparison table:
-
-  | Aspect | Approach A | Approach B | Approach C |
-  |--------|-----------|-----------|-----------|
-  | Summary | ... | ... | ... |
-  | Pros | ... | ... | ... |
-  | Cons | ... | ... | ... |
-  | Complexity | ... | ... | ... |
-  | Recommendation | ... | ... | ... |
-
-- Include a clear recommendation with reasoning.
-- If using Visual Companion: show approaches visually in the browser for comparison.
-- If only one sensible approach exists, state why alternatives were considered but dismissed.
-- Wait for the human to choose (or confirm the recommendation).
-- Under Autonomous Override: choose the recommended approach and proceed.
-
-#### 5d. Sectional Design Approval
-- Present the design in sections, scaled to complexity:
-  - **Simple** (few sentences per section): small feature, bug fix, config change
-  - **Medium** (1-2 paragraphs per section): new module, refactoring, integration
-  - **Detailed** (200-300 words per section): new system, major architecture change
-- Sections to cover (skip if not applicable):
-  1. **Architecture** — high-level structure, module relationships
-  2. **Components** — key components and their responsibilities
-  3. **Data Flow** — how data moves through the system
-  4. **Error Handling** — failure modes and recovery strategies
-  5. **Testing Strategy** — what and how to test
-- **After each section**, ask: "Does this look right so far?" (or confirm under Autonomous Override)
-- If using Visual Companion: show architecture/data flow diagrams in the browser.
-- Iterate until the human approves each section.
-
-#### 5e. Scope Decomposition Check
-- **Check for multi-subsystem scope**: If the goal describes 2+ independent subsystems (e.g., "build chat + file storage + billing"):
-  - Flag immediately: "This goal covers multiple independent subsystems. I recommend splitting into separate Generations."
-  - Help decompose into sub-goals, each getting its own Generation.
-- **Check FR count**: If functional requirements exceed 10, warn and suggest splitting.
-- Under Autonomous Override: if scope is clearly single-subsystem, proceed without asking.
-
-### 6. Genome Gap Analysis
-- Identify information required to achieve the goal that is missing from the genome
-- For each missing item, record it in `.reap/life/backlog/`:
-  ```markdown
-  ---
-  type: genome-change
-  status: pending
-  target: genome/{file}
-  ---
-  # [Title]
-  [Specifically what is lacking and how it should be changed]
-  ```
-
-### 7. Requirements Finalization
-- Organize functional requirements (FR) and non-functional requirements
-- Define acceptance criteria
-- **Limit**: Maximum 10 functional requirements. If exceeding 10, split into separate generations.
-- **Limit**: Maximum 7 completion criteria. Each must be verifiable.
-- Finalize with the human
-
-### 8. Spec Review Loop
-- After the artifact is complete, dispatch a **spec-document-reviewer subagent** (using the Agent tool with the prompt from `src/templates/brainstorm/spec-reviewer-prompt.md`):
-  - The subagent reads `.reap/life/01-objective.md` and reviews for completeness, consistency, clarity, scope, YAGNI, and verifiability.
-  - If **Issues Found**: fix the issues in the artifact and re-dispatch the reviewer.
-  - If **Approved**: proceed to human review.
-  - **Maximum 3 iterations**. If issues persist after 3 rounds, present remaining issues to the human for decision.
-- Under Autonomous Override: run the review loop automatically. Only escalate if the reviewer flags blocking issues after 3 rounds.
-
-## Escalation
-In the following situations, do NOT guess — **STOP and ask the human**:
-- When the scope of the goal is unclear
-- When two or more reasonable interpretations are possible
-- When contradictory information exists in the genome
-
-## Self-Verification
-Before saving the artifact, verify:
-- [ ] Is the goal clearly stated in a single sentence?
-- [ ] Are all completion criteria verifiable? (No vague wording like "improve" or "make better"?)
-- [ ] Are exclusions explicitly stated in the scope?
-- [ ] Do functional requirements have FR-XXX numbering?
-- [ ] Does the Design section include the chosen approach with rationale?
-- [ ] Has the spec review loop completed (approved or human-overridden)?
-
-❌ Bad completion criterion: "Stabilize the service"
-✅ Good completion criterion: "`npm run lint` reports 0 errors, `npm run build` succeeds"
-
-## Artifact Generation (Progressive Recording)
-- **Language**: Write all artifact content in the user's configured language (see REAP Guide § Language).
-- **Immediately upon entering this stage**: Read `~/.reap/templates/01-objective.md` and create `.reap/life/01-objective.md` with the Goal section filled in (from `current.yml` goal)
-- **Update incrementally**: As each step progresses, update the artifact in place:
-  - After Environment Scan → update Background section
-  - After Previous Generation Reference → update Background section
-  - After Backlog Review → update Background section
-  - After Genome Health Check → update Genome Reference section
-  - After Brainstorming Design (5a-5e) → update Goal, Scope, Design sections
-  - After Genome Gap Analysis → update Backlog section
-  - After Requirements Finalization → update Requirements, Completion Criteria sections
-  - After Spec Review Loop → update with any review-driven changes
-- The artifact should reflect the **current state of work at all times**
-- Do NOT wait until the end to write the artifact
-
-## Hook Execution
-Execute hooks for event `onLifeObjected` following the Hook System protocol:
-- Scan `.reap/hooks/` for `onLifeObjected.*` files
-- Sort by frontmatter `order`, then alphabetically
-- Evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script)
-- All hooks run BEFORE any commit (hook outputs included in the same commit)
-
-## Completion
-- **If called from `/reap.evolve`** (Autonomous Override active): Save the artifact, execute hooks, and proceed automatically. Do NOT pause for human confirmation.
-- **If called standalone**: Show the artifact to the human and get confirmation. Then execute hooks.
-- After confirmation or auto-proceed: "Proceed to the Planning stage with `/reap.next`."
+Run `reap run objective` and follow the stdout instructions exactly.