@c-d-cc/reap 0.2.1 → 0.3.0

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.1",
+  "version": "0.3.0",
   "description": "Recursive Evolutionary Autonomous Pipeline — AI and humans evolve software across generations",
   "type": "module",
   "license": "MIT",

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

@@ -1,200 +0,0 @@
-#!/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
-
-# Timing (node is guaranteed since REAP is an npm package)
-_reap_ms() { node -e 'process.stdout.write(String(Date.now()))'; }
-_reap_start_time=$(_reap_ms)
-_reap_log() {
-  local now=$(_reap_ms)
-  local elapsed=$(( now - _reap_start_time ))
-  echo "[REAP hook +${elapsed}ms] $1" >&2
-}
-
-# 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"
-
-_reap_log "Starting..."
-
-# Check if this is a REAP project
-if [ ! -d "$REAP_DIR" ]; then
-  _reap_log "Not a REAP project, exiting"
-  exit 0
-fi
-
-_reap_log "REAP project detected"
-
-_reap_log "Checking auto-update..."
-CONFIG_FILE="${REAP_DIR}/config.yml"
-auto_update_message=""
-if [ -f "$CONFIG_FILE" ]; then
-  auto_update=$(grep "^autoUpdate:" "$CONFIG_FILE" 2>/dev/null | sed 's/^autoUpdate: *//' | tr -d ' ' || true)
-  if [ "$auto_update" = "true" ]; then
-    installed=$(reap --version 2>/dev/null || echo "")
-    latest=$(npm view @c-d-cc/reap version 2>/dev/null || echo "")
-    if [ -n "$installed" ] && [ -n "$latest" ] && [ "$installed" != "$latest" ]; then
-      if npm update -g @c-d-cc/reap >/dev/null 2>&1; then
-        reap update >/dev/null 2>&1 || true
-        auto_update_message="REAP auto-updated: v${installed} → v${latest}"
-      fi
-    fi
-  fi
-fi
-
-_reap_log "Auto-update check done"
-
-# Read REAP guide
-_reap_log "Loading REAP guide..."
-reap_guide=""
-if [ -f "$GUIDE_FILE" ]; then
-  reap_guide=$(cat "$GUIDE_FILE")
-fi
-
-_reap_log "Loading Genome..."
-# 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() {
-  printf '%s' "$1" | node -e 'let d="";process.stdin.on("data",c=>d+=c);process.stdin.on("end",()=>process.stdout.write(JSON.stringify(d).slice(1,-1)))'
-}
-
-# 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
-
-# Build auto-update section
-update_section=""
-if [ -n "$auto_update_message" ]; then
-  update_section="\n\n## Auto-Update\n${auto_update_message}. Tell the user: \"${auto_update_message}\""
-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}${update_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>"
-
-_reap_log "Building context..."
-escaped_context=$(escape_for_json "$reap_context")
-_reap_log "Done. Outputting JSON."
-
-cat <<EOF
-{
-  "hookSpecificOutput": {
-    "hookEventName": "SessionStart",
-    "additionalContext": "${escaped_context}"
-  }
-}
-EOF
-
-exit 0