@c-d-cc/reap 0.10.2 → 0.10.3

package/README.ja.md

@@ -13,7 +13,7 @@
 
 <table align="center">
 <tr>
-<td align="center"><strong>Genome</strong><br><sub>設計とナレッジ</sub></td>
+<td align="center"><strong>Knowledge Base</strong><br><sub>Genome + Environment</sub></td>
 <td align="center">→</td>
 <td align="center"><strong>Evolution</strong><br><sub>世代を超えた進化</sub></td>
 <td align="center">→</td>
@@ -21,7 +21,7 @@
 </tr>
 </table>
 
-REAPはアプリケーションの遺伝情報（Genome）を定義し、各世代で目標を設定して実装し、その過程で発見したGenomeの欠陥を次のステージにフィードバックします。世代を重ねるごとにGenomeが進化し、Source Code（Civilization）が成長します。
+REAPはアプリケーションの設計知識 — Genome（アーキテクチャ、コンベンション、制約）とEnvironment（外部API、インフラ） — を記録し、各世代で目標を設定して実装します。その過程で発見した欠陥はKnowledge Baseにフィードバックされます。世代を重ねるごとに知識が進化し、Source Code（Civilization）が成長します。
 
 ## 目次
 

package/README.ko.md

@@ -13,7 +13,7 @@
 
 <table align="center">
 <tr>
-<td align="center"><strong>Genome</strong><br><sub>설계와 지식</sub></td>
+<td align="center"><strong>Knowledge Base</strong><br><sub>Genome + Environment</sub></td>
 <td align="center">→</td>
 <td align="center"><strong>Evolution</strong><br><sub>세대를 거친 진화</sub></td>
 <td align="center">→</td>
@@ -21,7 +21,7 @@
 </tr>
 </table>
 
-REAP은 Application의 유전 정보(Genome)를 정의하고, 각 세대에서 목표를 설정하여 구현하고, 그 과정에서 발견한 Genome 결함을 다음 단계에서 반영합니다. 세대를 거듭하며 Genome이 진화하고, Source Code(Civilization)가 성장합니다.
+REAP은 Application의 설계 지식 — Genome(아키텍처, 컨벤션, 제약사항)과 Environment(외부 API, 인프라) — 을 기록하고, 각 세대에서 목표를 설정하여 구현합니다. 그 과정에서 발견한 결함은 Knowledge Base에 반영됩니다. 세대를 거듭하며 지식이 진화하고, Source Code(Civilization)가 성장합니다.
 
 ## 목차
 

package/README.md

@@ -13,7 +13,7 @@
 
 <table align="center">
 <tr>
-<td align="center"><strong>Genome</strong><br><sub>Design & Knowledge</sub></td>
+<td align="center"><strong>Knowledge Base</strong><br><sub>Genome + Environment</sub></td>
 <td align="center">→</td>
 <td align="center"><strong>Evolution</strong><br><sub>Generational Progress</sub></td>
 <td align="center">→</td>
@@ -21,7 +21,7 @@
 </tr>
 </table>
 
-REAP defines an application's genetic information (Genome), sets objectives for each generation to implement, and feeds back any Genome defects discovered along the way into subsequent stages. As generations accumulate, the Genome evolves and the Source Code (Civilization) grows.
+REAP captures an application's design knowledge — the Genome (architecture, conventions, constraints) and Environment (external APIs, infrastructure) — then sets objectives for each generation to implement. Defects discovered along the way feed back into the Knowledge Base. As generations accumulate, knowledge evolves and the Source Code (Civilization) grows.
 
 ## Table of Contents
 

package/README.zh-CN.md

@@ -13,7 +13,7 @@
 
 <table align="center">
 <tr>
-<td align="center"><strong>Genome</strong><br><sub>设计与知识</sub></td>
+<td align="center"><strong>Knowledge Base</strong><br><sub>Genome + Environment</sub></td>
 <td align="center">→</td>
 <td align="center"><strong>Evolution</strong><br><sub>代际进化</sub></td>
 <td align="center">→</td>
