@c-d-cc/reap 0.3.4 → 0.4.0

package/README.ja.md

@@ -130,7 +130,7 @@ Objective → Planning → Implementation ⟷ Validation → Completion
 各項目は`status`フィールドも持ちます：
 
 - `status: pending` — 未処理項目（デフォルト）
-- `status: consumed` — 現在の世代で処理完了（`consumedBy: gen-XXX`必須）
+- `status: consumed` — 現在の世代で処理完了（`consumedBy: gen-XXX-{hash}`必須）
 
 アーカイブ時点（`/reap.next` from Completion）で`consumed`項目はlineageに移動し、`pending`項目は次の世代のbacklogに繰り越されます。
 
@@ -287,7 +287,7 @@ my-project/
 
 | レベル | 入力 | 出力 | 最大行数 | トリガー |
 |--------|------|------|----------|----------|
-| **Level 1** | 世代フォルダ（5つの成果物） | `gen-XXX.md` | 40行 | lineage > 5,000行 + 5世代以上 |
+| **Level 1** | 世代フォルダ（5つの成果物） | `gen-XXX-{hash}.md` | 40行 | lineage > 5,000行 + 5世代以上 |
 | **Level 2** | Level 1ファイル5つ | `epoch-XXX.md` | 60行 | Level 1が5つ以上 |
 
 圧縮は世代完了時に自動実行されます。直近3世代は常に圧縮から保護されます。圧縮されたファイルは目標（Objective）と結果（Completion）を中心に保存し、中間過程は特記事項のみを残します。

package/README.ko.md

@@ -130,7 +130,7 @@ Application의 유전 정보 — 아키텍처 원칙, 비즈니스 규칙, 개
 각 항목은 `status` 필드도 가집니다:
 
 - `status: pending` — 미처리 항목 (기본값)
-- `status: consumed` — 현재 세대에서 처리 완료 (`consumedBy: gen-XXX` 필수)
+- `status: consumed` — 현재 세대에서 처리 완료 (`consumedBy: gen-XXX-{hash}` 필수)
 
 아카이빙 시점(`/reap.next` from Completion)에 `consumed` 항목은 lineage로 이동하고, `pending` 항목은 다음 세대 backlog로 이월됩니다.
 
@@ -287,7 +287,7 @@ my-project/
 
 | 레벨 | 입력 | 출력 | 최대 줄 수 | 트리거 |
 |------|------|------|-----------|--------|
-| **Level 1** | 세대 폴더 (5개 산출물) | `gen-XXX.md` | 40줄 | lineage > 5,000줄 + 5세대 이상 |
+| **Level 1** | 세대 폴더 (5개 산출물) | `gen-XXX-{hash}.md` | 40줄 | lineage > 5,000줄 + 5세대 이상 |
 | **Level 2** | Level 1 파일 5개 | `epoch-XXX.md` | 60줄 | Level 1이 5개 이상 |
 
 압축은 세대 완료 시 자동 실행됩니다. 가장 최근 3개 세대는 항상 압축에서 보호됩니다. 압축된 파일은 목표(Objective)와 결과(Completion)를 중심으로 보존하고, 중간 과정은 특이사항만 남깁니다.

package/README.md

@@ -129,7 +129,7 @@ All items to be addressed next are stored in `.reap/life/backlog/`. Each item us
 Each item also carries a `status` field:
 
 - `status: pending` — Not yet processed (default)
-- `status: consumed` — Processed in the current generation (requires `consumedBy: gen-XXX`)
+- `status: consumed` — Processed in the current generation (requires `consumedBy: gen-XXX-{hash}`)
 
 At archiving time (`/reap.next` from Completion), `consumed` items move to lineage while `pending` items are carried forward to the next generation's backlog.
 
@@ -286,7 +286,7 @@ As generations accumulate, the lineage directory grows. REAP manages this with a
 
 | Level | Input | Output | Max lines | Trigger |
 |-------|-------|--------|-----------|---------|
-| **Level 1** | Generation folder (5 artifacts) | `gen-XXX.md` | 40 lines | lineage > 5,000 lines + 5+ generations |
+| **Level 1** | Generation folder (5 artifacts) | `gen-XXX-{hash}.md` | 40 lines | lineage > 5,000 lines + 5+ generations |
 | **Level 2** | 5 Level 1 files | `epoch-XXX.md` | 60 lines | 5+ Level 1 files |
 
 Compression runs automatically when a generation completes. The most recent 3 generations are always protected from compression. Compressed files preserve objectives and completion results while retaining only notable findings from intermediate stages.

