@c-d-cc/reap 0.3.2 → 0.3.5

package/dist/cli.js

@@ -10147,7 +10147,7 @@ async function fixProject(projectRoot) {
 
 // src/cli/index.ts
 import { join as join8 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.3.2");
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.3.5");
 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.status.md

@@ -47,7 +47,7 @@ Display a comprehensive overview of the current REAP project state.
 ### 6. Genome Health
 - Quick check of `.reap/genome/` files:
   - Any files that are still placeholder-only?
-  - Any files exceeding 100 lines?
+  - Any files exceeding their line limit? (default: ~100 lines. For source-map.md, read the file's own header to find its adaptive line limit.)
   - Is `domain/` empty (no rule files)?
 
 ## Output Format

package/dist/templates/hooks/genome-loader.cjs

@@ -0,0 +1,214 @@
+// REAP Genome Loader — shared logic for session-start hooks
+// Used by session-start.cjs (Claude Code) and opencode-session-start.js (OpenCode)
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const L1_LIMIT = 500;
+const L2_LIMIT = 200;
+const L1_FILES = ['principles.md', 'conventions.md', 'constraints.md', 'source-map.md'];
+const STAGE_COMMANDS = {
+  objective: '/reap.objective',
+  planning: '/reap.planning',
+  implementation: '/reap.implementation',
+  validation: '/reap.validation',
+  completion: '/reap.completion',
+};
+
+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, opts) {
+  try { return execSync(cmd, { encoding: 'utf-8', timeout: 10000, ...opts }).trim(); } catch { return ''; }
+}
+
+/**
+ * Load Genome content (L1 core files + L2 domain files) with line budget.
+ * @param {string} genomeDir - path to .reap/genome/
+ * @returns {{ content: string, l1Lines: number }}
+ */
+function loadGenome(genomeDir) {
+  let content = '';
+  let l1Lines = 0;
+
+  // Check source-map.md header for custom line limit
+  const smPath = path.join(genomeDir, 'source-map.md');
+  let smLimit = null;
+  const smContent = readFile(smPath);
+  if (smContent) {
+    const limitMatch = smContent.match(/줄 수 한도:\s*~?(\d+)줄/);
+    if (limitMatch) smLimit = parseInt(limitMatch[1], 10);
+  }
+
+  for (const file of L1_FILES) {
+    const fileContent = readFile(path.join(genomeDir, file));
+    if (!fileContent) continue;
+    const lines = fileContent.split('\n').length;
+    const limit = (file === 'source-map.md' && smLimit) ? smLimit : L1_LIMIT;
+    l1Lines += lines;
+    if (l1Lines <= limit) {
+      content += `\n### ${file}\n${fileContent}\n`;
+    } else {
+      content += `\n### ${file} [TRUNCATED — L1 budget exceeded, read full file directly]\n${fileContent.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 fileContent = readFile(path.join(domainDir, file));
+      if (!fileContent) continue;
+      const lines = fileContent.split('\n').length;
+      l2Lines += lines;
+      if (!l2Overflow && l2Lines <= L2_LIMIT) {
+        content += `\n### domain/${file}\n${fileContent}\n`;
+      } else {
+        l2Overflow = true;
+        const firstLine = fileContent.split('\n').find(l => l.startsWith('>')) || fileContent.split('\n')[0];
+        content += `\n### domain/${file} [summary — read full file for details]\n${firstLine}\n`;
+      }
+    }
+  }
+
+  return { content, l1Lines };
+}
+
+/**
+ * Parse config.yml for strict mode and other settings.
+ * @param {string} configFile - path to .reap/config.yml
+ * @returns {{ strictMode: boolean, language: string, configContent: string|null }}
+ */
+function parseConfig(configFile) {
+  const configContent = readFile(configFile);
+  let strictMode = false;
+  let language = '';
+  if (configContent) {
+    strictMode = /^strict:\s*true/m.test(configContent);
+    const langMatch = configContent.match(/^language:\s*(.+)$/m);
+    if (langMatch) language = langMatch[1].trim();
+  }
+  return { strictMode, language, configContent };
+}
+
+/**
+ * Parse current.yml for generation state.
+ * @param {string} currentYml - path to .reap/life/current.yml
+ * @returns {{ genStage: string, genId: string, genGoal: string, generationContext: string, nextCmd: string }}
+ */
+function parseCurrentYml(currentYml) {
+  let genStage = 'none', genId = '', genGoal = '', generationContext = '';
+  const content = readFile(currentYml);
+  if (content && content.trim()) {
+    genId = (content.match(/^id:\s*(.+)/m) || [])[1] || '';
+    genGoal = (content.match(/^goal:\s*(.+)/m) || [])[1] || '';
+    genStage = (content.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 nextCmd = STAGE_COMMANDS[genStage] || '/reap.start';
+  return { genStage, genId, genGoal, generationContext, nextCmd };
+}
+
+/**
+ * Detect Genome staleness.
+ * @param {string} projectRoot
+ * @returns {{ genomeStaleWarning: string, commitsSince: number }}
+ */
+function detectStaleness(projectRoot) {
+  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.`;
+      }
+    }
+  }
+
+  return { genomeStaleWarning, commitsSince };
+}
+
+/**
+ * Build strict mode section for context injection.
+ * @param {boolean} strictMode
+ * @param {string} genStage
+ * @returns {string}
+ */
+function buildStrictSection(strictMode, genStage) {
+  if (!strictMode) return '';
+  if (genStage === 'implementation') {
+    return "\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>";
+  }
+  if (genStage === 'none') {
+    return "\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>";
+  }
+  return `\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 Genome health status for session init display.
+ * @param {object} params
+ * @returns {{ initLines: string[], severity: string }}
+ */
+function buildGenomeHealth({ l1Lines, genomeDir, configFile, genomeStaleWarning, commitsSince }) {
+  const issues = [];
+  let severity = 'ok';
+  if (l1Lines === 0) { issues.push('empty'); severity = 'danger'; }
+  for (const f of [...L1_FILES, '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 (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';
+  }
+
+  const initLines = [];
+  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`);
+
+  return { initLines, severity };
+}
+
+module.exports = {
+  L1_LIMIT,
+  L2_LIMIT,
+  L1_FILES,
+  STAGE_COMMANDS,
+  readFile,
+  fileExists,
+  dirExists,
+  exec,
+  loadGenome,
+  parseConfig,
+  parseCurrentYml,
+  detectStaleness,
+  buildStrictSection,
+  buildGenomeHealth,
+};

package/dist/templates/hooks/opencode-session-start.js

@@ -1,7 +1,6 @@
 // REAP SessionStart plugin for OpenCode
 // Injects REAP guide + Genome + current generation context into every OpenCode session
 // Installed to ~/.config/opencode/plugins/reap-session-start.js
-
 const { execSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
@@ -15,22 +14,41 @@ module.exports = async (ctx) => {
       // Check if this is a REAP project
       if (!fs.existsSync(reapDir)) return;
 
+      // Load shared genome-loader (try multiple locations)
+      let gl;
+      const loaderLocations = [
+        path.join(__dirname, "genome-loader.cjs"),
+        path.join(__dirname, "..", "hooks", "genome-loader.cjs"),
+      ];
+      for (const loc of loaderLocations) {
+        if (fs.existsSync(loc)) {
+          gl = require(loc);
+          break;
+        }
+      }
+      if (!gl) {
+        try {
+          const pkgPath = require.resolve("@c-d-cc/reap/package.json");
+          const pkgLoader = path.join(pkgPath, "..", "dist", "templates", "hooks", "genome-loader.cjs");
+          if (fs.existsSync(pkgLoader)) gl = require(pkgLoader);
+        } catch { /* package not found */ }
+      }
+      if (!gl) return; // Cannot load shared module, skip
+
       // Auto-update check (with PATH resolution for non-shell environments)
       let autoUpdateMessage = "";
       try {
-        const autoConfigPath = path.join(reapDir, "config.yml");
-        if (fs.existsSync(autoConfigPath)) {
-          const configRaw = fs.readFileSync(autoConfigPath, "utf8");
-          const autoUpdateMatch = configRaw.match(/^autoUpdate:\s*(.+)$/m);
-          if (autoUpdateMatch && autoUpdateMatch[1].trim() === "true") {
+        const configPath = path.join(reapDir, "config.yml");
+        if (fs.existsSync(configPath)) {
+          const { configContent } = gl.parseConfig(configPath);
+          if (configContent && /^autoUpdate:\s*true/m.test(configContent)) {
             try {
-              // Resolve PATH: OpenCode plugin runs in Node.js context which may lack shell PATH
               const userShell = process.env.SHELL || "/bin/bash";
               const shellPath = execSync(`${userShell} -l -c 'echo $PATH' 2>/dev/null`, { encoding: "utf8" }).trim();
               const execOpts = { encoding: "utf8", env: { ...process.env, PATH: shellPath || process.env.PATH } };
 
-              const installed = execSync("reap --version 2>/dev/null", execOpts).trim();
-              const latest = execSync("npm view @c-d-cc/reap version 2>/dev/null", execOpts).trim();
+              const installed = gl.exec("reap --version 2>/dev/null", execOpts);
+              const latest = gl.exec("npm view @c-d-cc/reap version 2>/dev/null", execOpts);
               if (installed && latest && installed !== latest) {
                 execSync("npm update -g @c-d-cc/reap >/dev/null 2>&1", { ...execOpts, stdio: "ignore" });
                 execSync("reap update >/dev/null 2>&1", { ...execOpts, stdio: "ignore" });
@@ -41,14 +59,12 @@ module.exports = async (ctx) => {
         }
       } catch { /* config read failed, skip */ }
 
+      // Load REAP guide
       const scriptDir = __dirname;
-      // Look for reap-guide.md relative to the package hooks dir
-      // The guide is installed alongside this plugin's source package
       const guideLocations = [
         path.join(scriptDir, "..", "hooks", "reap-guide.md"),
         path.join(scriptDir, "reap-guide.md"),
       ];
-
       let reapGuide = "";
       for (const loc of guideLocations) {
         if (fs.existsSync(loc)) {
@@ -56,134 +72,33 @@ module.exports = async (ctx) => {
           break;
         }
       }
-
-      // If guide not found from package, try to get it via the reap CLI
       if (!reapGuide) {
         try {
-          // Find the package hooks dir by looking up from the plugin location
-          const possiblePaths = [
-            path.join(require.resolve("@c-d-cc/reap/package.json"), "..", "dist", "templates", "hooks", "reap-guide.md"),
-          ];
-          for (const p of possiblePaths) {
-            if (fs.existsSync(p)) {
-              reapGuide = fs.readFileSync(p, "utf8");
-              break;
-            }
-          }
+          const pkgPath = require.resolve("@c-d-cc/reap/package.json");
+          const guidePath = path.join(pkgPath, "..", "dist", "templates", "hooks", "reap-guide.md");
+          if (fs.existsSync(guidePath)) reapGuide = fs.readFileSync(guidePath, "utf8");
         } catch { /* package not found */ }
       }
 
-      // Read Genome files
+      // Load Genome via shared module
       const genomeDir = path.join(reapDir, "genome");
-      let genomeContent = "";
-      const L1_LIMIT = 500;
-      const L2_LIMIT = 200;
-      let l1Lines = 0;
+      const { content: genomeContent } = gl.loadGenome(genomeDir);
 
-      if (fs.existsSync(genomeDir)) {
-        for (const file of ["principles.md", "conventions.md", "constraints.md"]) {
-          const filePath = path.join(genomeDir, file);
-          if (fs.existsSync(filePath)) {
-            const content = fs.readFileSync(filePath, "utf8");
-            const lines = content.split("\n").length;
-            l1Lines += lines;
-            if (l1Lines <= L1_LIMIT) {
-              genomeContent += `\n### ${file}\n${content}\n`;
-            } else {
-              genomeContent += `\n### ${file} [TRUNCATED]\n${content.split("\n").slice(0, 20).join("\n")}\n...\n`;
-            }
-          }
-        }
+      // Parse config and generation state via shared module
+      const configFile = path.join(reapDir, "config.yml");
+      const currentYml = path.join(reapDir, "life", "current.yml");
+      const { strictMode, language } = gl.parseConfig(configFile);
+      const { genStage, generationContext, nextCmd } = gl.parseCurrentYml(currentYml);
 
-        // L2: domain/ files
-        const domainDir = path.join(genomeDir, "domain");
-        if (fs.existsSync(domainDir)) {
-          let l2Lines = 0;
-          let l2Overflow = false;
-          const domainFiles = fs.readdirSync(domainDir).filter(f => f.endsWith(".md"));
-          for (const file of domainFiles) {
-            const filePath = path.join(domainDir, file);
-            const content = fs.readFileSync(filePath, "utf8");
-            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]\n${firstLine}\n`;
-            }
-          }
-        }
-      }
+      // Build strict mode section via shared module
+      const strictSection = gl.buildStrictSection(strictMode, genStage);
 
-      // Read config (strict mode + language)
-      let strictMode = false;
-      let language = "";
-      const configPath = path.join(reapDir, "config.yml");
-      if (fs.existsSync(configPath)) {
-        const configContent = fs.readFileSync(configPath, "utf8");
-        const strictMatch = configContent.match(/^strict:\s*(.+)$/m);
-        if (strictMatch && strictMatch[1].trim() === "true") {
-          strictMode = true;
-        }
-        const langMatch = configContent.match(/^language:\s*(.+)$/m);
-        if (langMatch) {
-          language = langMatch[1].trim();
-        }
-      }
-
-      // Read current.yml
-      const currentPath = path.join(reapDir, "life", "current.yml");
-      let genStage = "none";
-      let generationContext = "No active Generation. Run `/reap.start` to start one.";
-
-      if (fs.existsSync(currentPath)) {
-        const content = fs.readFileSync(currentPath, "utf8").trim();
-        if (content) {
-          const idMatch = content.match(/^id:\s*(.+)$/m);
-          const goalMatch = content.match(/^goal:\s*(.+)$/m);
-          const stageMatch = content.match(/^stage:\s*(.+)$/m);
-          if (idMatch && goalMatch && stageMatch) {
-            genStage = stageMatch[1].trim();
-            generationContext = `Active Generation: ${idMatch[1].trim()} | Goal: ${goalMatch[1].trim()} | Stage: ${genStage}`;
-          }
-        }
-      }
-
-      // Map stage to command
-      const stageCommandMap = {
-        objective: "/reap.objective",
-        planning: "/reap.planning",
-        implementation: "/reap.implementation",
-        validation: "/reap.validation",
-        completion: "/reap.completion",
-      };
-      const nextCmd = stageCommandMap[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.\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.\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.\n</HARD-GATE>`;
-        }
-      }
-
-      // Detect genome staleness
+      // Detect staleness via shared module
       let staleSection = "";
-      try {
-        const lastCommit = execSync(`git -C "${projectRoot}" log -1 --format="%H" -- ".reap/genome/" 2>/dev/null`, { encoding: "utf8" }).trim();
-        if (lastCommit) {
-          const commitsSince = parseInt(execSync(`git -C "${projectRoot}" rev-list --count "${lastCommit}..HEAD" 2>/dev/null`, { encoding: "utf8" }).trim(), 10);
-          if (commitsSince > 10) {
-            staleSection = `\n\n## Genome Staleness\nWARNING: Genome may be stale — ${commitsSince} commits since last Genome update. Consider running /reap.sync.`;
-          }
-        }
-      } catch { /* git not available or not a repo */ }
+      const staleness = gl.detectStaleness(projectRoot);
+      if (staleness.genomeStaleWarning) {
+        staleSection = `\n\n## Genome Staleness\n${staleness.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.`;
+      }
 
       // Build language instruction
       let langSection = "";
@@ -199,7 +114,6 @@ module.exports = async (ctx) => {
 
       const context = `<REAP_WORKFLOW>\n${reapGuide}\n\n---\n\n## Genome (Project Knowledge)\n${genomeContent}\n\n---\n\n## Current State\n${generationContext}${staleSection}${strictSection}${updateSection}${langSection}\n\n## Rules\n1. ALL development work MUST follow the REAP lifecycle.\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 outside of the REAP lifecycle unless explicitly asked.\n6. Genome is the authoritative knowledge source.\n</REAP_WORKFLOW>`;
 
-      // Inject context into session via return value
       return { systemPrompt: context };
     },
   };

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

@@ -1,9 +1,8 @@
 #!/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 gl = require('./genome-loader.cjs');
 
 const startTime = Date.now();
 let step = 0;
@@ -14,22 +13,6 @@ function log(msg) {
   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();
@@ -40,7 +23,7 @@ const currentYml = path.join(reapDir, 'life', 'current.yml');
 const guideFile = path.join(scriptDir, 'reap-guide.md');
 
 // Check REAP project
-if (!dirExists(reapDir)) {
+if (!gl.dirExists(reapDir)) {
   process.stderr.write('[REAP] Not a REAP project, skipping\n');
   process.exit(0);
 }
@@ -49,15 +32,15 @@ if (!dirExists(reapDir)) {
 log('Checking for updates...');
 let autoUpdateMessage = '';
 let updateAvailableMessage = '';
-const configContent = readFile(configFile);
-const installed = exec('reap --version');
-const latest = exec('npm view @c-d-cc/reap version');
+const { configContent } = gl.parseConfig(configFile);
+const installed = gl.exec('reap --version');
+const latest = gl.exec('npm view @c-d-cc/reap version');
 if (installed && latest && installed !== latest) {
   const autoUpdate = configContent ? /^autoUpdate:\s*true/m.test(configContent) : false;
   if (autoUpdate) {
-    const updated = exec('npm update -g @c-d-cc/reap');
+    const updated = gl.exec('npm update -g @c-d-cc/reap');
     if (updated !== null) {
-      exec('reap update');
+      gl.exec('reap update');
       autoUpdateMessage = `REAP auto-updated: v${installed} → v${latest}`;
     }
   } else {
@@ -67,121 +50,29 @@ if (installed && latest && installed !== latest) {
 
 // Step 2: Load REAP guide
 log('Loading REAP guide...');
-const reapGuide = readFile(guideFile) || '';
+const reapGuide = gl.readFile(guideFile) || '';
 
 // Step 3: Load Genome (tiered)
 log('Loading Genome...');
-const L1_LIMIT = 500;
-const L2_LIMIT = 200;
-let genomeContent = '';
-let l1Lines = 0;
+const { content: genomeContent, l1Lines } = gl.loadGenome(genomeDir);
 
-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
+// Step 4: Check Genome staleness
 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.`;
-  }
-}
+const { genomeStaleWarning, commitsSince } = gl.detectStaleness(projectRoot);
 
 // 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';
+const { strictMode } = gl.parseConfig(configFile);
+const { genStage, genId, generationContext, nextCmd } = gl.parseCurrentYml(currentYml);
 
 // 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>`;
-  }
-}
+const strictSection = gl.buildStrictSection(strictMode, genStage);
 
 // 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 = '';
@@ -189,38 +80,16 @@ if (autoUpdateMessage) {
   updateSection = `\n\n## Auto-Update\n${autoUpdateMessage}. Tell the user: "${autoUpdateMessage}"`;
 }
 
-// Write session init log
+// Build session init display
 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`);
+// Genome health
+const health = gl.buildGenomeHealth({ l1Lines, genomeDir, configFile, genomeStaleWarning, commitsSince });
+initLines.push(...health.initLines);
 
 // Generation status
+const currentContent = gl.readFile(currentYml);
 if (currentContent && currentContent.trim()) {
   if (!genId || genStage === 'none') {
     initLines.push('🔴 Generation — current.yml corrupted. `reap fix`');
@@ -235,8 +104,8 @@ const initSummary = initLines.join('\n');
 
 // Load session-init format template and render
 const initFormatFile = path.join(scriptDir, 'session-init-format.md');
-const initFormat = readFile(initFormatFile) || '{{SESSION_INIT_LINES}}';
-const currentVersion = installed || exec('reap --version') || '?';
+const initFormat = gl.readFile(initFormatFile) || '{{SESSION_INIT_LINES}}';
+const currentVersion = installed || gl.exec('reap --version') || '?';
 const updateBadge = updateAvailableMessage ? ` — ${updateAvailableMessage}` : '';
 const sessionInitDisplay = initFormat
   .replace('{{VERSION}}', currentVersion)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c-d-cc/reap",
-  "version": "0.3.2",
+  "version": "0.3.5",
   "description": "Recursive Evolutionary Autonomous Pipeline — AI and humans evolve software across generations",
   "type": "module",
   "license": "MIT",
@@ -23,7 +23,8 @@
     "reap": "dist/cli.js"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "scripts/postinstall.cjs"
   ],
   "engines": {
     "node": ">=18"
@@ -31,6 +32,7 @@
   "scripts": {
     "dev": "bun run src/cli/index.ts",
     "build": "node scripts/build.js",
+    "postinstall": "node scripts/postinstall.cjs",
     "prepublishOnly": "npm run build",
     "test": "bun test"
   },

package/scripts/postinstall.cjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * postinstall — install REAP slash commands to detected AI agents.
+ * Runs after `npm install -g @c-d-cc/reap`.
+ * Graceful: never fails npm install (always exits 0).
+ */
+const { execSync } = require("child_process");
+const { readdirSync, readFileSync, writeFileSync, mkdirSync, existsSync } = require("fs");
+const { join, dirname } = require("path");
+const { homedir } = require("os");
+
+const AGENTS = [
+  { name: "Claude Code", bin: "claude", commandsDir: join(homedir(), ".claude", "commands") },
+  { name: "OpenCode", bin: "opencode", commandsDir: join(homedir(), ".config", "opencode", "commands") },
+];
+
+function isInstalled(bin) {
+  try {
+    execSync(`which ${bin}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+try {
+  // Resolve commands source: dist/templates/commands/ relative to this script
+  const commandsSource = join(dirname(__dirname), "dist", "templates", "commands");
+  if (!existsSync(commandsSource)) {
+    // During development or if dist not built yet, skip silently
+    process.exit(0);
+  }
+
+  const commandFiles = readdirSync(commandsSource).filter(f => f.endsWith(".md"));
+  if (commandFiles.length === 0) process.exit(0);
+
+  let installed = 0;
+  for (const agent of AGENTS) {
+    if (!isInstalled(agent.bin)) continue;
+
+    mkdirSync(agent.commandsDir, { recursive: true });
+    for (const file of commandFiles) {
+      const src = readFileSync(join(commandsSource, file), "utf-8");
+      writeFileSync(join(agent.commandsDir, file), src);
+    }
+    installed++;
+    console.log(`  reap: ${agent.name} — ${commandFiles.length} slash commands installed`);
+  }
+
+  if (installed === 0) {
+    console.log("  reap: no supported AI agents detected (claude, opencode). Run 'reap update' after installing one.");
+  }
+} catch (err) {
+  // Graceful failure — never break npm install
+  console.warn("  reap: postinstall warning —", err.message);
+}