@c-d-cc/reap 0.1.0

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

@@ -0,0 +1,171 @@
+---
+description: "REAP Objective — Define the goal and specification for this Generation"
+---
+
+# Objective (Goal Definition)
+
+<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.
+</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 Scan
+- Read all files in `.reap/environment/`
+- This directory stores external context: external API docs, product requirements, team decision logs, reference materials, etc.
+- **If empty (first time setup)**, conduct an interactive Environment setup:
+  1. **Brief the human on what Environment means**:
+     > "Environment is where we record information **external to this project** — things that affect development but are outside the project's direct control.
+     > Unlike the Genome (design and knowledge the team decides), Environment captures the **constraints and context from the outside world**:
+     > connected systems, infrastructure, organizational rules, external API specs, etc."
+  2. **Ask questions interactively** (one at a time, skip if not applicable):
+     - "Are there any **connected systems**? (other services, external APIs, legacy systems, etc.)"
+     - "What is the **infrastructure/deployment environment**? (cloud, on-premise, containers, etc.)"
+     - "Are there **organizational rules or guidelines** to follow? (company standards, coding policies, security policies, regulatory compliance, etc.)"
+     - "Are there **external reference documents** to incorporate? (API specs, system architecture diagrams, integration guides, etc.)"
+  3. **Save collected information** to `.reap/environment/` as structured markdown files (e.g., `integrations.md`, `infrastructure.md`, `org-guidelines.md`)
+  4. If the human has nothing to add, that's fine — Environment is optional
+- If files already exist, review them and ask if any updates are needed
+
+### 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
+- Based on the above information, converse with the human to refine this generation's goal
+- If genome enhancement is needed, discuss whether to include it in this generation's goal
+- Criteria for a good goal:
+  - Achievable within a single Generation
+  - Verifiable completion criteria (no vague wording)
+  - Relevant genome areas are clearly identified
+
+### 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/domain/{topic}.md
+  ---
+  # [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
+
+## 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?
+
+❌ 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 Goal + Spec Definition → update Goal, Scope sections
+  - After Genome Gap Analysis → update Backlog section
+  - After Requirements Finalization → update Requirements, Completion Criteria sections
+- The artifact should reflect the **current state of work at all times**
+- Do NOT wait until the end to write the artifact
+
+## Completion
+- **If called from `/reap.evolve`** (Autonomous Override active): Save the artifact and proceed automatically. Do NOT pause for human confirmation.
+- **If called standalone**: Show the artifact to the human and get confirmation.
+- After confirmation or auto-proceed: "Proceed to the Planning stage with `/reap.next`."

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

@@ -0,0 +1,88 @@
+---
+description: "REAP Planning — Develop the implementation plan and decompose tasks"
+---
+
+# Planning (Plan Development)
+
+<HARD-GATE>
+Do NOT create a plan without reading 01-objective.md.
+Do NOT make technical decisions without reading the Genome (conventions.md, constraints.md).
+</HARD-GATE>
+
+## Gate (Preconditions)
+- Read `.reap/life/current.yml` and verify that stage is `planning`
+- Verify that `.reap/life/01-objective.md` exists
+- If not met: ERROR — state the reason and **STOP**
+
+## Context (Generation Info)
+- Read `.reap/life/current.yml` for the current generation info (id, goal, genomeVersion)
+
+## Re-entry Check
+- If `.reap/life/02-planning.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
+- If `03-implementation.md` already exists, also reference implementation progress (decide whether to keep completed tasks)
+
+## Steps
+
+### 1. Read Objective
+- Read requirements and acceptance criteria from `.reap/life/01-objective.md`
+- Determine how to implement each FR
+
+### 2. Genome Reference
+- Check technical constraints and Validation Commands in `.reap/genome/constraints.md`
+- Check development rules and Enforced Rules in `.reap/genome/conventions.md`
+- Check Core Beliefs and Architecture Decisions in `.reap/genome/principles.md`
+
+### 3. Develop Implementation Plan
+- Decide on the architectural approach and technology choices
+- Respect the Tech Stack in constraints.md
+- **If there is an uncertain technical decision, STOP and ask the human**
+
+### 4. Task Decomposition
+- Write tasks as a checklist in the format `- [ ] T001 description`
+- **Limit**: Maximum 20 tasks. If exceeding 20, split into Phases.
+- Each task must be **one logical unit of change**
+- Specify dependencies and parallelization potential between tasks
+
+### 5. Human Confirmation
+- Finalize the plan with the human
+
+## Task Format
+
+```
+### Phase 1: [Phase Name]
+- [ ] T001 [Specific action] — [target file/module]
+- [ ] T002 [P] [Specific action] — [target file/module]
+
+### Phase 2: [Phase Name]
+- [ ] T003 [Specific action] — [target file/module]
+```
+
+- `[P]`: Indicates parallelizable execution
+- Specify the target file/module for each task
+
+❌ Bad task: "- [ ] T001 Implement authentication"
+✅ Good task: "- [ ] T001 `src/lib/auth.ts` — Configure NextAuth Google OAuth + define authOptions"
+
+## Self-Verification
+Before saving the artifact, verify:
+- [ ] Does every FR have a corresponding task?
+- [ ] Are dependencies between tasks specified?
+- [ ] Is the target file/module specified for each task?
+- [ ] Is the Phase classification logical?
+
+## 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/02-planning.md` and create `.reap/life/02-planning.md` with the Summary section filled in
+- **Update incrementally**: As each step progresses, update the artifact in place:
+  - After Genome Reference → update Technical Context section
+  - After Develop Implementation Plan → update Summary with architecture decisions
+  - After Task Decomposition → add tasks to the Tasks section as they are decomposed
+- The artifact is a **living document** during the stage — it should reflect the current state of work at all times
+- Do NOT wait until the end to write the artifact
+
+## Completion
+- **If called from `/reap.evolve`** (Autonomous Override active): Save the artifact and proceed automatically. Do NOT pause for human confirmation.
+- **If called standalone**: Show the artifact to the human and get confirmation.
+- After confirmation or auto-proceed: "Proceed to the Implementation stage with `/reap.next`."

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