package/README.zh-CN.md

@@ -130,7 +130,7 @@ Objective → Planning → Implementation ⟷ Validation → Completion
 每个项目还有`status`字段：
 
 - `status: pending` — 未处理项目（默认）
-- `status: consumed` — 在当前世代中已处理（需要`consumedBy: gen-XXX`）
+- `status: consumed` — 在当前世代中已处理（需要`consumedBy: gen-XXX-{hash}`）
 
 归档时（`/reap.next` from Completion），`consumed`项目移至lineage，`pending`项目结转到下一个世代的backlog。
 
@@ -287,7 +287,7 @@ my-project/
 
 | 级别 | 输入 | 输出 | 最大行数 | 触发条件 |
 |------|------|------|----------|----------|
-| **Level 1** | 世代文件夹（5个产出物） | `gen-XXX.md` | 40行 | lineage > 5,000行 + 5个以上世代 |
+| **Level 1** | 世代文件夹（5个产出物） | `gen-XXX-{hash}.md` | 40行 | lineage > 5,000行 + 5个以上世代 |
 | **Level 2** | 5个Level 1文件 | `epoch-XXX.md` | 60行 | Level 1达到5个以上 |
 
 压缩在世代完成时自动执行。最近3个世代始终受到保护，不会被压缩。压缩后的文件以目标（Objective）和结果（Completion）为中心保存，中间过程仅保留特别事项。

package/dist/cli.js

@@ -9497,8 +9497,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 readdir7, unlink as unlink3, rm as rm2, mkdir as mkdir6 } from "fs/promises";
+import { join as join8 } from "path";
 
 // src/core/hooks.ts
 async function migrateHooks(dryRun = false) {
@@ -9513,148 +9513,17 @@ 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_yaml4 = __toESM(require_dist(), 1);
+import { readdir as readdir6, rename as rename2 } from "fs/promises";
+import { join as join7 } from "path";
 
 // src/core/generation.ts
-var import_yaml2 = __toESM(require_dist(), 1);
-import { readdir as readdir6, mkdir as mkdir5, rename } from "fs/promises";
-import { join as join7 } from "path";
+var import_yaml3 = __toESM(require_dist(), 1);
+import { createHash } from "crypto";
+import { hostname } from "os";
+import { readdir as readdir5, mkdir as mkdir4, rename } from "fs/promises";
+import { join as join6 } from "path";
 
 // src/types/index.ts
 var LIFECYCLE_ORDER = [
@@ -9708,14 +9577,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 +9616,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 +9628,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 +9746,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 +9759,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 +9779,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 +9790,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 +9843,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 +9866,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 +9895,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 +9920,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++;
@@ -9963,6 +9936,46 @@ async function compressLineageIfNeeded(paths) {
 }
 
 // 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 readdir5(genomePath, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).sort((a, b) => {
+      const pathA = join6(e2path(a), a.name);
+      const pathB = join6(e2path(b), b.name);
+      return pathA.localeCompare(pathB);
+    });
+    for (const entry of entries) {
+      const filePath = join6(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 +9985,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_yaml3.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_yaml3.default.stringify(state));
     return state;
   }
   async advance() {
@@ -9999,7 +10025,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_yaml3.default.stringify(state));
     return state;
   }
   async complete() {
@@ -10008,31 +10034,43 @@ 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 });
-    const lifeEntries = await readdir6(this.paths.life);
+    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(join6(genDir, "meta.yml"), import_yaml3.default.stringify(meta));
+    const lifeEntries = await readdir5(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(join6(this.paths.life, entry), join6(genDir, entry));
       }
     }
