@c-d-cc/reap 0.10.2 → 0.11.0

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

@@ -2,52 +2,4 @@
 description: "REAP Pull — Fetch remote, detect divergence, and run a full merge generation"
 ---
 
-# Pull
-
-Fetch from the remote, detect new generations, and run a full merge generation lifecycle. This is the distributed equivalent of `/reap.evolve`.
-
-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 pulling."
-
-## Arguments
-- `{branch}` — Target remote branch to pull from (required)
-
-## Steps
-
-### Phase 1: Fetch + Detect
-1. Run `git fetch origin` (or the specified remote)
-2. Verify the target branch exists: `git rev-parse --verify {branch}`
-   - If not found: ERROR — "Branch {branch} does not exist. Run `git fetch` first."
-3. Scan the target branch's `.reap/lineage/` via git refs:
-   - `git ls-tree -r --name-only {branch} -- .reap/lineage/`
-   - Read `meta.yml` files via `git show {branch}:.reap/lineage/{dir}/meta.yml`
-4. Compare with local lineage to identify new generations
-5. If no new generations: "Already up to date. No new generations on {branch}." → STOP
-6. Report: list new generation IDs + goals found on the target branch
-
-### Phase 1.5: Fast-Forward Check
-7. Determine the local latest generation ID and the remote latest generation ID
-8. Build a combined DAG from both local and remote lineage metadata
-9. Check if the local latest generation is an ancestor of the remote latest generation:
-   - **If yes (fast-forward possible)**:
-     - Run `git merge --ff {branch}`
-     - Run `git submodule update --init` to sync submodules
-     - Report: "Fast-forwarded to {branch}. Local lineage now includes {remote-latest-id}. No merge generation needed."
-     - **STOP** — no merge lifecycle needed
-   - **If same generation**: "Already up to date." → **STOP**
-   - **If no (diverged)**: Continue to Phase 2
-
-### Phase 2: Merge Generation
-10. Execute `/reap.merge.start` with the target branch
-    - This creates the merge generation and runs detect (01-detect.md)
-11. Execute `/reap.merge.evolve` to run the full merge lifecycle:
-    - Detect → Mate → Merge → Sync → Validation → Completion
-12. Run `git submodule update --init` to sync submodules after merge
-13. The merge generation is archived upon completion
-
-## Completion
-- Fast-forward: "Fast-forwarded to {branch}. No merge generation needed."
-- Full merge: "Pull complete. Merged {branch} into {current-branch}. Generation {id} archived."
+Run `reap run pull` and follow the stdout instructions exactly.

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

@@ -2,17 +2,4 @@
 description: "REAP Push — Validate REAP state and push current branch"
 ---
 
-# Push
-
-Validate the current REAP state and push the current branch to the remote.
-
-## Steps
-
-1. Read `.reap/life/current.yml`
-2. If an active generation exists and stage is not `completion`:
-   - Warn: "Generation {id} is in progress (stage: {stage}). Complete it before pushing."
-   - Ask the user: "Push anyway? (yes/no)"
-   - If no: STOP
-3. Get current branch: `git rev-parse --abbrev-ref HEAD`
-4. Run `git push origin {branch}`
-5. Report: "Pushed {branch} to origin."
+Run `reap run push` and follow the stdout instructions exactly.

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

@@ -2,126 +2,4 @@
 description: "REAP Report — Report a bug or issue to the REAP project"
 ---
 