@@ -0,0 +1,44 @@
+---
+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: use its title/content as the goal, then update the selected item's frontmatter to `status: consumed` and add `consumedBy: gen-XXX`
+  - 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
+2. Count existing generations in `.reap/lineage/` to determine the genomeVersion
+3. Generate the next generation ID (existing count + 1, in `gen-XXX` format)
+4. Write the following to `current.yml`:
+   ```yaml
+   id: gen-XXX
+   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]
+   ```
+5. Immediately create `.reap/life/01-objective.md` from the artifact template with the Goal section filled in
+
+### Hook Execution
+6. Read `.reap/config.yml` — if `hooks.onGenerationStart` is defined, execute each hook in order:
+   - If hook has `command`: run the shell command
+   - If hook has `prompt`: follow the prompt instructions (AI agent executes the described task)
+
+## Completion
+- "Generation gen-XXX started. Proceed with `/reap.objective` to define the goal, or `/reap.evolve` to run the full lifecycle."

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

@@ -0,0 +1,70 @@
+---
+description: "REAP Status — Show current generation state and project health"
+---
+
+# Status
+
+Display a comprehensive overview of the current REAP project state.
+
+## Steps
+
+### 1. Project Info
+- Read `.reap/config.yml` for project name, entryMode, preset, hooks
+- Count completed generations in `.reap/lineage/`
+
+### 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 100 lines?
+  - Is `domain/` empty (no rule files)?
+
+## Output Format
+Present as a structured summary the human can quickly scan:
+
+```
+📊 REAP Status
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Project: [name] ([entryMode])
+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]
+```

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

@@ -0,0 +1,95 @@
+---
+description: "REAP Sync — Synchronize Genome with current source code"
+---
+
+# Sync (Genome Synchronization)
+
+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
+
+### 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
+
+### 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."

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

