@c-d-cc/reap 0.2.2 → 0.3.0

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

@@ -71,6 +71,39 @@ Do NOT finalize Genome changes without running Validation Commands.
     - **If called standalone**: Show the modified genome/environment content to the human and get approval. Do NOT finalize changes until the human approves.
 16. For each applied `type: genome-change` and `type: environment-change` backlog item, update its frontmatter to `status: consumed` and add `consumedBy: gen-XXX`
 
+### Phase 5: Hook Suggestion
+
+17. Read the last 3 completed generations from `.reap/lineage/` (sorted by gen number, most recent first)
+    - For each: read `03-implementation.md` (Implementation Notes) and `05-completion.md` (Retrospective)
+    - Identify **manual tasks that were repeated across 2+ generations**
+    - Examples: docs update, lint fix, dependency sync, test data setup, specific file regeneration
+18. If a repeated pattern is found, engage the human with a step-by-step confirmation:
+    a. **Describe the pattern**: "최근 N개 generation에서 '[작업 설명]'이 반복적으로 수행되었습니다."
+    b. **Ask if it should be a hook**: "이 작업을 hook으로 자동화할까요? (yes/no)"
+    c. If yes, ask **event**: "어떤 이벤트에서 실행할까요?"
+       - `onGenerationComplete` — generation 완료 후
+       - `onStageTransition` — stage 전환 시
+       - `onGenerationStart` — generation 시작 시
+       - `onRegression` — stage 회귀 시
+    d. Ask **condition**: "실행 조건은 무엇인가요?"
+       - `always` — 항상
+       - `has-code-changes` — src/ 변경이 있을 때
+       - `version-bumped` — version bump가 있을 때
+       - Custom — 유저가 직접 기술
+    e. Ask **hook name**: "hook 이름을 지어주세요 (예: lint-fix, docs-sync)"
+    f. **Preview**: 생성될 hook 파일 내용을 보여주고 확인:
+       ```
+       파일: .reap/hooks/{event}.{name}.md
+       ---
+       condition: {condition}
+       order: 50
+       ---
+       {작업 내용}
+       ```
+    g. 유저 확인 후 `.reap/hooks/{event}.{name}.md` 생성
+19. 반복 패턴이 없으면 skip — "반복 패턴이 감지되지 않았습니다."
+20. **Limit**: 한 번에 최대 2개까지만 제안 (과부하 방지)
+
 ## Self-Verification
 Before saving the artifact, verify:
 - [ ] Are lessons concrete and applicable to the next generation? (No vague "do better next time")

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

@@ -21,9 +21,17 @@ description: "REAP Next — Advance to the next lifecycle stage"
 - Immediately create the next stage's artifact file from template (empty, ready to fill)
 
 ### Hook Execution (Stage Transition)
-- Read `.reap/config.yml` — if `hooks.onStageTransition` 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)
+- Scan `.reap/hooks/` for files matching `onStageTransition.*`
+- 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`
@@ -43,10 +51,18 @@ description: "REAP Next — Advance to the next lifecycle stage"
   - If there are no code changes (REAP-only generation), use `chore(reap): [goal summary]`
 
 ### Hook Execution (Generation Complete)
-- Read `.reap/config.yml` — if `hooks.onGenerationComplete` 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)
-  - Note: hooks run AFTER the commit, so any changes from hooks will be uncommitted
+- Scan `.reap/hooks/` for files matching `onGenerationComplete.*`
+- 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
 
 ## Completion
 - If archived: "Generation [id] complete and archived. Run `/reap.start` to begin a new generation."

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

@@ -35,10 +35,18 @@ description: "REAP Start — Start a new Generation"
    ```
 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)
+### Hook Execution (Generation Start)
+6. Scan `.reap/hooks/` for files matching `onGenerationStart.*`
+   - For each matched file (sorted by `order` from frontmatter, then alphabetically):
+     1. Read the frontmatter (`condition`, `order`)
+     2. Evaluate `condition` by running `.reap/hooks/conditions/{condition}.sh` (exit 0 = met, non-zero = skip):
+        - If `condition` is absent: treat as `always`
+        - If the condition script doesn't exist: warn and skip the hook
+        - Default conditions: `always`, `has-code-changes`, `version-bumped`
+        - Users can add custom conditions by placing scripts in `.reap/hooks/conditions/`
+     3. Execute based on file extension:
+        - `.md`: read the file content (after frontmatter) as AI prompt and follow the instructions
+        - `.sh`: run as shell script in the project root directory
 
 ## Completion
 - "Generation gen-XXX started. Proceed with `/reap.objective` to define the goal, or `/reap.evolve` to run the full lifecycle."