-    const backlogDir = join7(genDir, "backlog");
-    await mkdir5(backlogDir, { recursive: true });
+    const backlogDir = join6(genDir, "backlog");
+    await mkdir4(backlogDir, { recursive: true });
     try {
-      const backlogEntries = await readdir6(this.paths.backlog);
+      const backlogEntries = await readdir5(this.paths.backlog);
       for (const entry of backlogEntries) {
-        await rename(join7(this.paths.backlog, entry), join7(backlogDir, entry));
+        await rename(join6(this.paths.backlog, entry), join6(backlogDir, entry));
       }
     } catch {}
     try {
-      const mutEntries = await readdir6(this.paths.mutations);
+      const mutEntries = await readdir5(this.paths.mutations);
       if (mutEntries.length > 0) {
-        const mutDir = join7(genDir, "mutations");
-        await mkdir5(mutDir, { recursive: true });
+        const mutDir = join6(genDir, "mutations");
+        await mkdir4(mutDir, { recursive: true });
         for (const entry of mutEntries) {
-          await rename(join7(this.paths.mutations, entry), join7(mutDir, entry));
+          await rename(join6(this.paths.mutations, entry), join6(mutDir, entry));
         }
       }
     } catch {}
@@ -10041,32 +10079,333 @@ class GenerationManager {
     return compression;
   }
   async save(state) {
-    await writeTextFile(this.paths.currentYml, import_yaml2.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml3.default.stringify(state));
   }
   async listCompleted() {
     try {
-      const entries = await readdir6(this.paths.lineage);
+      const entries = await readdir5(this.paths.lineage);
       return entries.filter((e) => e.startsWith("gen-")).sort();
     } catch {
       return [];
     }
   }
-  async nextGenId() {
+  async readMeta(lineageDirName) {
+    const metaPath = join6(this.paths.lineage, lineageDirName, "meta.yml");
+    const content = await readTextFile(metaPath);
+    if (content === null)
+      return null;
+    return import_yaml3.default.parse(content);
+  }
+  async listMeta() {
+    const metas = [];
+    try {
+      const entries = await readdir5(this.paths.lineage, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith("gen-")) {
+          const meta = await this.readMeta(entry.name);
+          if (meta)
+            metas.push(meta);
+        } else if (entry.isFile() && entry.name.startsWith("gen-") && entry.name.endsWith(".md")) {
+          const content = await readTextFile(join6(this.paths.lineage, entry.name));
+          if (content) {
+            const meta = parseFrontmatter(content);
+            if (meta)
+              metas.push(meta);
+          }
+        }
+      }
+    } catch {}
+    return metas;
+  }
+  async resolveParents() {
+    const metas = await this.listMeta();
+    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 this.listCompleted();
+    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 [];
+  }
+  async nextSeq() {
     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")}`;
+        return parseGenSeq(current.id) + 1;
       }
-      return "gen-001";
+      return 1;
+    }
+    let maxSeq = 0;
+    for (const dir of genDirs) {
+      const seq = parseGenSeq(dir);
+      if (seq > maxSeq)
+        maxSeq = seq;
     }
