@c-d-cc/reap 0.1.0

package/dist/templates/genome/domain/README.md

@@ -0,0 +1,96 @@
+# Domain Rules — Writing Guide
+
+> `genome/domain/` is a space for recording the **business domain rules** of the project.
+> If `principles.md`, `conventions.md`, and `constraints.md` are the map of "what to do",
+> `domain/` holds the details of "how, why, and how much".
+
+## domain/ vs Upper-level Genome Files
+
+| Upper-level Genome File | domain/ File |
+|-------------------------|-------------|
+| One-line architecture decision | Detailed rules, flows, and state transitions for that decision |
+| Technical constraint summary | Thresholds, frequencies, conditions, and policy intent |
+| Code pattern name | Pattern inputs/outputs, triggers, and exception cases |
+
+**Example**: A one-liner in constraints.md: "Moderation suspension escalation: 3 times/1h → 30 min"
+→ domain/moderation-policy.md contains the full pipeline, threshold table, and state transition details
+
+## File Organization Principles
+
+### 1. Separate by Business Domain Unit
+
+Split files by **business rule grouping**, not by code structure (files, directories).
+
+- **Good examples**: `interview-protocol.md`, `billing-rules.md`, `moderation-policy.md`
+- **Bad examples**: `api-routes.md`, `database-tables.md`, `components.md`
+
+Each domain file corresponds to one "topic you would ask a domain expert about".
+
+### 2. Record Knowledge Not Directly Readable from Code
+
+Do not write down things that can be learned by reading the code (function signatures, type definitions).
+Record things that are difficult to determine from code alone:
+
+- **Policy intent**: Why this threshold, why this order
+- **Values and conditions**: Frequency (20–30%), limits (max 2), escalation steps
+- **State machines**: Trigger → state transition → result
+- **Domain term definitions**: Precise meaning of project-specific concepts
+
+### 3. Agent-Implementable Level
+
+An agent reading a domain file should be able to implement or modify the feature without additional questions.
+
+- Structure with tables/diagrams
+- Specify concrete values and conditions
+- Include exception cases and edge cases
+- Prohibit vague expressions like "it depends on the situation"
+
+### 4. File Size
+
+- Recommended: 40–80 lines
+- Upper limit: 100 lines (same as the genome map principle)
+- If exceeding 100 lines, split into sub-topics
+
+### 5. Genome Total Budget (SessionStart Load)
+
+- **L1** (upper-level genome files: principles, conventions, constraints): ~500 line limit. Always loaded in full
+- **L2** (domain/ files): ~200 line limit. Loaded in full within budget; if exceeded, only titles + summaries are loaded (on-demand reading)
+- As domain files grow, keep each file more concise or consolidate files with low reference frequency
+
+## File Structure Template
+
+```markdown
+# [Domain Rule Name]
+
+> [One-line description: scope covered by this file]
+
+## [Core Concepts/Flows]
+(Explain the core process or concepts of this domain)
+
+## [Rules/Policy Table]
+(Structure values, conditions, thresholds, etc. as a table)
+
+## [State Transitions / Triggers]
+(When does what occur)
+
+## [Exceptions/Edge Cases]
+(Exceptions to the general rules)
+```
+
+## Naming Rules
+
+- Filename: `kebab-case.md`
+- Names that intuitively represent the business domain
+- Examples: `interview-protocol.md`, `article-generation.md`, `subscription-billing.md`
+
+## When to Create a Domain File
+
+- When a single item in an upper-level genome file requires 3+ lines of explanation
+- When new business rules are added that don't fit the scope of existing files
+- When a topic is something an agent implementing a feature would ask "where is this rule?"
+
+## When NOT to Create a Domain File
+
+- Implementation details that can be understood by reading the code
+- One-off task notes (record these in life/)
+- External library usage (refer to official documentation for these)

package/dist/templates/genome/principles.md

@@ -0,0 +1,31 @@
+# Architecture Principles
+
+> **Writing principle**: This file should be a **map** of ~100 lines or fewer.
+> Write at a level where agents can act immediately.
+> Separate detailed content into files under `domain/`.
+> Modified only during the Birth phase.
+
+## Core Beliefs
+
+Describe core principles that both agents and humans must follow.
+Principles should be specific and verifiable. Instead of "write good code",
+describe it as "all external inputs are parsed/validated at the system boundary".
+
+- (Add architecture principles here)
+
+## Architecture Decisions
+
+Record major architecture decisions in ADR (Architecture Decision Record) format.
+Agents should be able to reason about "why it is this way".
+
+| ID | Decision | Rationale | Date |
+|----|----------|-----------|------|
+| | | | |
+
+## Layer Map
+
+Describe the project's layer structure and dependency direction.
+Specify which layers can depend on which layers.
+Write detailed layer rules in files under `domain/`.
+
+- (Describe layer structure here)