@@ -21,7 +21,7 @@
 </tr>
 </table>
 
-REAP定义应用程序的遗传信息（Genome），为每个世代设定目标进行实现，并将过程中发现的Genome缺陷反馈到后续阶段。随着世代的积累，Genome不断进化，Source Code（Civilization）持续成长。
+REAP记录应用程序的设计知识 — Genome（架构、约定、约束）和Environment（外部API、基础设施） — 并在每个世代设定目标进行实现。过程中发现的缺陷反馈到Knowledge Base。随着世代的积累，知识不断进化，Source Code（Civilization）持续成长。
 
 ## 目录
 

package/dist/cli.js

@@ -9817,7 +9817,7 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
     log("GitHub CLI(gh) not found. Install from https://cli.github.com for auto issue reporting.");
   }
   const config = {
-    version: "0.10.2",
+    version: "0.10.3",
     project: projectName,
     entryMode,
     autoUpdate: true,
@@ -10992,7 +10992,7 @@ async function updateProject(projectRoot, dryRun = false) {
       result.skipped.push(`.claude/commands/ (${reapCmdFiles.length} unchanged)`);
     }
     await migrateLegacyFiles(paths, dryRun, result);
-    const currentVersion = "0.10.2";
+    const currentVersion = "0.10.3";
     const migrationResult = await MigrationRunner.run(paths, currentVersion, dryRun);
     for (const m of migrationResult.migrated) {
       result.updated.push(`[migration] ${m}`);
@@ -11169,7 +11169,7 @@ async function fixProject(projectRoot) {
 // src/cli/index.ts
 init_fs();
 import { join as join12 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.10.2");
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.10.3");
 program.command("init").description("Initialize a new REAP project (Genesis)").argument("[project-name]", "Project name (defaults to current directory name)").option("-m, --mode <mode>", "Entry mode: greenfield, migration, adoption", "greenfield").option("-p, --preset <preset>", "Bootstrap with a genome preset (e.g., bun-hono-react)").action(async (projectName, options) => {
   try {
     const cwd = process.cwd();

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

@@ -46,17 +46,11 @@ description: "REAP Back — Return to a previous lifecycle stage"
    ```
 
 ### Hook Execution (Regression)
-7. Scan `.reap/hooks/` for files matching `onLifeRegretted.*`
-   - 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
+7. Execute hooks for event `onLifeRegretted` following the Hook System protocol:
+   - Scan `.reap/hooks/` for `onLifeRegretted.*` 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
 - "Returned to [stage] stage. Proceed with `/reap.[stage]`."

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

@@ -1,5 +1,5 @@
 ---
-description: "REAP Completion — Retrospect, evolve the Genome, and finalize the Generation"
+description: "REAP Completion — Retrospect, evolve the Genome, archive, and finalize the Generation"
 ---
 
 # Completion
@@ -81,10 +81,15 @@ Do NOT finalize Genome changes without running Validation Commands.
     a. **Describe the pattern**: "최근 N개 generation에서 '[작업 설명]'이 반복적으로 수행되었습니다."
     b. **Ask if it should be a hook**: "이 작업을 hook으로 자동화할까요? (yes/no)"
     c. If yes, ask **event**: "어떤 이벤트에서 실행할까요?"
-       - `onLifeCompleted` — generation 완료 후
-       - `onLifeTransited` — stage 전환 시
-       - `onLifeStarted` — generation 시작 시
-       - `onLifeRegretted` — stage 회귀 시
+       - Normal lifecycle events (8개):
+         - `onLifeStarted` — generation 시작 시
+         - `onLifeObjected` — objective 완료 시
+         - `onLifePlanned` — planning 완료 시
+         - `onLifeImplemented` — implementation 완료 시
+         - `onLifeValidated` — validation 완료 시
+         - `onLifeCompleted` — generation 완료 시 (archiving 전, 커밋 전)
+         - `onLifeTransited` — stage 전환 시
+         - `onLifeRegretted` — stage 회귀 시
     d. Ask **condition**: "실행 조건은 무엇인가요?"
        - `always` — 항상
        - `has-code-changes` — src/ 변경이 있을 때
@@ -123,6 +128,47 @@ Do NOT finalize Genome changes without running Validation Commands.
 24. Report compression results: "Compressed N generations (Level 1: X, Level 2: Y)"
     - If no compression needed: skip silently
 
+### Phase 7: Hook Execution + Archiving + Commit
+
+**This phase replaces what `reap.next` previously did when advancing from completion.**
+
+25. **Hook Execution** (before archiving, before commit):
+    Execute hooks for event `onLifeCompleted` following the Hook System protocol:
+    - Scan `.reap/hooks/` for `onLifeCompleted.*` 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
+
+26. **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: normal
+      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 `05-*.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 `.reap/lineage/[gen-id]-[goal-slug]/backlog/`
+      - Files with `status: pending` or no status field → copy to `.reap/lineage/[gen-id]-[goal-slug]/backlog/` for record, then carry over to new `.reap/life/backlog/`
+    - Clear `current.yml` (write empty content)
+    - Recreate `.reap/life/backlog/` directory (with carried-over pending items already in place)
+
+27. **Commit all changes** (code + `.reap/` artifacts together):
+    - **Submodule check**: If any git submodule has uncommitted changes (e.g., `tests/`), commit and push inside the submodule first, then stage the updated submodule pointer in the parent repo
+    - Stage all changed files: code changes from this generation + `.reap/` directory + submodule pointers
+    - Commit message format: `feat(gen-NNN): [generation goal summary]`
+    - Use `feat` for feature generations, `fix` for bugfix generations, `chore` for maintenance
+    - Include both code and REAP artifacts in the same commit
+    - If there are no code changes (REAP-only generation), use `chore(reap): [goal summary]`
+
 ## Self-Verification
 Before saving the artifact, verify:
 - [ ] Are lessons concrete and applicable to the next generation? (No vague "do better next time")
@@ -144,5 +190,5 @@ Before saving the artifact, verify:
 - The artifact should reflect the current state of completion work at all times
 
 ## Completion
-- **If called from `/reap.evolve`** (Autonomous Override active): Proceed automatically to `/reap.next`.
-- **If called standalone**: "Finalize the generation with `/reap.next`. Lineage archiving will be performed automatically."
+- **If called from `/reap.evolve`** (Autonomous Override active): Execute Phase 7 (Hook + Archiving + Commit) automatically. Report: "Generation [id] complete and archived."
+- **If called standalone**: Execute Phase 7 (Hook + Archiving + Commit). Report: "Generation [id] complete and archived. Run `/reap.start` to begin a new generation."

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

@@ -31,6 +31,17 @@ When `/reap.evolve` calls each stage command, the following overrides apply:
 - **Escalation sections still apply**: If a stage's Escalation rules trigger, STOP and ask.
 - This override does NOT apply when stages are invoked standalone (e.g., user runs `/reap.objective` directly).
 
+## Hook Auto-Execution
+Each stage command automatically executes its own hook at completion:
+- `/reap.objective` → `onLifeObjected`
+- `/reap.planning` → `onLifePlanned`
+- `/reap.implementation` → `onLifeImplemented`
+- `/reap.validation` → `onLifeValidated`
+- `/reap.completion` → `onLifeCompleted` (before archiving and commit)
+
+`/reap.next` only handles stage transitions — it does NOT execute hooks or archiving.
+`/reap.completion` handles archiving and the final commit.
+
 ## Lifecycle Loop
 
 Execute the following loop until the generation is complete:
@@ -42,14 +53,14 @@ Execute the following loop until the generation is complete:
    - `implementation` → `/reap.implementation`
    - `validation` → `/reap.validation`
    - `completion` → `/reap.completion`
-3. When the stage command completes, run `/reap.next` to advance
-4. If `/reap.next` archives the generation (from completion), the loop ends
-5. Otherwise, return to step 1
+3. When the stage command completes (hooks already executed by the stage command):
+   - If the current stage is `completion`: `/reap.completion` handles archiving and commit internally. The loop ends.
+   - Otherwise: run `/reap.next` to advance, then return to step 1.
 
 ## Handling Issues
 - If validation fails: `/reap.back` to return to implementation (or earlier), then resume the loop
 - If the human wants to pause: stop the loop, the generation state is preserved in `current.yml`
-- If the human wants to skip a stage: advance with `/reap.next` without running the stage command
+- If the human wants to skip a stage: advance with `/reap.next` without running the stage command (note: hooks for skipped stages will NOT run)
 
 ## Completion
 - "Generation [id] completed. All artifacts archived to lineage."

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

@@ -97,6 +97,13 @@ In the following situations, **STOP and ask the human**:
 - By the time all tasks are done, the artifact should already be complete — no separate "generation" step is needed
 - Add Implementation Notes at the end summarizing notable decisions
 
+## Hook Execution
+Execute hooks for event `onLifeImplemented` following the Hook System protocol:
+- Scan `.reap/hooks/` for `onLifeImplemented.*` 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
 - "Proceed to the Validation stage with `/reap.next`."
 - "If issues are found during Validation, you can return with `/reap.back`."

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

@@ -1,5 +1,5 @@
 ---
-description: "REAP Merge Completion — Finalize the merge generation"
+description: "REAP Merge Completion — Finalize the merge generation with archiving"
 ---
 
 # Merge Completion
@@ -12,9 +12,48 @@ Finalize the merge generation after validation passes.
 
 ## Steps
 
-1. Commit the merged source + genome changes
-2. Write `06-completion.md` with:
+1. Write `06-completion.md` with:
    - Summary of what was merged
    - Genome changes applied
    - Lessons learned
-3. Proceed with `/reap.next` to archive
+
+### 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."

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

@@ -17,4 +17,11 @@ Analyze the divergence between the current branch and the target branch.
    - 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, proceed with `/reap.next`
+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)

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

@@ -9,6 +9,18 @@ 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:
@@ -20,8 +32,9 @@ Execute the merge lifecycle loop:
    - `sync` → `/reap.merge.sync`
    - `validation` → `/reap.merge.validation`
    - `completion` → `/reap.merge.completion`
-3. After each stage, run `/reap.next`
-4. If `/reap.next` archives the generation, the loop ends
+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.

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

@@ -20,7 +20,14 @@ Resolve genome conflicts identified in the detect stage. The genome must be full
    - 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. Proceed with `/reap.next`
+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

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

@@ -19,4 +19,11 @@ Merge the source code from the target branch, using the finalized genome as the
 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. Proceed with `/reap.next`
+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)

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

@@ -20,3 +20,10 @@ Start a merge generation by specifying a target branch to merge into the current
 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)

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

@@ -24,7 +24,14 @@ Verify that the merged source code is consistent with the finalized genome. This
    - 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. Proceed with `/reap.next`
+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

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

@@ -18,8 +18,16 @@ Run all validation commands to verify the merged code works correctly. Same as n
    - Type check (`bunx tsc --noEmit`)
    - Build (`npm run build`)
 3. Record results in `05-validation.md`
-4. If all pass: proceed with `/reap.next`
+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

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

@@ -13,7 +13,8 @@ This command is the **ONLY legitimate way** to advance the lifecycle stage. All
 ## Steps
 
 ### Stage Transition
-- Stage order: objective → planning → implementation → validation → completion
+- 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
@@ -22,70 +23,14 @@ This command is the **ONLY legitimate way** to advance the lifecycle stage. All
   ```
 - Immediately create the next stage's artifact file from template (empty, ready to fill)
 
-### Hook Execution (Stage Transition)
-Execute two sets of hooks in order:
+**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).
 
-1. **Stage-specific hook** — based on the stage that just completed:
-   - objective → planning: `onLifeObjected.*`
-   - planning → implementation: `onLifePlanned.*`
-   - implementation → validation: `onLifeImplemented.*`
-   - validation → completion: `onLifeValidated.*`
+### 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`
 
-2. **Generic transition hook** — `onLifeTransited.*` (fires on every transition)
-
-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
-
-### When Advancing from Completion (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: [normal or 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 `05-*.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 `.reap/lineage/[gen-id]-[goal-slug]/backlog/`
-  - Files with `status: pending` or no status field → copy to `.reap/lineage/[gen-id]-[goal-slug]/backlog/` for record, then carry over to new `.reap/life/backlog/`
-- Clear `current.yml` (write empty content)
-- Recreate `.reap/life/backlog/` directory (with carried-over pending items already in place)
-- **Commit all changes** (code + `.reap/` artifacts together):
-  - Stage all changed files: code changes from this generation + `.reap/` directory
-  - Commit message format: `feat(gen-NNN): [generation goal summary]`
-  - Use `feat` for feature generations, `fix` for bugfix generations, `chore` for maintenance
-  - Include both code and REAP artifacts in the same commit
-  - If there are no code changes (REAP-only generation), use `chore(reap): [goal summary]`
-
-### Hook Execution (Generation Complete)
-- Scan `.reap/hooks/` for files matching `onLifeCompleted.*`
-- 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
-- Note: hooks run AFTER the commit, so any changes from hooks will be uncommitted
+Scan `.reap/hooks/` for `{event}.*` files, sort by frontmatter `order` then alphabetically, evaluate `condition`, execute `.md` (AI prompt) or `.sh` (shell script).
 
 ## Completion
-- If archived: "Generation [id] complete and archived. Run `/reap.start` to begin a new generation."
-- Otherwise: "Advanced to [next stage]. Proceed with `/reap.[next stage]`."
+- "Advanced to [next stage]. Proceed with `/reap.[next stage]`."

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

@@ -196,7 +196,7 @@ When entering brainstorming, follow the structured brainstorming process below t
   ---
   type: genome-change
   status: pending
-  target: genome/domain/{topic}.md
+  target: genome/{file}
   ---
   # [Title]
   [Specifically what is lacking and how it should be changed]
@@ -250,7 +250,14 @@ Before saving the artifact, verify:
 - 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 and proceed automatically. Do NOT pause for human confirmation.
-- **If called standalone**: Show the artifact to the human and get confirmation.
+- **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`."

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

@@ -95,7 +95,14 @@ Before saving the artifact, verify:
 - 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
 
+## Hook Execution
+Execute hooks for event `onLifePlanned` following the Hook System protocol:
+- Scan `.reap/hooks/` for `onLifePlanned.*` 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 and proceed automatically. Do NOT pause for human confirmation.
-- **If called standalone**: Show the artifact to the human and get confirmation.
+- **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 Implementation stage with `/reap.next`."

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

@@ -41,17 +41,12 @@ description: "REAP Start — Start a new Generation"
 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
+8. Execute hooks for event `onLifeStarted` following the Hook System protocol:
+   - Scan `.reap/hooks/` for `onLifeStarted.*` 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)
+   - **Order**: This runs AFTER backlog consumed marking (Step 4) and current.yml creation (Step 6)
 
 ## Completion
 - "Generation gen-XXX-{hash} started. Proceed with `/reap.objective` to define the goal, or `/reap.evolve` to run the full lifecycle."

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

@@ -80,6 +80,13 @@ Do NOT make claims without evidence. This is non-negotiable.
 - After Step 5 (Verdict) → update the Result field to pass / partial / fail
 - The artifact should reflect the current validation progress at all times
 
+## Hook Execution
+Execute hooks for event `onLifeValidated` following the Hook System protocol:
+- Scan `.reap/hooks/` for `onLifeValidated.*` 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
-- pass/partial: "Proceed to the Completion stage with `/reap.next`."
-- fail: Provide regression guidance
+- pass/partial: Execute hooks, then "Proceed to the Completion stage with `/reap.next`."
+- fail: Provide regression guidance (do NOT execute hooks on fail)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c-d-cc/reap",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "description": "Recursive Evolutionary Autonomous Pipeline — AI and humans evolve software across generations",
   "type": "module",
   "license": "MIT",