package/dist/templates/conditions/always.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Always true — hook always executes
+exit 0

package/dist/templates/conditions/has-code-changes.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# True if src/ files were changed in the most recent commit
+# Exit 0 = condition met, Exit 1 = condition not met
+last_commit=$(git log -1 --format="%H" 2>/dev/null)
+if [ -z "$last_commit" ]; then
+  exit 1
+fi
+changes=$(git diff-tree --no-commit-id --name-only -r "$last_commit" -- src/ 2>/dev/null)
+if [ -n "$changes" ]; then
+  exit 0
+else
+  exit 1
+fi

package/dist/templates/conditions/version-bumped.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# True if package.json version differs from the last git tag
+# Exit 0 = version was bumped, Exit 1 = same version
+last_tag=$(git describe --tags --abbrev=0 2>/dev/null)
+if [ -z "$last_tag" ]; then
+  exit 1
+fi
+tag_version="${last_tag#v}"
+pkg_version=$(node -e "console.log(require('./package.json').version)" 2>/dev/null)
+if [ -z "$pkg_version" ]; then
+  exit 1
+fi
+if [ "$tag_version" != "$pkg_version" ]; then
+  exit 0
+else
+  exit 1
+fi

package/dist/templates/genome/constraints.md

@@ -3,7 +3,7 @@
 > **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.
+> Modified only during the Completion stage.
 
 ## Tech Stack
 

package/dist/templates/genome/conventions.md

@@ -4,7 +4,7 @@
 > 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.
+> Modified only during the Completion stage.
 
 ## Code Style
 

package/dist/templates/genome/principles.md

@@ -3,7 +3,7 @@
 > **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.
+> Modified only during the Completion stage.
 
 ## Core Beliefs
 
@@ -22,10 +22,6 @@ Agents should be able to reason about "why it is this way".
 |----|----------|-----------|------|
 | | | | |
 
-## Layer Map
+## Source 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)
+→ See `genome/source-map.md` for C4 Container + Component level Mermaid diagrams.

package/dist/templates/genome/source-map.md

@@ -0,0 +1,22 @@
+# Source Map
+
+> C4 Container + Component level project structure map.
+> Agents reference this before exploring code to quickly identify entry points.
+> Line limit: ~150 lines (adaptive to codebase size).
+> Modified only during the Completion stage.
+
+## C4 Context
+
+(Describe the system context: users, external systems, and relationships)
+
+## C4 Container
+
+(Describe containers: applications, data stores, and their interactions)
+
+## Core Components
+
+(Describe key components within each container)
+
+## Data Flow
+
+(Describe how data flows through the system)

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

@@ -92,7 +92,7 @@ Regression reason is recorded as a `## Regression` section in the target stage's
 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:
+As generations accumulate, lineage grows. Auto-compression triggers when total exceeds 5,000 lines + 5 or more generations (most recent 3 generations are protected):
 - **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.
 
@@ -100,26 +100,34 @@ 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'"
+Hooks are defined as individual files in `.reap/hooks/` with the naming convention `{event}.{name}.{md|sh}`:
+
+```
+.reap/hooks/
+├── onGenerationComplete.version-bump.md
+├── onGenerationComplete.reap-update.sh
+├── onGenerationComplete.docs-update.md
+└── onGenerationComplete.release-notes.md
 ```
 
-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.
+File naming: `{event}.{name}.{extension}`
+- Event: onGenerationStart, onStageTransition, onGenerationComplete, onRegression
+- Extension: `.md` (AI prompt) or `.sh` (shell script)
+
+Frontmatter (`.md` files) or comment headers (`.sh` files):
+- `condition`: name of a script in `.reap/hooks/conditions/` (default: `always`)
+- `order`: execution order within the same event (default: 50, lower runs first)
+
+### Conditions
+
+Conditions are executable scripts in `.reap/hooks/conditions/`. Exit code 0 = condition met, non-zero = skip.
+
+Default conditions (installed by `reap init`):
+- `always.sh` — always true
+- `has-code-changes.sh` — true if src/ files were changed in the last commit
+- `version-bumped.sh` — true if package.json version ≠ last git tag
 