package/dist/templates/help/en.txt

@@ -0,0 +1,32 @@
+REAP — Recursive Evolutionary Autonomous Pipeline
+
+CLI Commands:
+  reap init [name]    Initialize a new REAP project
+  reap status         Show current project and Generation status
+  reap update         Sync slash commands, templates, and hooks
+  reap fix            Diagnose and repair .reap/ directory
+  reap help           Show this help message
+
+Slash Commands (use in Claude Code):
+  /reap.start          Start a new Generation
+  /reap.evolve         Run the full lifecycle autonomously
+  /reap.objective      Define goal + requirements
+  /reap.planning       Task decomposition + implementation plan
+  /reap.implementation Code implementation
+  /reap.validation     Run tests + check completion criteria
+  /reap.completion     Retrospective + genome updates
+  /reap.next           Advance to the next stage
+  /reap.back           Return to a previous stage
+  /reap.status         Show current state
+  /reap.sync           Synchronize Genome with source code
+  /reap.help           Contextual help (AI-powered)
+
+Quick Start:
+  1. reap init my-project
+  2. /reap.evolve  (runs the full lifecycle)
+  — or step by step: /reap.start → /reap.objective → /reap.next → ...
+
+Config: .reap/config.yml
+  strict: true/false   Restrict code changes to REAP workflow only
+
+Docs: https://github.com/c-d-cc/reap

package/dist/templates/help/ko.txt

@@ -0,0 +1,32 @@
+REAP — Recursive Evolutionary Autonomous Pipeline
+
+CLI 명령어:
+  reap init [name]    새 REAP 프로젝트 초기화
+  reap status         현재 프로젝트 및 Generation 상태 확인
+  reap update         슬래시 커맨드, 템플릿, 훅을 최신 버전으로 동기화
+  reap fix            .reap/ 디렉토리 구조 진단 및 복구
+  reap help           이 도움말 표시
+
+슬래시 커맨드 (Claude Code에서 사용):
+  /reap.start          새 Generation 시작
+  /reap.evolve         전체 라이프사이클 자율 실행
+  /reap.objective      목표 + 요구사항 정의
+  /reap.planning       작업 분해 + 구현 계획
+  /reap.implementation 코드 구현
+  /reap.validation     테스트 실행 + 완료 기준 확인
+  /reap.completion     회고 + Genome 업데이트
+  /reap.next           다음 단계로 전진
+  /reap.back           이전 단계로 회귀
+  /reap.status         현재 상태 확인
+  /reap.sync           Genome을 소스 코드와 동기화
+  /reap.help           상황별 도움말 (AI 기반)
+
+빠른 시작:
+  1. reap init my-project
+  2. /reap.evolve  (전체 라이프사이클 실행)
+  — 또는 단계별: /reap.start → /reap.objective → /reap.next → ...
+
+설정: .reap/config.yml
+  strict: true/false   코드 변경을 REAP 워크플로우로 제한
+
+문서: https://github.com/c-d-cc/reap

package/dist/templates/hooks/reap-guide.md