-    const last = genDirs[genDirs.length - 1];
-    const num = parseInt(last.replace("gen-", ""), 10);
-    return `gen-${String(num + 1).padStart(3, "0")}`;
+    return maxSeq + 1;
+  }
+  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 readdir6(paths.lineage, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || !entry.name.startsWith("gen-"))
+        continue;
+      const metaPath = join7(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 readdir6(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 = join7(paths.lineage, dirName, "meta.yml");
+    const metaContent = await readTextFile(metaPath);
+    const seq = parseGenSeq(dirName);
+    let goal = "";
+    const objContent = await readTextFile(join7(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(join7(paths.lineage, entry.dirName, "meta.yml"));
+      if (metaContent) {
+        const meta = import_yaml4.default.parse(metaContent);
+        prevId = meta.id;
+      }
+      result.skipped.push(entry.dirName);
+      continue;
+    }
+    try {
+      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(join7(paths.lineage, entry.dirName, "meta.yml"), import_yaml4.default.stringify(meta));
+      const oldSlug = entry.dirName.replace(/^gen-\d{3}/, "");
+      const newDirName = `${newId}${oldSlug}`;
+      if (newDirName !== entry.dirName) {
+        await rename2(join7(paths.lineage, entry.dirName), join7(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)}`);
+    }
+  }
+  try {
+    const currentContent = await readTextFile(paths.currentYml);
+    if (currentContent && currentContent.trim()) {
+      const state = import_yaml4.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_yaml4.default.stringify(state));
+        result.migrated.push(`current.yml: ${state.id}`);
+      }
+    }
+  } 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 readdir7(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(join8(commandsDir, file));
+      const dest = join8(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(join8(ReapPaths.packageArtifactsDir, file));
+    const dest = join8(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(join8(ReapPaths.packageGenomeDir, "domain/README.md"));
+  const domainGuideDest = join8(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);
+  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 readdir7(claudeCmdDir);
+    for (const file of files) {
+      if (file.startsWith("reap.") && file.endsWith(".md")) {
+        if (!dryRun)
+          await unlink3(join8(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 readdir7(dirPath);
+    if (entries.length > 0 || true) {
+      if (!dryRun)
+        await rm2(dirPath, { recursive: true });
+      result.removed.push(label);
+    }
+  } catch {}
+}
+
 // src/cli/commands/status.ts
 async function getStatus(projectRoot) {
   const paths = new ReapPaths(projectRoot);
@@ -10082,15 +10421,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_yaml5 = __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 +10455,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 +10466,7 @@ async function fixProject(projectRoot) {
   if (currentContent !== null) {
     if (currentContent.trim()) {
       try {
-        const state = import_yaml3.default.parse(currentContent);
+        const state = import_yaml5.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 +10475,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 +10488,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.4");
+import { join as join9 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.4.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 +10611,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 = join9(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join9(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join8(helpDir, "en.txt"));
+    helpText = await readTextFile(join9(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;

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

@@ -69,7 +69,7 @@ Do NOT finalize Genome changes without running Validation Commands.
 15. **Human confirmation**:
     - **If called from `/reap.evolve`** (Autonomous Override active): Apply genome changes automatically after Validation Commands pass. Do NOT pause for human confirmation.
     - **If called standalone**: Show the modified genome/environment content to the human and get approval. Do NOT finalize changes until the human approves.
-16. For each applied `type: genome-change` and `type: environment-change` backlog item, update its frontmatter to `status: consumed` and add `consumedBy: gen-XXX`
+16. For each applied `type: genome-change` and `type: environment-change` backlog item, update its frontmatter to `status: consumed` and add `consumedBy: gen-XXX-{hash}`
 
 ### Phase 5: Hook Suggestion
 

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

@@ -15,16 +15,16 @@ description: "REAP Start — Start a new Generation"
 - If backlog items exist:
   - Present the list with title and priority for each item
   - Ask: "Would you like to select one of these, or enter a new goal?"
-  - If the human selects a backlog item: use its title/content as the goal, then update the selected item's frontmatter to `status: consumed` and add `consumedBy: gen-XXX`
+  - If the human selects a backlog item: use its title/content as the goal, then update the selected item's frontmatter to `status: consumed` and add `consumedBy: gen-XXX-{hash}`
   - If the human wants a new goal: proceed to Step 1
 - If no backlog items exist: proceed to Step 1
 
 1. Ask the human for the goal of this generation
 2. Count existing generations in `.reap/lineage/` to determine the genomeVersion
-3. Generate the next generation ID (existing count + 1, in `gen-XXX` format)
+3. Generate the next generation ID (existing count + 1, in `gen-XXX-{hash}` format where `{hash}` is a short content hash)
 4. Write the following to `current.yml`:
    ```yaml
-   id: gen-XXX
+   id: gen-XXX-{hash}
    goal: [goal provided by the human]
    stage: objective
    genomeVersion: [generation count + 1]
@@ -49,4 +49,4 @@ description: "REAP Start — Start a new Generation"
         - `.sh`: run as shell script in the project root directory
 
 ## Completion
-- "Generation gen-XXX started. Proceed with `/reap.objective` to define the goal, or `/reap.evolve` to run the full lifecycle."
+- "Generation gen-XXX-{hash} started. Proceed with `/reap.objective` to define the goal, or `/reap.evolve` to run the full lifecycle."

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

@@ -66,7 +66,7 @@ All items to be carried forward to the next generation are stored in `.reap/life
 
 Each item also carries a `status` field:
 - `status: pending` — Not yet processed (default; absent field treated as pending)
-- `status: consumed` — Processed in the current generation (requires `consumedBy: gen-XXX`)
+- `status: consumed` — Processed in the current generation (requires `consumedBy: gen-XXX-{hash}`)
 
 Marking rules:
 - `/reap.start`: backlog items chosen as the generation's goal → mark `consumed`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c-d-cc/reap",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "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);
+}