@@ -0,0 +1,85 @@
+---
+description: "REAP Validation — Verify goal achievement through testing and validation"
+---
+
+# Validation
+
+<HARD-GATE>
+Do NOT declare "pass" without running the validation commands.
+Do NOT reuse results from a previous run — you MUST execute them fresh in this session.
+"It will probably pass" or "It looks fine" is NOT validation.
+Do NOT make claims without evidence. This is non-negotiable.
+</HARD-GATE>
+
+## Gate (Preconditions)
+- Read `.reap/life/current.yml` and verify that stage is `validation`
+- Verify that `.reap/life/03-implementation.md` exists
+- If not met: ERROR — state the reason and **STOP**
+
+## Context (Generation Info)
+- Read `.reap/life/current.yml` for the current generation info (id, goal, genomeVersion)
+
+## Re-entry Check
+- If `.reap/life/04-validation.md` already exists, this is a **re-entry due to regression**
+- Reference the previous validation report, but overwrite it with a fresh one
+
+## Steps
+
+### 1. Run Automated Validation
+- Read the **Validation Commands** table from `.reap/genome/constraints.md`
+- Execute **all** defined commands **in order**:
+  - Test → Lint → Build → Type check
+- Record the **actual output and exit code** of each command
+- Skip items with no defined command, but record them as "undefined"
+
+| Claim | Required Evidence | Insufficient Evidence |
+|-------|------------------|-----------------------|
+| "Tests pass" | Test command output: 0 failures | Previous run, "it should pass" |
+| "Lint clean" | Lint output: 0 errors | Partial check, assumption |
+| "Build succeeds" | Build command: exit 0 | "Lint passed so build should too" |
+
+### 2. Convention Compliance Check
+- Read the **Enforced Rules** table from `.reap/genome/conventions.md`
+- Execute the verification command for each defined rule
+- Record any violations
+
+### 3. Completion Criteria Review
+- Read the completion criteria from `.reap/life/01-objective.md`
+- Check the deferred task list in `.reap/life/03-implementation.md`
+- Review each completion criterion **one by one**, excluding deferred tasks from scope
+- Determine pass/fail/deferred for each criterion
+
+### 4. Minor Fix (Fix Trivial Issues Directly)
+- Fix typos, lint errors, minor bugs, and other **issues that can be resolved without a stage transition** directly
+- Record all fixes in the "Minor Fixes" section of the artifact
+- Minor fix criteria: **issues resolvable within 5 minutes without design changes**
+- After minor fixes, **re-run** the relevant validation commands
+
+### 5. Verdict
+- All automated validations pass + completion criteria met → **pass**
+- Automated validations pass + some completion criteria deferred → **partial**
+- Automated validation failure or completion criteria not met → **fail**
+- If **fail**, provide regression guidance:
+  - Code issue → `/reap.back` (implementation)
+  - Plan issue → `/reap.back planning`
+  - Goal issue → `/reap.back objective`
+
+## Red Flags — STOP if you catch yourself thinking:
+- "It will probably pass" → Run it.
+- "It passed before" → Run it again.
+- "It's trivial, it'll be fine" → Fix it as a minor fix and re-validate.
+- "I haven't tried the build but lint passed" → Run the build too.
+
+## 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/04-validation.md` and create `.reap/life/04-validation.md` with `result: pending`
+- **Update incrementally during validation**:
+  - After EACH validation command execution → immediately record the result in Test Results
+  - After EACH completion criterion check → immediately record pass/fail/deferred in the Completion Criteria Check table
+  - After EACH minor fix → immediately record it in the Minor Fixes table, then re-run and record
+- After Step 5 (Verdict) → update the Result field to pass / partial / fail
+- The artifact should reflect the current validation progress at all times
+
+## Completion
+- pass/partial: "Proceed to the Completion stage with `/reap.next`."
+- fail: Provide regression guidance

package/dist/templates/genome/constraints.md

@@ -0,0 +1,38 @@
+# Technical Constraints
+
+> **Writing principle**: This file should be a **map** of ~100 lines or fewer.
+> Record not only the "what" but also the "why" of each technical choice.
+> Agents refer to this file when making technical decisions.
+> Modified only during the Birth phase.
+
+## Tech Stack
+
+Briefly record the rationale for each technology choice.
+
+- **Language**: (language and version) — Rationale:
+- **Framework**: (framework) — Rationale:
+- **Database**: (database) — Rationale:
+- **Runtime**: (runtime environment) — Rationale:
+
+## Constraints
+
+Technical constraints that agents must follow during implementation.
+
+- (Add technical constraints here)
+
+## Validation Commands
+
+Project test/lint/build commands. Automatically executed during the Validation phase.
+
+| Purpose | Command | Description |
+|---------|---------|-------------|
+| Test | | e.g., `npm test`, `bun test` |
+| Lint | | e.g., `npm run lint` |
+| Build | | e.g., `npm run build` |
+| Type check | | e.g., `tsc --noEmit` |
+
+## External Dependencies
+
+External services, APIs, etc. Specify external dependencies that agents cannot access.
+
+- (External services, APIs, etc.)

package/dist/templates/genome/conventions.md

@@ -0,0 +1,35 @@
+# Development Conventions
+
+> **Writing principle**: This file should be a **map** of ~100 lines or fewer.
+> Write rules to be mechanically verifiable whenever possible.
+> Instead of "write good code", describe it as "functions must not exceed 50 lines".
+> Prioritize rules that can be enforced via linters/tests over documentation-only rules.
+> Modified only during the Birth phase.
+
+## Code Style
+
+Code style rules. Delegate to linter configuration for anything the linter can enforce;
+record only rules that linters cannot catch here.
+
+- (Add code style rules here)
+
+## Naming Conventions
+
+Naming rules for filenames, variables, functions, classes, etc.
+
+- (Add naming rules here)
+
+## Git Conventions
+
+Commit messages, branching strategy, PR rules.
+
+- (Add commit/branching rules here)
+
+## Enforced Rules
+
+List of mechanically enforced rules. Specify which tool verifies each rule.
+Automatically executed during the Validation phase.
+
+| Rule | Verification Tool | Command |
+|------|-------------------|---------|
+| | | |