@@ -0,0 +1,188 @@
+# REAP Guide
+
+## What is REAP
+
+REAP (Recursive Evolutionary Autonomous Pipeline) is a development pipeline where AI and humans collaborate to incrementally evolve an Application across successive Generations.
+
+## 3-Layer Model
+
+```
+Genome (Genetic Information)  →  Evolution (Cross-generational Evolution)  →  Civilization (Source Code)
+  Design and knowledge             Life cycle, mutation, adaptation              Accumulated artifacts
+```
+
+- **Genome** — Design and knowledge for building the Application. Stored in `.reap/genome/`.
+- **Evolution** — The process by which Genome evolves and Civilization grows through repeated Generations.
+- **Civilization** — Source Code. The entire project codebase outside `.reap/`.
+
+## Genome Structure
+
+```
+.reap/genome/
+├── principles.md      # Architecture principles/decisions (ADR style)
+├── domain/            # Business rules (separated by module)
+├── conventions.md     # Development rules/conventions + Enforced Rules
+└── constraints.md     # Technical constraints/choices + Validation Commands
+```
+
+**Genome Immutability Principle**: The current generation does not modify Genome directly. Issues discovered during Implementation are recorded in the backlog as `type: genome-change` and applied to Genome only during the Completion stage.
+
+**Environment Immutability Principle**: The current generation does not modify Environment directly. External environment changes discovered during a generation are recorded in the backlog as `type: environment-change` and applied during the Completion stage.
+
+## .reap/ 4-Axis Structure
+
+| Axis | Path | Role |
+|------|------|------|
+| **Genome** | `.reap/genome/` | Genetic information. Collection of principles, rules, and decisions |
+| **Environment** | `.reap/environment/` | External environment. API docs, infrastructure info, business constraints |
+| **Life** | `.reap/life/` | Current generation's life cycle. Progress state and artifacts |
+| **Lineage** | `.reap/lineage/` | Genealogy. Archive of completed generations |
+
+## Life Cycle (A Single Generation's Lifespan)
+
+```
+Objective → Planning → Implementation ⟷ Validation → Completion
+```
+
+| Stage | Description | What it does | Artifact |
+|-------|-------------|--------------|----------|
+| **Objective** | Goal definition | Define this generation's goal + requirements. Reference environment, backlog, genome | `01-objective.md` |
+| **Planning** | Plan formulation | Task decomposition, dependencies, implementation approach | `02-planning.md` |
+| **Implementation** | Implementation | AI+Human collaboration to write code. Record genome defects in backlog when found | `03-implementation.md` |
+| **Validation** | Verification | Run tests, check completion criteria. Can regress to Implementation on failure | `04-validation.md` |
+| **Completion** | Finalization | Retrospective + backlog review + apply genome changes + archiving | `05-completion.md` |
+
+## Key Concepts
+
+### Generation
+A single generation. Carries one goal through the Life Cycle. State is tracked in `life/current.yml`.
+
+### Backlog
+All items to be carried forward to the next generation are stored in `.reap/life/backlog/`. Each item uses markdown + frontmatter format:
+- `type: genome-change` — Applied to genome during Completion (genome defects discovered mid-generation)
+- `type: environment-change` — Applied to environment during Completion (external environment changes discovered mid-generation)
+- `type: task` — Referenced as goal candidates in the next Objective (deferred tasks, tech debt, etc.)
+
+Each item also carries a `status` field:
+- `status: pending` — Not yet processed (default; absent field treated as pending)
+- `status: consumed` — Processed in the current generation (requires `consumedBy: gen-XXX`)
+
+Marking rules:
+- `/reap.start`: backlog items chosen as the generation's goal → mark `consumed`
+- `/reap.completion`: applied `genome-change` / `environment-change` items → mark `consumed`
+
+Archiving rules (`/reap.next` from completion):
+- `consumed` items → moved to lineage
+- `pending` items → copied to lineage + carried forward to the new generation's backlog
+
+### Task Deferral
+Tasks that depend on Genome changes cannot be completed in the current generation. Mark as `[deferred]` and add to backlog as `type: task`. Partial completion is normal.
+
+### Micro Loop (Regression to a Previous Stage)
+Any stage can regress to a previous stage. Use `/reap.back` to go back one stage, or `/reap.back [stage]` to regress to a specific stage.
+
+Artifact handling rules:
+- **Before target stage**: Preserved
+- **Target stage**: Overwritten (implementation only appends)
+- **After target stage**: Preserved, overwritten upon re-entry
+
+Regression reason is recorded as a `## Regression` section in the target stage's artifact.
+
+### Minor Fix
+Trivial issues (typos, lint errors, etc.) are fixed directly in the current stage without a stage transition and recorded in the artifact. Judgment criterion: resolvable within 5 minutes without design changes.
+
+### Lineage Compression
+As generations accumulate, lineage grows. Auto-compression triggers when total exceeds 10,000 lines + 5 or more generations:
+- **Level 1**: Generation folder → single .md (40 lines). Only goal + result + notable items preserved.
+- **Level 2**: 5 Level 1 entries → epoch .md (60 lines). Only key flow preserved.
+
+Compression runs automatically during `/reap.next` (archiving after completion).
+
+## REAP Hooks
+
+Projects can define hooks in `.reap/config.yml` to run commands or prompts at lifecycle events:
+
+```yaml
+hooks:
+  onGenerationStart:
+    - command: "echo 'Generation started'"
+  onStageTransition:
+    - command: "echo 'Stage changed'"
+  onGenerationComplete:
+    - command: "reap update"
+    - prompt: "Check if README needs updating based on this generation's changes."
+  onRegression:
+    - command: "echo 'Regressed'"
+```
+
+Each hook entry supports two types:
+- `command` — Run a shell command in the project root directory
+- `prompt` — AI agent instruction. The agent reads and executes the described task.
+
+Only one of `command` or `prompt` should be set per entry.
+
+| Event | Trigger |
+|-------|---------|
+| `onGenerationStart` | After `/reap.start` creates a new generation |
+| `onStageTransition` | After `/reap.next` advances to the next stage |
+| `onGenerationComplete` | After `/reap.next` archives a completed generation (after commit) |
+| `onRegression` | After `/reap.back` returns to a previous stage |
+
+Hooks are executed by the AI agent.
+
+## Role Separation
+
+| Component | Role |
+|-----------|------|
+| **CLI (`reap`)** | Project setup and maintenance. Init, status, update, fix |
+| **AI Agent** | Workflow executor. Performs each stage's work via slash commands |
+| **Human** | Decision maker. Sets goals, finalizes specs, reviews code, approves stage transitions |
+
+## Execution Flow
+
+```
+1. /reap.start → Start a new Generation
+2. /reap.objective → Define goal + requirements
+3. /reap.next
+4. /reap.planning → Task decomposition + implementation plan
+5. /reap.next
+6. /reap.implementation → Code implementation
+7. /reap.next
+8. /reap.validation → Verification
+9. /reap.next
+10. /reap.completion → Retrospective + genome updates
+11. /reap.next → Archiving, generation ends
+```
+
+Each slash command follows a 3-step structure: Gate (precondition check) → Steps (work execution) → Artifact generation.
+
+## Language
+
+All REAP artifacts and user interactions MUST follow the user's configured language setting (from `~/.claude/settings.json` `language` field or the system prompt's language instruction).
+
+- **Artifacts** (01-objective.md through 05-completion.md): Write in the user's language. Template section headings (Goal, Completion Criteria, etc.) may remain in English, but all content/descriptions must be in the user's language.
+- **User interactions**: Communicate with the user in their configured language — questions, status updates, confirmations, error messages.
+- **Backlog items**: Write in the user's language.
+- **Genome files**: Write in the user's configured language. When modifying genome during Completion, use the user's language.
+- **If no language is configured**: Default to English.
+
+## Strict Mode
+
+When `strict: true` is set in `.reap/config.yml`, the AI agent enforces code modification restrictions:
+
+| Condition | Code Modification | Allowed Actions |
+|-----------|------------------|-----------------|
+| No active Generation | **BLOCKED** | Read, analyze, answer questions |
+| Active Generation, not implementation stage | **BLOCKED** | Read, analyze, answer questions, write REAP artifacts |
+| Active Generation, implementation stage | **SCOPED** — only files/modules listed in 02-planning.md | Full development within plan scope |
+
+- **Escape hatch**: If the user explicitly requests to bypass strict mode (e.g., "override", "bypass strict", "just do it"), the agent may proceed but must inform the user that strict mode is being bypassed.
+- **Default**: `strict: false` (no restrictions beyond normal REAP workflow guidance).
+
+## Critical Rules
+
+1. **NEVER modify `current.yml` directly.** Stage transitions MUST go through `/reap.next` (forward) or `/reap.back` (regression). Direct modification bypasses artifact creation and breaks the lifecycle.
+2. **NEVER skip a stage.** Each stage command must be executed and its artifact must exist before advancing. `/reap.next` enforces this by creating the next artifact from template.
+3. **ALL development work MUST follow the REAP lifecycle.** Do NOT bypass it unless the human explicitly asks.
+4. **Genome is the authoritative source of truth.** When making any decision about architecture, conventions, constraints, or domain rules, ALWAYS consult the Genome first. If you observe code that contradicts the Genome, flag it as a potential `genome-change` backlog item. Do NOT silently ignore discrepancies.
+5. **Keep Genome fresh.** If you notice the Genome is missing information about current code patterns, or contains outdated information, inform the human and suggest `/reap.sync`. The human may choose to defer sync — respect that choice, but always flag the staleness.

