@c-d-cc/reap 0.3.5 → 0.5.0

package/dist/cli.js

@@ -8999,6 +8999,18 @@ class ConfigManager {
     const content = import_yaml.default.stringify(config);
     await writeTextFile(paths.config, content);
   }
+  static resolveStrict(strict) {
+    if (strict === undefined || strict === false) {
+      return { edit: false, merge: false };
+    }
+    if (strict === true) {
+      return { edit: true, merge: true };
+    }
+    return {
+      edit: strict.edit ?? false,
+      merge: strict.merge ?? false
+    };
+  }
 }
 
 // src/core/agents/claude-code.ts
@@ -9419,7 +9431,18 @@ var COMMAND_NAMES = [
   "reap.status",
   "reap.sync",
   "reap.help",
-  "reap.update"
+  "reap.update",
+  "reap.merge.start",
+  "reap.merge.detect",
+  "reap.merge.mate",
+  "reap.merge.merge",
+  "reap.merge.sync",
+  "reap.merge.validation",
+  "reap.merge.completion",
+  "reap.merge.evolve",
+  "reap.merge",
+  "reap.pull",
+  "reap.push"
 ];
 async function initProject(projectRoot, projectName, entryMode, preset, onProgress) {
   const log = onProgress ?? (() => {});
@@ -9468,6 +9491,15 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   const domainGuideSrc = join4(ReapPaths.packageGenomeDir, "domain/README.md");
   const domainGuideDest = join4(ReapPaths.userReapTemplates, "domain-guide.md");
   await writeTextFile(domainGuideDest, await readTextFileOrThrow(domainGuideSrc));
+  const mergeTemplatesDir = join4(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");
+  for (const file of mergeArtifactFiles) {
+    const src = join4(mergeSourceDir, file);
+    const dest = join4(mergeTemplatesDir, file);
+    await writeTextFile(dest, await readTextFileOrThrow(src));
+  }
   log("Installing hook conditions...");
   const conditionsSourceDir = join4(ReapPaths.packageTemplatesDir, "conditions");
   const conditionsDestDir = join4(paths.hooks, "conditions");
@@ -9497,8 +9529,8 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
 }
 
 // src/cli/commands/update.ts
-import { readdir as readdir4, unlink as unlink3, rm, mkdir as mkdir4 } from "fs/promises";
-import { join as join5 } from "path";
+import { readdir as readdir8, unlink as unlink3, rm as rm2, mkdir as mkdir6 } from "fs/promises";
+import { join as join9 } from "path";
 
 // src/core/hooks.ts
 async function migrateHooks(dryRun = false) {
@@ -9513,147 +9545,16 @@ async function migrateHooks(dryRun = false) {
   return { results };
 }
 
-// src/cli/commands/update.ts
-async function updateProject(projectRoot, dryRun = false) {
-  const paths = new ReapPaths(projectRoot);
-  if (!await paths.isReapProject()) {
-    throw new Error("Not a REAP project. Run 'reap init' first.");
-  }
-  const result = { updated: [], skipped: [], removed: [] };
-  const config = await ConfigManager.read(paths);
-  const adapters = await AgentRegistry.getActiveAdapters(config ?? undefined);
-  const commandsDir = ReapPaths.packageCommandsDir;
-  const commandFiles = await readdir4(commandsDir);
-  for (const adapter of adapters) {
-    const agentCmdDir = adapter.getCommandsDir();
-    const label = `${adapter.displayName}`;
-    for (const file of commandFiles) {
-      if (!file.endsWith(".md"))
-        continue;
-      const src = await readTextFileOrThrow(join5(commandsDir, file));
-      const dest = join5(agentCmdDir, file);
-      const existingContent = await readTextFile(dest);
-      if (existingContent !== null && existingContent === src) {
-        result.skipped.push(`[${label}] commands/${file}`);
-      } else {
-        if (!dryRun) {
-          await mkdir4(agentCmdDir, { recursive: true });
-          await writeTextFile(dest, src);
-        }
-        result.updated.push(`[${label}] commands/${file}`);
-      }
-    }
-    const validCommandFiles = new Set(commandFiles);
-    if (!dryRun) {
-      await adapter.removeStaleCommands(validCommandFiles);
-    }
-  }
-  await mkdir4(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(join5(ReapPaths.packageArtifactsDir, file));
-    const dest = join5(ReapPaths.userReapTemplates, file);
-    const existingContent = await readTextFile(dest);
-    if (existingContent !== null && existingContent === src) {
-      result.skipped.push(`~/.reap/templates/${file}`);
-    } else {
-      if (!dryRun)
-        await writeTextFile(dest, src);
-      result.updated.push(`~/.reap/templates/${file}`);
-    }
-  }
-  const domainGuideSrc = await readTextFileOrThrow(join5(ReapPaths.packageGenomeDir, "domain/README.md"));
-  const domainGuideDest = join5(ReapPaths.userReapTemplates, "domain-guide.md");
-  const domainExistingContent = await readTextFile(domainGuideDest);
-  if (domainExistingContent !== null && domainExistingContent === domainGuideSrc) {
-    result.skipped.push(`~/.reap/templates/domain-guide.md`);
-  } else {
-    if (!dryRun)
-      await writeTextFile(domainGuideDest, domainGuideSrc);
-    result.updated.push(`~/.reap/templates/domain-guide.md`);
-  }
-  const migrations = await migrateHooks(dryRun);
-  for (const m of migrations.results) {
-    if (m.action === "migrated") {
-      result.updated.push(`[${m.agent}] hooks (migrated)`);
-    }
-  }
-  for (const adapter of adapters) {
-    const hookResult = await adapter.syncSessionHook(dryRun);
-    if (hookResult.action === "updated") {
-      result.updated.push(`[${adapter.displayName}] session hook`);
-    } else {
-      result.skipped.push(`[${adapter.displayName}] session hook`);
-    }
-  }
-  await migrateLegacyFiles(paths, dryRun, result);
-  return result;
-}
-async function migrateLegacyFiles(paths, dryRun, result) {
-  await removeDirIfExists(paths.legacyCommands, ".reap/commands/", dryRun, result);
-  await removeDirIfExists(paths.legacyTemplates, ".reap/templates/", dryRun, result);
-  try {
-    const claudeCmdDir = paths.legacyClaudeCommands;
-    const files = await readdir4(claudeCmdDir);
-    for (const file of files) {
-      if (file.startsWith("reap.") && file.endsWith(".md")) {
-        if (!dryRun)
-          await unlink3(join5(claudeCmdDir, file));
-        result.removed.push(`.claude/commands/${file}`);
-      }
-    }
-  } catch {}
-  try {
-    const legacyHooksJson = paths.legacyClaudeHooksJson;
-    const fileContent = await readTextFile(legacyHooksJson);
-    if (fileContent !== null) {
-      const content = JSON.parse(fileContent);
-      const sessionStart = content["SessionStart"];
-      if (Array.isArray(sessionStart)) {
-        const filtered = sessionStart.filter((entry) => {
-          if (typeof entry !== "object" || entry === null)
-            return true;
-          const hooks = entry["hooks"];
-          if (!Array.isArray(hooks))
-            return true;
-          return !hooks.some((h) => {
-            if (typeof h !== "object" || h === null)
-              return false;
-            const cmd = h["command"];
-            return typeof cmd === "string" && cmd.includes(".reap/hooks/");
-          });
-        });
-        if (filtered.length !== sessionStart.length) {
-          if (!dryRun) {
-            if (filtered.length === 0 && Object.keys(content).length === 1) {
-              await unlink3(legacyHooksJson);
-              result.removed.push(`.claude/hooks.json (legacy)`);
-            } else {
-              content["SessionStart"] = filtered;
-              await writeTextFile(legacyHooksJson, JSON.stringify(content, null, 2) + `
-`);
-              result.removed.push(`.claude/hooks.json (legacy REAP hook entry)`);
-            }
-          }
-        }
-      }
-    }
-  } catch {}
-}
-async function removeDirIfExists(dirPath, label, dryRun, result) {
-  try {
-    const entries = await readdir4(dirPath);
-    if (entries.length > 0 || true) {
-      if (!dryRun)
-        await rm(dirPath, { recursive: true });
-      result.removed.push(label);
-    }
-  } catch {}
-}
+// src/core/migration.ts
+var import_yaml5 = __toESM(require_dist(), 1);
+import { readdir as readdir7, rename as rename2 } from "fs/promises";
+import { join as join8 } from "path";
 
 // src/core/generation.ts
-var import_yaml2 = __toESM(require_dist(), 1);
-import { readdir as readdir6, mkdir as mkdir5, rename } from "fs/promises";
+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";
 
 // src/types/index.ts
@@ -9708,14 +9609,35 @@ class LifeCycle {
 }
 
 // src/core/compression.ts
-import { readdir as readdir5, rm as rm2 } from "fs/promises";
-import { join as join6 } from "path";
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readdir as readdir4, rm } from "fs/promises";
+import { join as join5 } from "path";
 var LINEAGE_MAX_LINES = 5000;
 var MIN_GENERATIONS_FOR_COMPRESSION = 5;
 var LEVEL1_MAX_LINES = 40;
 var LEVEL2_MAX_LINES = 60;
 var LEVEL2_BATCH_SIZE = 5;
 var RECENT_PROTECTED_COUNT = 3;
+function extractGenNum(name) {
+  const match = name.match(/^gen-(\d{3})/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match)
+    return null;
+  try {
+    return import_yaml2.default.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
+function buildFrontmatter(meta) {
+  return `---
+${import_yaml2.default.stringify(meta).trim()}
+---
+`;
+}
 async function countLines(filePath) {
   const content = await readTextFile(filePath);
   if (content === null)
@@ -9726,9 +9648,9 @@ async function countLines(filePath) {
 async function countDirLines(dirPath) {
   let total = 0;
   try {
-    const entries = await readdir5(dirPath, { withFileTypes: true });
+    const entries = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join6(dirPath, entry.name);
+      const fullPath = join5(dirPath, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         total += await countLines(fullPath);
       } else if (entry.isDirectory()) {
@@ -9738,33 +9660,113 @@ async function countDirLines(dirPath) {
   } catch {}
   return total;
 }
+async function readDirMeta(dirPath) {
+  const content = await readTextFile(join5(dirPath, "meta.yml"));
+  if (content === null)
+    return null;
+  try {
+    return import_yaml2.default.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readFileMeta(filePath) {
+  const content = await readTextFile(filePath);
+  if (content === null)
+    return null;
+  return parseFrontmatter(content);
+}
 async function scanLineage(paths) {
   const entries = [];
   try {
-    const items = await readdir5(paths.lineage, { withFileTypes: true });
+    const items = await readdir4(paths.lineage, { withFileTypes: true });
     for (const item of items) {
-      const fullPath = join6(paths.lineage, item.name);
+      const fullPath = join5(paths.lineage, item.name);
       if (item.isDirectory() && item.name.startsWith("gen-")) {
-        const genNum = parseInt(item.name.replace("gen-", ""), 10);
+        const genNum = extractGenNum(item.name);
         const lines = await countDirLines(fullPath);
-        entries.push({ name: item.name, type: "dir", lines, genNum });
+        const meta = await readDirMeta(fullPath);
+        const genId = meta?.id ?? item.name.match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? item.name;
+        entries.push({
+          name: item.name,
+          type: "dir",
+          lines,
+          genNum,
+          completedAt: meta?.completedAt ?? "",
+          genId
+        });
       } else if (item.isFile() && item.name.startsWith("gen-") && item.name.endsWith(".md")) {
-        const genNum = parseInt(item.name.replace("gen-", ""), 10);
+        const genNum = extractGenNum(item.name);
         const lines = await countLines(fullPath);
-        entries.push({ name: item.name, type: "level1", lines, genNum });
+        const meta = await readFileMeta(fullPath);
+        const genId = meta?.id ?? item.name.replace(".md", "").match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? item.name;
+        entries.push({
+          name: item.name,
+          type: "level1",
+          lines,
+          genNum,
+          completedAt: meta?.completedAt ?? "",
+          genId
+        });
       } else if (item.isFile() && item.name.startsWith("epoch-") && item.name.endsWith(".md")) {
         const lines = await countLines(fullPath);
-        entries.push({ name: item.name, type: "level2", lines, genNum: 0 });
+        entries.push({
+          name: item.name,
+          type: "level2",
+          lines,
+          genNum: 0,
+          completedAt: "",
+          genId: ""
+        });
       }
     }
   } catch {}
-  return entries.sort((a, b) => a.genNum - b.genNum);
+  return entries.sort((a, b) => {
+    if (a.completedAt && b.completedAt) {
+      return a.completedAt.localeCompare(b.completedAt);
+    }
+    return a.genNum - b.genNum;
+  });
+}
+async function findLeafNodes(paths, entries) {
+  const allIds = new Set;
+  const referencedAsParent = new Set;
+  for (const entry of entries) {
+    if (entry.type === "level2")
+      continue;
+    let meta = null;
+    const fullPath = join5(paths.lineage, entry.name);
+    if (entry.type === "dir") {
+      meta = await readDirMeta(fullPath);
+    } else {
+      meta = await readFileMeta(fullPath);
+    }
+    if (meta) {
+      allIds.add(meta.id);
+      for (const parent of meta.parents) {
+        referencedAsParent.add(parent);
+      }
+    } else {
+      allIds.add(entry.genId);
+    }
+  }
+  const leaves = new Set;
+  for (const id of allIds) {
+    if (!referencedAsParent.has(id)) {
+      leaves.add(id);
+    }
+  }
+  return leaves;
 }
 async function compressLevel1(genDir, genName) {
   const lines = [];
+  const meta = await readDirMeta(genDir);
+  if (meta) {
+    lines.push(buildFrontmatter(meta));
+  }
   let goal = "", completionConditions = "";
   {
-    const objective = await readTextFile(join6(genDir, "01-objective.md"));
+    const objective = await readTextFile(join5(genDir, "01-objective.md"));
     if (objective) {
       const goalMatch = objective.match(/## Goal\n([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -9776,7 +9778,7 @@ async function compressLevel1(genDir, genName) {
   }
   let lessons = "", genomeChanges = "", nextBacklog = "";
   {
-    const completion = await readTextFile(join6(genDir, "05-completion.md"));
+    const completion = await readTextFile(join5(genDir, "05-completion.md"));
     if (completion) {
       const lessonsMatch = completion.match(/### Lessons Learned\n([\s\S]*?)(?=\n###)/);
       if (lessonsMatch)
@@ -9789,18 +9791,18 @@ async function compressLevel1(genDir, genName) {
         nextBacklog = backlogMatch[1].trim();
     }
   }
-  let metadata = "";
+  let summaryText = "";
   {
-    const completion = await readTextFile(join6(genDir, "05-completion.md"));
+    const completion = await readTextFile(join5(genDir, "05-completion.md"));
     if (completion) {
       const summaryMatch = completion.match(/## Summary\n([\s\S]*?)(?=\n##)/);
       if (summaryMatch)
-        metadata = summaryMatch[1].trim();
+        summaryText = summaryMatch[1].trim();
     }
   }
   let validationResult = "";
   {
-    const validation = await readTextFile(join6(genDir, "04-validation.md"));
+    const validation = await readTextFile(join5(genDir, "04-validation.md"));
     if (validation) {
       const resultMatch = validation.match(/## Result: (.+)/);
       if (resultMatch)
@@ -9809,7 +9811,7 @@ async function compressLevel1(genDir, genName) {
   }
   let deferred = "";
   {
-    const impl = await readTextFile(join6(genDir, "03-implementation.md"));
+    const impl = await readTextFile(join5(genDir, "03-implementation.md"));
     if (impl) {
       const deferredMatch = impl.match(/## Deferred Tasks\n([\s\S]*?)(?=\n##)/);
       if (deferredMatch) {
@@ -9820,10 +9822,10 @@ async function compressLevel1(genDir, genName) {
       }
     }
   }
-  const genId = genName.match(/^gen-\d+/)?.[0] ?? genName;
+  const genId = genName.match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? genName;
   lines.push(`# ${genId}`);
-  if (metadata) {
-    lines.push(metadata.replace(/^# .+\n/, "").trim());
+  if (summaryText) {
+    lines.push(summaryText.replace(/^# .+\n/, "").trim());
   }
   lines.push("");
   if (goal) {
@@ -9873,18 +9875,19 @@ async function compressLevel1(genDir, genName) {
 }
 async function compressLevel2(level1Files, epochNum) {
   const lines = [];
-  const genIds = level1Files.map((f) => f.name.replace(".md", "").match(/^gen-\d+/)?.[0] ?? f.name);
+  const genIds = level1Files.map((f) => f.name.replace(".md", "").match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? f.name);
   const first = genIds[0];
   const last = genIds[genIds.length - 1];
   lines.push(`# Epoch ${String(epochNum).padStart(3, "0")} (${first} ~ ${last})`);
   lines.push("");
   for (const file of level1Files) {
     const content = await readTextFileOrThrow(file.path);
-    const headerMatch = content.match(/^# (gen-\d+)/m);
-    const goalMatch = content.match(/- Goal: (.+)/);
-    const periodMatch = content.match(/- (?:Started|Period): (.+)/);
-    const genomeMatch = content.match(/- Genome.*: (.+)/);
-    const resultMatch = content.match(/## Result: (.+)/);
+    const bodyContent = content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+    const headerMatch = bodyContent.match(/^# (gen-\d{3}(?:-[a-f0-9]{6})?)/m);
+    const goalMatch = bodyContent.match(/- Goal: (.+)/);
+    const periodMatch = bodyContent.match(/- (?:Started|Period): (.+)/);
+    const genomeMatch = bodyContent.match(/- Genome.*: (.+)/);
+    const resultMatch = bodyContent.match(/## Result: (.+)/);
     const genId = headerMatch?.[1] ?? "unknown";
     const goal = goalMatch?.[1] ?? "";
     const result2 = resultMatch?.[1] ?? "";
@@ -9895,7 +9898,7 @@ async function compressLevel2(level1Files, epochNum) {
       lines.push(`- ${genomeMatch[0].trim()}`);
     if (result2)
       lines.push(`- Result: ${result2}`);
-    const changeSection = content.match(/## Genome Changes\n([\s\S]*?)(?=\n##|$)/);
+    const changeSection = bodyContent.match(/## Genome Changes\n([\s\S]*?)(?=\n##|$)/);
     if (changeSection && !changeSection[1].match(/^\|\s*\|\s*\|\s*\|\s*\|$/)) {
       lines.push(`- Genome Changes: ${changeSection[1].trim().split(`
 `)[0]}`);
@@ -9924,21 +9927,23 @@ async function compressLineageIfNeeded(paths) {
   if (totalLines <= LINEAGE_MAX_LINES) {
     return result;
   }
-  const allDirs = entries.filter((e) => e.type === "dir").sort((a, b) => a.genNum - b.genNum);
-  const dirs = allDirs.slice(0, Math.max(0, allDirs.length - RECENT_PROTECTED_COUNT));
-  for (const dir of dirs) {
+  const leafNodes = await findLeafNodes(paths, entries);
+  const allDirs = entries.filter((e) => e.type === "dir");
+  const recentIds = new Set(allDirs.slice(Math.max(0, allDirs.length - RECENT_PROTECTED_COUNT)).map((e) => e.genId));
+  const compressibleDirs = allDirs.filter((dir) => !recentIds.has(dir.genId) && !leafNodes.has(dir.genId));
+  for (const dir of compressibleDirs) {
     const currentTotal = await countDirLines(paths.lineage);
     if (currentTotal <= LINEAGE_MAX_LINES)
       break;
-    const dirPath = join6(paths.lineage, dir.name);
+    const dirPath = join5(paths.lineage, dir.name);
     const compressed = await compressLevel1(dirPath, dir.name);
-    const genId = dir.name.match(/^gen-\d+/)?.[0] ?? dir.name;
-    const outPath = join6(paths.lineage, `${genId}.md`);
+    const genId = dir.name.match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? dir.name;
+    const outPath = join5(paths.lineage, `${genId}.md`);
     await writeTextFile(outPath, compressed);
-    await rm2(dirPath, { recursive: true });
+    await rm(dirPath, { recursive: true });
     result.level1.push(genId);
   }
-  const level1s = (await scanLineage(paths)).filter((e) => e.type === "level1").sort((a, b) => a.genNum - b.genNum);
+  const level1s = (await scanLineage(paths)).filter((e) => e.type === "level1");
   if (level1s.length >= LEVEL2_BATCH_SIZE) {
     const existingEpochs = (await scanLineage(paths)).filter((e) => e.type === "level2");
     let epochNum = existingEpochs.length + 1;
@@ -9947,13 +9952,13 @@ 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: join6(paths.lineage, e.name)
+        path: join5(paths.lineage, e.name)
       }));
       const compressed = await compressLevel2(files, epochNum);
-      const outPath = join6(paths.lineage, `epoch-${String(epochNum).padStart(3, "0")}.md`);
+      const outPath = join5(paths.lineage, `epoch-${String(epochNum).padStart(3, "0")}.md`);
       await writeTextFile(outPath, compressed);
       for (const file of files) {
-        await rm2(file.path);
+        await rm(file.path);
       }
       result.level2.push(`epoch-${String(epochNum).padStart(3, "0")}`);
       epochNum++;
@@ -9962,7 +9967,119 @@ async function compressLineageIfNeeded(paths) {
   return result;
 }
 
+// src/core/lineage.ts
+var import_yaml3 = __toESM(require_dist(), 1);
+import { readdir as readdir5 } from "fs/promises";
+import { join as join6 } from "path";
+async function listCompleted(paths) {
+  try {
+    const entries = await readdir5(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 content = await readTextFile(metaPath);
+  if (content === null)
+    return null;
+  return import_yaml3.default.parse(content);
+}
+async function listMeta(paths) {
+  const metas = [];
+  try {
+    const entries = await readdir5(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));
+        if (content) {
+          const meta = parseFrontmatter(content);
+          if (meta)
+            metas.push(meta);
+        }
+      }
+    }
+  } catch {}
+  return metas;
+}
+async function nextSeq(paths, currentId) {
+  const genDirs = await listCompleted(paths);
+  if (genDirs.length === 0) {
+    if (currentId) {
+      return parseGenSeq(currentId) + 1;
+    }
+    return 1;
+  }
+  let maxSeq = 0;
+  for (const dir of genDirs) {
+    const seq = parseGenSeq(dir);
+    if (seq > maxSeq)
+      maxSeq = seq;
+  }
+  return maxSeq + 1;
+}
+async function resolveParents(paths) {
+  const metas = await listMeta(paths);
+  if (metas.length > 0) {
+    const sorted = metas.sort((a, b) => new Date(b.completedAt).getTime() - new Date(a.completedAt).getTime());
+    return [sorted[0].id];
+  }
+  const dirs = await listCompleted(paths);
+  if (dirs.length > 0) {
+    const lastDir = dirs[dirs.length - 1];
+    const legacyId = lastDir.match(/^(gen-\d{3}(?:-[a-f0-9]{6})?)/)?.[1];
+    if (legacyId)
+      return [legacyId];
+  }
+  return [];
+}
+
 // src/core/generation.ts
+function generateGenHash(parents, goal, genomeHash, machineId, startedAt) {
+  const input = JSON.stringify({ parents, goal, genomeHash, machineId, startedAt });
+  return createHash("sha256").update(input).digest("hex").slice(0, 6);
+}
+function getMachineId() {
+  return hostname();
+}
+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);
+      return pathA.localeCompare(pathB);
+    });
+    for (const entry of entries) {
+      const filePath = join7(e2path(entry), entry.name);
+      const content = await readTextFile(filePath);
+      if (content !== null) {
+        hash.update(filePath.replace(genomePath, ""));
+        hash.update(content);
+      }
+    }
+  } catch {}
+  return hash.digest("hex").slice(0, 8);
+}
+function e2path(entry) {
+  return entry.parentPath ?? entry.path ?? "";
+}
+function formatGenId(seq, hash) {
+  return `gen-${String(seq).padStart(3, "0")}-${hash}`;
+}
+function parseGenSeq(id) {
+  const match = id.match(/^gen-(\d{3})/);
+  return match ? parseInt(match[1], 10) : 0;
+}
+function isLegacyId(id) {
+  return /^gen-\d{3}$/.test(id);
+}
+
 class GenerationManager {
   paths;
   constructor(paths) {
@@ -9972,20 +10089,33 @@ class GenerationManager {
     const content = await readTextFile(this.paths.currentYml);
     if (content === null || !content.trim())
       return null;
-    return import_yaml2.default.parse(content);
+    const state = import_yaml4.default.parse(content);
+    if (!state.type)
+      state.type = "normal";
+    if (!state.parents)
+      state.parents = [];
+    return state;
   }
   async create(goal, genomeVersion) {
-    const id = await this.nextGenId();
+    const seq = await this.nextSeq();
     const now = new Date().toISOString();
+    const genomeHash = await computeGenomeHash(this.paths.genome);
+    const machineId = getMachineId();
+    const parents = await this.resolveParents();
+    const hash = generateGenHash(parents, goal, genomeHash, machineId, now);
+    const id = formatGenId(seq, hash);
     const state = {
       id,
       goal,
       stage: "objective",
       genomeVersion,
       startedAt: now,
-      timeline: [{ stage: "objective", at: now }]
+      timeline: [{ stage: "objective", at: now }],
+      type: "normal",
+      parents,
+      genomeHash
     };
-    await writeTextFile(this.paths.currentYml, import_yaml2.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml4.default.stringify(state));
     return state;
   }
   async advance() {
@@ -9999,7 +10129,7 @@ class GenerationManager {
     if (!state.timeline)
       state.timeline = [];
     state.timeline.push({ stage: next, at: new Date().toISOString() });
-    await writeTextFile(this.paths.currentYml, import_yaml2.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml4.default.stringify(state));
     return state;
   }
   async complete() {
@@ -10008,10 +10138,22 @@ class GenerationManager {
       throw new Error("No active generation");
     if (state.stage !== "completion")
       throw new Error("Generation must be in completion stage to complete");
+    const now = new Date().toISOString();
+    state.completedAt = now;
     const goalSlug = state.goal.toLowerCase().replace(/[^a-z0-9가-힣]+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
     const genDirName = `${state.id}-${goalSlug}`;
     const genDir = this.paths.generationDir(genDirName);
-    await mkdir5(genDir, { recursive: true });
+    await mkdir4(genDir, { recursive: true });
+    const meta = {
+      id: state.id,
+      type: state.type ?? "normal",
+      parents: state.parents ?? [],
+      goal: state.goal,
+      genomeHash: state.genomeHash ?? "unknown",
+      startedAt: state.startedAt,
+      completedAt: now
+    };
+    await writeTextFile(join7(genDir, "meta.yml"), import_yaml4.default.stringify(meta));
     const lifeEntries = await readdir6(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
@@ -10019,7 +10161,7 @@ class GenerationManager {
       }
     }
     const backlogDir = join7(genDir, "backlog");
-    await mkdir5(backlogDir, { recursive: true });
+    await mkdir4(backlogDir, { recursive: true });
     try {
       const backlogEntries = await readdir6(this.paths.backlog);
       for (const entry of backlogEntries) {
@@ -10030,7 +10172,7 @@ class GenerationManager {
       const mutEntries = await readdir6(this.paths.mutations);
       if (mutEntries.length > 0) {
         const mutDir = join7(genDir, "mutations");
-        await mkdir5(mutDir, { recursive: true });
+        await mkdir4(mutDir, { recursive: true });
         for (const entry of mutEntries) {
           await rename(join7(this.paths.mutations, entry), join7(mutDir, entry));
         }
@@ -10041,30 +10183,295 @@ class GenerationManager {
     return compression;
   }
   async save(state) {
-    await writeTextFile(this.paths.currentYml, import_yaml2.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml4.default.stringify(state));
   }
   async listCompleted() {
+    return listCompleted(this.paths);
+  }
+  async readMeta(lineageDirName) {
+    return readMeta(this.paths, lineageDirName);
+  }
+  async listMeta() {
+    return listMeta(this.paths);
+  }
+  async resolveParents() {
+    return resolveParents(this.paths);
+  }
+  async nextSeq() {
+    const current = await this.current();
+    return nextSeq(this.paths, current?.id);
+  }
+  async nextGenId() {
+    const seq = await this.nextSeq();
+    return `gen-${String(seq).padStart(3, "0")}`;
+  }
+}
+
+// src/core/migration.ts
+async function needsMigration(paths) {
+  try {
+    const entries = await readdir7(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 content = await readTextFile(metaPath);
+      if (content === null)
+        return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+async function migrateLineage(paths) {
+  const result = { migrated: [], skipped: [], errors: [] };
+  let entries;
+  try {
+    const dirEntries = await readdir7(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 metaContent = await readTextFile(metaPath);
+    const seq = parseGenSeq(dirName);
+    let goal = "";
+    const objContent = await readTextFile(join8(paths.lineage, dirName, "01-objective.md"));
+    if (objContent) {
+      const goalMatch = objContent.match(/## Goal\n+([\s\S]*?)(?=\n##)/);
+      if (goalMatch)
+        goal = goalMatch[1].trim();
+    }
+    if (!goal) {
+      const slugMatch = dirName.match(/^gen-\d{3}(?:-[a-f0-9]{6})?-(.+)$/);
+      goal = slugMatch ? slugMatch[1].replace(/-/g, " ") : `Generation ${seq}`;
+    }
+    plan.push({ dirName, seq, goal, hasMeta: metaContent !== null });
+  }
+  let prevId = null;
+  for (const entry of plan) {
+    if (entry.hasMeta) {
+      const metaContent = await readTextFile(join8(paths.lineage, entry.dirName, "meta.yml"));
+      if (metaContent) {
+        const meta = import_yaml5.default.parse(metaContent);
+        prevId = meta.id;
+      }
+      result.skipped.push(entry.dirName);
+      continue;
+    }
     try {
-      const entries = await readdir6(this.paths.lineage);
-      return entries.filter((e) => e.startsWith("gen-")).sort();
-    } catch {
-      return [];
+      const parents = prevId ? [prevId] : [];
+      const hash = generateGenHash(parents, entry.goal, "legacy", "migration", `legacy-${entry.seq}`);
+      const newId = formatGenId(entry.seq, hash);
+      const meta = {
+        id: newId,
+        type: "normal",
+        parents,
+        goal: entry.goal,
+        genomeHash: "legacy",
+        startedAt: `legacy-${entry.seq}`,
+        completedAt: `legacy-${entry.seq}`
+      };
+      await writeTextFile(join8(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));
+      }
+      prevId = newId;
+      result.migrated.push(`${entry.dirName} → ${newDirName}`);
+    } catch (err) {
+      result.errors.push(`${entry.dirName}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  async nextGenId() {
-    const genDirs = await this.listCompleted();
-    if (genDirs.length === 0) {
-      const current = await this.current();
-      if (current) {
-        const num2 = parseInt(current.id.replace("gen-", ""), 10);
-        return `gen-${String(num2 + 1).padStart(3, "0")}`;
+  try {
+    const currentContent = await readTextFile(paths.currentYml);
+    if (currentContent && currentContent.trim()) {
+      const state = import_yaml5.default.parse(currentContent);
+      if (isLegacyId(state.id)) {
+        const parents = prevId ? [prevId] : [];
+        const genomeHash = "legacy";
+        const hash = generateGenHash(parents, state.goal, genomeHash, "migration", state.startedAt);
+        state.id = formatGenId(parseGenSeq(state.id), hash);
+        state.type = state.type ?? "normal";
+        state.parents = parents;
+        state.genomeHash = genomeHash;
+        await writeTextFile(paths.currentYml, import_yaml5.default.stringify(state));
+        result.migrated.push(`current.yml: ${state.id}`);
       }
-      return "gen-001";
     }
-    const last = genDirs[genDirs.length - 1];
-    const num = parseInt(last.replace("gen-", ""), 10);
-    return `gen-${String(num + 1).padStart(3, "0")}`;
+  } catch {}
+  return result;
+}
+
+// src/cli/commands/update.ts
+async function updateProject(projectRoot, dryRun = false) {
+  const paths = new ReapPaths(projectRoot);
+  if (!await paths.isReapProject()) {
+    throw new Error("Not a REAP project. Run 'reap init' first.");
   }
+  const result = { updated: [], skipped: [], removed: [] };
+  const config = await ConfigManager.read(paths);
+  const adapters = await AgentRegistry.getActiveAdapters(config ?? undefined);
+  const commandsDir = ReapPaths.packageCommandsDir;
+  const commandFiles = await readdir8(commandsDir);
+  for (const adapter of adapters) {
+    const agentCmdDir = adapter.getCommandsDir();
+    const label = `${adapter.displayName}`;
+    for (const file of commandFiles) {
+      if (!file.endsWith(".md"))
+        continue;
+      const src = await readTextFileOrThrow(join9(commandsDir, file));
+      const dest = join9(agentCmdDir, file);
+      const existingContent = await readTextFile(dest);
+      if (existingContent !== null && existingContent === src) {
+        result.skipped.push(`[${label}] commands/${file}`);
+      } else {
+        if (!dryRun) {
+          await mkdir6(agentCmdDir, { recursive: true });
+          await writeTextFile(dest, src);
+        }
+        result.updated.push(`[${label}] commands/${file}`);
+      }
+    }
+    const validCommandFiles = new Set(commandFiles);
+    if (!dryRun) {
+      await adapter.removeStaleCommands(validCommandFiles);
+    }
+  }
+  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 existingContent = await readTextFile(dest);
+    if (existingContent !== null && existingContent === src) {
+      result.skipped.push(`~/.reap/templates/${file}`);
+    } else {
+      if (!dryRun)
+        await writeTextFile(dest, src);
+      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 domainExistingContent = await readTextFile(domainGuideDest);
+  if (domainExistingContent !== null && domainExistingContent === domainGuideSrc) {
+    result.skipped.push(`~/.reap/templates/domain-guide.md`);
+  } else {
+    if (!dryRun)
+      await writeTextFile(domainGuideDest, domainGuideSrc);
+    result.updated.push(`~/.reap/templates/domain-guide.md`);
+  }
+  const mergeTemplatesDir = join9(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");
+  for (const file of mergeArtifactFiles) {
+    const src = await readTextFileOrThrow(join9(mergeSourceDir, file));
+    const dest = join9(mergeTemplatesDir, file);
+    const existing = await readTextFile(dest);
+    if (existing !== null && existing === src) {
+      result.skipped.push(`~/.reap/templates/merge/${file}`);
+    } else {
+      if (!dryRun)
+        await writeTextFile(dest, src);
+      result.updated.push(`~/.reap/templates/merge/${file}`);
+    }
+  }
+  const migrations = await migrateHooks(dryRun);
+  for (const m of migrations.results) {
+    if (m.action === "migrated") {
+      result.updated.push(`[${m.agent}] hooks (migrated)`);
+    }
+  }
+  for (const adapter of adapters) {
+    const hookResult = await adapter.syncSessionHook(dryRun);
+    if (hookResult.action === "updated") {
+      result.updated.push(`[${adapter.displayName}] session hook`);
+    } else {
+      result.skipped.push(`[${adapter.displayName}] session hook`);
+    }
+  }
+  await migrateLegacyFiles(paths, dryRun, result);
+  if (await needsMigration(paths)) {
+    if (!dryRun) {
+      const migrationResult = await migrateLineage(paths);
+      for (const m of migrationResult.migrated) {
+        result.updated.push(`[lineage] ${m}`);
+      }
+      for (const e of migrationResult.errors) {
+        result.removed.push(`[lineage error] ${e}`);
+      }
+    } else {
+      result.updated.push("[lineage] DAG migration pending (dry-run)");
+    }
+  }
+  return result;
+}
+async function migrateLegacyFiles(paths, dryRun, result) {
+  await removeDirIfExists(paths.legacyCommands, ".reap/commands/", dryRun, result);
+  await removeDirIfExists(paths.legacyTemplates, ".reap/templates/", dryRun, result);
+  try {
+    const claudeCmdDir = paths.legacyClaudeCommands;
+    const files = await readdir8(claudeCmdDir);
+    for (const file of files) {
+      if (file.startsWith("reap.") && file.endsWith(".md")) {
+        if (!dryRun)
+          await unlink3(join9(claudeCmdDir, file));
+        result.removed.push(`.claude/commands/${file}`);
+      }
+    }
+  } catch {}
+  try {
+    const legacyHooksJson = paths.legacyClaudeHooksJson;
+    const fileContent = await readTextFile(legacyHooksJson);
+    if (fileContent !== null) {
+      const content = JSON.parse(fileContent);
+      const sessionStart = content["SessionStart"];
+      if (Array.isArray(sessionStart)) {
+        const filtered = sessionStart.filter((entry) => {
+          if (typeof entry !== "object" || entry === null)
+            return true;
+          const hooks = entry["hooks"];
+          if (!Array.isArray(hooks))
+            return true;
+          return !hooks.some((h) => {
+            if (typeof h !== "object" || h === null)
+              return false;
+            const cmd = h["command"];
+            return typeof cmd === "string" && cmd.includes(".reap/hooks/");
+          });
+        });
+        if (filtered.length !== sessionStart.length) {
+          if (!dryRun) {
+            if (filtered.length === 0 && Object.keys(content).length === 1) {
+              await unlink3(legacyHooksJson);
+              result.removed.push(`.claude/hooks.json (legacy)`);
+            } else {
+              content["SessionStart"] = filtered;
+              await writeTextFile(legacyHooksJson, JSON.stringify(content, null, 2) + `
+`);
+              result.removed.push(`.claude/hooks.json (legacy REAP hook entry)`);
+            }
+          }
+        }
+      }
+    }
+  } catch {}
+}
+async function removeDirIfExists(dirPath, label, dryRun, result) {
+  try {
+    const entries = await readdir8(dirPath);
+    if (entries.length > 0 || true) {
+      if (!dryRun)
+        await rm2(dirPath, { recursive: true });
+      result.removed.push(label);
+    }
+  } catch {}
 }
 
 // src/cli/commands/status.ts
@@ -10082,15 +10489,18 @@ async function getStatus(projectRoot) {
       goal: current.goal,
       stage: current.stage,
       genomeVersion: current.genomeVersion,
-      startedAt: current.startedAt
+      startedAt: current.startedAt,
+      type: current.type,
+      parents: current.parents,
+      genomeHash: current.genomeHash
     } : null,
     totalGenerations: completedGens.length
   };
 }
 
 // src/cli/commands/fix.ts
-var import_yaml3 = __toESM(require_dist(), 1);
-import { mkdir as mkdir6, stat as stat2 } from "fs/promises";
+var import_yaml6 = __toESM(require_dist(), 1);
+import { mkdir as mkdir7, stat as stat2 } from "fs/promises";
 async function dirExists(path) {
   try {
     const s = await stat2(path);
@@ -10113,7 +10523,7 @@ async function fixProject(projectRoot) {
   ];
   for (const dir of requiredDirs) {
     if (!await dirExists(dir.path)) {
-      await mkdir6(dir.path, { recursive: true });
+      await mkdir7(dir.path, { recursive: true });
       fixed.push(`Recreated missing directory: ${dir.name}/`);
     }
   }
@@ -10124,7 +10534,7 @@ async function fixProject(projectRoot) {
   if (currentContent !== null) {
     if (currentContent.trim()) {
       try {
-        const state = import_yaml3.default.parse(currentContent);
+        const state = import_yaml6.default.parse(currentContent);
         if (!state.stage || !LifeCycle.isValid(state.stage)) {
           issues.push(`Invalid stage "${state.stage}" in current.yml. Valid stages: ${LifeCycle.stages().join(", ")}. Manual correction required.`);
         }
@@ -10133,7 +10543,7 @@ async function fixProject(projectRoot) {
         if (!state.goal)
           issues.push("current.yml is missing 'goal' field. Manual correction required.");
         if (!await dirExists(paths.backlog)) {
-          await mkdir6(paths.backlog, { recursive: true });
+          await mkdir7(paths.backlog, { recursive: true });
           fixed.push("Recreated missing backlog/ directory for active generation");
         }
       } catch {
@@ -10146,8 +10556,8 @@ 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.5");
+import { join as join10 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.5.0");
 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();
@@ -10269,10 +10679,10 @@ program.command("help").description("Show REAP commands, slash commands, and wor
     if (l === "korean" || l === "ko")
       lang = "ko";
   }
-  const helpDir = join8(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join8(helpDir, `${lang}.txt`));
+  const helpDir = join10(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join10(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join8(helpDir, "en.txt"));
+    helpText = await readTextFile(join10(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;