-Only one of `command` or `prompt` should be set per entry.
+Custom conditions: add any `.sh` script to `.reap/hooks/conditions/`. The hook's `condition` field matches the filename (without `.sh`).
 
 | Event | Trigger |
 |-------|---------|
@@ -128,7 +136,7 @@ Only one of `command` or `prompt` should be set per entry.
 | `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.
+Hooks are executed by the AI agent by scanning `.reap/hooks/` for files matching the current event.
 
 ## Multi-Agent Support
 

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

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+// REAP SessionStart hook — injects REAP guide + Genome + current generation context
+// Single Node.js process (replaces session-start.sh for better performance)
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const startTime = Date.now();
+let step = 0;
+const totalSteps = 6;
+
+function log(msg) {
+  step++;
+  process.stderr.write(`[REAP ${step}/${totalSteps} +${Date.now() - startTime}ms] ${msg}\n`);
+}
+
+function readFile(p) {
+  try { return fs.readFileSync(p, 'utf-8'); } catch { return null; }
+}
+
+function fileExists(p) {
+  try { return fs.statSync(p).isFile(); } catch { return false; }
+}
+
+function dirExists(p) {
+  try { return fs.statSync(p).isDirectory(); } catch { return false; }
+}
+
+function exec(cmd) {
+  try { return execSync(cmd, { encoding: 'utf-8', timeout: 10000 }).trim(); } catch { return ''; }
+}
+
+// Paths
+const scriptDir = __dirname;
+const projectRoot = process.cwd();
+const reapDir = path.join(projectRoot, '.reap');
+const genomeDir = path.join(reapDir, 'genome');
+const configFile = path.join(reapDir, 'config.yml');
+const currentYml = path.join(reapDir, 'life', 'current.yml');
+const guideFile = path.join(scriptDir, 'reap-guide.md');
+
+// Check REAP project
+if (!dirExists(reapDir)) {
+  process.stderr.write('[REAP] Not a REAP project, skipping\n');
+  process.exit(0);
+}
+
+// Step 1: Auto-update
+log('Checking for updates...');
+let autoUpdateMessage = '';
+const configContent = readFile(configFile);
+if (configContent) {
+  const autoUpdate = /^autoUpdate:\s*true/m.test(configContent);
+  if (autoUpdate) {
+    const installed = exec('reap --version');
+    const latest = exec('npm view @c-d-cc/reap version');
+    if (installed && latest && installed !== latest) {
+      const updated = exec('npm update -g @c-d-cc/reap');
+      if (updated !== null) {
+        exec('reap update');
+        autoUpdateMessage = `REAP auto-updated: v${installed} → v${latest}`;
+      }
+    }
+  }
+}
+
+// Step 2: Load REAP guide
+log('Loading REAP guide...');
+const reapGuide = readFile(guideFile) || '';
+
+// Step 3: Load Genome (tiered)
+log('Loading Genome...');
+const L1_LIMIT = 500;
+const L2_LIMIT = 200;
+let genomeContent = '';
+let l1Lines = 0;
+
+const l1Files = ['principles.md', 'conventions.md', 'constraints.md', 'source-map.md'];
+for (const file of l1Files) {
+  const content = readFile(path.join(genomeDir, file));
+  if (!content) continue;
+  const lines = content.split('\n').length;
+  l1Lines += lines;
+  if (l1Lines <= L1_LIMIT) {
+    genomeContent += `\n### ${file}\n${content}\n`;
+  } else {
+    genomeContent += `\n### ${file} [TRUNCATED — L1 budget exceeded, read full file directly]\n${content.split('\n').slice(0, 20).join('\n')}\n...\n`;
+  }
+}
+
+// L2: domain/ files
+const domainDir = path.join(genomeDir, 'domain');
+if (dirExists(domainDir)) {
+  let l2Lines = 0;
+  let l2Overflow = false;
+  const domainFiles = fs.readdirSync(domainDir).filter(f => f.endsWith('.md')).sort();
+  for (const file of domainFiles) {
+    const content = readFile(path.join(domainDir, file));
+    if (!content) continue;
+    const lines = content.split('\n').length;
+    l2Lines += lines;
+    if (!l2Overflow && l2Lines <= L2_LIMIT) {
+      genomeContent += `\n### domain/${file}\n${content}\n`;
+    } else {
+      l2Overflow = true;
+      const firstLine = content.split('\n').find(l => l.startsWith('>')) || content.split('\n')[0];
+      genomeContent += `\n### domain/${file} [summary — read full file for details]\n${firstLine}\n`;
+    }
+  }
+}
+
+// Step 4: Check Genome & source-map sync
+log('Checking sync...');
+let genomeStaleWarning = '';
+let commitsSince = 0;
+if (dirExists(path.join(projectRoot, '.git'))) {
+  const lastGenomeCommit = exec(`git -C "${projectRoot}" log -1 --format="%H" -- ".reap/genome/"`);
+  if (lastGenomeCommit) {
+    commitsSince = parseInt(exec(`git -C "${projectRoot}" rev-list --count "${lastGenomeCommit}..HEAD" -- src/ tests/ package.json tsconfig.json scripts/`) || '0', 10);
+    if (commitsSince > 10) {
+      genomeStaleWarning = `WARNING: Genome may be stale — ${commitsSince} commits since last Genome update. Consider running /reap.sync to synchronize.`;
+    }
+  }
+}
+
+let sourcemapDriftWarning = '';
+let documented = 0, actual = 0;
+const sourcemapFile = path.join(genomeDir, 'source-map.md');
+const srcCoreDir = path.join(projectRoot, 'src', 'core');
+if (fileExists(sourcemapFile) && dirExists(srcCoreDir)) {
+  const smContent = readFile(sourcemapFile) || '';
+  documented = (smContent.match(/Component\(/g) || []).length;
+  const coreEntries = fs.readdirSync(srcCoreDir);
+  actual = coreEntries.filter(e => e.endsWith('.ts')).length
+    + coreEntries.filter(e => { try { return fs.statSync(path.join(srcCoreDir, e)).isDirectory(); } catch { return false; } }).length;
+  if (documented > 0 && actual > 0 && documented !== actual) {
+    sourcemapDriftWarning = `WARNING: source-map.md drift — ${documented} components documented, ${actual} core files found. Consider running /reap.sync.`;
+  }
+}
+
+// Step 5: Read generation state
+log('Reading generation state...');
+const strictMode = configContent ? /^strict:\s*true/m.test(configContent) : false;
+
+let genStage = 'none', genId = '', genGoal = '', generationContext = '';
+const currentContent = readFile(currentYml);
+if (currentContent && currentContent.trim()) {
+  genId = (currentContent.match(/^id:\s*(.+)/m) || [])[1] || '';
+  genGoal = (currentContent.match(/^goal:\s*(.+)/m) || [])[1] || '';
+  genStage = (currentContent.match(/^stage:\s*(.+)/m) || [])[1] || 'none';
+  if (genId && genStage !== 'none') {
+    generationContext = `Active Generation: ${genId} | Goal: ${genGoal} | Stage: ${genStage}`;
+  } else {
+    genStage = 'none';
+    generationContext = 'No active Generation. Run `/reap.start` to start one.';
+  }
+} else {
+  generationContext = 'No active Generation. Run `/reap.start` to start one.';
+}
+
+const stageCommands = { objective: '/reap.objective', planning: '/reap.planning', implementation: '/reap.implementation', validation: '/reap.validation', completion: '/reap.completion' };
+const nextCmd = stageCommands[genStage] || '/reap.start';
+
+// Build strict mode section
+let strictSection = '';
+if (strictMode) {
+  if (genStage === 'implementation') {
+    strictSection = '\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>';
+  } else if (genStage === 'none') {
+    strictSection = '\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 {
+    strictSection = `\n\n## Strict Mode (ACTIVE — CODE MODIFICATION BLOCKED)\n<HARD-GATE>\nStrict mode is enabled. Current stage is '${genStage}', 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>`;
+  }
+}
+
+// Build staleness section
+let staleSection = '';
+if (genomeStaleWarning) {
+  staleSection = `\n\n## Genome Staleness\n${genomeStaleWarning}\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.`;
+}
+if (sourcemapDriftWarning) {
+  staleSection += `\n${sourcemapDriftWarning}`;
+}
+
+// Build auto-update section
+let updateSection = '';
+if (autoUpdateMessage) {
+  updateSection = `\n\n## Auto-Update\n${autoUpdateMessage}. Tell the user: "${autoUpdateMessage}"`;
+}
+
+// Write session init log
+const initLines = [];
+if (autoUpdateMessage) initLines.push(`🟢 ${autoUpdateMessage}`);
+
+// Genome status (single line)
+const issues = [];
+let severity = 'ok';
+if (l1Lines === 0) { issues.push('empty'); severity = 'danger'; }
+for (const f of [...l1Files, 'domain/']) {
+  const check = f.endsWith('/') ? dirExists(path.join(genomeDir, f.slice(0, -1))) : fileExists(path.join(genomeDir, f));
+  if (!check) { issues.push(`missing ${f}`); severity = 'danger'; }
+}
+if (!fileExists(configFile)) { issues.push('no config.yml'); severity = 'danger'; }
+if (sourcemapDriftWarning) {
+  const diff = Math.abs(documented - actual);
+  issues.push(`source-map drift (${documented}→${actual})`);
+  if (diff > 3) { if (severity === 'ok') severity = 'danger'; }
+  else { if (severity === 'ok') severity = 'warn'; }
+}
+if (genomeStaleWarning && commitsSince > 30) {
+  issues.push(`severely stale (${commitsSince} commits)`);
+  if (severity !== 'danger') severity = 'danger';
+} else if (genomeStaleWarning) {
+  issues.push(`stale (${commitsSince} commits)`);
+  if (severity === 'ok') severity = 'warn';
+}
+
+if (severity === 'ok') initLines.push(`🟢 Genome — loaded (${l1Lines} lines), synced`);
+else if (severity === 'warn') initLines.push(`🟡 Genome — ${issues.join(', ')}. /reap.sync`);
+else initLines.push(`🔴 Genome — ${issues.join(', ')}. \`reap fix\` or /reap.sync`);
+
+// Generation status
+if (currentContent && currentContent.trim()) {
+  if (!genId || genStage === 'none') {
+    initLines.push('🔴 Generation — current.yml corrupted. `reap fix`');
+  } else {
+    initLines.push(`🟢 Generation ${genId} — ${genStage}`);
+  }
+} else {
+  initLines.push('⚪ No active Generation');
+}
+
+const initSummary = `**REAP Session Initialized**\n${initLines.join('\n')}`;
+
+// Step 6: Output JSON
+log('Done. Injecting context.');
+
+const reapContext = `<REAP_WORKFLOW>\n${reapGuide}\n\n---\n\n## Genome (Project Knowledge — treat as authoritative source of truth)\n${genomeContent}\n\n---\n\n## Current State\n${generationContext}${staleSection}${strictSection}${updateSection}\n\n## Session Init\n${initSummary}\nWhen the user sends their first message, start your response with this init summary exactly as-is. Do not add greetings, explanations, or command suggestions — just the summary, then respond to the user's message.\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 \`${nextCmd}\` 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>`;
+
+process.stdout.write(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: 'SessionStart',
+    additionalContext: reapContext
+  }
+}) + '\n');

package/dist/templates/presets/bun-hono-react/source-map.md

@@ -0,0 +1,22 @@
+# Source Map
+
+> C4 Container + Component level project structure map.
+> Agents reference this before exploring code to quickly identify entry points.
+> Line limit: ~150 lines (adaptive to codebase size).
+> Modified only during the Completion stage.
+
+## C4 Context
+
+(Describe the system context: users, external systems, and relationships)
+
+## C4 Container
+
+(Describe containers: applications, data stores, and their interactions)
+
+## Core Components
+
+(Describe key components within each container)
+
+## Data Flow
+
+(Describe how data flows through the system)

package/package.json

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