package/dist/templates/hooks/session-start.sh

@@ -0,0 +1,163 @@
+#!/usr/bin/env bash
+# REAP SessionStart hook — injects REAP guide + Genome + current generation context into every Claude session
+# This script runs from the package directory but uses cwd to find the project's .reap/
+set -euo pipefail
+
+# Script directory (package-internal) for guide file
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+
+# Project directory is cwd (where Claude Code session started)
+PROJECT_ROOT="$(pwd)"
+REAP_DIR="${PROJECT_ROOT}/.reap"
+CURRENT_YML="${REAP_DIR}/life/current.yml"
+GUIDE_FILE="${SCRIPT_DIR}/reap-guide.md"
+GENOME_DIR="${REAP_DIR}/genome"
+
+# Check if this is a REAP project
+if [ ! -d "$REAP_DIR" ]; then
+  exit 0
+fi
+
+# Read REAP guide
+reap_guide=""
+if [ -f "$GUIDE_FILE" ]; then
+  reap_guide=$(cat "$GUIDE_FILE")
+fi
+
+# Read Genome files with tiered loading
+# L1 (~500 lines max): principles.md, conventions.md, constraints.md — always full load
+# L2 (~200 lines max): domain/*.md — full load if within budget, otherwise title+summary only
+L1_LIMIT=500
+L2_LIMIT=200
+
+genome_content=""
+l1_lines=0
+if [ -d "$GENOME_DIR" ]; then
+  for f in "$GENOME_DIR"/principles.md "$GENOME_DIR"/conventions.md "$GENOME_DIR"/constraints.md; do
+    if [ -f "$f" ]; then
+      file_content=$(cat "$f")
+      file_lines=$(echo "$file_content" | wc -l | tr -d ' ')
+      l1_lines=$((l1_lines + file_lines))
+      if [ "$l1_lines" -le "$L1_LIMIT" ]; then
+        genome_content="${genome_content}\n### $(basename "$f")\n${file_content}\n"
+      else
+        # L1 budget exceeded — include truncated with warning
+        genome_content="${genome_content}\n### $(basename "$f") [TRUNCATED — L1 budget exceeded, read full file directly]\n$(echo "$file_content" | head -20)\n...\n"
+      fi
+    fi
+  done
+
+  # L2: domain/ files
+  if [ -d "$GENOME_DIR/domain" ]; then
+    l2_lines=0
+    l2_overflow=false
+    for f in "$GENOME_DIR"/domain/*.md; do
+      if [ -f "$f" ]; then
+        file_content=$(cat "$f")
+        file_lines=$(echo "$file_content" | wc -l | tr -d ' ')
+        l2_lines=$((l2_lines + file_lines))
+        if [ "$l2_overflow" = false ] && [ "$l2_lines" -le "$L2_LIMIT" ]; then
+          genome_content="${genome_content}\n### domain/$(basename "$f")\n${file_content}\n"
+        else
+          # L2 budget exceeded — title + first line only
+          l2_overflow=true
+          first_line=$(echo "$file_content" | grep -m1 "^>" || echo "$file_content" | head -1)
+          genome_content="${genome_content}\n### domain/$(basename "$f") [summary — read full file for details]\n${first_line}\n"
+        fi
+      fi
+    done
+  fi
+fi
+
+# Detect Genome staleness — count commits since last Genome modification
+genome_stale_warning=""
+if command -v git &>/dev/null && [ -d "$PROJECT_ROOT/.git" ]; then
+  last_genome_commit=$(git -C "$PROJECT_ROOT" log -1 --format="%H" -- ".reap/genome/" 2>/dev/null || echo "")
+  if [ -n "$last_genome_commit" ]; then
+    commits_since=$(git -C "$PROJECT_ROOT" rev-list --count "${last_genome_commit}..HEAD" 2>/dev/null || echo "0")
+    if [ "$commits_since" -gt 10 ]; then
+      genome_stale_warning="WARNING: Genome may be stale — ${commits_since} commits since last Genome update. Consider running /reap.sync to synchronize."
+    fi
+  fi
+fi
+
+# Read strict mode from config.yml
+strict_mode=false
+CONFIG_FILE="${REAP_DIR}/config.yml"
+if [ -f "$CONFIG_FILE" ]; then
+  strict_val=$(grep "^strict:" "$CONFIG_FILE" 2>/dev/null | sed 's/^strict: *//' | tr -d ' ' || true)
+  if [ "$strict_val" = "true" ]; then
+    strict_mode=true
+  fi
+fi
+
+# Read current.yml
+gen_stage="none"
+if [ ! -f "$CURRENT_YML" ]; then
+  generation_context="No active Generation. Run \`/reap.start\` to start one."
+else
+  content=$(cat "$CURRENT_YML")
+  if [ -z "$content" ]; then
+    generation_context="No active Generation. Run \`/reap.start\` to start one."
+  else
+    # Parse YAML fields (simple grep-based, no external deps)
+    gen_id=$(echo "$content" | grep "^id:" | sed 's/^id: *//')
+    gen_goal=$(echo "$content" | grep "^goal:" | sed 's/^goal: *//')
+    gen_stage=$(echo "$content" | grep "^stage:" | sed 's/^stage: *//')
+    generation_context="Active Generation: ${gen_id} | Goal: ${gen_goal} | Stage: ${gen_stage}"
+  fi
+fi
+
+# Map stage to command
+case "${gen_stage}" in
+  objective)      next_cmd="/reap.objective" ;;
+  planning)       next_cmd="/reap.planning" ;;
+  implementation) next_cmd="/reap.implementation" ;;
+  validation)     next_cmd="/reap.validation" ;;
+  completion)     next_cmd="/reap.completion" ;;
+  *)              next_cmd="/reap.start" ;;
+esac
+
+# Escape for JSON
+escape_for_json() {
+  local s="$1"
+  s="${s//\\/\\\\}"
+  s="${s//\"/\\\"}"
+  s="${s//$'\n'/\\n}"
+  s="${s//$'\r'/\\r}"
+  s="${s//$'\t'/\\t}"
+  printf '%s' "$s"
+}
+
+# Build strict mode section
+strict_section=""
+if [ "$strict_mode" = true ]; then
+  if [ "$gen_stage" = "implementation" ]; then
+    strict_section="\n\n## Strict Mode (ACTIVE — SCOPED MODIFICATION ALLOWED)\n<HARD-GATE>\nStrict mode is enabled. Code modification is ALLOWED only within the scope of the current Generation's plan.\n- You MUST read \`.reap/life/02-planning.md\` before writing any code.\n- You may ONLY modify files and modules listed in the plan's task list.\n- Changes outside the plan's scope are BLOCKED. If you discover out-of-scope work is needed, add it to the backlog instead of implementing it.\n- If the user explicitly requests to bypass strict mode (e.g., \"override\", \"bypass strict\"), you may proceed — but inform them that strict mode is being bypassed.\n</HARD-GATE>"
+  elif [ "$gen_stage" = "none" ]; then
+    strict_section="\n\n## Strict Mode (ACTIVE — CODE MODIFICATION BLOCKED)\n<HARD-GATE>\nStrict mode is enabled and there is NO active Generation.\nYou MUST NOT write, edit, or create any source code files.\nAllowed actions: reading files, analyzing code, answering questions, running commands.\nTo start coding, the user must first run \`/reap.start\` and advance to the implementation stage.\nIf the user explicitly requests to bypass strict mode (e.g., \"override\", \"bypass strict\", \"just do it\"), you may proceed — but inform them that strict mode is being bypassed.\n</HARD-GATE>"
+  else
+    strict_section="\n\n## Strict Mode (ACTIVE — CODE MODIFICATION BLOCKED)\n<HARD-GATE>\nStrict mode is enabled. Current stage is '${gen_stage}', which is NOT the implementation stage.\nYou MUST NOT write, edit, or create any source code files.\nAllowed actions: reading files, analyzing code, answering questions, running commands, writing REAP artifacts.\nAdvance to the implementation stage via the REAP lifecycle to unlock code modification.\nIf the user explicitly requests to bypass strict mode (e.g., \"override\", \"bypass strict\", \"just do it\"), you may proceed — but inform them that strict mode is being bypassed.\n</HARD-GATE>"
+  fi
+fi
+
+# Build staleness section
+stale_section=""
+if [ -n "$genome_stale_warning" ]; then
+  stale_section="\n\n## Genome Staleness\n${genome_stale_warning}\nIf the user wants to proceed without syncing, ask: \"The Genome may be stale. Would you like to run /reap.sync now, or do it later?\" and respect their choice."
+fi
+
+reap_context="<REAP_WORKFLOW>\n${reap_guide}\n\n---\n\n## Genome (Project Knowledge — treat as authoritative source of truth)\n${genome_content}\n\n---\n\n## Current State\n${generation_context}${stale_section}${strict_section}\n\n## Rules\n1. ALL development work MUST follow the REAP lifecycle. Do NOT bypass it.\n2. Before writing any code, check if a Generation is active and what stage it is in.\n3. If a Generation is active, use \`${next_cmd}\` to proceed with the current stage.\n4. If no Generation is active, use \`/reap.start\` to start a new one.\n5. Do NOT implement features, fix bugs, or make changes outside of the REAP lifecycle unless the user explicitly asks to bypass it.\n6. When the user says \"reap evolve\", \"next stage\", \"proceed\", or similar — invoke the appropriate REAP skill.\n7. **Genome is the authoritative knowledge source.** When making decisions about architecture, conventions, or constraints, ALWAYS reference the Genome first. If code contradicts Genome, flag it as a potential genome-change backlog item.\n8. If you notice the Genome is outdated or missing information relevant to your current task, inform the user and suggest running \`/reap.sync\`.\n</REAP_WORKFLOW>"
+
+escaped_context=$(escape_for_json "$reap_context")
+
+cat <<EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "SessionStart",
+    "additionalContext": "${escaped_context}"
+  }
+}
+EOF
+
+exit 0

