@c-d-cc/reap 0.7.0 → 0.7.1

package/dist/cli.js

@@ -31,6 +31,20 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/commander/lib/error.js
@@ -8823,6 +8837,311 @@ var require_dist = __commonJS((exports) => {
   exports.visitAsync = visit.visitAsync;
 });
 
+// src/core/fs.ts
+var exports_fs = {};
+__export(exports_fs, {
+  writeTextFile: () => writeTextFile,
+  readTextFileOrThrow: () => readTextFileOrThrow,
+  readTextFile: () => readTextFile,
+  fileExists: () => fileExists
+});
+import { readFile, writeFile, access } from "fs/promises";
+async function readTextFile(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function readTextFileOrThrow(path) {
+  return await readFile(path, "utf-8");
+}
+async function writeTextFile(path, content) {
+  await writeFile(path, content, "utf-8");
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_fs = () => {};
+
+// src/core/genome-sync.ts
+var exports_genome_sync = {};
+__export(exports_genome_sync, {
+  syncGenomeFromProject: () => syncGenomeFromProject
+});
+import { join as join4 } from "path";
+import { readdir as readdir3, stat as stat2 } from "fs/promises";
+async function scanProject(projectRoot) {
+  const scan = {
+    language: "Unknown",
+    runtime: "Unknown",
+    framework: "None",
+    packageManager: "Unknown",
+    testFramework: "None",
+    linter: "None",
+    formatter: "None",
+    buildTool: "None",
+    scripts: {},
+    dependencies: [],
+    devDependencies: [],
+    hasTypeScript: false,
+    hasDocker: false,
+    directories: [],
+    existingDocs: []
+  };
+  const pkgContent = await readTextFile(join4(projectRoot, "package.json"));
+  if (pkgContent) {
+    try {
+      const pkg = JSON.parse(pkgContent);
+      scan.dependencies = Object.keys(pkg.dependencies ?? {});
+      scan.devDependencies = Object.keys(pkg.devDependencies ?? {});
+      scan.scripts = pkg.scripts ?? {};
+      scan.packageManager = pkg.packageManager?.startsWith("bun") ? "Bun" : pkg.packageManager?.startsWith("pnpm") ? "pnpm" : pkg.packageManager?.startsWith("yarn") ? "Yarn" : "npm";
+      scan.language = "JavaScript";
+      scan.runtime = "Node.js";
+      const allDeps = [...scan.dependencies, ...scan.devDependencies];
+      if (allDeps.includes("next"))
+        scan.framework = "Next.js";
+      else if (allDeps.includes("nuxt"))
+        scan.framework = "Nuxt";
+      else if (allDeps.includes("react"))
+        scan.framework = "React";
+      else if (allDeps.includes("vue"))
+        scan.framework = "Vue";
+      else if (allDeps.includes("svelte") || allDeps.includes("@sveltejs/kit"))
+        scan.framework = "Svelte/SvelteKit";
+      else if (allDeps.includes("express"))
+        scan.framework = "Express";
+      else if (allDeps.includes("hono"))
+        scan.framework = "Hono";
+      else if (allDeps.includes("fastify"))
+        scan.framework = "Fastify";
+      else if (allDeps.includes("nestjs") || allDeps.includes("@nestjs/core"))
+        scan.framework = "NestJS";
+      else if (allDeps.includes("astro"))
+        scan.framework = "Astro";
+      if (allDeps.includes("vitest"))
+        scan.testFramework = "Vitest";
+      else if (allDeps.includes("jest"))
+        scan.testFramework = "Jest";
+      else if (allDeps.includes("mocha"))
+        scan.testFramework = "Mocha";
+      else if (scan.scripts.test?.includes("bun test"))
+        scan.testFramework = "Bun Test";
+      if (allDeps.includes("eslint"))
+        scan.linter = "ESLint";
+      else if (allDeps.includes("biome") || allDeps.includes("@biomejs/biome"))
+        scan.linter = "Biome";
+      if (allDeps.includes("prettier"))
+        scan.formatter = "Prettier";
+      else if (allDeps.includes("biome") || allDeps.includes("@biomejs/biome"))
+        scan.formatter = "Biome";
+      if (allDeps.includes("vite"))
+        scan.buildTool = "Vite";
+      else if (allDeps.includes("webpack"))
+        scan.buildTool = "Webpack";
+      else if (allDeps.includes("esbuild"))
+        scan.buildTool = "esbuild";
+      else if (allDeps.includes("rollup"))
+        scan.buildTool = "Rollup";
+      else if (allDeps.includes("turbo") || allDeps.includes("turbopack"))
+        scan.buildTool = "Turbopack";
+    } catch {}
+  }
+  if (await fileExists(join4(projectRoot, "go.mod"))) {
+    scan.language = "Go";
+    scan.runtime = "Go";
+    scan.packageManager = "Go Modules";
+  }
+  if (await fileExists(join4(projectRoot, "pyproject.toml")) || await fileExists(join4(projectRoot, "requirements.txt"))) {
+    scan.language = "Python";
+    scan.runtime = "Python";
+    if (await fileExists(join4(projectRoot, "pyproject.toml"))) {
+      const pyproject = await readTextFile(join4(projectRoot, "pyproject.toml"));
+      if (pyproject?.includes("[tool.poetry]"))
+        scan.packageManager = "Poetry";
+      else if (pyproject?.includes("[tool.uv]") || pyproject?.includes("[project]"))
+        scan.packageManager = "uv/pip";
+      if (pyproject?.includes("pytest"))
+        scan.testFramework = "pytest";
+      if (pyproject?.includes("django"))
+        scan.framework = "Django";
+      else if (pyproject?.includes("fastapi"))
+        scan.framework = "FastAPI";
+      else if (pyproject?.includes("flask"))
+        scan.framework = "Flask";
+    }
+  }
+  if (await fileExists(join4(projectRoot, "Cargo.toml"))) {
+    scan.language = "Rust";
+    scan.runtime = "Rust";
+    scan.packageManager = "Cargo";
+  }
+  if (await fileExists(join4(projectRoot, "tsconfig.json"))) {
+    scan.hasTypeScript = true;
+    scan.language = "TypeScript";
+  }
+  scan.hasDocker = await fileExists(join4(projectRoot, "Dockerfile")) || await fileExists(join4(projectRoot, "docker-compose.yml"));
+  try {
+    const entries = await readdir3(projectRoot);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules")
+        continue;
+      try {
+        const s = await stat2(join4(projectRoot, entry));
+        if (s.isDirectory())
+          scan.directories.push(entry);
+      } catch {}
+    }
+  } catch {}
+  const docFiles = ["README.md", "CLAUDE.md", "AGENTS.md", "CONTRIBUTING.md", "ARCHITECTURE.md"];
+  for (const file of docFiles) {
+    const content = await readTextFile(join4(projectRoot, file));
+    if (content) {
+      scan.existingDocs.push({ file, content: content.substring(0, 2000) });
+    }
+  }
+  return scan;
+}
+function generateConstraints(scan) {
+  const lines = [
+    "# Technical Constraints",
+    "",
+    "> Auto-generated by `reap init` from project scan. Refine during the first Generation's Objective stage.",
+    "",
+    "## Tech Stack",
+    "",
+    `- **Language**: ${scan.language}${scan.hasTypeScript ? " (TypeScript)" : ""}`,
+    `- **Runtime**: ${scan.runtime}`
+  ];
+  if (scan.framework !== "None")
+    lines.push(`- **Framework**: ${scan.framework}`);
+  if (scan.packageManager !== "Unknown")
+    lines.push(`- **Package Manager**: ${scan.packageManager}`);
+  if (scan.buildTool !== "None")
+    lines.push(`- **Build Tool**: ${scan.buildTool}`);
+  lines.push("", "## Constraints", "");
+  if (scan.hasDocker)
+    lines.push("- Docker containerized deployment");
+  if (scan.hasTypeScript)
+    lines.push("- TypeScript strict mode (check tsconfig.json for details)");
+  lines.push("", "## Validation Commands", "", "| Purpose | Command | Description |", "|---------|---------|-------------|");
+  if (scan.testFramework !== "None") {
+    const testCmd = scan.scripts.test ?? `${scan.testFramework.toLowerCase()} test`;
+    lines.push(`| Test | \`${testCmd}\` | Run tests |`);
+  }
+  if (scan.scripts.lint)
+    lines.push(`| Lint | \`${scan.scripts.lint.includes("npm") ? "npm run lint" : scan.scripts.lint}\` | Lint check |`);
+  else if (scan.scripts.lint)
+    lines.push(`| Lint | \`npm run lint\` | Lint check |`);
+  if (scan.scripts.build)
+    lines.push(`| Build | \`npm run build\` | Build project |`);
+  if (scan.hasTypeScript)
+    lines.push("| Type check | `npx tsc --noEmit` | TypeScript compile check |");
+  lines.push("", "## External Dependencies", "", "- (review and fill in during first generation)");
+  return lines.join(`
+`) + `
+`;
+}
+function generateConventions(scan) {
+  const lines = [
+    "# Development Conventions",
+    "",
+    "> Auto-generated by `reap init` from project scan. Refine during the first Generation's Objective stage.",
+    "",
+    "## Code Style",
+    ""
+  ];
+  if (scan.linter !== "None")
+    lines.push(`- Linter: ${scan.linter}`);
+  if (scan.formatter !== "None")
+    lines.push(`- Formatter: ${scan.formatter}`);
+  if (scan.hasTypeScript)
+    lines.push("- TypeScript strict mode");
+  lines.push("", "## Naming Conventions", "", "- (review and fill in during first generation)");
+  lines.push("", "## Git Conventions", "", "- (review and fill in during first generation)");
+  if (scan.testFramework !== "None") {
+    lines.push("", "## Testing", "", `- Test framework: ${scan.testFramework}`);
+  }
+  lines.push("", "## Enforced Rules", "", "| Rule | Tool | Command |", "|------|------|---------|");
+  if (scan.scripts.test)
+    lines.push(`| Tests pass | ${scan.testFramework} | \`npm test\` |`);
+  if (scan.scripts.lint)
+    lines.push(`| Lint clean | ${scan.linter} | \`npm run lint\` |`);
+  if (scan.scripts.build)
+    lines.push("| Build succeeds | Build | `npm run build` |");
+  if (scan.hasTypeScript)
+    lines.push("| TypeScript compiles | tsc | `npx tsc --noEmit` |");
+  return lines.join(`
+`) + `
+`;
+}
+function generatePrinciples(scan) {
+  const lines = [
+    "# Architecture Principles",
+    "",
+    "> Auto-generated by `reap init` from project scan. Refine during the first Generation's Objective stage.",
+    "",
+    "## Core Beliefs",
+    "",
+    "- (define your project's core architectural beliefs during the first generation)",
+    "",
+    "## Architecture Decisions",
+    "",
+    "| ID | Decision | Rationale | Date |",
+    "|----|----------|-----------|------|"
+  ];
+  if (scan.framework !== "None")
+    lines.push(`| ADR-001 | ${scan.framework} | Detected from project dependencies | Auto |`);
+  if (scan.hasTypeScript)
+    lines.push(`| ADR-002 | TypeScript | Type safety | Auto |`);
+  lines.push("", "## Source Map", "", "→ `genome/source-map.md`");
+  return lines.join(`
+`) + `
+`;
+}
+function generateSourceMap(scan) {
+  const lines = [
+    "# Source Map",
+    "",
+    "> Auto-generated by `reap init` from project scan. Refine during the first Generation's Objective stage.",
+    "",
+    "## Project Structure",
+    "",
+    "```"
+  ];
+  for (const dir of scan.directories.sort()) {
+    lines.push(`${dir}/`);
+  }
+  lines.push("```");
+  return lines.join(`
+`) + `
+`;
+}
+async function syncGenomeFromProject(projectRoot, genomePath, onProgress) {
+  const log = onProgress ?? (() => {});
+  log("Scanning project structure...");
+  const scan = await scanProject(projectRoot);
+  log(`Detected: ${scan.language}, ${scan.framework !== "None" ? scan.framework : "no framework"}, ${scan.packageManager}`);
+  const { writeTextFile: writeTextFile2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
+  log("Generating constraints.md...");
+  await writeTextFile2(join4(genomePath, "constraints.md"), generateConstraints(scan));
+  log("Generating conventions.md...");
+  await writeTextFile2(join4(genomePath, "conventions.md"), generateConventions(scan));
+  log("Generating principles.md...");
+  await writeTextFile2(join4(genomePath, "principles.md"), generatePrinciples(scan));
+  log("Generating source-map.md...");
+  await writeTextFile2(join4(genomePath, "source-map.md"), generateSourceMap(scan));
+}
+var init_genome_sync = __esm(() => {
+  init_fs();
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -8840,8 +9159,8 @@ var {
 } = import__.default;
 
 // src/cli/commands/init.ts
-import { mkdir as mkdir3, readdir as readdir3, chmod } from "fs/promises";
-import { join as join4 } from "path";
+import { mkdir as mkdir3, readdir as readdir4, chmod } from "fs/promises";
+import { join as join5 } from "path";
 
 // src/core/paths.ts
 import { join, dirname } from "path";
@@ -8966,33 +9285,9 @@ class ReapPaths {
 }
 
 // src/core/config.ts
+init_fs();
 var import_yaml = __toESM(require_dist(), 1);
 
-// src/core/fs.ts
-import { readFile, writeFile, access } from "fs/promises";
-async function readTextFile(path) {
-  try {
-    return await readFile(path, "utf-8");
-  } catch {
-    return null;
-  }
-}
-async function readTextFileOrThrow(path) {
-  return await readFile(path, "utf-8");
-}
-async function writeTextFile(path, content) {
-  await writeFile(path, content, "utf-8");
-}
-async function fileExists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/core/config.ts
 class ConfigManager {
   static async read(paths) {
     const content = await readTextFileOrThrow(paths.config);
@@ -9017,6 +9312,7 @@ class ConfigManager {
 }
 
 // src/core/agents/claude-code.ts
+init_fs();
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 import { mkdir, readdir, unlink } from "fs/promises";
@@ -9242,6 +9538,7 @@ Read \`~/.reap/commands/${cmd}.md\` and follow the instructions there.
 }
 
 // src/core/agents/opencode.ts
+init_fs();
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 import { mkdir as mkdir2, readdir as readdir2, unlink as unlink2 } from "fs/promises";
@@ -9441,6 +9738,7 @@ class AgentRegistry {
 }
 
 // src/cli/commands/init.ts
+init_fs();
 var COMMAND_NAMES = [
   "reap.objective",
   "reap.planning",
@@ -9474,8 +9772,8 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
     throw new Error(".reap/ already exists. This is already a REAP project.");
   }
   if (preset) {
-    const presetDir = join4(ReapPaths.packageTemplatesDir, "presets", preset);
-    const presetExists = await fileExists(join4(presetDir, "principles.md"));
+    const presetDir = join5(ReapPaths.packageTemplatesDir, "presets", preset);
+    const presetExists = await fileExists(join5(presetDir, "principles.md"));
     if (!presetExists) {
       throw new Error(`Unknown preset: "${preset}". Available presets: bun-hono-react`);
     }
@@ -9497,54 +9795,59 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   await ConfigManager.write(paths, config);
   log("Setting up Genome templates...");
   const genomeTemplates = ["principles.md", "conventions.md", "constraints.md", "source-map.md"];
-  const genomeSourceDir = preset ? join4(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
+  const genomeSourceDir = preset ? join5(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
   for (const file of genomeTemplates) {
-    const src = join4(genomeSourceDir, file);
-    const dest = join4(paths.genome, file);
+    const src = join5(genomeSourceDir, file);
+    const dest = join5(paths.genome, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
+  if ((entryMode === "adoption" || entryMode === "migration") && !preset) {
+    log("Scanning project for genome auto-sync...");
+    const { syncGenomeFromProject: syncGenomeFromProject2 } = await Promise.resolve().then(() => (init_genome_sync(), exports_genome_sync));
+    await syncGenomeFromProject2(projectRoot, paths.genome, log);
+  }
   log("Installing artifact templates...");
   await mkdir3(ReapPaths.userReapTemplates, { recursive: true });
   const artifactFiles = ["01-objective.md", "02-planning.md", "03-implementation.md", "04-validation.md", "05-completion.md"];
   for (const file of artifactFiles) {
-    const src = join4(ReapPaths.packageArtifactsDir, file);
-    const dest = join4(ReapPaths.userReapTemplates, file);
+    const src = join5(ReapPaths.packageArtifactsDir, file);
+    const dest = join5(ReapPaths.userReapTemplates, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
-  const domainGuideSrc = join4(ReapPaths.packageGenomeDir, "domain/README.md");
-  const domainGuideDest = join4(ReapPaths.userReapTemplates, "domain-guide.md");
+  const domainGuideSrc = join5(ReapPaths.packageGenomeDir, "domain/README.md");
+  const domainGuideDest = join5(ReapPaths.userReapTemplates, "domain-guide.md");
   await writeTextFile(domainGuideDest, await readTextFileOrThrow(domainGuideSrc));
-  const mergeTemplatesDir = join4(ReapPaths.userReapTemplates, "merge");
+  const mergeTemplatesDir = join5(ReapPaths.userReapTemplates, "merge");
   await mkdir3(mergeTemplatesDir, { recursive: true });
   const mergeArtifactFiles = ["01-detect.md", "02-mate.md", "03-merge.md", "04-sync.md", "05-validation.md", "06-completion.md"];
-  const mergeSourceDir = join4(ReapPaths.packageArtifactsDir, "merge");
+  const mergeSourceDir = join5(ReapPaths.packageArtifactsDir, "merge");
   for (const file of mergeArtifactFiles) {
-    const src = join4(mergeSourceDir, file);
-    const dest = join4(mergeTemplatesDir, file);
+    const src = join5(mergeSourceDir, file);
+    const dest = join5(mergeTemplatesDir, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
   log("Installing brainstorm server...");
-  const brainstormSourceDir = join4(ReapPaths.packageTemplatesDir, "brainstorm");
-  const brainstormDestDir = join4(paths.root, "brainstorm");
+  const brainstormSourceDir = join5(ReapPaths.packageTemplatesDir, "brainstorm");
+  const brainstormDestDir = join5(paths.root, "brainstorm");
   await mkdir3(brainstormDestDir, { recursive: true });
   const brainstormFiles = ["server.cjs", "frame.html", "start-server.sh"];
   for (const file of brainstormFiles) {
-    const src = join4(brainstormSourceDir, file);
-    const dest = join4(brainstormDestDir, file);
+    const src = join5(brainstormSourceDir, file);
+    const dest = join5(brainstormDestDir, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
     if (file.endsWith(".sh"))
       await chmod(dest, 493);
   }
   log("Installing hook conditions...");
-  const conditionsSourceDir = join4(ReapPaths.packageTemplatesDir, "conditions");
-  const conditionsDestDir = join4(paths.hooks, "conditions");
+  const conditionsSourceDir = join5(ReapPaths.packageTemplatesDir, "conditions");
+  const conditionsDestDir = join5(paths.hooks, "conditions");
   await mkdir3(conditionsDestDir, { recursive: true });
-  const conditionFiles = await readdir3(conditionsSourceDir);
+  const conditionFiles = await readdir4(conditionsSourceDir);
   for (const file of conditionFiles) {
     if (!file.endsWith(".sh"))
       continue;
-    const src = join4(conditionsSourceDir, file);
-    const dest = join4(conditionsDestDir, file);
+    const src = join5(conditionsSourceDir, file);
+    const dest = join5(conditionsDestDir, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
     await chmod(dest, 493);
   }
@@ -9564,8 +9867,8 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
 }
 
 // src/cli/commands/update.ts
-import { readdir as readdir8, unlink as unlink3, rm as rm2, mkdir as mkdir6, chmod as chmod2 } from "fs/promises";
-import { join as join9 } from "path";
+import { readdir as readdir9, unlink as unlink3, rm as rm2, mkdir as mkdir6, chmod as chmod2 } from "fs/promises";
+import { join as join10 } from "path";
 
 // src/core/hooks.ts
 async function migrateHooks(dryRun = false) {
@@ -9580,17 +9883,21 @@ async function migrateHooks(dryRun = false) {
   return { results };
 }
 
+// src/cli/commands/update.ts
+init_fs();
+
 // src/core/migration.ts
+init_fs();
 var import_yaml5 = __toESM(require_dist(), 1);
-import { readdir as readdir7, rename as rename2 } from "fs/promises";
-import { join as join8 } from "path";
+import { readdir as readdir8, rename as rename2 } from "fs/promises";
+import { join as join9 } from "path";
 
 // src/core/generation.ts
 var import_yaml4 = __toESM(require_dist(), 1);
 import { createHash } from "crypto";
 import { hostname } from "os";
-import { readdir as readdir6, mkdir as mkdir4, rename } from "fs/promises";
-import { join as join7 } from "path";
+import { readdir as readdir7, mkdir as mkdir4, rename } from "fs/promises";
+import { join as join8 } from "path";
 
 // src/types/index.ts
 var LIFECYCLE_ORDER = [
@@ -9644,9 +9951,10 @@ class LifeCycle {
 }
 
 // src/core/compression.ts
+init_fs();
 var import_yaml2 = __toESM(require_dist(), 1);
-import { readdir as readdir4, rm } from "fs/promises";
-import { join as join5 } from "path";
+import { readdir as readdir5, rm } from "fs/promises";
+import { join as join6 } from "path";
 var LINEAGE_MAX_LINES = 5000;
 var MIN_GENERATIONS_FOR_COMPRESSION = 5;
 var LEVEL1_MAX_LINES = 40;
@@ -9683,9 +9991,9 @@ async function countLines(filePath) {
 async function countDirLines(dirPath) {
   let total = 0;
   try {
-    const entries = await readdir4(dirPath, { withFileTypes: true });
+    const entries = await readdir5(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join5(dirPath, entry.name);
+      const fullPath = join6(dirPath, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         total += await countLines(fullPath);
       } else if (entry.isDirectory()) {
@@ -9696,7 +10004,7 @@ async function countDirLines(dirPath) {
   return total;
 }
 async function readDirMeta(dirPath) {
-  const content = await readTextFile(join5(dirPath, "meta.yml"));
+  const content = await readTextFile(join6(dirPath, "meta.yml"));
   if (content === null)
     return null;
   try {
@@ -9714,9 +10022,9 @@ async function readFileMeta(filePath) {
 async function scanLineage(paths) {
   const entries = [];
   try {
-    const items = await readdir4(paths.lineage, { withFileTypes: true });
+    const items = await readdir5(paths.lineage, { withFileTypes: true });
     for (const item of items) {
-      const fullPath = join5(paths.lineage, item.name);
+      const fullPath = join6(paths.lineage, item.name);
       if (item.isDirectory() && item.name.startsWith("gen-")) {
         const genNum = extractGenNum(item.name);
         const lines = await countDirLines(fullPath);
@@ -9770,7 +10078,7 @@ async function findLeafNodes(paths, entries) {
     if (entry.type === "level2")
       continue;
     let meta = null;
-    const fullPath = join5(paths.lineage, entry.name);
+    const fullPath = join6(paths.lineage, entry.name);
     if (entry.type === "dir") {
       meta = await readDirMeta(fullPath);
     } else {
@@ -9801,7 +10109,7 @@ async function compressLevel1(genDir, genName) {
   }
   let goal = "", completionConditions = "";
   {
-    const objective = await readTextFile(join5(genDir, "01-objective.md"));
+    const objective = await readTextFile(join6(genDir, "01-objective.md"));
     if (objective) {
       const goalMatch = objective.match(/## Goal\n([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -9813,7 +10121,7 @@ async function compressLevel1(genDir, genName) {
   }
   let lessons = "", genomeChanges = "", nextBacklog = "";
   {
-    const completion = await readTextFile(join5(genDir, "05-completion.md"));
+    const completion = await readTextFile(join6(genDir, "05-completion.md"));
     if (completion) {
       const lessonsMatch = completion.match(/### Lessons Learned\n([\s\S]*?)(?=\n###)/);
       if (lessonsMatch)
@@ -9828,7 +10136,7 @@ async function compressLevel1(genDir, genName) {
   }
   let summaryText = "";
   {
-    const completion = await readTextFile(join5(genDir, "05-completion.md"));
+    const completion = await readTextFile(join6(genDir, "05-completion.md"));
     if (completion) {
       const summaryMatch = completion.match(/## Summary\n([\s\S]*?)(?=\n##)/);
       if (summaryMatch)
@@ -9837,7 +10145,7 @@ async function compressLevel1(genDir, genName) {
   }
   let validationResult = "";
   {
-    const validation = await readTextFile(join5(genDir, "04-validation.md"));
+    const validation = await readTextFile(join6(genDir, "04-validation.md"));
     if (validation) {
       const resultMatch = validation.match(/## Result: (.+)/);
       if (resultMatch)
@@ -9846,7 +10154,7 @@ async function compressLevel1(genDir, genName) {
   }
   let deferred = "";
   {
-    const impl = await readTextFile(join5(genDir, "03-implementation.md"));
+    const impl = await readTextFile(join6(genDir, "03-implementation.md"));
     if (impl) {
       const deferredMatch = impl.match(/## Deferred Tasks\n([\s\S]*?)(?=\n##)/);
       if (deferredMatch) {
@@ -9970,10 +10278,10 @@ async function compressLineageIfNeeded(paths) {
     const currentTotal = await countDirLines(paths.lineage);
     if (currentTotal <= LINEAGE_MAX_LINES)
       break;
-    const dirPath = join5(paths.lineage, dir.name);
+    const dirPath = join6(paths.lineage, dir.name);
     const compressed = await compressLevel1(dirPath, dir.name);
     const genId = dir.name.match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? dir.name;
-    const outPath = join5(paths.lineage, `${genId}.md`);
+    const outPath = join6(paths.lineage, `${genId}.md`);
     await writeTextFile(outPath, compressed);
     await rm(dirPath, { recursive: true });
     result.level1.push(genId);
@@ -9987,10 +10295,10 @@ async function compressLineageIfNeeded(paths) {
       const batch = level1s.slice(i * LEVEL2_BATCH_SIZE, (i + 1) * LEVEL2_BATCH_SIZE);
       const files = batch.map((e) => ({
         name: e.name,
-        path: join5(paths.lineage, e.name)
+        path: join6(paths.lineage, e.name)
       }));
       const compressed = await compressLevel2(files, epochNum);
-      const outPath = join5(paths.lineage, `epoch-${String(epochNum).padStart(3, "0")}.md`);
+      const outPath = join6(paths.lineage, `epoch-${String(epochNum).padStart(3, "0")}.md`);
       await writeTextFile(outPath, compressed);
       for (const file of files) {
         await rm(file.path);
@@ -10002,20 +10310,24 @@ async function compressLineageIfNeeded(paths) {
   return result;
 }
 
+// src/core/generation.ts
+init_fs();
+
 // src/core/lineage.ts
+init_fs();
 var import_yaml3 = __toESM(require_dist(), 1);
-import { readdir as readdir5 } from "fs/promises";
-import { join as join6 } from "path";
+import { readdir as readdir6 } from "fs/promises";
+import { join as join7 } from "path";
 async function listCompleted(paths) {
   try {
-    const entries = await readdir5(paths.lineage);
+    const entries = await readdir6(paths.lineage);
     return entries.filter((e) => e.startsWith("gen-")).sort();
   } catch {
     return [];
   }
 }
 async function readMeta(paths, lineageDirName) {
-  const metaPath = join6(paths.lineage, lineageDirName, "meta.yml");
+  const metaPath = join7(paths.lineage, lineageDirName, "meta.yml");
   const content = await readTextFile(metaPath);
   if (content === null)
     return null;
@@ -10024,14 +10336,14 @@ async function readMeta(paths, lineageDirName) {
 async function listMeta(paths) {
   const metas = [];
   try {
-    const entries = await readdir5(paths.lineage, { withFileTypes: true });
+    const entries = await readdir6(paths.lineage, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith("gen-")) {
         const meta = await readMeta(paths, entry.name);
         if (meta)
           metas.push(meta);
       } else if (entry.isFile() && entry.name.startsWith("gen-") && entry.name.endsWith(".md")) {
-        const content = await readTextFile(join6(paths.lineage, entry.name));
+        const content = await readTextFile(join7(paths.lineage, entry.name));
         if (content) {
           const meta = parseFrontmatter(content);
           if (meta)
@@ -10085,13 +10397,13 @@ function getMachineId() {
 async function computeGenomeHash(genomePath) {
   const hash = createHash("sha256");
   try {
-    const entries = (await readdir6(genomePath, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).sort((a, b) => {
-      const pathA = join7(e2path(a), a.name);
-      const pathB = join7(e2path(b), b.name);
+    const entries = (await readdir7(genomePath, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).sort((a, b) => {
+      const pathA = join8(e2path(a), a.name);
+      const pathB = join8(e2path(b), b.name);
       return pathA.localeCompare(pathB);
     });
     for (const entry of entries) {
-      const filePath = join7(e2path(entry), entry.name);
+      const filePath = join8(e2path(entry), entry.name);
       const content = await readTextFile(filePath);
       if (content !== null) {
         hash.update(filePath.replace(genomePath, ""));
@@ -10188,28 +10500,28 @@ class GenerationManager {
       startedAt: state.startedAt,
       completedAt: now
     };
-    await writeTextFile(join7(genDir, "meta.yml"), import_yaml4.default.stringify(meta));
-    const lifeEntries = await readdir6(this.paths.life);
+    await writeTextFile(join8(genDir, "meta.yml"), import_yaml4.default.stringify(meta));
+    const lifeEntries = await readdir7(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-        await rename(join7(this.paths.life, entry), join7(genDir, entry));
+        await rename(join8(this.paths.life, entry), join8(genDir, entry));
       }
     }
-    const backlogDir = join7(genDir, "backlog");
+    const backlogDir = join8(genDir, "backlog");
     await mkdir4(backlogDir, { recursive: true });
     try {
-      const backlogEntries = await readdir6(this.paths.backlog);
+      const backlogEntries = await readdir7(this.paths.backlog);
       for (const entry of backlogEntries) {
-        await rename(join7(this.paths.backlog, entry), join7(backlogDir, entry));
+        await rename(join8(this.paths.backlog, entry), join8(backlogDir, entry));
       }
     } catch {}
     try {
-      const mutEntries = await readdir6(this.paths.mutations);
+      const mutEntries = await readdir7(this.paths.mutations);
       if (mutEntries.length > 0) {
-        const mutDir = join7(genDir, "mutations");
+        const mutDir = join8(genDir, "mutations");
         await mkdir4(mutDir, { recursive: true });
         for (const entry of mutEntries) {
-          await rename(join7(this.paths.mutations, entry), join7(mutDir, entry));
+          await rename(join8(this.paths.mutations, entry), join8(mutDir, entry));
         }
       }
     } catch {}
@@ -10245,11 +10557,11 @@ class GenerationManager {
 // src/core/migration.ts
 async function needsMigration(paths) {
   try {
-    const entries = await readdir7(paths.lineage, { withFileTypes: true });
+    const entries = await readdir8(paths.lineage, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || !entry.name.startsWith("gen-"))
         continue;
-      const metaPath = join8(paths.lineage, entry.name, "meta.yml");
+      const metaPath = join9(paths.lineage, entry.name, "meta.yml");
       const content = await readTextFile(metaPath);
       if (content === null)
         return true;
@@ -10263,18 +10575,18 @@ async function migrateLineage(paths) {
   const result = { migrated: [], skipped: [], errors: [] };
   let entries;
   try {
-    const dirEntries = await readdir7(paths.lineage, { withFileTypes: true });
+    const dirEntries = await readdir8(paths.lineage, { withFileTypes: true });
     entries = dirEntries.filter((e) => e.isDirectory() && e.name.startsWith("gen-")).map((e) => e.name).sort();
   } catch {
     return result;
   }
   const plan = [];
   for (const dirName of entries) {
-    const metaPath = join8(paths.lineage, dirName, "meta.yml");
+    const metaPath = join9(paths.lineage, dirName, "meta.yml");
     const metaContent = await readTextFile(metaPath);
     const seq = parseGenSeq(dirName);
     let goal = "";
-    const objContent = await readTextFile(join8(paths.lineage, dirName, "01-objective.md"));
+    const objContent = await readTextFile(join9(paths.lineage, dirName, "01-objective.md"));
     if (objContent) {
       const goalMatch = objContent.match(/## Goal\n+([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -10289,7 +10601,7 @@ async function migrateLineage(paths) {
   let prevId = null;
   for (const entry of plan) {
     if (entry.hasMeta) {
-      const metaContent = await readTextFile(join8(paths.lineage, entry.dirName, "meta.yml"));
+      const metaContent = await readTextFile(join9(paths.lineage, entry.dirName, "meta.yml"));
       if (metaContent) {
         const meta = import_yaml5.default.parse(metaContent);
         prevId = meta.id;
@@ -10310,11 +10622,11 @@ async function migrateLineage(paths) {
         startedAt: `legacy-${entry.seq}`,
         completedAt: `legacy-${entry.seq}`
       };
-      await writeTextFile(join8(paths.lineage, entry.dirName, "meta.yml"), import_yaml5.default.stringify(meta));
+      await writeTextFile(join9(paths.lineage, entry.dirName, "meta.yml"), import_yaml5.default.stringify(meta));
       const oldSlug = entry.dirName.replace(/^gen-\d{3}/, "");
       const newDirName = `${newId}${oldSlug}`;
       if (newDirName !== entry.dirName) {
-        await rename2(join8(paths.lineage, entry.dirName), join8(paths.lineage, newDirName));
+        await rename2(join9(paths.lineage, entry.dirName), join9(paths.lineage, newDirName));
       }
       prevId = newId;
       result.migrated.push(`${entry.dirName} → ${newDirName}`);
@@ -10352,13 +10664,13 @@ async function updateProject(projectRoot, dryRun = false) {
   const config = await ConfigManager.read(paths);
   const adapters = await AgentRegistry.getActiveAdapters(config ?? undefined);
   const commandsDir = ReapPaths.packageCommandsDir;
-  const commandFiles = await readdir8(commandsDir);
+  const commandFiles = await readdir9(commandsDir);
   await mkdir6(ReapPaths.userReapCommands, { recursive: true });
   for (const file of commandFiles) {
     if (!file.endsWith(".md"))
       continue;
-    const src = await readTextFileOrThrow(join9(commandsDir, file));
-    const dest = join9(ReapPaths.userReapCommands, file);
+    const src = await readTextFileOrThrow(join10(commandsDir, file));
+    const dest = join10(ReapPaths.userReapCommands, file);
     const existing = await readTextFile(dest);
     if (existing !== null && existing === src) {
       result.skipped.push(`~/.reap/commands/${file}`);
@@ -10380,7 +10692,7 @@ description: "REAP — redirected to ~/.reap/commands/"
 ---
 Read \`~/.reap/commands/${cmdName}.md\` and follow the instructions there.
 `;
-      const dest = join9(agentCmdDir, file);
+      const dest = join10(agentCmdDir, file);
       const existingContent = await readTextFile(dest);
       if (existingContent !== null && existingContent === redirectContent) {
         result.skipped.push(`[${label}] commands/${file}`);
@@ -10400,8 +10712,8 @@ Read \`~/.reap/commands/${cmdName}.md\` and follow the instructions there.
   await mkdir6(ReapPaths.userReapTemplates, { recursive: true });
   const artifactFiles = ["01-objective.md", "02-planning.md", "03-implementation.md", "04-validation.md", "05-completion.md"];
   for (const file of artifactFiles) {
-    const src = await readTextFileOrThrow(join9(ReapPaths.packageArtifactsDir, file));
-    const dest = join9(ReapPaths.userReapTemplates, file);
+    const src = await readTextFileOrThrow(join10(ReapPaths.packageArtifactsDir, file));
+    const dest = join10(ReapPaths.userReapTemplates, file);
     const existingContent = await readTextFile(dest);
     if (existingContent !== null && existingContent === src) {
       result.skipped.push(`~/.reap/templates/${file}`);
@@ -10411,8 +10723,8 @@ Read \`~/.reap/commands/${cmdName}.md\` and follow the instructions there.
       result.updated.push(`~/.reap/templates/${file}`);
     }
   }
-  const domainGuideSrc = await readTextFileOrThrow(join9(ReapPaths.packageGenomeDir, "domain/README.md"));
-  const domainGuideDest = join9(ReapPaths.userReapTemplates, "domain-guide.md");
+  const domainGuideSrc = await readTextFileOrThrow(join10(ReapPaths.packageGenomeDir, "domain/README.md"));
+  const domainGuideDest = join10(ReapPaths.userReapTemplates, "domain-guide.md");
   const domainExistingContent = await readTextFile(domainGuideDest);
   if (domainExistingContent !== null && domainExistingContent === domainGuideSrc) {
     result.skipped.push(`~/.reap/templates/domain-guide.md`);
@@ -10421,13 +10733,13 @@ Read \`~/.reap/commands/${cmdName}.md\` and follow the instructions there.
       await writeTextFile(domainGuideDest, domainGuideSrc);
     result.updated.push(`~/.reap/templates/domain-guide.md`);
   }
-  const mergeTemplatesDir = join9(ReapPaths.userReapTemplates, "merge");
+  const mergeTemplatesDir = join10(ReapPaths.userReapTemplates, "merge");
   await mkdir6(mergeTemplatesDir, { recursive: true });
   const mergeArtifactFiles = ["01-detect.md", "02-mate.md", "03-merge.md", "04-sync.md", "05-validation.md", "06-completion.md"];
-  const mergeSourceDir = join9(ReapPaths.packageArtifactsDir, "merge");
+  const mergeSourceDir = join10(ReapPaths.packageArtifactsDir, "merge");
   for (const file of mergeArtifactFiles) {
-    const src = await readTextFileOrThrow(join9(mergeSourceDir, file));
-    const dest = join9(mergeTemplatesDir, file);
+    const src = await readTextFileOrThrow(join10(mergeSourceDir, file));
+    const dest = join10(mergeTemplatesDir, file);
     const existing = await readTextFile(dest);
     if (existing !== null && existing === src) {
       result.skipped.push(`~/.reap/templates/merge/${file}`);
@@ -10437,13 +10749,13 @@ Read \`~/.reap/commands/${cmdName}.md\` and follow the instructions there.
       result.updated.push(`~/.reap/templates/merge/${file}`);
     }
   }
-  const brainstormSourceDir = join9(ReapPaths.packageTemplatesDir, "brainstorm");
-  const brainstormDestDir = join9(paths.root, "brainstorm");
+  const brainstormSourceDir = join10(ReapPaths.packageTemplatesDir, "brainstorm");
+  const brainstormDestDir = join10(paths.root, "brainstorm");
   await mkdir6(brainstormDestDir, { recursive: true });
   const brainstormFiles = ["server.cjs", "frame.html", "start-server.sh"];
   for (const file of brainstormFiles) {
-    const src = await readTextFileOrThrow(join9(brainstormSourceDir, file));
-    const dest = join9(brainstormDestDir, file);
+    const src = await readTextFileOrThrow(join10(brainstormSourceDir, file));
+    const dest = join10(brainstormDestDir, file);
     const existing = await readTextFile(dest);
     if (existing !== null && existing === src) {
       result.skipped.push(`.reap/brainstorm/${file}`);
@@ -10492,11 +10804,11 @@ async function migrateLegacyFiles(paths, dryRun, result) {
   await removeDirIfExists(paths.legacyTemplates, ".reap/templates/", dryRun, result);
   try {
     const claudeCmdDir = paths.legacyClaudeCommands;
-    const files = await readdir8(claudeCmdDir);
+    const files = await readdir9(claudeCmdDir);
     for (const file of files) {
       if (file.startsWith("reap.") && file.endsWith(".md")) {
         if (!dryRun)
-          await unlink3(join9(claudeCmdDir, file));
+          await unlink3(join10(claudeCmdDir, file));
         result.removed.push(`.claude/commands/${file}`);
       }
     }
@@ -10540,7 +10852,7 @@ async function migrateLegacyFiles(paths, dryRun, result) {
 }
 async function removeDirIfExists(dirPath, label, dryRun, result) {
   try {
-    const entries = await readdir8(dirPath);
+    const entries = await readdir9(dirPath);
     if (entries.length > 0 || true) {
       if (!dryRun)
         await rm2(dirPath, { recursive: true });
@@ -10575,10 +10887,11 @@ async function getStatus(projectRoot) {
 
 // src/cli/commands/fix.ts
 var import_yaml6 = __toESM(require_dist(), 1);
-import { mkdir as mkdir7, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir7, stat as stat3 } from "fs/promises";
+init_fs();
 async function dirExists(path) {
   try {
-    const s = await stat2(path);
+    const s = await stat3(path);
     return s.isDirectory();
   } catch {
     return false;
@@ -10631,8 +10944,9 @@ async function fixProject(projectRoot) {
 }
 
 // src/cli/index.ts
-import { join as join10 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.7.0");
+init_fs();
+import { join as join11 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.7.1");
 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();
@@ -10754,10 +11068,10 @@ program.command("help").description("Show REAP commands, slash commands, and wor
     if (l === "korean" || l === "ko")
       lang = "ko";
   }
-  const helpDir = join10(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join10(helpDir, `${lang}.txt`));
+  const helpDir = join11(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join11(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join10(helpDir, "en.txt"));
+    helpText = await readTextFile(join11(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;

package/package.json

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