-# Report
-
-Report a bug, malfunction, or feedback to the REAP project via GitHub Issue.
-**Language**: All user-facing messages must follow the user's configured language setting (see REAP Guide § Language).
-
-## Gate (Preconditions)
-- Check if `gh` CLI is available: `which gh`
-- If not available: inform user that GitHub CLI is required (https://cli.github.com), then `gh auth login`. **STOP**
-- Check if authenticated: `gh auth status`
-- If not authenticated: inform user to run `gh auth login`. **STOP**
-- Read `.reap/config.yml` — check `autoIssueReport` is not explicitly `false`
-- If `autoIssueReport: false`: inform user that issue reporting is disabled and how to enable it in config.yml. **STOP**
-
-## Mode Detection
-
-**Auto mode** (called by agent when malfunction detected):
-- The agent provides error context as arguments
-- Skip to Step 2 with pre-filled context
-
-**Manual mode** (user calls `/reap.report` directly):
-- Ask the user what they want to report:
-  - Bug / malfunction
-  - Feature request
-  - Other feedback
-- Gather description from the user
-
-## Steps
-
-### 1. Collect Context
-Automatically gather (do NOT ask the user for these):
-- REAP version: `reap --version`
-- Node version: `node --version`
-- OS: `uname -sr`
-- Agent: detect from environment (Claude Code, OpenCode, etc.)
-- Generation state: read `.reap/life/current.yml` (id, stage — if active)
-- Genome hash: compute from `.reap/genome/`
-- Config: read `.reap/config.yml`
-
-### 2. Draft Issue
-
-<PRIVACY_GATE>
-**BEFORE writing any issue content, apply these rules:**
-- Do NOT include: file contents, source code, environment variables, API keys,
-  tokens, passwords, usernames, email addresses, IP addresses, domain names,
-  database URLs, project-specific business logic, or any proprietary information.
-- ONLY include: REAP version, Node version, OS, generation ID, stage name,
-  command name, genome hash, generic error messages, and REAP config structure
-  (with all values masked).
-- When in doubt, OMIT the information rather than include it.
-</PRIVACY_GATE>
-
-Draft the issue using this template (issue body is always in English for the public repo):
-
-```markdown
-## {Bug Report / Feature Request / Feedback} (Auto-generated by REAP)
-
-**REAP Version**: v{version}
-**Node Version**: v{nodeVersion}
-**OS**: {os}
-**Agent**: {agentName}
-
-### Context
-- **Generation**: {genId or "none"} (stage: {stage or "n/a"})
-- **Command**: {command that triggered the issue}
-- **Genome Hash**: {genomeHash}
-
-### Description
-{user description or auto-detected malfunction description}
-
-### Expected Behavior
-{what should have happened}
-
-### Actual Behavior
-{what actually happened}
-
-### Steps to Reproduce
-1. {step}
-
-### Config
-```yaml
-version: {version}
-project: {projectName}
-strict: {on/off}
-autoUpdate: {on/off}
-# all other values masked
-```
-
----
-*Auto-reported by REAP agent. Repository: c-d-cc/reap*
-```
-
-### 3. Post-format Sanitization
-Scan the drafted issue body and mask/remove:
-- Email patterns: `*@*.*` → `[REDACTED_EMAIL]`
-- API key/token patterns: `sk-*`, `ghp_*`, `Bearer *`, `token:*` → `[REDACTED]`
-- URLs with credentials: `https://user:pass@` → `https://[REDACTED]@`
-- Environment variable values: `KEY=value` → `KEY=[REDACTED]`
-- User paths: `/Users/{name}/` or `/home/{name}/` → `/Users/***/`
-- IP addresses: digit patterns like `\d+\.\d+\.\d+\.\d+` → `[REDACTED_IP]`
-- Source code blocks: if any project source code is included, remove it
-
-### 4. User Confirmation
-Show the sanitized issue to the user (in user's language):
-- Explain that this report greatly helps improve the REAP project
-- Ask the user to verify no sensitive information is included
-- Present the full issue body
-- Ask: yes / no / edit
-  - **yes**: proceed to Step 5
-  - **no**: report cancelled
-  - **edit**: let user modify, then re-run Step 3 sanitization and re-confirm
-
-### 5. Submit
-- Determine labels (comma-separated, always include `auto-reported`):
-  - Bug: `bug,auto-reported`
-  - Feature request: `enhancement,auto-reported`
-  - Feedback: `feedback,auto-reported`
-  - Add context labels if applicable: `lifecycle`, `genome`, `cli`
-- Run: `gh issue create --repo c-d-cc/reap --title "{title}" --label "{labels}" --body "{sanitized body}"`
-- Show the issue URL to the user
-- Thank the user for their contribution to improving REAP
-
-## Completion
-- "Issue #{number} reported: {url}"
+Run `reap run report` and follow the stdout instructions exactly.

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

@@ -2,56 +2,4 @@
 description: "REAP Start — Start a new Generation"
 ---
 
-# Start a New Generation
-
-## Gate (Preconditions)
-- Read `.reap/life/current.yml`
-- If an active Generation exists: ERROR — "Generation [id] is in progress (stage: [stage]). Complete it before starting a new generation." **STOP**
-
-## Steps
-
-### 0. Backlog Scan
-- Read all files in `.reap/life/backlog/`
-- If backlog items exist:
-  - Present the list with title and priority for each item
-  - Ask: "Would you like to select one of these, or enter a new goal?"
-  - If the human selects a backlog item: **note the selection** (do NOT mark consumed yet — ID is not generated)
-  - If the human wants a new goal: proceed to Step 1
-- If no backlog items exist: proceed to Step 1
-
-1. Ask the human for the goal of this generation (or use selected backlog item's goal)
-2. Count existing generations in `.reap/lineage/` to determine the genomeVersion
-3. Generate the next generation ID:
-   - Format: `gen-{NNN}-{hash}` (e.g. `gen-042-a3f8c2`)
-   - `{NNN}`: zero-padded 3-digit sequence (existing count + 1)
-   - `{hash}`: 6-character hex (0-9a-f only) — first 6 chars of `sha256(JSON.stringify({parents, goal, genomeHash, machineId, startedAt}))`
-   - Generate: `node -e "const c=require('crypto'),o=require('os');console.log(c.createHash('sha256').update(JSON.stringify({parents:[],goal:'YOUR_GOAL',genomeHash:'',machineId:o.hostname(),startedAt:new Date().toISOString()})).digest('hex').slice(0,6))"`
-4. **If a backlog item was selected in Step 0**: now mark it as `status: consumed` and add `consumedBy: gen-XXX-{hash}` (using the ID just generated)
-6. Write the following to `current.yml`:
-   ```yaml
-   id: gen-XXX-{hash}
-   goal: [goal provided by the human]
-   stage: objective
-   genomeVersion: [generation count + 1]
-   startedAt: [current ISO 8601 timestamp]
-   timeline:
-     - stage: objective
-       at: [current ISO 8601 timestamp]
-   ```
-7. Immediately create `.reap/life/01-objective.md` from the artifact template with the Goal section filled in
-
-### Hook Execution (Generation Start)
-8. Scan `.reap/hooks/` for files matching `onLifeStarted.*`
-   - For each matched file (sorted by `order` from frontmatter, then alphabetically):
-     1. Read the frontmatter (`condition`, `order`)
-     2. Evaluate `condition` by running `.reap/hooks/conditions/{condition}.sh` (exit 0 = met, non-zero = skip):
-        - If `condition` is absent: treat as `always`
-        - If the condition script doesn't exist: warn and skip the hook
-        - Default conditions: `always`, `has-code-changes`, `version-bumped`
-        - Users can add custom conditions by placing scripts in `.reap/hooks/conditions/`
-     3. Execute based on file extension:
-        - `.md`: read the file content (after frontmatter) as AI prompt and follow the instructions
-        - `.sh`: run as shell script in the project root directory
-
-## Completion
-- "Generation gen-XXX-{hash} started. Proceed with `/reap.objective` to define the goal, or `/reap.evolve` to run the full lifecycle."
+Run `reap run start` and follow the stdout instructions exactly.

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

@@ -2,79 +2,4 @@
 description: "REAP Status — Show current generation state and project health"
 ---
 
-# Status
-
-Display a comprehensive overview of the current REAP project state.
-
-## IMPORTANT: File Access Rules
-- ONLY read files explicitly listed in the steps below. Do NOT guess or infer file paths.
-- If a file read fails or the file does not exist, skip it silently and continue.
-- Do NOT attempt to read files like `reaprc.json`, `.reaprc`, or any file not specified in this command.
-- The REAP project structure uses ONLY: `.reap/config.yml`, `.reap/life/current.yml`, `.reap/life/backlog/`, `.reap/life/0X-*.md`, `.reap/genome/`, `.reap/lineage/`
-
-## Steps
-
-### 1. Project Info (MUST execute all of these)
-- Read `.reap/config.yml` for project name, entryMode, strict, autoUpdate, language
-- Count completed generations in `.reap/lineage/`
-- **REQUIRED**: Run the shell command `reap --version` to get the installed version. You MUST actually execute this command, do not skip it.
-- Show "REAP: v{installed}" — do NOT run `npm view` here (slow network call). Users can run `/reap.update` to check for updates.
-
-### 2. Current Generation
-- Read `.reap/life/current.yml`
-- If no active generation: report "No active Generation" and skip to Step 5
-- Display: Generation ID, goal, current stage, genomeVersion, startedAt
-
-### 3. Stage Progress
-- Read the current stage's artifact file (`.reap/life/0X-*.md`)
-- Summarize what has been done so far in this stage (completed tasks, decisions made, etc.)
-- If the artifact doesn't exist yet, report "Stage not started"
-
-### 4. Timeline & Notable Events
-- Display the full timeline from `current.yml`:
-  - Stage transitions with timestamps
-  - Regressions (from, reason, refs)
-- Flag notable events:
-  - Any regressions in this generation
-  - Deferred tasks (from `03-implementation.md` if exists)
-  - Genome-change backlog items pending
-
-### 5. Backlog Summary
-- Read all files in `.reap/life/backlog/`
-- Count by type: `genome-change`, `environment-change`, `task`
-- List titles briefly
-
-### 6. Genome Health
-- Quick check of `.reap/genome/` files:
-  - Any files that are still placeholder-only?
-  - Any files exceeding their line limit? (default: ~100 lines. For source-map.md, read the file's own header to find its adaptive line limit.)
-  - Is `domain/` empty (no rule files)?
-
-## Output Format
-Present as a structured summary the human can quickly scan:
-
-```
-📊 REAP Status
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-REAP: v[installed] (run `/reap.update` to check for updates)
-Project: [name] ([entryMode])
-Strict: [on/off]  Auto-Update: [on/off]  Language: [lang]
-Genome Version: v[N]
-Completed Generations: [count]
-
-🔄 Active Generation: [id]
-Goal: [goal]
-Stage: [stage]
-Started: [date]
-
-📋 Stage Progress:
-[summary of current artifact]
-
-📅 Timeline:
-[stage transitions]
-
-📦 Backlog: [N] items
-  genome-change: [n]  environment-change: [n]  task: [n]
-
-🧬 Genome Health: [status]
-```
+Run `reap status` and present the output to the human.

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

@@ -2,83 +2,4 @@
 description: "REAP Sync Environment — Discover and document external environment dependencies"
 ---
 
-# Sync Environment
-
-Discover external systems, APIs, infrastructure, and constraints that affect this project. Populate the `.reap/environment/` 3-layer structure.
-
-## Gate (Preconditions)
-- Read `.reap/life/current.yml`
-- If active Generation exists: switch to **Backlog Mode** (record as `type: environment-change`)
-- If no active Generation: proceed with **Sync Mode** (modify environment directly after human confirmation)
-
-## Environment 3-Layer Structure
-
-```
-.reap/environment/
-├── summary.md          # Session context (~100 lines max)
-├── docs/               # Main reference docs (agent reads these)
-└── resources/          # Raw materials (user-managed)
-    ├── *.pdf, *.md     # Original documents
-    └── links.md        # External URLs + summaries
-```
-
-- **summary.md**: Auto-generated overview of all docs/. Loaded into session context.
-- **docs/**: One file per environment topic. ~100 lines each. AI + human maintained.
-- **resources/**: User-provided originals. No line limit. AI reads when deeper detail needed.
-
-## Steps
-
-### 1. Source Code Scan
-Detect hints of external dependencies from:
-- `package.json` / `requirements.txt` / `go.mod` — SDK/client libraries (e.g., `discord.js`, `@aws-sdk/*`, `stripe`)
-- Config files — `.env`, `.env.example`, `wrangler.toml`, `docker-compose.yml`, `vercel.json`
-- API client code — HTTP clients, webhook handlers, OAuth configs
-- Infrastructure — Dockerfile, CI/CD configs, deployment scripts
-
-Present findings:
-```
-🔍 Detected external dependencies:
-  - discord.js → Discord Bot API
-  - @supabase/supabase-js → Supabase (DB + Auth)
-  - wrangler.toml → Cloudflare Workers
-```
-
-### 2. User Interview
-Ask the user to confirm and expand. Goal: **capture ALL external systems** that affect this project.
-
-Questions (one at a time, skip if already covered):
-1. "감지된 외부 서비스들이 맞나요? 추가/수정할 것이 있나요?"
-2. "그 외에 연동되는 외부 서비스, API, 시스템이 있나요?"
-3. "배포/인프라 환경을 알려주세요 (호스팅, CI/CD, 도메인 등)"
-4. "따라야 하는 조직 규칙이나 외부 제약이 있나요? (보안 정책, 규제 등)"
-5. "참고해야 할 외부 문서나 링크가 있나요? (API docs, 스펙 등)"
-
-For each confirmed item:
-- Ask: "관련 문서/링크가 있으면 알려주세요 (없으면 skip)"
-- If provided: save to `resources/` (file or `links.md` entry)
-
-### 3. Generate docs/
-For each confirmed environment topic, create a file in `docs/`:
-- File name: `{topic-slug}.md` (e.g., `discord-api.md`, `infrastructure.md`)
-- Content: structured markdown with key info the agent needs during implementation
-- Sections: Overview, Key Constraints, API/Config Details, References (→ resources/)
-- ~100 lines max per file
-
-### 4. Generate summary.md
-Aggregate all docs/ into a concise summary:
-- One section per environment topic
-- Key constraints and gotchas highlighted
-- Links to docs/ files for detail
-- **~100 lines max** (this gets loaded into every session)
-
-### 5. Verify
-- List all created/updated files
-- Show summary.md content to user for confirmation
-- Ask: "빠진 환경 정보가 있나요?"
-
-## Backlog Mode (active Generation)
-- Record each discovered environment item as `type: environment-change` in `.reap/life/backlog/`
-- "Environment 변경사항이 backlog에 기록되었습니다. Completion에서 적용됩니다."
-
-## Completion
-- "Environment synced. {N} docs created, summary.md updated."
+Run `reap run sync-environment` and follow the stdout instructions exactly.

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

@@ -2,108 +2,4 @@
 description: "REAP Sync Genome — Synchronize Genome with current source code"
 ---
 
-# Sync Genome
-
-Analyze the current source code and update the Genome to reflect reality.
-
-<HARD-GATE>
-If an active Generation exists (`.reap/life/current.yml` has content), do NOT modify Genome directly.
-Instead, record discovered differences as `type: genome-change` items in `.reap/life/backlog/` and inform the human.
-Only proceed with direct Genome modification when NO active Generation exists.
-</HARD-GATE>
-
-## Gate (Preconditions)
-- Read `.reap/life/current.yml`
-- If active Generation exists: switch to **Backlog Mode** (record differences, do not modify Genome)
-- If no active Generation: proceed with **Sync Mode** (modify Genome directly after human confirmation)
-
-## Steps
-
-### 1. Read Current Genome
-- Read all files in `.reap/genome/` (principles.md, conventions.md, constraints.md, domain/)
-- Note current genomeVersion from the most recent generation in `.reap/lineage/`
-
-### 2. Analyze Source Code
-Scan the project to understand its current state:
-
-**Tech Stack & Dependencies**:
-- package.json, tsconfig.json, Dockerfile, docker-compose.yml, etc.
-- New dependencies added, removed, or version-changed since Genome was last updated
-
-**Architecture & Structure**:
-- Directory structure and patterns (layers, modules, services)
-- Entry points, routing, API structure
-- Database, ORM, migration setup
-
-**Conventions**:
-- Linter/formatter configs (.eslintrc, .prettierrc, biome.json, etc.)
-- Test setup and patterns (test framework, file naming, coverage config)
-- Git hooks, CI/CD config
-- Code patterns observed in the source (naming, error handling, etc.)
-
-**Constraints**:
-- Build commands, test commands, validation commands
-- Environment requirements, runtime constraints
-- External service dependencies
-
-**Domain Knowledge** (→ `genome/domain/`):
-- Read `~/.reap/templates/domain-guide.md` for domain file writing principles
-- Scan source code for business rules NOT derivable from infrastructure analysis:
-  - State machines and status transitions (e.g., post lifecycle, order states)
-  - Policy rules with thresholds, limits, or conditions (e.g., rate limits, scoring criteria)
-  - Classification/branching logic driven by business categories (e.g., template selection by type)
-  - Hardcoded domain constants (keyword lists, prompt templates, magic numbers with business meaning)
-  - Workflow orchestration sequences (e.g., approval flows, pipeline stages)
-- For each discovered domain rule cluster, evaluate:
-  - "Would an agent implementing this feature ask 'where is this rule?'" → YES = create domain file
-  - "Does a single item in an upper-level genome file require 3+ lines of explanation?" → YES = extract to domain file
-- Even if `genome/domain/` is currently empty, treat it as "not yet created" rather than "not needed"
-
-### 3. Diff Analysis
-Compare source analysis with current Genome and identify:
-- **Additions**: Things in code but not in Genome
-- **Changes**: Things in Genome that no longer match code
-- **Removals**: Things in Genome that no longer exist in code
-- **Gaps**: Areas where Genome has placeholders but code has established patterns
-- **Domain gaps**: Business rules in code that have no corresponding `domain/` file
-
-### 4. Report to Human
-Present a structured diff report:
-
-```
-🔄 Genome Sync Report
-━━━━━━━━━━━━━━━━━━━━━
-
-📝 principles.md
-  + [New] API-first design pattern observed
-  ~ [Changed] Layer structure: added shared/ directory
-
-📝 conventions.md
-  + [New] Biome used for linting (replacing ESLint)
-  ~ [Changed] Test pattern: using vitest instead of jest
-
-📝 constraints.md
-  + [New] Validation command: bun test
-  ~ [Changed] Runtime: Node.js compatible (was Bun-only)
-
-📁 domain/
-  + [Suggest] Create lifecycle-rules.md for REAP lifecycle logic
-```
-
-### 5. Apply Changes
-
-**Sync Mode** (no active Generation):
-- For each difference, ask the human: "Apply this change? (yes/no/modify)"
-- Apply confirmed changes to the corresponding Genome files
-- Follow Genome writing principles:
-  - Each file ≤ 100 lines
-  - If exceeding, extract to `domain/`
-  - Follow `~/.reap/templates/domain-guide.md` for domain files
-
-**Backlog Mode** (active Generation):
-- Record each difference as a `type: genome-change` backlog item in `.reap/life/backlog/`
-- Inform: "Genome changes recorded in backlog. They will be applied at the Completion stage."
-
-## Completion
-- **Sync Mode**: "Genome synchronized. [N] changes applied."
-- **Backlog Mode**: "Genome differences recorded as [N] backlog items. Apply during Completion."
+Run `reap run sync-genome` and follow the stdout instructions exactly.

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

@@ -2,16 +2,4 @@
 description: "REAP Sync — Synchronize both Genome and Environment with current state"
 ---
 
-# Sync (Full)
-
-Run both Genome and Environment synchronization.
-
-## Steps
-
-1. Execute `/reap.sync.genome` — synchronize Genome with source code
-2. Execute `/reap.sync.environment` — discover and document external environment
-
-## Usage
-- `/reap.sync` — full sync (recommended after init or major changes)
-- `/reap.sync.genome` — genome only
-- `/reap.sync.environment` — environment only
+Run `reap run sync` and follow the stdout instructions exactly.

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

@@ -2,43 +2,4 @@
 description: "REAP Update — Check for updates and upgrade REAP"
 ---
 
-# Update
-
-Check for REAP updates and upgrade to the latest version.
-
-## IMPORTANT: File Access Rules
-- Do NOT access global node_modules or any path outside the project.
-- If a command fails, report the error and stop.
-
-## Steps
-
-### 1. Check Current Version
-- Run `reap --version` to get the installed version
-- Run `npm view @c-d-cc/reap version` to get the latest published version
-- Compare the two versions
-
-### 2. Update Decision
-**If installed == latest:**
-- "REAP v{version} is already up to date. (latest)"
-- Then skip to Step 4.
-
-**If installed < latest (patch only — same major.minor, different patch):**
-- Show: "Patch update available: v{installed} → v{latest}. Updating automatically..."
-- Proceed directly to Step 3 (no user confirmation needed)
-
-**If installed < latest (minor or major change):**
-- Show: "Update available: v{installed} → v{latest}"
-- Ask the user: "Update now? (yes/no)"
-- If yes: proceed to Step 3
-- If no: "Skipped. Run `/reap.update` anytime to update."
-
-### 3. Perform Update
-- Run: `npm update -g @c-d-cc/reap`
-- If the command fails, suggest: `sudo npm update -g @c-d-cc/reap` or `npm install -g @c-d-cc/reap@latest`
-- After npm update, run: `reap update` to sync commands, templates, and hooks to all detected agents
-- Show the update result summary
-
-### 4. Sync Check
-- Run: `reap update --dry-run` to check if commands/templates need syncing
-- If changes detected: run `reap update` and show results
-- If no changes: "All commands and templates are up to date."
+Run `reap update` and follow the output. For detailed update steps, run `reap update --dry-run` first.