package/dist/templates/presets/bun-hono-react/constraints.md

@@ -0,0 +1,28 @@
+# Technical Constraints
+
+> Modified only during the Birth stage.
+
+## Tech Stack
+
+- **Language**: TypeScript 5.x
+- **Runtime**: Bun 1.x
+- **Backend**: Hono — Web Standard API, middleware
+- **Frontend**: React 19 — Component UI
+- **Package Manager**: bun
+
+## Constraints
+
+- Use `shared/` directory when sharing types between server and client
+- API responses must always be JSON
+- Environment variables are managed via `.env`; no hardcoding in source code
+
+## Validation Commands
+
+| Purpose | Command | Description |
+|---------|---------|-------------|
+| Test | `bun test` | Run all tests |
+| Type check | `bunx tsc --noEmit` | TypeScript compilation verification |
+
+## External Dependencies
+
+- (Add as needed for the project)

package/dist/templates/presets/bun-hono-react/conventions.md

@@ -0,0 +1,28 @@
+# Development Conventions
+
+> Modified only during the Birth stage.
+
+## Code Style
+
+- TypeScript strict mode
+- Functions should have a single responsibility, recommended 50 lines or fewer
+- Use `async/await`
+
+## Naming Conventions
+
+- File names: `kebab-case.ts` / `kebab-case.tsx`
+- Components: `PascalCase`
+- Functions/variables: `camelCase`
+- API routes: `/api/v1/resource-name`
+
+## Git Conventions
+
+- Commit messages: `type: description` (feat, fix, test, chore, docs)
+- One commit = one logical change
+
+## Enforced Rules
+
+| Rule | Validation Tool | Command |
+|------|-----------------|---------|
+| All tests pass | bun test | `bun test` |
+| TypeScript compilation | tsc | `bunx tsc --noEmit` |

package/dist/templates/presets/bun-hono-react/principles.md

@@ -0,0 +1,28 @@
+# Architecture Principles
+
+> Modified only during the Birth stage.
+
+## Core Beliefs
+
+- **API-First** — Design REST/RPC APIs with Hono first; React is a client that consumes the APIs
+- **Type-Safe Full Stack** — Server and client share the same TypeScript types
+- **Edge-Ready** — Fast startup with Bun runtime, portability through Hono's Web Standard API
+- **Colocation** — Keep related code close together (route + handler + schema)
+
+## Architecture Decisions
+
+| ID | Decision | Rationale | Date |
+|----|----------|-----------|------|
+| ADR-001 | Bun + TypeScript | Fast execution, built-in testing, native TS support | - |
+| ADR-002 | Hono (Web Framework) | Lightweight, Web Standard, middleware system | - |
+| ADR-003 | React (Frontend) | Ecosystem, component model | - |
+
+## Layer Map
+
+```
+src/
+├── server/        → Hono API routes + middleware
+├── client/        → React components + pages
+├── shared/        → Shared types and utilities for server/client
+└── db/            → Data access layer
+```