@c-d-cc/reap 0.15.2 → 0.15.3

package/dist/cli.js

@@ -9073,8 +9073,8 @@ var exports_genome_sync = {};
 __export(exports_genome_sync, {
   syncGenomeFromProject: () => syncGenomeFromProject
 });
-import { join as join5 } from "path";
-import { readdir as readdir4, stat as stat2 } from "fs/promises";
+import { join as join6 } from "path";
+import { readdir as readdir5, stat as stat2 } from "fs/promises";
 async function scanProject(projectRoot) {
   const scan = {
     language: "Unknown",
@@ -9093,7 +9093,7 @@ async function scanProject(projectRoot) {
     directories: [],
     existingDocs: []
   };
-  const pkgContent = await readTextFile(join5(projectRoot, "package.json"));
+  const pkgContent = await readTextFile(join6(projectRoot, "package.json"));
   if (pkgContent) {
     try {
       const pkg = JSON.parse(pkgContent);
@@ -9152,16 +9152,16 @@ async function scanProject(projectRoot) {
         scan.buildTool = "Turbopack";
     } catch {}
   }
-  if (await fileExists(join5(projectRoot, "go.mod"))) {
+  if (await fileExists(join6(projectRoot, "go.mod"))) {
     scan.language = "Go";
     scan.runtime = "Go";
     scan.packageManager = "Go Modules";
   }
-  if (await fileExists(join5(projectRoot, "pyproject.toml")) || await fileExists(join5(projectRoot, "requirements.txt"))) {
+  if (await fileExists(join6(projectRoot, "pyproject.toml")) || await fileExists(join6(projectRoot, "requirements.txt"))) {
     scan.language = "Python";
     scan.runtime = "Python";
-    if (await fileExists(join5(projectRoot, "pyproject.toml"))) {
-      const pyproject = await readTextFile(join5(projectRoot, "pyproject.toml"));
+    if (await fileExists(join6(projectRoot, "pyproject.toml"))) {
+      const pyproject = await readTextFile(join6(projectRoot, "pyproject.toml"));
       if (pyproject?.includes("[tool.poetry]"))
         scan.packageManager = "Poetry";
       else if (pyproject?.includes("[tool.uv]") || pyproject?.includes("[project]"))
@@ -9176,23 +9176,23 @@ async function scanProject(projectRoot) {
         scan.framework = "Flask";
     }
   }
-  if (await fileExists(join5(projectRoot, "Cargo.toml"))) {
+  if (await fileExists(join6(projectRoot, "Cargo.toml"))) {
     scan.language = "Rust";
     scan.runtime = "Rust";
     scan.packageManager = "Cargo";
   }
-  if (await fileExists(join5(projectRoot, "tsconfig.json"))) {
+  if (await fileExists(join6(projectRoot, "tsconfig.json"))) {
     scan.hasTypeScript = true;
     scan.language = "TypeScript";
   }
-  scan.hasDocker = await fileExists(join5(projectRoot, "Dockerfile")) || await fileExists(join5(projectRoot, "docker-compose.yml"));
+  scan.hasDocker = await fileExists(join6(projectRoot, "Dockerfile")) || await fileExists(join6(projectRoot, "docker-compose.yml"));
   try {
-    const entries = await readdir4(projectRoot);
+    const entries = await readdir5(projectRoot);
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules")
         continue;
       try {
-        const s = await stat2(join5(projectRoot, entry));
+        const s = await stat2(join6(projectRoot, entry));
         if (s.isDirectory())
           scan.directories.push(entry);
       } catch {}
@@ -9200,7 +9200,7 @@ async function scanProject(projectRoot) {
   } catch {}
   const docFiles = ["README.md", "CLAUDE.md", "AGENTS.md", "CONTRIBUTING.md", "ARCHITECTURE.md"];
   for (const file of docFiles) {
-    const content = await readTextFile(join5(projectRoot, file));
+    const content = await readTextFile(join6(projectRoot, file));
     if (content) {
       scan.existingDocs.push({ file, content: content.substring(0, 2000) });
     }
@@ -9329,17 +9329,17 @@ async function syncGenomeFromProject(projectRoot, genomePath, onProgress) {
   log(`Detected: ${scan.language}, ${scan.framework !== "None" ? scan.framework : "no framework"}, ${scan.packageManager}`);
   const { writeTextFile: writeTextFile2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
   log("Generating constraints.md...");
-  await writeTextFile2(join5(genomePath, "constraints.md"), generateConstraints(scan));
+  await writeTextFile2(join6(genomePath, "constraints.md"), generateConstraints(scan));
   log("Generating conventions.md...");
-  await writeTextFile2(join5(genomePath, "conventions.md"), generateConventions(scan));
+  await writeTextFile2(join6(genomePath, "conventions.md"), generateConventions(scan));
   log("Generating principles.md...");
-  await writeTextFile2(join5(genomePath, "principles.md"), generatePrinciples(scan));
+  await writeTextFile2(join6(genomePath, "principles.md"), generatePrinciples(scan));
   log("Generating source-map.md...");
-  await writeTextFile2(join5(genomePath, "source-map.md"), generateSourceMap(scan));
-  const { mkdir: mkdir4 } = await import("fs/promises");
-  const domainDir = join5(genomePath, "domain");
-  await mkdir4(domainDir, { recursive: true });
-  const domainReadme = join5(domainDir, "README.md");
+  await writeTextFile2(join6(genomePath, "source-map.md"), generateSourceMap(scan));
+  const { mkdir: mkdir5 } = await import("fs/promises");
+  const domainDir = join6(genomePath, "domain");
+  await mkdir5(domainDir, { recursive: true });
+  const domainReadme = join6(domainDir, "README.md");
   if (!await fileExists(domainReadme)) {
     await writeTextFile2(domainReadme, [
       "# Domain Rules",
@@ -9482,8 +9482,8 @@ function gitCurrentBranch(cwd) {
 var init_git = () => {};
 
 // src/core/compression.ts
-import { readdir as readdir6, rm } from "fs/promises";
-import { join as join7 } from "path";
+import { readdir as readdir7, rm as rm2 } from "fs/promises";
+import { join as join8 } from "path";
 function safeCompletedAtTime(dateStr) {
   const t = new Date(dateStr).getTime();
   return Number.isNaN(t) ? 0 : t;
@@ -9518,9 +9518,9 @@ async function countLines(filePath) {
 async function countDirLines(dirPath) {
   let total = 0;
   try {
-    const entries = await readdir6(dirPath, { withFileTypes: true });
+    const entries = await readdir7(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join7(dirPath, entry.name);
+      const fullPath = join8(dirPath, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         total += await countLines(fullPath);
       } else if (entry.isDirectory()) {
@@ -9531,7 +9531,7 @@ async function countDirLines(dirPath) {
   return total;
 }
 async function readDirMeta(dirPath) {
-  const content = await readTextFile(join7(dirPath, "meta.yml"));
+  const content = await readTextFile(join8(dirPath, "meta.yml"));
   if (content === null)
     return null;
   try {
@@ -9549,9 +9549,9 @@ async function readFileMeta(filePath) {
 async function scanLineage(paths) {
   const entries = [];
   try {
-    const items = await readdir6(paths.lineage, { withFileTypes: true });
+    const items = await readdir7(paths.lineage, { withFileTypes: true });
     for (const item of items) {
-      const fullPath = join7(paths.lineage, item.name);
+      const fullPath = join8(paths.lineage, item.name);
       if (item.isDirectory() && item.name.startsWith("gen-")) {
         const genNum = extractGenNum(item.name);
         const lines = await countDirLines(fullPath);
@@ -9606,7 +9606,7 @@ async function findLeafNodes(paths, entries) {
     if (entry.type === "level2")
       continue;
     let meta = null;
-    const fullPath = join7(paths.lineage, entry.name);
+    const fullPath = join8(paths.lineage, entry.name);
     if (entry.type === "dir") {
       meta = await readDirMeta(fullPath);
     } else {
@@ -9637,7 +9637,7 @@ async function compressLevel1(genDir, genName) {
   }
   let goal = "", completionConditions = "";
   {
-    const objective = await readTextFile(join7(genDir, "01-objective.md"));
+    const objective = await readTextFile(join8(genDir, "01-objective.md"));
     if (objective) {
       const goalMatch = objective.match(/## Goal\n([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -9649,7 +9649,7 @@ async function compressLevel1(genDir, genName) {
   }
   let lessons = "", genomeChanges = "", nextBacklog = "";
   {
-    const completion = await readTextFile(join7(genDir, "05-completion.md"));
+    const completion = await readTextFile(join8(genDir, "05-completion.md"));
     if (completion) {
       const lessonsMatch = completion.match(/### Lessons Learned\n([\s\S]*?)(?=\n###)/);
       if (lessonsMatch)
@@ -9664,7 +9664,7 @@ async function compressLevel1(genDir, genName) {
   }
   let summaryText = "";
   {
-    const completion = await readTextFile(join7(genDir, "05-completion.md"));
+    const completion = await readTextFile(join8(genDir, "05-completion.md"));
     if (completion) {
       const summaryMatch = completion.match(/## Summary\n([\s\S]*?)(?=\n##)/);
       if (summaryMatch)
@@ -9673,7 +9673,7 @@ async function compressLevel1(genDir, genName) {
   }
   let validationResult = "";
   {
-    const validation = await readTextFile(join7(genDir, "04-validation.md"));
+    const validation = await readTextFile(join8(genDir, "04-validation.md"));
     if (validation) {
       const resultMatch = validation.match(/## Result: (.+)/);
       if (resultMatch)
@@ -9682,7 +9682,7 @@ async function compressLevel1(genDir, genName) {
   }
   let deferred = "";
   {
-    const impl = await readTextFile(join7(genDir, "03-implementation.md"));
+    const impl = await readTextFile(join8(genDir, "03-implementation.md"));
     if (impl) {
       const deferredMatch = impl.match(/## Deferred Tasks\n([\s\S]*?)(?=\n##)/);
       if (deferredMatch) {
@@ -9768,7 +9768,7 @@ async function findForkedByOtherBranches(paths, cwd) {
 }
 async function compressLevel2Single(level1Files, paths) {
   const compressed = [];
-  const epochPath = join7(paths.lineage, "epoch.md");
+  const epochPath = join8(paths.lineage, "epoch.md");
   let existingMeta = { generations: [] };
   let existingBody = "";
   const existingContent = await readTextFile(epochPath);
@@ -9817,7 +9817,7 @@ ${import_yaml2.default.stringify(existingMeta).trim()}
   await writeTextFile(epochPath, frontmatter + header + body.trim() + `
 `);
   for (const file of level1Files) {
-    await rm(file.path);
+    await rm2(file.path);
   }
   return compressed;
 }
@@ -9840,12 +9840,12 @@ async function compressLineageIfNeeded(paths, projectRoot) {
     const currentTotal = await countDirLines(paths.lineage);
     if (currentTotal <= LINEAGE_MAX_LINES)
       break;
-    const dirPath = join7(paths.lineage, dir.name);
+    const dirPath = join8(paths.lineage, dir.name);
     const compressed = await compressLevel1(dirPath, dir.name);
     const genId = dir.name.match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? dir.name;
-    const outPath = join7(paths.lineage, `${genId}.md`);
+    const outPath = join8(paths.lineage, `${genId}.md`);
     await writeTextFile(outPath, compressed);
-    await rm(dirPath, { recursive: true });
+    await rm2(dirPath, { recursive: true });
     result.level1.push(genId);
   }
   const level1s = (await scanLineage(paths)).filter((e) => e.type === "level1");
@@ -9864,8 +9864,8 @@ async function compressLineageIfNeeded(paths, projectRoot) {
     if (compressible.length > 0) {
       const filesWithMeta = await Promise.all(compressible.map(async (e) => ({
         name: e.name,
-        path: join7(paths.lineage, e.name),
-        meta: await readFileMeta(join7(paths.lineage, e.name))
+        path: join8(paths.lineage, e.name),
+        meta: await readFileMeta(join8(paths.lineage, e.name))
       })));
       const compressed = await compressLevel2Single(filesWithMeta, paths);
       result.level2.push(...compressed);
@@ -9881,18 +9881,40 @@ var init_compression = __esm(() => {
 });
 
 // src/core/lineage.ts
-import { readdir as readdir7 } from "fs/promises";
-import { join as join8 } from "path";
+import { readdir as readdir8 } from "fs/promises";
+import { join as join9 } from "path";
 async function listCompleted(paths) {
   try {
-    const entries = await readdir7(paths.lineage);
+    const entries = await readdir8(paths.lineage);
     return entries.filter((e) => e.startsWith("gen-")).sort();
   } catch {
     return [];
   }
 }
+async function listEpochGenerations(paths) {
+  const epochPath = join9(paths.lineage, "epoch.md");
+  const content = await readTextFile(epochPath);
+  if (!content)
+    return [];
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match)
+    return [];
+  try {
+    const meta = import_yaml3.default.parse(match[1]);
+    if (!meta?.generations)
+      return [];
+    return meta.generations.map((g) => g.id).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function countAllCompleted(paths) {
+  const genDirs = await listCompleted(paths);
+  const epochGens = await listEpochGenerations(paths);
+  return genDirs.length + epochGens.length;
+}
 async function readMeta(paths, lineageDirName) {
-  const metaPath = join8(paths.lineage, lineageDirName, "meta.yml");
+  const metaPath = join9(paths.lineage, lineageDirName, "meta.yml");
   const content = await readTextFile(metaPath);
   if (content === null)
     return null;
@@ -9901,14 +9923,14 @@ async function readMeta(paths, lineageDirName) {
 async function listMeta(paths) {
   const metas = [];
   try {
-    const entries = await readdir7(paths.lineage, { withFileTypes: true });
+    const entries = await readdir8(paths.lineage, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith("gen-")) {
         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(join8(paths.lineage, entry.name));
+        const content = await readTextFile(join9(paths.lineage, entry.name));
         if (content) {
           const meta = parseFrontmatter(content);
           if (meta)
@@ -9921,21 +9943,25 @@ async function listMeta(paths) {
 }
 async function nextSeq(paths, currentId) {
   const genDirs = await listCompleted(paths);
-  if (genDirs.length === 0) {
+  const epochGens = await listEpochGenerations(paths);
+  const allIds = [...genDirs, ...epochGens];
+  if (allIds.length === 0) {
     if (currentId) {
       return parseGenSeq(currentId) + 1;
     }
     return 1;
   }
   let maxSeq = 0;
-  for (const dir of genDirs) {
-    const seq = parseGenSeq(dir);
+  for (const id of allIds) {
+    const seq = parseGenSeq(id);
     if (seq > maxSeq)
       maxSeq = seq;
   }
   return maxSeq + 1;
 }
 function safeCompletedAtTime2(dateStr) {
+  if (!ISO_DATE_RE.test(dateStr))
+    return 0;
   const t = new Date(dateStr).getTime();
   return Number.isNaN(t) ? 0 : t;
 }
@@ -9954,27 +9980,28 @@ async function resolveParents(paths) {
   }
   return [];
 }
-var import_yaml3;
+var import_yaml3, ISO_DATE_RE;
 var init_lineage = __esm(() => {
   init_fs();
   init_compression();
   init_generation();
   import_yaml3 = __toESM(require_dist(), 1);
+  ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
 });
 
 // src/core/generation.ts
 import { createHash, randomBytes } from "crypto";
 import { hostname } from "os";
-import { readdir as readdir8, mkdir as mkdir5, rename, unlink as unlink3 } from "fs/promises";
-import { join as join9 } from "path";
+import { readdir as readdir9, mkdir as mkdir6, rename, unlink as unlink4 } from "fs/promises";
+import { join as join10 } from "path";
 function generateToken(genId, stage, phase) {
   const nonce = randomBytes(16).toString("hex");
-  const input = phase ? `${nonce}${genId}${stage}:${phase}` : `${nonce}${genId}${stage}`;
+  const input = `${nonce}${genId}${stage}:${phase}`;
   const hash = createHash("sha256").update(input).digest("hex");
   return { nonce, hash };
 }
 function verifyToken(token, genId, stage, expectedHash, phase) {
-  const input = phase ? `${token}${genId}${stage}:${phase}` : `${token}${genId}${stage}`;
+  const input = `${token}${genId}${stage}:${phase}`;
   return createHash("sha256").update(input).digest("hex") === expectedHash;
 }
 function generateGenHash(parents, goal, genomeHash, machineId, startedAt) {
@@ -9987,13 +10014,13 @@ function getMachineId() {
 async function computeGenomeHash(genomePath) {
   const hash = createHash("sha256");
   try {
-    const entries = (await readdir8(genomePath, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).sort((a, b) => {
-      const pathA = join9(e2path(a), a.name);
-      const pathB = join9(e2path(b), b.name);
+    const entries = (await readdir9(genomePath, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).sort((a, b) => {
+      const pathA = join10(e2path(a), a.name);
+      const pathB = join10(e2path(b), b.name);
       return pathA.localeCompare(pathB);
     });
     for (const entry of entries) {
-      const filePath = join9(e2path(entry), entry.name);
+      const filePath = join10(e2path(entry), entry.name);
       const content = await readTextFile(filePath);
       if (content !== null) {
         hash.update(filePath.replace(genomePath, ""));
@@ -10106,7 +10133,7 @@ class GenerationManager {
     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 mkdir6(genDir, { recursive: true });
     const meta = {
       id: state.id,
       type: state.type ?? "normal",
@@ -10117,42 +10144,42 @@ class GenerationManager {
       completedAt: now,
       ...state.type === "recovery" && state.recovers ? { recovers: state.recovers } : {}
     };
-    await writeTextFile(join9(genDir, "meta.yml"), import_yaml4.default.stringify(meta));
-    const lifeEntries = await readdir8(this.paths.life);
+    await writeTextFile(join10(genDir, "meta.yml"), import_yaml4.default.stringify(meta));
+    const lifeEntries = await readdir9(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-        const srcPath = join9(this.paths.life, entry);
-        const destPath = join9(genDir, entry);
+        const srcPath = join10(this.paths.life, entry);
+        const destPath = join10(genDir, entry);
         let content = await readTextFile(srcPath);
         if (content && content.startsWith("# REAP MANAGED")) {
           content = content.replace(/^# REAP MANAGED[^\n]*\n/, "");
         }
         await writeTextFile(destPath, content ?? "");
-        await unlink3(srcPath);
+        await unlink4(srcPath);
       }
     }
-    const backlogDir = join9(genDir, "backlog");
-    await mkdir5(backlogDir, { recursive: true });
+    const backlogDir = join10(genDir, "backlog");
+    await mkdir6(backlogDir, { recursive: true });
     try {
-      const backlogEntries = await readdir8(this.paths.backlog);
+      const backlogEntries = await readdir9(this.paths.backlog);
       for (const entry of backlogEntries) {
-        const content = await readTextFile(join9(this.paths.backlog, entry));
+        const content = await readTextFile(join10(this.paths.backlog, entry));
         if (!content)
           continue;
         const isConsumed = /status:\s*consumed/i.test(content) || /consumed:\s*true/i.test(content);
-        await writeTextFile(join9(backlogDir, entry), content);
+        await writeTextFile(join10(backlogDir, entry), content);
         if (isConsumed) {
-          await unlink3(join9(this.paths.backlog, entry));
+          await unlink4(join10(this.paths.backlog, entry));
         }
       }
     } catch {}
     try {
-      const mutEntries = await readdir8(this.paths.mutations);
+      const mutEntries = await readdir9(this.paths.mutations);
       if (mutEntries.length > 0) {
-        const mutDir = join9(genDir, "mutations");
-        await mkdir5(mutDir, { recursive: true });
+        const mutDir = join10(genDir, "mutations");
+        await mkdir6(mutDir, { recursive: true });
         for (const entry of mutEntries) {
-          await rename(join9(this.paths.mutations, entry), join9(mutDir, entry));
+          await rename(join10(this.paths.mutations, entry), join10(mutDir, entry));
         }
       }
     } catch {}
@@ -10166,6 +10193,9 @@ class GenerationManager {
   async listCompleted() {
     return listCompleted(this.paths);
   }
+  async countAllCompleted() {
+    return countAllCompleted(this.paths);
+  }
   async readMeta(lineageDirName) {
     return readMeta(this.paths, lineageDirName);
   }
@@ -10195,10 +10225,10 @@ var init_generation = __esm(() => {
 });
 
 // src/core/version.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function checkLatestVersion() {
   try {
-    const result = execSync3("npm view @c-d-cc/reap version", {
+    const result = execSync4("npm view @c-d-cc/reap version", {
       timeout: 2000,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -10323,13 +10353,13 @@ var init_merge_lifecycle = __esm(() => {
 
 // src/core/hook-engine.ts
 import { readdir as readdir14 } from "fs/promises";
-import { join as join16 } from "path";
-import { execSync as execSync4 } from "child_process";
+import { join as join17 } from "path";
+import { execSync as execSync5 } from "child_process";
 async function executeHooks(hooksDir, event, projectRoot) {
   const hooks = await scanHooks(hooksDir, event);
   if (hooks.length === 0)
     return [];
-  const conditionsDir = join16(hooksDir, "conditions");
+  const conditionsDir = join17(hooksDir, "conditions");
   const results = [];
   for (const hook of hooks) {
     const conditionMet = await evaluateCondition(conditionsDir, hook.condition, projectRoot);
@@ -10364,7 +10394,7 @@ async function scanHooks(hooksDir, event) {
     const match = filename.match(pattern);
     if (!match)
       continue;
-    const meta = await parseHookMeta(join16(hooksDir, filename), match[2]);
+    const meta = await parseHookMeta(join17(hooksDir, filename), match[2]);
     hooks.push({
       filename,
       name: match[1],
@@ -10385,7 +10415,7 @@ async function parseHookMeta(filePath, ext) {
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (fmMatch) {
       try {
-        const fm = import_yaml9.default.parse(fmMatch[1]) ?? {};
+        const fm = import_yaml8.default.parse(fmMatch[1]) ?? {};
         return {
           condition: String(fm.condition ?? "always"),
           order: Number(fm.order ?? 50)
@@ -10411,12 +10441,12 @@ async function parseHookMeta(filePath, ext) {
 async function evaluateCondition(conditionsDir, conditionName, projectRoot) {
   if (conditionName === "always")
     return { met: true };
-  const scriptPath = join16(conditionsDir, `${conditionName}.sh`);
+  const scriptPath = join17(conditionsDir, `${conditionName}.sh`);
   if (!await fileExists(scriptPath)) {
     return { met: false, reason: `condition script not found: ${conditionName}.sh` };
   }
   try {
-    execSync4(`bash "${scriptPath}"`, { cwd: projectRoot, timeout: 1e4, stdio: "pipe" });
+    execSync5(`bash "${scriptPath}"`, { cwd: projectRoot, timeout: 1e4, stdio: "pipe" });
     return { met: true };
   } catch {
     return { met: false, reason: `condition '${conditionName}' returned non-zero` };
@@ -10424,7 +10454,7 @@ async function evaluateCondition(conditionsDir, conditionName, projectRoot) {
 }
 async function executeShHook(hook, event, projectRoot, hooksDir) {
   try {
-    const stdout = execSync4(`bash "${join16(hooksDir, hook.filename)}"`, {
+    const stdout = execSync5(`bash "${join17(hooksDir, hook.filename)}"`, {
       cwd: projectRoot,
       timeout: 60000,
       stdio: "pipe"
@@ -10450,7 +10480,7 @@ async function executeShHook(hook, event, projectRoot, hooksDir) {
   }
 }
 async function executeMdHook(hook, event, hooksDir) {
-  const content = await readTextFile(join16(hooksDir, hook.filename));
+  const content = await readTextFile(join17(hooksDir, hook.filename));
   const body = content?.replace(/^---\n[\s\S]*?\n---\n?/, "").trim() ?? "";
   return {
     name: hook.name,
@@ -10460,10 +10490,10 @@ async function executeMdHook(hook, event, hooksDir) {
     content: body
   };
 }
-var import_yaml9;
+var import_yaml8;
 var init_hook_engine = __esm(() => {
   init_fs();
-  import_yaml9 = __toESM(require_dist(), 1);
+  import_yaml8 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/back.ts
@@ -10568,9 +10598,104 @@ var init_back = __esm(() => {
   init_hook_engine();
 });
 
+// src/core/stage-transition.ts
+import { join as join18 } from "path";
+function verifyNonce(command, state, stage, phase) {
+  if (!state.lastNonce) {
+    return;
+  }
+  if (!state.expectedHash) {
+    emitError(command, "Nonce transition error: lastNonce exists but expectedHash is missing. State may be corrupted.");
+  }
+  if (!verifyToken(state.lastNonce, state.id, stage, state.expectedHash, phase)) {
+    emitError(command, `Nonce verification failed for ${stage}:${phase}. Re-run the previous phase to get a valid token.`);
+  }
+  state.lastNonce = undefined;
+  state.expectedHash = undefined;
+  state.phase = undefined;
+}
+function setNonce(state, stage, phase) {
+  const { nonce, hash } = generateToken(state.id, stage, phase);
+  state.lastNonce = nonce;
+  state.expectedHash = hash;
+  state.phase = phase;
+}
+async function performTransition(paths, state, saveFn) {
+  const isMerge = state.type === "merge";
+  let nextStage;
+  if (isMerge) {
+    nextStage = MergeLifeCycle.next(state.stage);
+  } else {
+    nextStage = LifeCycle.next(state.stage);
+  }
+  if (!nextStage) {
+    throw new Error(`Cannot advance from '${state.stage}' — already at the last stage.`);
+  }
+  state.stage = nextStage;
+  if (!state.timeline)
+    state.timeline = [];
+  state.timeline.push({ stage: nextStage, at: new Date().toISOString() });
+  await saveFn(state);
+  const artifactFile = isMerge ? MERGE_ARTIFACT[nextStage] : NORMAL_ARTIFACT[nextStage];
+  if (artifactFile) {
+    const templateDir = join18(__require("os").homedir(), ".reap", "templates");
+    const templatePath = join18(templateDir, artifactFile);
+    const destPath = paths.artifact(artifactFile);
+    if (await fileExists(templatePath) && !await fileExists(destPath)) {
+      const templateContent = await readTextFile(templatePath);
+      if (templateContent) {
+        await writeTextFile(destPath, templateContent);
+      }
+    }
+  }
+  const stageKey = isMerge && (nextStage === "validation" || nextStage === "completion") ? `${nextStage}:merge` : nextStage;
+  const stageHookEvent = STAGE_HOOK[stageKey];
+  const stageHookResults = stageHookEvent ? await executeHooks(paths.hooks, stageHookEvent, paths.projectRoot) : [];
+  const transitionEvent = isMerge ? "onMergeTransited" : "onLifeTransited";
+  const transitionHookResults = await executeHooks(paths.hooks, transitionEvent, paths.projectRoot);
+  return {
+    nextStage,
+    artifactFile,
+    stageHookResults,
+    transitionHookResults
+  };
+}
+var NORMAL_ARTIFACT, MERGE_ARTIFACT, STAGE_HOOK;
+var init_stage_transition = __esm(() => {
+  init_lifecycle();
+  init_merge_lifecycle();
+  init_generation();
+  init_fs();
+  init_hook_engine();
+  NORMAL_ARTIFACT = {
+    planning: "02-planning.md",
+    implementation: "03-implementation.md",
+    validation: "04-validation.md",
+    completion: "05-completion.md"
+  };
+  MERGE_ARTIFACT = {
+    mate: "02-mate.md",
+    merge: "03-merge.md",
+    sync: "04-sync.md",
+    validation: "05-validation.md",
+    completion: "06-completion.md"
+  };
+  STAGE_HOOK = {
+    planning: "onLifeObjected",
+    implementation: "onLifePlanned",
+    validation: "onLifeImplemented",
+    completion: "onLifeValidated",
+    mate: "onMergeDetected",
+    merge: "onMergeMated",
+    sync: "onMergeMerged",
+    "validation:merge": "onMergeSynced",
+    "completion:merge": "onMergeValidated"
+  };
+});
+
 // src/core/backlog.ts
 import { readdir as readdir15 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 async function scanBacklog(backlogDir) {
   let entries;
   try {
@@ -10582,7 +10707,7 @@ async function scanBacklog(backlogDir) {
   for (const filename of entries) {
     if (!filename.endsWith(".md"))
       continue;
-    const content = await readTextFile(join17(backlogDir, filename));
+    const content = await readTextFile(join19(backlogDir, filename));
     if (!content)
       continue;
     const { frontmatter, body } = parseFrontmatter2(content);
@@ -10600,7 +10725,7 @@ async function scanBacklog(backlogDir) {
   return items;
 }
 async function markBacklogConsumed(backlogDir, filename, genId) {
-  const filePath = join17(backlogDir, filename);
+  const filePath = join19(backlogDir, filename);
   const content = await readTextFile(filePath);
   if (!content)
     return;
@@ -10609,7 +10734,7 @@ async function markBacklogConsumed(backlogDir, filename, genId) {
   frontmatter.consumedBy = genId;
   delete frontmatter.consumed;
   const newContent = `---
-${import_yaml10.default.stringify(frontmatter).trim()}
+${import_yaml9.default.stringify(frontmatter).trim()}
 ---
 ${body}`;
   await writeTextFile(filePath, newContent);
@@ -10624,7 +10749,7 @@ async function revertBacklogConsumed(backlogDir, genId) {
   for (const filename of entries) {
     if (!filename.endsWith(".md"))
       continue;
-    const filePath = join17(backlogDir, filename);
+    const filePath = join19(backlogDir, filename);
     const content = await readTextFile(filePath);
     if (!content)
       continue;
@@ -10633,7 +10758,7 @@ async function revertBacklogConsumed(backlogDir, genId) {
       frontmatter.status = "pending";
       delete frontmatter.consumedBy;
       const newContent = `---
-${import_yaml10.default.stringify(frontmatter).trim()}
+${import_yaml9.default.stringify(frontmatter).trim()}
 ---
 ${body}`;
       await writeTextFile(filePath, newContent);
@@ -10645,15 +10770,15 @@ function parseFrontmatter2(content) {
   if (!match)
     return { frontmatter: {}, body: content };
   try {
-    return { frontmatter: import_yaml10.default.parse(match[1]) ?? {}, body: match[2] };
+    return { frontmatter: import_yaml9.default.parse(match[1]) ?? {}, body: match[2] };
   } catch {
     return { frontmatter: {}, body: content };
   }
 }
-var import_yaml10;
+var import_yaml9;
 var init_backlog = __esm(() => {
   init_fs();
-  import_yaml10 = __toESM(require_dist(), 1);
+  import_yaml9 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/start.ts
@@ -10661,7 +10786,7 @@ var exports_start = {};
 __export(exports_start, {
   execute: () => execute3
 });
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 import { readdir as readdir16 } from "fs/promises";
 function getFlag2(args, name) {
   const idx = args.indexOf(`--${name}`);
@@ -10715,14 +10840,13 @@ async function execute3(paths, phase, argv = []) {
       genomeVersion = lineageEntries.filter((e) => e.startsWith("gen-")).length + 1;
     } catch {}
     const state = await gm.create(goal, genomeVersion);
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
+    setNonce(state, "objective", "entry");
     await gm.save(state);
     if (backlogFile) {
       await markBacklogConsumed(paths.backlog, backlogFile, state.id);
     }
-    const templateDir = join18(__require("os").homedir(), ".reap", "templates");
-    const templatePath = join18(templateDir, "01-objective.md");
+    const templateDir = join20(__require("os").homedir(), ".reap", "templates");
+    const templatePath = join20(templateDir, "01-objective.md");
     const destPath = paths.artifact("01-objective.md");
     if (await fileExists(templatePath)) {
       let template = await readTextFile(templatePath);
@@ -10752,16 +10876,17 @@ async function execute3(paths, phase, argv = []) {
 }
 var init_start = __esm(() => {
   init_generation();
+  init_stage_transition();
   init_fs();
   init_backlog();
   init_hook_engine();
 });
 
 // src/core/commit.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 function checkSubmodules(projectRoot) {
   try {
-    const output = execSync5("git submodule status", { cwd: projectRoot, stdio: "pipe" }).toString();
+    const output = execSync6("git submodule status", { cwd: projectRoot, stdio: "pipe" }).toString();
     if (!output.trim())
       return [];
     return output.trim().split(`
@@ -10781,134 +10906,13 @@ function checkSubmodules(projectRoot) {
 }
 var init_commit = () => {};
 
-// src/core/stage-transition.ts
-import { join as join19 } from "path";
-function verifyStageEntry(command, state) {
-  if (!state.lastNonce) {
-    return;
-  }
-  if (state.phase) {
-    return;
-  }
-  if (!state.expectedHash) {
-    emitError(command, "Stage transition error: lastNonce exists but expectedHash is missing. State may be corrupted.");
-  }
-  const isMerge = state.type === "merge";
-  let prevStage;
-  if (isMerge) {
-    prevStage = MergeLifeCycle.prev(state.stage);
-  } else {
-    prevStage = LifeCycle.prev(state.stage);
-  }
-  if (!prevStage) {
-    emitError(command, "Stage transition error: cannot determine previous stage for token verification.");
-  }
-  if (!verifyToken(state.lastNonce, state.id, prevStage, state.expectedHash)) {
-    emitError(command, `Token verification failed. The stage chain token does not match. Re-run the previous stage command to get a valid token.`);
-  }
-  state.lastNonce = undefined;
-  state.expectedHash = undefined;
-}
-function setPhaseNonce(state, stage, phase) {
-  const { nonce, hash } = generateToken(state.id, stage, phase);
-  state.lastNonce = nonce;
-  state.expectedHash = hash;
-  state.phase = phase;
-}
-function verifyPhaseEntry(command, state, stage, phase) {
-  if (!state.lastNonce) {
-    emitError(command, `Phase nonce missing. Complete the previous phase before running --phase ${phase}.`);
-  }
-  if (!state.expectedHash) {
-    emitError(command, "Phase transition error: lastNonce exists but expectedHash is missing. State may be corrupted.");
-  }
-  if (!verifyToken(state.lastNonce, state.id, stage, state.expectedHash, phase)) {
-    emitError(command, `Phase token verification failed. Re-run the previous phase to get a valid token.`);
-  }
-  state.lastNonce = undefined;
-  state.expectedHash = undefined;
-  state.phase = undefined;
-}
-async function performTransition(paths, state, saveFn) {
-  const isMerge = state.type === "merge";
-  let nextStage;
-  if (isMerge) {
-    nextStage = MergeLifeCycle.next(state.stage);
-  } else {
-    nextStage = LifeCycle.next(state.stage);
-  }
-  if (!nextStage) {
-    throw new Error(`Cannot advance from '${state.stage}' — already at the last stage.`);
-  }
-  state.stage = nextStage;
-  if (!state.timeline)
-    state.timeline = [];
-  state.timeline.push({ stage: nextStage, at: new Date().toISOString() });
-  await saveFn(state);
-  const artifactFile = isMerge ? MERGE_ARTIFACT[nextStage] : NORMAL_ARTIFACT[nextStage];
-  if (artifactFile) {
-    const templateDir = join19(__require("os").homedir(), ".reap", "templates");
-    const templatePath = join19(templateDir, artifactFile);
-    const destPath = paths.artifact(artifactFile);
-    if (await fileExists(templatePath) && !await fileExists(destPath)) {
-      const templateContent = await readTextFile(templatePath);
-      if (templateContent) {
-        await writeTextFile(destPath, templateContent);
-      }
-    }
-  }
-  const stageKey = isMerge && (nextStage === "validation" || nextStage === "completion") ? `${nextStage}:merge` : nextStage;
-  const stageHookEvent = STAGE_HOOK[stageKey];
-  const stageHookResults = stageHookEvent ? await executeHooks(paths.hooks, stageHookEvent, paths.projectRoot) : [];
-  const transitionEvent = isMerge ? "onMergeTransited" : "onLifeTransited";
-  const transitionHookResults = await executeHooks(paths.hooks, transitionEvent, paths.projectRoot);
-  return {
-    nextStage,
-    artifactFile,
-    stageHookResults,
-    transitionHookResults
-  };
-}
-var NORMAL_ARTIFACT, MERGE_ARTIFACT, STAGE_HOOK;
-var init_stage_transition = __esm(() => {
-  init_lifecycle();
-  init_merge_lifecycle();
-  init_generation();
-  init_fs();
-  init_hook_engine();
-  NORMAL_ARTIFACT = {
-    planning: "02-planning.md",
-    implementation: "03-implementation.md",
-    validation: "04-validation.md",
-    completion: "05-completion.md"
-  };
-  MERGE_ARTIFACT = {
-    mate: "02-mate.md",
-    merge: "03-merge.md",
-    sync: "04-sync.md",
-    validation: "05-validation.md",
-    completion: "06-completion.md"
-  };
-  STAGE_HOOK = {
-    planning: "onLifeObjected",
-    implementation: "onLifePlanned",
-    validation: "onLifeImplemented",
-    completion: "onLifeValidated",
-    mate: "onMergeDetected",
-    merge: "onMergeMated",
-    sync: "onMergeMerged",
-    "validation:merge": "onMergeSynced",
-    "completion:merge": "onMergeValidated"
-  };
-});
-
 // src/cli/commands/run/completion.ts
 var exports_completion = {};
 __export(exports_completion, {
   execute: () => execute4
 });
-import { join as join20 } from "path";
-import { execSync as execSync6 } from "child_process";
+import { join as join21 } from "path";
+import { execSync as execSync7 } from "child_process";
 function detectGenomeImpact(projectRoot) {
   const impact = {
     newCommands: [],
@@ -10917,7 +10921,7 @@ function detectGenomeImpact(projectRoot) {
   };
   let changedFiles;
   try {
-    const output = execSync6("git diff --name-only HEAD~1", {
+    const output = execSync7("git diff --name-only HEAD~1", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 5000
@@ -10988,20 +10992,20 @@ async function execute4(paths, phase) {
   if (state.stage !== "completion") {
     emitError("completion", `Stage is '${state.stage}', expected 'completion'.`);
   }
-  verifyStageEntry("completion", state);
-  await gm.save(state);
   const validationArtifact = paths.artifact("04-validation.md");
   if (!await fileExists(validationArtifact)) {
     emitError("completion", "04-validation.md does not exist. Complete validation first.");
   }
   if (!phase || phase === "retrospective") {
+    verifyNonce("completion", state, "completion", "entry");
+    await gm.save(state);
     const backlogItems = await scanBacklog(paths.backlog);
     const validationContent = await readTextFile(validationArtifact);
     const implContent = await readTextFile(paths.artifact("03-implementation.md"));
     const destPath = paths.artifact("05-completion.md");
     if (!await fileExists(destPath)) {
-      const templateDir = join20(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join20(templateDir, "05-completion.md");
+      const templateDir = join21(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join21(templateDir, "05-completion.md");
       if (await fileExists(templatePath)) {
         const { writeTextFile: writeTextFile2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
         const template = await readTextFile(templatePath);
@@ -11009,7 +11013,7 @@ async function execute4(paths, phase) {
           await writeTextFile2(destPath, template);
       }
     }
-    setPhaseNonce(state, "completion", "retrospective");
+    setNonce(state, "completion", "feedKnowledge");
     await gm.save(state);
     emitOutput({
       status: "prompt",
@@ -11030,7 +11034,7 @@ async function execute4(paths, phase) {
     });
   }
   if (phase === "feedKnowledge") {
-    verifyPhaseEntry("completion", state, "completion", "retrospective");
+    verifyNonce("completion", state, "completion", "feedKnowledge");
     await gm.save(state);
     const backlogItems = await scanBacklog(paths.backlog);
     const genomeChanges = backlogItems.filter((b) => b.type === "genome-change" && b.status !== "consumed");
@@ -11077,43 +11081,6 @@ async function execute4(paths, phase) {
       message: `Generation ${state.id} archived. ${hasChanges ? "Genome/env changes applied." : "No genome/environment changes."} ${toConsume.length} backlog item(s) consumed.`
     });
   }
-  if (phase === "consume") {
-    const backlogItems = await scanBacklog(paths.backlog);
-    const toConsume = backlogItems.filter((b) => (b.type === "genome-change" || b.type === "environment-change") && b.status !== "consumed");
-    for (const item of toConsume) {
-      await markBacklogConsumed(paths.backlog, item.filename, state.id);
-    }
-    emitOutput({
-      status: "prompt",
-      command: "completion",
-      phase: "hook-suggest",
-      completed: ["gate", "artifact-create", "context-scan", "retrospective", "genome-apply", "backlog-consume"],
-      context: { id: state.id, consumedCount: toConsume.length },
-      prompt: "Check the last 3 generations in .reap/lineage/ for repeated manual patterns. If found, suggest hooks (max 2). Then run: reap run completion --phase archive",
-      nextCommand: "reap run completion --phase archive"
-    });
-  }
-  if (phase === "archive") {
-    const hookResults = await executeHooks(paths.hooks, "onLifeCompleted", paths.projectRoot);
-    const submodules = checkSubmodules(paths.projectRoot);
-    const dirtySubmodules = submodules.filter((s) => s.dirty);
-    const compression = await gm.complete();
-    emitOutput({
-      status: "prompt",
-      command: "completion",
-      phase: "commit",
-      completed: ["gate", "artifact-create", "context-scan", "retrospective", "genome", "hook-suggest", "hooks", "archive", "compress"],
-      context: {
-        id: state.id,
-        goal: state.goal,
-        compression: { level1: compression.level1.length, level2: compression.level2.length },
-        hookResults,
-        dirtySubmodules
-      },
-      prompt: (dirtySubmodules.length > 0 ? `Dirty submodules detected: ${dirtySubmodules.map((s) => s.path).join(", ")}. Commit and push inside each submodule first, then commit the parent repo. Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.` : `Commit all changes (code + .reap/ artifacts). Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.`) + buildMdHookPrompt(hookResults),
-      message: `Generation ${state.id} archived.`
-    });
-  }
 }
 var init_completion = __esm(() => {
   init_generation();
@@ -11129,7 +11096,7 @@ var exports_abort = {};
 __export(exports_abort, {
   execute: () => execute5
 });
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import { readdir as readdir17, unlink as unlink6 } from "fs/promises";
 function getFlag3(args, name) {
   const idx = args.indexOf(`--${name}`);
@@ -11205,7 +11172,7 @@ async function execute5(paths, phase, argv = []) {
         sourceAction === "stash" ? "git stash pop으로 코드 복구" : sourceAction === "hold" ? "코드 변경이 working tree에 유지됨" : sourceAction === "rollback" ? "코드 변경이 revert됨. objective부터 재시작 필요" : "소스 코드 변경 없음"
       ].filter((line) => line !== null).join(`
 `);
-      await writeTextFile(join21(paths.backlog, `aborted-${state.id}.md`), backlogContent);
+      await writeTextFile(join22(paths.backlog, `aborted-${state.id}.md`), backlogContent);
       backlogSaved = true;
     }
     await revertBacklogConsumed(paths.backlog, state.id);
@@ -11213,7 +11180,7 @@ async function execute5(paths, phase, argv = []) {
       const lifeEntries = await readdir17(paths.life);
       for (const entry of lifeEntries) {
         if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-          await unlink6(join21(paths.life, entry));
+          await unlink6(join22(paths.life, entry));
         }
       }
     } catch {}
@@ -11272,7 +11239,7 @@ var exports_objective = {};
 __export(exports_objective, {
   execute: () => execute7
 });
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { readdir as readdir18 } from "fs/promises";
 async function execute7(paths, phase) {
   const gm = new GenerationManager(paths);
@@ -11284,6 +11251,8 @@ async function execute7(paths, phase) {
     emitError("objective", `Current stage is '${state.stage}', not 'objective'. Start a new Generation with /reap.start or check the current state with 'reap status'.`);
   }
   if (!phase || phase === "work") {
+    verifyNonce("objective", state, "objective", "entry");
+    await gm.save(state);
     const artifactPath = paths.artifact("01-objective.md");
     const existingArtifact = await readTextFile(artifactPath);
     const isReentry = !!existingArtifact && existingArtifact.length > 100;
@@ -11294,9 +11263,9 @@ async function execute7(paths, phase) {
       const genDirs = lineageEntries.filter((e) => e.startsWith("gen-")).sort();
       if (genDirs.length > 0) {
         const lastGen = genDirs[genDirs.length - 1];
-        prevCompletion = await readTextFile(join22(paths.lineage, lastGen, "05-completion.md"));
+        prevCompletion = await readTextFile(join23(paths.lineage, lastGen, "05-completion.md"));
         if (!prevCompletion) {
-          const compressed = await readTextFile(join22(paths.lineage, `${lastGen}.md`));
+          const compressed = await readTextFile(join23(paths.lineage, `${lastGen}.md`));
           if (compressed)
             prevCompletion = compressed.slice(0, 2000);
         }
@@ -11313,8 +11282,8 @@ async function execute7(paths, phase) {
       lineageCount = entries.filter((e) => e.startsWith("gen-")).length;
     } catch {}
     if (!isReentry) {
-      const templateDir = join22(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join22(templateDir, "01-objective.md");
+      const templateDir = join23(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join23(templateDir, "01-objective.md");
       if (await fileExists(templatePath)) {
         let template = await readTextFile(templatePath);
         if (template) {
@@ -11323,7 +11292,7 @@ async function execute7(paths, phase) {
         }
       }
     }
-    setPhaseNonce(state, "objective", "work");
+    setNonce(state, "objective", "complete");
     await gm.save(state);
     emitOutput({
       status: "prompt",
@@ -11386,8 +11355,7 @@ async function execute7(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("objective", state, "objective", "work");
-    await gm.save(state);
+    verifyNonce("objective", state, "objective", "complete");
     const artifactPath = paths.artifact("01-objective.md");
     if (!await fileExists(artifactPath)) {
       emitError("objective", "01-objective.md does not exist. Complete the objective work first.");
@@ -11396,9 +11364,8 @@ async function execute7(paths, phase) {
     if (!content || content.length < 50) {
       emitError("objective", "01-objective.md appears incomplete (too short). Fill in the objective before completing.");
     }
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
+    setNonce(state, "planning", "entry");
+    await gm.save(state);
     const hookResults = await executeHooks(paths.hooks, "onLifeObjected", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => gm.save(s));
     const nextCommand = `reap run ${transition.nextStage}`;
@@ -11432,7 +11399,7 @@ var exports_planning = {};
 __export(exports_planning, {
   execute: () => execute8
 });
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 async function execute8(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11442,13 +11409,13 @@ async function execute8(paths, phase) {
   if (state.stage !== "planning") {
     emitError("planning", `Current stage is '${state.stage}', not 'planning'.`);
   }
-  verifyStageEntry("planning", state);
-  await gm.save(state);
   const objectiveArtifact = paths.artifact("01-objective.md");
   if (!await fileExists(objectiveArtifact)) {
     emitError("planning", "01-objective.md does not exist. Complete the objective stage first.");
   }
   if (!phase || phase === "work") {
+    verifyNonce("planning", state, "planning", "entry");
+    await gm.save(state);
     const artifactPath = paths.artifact("02-planning.md");
     const existingArtifact = await readTextFile(artifactPath);
     const isReentry = !!existingArtifact && existingArtifact.length > 100;
@@ -11458,15 +11425,15 @@ async function execute8(paths, phase) {
     const principlesContent = await readTextFile(paths.principles);
     const implContent = await readTextFile(paths.artifact("03-implementation.md"));
     if (!isReentry) {
-      const templateDir = join23(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join23(templateDir, "02-planning.md");
+      const templateDir = join24(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join24(templateDir, "02-planning.md");
       if (await fileExists(templatePath)) {
         const template = await readTextFile(templatePath);
         if (template)
           await writeTextFile(artifactPath, template);
       }
     }
-    setPhaseNonce(state, "planning", "work");
+    setNonce(state, "planning", "complete");
     await gm.save(state);
     emitOutput({
       status: "prompt",
@@ -11524,8 +11491,7 @@ async function execute8(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("planning", state, "planning", "work");
-    await gm.save(state);
+    verifyNonce("planning", state, "planning", "complete");
     const artifactPath = paths.artifact("02-planning.md");
     if (!await fileExists(artifactPath)) {
       emitError("planning", "02-planning.md does not exist. Complete the planning work first.");
@@ -11534,9 +11500,8 @@ async function execute8(paths, phase) {
     if (!content || content.length < 50) {
       emitError("planning", "02-planning.md appears incomplete. Fill in the plan before completing.");
     }
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
+    setNonce(state, "implementation", "entry");
+    await gm.save(state);
     const hookResults = await executeHooks(paths.hooks, "onLifePlanned", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => gm.save(s));
     const nextCommand = `reap run ${transition.nextStage}`;
@@ -11569,7 +11534,7 @@ var exports_implementation = {};
 __export(exports_implementation, {
   execute: () => execute9
 });
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 async function execute9(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11579,13 +11544,13 @@ async function execute9(paths, phase) {
   if (state.stage !== "implementation") {
     emitError("implementation", `Current stage is '${state.stage}', not 'implementation'.`);
   }
-  verifyStageEntry("implementation", state);
-  await gm.save(state);
   const planningArtifact = paths.artifact("02-planning.md");
   if (!await fileExists(planningArtifact)) {
     emitError("implementation", "02-planning.md does not exist. Complete the planning stage first.");
   }
   if (!phase || phase === "work") {
+    verifyNonce("implementation", state, "implementation", "entry");
+    await gm.save(state);
     const artifactPath = paths.artifact("03-implementation.md");
     const existingArtifact = await readTextFile(artifactPath);
     const isReentry = !!existingArtifact && existingArtifact.length > 100;
@@ -11593,15 +11558,15 @@ async function execute9(paths, phase) {
     const conventionsContent = await readTextFile(paths.conventions);
     const constraintsContent = await readTextFile(paths.constraints);
     if (!isReentry) {
-      const templateDir = join24(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join24(templateDir, "03-implementation.md");
+      const templateDir = join25(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join25(templateDir, "03-implementation.md");
       if (await fileExists(templatePath)) {
         const template = await readTextFile(templatePath);
         if (template)
           await writeTextFile(artifactPath, template);
       }
     }
-    setPhaseNonce(state, "implementation", "work");
+    setNonce(state, "implementation", "complete");
     await gm.save(state);
     emitOutput({
       status: "prompt",
@@ -11662,15 +11627,13 @@ async function execute9(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("implementation", state, "implementation", "work");
-    await gm.save(state);
+    verifyNonce("implementation", state, "implementation", "complete");
     const artifactPath = paths.artifact("03-implementation.md");
     if (!await fileExists(artifactPath)) {
       emitError("implementation", "03-implementation.md does not exist. Complete the implementation work first.");
     }
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
+    setNonce(state, "validation", "entry");
+    await gm.save(state);
     const hookResults = await executeHooks(paths.hooks, "onLifeImplemented", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => gm.save(s));
     const nextCommand = `reap run ${transition.nextStage}`;
@@ -11703,7 +11666,7 @@ var exports_validation = {};
 __export(exports_validation, {
   execute: () => execute10
 });
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 async function execute10(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11713,13 +11676,13 @@ async function execute10(paths, phase) {
   if (state.stage !== "validation") {
     emitError("validation", `Current stage is '${state.stage}', not 'validation'.`);
   }
-  verifyStageEntry("validation", state);
-  await gm.save(state);
   const implArtifact = paths.artifact("03-implementation.md");
   if (!await fileExists(implArtifact)) {
     emitError("validation", "03-implementation.md does not exist. Complete the implementation stage first.");
   }
   if (!phase || phase === "work") {
+    verifyNonce("validation", state, "validation", "entry");
+    await gm.save(state);
     const artifactPath = paths.artifact("04-validation.md");
     const existingArtifact = await readTextFile(artifactPath);
     const isReentry = !!existingArtifact && existingArtifact.length > 100;
@@ -11728,15 +11691,15 @@ async function execute10(paths, phase) {
     const implContent = await readTextFile(implArtifact);
     const objectiveContent = await readTextFile(paths.artifact("01-objective.md"));
     if (!isReentry) {
-      const templateDir = join25(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join25(templateDir, "04-validation.md");
+      const templateDir = join26(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join26(templateDir, "04-validation.md");
       if (await fileExists(templatePath)) {
         const template = await readTextFile(templatePath);
         if (template)
           await writeTextFile(artifactPath, template);
       }
     }
-    setPhaseNonce(state, "validation", "work");
+    setNonce(state, "validation", "complete");
     await gm.save(state);
     emitOutput({
       status: "prompt",
@@ -11807,15 +11770,13 @@ async function execute10(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("validation", state, "validation", "work");
-    await gm.save(state);
+    verifyNonce("validation", state, "validation", "complete");
     const artifactPath = paths.artifact("04-validation.md");
     if (!await fileExists(artifactPath)) {
       emitError("validation", "04-validation.md does not exist. Complete the validation work first.");
     }
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
+    setNonce(state, "completion", "entry");
+    await gm.save(state);
     const hookResults = await executeHooks(paths.hooks, "onLifeValidated", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => gm.save(s));
     const nextCommand = transition.nextStage !== "completion" ? `reap run ${transition.nextStage}` : "reap run completion";
@@ -12129,7 +12090,7 @@ __export(exports_sync_genome, {
   execute: () => execute13
 });
 import { readdir as readdir19 } from "fs/promises";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 async function execute13(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -12144,7 +12105,7 @@ async function execute13(paths, phase) {
       const entries = await readdir19(paths.domain);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
-          const content = await readTextFile(join26(paths.domain, entry));
+          const content = await readTextFile(join27(paths.domain, entry));
           if (content)
             domainFiles[entry] = content.slice(0, 1000);
         }
@@ -12232,7 +12193,7 @@ __export(exports_sync_environment, {
   execute: () => execute14
 });
 import { readdir as readdir20 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 async function execute14(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -12244,7 +12205,7 @@ async function execute14(paths, phase) {
       const docsEntries = await readdir20(paths.environmentDocs);
       for (const entry of docsEntries) {
         if (entry.endsWith(".md")) {
-          const content = await readTextFile(join27(paths.environmentDocs, entry));
+          const content = await readTextFile(join28(paths.environmentDocs, entry));
           if (content)
             envDocs[entry] = content.slice(0, 1000);
         }
@@ -12252,7 +12213,7 @@ async function execute14(paths, phase) {
     } catch {}
     let linksContent = null;
     try {
-      linksContent = await readTextFile(join27(paths.environmentResources, "links.md"));
+      linksContent = await readTextFile(join28(paths.environmentResources, "links.md"));
     } catch {}
     emitOutput({
       status: "prompt",
@@ -12324,7 +12285,7 @@ var exports_help = {};
 __export(exports_help, {
   execute: () => execute15
 });
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function detectLanguage(configContent) {
   const raw = configContent?.match(/language:\s*(\S+)/)?.[1] ?? null;
   if (raw && raw in LANGUAGE_ALIASES)
@@ -12359,7 +12320,7 @@ async function execute15(paths) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
   const configContent = await readTextFile(paths.config);
-  const installedVersion = "0.15.2";
+  const installedVersion = "0.15.3";
   const autoUpdate = configContent?.match(/autoUpdate:\s*(true|false)/)?.[1] === "true";
   const versionDisplay = formatVersionLine(installedVersion, !autoUpdate);
   const rawLang = detectLanguage(configContent);
@@ -12370,7 +12331,7 @@ async function execute15(paths) {
   const stateDisplay = state?.id ? `Active: **${state.id}** — ${state.goal} (Stage: ${state.stage})` : "No active Generation → `/reap.start` or `/reap.evolve`";
   const lines = buildLines(versionDisplay, lang, stateDisplay);
   if (topic) {
-    const guidePath = join28(ReapPaths.packageHooksDir, "reap-guide.md");
+    const guidePath = join29(ReapPaths.packageHooksDir, "reap-guide.md");
     const reapGuide = await readTextFile(guidePath) ?? "";
     emitOutput({
       status: "prompt",
@@ -12675,8 +12636,8 @@ var init_merge = __esm(() => {
 });
 
 // src/core/merge-generation.ts
-import { readdir as readdir21, mkdir as mkdir10, rename as rename3 } from "fs/promises";
-import { join as join29 } from "path";
+import { readdir as readdir21, mkdir as mkdir10, unlink as unlink7 } from "fs/promises";
+import { join as join30 } from "path";
 
 class MergeGenerationManager {
   paths;
@@ -12687,7 +12648,7 @@ class MergeGenerationManager {
     const content = await readTextFile(this.paths.currentYml);
     if (content === null || !content.trim())
       return null;
-    const state = import_yaml11.default.parse(content);
+    const state = import_yaml10.default.parse(content);
     if (!state.type)
       state.type = "normal";
     if (!state.parents)
@@ -12720,7 +12681,7 @@ class MergeGenerationManager {
       genomeHash,
       commonAncestor: commonAncestor ?? undefined
     };
-    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
     return state;
   }
   async createFromBranch(targetBranch, projectRoot) {
@@ -12764,10 +12725,10 @@ class MergeGenerationManager {
       genomeHash,
       commonAncestor: commonAncestor ?? undefined
     };
-    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
     return { state, report };
   }
-  async resolveLatestGenId(branch, cwd) {
+  async resolveLatestGenId(_branch, _cwd) {
     const metas = await listMeta(this.paths);
     if (metas.length === 0)
       return null;
@@ -12789,7 +12750,7 @@ class MergeGenerationManager {
       const content = gitShow(ref, metaFile, cwd);
       if (content) {
         try {
-          const meta = import_yaml11.default.parse(content);
+          const meta = import_yaml10.default.parse(content);
           if (meta?.id)
             metas.push(meta);
         } catch {}
@@ -12836,7 +12797,7 @@ class MergeGenerationManager {
     if (!state.timeline)
       state.timeline = [];
     state.timeline.push({ stage: next, at: new Date().toISOString() });
-    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
     return state;
   }
   async complete() {
@@ -12862,19 +12823,33 @@ class MergeGenerationManager {
       startedAt: state.startedAt,
       completedAt: now
     };
-    await writeTextFile(join29(genDir, "meta.yml"), import_yaml11.default.stringify(meta));
+    await writeTextFile(join30(genDir, "meta.yml"), import_yaml10.default.stringify(meta));
     const lifeEntries = await readdir21(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-        await rename3(join29(this.paths.life, entry), join29(genDir, entry));
+        const srcPath = join30(this.paths.life, entry);
+        const destPath = join30(genDir, entry);
+        let content = await readTextFile(srcPath);
+        if (content && content.startsWith("# REAP MANAGED")) {
+          content = content.replace(/^# REAP MANAGED[^\n]*\n/, "");
+        }
+        await writeTextFile(destPath, content ?? "");
+        await unlink7(srcPath);
       }
     }
-    const backlogDir = join29(genDir, "backlog");
+    const backlogDir = join30(genDir, "backlog");
     await mkdir10(backlogDir, { recursive: true });
     try {
       const backlogEntries = await readdir21(this.paths.backlog);
       for (const entry of backlogEntries) {
-        await rename3(join29(this.paths.backlog, entry), join29(backlogDir, entry));
+        const content = await readTextFile(join30(this.paths.backlog, entry));
+        if (!content)
+          continue;
+        const isConsumed = /status:\s*consumed/i.test(content) || /consumed:\s*true/i.test(content);
+        await writeTextFile(join30(backlogDir, entry), content);
+        if (isConsumed) {
+          await unlink7(join30(this.paths.backlog, entry));
+        }
       }
     } catch {}
     await writeTextFile(this.paths.currentYml, "");
@@ -12882,7 +12857,7 @@ class MergeGenerationManager {
     return compression;
   }
   async save(state) {
-    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
   }
 }
 function canFastForward(localLatestId, remoteLatestId, allMetas) {
@@ -12944,7 +12919,7 @@ function findCommonAncestor(idA, idB, metas) {
   }
   return null;
 }
-var import_yaml11;
+var import_yaml10;
 var init_merge_generation = __esm(() => {
   init_merge_lifecycle();
   init_compression();
@@ -12954,7 +12929,7 @@ var init_merge_generation = __esm(() => {
   init_merge();
   init_lineage();
   init_compression();
-  import_yaml11 = __toESM(require_dist(), 1);
+  import_yaml10 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/merge-start.ts
@@ -13071,7 +13046,7 @@ async function execute18(paths, phase) {
       emitError("merge-detect", "01-detect.md does not exist. Run /reap.merge.start first.");
     }
     const detectContent = await readTextFile(detectArtifact);
-    setPhaseNonce(state, "detect", "review");
+    setNonce(state, "detect", "complete");
     await mgm.save(state);
     emitOutput({
       status: "prompt",
@@ -13101,11 +13076,9 @@ async function execute18(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("merge-detect", state, "detect", "review");
+    verifyNonce("merge-detect", state, "detect", "complete");
+    setNonce(state, "mate", "entry");
     await mgm.save(state);
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
     const hookResults = await executeHooks(paths.hooks, "onMergeDetected", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => mgm.save(s));
     const nextCommand = `reap run merge-${transition.nextStage}`;
@@ -13128,7 +13101,6 @@ async function execute18(paths, phase) {
 }
 var init_merge_detect = __esm(() => {
   init_merge_generation();
-  init_generation();
   init_fs();
   init_hook_engine();
   init_stage_transition();
@@ -13151,15 +13123,15 @@ async function execute19(paths, phase) {
   if (state.stage !== "mate") {
     emitError("merge-mate", `Stage is '${state.stage}', expected 'mate'.`);
   }
-  verifyStageEntry("merge-mate", state);
-  await mgm.save(state);
   const detectArtifact = paths.artifact("01-detect.md");
   if (!await fileExists(detectArtifact)) {
     emitError("merge-mate", "01-detect.md does not exist. Complete detect stage first.");
   }
   if (!phase || phase === "resolve") {
+    verifyNonce("merge-mate", state, "mate", "entry");
+    await mgm.save(state);
     const detectContent = await readTextFile(detectArtifact);
-    setPhaseNonce(state, "mate", "resolve");
+    setNonce(state, "mate", "complete");
     await mgm.save(state);
     emitOutput({
       status: "prompt",
@@ -13200,11 +13172,13 @@ async function execute19(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("merge-mate", state, "mate", "resolve");
+    verifyNonce("merge-mate", state, "mate", "complete");
+    const mateArtifact = paths.artifact("02-mate.md");
+    if (!await fileExists(mateArtifact)) {
+      emitError("merge-mate", "02-mate.md does not exist. Write the mate artifact before completing.");
+    }
+    setNonce(state, "merge", "entry");
     await mgm.save(state);
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
     const hookResults = await executeHooks(paths.hooks, "onMergeMated", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => mgm.save(s));
     const nextCommand = `reap run merge-${transition.nextStage}`;
@@ -13227,7 +13201,6 @@ async function execute19(paths, phase) {
 }
 var init_merge_mate = __esm(() => {
   init_merge_generation();
-  init_generation();
   init_fs();
   init_hook_engine();
   init_stage_transition();
@@ -13250,17 +13223,17 @@ async function execute20(paths, phase) {
   if (state.stage !== "merge") {
     emitError("merge-merge", `Stage is '${state.stage}', expected 'merge'.`);
   }
-  verifyStageEntry("merge-merge", state);
-  await mgm.save(state);
   const mateArtifact = paths.artifact("02-mate.md");
   if (!await fileExists(mateArtifact)) {
     emitError("merge-merge", "02-mate.md does not exist. Complete mate stage first.");
   }
   if (!phase || phase === "work") {
+    verifyNonce("merge-merge", state, "merge", "entry");
+    await mgm.save(state);
     const mateContent = await readTextFile(mateArtifact);
     const detectContent = await readTextFile(paths.artifact("01-detect.md"));
     const targetBranch = state.goal.split(" + ").pop() ?? "";
-    setPhaseNonce(state, "merge", "work");
+    setNonce(state, "merge", "complete");
     await mgm.save(state);
     emitOutput({
       status: "prompt",
@@ -13296,11 +13269,13 @@ async function execute20(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("merge-merge", state, "merge", "work");
+    verifyNonce("merge-merge", state, "merge", "complete");
+    const mergeArtifactCheck = paths.artifact("03-merge.md");
+    if (!await fileExists(mergeArtifactCheck)) {
+      emitError("merge-merge", "03-merge.md does not exist. Write the merge artifact before completing.");
+    }
+    setNonce(state, "sync", "entry");
     await mgm.save(state);
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
     const hookResults = await executeHooks(paths.hooks, "onMergeMerged", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => mgm.save(s));
     const nextCommand = `reap run merge-${transition.nextStage}`;
@@ -13323,7 +13298,6 @@ async function execute20(paths, phase) {
 }
 var init_merge_merge = __esm(() => {
   init_merge_generation();
-  init_generation();
   init_fs();
   init_hook_engine();
   init_stage_transition();
@@ -13346,18 +13320,18 @@ async function execute21(paths, phase) {
   if (state.stage !== "sync") {
     emitError("merge-sync", `Stage is '${state.stage}', expected 'sync'.`);
   }
-  verifyStageEntry("merge-sync", state);
-  await mgm.save(state);
   const mergeArtifact = paths.artifact("03-merge.md");
   if (!await fileExists(mergeArtifact)) {
     emitError("merge-sync", "03-merge.md does not exist. Complete merge stage first.");
   }
   if (!phase || phase === "verify") {
+    verifyNonce("merge-sync", state, "sync", "entry");
+    await mgm.save(state);
     const genomeConventions = await readTextFile(paths.conventions);
     const genomeConstraints = await readTextFile(paths.constraints);
     const genomePrinciples = await readTextFile(paths.principles);
     const mergeContent = await readTextFile(mergeArtifact);
-    setPhaseNonce(state, "sync", "verify");
+    setNonce(state, "sync", "complete");
     await mgm.save(state);
     emitOutput({
       status: "prompt",
@@ -13403,11 +13377,13 @@ async function execute21(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("merge-sync", state, "sync", "verify");
+    verifyNonce("merge-sync", state, "sync", "complete");
+    const syncArtifactCheck = paths.artifact("04-sync.md");
+    if (!await fileExists(syncArtifactCheck)) {
+      emitError("merge-sync", "04-sync.md does not exist. Write the sync artifact before completing.");
+    }
+    setNonce(state, "validation", "entry");
     await mgm.save(state);
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
     const hookResults = await executeHooks(paths.hooks, "onMergeSynced", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => mgm.save(s));
     const nextCommand = `reap run merge-${transition.nextStage}`;
@@ -13430,7 +13406,6 @@ async function execute21(paths, phase) {
 }
 var init_merge_sync = __esm(() => {
   init_merge_generation();
-  init_generation();
   init_fs();
   init_hook_engine();
   init_stage_transition();
@@ -13453,15 +13428,15 @@ async function execute22(paths, phase) {
   if (state.stage !== "validation") {
     emitError("merge-validation", `Stage is '${state.stage}', expected 'validation'.`);
   }
-  verifyStageEntry("merge-validation", state);
-  await mgm.save(state);
   const syncArtifact = paths.artifact("04-sync.md");
   if (!await fileExists(syncArtifact)) {
     emitError("merge-validation", "04-sync.md does not exist. Complete sync stage first.");
   }
   if (!phase || phase === "work") {
+    verifyNonce("merge-validation", state, "validation", "entry");
+    await mgm.save(state);
     const constraintsContent = await readTextFile(paths.constraints);
-    setPhaseNonce(state, "validation", "work");
+    setNonce(state, "validation", "complete");
     await mgm.save(state);
     emitOutput({
       status: "prompt",
@@ -13499,15 +13474,13 @@ async function execute22(paths, phase) {
     });
   }
   if (phase === "complete") {
-    verifyPhaseEntry("merge-validation", state, "validation", "work");
-    await mgm.save(state);
+    verifyNonce("merge-validation", state, "validation", "complete");
     const validationArtifact = paths.artifact("05-validation.md");
     if (!await fileExists(validationArtifact)) {
       emitError("merge-validation", "05-validation.md does not exist. Complete validation work first.");
     }
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
-    state.lastNonce = nonce;
+    setNonce(state, "completion", "entry");
+    await mgm.save(state);
     const hookResults = await executeHooks(paths.hooks, "onMergeValidated", paths.projectRoot);
     const transition = await performTransition(paths, state, (s) => mgm.save(s));
     const nextCommand = `reap run merge-${transition.nextStage}`;
@@ -13530,7 +13503,6 @@ async function execute22(paths, phase) {
 }
 var init_merge_validation = __esm(() => {
   init_merge_generation();
-  init_generation();
   init_fs();
   init_hook_engine();
   init_stage_transition();
@@ -13553,18 +13525,18 @@ async function execute23(paths, phase) {
   if (state.stage !== "completion") {
     emitError("merge-completion", `Stage is '${state.stage}', expected 'completion'.`);
   }
-  verifyStageEntry("merge-completion", state);
-  await mgm.save(state);
   const validationArtifact = paths.artifact("05-validation.md");
   if (!await fileExists(validationArtifact)) {
     emitError("merge-completion", "05-validation.md does not exist. Complete validation first.");
   }
   if (!phase || phase === "retrospective") {
+    verifyNonce("merge-completion", state, "completion", "entry");
+    await mgm.save(state);
     const detectContent = await readTextFile(paths.artifact("01-detect.md"));
     const mateContent = await readTextFile(paths.artifact("02-mate.md"));
     const mergeContent = await readTextFile(paths.artifact("03-merge.md"));
     const validationContent = await readTextFile(validationArtifact);
-    setPhaseNonce(state, "completion", "retrospective");
+    setNonce(state, "completion", "archive");
     await mgm.save(state);
     emitOutput({
       status: "prompt",
@@ -13596,7 +13568,7 @@ async function execute23(paths, phase) {
     });
   }
   if (phase === "archive") {
-    verifyPhaseEntry("merge-completion", state, "completion", "retrospective");
+    verifyNonce("merge-completion", state, "completion", "archive");
     await mgm.save(state);
     const hookResults = await executeHooks(paths.hooks, "onMergeCompleted", paths.projectRoot);
     const submodules = checkSubmodules(paths.projectRoot);
@@ -13807,7 +13779,7 @@ var exports_evolve_recovery = {};
 __export(exports_evolve_recovery, {
   execute: () => execute26
 });
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import { readdir as readdir22 } from "fs/promises";
 function getFlag4(args, name) {
   const idx = args.indexOf(`--${name}`);
@@ -13830,12 +13802,12 @@ async function loadLineageArtifacts(paths, genId) {
   const completed = await listCompleted(paths);
   const genDir = completed.find((d) => d.startsWith(genId));
   if (genDir) {
-    const dirPath = join30(paths.lineage, genDir);
+    const dirPath = join31(paths.lineage, genDir);
     const [objective, planning, implementation, completion] = await Promise.all([
-      readTextFile(join30(dirPath, "01-objective.md")),
-      readTextFile(join30(dirPath, "02-planning.md")),
-      readTextFile(join30(dirPath, "03-implementation.md")),
-      readTextFile(join30(dirPath, "05-completion.md"))
+      readTextFile(join31(dirPath, "01-objective.md")),
+      readTextFile(join31(dirPath, "02-planning.md")),
+      readTextFile(join31(dirPath, "03-implementation.md")),
+      readTextFile(join31(dirPath, "05-completion.md"))
     ]);
     return {
       objective: objective ?? "(not found)",
@@ -13848,7 +13820,7 @@ async function loadLineageArtifacts(paths, genId) {
     const entries = await readdir22(paths.lineage);
     const compressedFile = entries.find((e) => e.startsWith(genId) && e.endsWith(".md"));
     if (compressedFile) {
-      const content = await readTextFile(join30(paths.lineage, compressedFile));
+      const content = await readTextFile(join31(paths.lineage, compressedFile));
       if (content) {
         return {
           objective: content,
@@ -13937,8 +13909,7 @@ async function execute26(paths, phase, argv = []) {
     } catch {}
     const goal = reason ? `Recovery: ${reason} (corrects ${targetGenIds.join(", ")})` : `Recovery for ${targetGenIds.join(", ")}`;
     const state = await gm.createRecoveryGeneration(goal, genomeVersion, targetGenIds);
-    const { nonce, hash } = generateToken(state.id, state.stage);
-    state.expectedHash = hash;
+    setNonce(state, "objective", "entry");
     await gm.save(state);
     emitOutput({
       status: "prompt",
@@ -13960,6 +13931,7 @@ async function execute26(paths, phase, argv = []) {
 }
 var init_evolve_recovery = __esm(() => {
   init_generation();
+  init_stage_transition();
   init_fs();
   init_lineage();
 });
@@ -14028,9 +14000,9 @@ async function execute27(paths, phase, argv = []) {
       const localLatest = localMetas.sort((a, b) => new Date(b.completedAt).getTime() - new Date(a.completedAt).getTime())[0];
       const remoteLatest = remoteMetasRaw.sort((a, b) => new Date(b.completedAt).getTime() - new Date(a.completedAt).getTime())[0];
       const allMetas = [...localMetas];
-      for (const rm5 of remoteMetasRaw) {
-        if (!allMetas.find((m) => m.id === rm5.id))
-          allMetas.push(rm5);
+      for (const rm6 of remoteMetasRaw) {
+        if (!allMetas.find((m) => m.id === rm6.id))
+          allMetas.push(rm6);
       }
       const ffResult = canFastForward(localLatest.id, remoteLatest.id, allMetas);
       if (ffResult.fastForward) {
@@ -14220,20 +14192,20 @@ var exports_refresh_knowledge = {};
 __export(exports_refresh_knowledge, {
   execute: () => execute30
 });
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 import { readdir as readdir23 } from "fs/promises";
 async function loadGenome(genomeDir) {
   let content = "";
   let l1Lines = 0;
   let smLimit = null;
-  const smContent = await readTextFile(join31(genomeDir, "source-map.md"));
+  const smContent = await readTextFile(join32(genomeDir, "source-map.md"));
   if (smContent) {
     const limitMatch = smContent.match(/줄 수 한도:\s*~?(\d+)줄/);
     if (limitMatch)
       smLimit = parseInt(limitMatch[1], 10);
   }
   for (const file of L1_FILES) {
-    const fileContent = await readTextFile(join31(genomeDir, file));
+    const fileContent = await readTextFile(join32(genomeDir, file));
     if (!fileContent)
       continue;
     const lines = fileContent.split(`
@@ -14255,14 +14227,14 @@ ${fileContent.split(`
 `;
     }
   }
-  const domainDir = join31(genomeDir, "domain");
+  const domainDir = join32(genomeDir, "domain");
   if (await fileExists(domainDir)) {
     let l2Lines = 0;
     let l2Overflow = false;
     try {
       const domainFiles = (await readdir23(domainDir)).filter((f) => f.endsWith(".md")).sort();
       for (const file of domainFiles) {
-        const fileContent = await readTextFile(join31(domainDir, file));
+        const fileContent = await readTextFile(join32(domainDir, file));
         if (!fileContent)
           continue;
         const lines = fileContent.split(`
@@ -14313,7 +14285,7 @@ function buildStrictSection(strict, genStage) {
   return sections;
 }
 async function execute30(paths) {
-  const guidePath = join31(ReapPaths.packageHooksDir, "reap-guide.md");
+  const guidePath = join32(ReapPaths.packageHooksDir, "reap-guide.md");
   const reapGuide = await readTextFile(guidePath) || "";
   const { content: genomeContent } = await loadGenome(paths.genome);
   const envSummary = await readTextFile(paths.environmentSummary) || "";
@@ -14385,7 +14357,7 @@ var exports_run = {};
 __export(exports_run, {
   runCommand: () => runCommand
 });
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 async function runCommand(command, phase, argv = []) {
   const cwd = process.cwd();
   const paths = new ReapPaths(cwd);
@@ -14403,7 +14375,7 @@ async function runCommand(command, phase, argv = []) {
     try {
       const config = await ConfigManager.read(paths);
       if (config.autoIssueReport) {
-        const version = "0.15.2";
+        const version = "0.15.3";
         const errMsg = err instanceof Error ? err.message : String(err);
         const title = `[auto] reap run ${command}: ${errMsg.slice(0, 80)}`;
         const body = [
@@ -14413,7 +14385,7 @@ async function runCommand(command, phase, argv = []) {
           `**OS**: ${process.platform} ${process.arch}`,
           `**Node**: ${process.version}`
         ].join("\\n");
-        execSync7(`gh issue create --repo c-d-cc/reap --title "${title}" --label "auto-reported,bug" --body "${body}"`, { stdio: "ignore", timeout: 1e4 });
+        execSync8(`gh issue create --repo c-d-cc/reap --title "${title}" --label "auto-reported,bug" --body "${body}"`, { stdio: "ignore", timeout: 1e4 });
       }
     } catch {}
     emitError(command, err instanceof Error ? err.message : String(err));
@@ -14479,15 +14451,15 @@ import { createInterface } from "readline";
 // src/cli/commands/init.ts
 init_paths();
 init_config();
-import { mkdir as mkdir4, readdir as readdir5, chmod } from "fs/promises";
-import { join as join6 } from "path";
+import { mkdir as mkdir5, readdir as readdir6, chmod } from "fs/promises";
+import { join as join7 } from "path";
 
 // src/core/agents/claude-code.ts
 init_fs();
 init_paths();
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
-import { mkdir, readdir, unlink } from "fs/promises";
+import { mkdir, readdir, rm, unlink } from "fs/promises";
 
 class ClaudeCodeAdapter {
   name = "claude-code";
@@ -14674,6 +14646,55 @@ class ClaudeCodeAdapter {
     } catch {}
     return removed;
   }
+  async setupAgentMd(projectRoot) {
+    return this.setupClaudeMd(projectRoot);
+  }
+  async cleanupProjectFiles(projectRoot) {
+    const removed = [];
+    const skipped = [];
+    const claudeCommandsDir = join2(projectRoot, ".claude", "commands");
+    try {
+      const files = await readdir(claudeCommandsDir);
+      const matched = files.filter((f) => f.startsWith("reap."));
+      for (const file of matched) {
+        await unlink(join2(claudeCommandsDir, file));
+        removed.push(`.claude/commands/${file}`);
+      }
+      if (matched.length === 0)
+        skipped.push(".claude/commands/reap.* (none found)");
+    } catch {
+      skipped.push(".claude/commands/reap.* (directory not found)");
+    }
+    const claudeSkillsDir = join2(projectRoot, ".claude", "skills");
+    try {
+      const entries = await readdir(claudeSkillsDir);
+      const matched = entries.filter((e) => e.startsWith("reap."));
+      for (const entry of matched) {
+        await rm(join2(claudeSkillsDir, entry), { recursive: true, force: true });
+        removed.push(`.claude/skills/${entry}`);
+      }
+      if (matched.length === 0)
+        skipped.push(".claude/skills/reap.* (none found)");
+    } catch {
+      skipped.push(".claude/skills/reap.* (directory not found)");
+    }
+    const claudeMdPath = join2(projectRoot, ".claude", "CLAUDE.md");
+    const content = await readTextFile(claudeMdPath);
+    if (content !== null && content.includes("# REAP Project")) {
+      const cleaned = content.replace(/# REAP Project[\s\S]*?(?=\n# |\s*$)/, "").trim();
+      if (cleaned.length === 0) {
+        await unlink(claudeMdPath);
+        removed.push(".claude/CLAUDE.md (deleted, was REAP-only)");
+      } else {
+        await writeTextFile(claudeMdPath, cleaned + `
+`);
+        removed.push(".claude/CLAUDE.md (REAP section removed)");
+      }
+    } else {
+      skipped.push(".claude/CLAUDE.md (no REAP section)");
+    }
+    return { removed, skipped };
+  }
   async setupClaudeMd(projectRoot) {
     const claudeMdPath = join2(projectRoot, ".claude", "CLAUDE.md");
     const marker = "# REAP Project";
@@ -14737,31 +14758,232 @@ If context was compacted and REAP knowledge is lost, re-run the session-start ho
   }
 }
 
-// src/core/agents/opencode.ts
+// src/core/agents/codex.ts
 init_fs();
 init_paths();
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 import { mkdir as mkdir2, readdir as readdir2, unlink as unlink2 } from "fs/promises";
-var OPENCODE_STATE_DIR = join3(homedir3(), ".local", "state", "opencode");
+
+class CodexAdapter {
+  name = "codex";
+  displayName = "Codex CLI";
+  get userDir() {
+    return join3(homedir3(), ".codex");
+  }
+  get commandsDir() {
+    return join3(this.userDir, "commands");
+  }
+  get hooksJsonPath() {
+    return join3(this.userDir, "hooks.json");
+  }
+  get configTomlPath() {
+    return join3(this.userDir, "config.toml");
+  }
+  async detect() {
+    try {
+      const { execSync } = await import("child_process");
+      execSync("which codex", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getCommandsDir() {
+    return this.commandsDir;
+  }
+  async installCommands(commandNames, sourceDir) {
+    await mkdir2(ReapPaths.userReapCommands, { recursive: true });
+    for (const cmd of commandNames) {
+      const src = join3(sourceDir, `${cmd}.md`);
+      const dest = join3(ReapPaths.userReapCommands, `${cmd}.md`);
+      await writeTextFile(dest, await readTextFileOrThrow(src));
+    }
+  }
+  async removeStaleCommands(validNames) {
+    try {
+      const existing = await readdir2(this.commandsDir);
+      for (const file of existing) {
+        if (!file.startsWith("reap.") || !file.endsWith(".md"))
+          continue;
+        if (!validNames.has(file)) {
+          await unlink2(join3(this.commandsDir, file));
+        }
+      }
+    } catch {}
+  }
+  async registerSessionHook(dryRun = false) {
+    await mkdir2(this.userDir, { recursive: true });
+    const hooksFile = await this.readHooksJson();
+    const hooks = hooksFile["hooks"] ?? {};
+    const sessionStart = hooks["SessionStart"] ?? [];
+    if (Array.isArray(sessionStart) && this.hasReapHook(sessionStart)) {
+      return { action: "skipped" };
+    }
+    const hadHooksSection = "hooks" in hooksFile && "SessionStart" in hooks;
+    hooksFile["hooks"] = {
+      ...hooks,
+      SessionStart: [
+        ...Array.isArray(sessionStart) ? sessionStart : [],
+        this.getHookEntry()
+      ]
+    };
+    if (!dryRun) {
+      await this.writeHooksJson(hooksFile);
+    }
+    return { action: hadHooksSection ? "updated" : "created" };
+  }
+  async syncSessionHook(dryRun = false) {
+    const hooksFile = await this.readHooksJson();
+    const hooks = hooksFile["hooks"] ?? {};
+    const sessionStart = hooks["SessionStart"] ?? [];
+    if (!Array.isArray(sessionStart) || !this.hasReapHook(sessionStart)) {
+      await this.registerSessionHook(dryRun);
+      return { action: "updated" };
+    }
+    const expectedEntry = this.getHookEntry();
+    let changed = false;
+    const updated = sessionStart.map((entry) => {
+      if (typeof entry !== "object" || entry === null)
+        return entry;
+      const entryHooks = entry["hooks"];
+      if (!Array.isArray(entryHooks))
+        return entry;
+      const isReap = entryHooks.some((h) => {
+        if (typeof h !== "object" || h === null)
+          return false;
+        const cmd = h["command"];
+        return typeof cmd === "string" && cmd.includes("session-start");
+      });
+      if (isReap) {
+        if (JSON.stringify(entry) !== JSON.stringify(expectedEntry)) {
+          changed = true;
+          return expectedEntry;
+        }
+      }
+      return entry;
+    });
+    if (changed && !dryRun) {
+      hooksFile["hooks"] = { ...hooks, SessionStart: updated };
+      await this.writeHooksJson(hooksFile);
+    }
+    return { action: changed ? "updated" : "skipped" };
+  }
+  async readLanguage() {
+    const content = await readTextFile(this.configTomlPath);
+    if (!content)
+      return null;
+    const match = content.match(/^language\s*=\s*"([^"]+)"/m);
+    return match ? match[1] : null;
+  }
+  async setupAgentMd(projectRoot) {
+    const agentsMdPath = join3(projectRoot, ".codex", "AGENTS.md");
+    const marker = "# REAP Project";
+    const reapSection = `# REAP Project
+This project uses REAP. Session-start hook loads project knowledge on session start.
+If context was compacted and REAP knowledge is lost, re-run the session-start hook.
+`;
+    await mkdir2(join3(projectRoot, ".codex"), { recursive: true });
+    const existing = await readTextFile(agentsMdPath);
+    if (existing === null) {
+      await writeTextFile(agentsMdPath, reapSection);
+      return { action: "created" };
+    }
+    if (existing.includes(marker)) {
+      const updated = existing.replace(/# REAP Project[\s\S]*?(?=\n# |\n*$)/, reapSection.trim());
+      if (updated === existing)
+        return { action: "skipped" };
+      await writeTextFile(agentsMdPath, updated);
+      return { action: "updated" };
+    }
+    await writeTextFile(agentsMdPath, reapSection + `
+` + existing);
+    return { action: "created" };
+  }
+  async cleanupProjectFiles(projectRoot) {
+    const removed = [];
+    const skipped = [];
+    const agentsMdPath = join3(projectRoot, ".codex", "AGENTS.md");
+    const content = await readTextFile(agentsMdPath);
+    if (content !== null && content.includes("# REAP Project")) {
+      const cleaned = content.replace(/# REAP Project[\s\S]*?(?=\n# |\s*$)/, "").trim();
+      if (cleaned.length === 0) {
+        await unlink2(agentsMdPath);
+        removed.push(".codex/AGENTS.md (deleted, was REAP-only)");
+      } else {
+        await writeTextFile(agentsMdPath, cleaned + `
+`);
+        removed.push(".codex/AGENTS.md (REAP section removed)");
+      }
+    } else {
+      skipped.push(".codex/AGENTS.md (no REAP section)");
+    }
+    return { removed, skipped };
+  }
+  getHookEntry() {
+    const sessionStartPath = join3(ReapPaths.packageHooksDir, "session-start.cjs");
+    return {
+      matcher: "",
+      hooks: [{ type: "command", command: `node "${sessionStartPath}"` }]
+    };
+  }
+  hasReapHook(sessionStartHooks) {
+    return sessionStartHooks.some((entry) => {
+      if (typeof entry !== "object" || entry === null)
+        return false;
+      const hooks = entry["hooks"];
+      if (!Array.isArray(hooks))
+        return false;
+      return hooks.some((h) => {
+        if (typeof h !== "object" || h === null)
+          return false;
+        const cmd = h["command"];
+        return typeof cmd === "string" && cmd.includes("session-start");
+      });
+    });
+  }
+  async readHooksJson() {
+    const content = await readTextFile(this.hooksJsonPath);
+    if (content === null)
+      return {};
+    try {
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  async writeHooksJson(data) {
+    await mkdir2(this.userDir, { recursive: true });
+    await writeTextFile(this.hooksJsonPath, JSON.stringify(data, null, 2) + `
+`);
+  }
+}
+
+// src/core/agents/opencode.ts
+init_fs();
+init_paths();
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { mkdir as mkdir3, readdir as readdir3, unlink as unlink3 } from "fs/promises";
+var OPENCODE_STATE_DIR = join4(homedir4(), ".local", "state", "opencode");
 
 class OpenCodeAdapter {
   name = "opencode";
   displayName = "OpenCode";
   get configDir() {
-    return join3(homedir3(), ".config", "opencode");
+    return join4(homedir4(), ".config", "opencode");
   }
   get commandsDir() {
-    return join3(this.configDir, "commands");
+    return join4(this.configDir, "commands");
   }
   get pluginsDir() {
-    return join3(this.configDir, "plugins");
+    return join4(this.configDir, "plugins");
   }
   get settingsPath() {
-    return join3(this.configDir, "opencode.json");
+    return join4(this.configDir, "opencode.json");
   }
   get tuiConfigPath() {
-    return join3(this.configDir, "tui.json");
+    return join4(this.configDir, "tui.json");
   }
   async detect() {
     try {
@@ -14776,27 +14998,27 @@ class OpenCodeAdapter {
     return this.commandsDir;
   }
   async installCommands(commandNames, sourceDir) {
-    await mkdir2(ReapPaths.userReapCommands, { recursive: true });
+    await mkdir3(ReapPaths.userReapCommands, { recursive: true });
     for (const cmd of commandNames) {
-      const src = join3(sourceDir, `${cmd}.md`);
-      const dest = join3(ReapPaths.userReapCommands, `${cmd}.md`);
+      const src = join4(sourceDir, `${cmd}.md`);
+      const dest = join4(ReapPaths.userReapCommands, `${cmd}.md`);
       await writeTextFile(dest, await readTextFileOrThrow(src));
     }
   }
   async removeStaleCommands(validNames) {
     try {
-      const existing = await readdir2(this.commandsDir);
+      const existing = await readdir3(this.commandsDir);
       for (const file of existing) {
         if (!file.startsWith("reap.") || !file.endsWith(".md"))
           continue;
         if (!validNames.has(file)) {
-          await unlink2(join3(this.commandsDir, file));
+          await unlink3(join4(this.commandsDir, file));
         }
       }
     } catch {}
   }
   async registerSessionHook(dryRun = false) {
-    const pluginPath = join3(this.pluginsDir, "reap-session-start.js");
+    const pluginPath = join4(this.pluginsDir, "reap-session-start.js");
     const exists = await fileExists(pluginPath);
     let pluginAction = "skipped";
     if (exists) {
@@ -14809,7 +15031,7 @@ class OpenCodeAdapter {
       }
     } else {
       if (!dryRun) {
-        await mkdir2(this.pluginsDir, { recursive: true });
+        await mkdir3(this.pluginsDir, { recursive: true });
         await writeTextFile(pluginPath, await this.getPluginContent());
       }
       pluginAction = "created";
@@ -14836,12 +15058,12 @@ class OpenCodeAdapter {
     }
   }
   async getPluginContent() {
-    const templatePath = join3(ReapPaths.packageHooksDir, "opencode-session-start.js");
+    const templatePath = join4(ReapPaths.packageHooksDir, "opencode-session-start.js");
     return readTextFileOrThrow(templatePath);
   }
   async ensureDefaultVisibility() {
-    const kvPath = join3(OPENCODE_STATE_DIR, "kv.json");
-    await mkdir2(OPENCODE_STATE_DIR, { recursive: true });
+    const kvPath = join4(OPENCODE_STATE_DIR, "kv.json");
+    await mkdir3(OPENCODE_STATE_DIR, { recursive: true });
     let kv = {};
     const existing = await readTextFile(kvPath);
     if (existing) {
@@ -14860,7 +15082,7 @@ class OpenCodeAdapter {
     }
   }
   async ensureTuiConfig() {
-    await mkdir2(this.configDir, { recursive: true });
+    await mkdir3(this.configDir, { recursive: true });
     const reapKeybinds = {
       display_thinking: "<leader>t",
       tool_details: "<leader>d"
@@ -14894,7 +15116,8 @@ class OpenCodeAdapter {
 // src/core/agents/index.ts
 var ALL_ADAPTERS = [
   new ClaudeCodeAdapter,
-  new OpenCodeAdapter
+  new OpenCodeAdapter,
+  new CodexAdapter
 ];
 
 class AgentRegistry {
@@ -14934,17 +15157,17 @@ init_fs();
 // src/core/skills.ts
 init_paths();
 init_fs();
-import { readdir as readdir3, mkdir as mkdir3 } from "fs/promises";
-import { join as join4 } from "path";
+import { readdir as readdir4, mkdir as mkdir4 } from "fs/promises";
+import { join as join5 } from "path";
 async function syncSkillsToProject(projectRoot, dryRun = false) {
-  const projectClaudeSkills = join4(projectRoot, ".claude", "skills");
-  const reapCmdFiles = (await readdir3(ReapPaths.userReapCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
+  const projectClaudeSkills = join5(projectRoot, ".claude", "skills");
+  const reapCmdFiles = (await readdir4(ReapPaths.userReapCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
   let installed = 0;
   for (const file of reapCmdFiles) {
-    const src = await readTextFileOrThrow(join4(ReapPaths.userReapCommands, file));
+    const src = await readTextFileOrThrow(join5(ReapPaths.userReapCommands, file));
     const name = file.replace(/\.md$/, "");
-    const skillDir = join4(projectClaudeSkills, name);
-    const skillFile = join4(skillDir, "SKILL.md");
+    const skillDir = join5(projectClaudeSkills, name);
+    const skillFile = join5(skillDir, "SKILL.md");
     const fmMatch = src.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
     const description = fmMatch ? fmMatch[1].match(/^description:\s*"?([^"\n]*)"?/m)?.[1]?.trim() ?? "" : "";
     const body = fmMatch ? fmMatch[2] : src;
@@ -14957,7 +15180,7 @@ ${body}`;
     if (existing !== null && existing === skillContent)
       continue;
     if (!dryRun) {
-      await mkdir3(skillDir, { recursive: true });
+      await mkdir4(skillDir, { recursive: true });
       await writeTextFile(skillFile, skillContent);
     }
     installed++;
@@ -15007,21 +15230,21 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
     throw new Error(".reap/ already exists. This is already a REAP project.");
   }
   if (preset) {
-    const presetDir = join6(ReapPaths.packageTemplatesDir, "presets", preset);
-    const presetExists = await fileExists(join6(presetDir, "principles.md"));
+    const presetDir = join7(ReapPaths.packageTemplatesDir, "presets", preset);
+    const presetExists = await fileExists(join7(presetDir, "principles.md"));
     if (!presetExists) {
       throw new Error(`Unknown preset: "${preset}". Available presets: bun-hono-react`);
     }
   }
   log("Creating .reap/ directory structure...");
-  await mkdir4(paths.genome, { recursive: true });
-  await mkdir4(paths.domain, { recursive: true });
-  await mkdir4(paths.environment, { recursive: true });
-  await mkdir4(join6(paths.environment, "docs"), { recursive: true });
-  await mkdir4(join6(paths.environment, "resources"), { recursive: true });
-  await mkdir4(paths.life, { recursive: true });
-  await mkdir4(paths.backlog, { recursive: true });
-  await mkdir4(paths.lineage, { recursive: true });
+  await mkdir5(paths.genome, { recursive: true });
+  await mkdir5(paths.domain, { recursive: true });
+  await mkdir5(paths.environment, { recursive: true });
+  await mkdir5(join7(paths.environment, "docs"), { recursive: true });
+  await mkdir5(join7(paths.environment, "resources"), { recursive: true });
+  await mkdir5(paths.life, { recursive: true });
+  await mkdir5(paths.backlog, { recursive: true });
+  await mkdir5(paths.lineage, { recursive: true });
   log("Writing config.yml...");
   let hasGhCli = false;
   try {
@@ -15034,7 +15257,7 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   }
   const detectedLanguage = await AgentRegistry.readLanguage();
   const config = {
-    version: "0.15.2",
+    version: "0.15.3",
     project: projectName,
     entryMode,
     strict: false,
@@ -15047,10 +15270,10 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   await ConfigManager.write(paths, config);
   log("Setting up Genome templates...");
   const genomeTemplates = ["principles.md", "conventions.md", "constraints.md", "source-map.md"];
-  const genomeSourceDir = preset ? join6(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
+  const genomeSourceDir = preset ? join7(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
   for (const file of genomeTemplates) {
-    const src = join6(genomeSourceDir, file);
-    const dest = join6(paths.genome, file);
+    const src = join7(genomeSourceDir, file);
+    const dest = join7(paths.genome, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
   if ((entryMode === "adoption" || entryMode === "migration") && !preset) {
@@ -15059,47 +15282,47 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
     await syncGenomeFromProject2(projectRoot, paths.genome, log);
   }
   log("Installing artifact templates...");
-  await mkdir4(ReapPaths.userReapTemplates, { recursive: true });
+  await mkdir5(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 = join6(ReapPaths.packageArtifactsDir, file);
-    const dest = join6(ReapPaths.userReapTemplates, file);
+    const src = join7(ReapPaths.packageArtifactsDir, file);
+    const dest = join7(ReapPaths.userReapTemplates, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
-  const domainGuideSrc = join6(ReapPaths.packageGenomeDir, "domain/README.md");
-  const domainGuideDest = join6(ReapPaths.userReapTemplates, "domain-guide.md");
+  const domainGuideSrc = join7(ReapPaths.packageGenomeDir, "domain/README.md");
+  const domainGuideDest = join7(ReapPaths.userReapTemplates, "domain-guide.md");
   await writeTextFile(domainGuideDest, await readTextFileOrThrow(domainGuideSrc));
-  const mergeTemplatesDir = join6(ReapPaths.userReapTemplates, "merge");
-  await mkdir4(mergeTemplatesDir, { recursive: true });
+  const mergeTemplatesDir = join7(ReapPaths.userReapTemplates, "merge");
+  await mkdir5(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 = join6(ReapPaths.packageArtifactsDir, "merge");
+  const mergeSourceDir = join7(ReapPaths.packageArtifactsDir, "merge");
   for (const file of mergeArtifactFiles) {
-    const src = join6(mergeSourceDir, file);
-    const dest = join6(mergeTemplatesDir, file);
+    const src = join7(mergeSourceDir, file);
+    const dest = join7(mergeTemplatesDir, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
   log("Installing hook conditions...");
-  const conditionsSourceDir = join6(ReapPaths.packageTemplatesDir, "conditions");
-  const conditionsDestDir = join6(paths.hooks, "conditions");
-  await mkdir4(conditionsDestDir, { recursive: true });
-  const conditionFiles = await readdir5(conditionsSourceDir);
+  const conditionsSourceDir = join7(ReapPaths.packageTemplatesDir, "conditions");
+  const conditionsDestDir = join7(paths.hooks, "conditions");
+  await mkdir5(conditionsDestDir, { recursive: true });
+  const conditionFiles = await readdir6(conditionsSourceDir);
   for (const file of conditionFiles) {
     if (!file.endsWith(".sh"))
       continue;
-    const src = join6(conditionsSourceDir, file);
-    const dest = join6(conditionsDestDir, file);
+    const src = join7(conditionsSourceDir, file);
+    const dest = join7(conditionsDestDir, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
     await chmod(dest, 493);
   }
   log("Installing hook scripts...");
-  const hooksSourceDir = join6(ReapPaths.packageTemplatesDir, "hooks");
+  const hooksSourceDir = join7(ReapPaths.packageTemplatesDir, "hooks");
   const { readdir: readdirAsync } = await import("fs/promises");
   const hookFiles = await readdirAsync(hooksSourceDir);
   for (const file of hookFiles) {
     if (!file.endsWith(".sh") || !file.startsWith("on"))
       continue;
-    const src = join6(hooksSourceDir, file);
-    const dest = join6(paths.hooks, file);
+    const src = join7(hooksSourceDir, file);
+    const dest = join7(paths.hooks, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
     await chmod(dest, 493);
   }
@@ -15111,9 +15334,9 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
     await adapter.installCommands(COMMAND_NAMES, sourceDir);
     log(`  Registering session hook for ${adapter.displayName}...`);
     await adapter.registerSessionHook();
-    if (typeof adapter.setupClaudeMd === "function") {
-      const mdResult = await adapter.setupClaudeMd(projectRoot);
-      log(`  .claude/CLAUDE.md: ${mdResult.action}`);
+    if (typeof adapter.setupAgentMd === "function") {
+      const mdResult = await adapter.setupAgentMd(projectRoot);
+      log(`  [${adapter.displayName}] agent md: ${mdResult.action}`);
     }
   }
   if (detectedAgents.length === 0) {
@@ -15134,9 +15357,9 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
 
 // src/cli/commands/update.ts
 init_paths();
-import { readdir as readdir10, unlink as unlink4, rm as rm2, mkdir as mkdir7 } from "fs/promises";
-import { join as join11 } from "path";
-import { execSync as execSync2 } from "child_process";
+import { readdir as readdir12, unlink as unlink5, rm as rm3, mkdir as mkdir7 } from "fs/promises";
+import { join as join13 } from "path";
+import { execSync as execSync3 } from "child_process";
 
 // src/core/hooks.ts
 async function migrateHooks(dryRun = false) {
@@ -15162,15 +15385,30 @@ init_config();
 init_fs();
 init_generation();
 var import_yaml5 = __toESM(require_dist(), 1);
-import { readdir as readdir9, rename as rename2 } from "fs/promises";
-import { join as join10 } from "path";
+import { readdir as readdir10, rename as rename2 } from "fs/promises";
+import { join as join11 } from "path";
+import { execSync as execSync2 } from "child_process";
+function estimateGenDates(lineagePath, dirName, fallbackDate) {
+  const pattern = join11(lineagePath, `${dirName}*`);
+  const fallback = fallbackDate ?? new Date().toISOString();
+  try {
+    const startedRaw = execSync2(`git log --format=%aI --diff-filter=A -- "${pattern}"`, { encoding: "utf-8", timeout: 5000 }).trim();
+    const startedAt = startedRaw.split(`
+`).pop() || fallback;
+    const completedRaw = execSync2(`git log -1 --format=%aI -- "${pattern}"`, { encoding: "utf-8", timeout: 5000 }).trim();
+    const completedAt = completedRaw || startedAt;
+    return { startedAt, completedAt };
+  } catch {
+    return { startedAt: fallback, completedAt: fallback };
+  }
+}
 async function needsMigration(paths) {
   try {
-    const entries = await readdir9(paths.lineage, { withFileTypes: true });
+    const entries = await readdir10(paths.lineage, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || !entry.name.startsWith("gen-"))
         continue;
-      const metaPath = join10(paths.lineage, entry.name, "meta.yml");
+      const metaPath = join11(paths.lineage, entry.name, "meta.yml");
       const content = await readTextFile(metaPath);
       if (content === null)
         return true;
@@ -15184,18 +15422,18 @@ async function migrateLineage(paths) {
   const result = { migrated: [], skipped: [], errors: [] };
   let entries;
   try {
-    const dirEntries = await readdir9(paths.lineage, { withFileTypes: true });
+    const dirEntries = await readdir10(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 = join10(paths.lineage, dirName, "meta.yml");
+    const metaPath = join11(paths.lineage, dirName, "meta.yml");
     const metaContent = await readTextFile(metaPath);
     const seq = parseGenSeq(dirName);
     let goal = "";
-    const objContent = await readTextFile(join10(paths.lineage, dirName, "01-objective.md"));
+    const objContent = await readTextFile(join11(paths.lineage, dirName, "01-objective.md"));
     if (objContent) {
       const goalMatch = objContent.match(/## Goal\n+([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -15210,7 +15448,7 @@ async function migrateLineage(paths) {
   let prevId = null;
   for (const entry of plan) {
     if (entry.hasMeta) {
-      const metaContent = await readTextFile(join10(paths.lineage, entry.dirName, "meta.yml"));
+      const metaContent = await readTextFile(join11(paths.lineage, entry.dirName, "meta.yml"));
       if (metaContent) {
         const meta = import_yaml5.default.parse(metaContent);
         prevId = meta.id;
@@ -15222,20 +15460,21 @@ async function migrateLineage(paths) {
       const parents = prevId ? [prevId] : [];
       const hash = generateGenHash(parents, entry.goal, "legacy", "migration", `legacy-${entry.seq}`);
       const newId = formatGenId(entry.seq, hash);
+      const dates = estimateGenDates(paths.lineage, entry.dirName);
       const meta = {
         id: newId,
         type: "normal",
         parents,
         goal: entry.goal,
         genomeHash: "legacy",
-        startedAt: `legacy-${entry.seq}`,
-        completedAt: `legacy-${entry.seq}`
+        startedAt: dates.startedAt,
+        completedAt: dates.completedAt
       };
-      await writeTextFile(join10(paths.lineage, entry.dirName, "meta.yml"), import_yaml5.default.stringify(meta));
+      await writeTextFile(join11(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(join10(paths.lineage, entry.dirName), join10(paths.lineage, newDirName));
+        await rename2(join11(paths.lineage, entry.dirName), join11(paths.lineage, newDirName));
       }
       prevId = newId;
       result.migrated.push(`${entry.dirName} → ${newDirName}`);
@@ -15355,752 +15594,753 @@ class MigrationRunner {
   }
 }
 
-// src/core/migration-spec.ts
+// src/core/integrity.ts
 init_fs();
+init_lifecycle();
+init_types();
 var import_yaml6 = __toESM(require_dist(), 1);
-import { existsSync as existsSync2 } from "fs";
-function buildMigrationSpec(paths) {
-  const sections = [];
-  sections.push(`## Config fields (config.yml)
-
-| Field | Type | Required | Default |
-|-------|------|----------|---------|
-| version | string | yes | — |
-| project | string | yes | — |
-| entryMode | greenfield \\| migration \\| adoption | yes | — |
-| stack | string | no | — |
-| preset | string | no | — |
-| agents | AgentName[] | no | auto-detect |
-| language | string | no | — |
-| autoUpdate | boolean | no | true |
-| autoSubagent | boolean | no | true |
-| autoIssueReport | boolean | no | false |
-| strict | boolean \\| { edit?: boolean; merge?: boolean } | no | false |`);
-  sections.push(`## Expected directory structure
-
-.reap/
-├── config.yml
-├── genome/
-│   ├── principles.md
-│   ├── conventions.md
-│   ├── constraints.md
-│   ├── source-map.md
-│   └── domain/
-├── environment/
-│   ├── summary.md
-│   ├── docs/
-│   └── resources/
-├── life/
-│   ├── current.yml
-│   ├── backlog/
-│   ├── 01-objective.md
-│   ├── 02-planning.md
-│   ├── 03-implementation.md
-│   ├── 04-validation.md
-│   └── 05-completion.md
-├── lineage/
-│   └── gen-NNN-hash/ or gen-NNN-hash.md
-└── hooks/
-    ├── conditions/
-    └── {event}.{name}.{sh|md}`);
-  sections.push(`## Slash commands (29)
-
-reap.objective, reap.planning, reap.implementation,
-reap.validation, reap.completion, reap.evolve,
-reap.start, reap.next, reap.back, reap.abort,
-reap.status, reap.sync, reap.sync.genome, reap.sync.environment,
-reap.help, reap.update, reap.report,
-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,
-reap.config`);
-  sections.push(`## Hooks format
-
-File naming: {event}.{name}.{md|sh}
-Location: .reap/hooks/
-
-Frontmatter (md hooks):
----
-event: onLifeStarted
-name: my-hook
-description: What this hook does
----
-
-Condition files: .reap/hooks/conditions/{name}.yml`);
-  sections.push(`## Project root: ${paths.projectRoot}`);
-  return sections.join(`
-
-`);
+import { readdir as readdir11, stat as stat3 } from "fs/promises";
+import { join as join12 } from "path";
+import { homedir as homedir5 } from "os";
+var VALID_BACKLOG_TYPES = ["genome-change", "environment-change", "task"];
+var VALID_BACKLOG_STATUSES = ["pending", "consumed"];
+var VALID_GENERATION_TYPES = ["normal", "merge", "recovery"];
+var GENOME_LINE_WARNING_THRESHOLD = 100;
+var ISO_DATE_RE2 = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
+function isISODate(s) {
+  return ISO_DATE_RE2.test(s) && !Number.isNaN(new Date(s).getTime());
 }
-async function detectMigrationGaps(paths) {
-  const gaps = [];
-  const configContent = await readTextFile(paths.config);
-  if (configContent === null) {
-    gaps.push("config.yml missing");
-  } else {
+async function checkIntegrity(paths) {
+  const errors = [];
+  const warnings = [];
+  await checkDirectoryStructure(paths, errors);
+  await checkConfig(paths, errors, warnings);
+  const state = await checkCurrentYml(paths, errors, warnings);
+  await checkLineage(paths, errors, warnings);
+  await checkGenome(paths, errors, warnings);
+  await checkBacklog(paths, errors, warnings);
+  if (state) {
+    await checkArtifacts(paths, state, errors, warnings);
+  }
+  return { errors, warnings };
+}
+async function checkDirectoryStructure(paths, errors) {
+  const requiredDirs = [
+    { path: paths.genome, name: "genome/" },
+    { path: paths.environment, name: "environment/" },
+    { path: paths.life, name: "life/" },
+    { path: paths.lineage, name: "lineage/" },
+    { path: paths.backlog, name: "life/backlog/" },
+    { path: paths.hooks, name: "hooks/" },
+    { path: paths.hookConditions, name: "hooks/conditions/" }
+  ];
+  for (const dir of requiredDirs) {
     try {
-      const config = import_yaml6.default.parse(configContent);
-      if (!config?.version)
-        gaps.push("config.yml: missing required field 'version'");
-      if (!config?.project)
-        gaps.push("config.yml: missing required field 'project'");
-      if (!config?.entryMode)
-        gaps.push("config.yml: missing required field 'entryMode'");
+      const s = await stat3(dir.path);
+      if (!s.isDirectory()) {
+        errors.push(`${dir.name} directory missing`);
+      }
     } catch {
-      gaps.push("config.yml: invalid YAML");
+      errors.push(`${dir.name} directory missing`);
     }
   }
-  if (!existsSync2(paths.genome)) {
-    gaps.push("genome/ directory missing");
-  } else {
-    const genomeFiles = [
-      { path: paths.principles, label: "genome/principles.md" },
-      { path: paths.conventions, label: "genome/conventions.md" },
-      { path: paths.constraints, label: "genome/constraints.md" },
-      { path: paths.sourceMap, label: "genome/source-map.md" }
-    ];
-    for (const { path, label } of genomeFiles) {
-      if (!existsSync2(path)) {
-        gaps.push(`${label} missing`);
-      }
-    }
+}
+async function checkConfig(paths, errors, warnings) {
+  const content = await readTextFile(paths.config);
+  if (content === null) {
+    errors.push("config.yml does not exist");
+    return;
+  }
+  let config;
+  try {
+    config = import_yaml6.default.parse(content) ?? {};
+  } catch {
+    errors.push("config.yml is not valid YAML");
+    return;
   }
-  if (!existsSync2(paths.environment)) {
-    gaps.push("environment/ directory missing");
+  if (typeof config !== "object" || Array.isArray(config)) {
+    errors.push("config.yml root must be a YAML mapping");
+    return;
+  }
+  if (!config.project || typeof config.project !== "string") {
+    errors.push("config.yml: missing or invalid 'project' field (string required)");
   }
-  if (!existsSync2(paths.life)) {
-    gaps.push("life/ directory missing");
+  if (!config.entryMode || typeof config.entryMode !== "string") {
+    errors.push("config.yml: missing or invalid 'entryMode' field (string required)");
   } else {
-    if (!existsSync2(paths.backlog)) {
-      gaps.push("life/backlog/ directory missing");
+    const validModes = ["greenfield", "migration", "adoption"];
+    if (!validModes.includes(config.entryMode)) {
+      errors.push(`config.yml: invalid entryMode "${config.entryMode}" (valid: ${validModes.join(", ")})`);
     }
   }
-  if (!existsSync2(paths.lineage)) {
-    gaps.push("lineage/ directory missing");
+  if (config.version !== undefined && typeof config.version !== "string") {
+    warnings.push("config.yml: 'version' should be a string");
+  }
+  if (config.strict !== undefined && typeof config.strict !== "boolean" && typeof config.strict !== "object") {
+    warnings.push("config.yml: 'strict' should be boolean or object");
   }
-  if (!existsSync2(paths.hooks)) {
-    gaps.push("hooks/ directory missing");
+  if (config.autoUpdate !== undefined && typeof config.autoUpdate !== "boolean") {
+    warnings.push("config.yml: 'autoUpdate' should be boolean");
   }
-  if (!existsSync2(paths.hookConditions)) {
-    gaps.push("hooks/conditions/ directory missing");
+  if (config.autoSubagent !== undefined && typeof config.autoSubagent !== "boolean") {
+    warnings.push("config.yml: 'autoSubagent' should be boolean");
   }
-  return gaps;
 }
-
-// src/cli/commands/update.ts
-function selfUpgrade() {
+async function checkCurrentYml(paths, errors, warnings) {
+  const content = await readTextFile(paths.currentYml);
+  if (content === null || !content.trim()) {
+    return null;
+  }
+  let state;
   try {
-    const installed = execSync2("reap --version", { encoding: "utf-8", timeout: 5000 }).trim();
-    if (installed.includes("+dev")) {
-      return { upgraded: false };
-    }
-    const latest = execSync2("npm view @c-d-cc/reap version", { encoding: "utf-8", timeout: 1e4 }).trim();
-    if (installed === latest) {
-      return { upgraded: false };
-    }
-    execSync2("npm update -g @c-d-cc/reap", { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
-    return { upgraded: true, from: installed, to: latest };
+    state = import_yaml6.default.parse(content) ?? {};
   } catch {
-    return { upgraded: false };
+    errors.push("current.yml is not valid YAML");
+    return null;
   }
-}
-async function updateProject(projectRoot, dryRun = false) {
-  const paths = new ReapPaths(projectRoot);
-  const result = { updated: [], skipped: [], removed: [] };
-  const config = await paths.isReapProject() ? await ConfigManager.read(paths) : null;
-  const adapters = await AgentRegistry.getActiveAdapters(config ?? undefined);
-  const commandsDir = ReapPaths.packageCommandsDir;
-  const commandFiles = await readdir10(commandsDir);
-  await mkdir7(ReapPaths.userReapCommands, { recursive: true });
-  for (const file of commandFiles) {
-    if (!file.endsWith(".md"))
-      continue;
-    const src = await readTextFileOrThrow(join11(commandsDir, file));
-    const dest = join11(ReapPaths.userReapCommands, file);
-    const existing = await readTextFile(dest);
-    if (existing !== null && existing === src) {
-      result.skipped.push(`~/.reap/commands/${file}`);
-    } else {
-      if (!dryRun)
-        await writeTextFile(dest, src);
-      result.updated.push(`~/.reap/commands/${file}`);
+  if (typeof state !== "object" || Array.isArray(state)) {
+    errors.push("current.yml root must be a YAML mapping");
+    return null;
+  }
+  const requiredStrings = ["id", "goal", "stage", "startedAt"];
+  for (const field of requiredStrings) {
+    if (!state[field] || typeof state[field] !== "string") {
+      errors.push(`current.yml: missing or invalid '${field}' field (string required)`);
     }
   }
-  for (const adapter of adapters) {
-    const agentCmdDir = adapter.getCommandsDir();
-    const label = adapter.displayName;
-    try {
-      const existing = await readdir10(agentCmdDir);
-      for (const file of existing) {
-        if (!file.startsWith("reap.") || !file.endsWith(".md"))
-          continue;
-        const filePath = join11(agentCmdDir, file);
-        const content = await readTextFile(filePath);
-        if (content !== null && content.includes("redirected to ~/.reap/commands/")) {
-          if (!dryRun)
-            await unlink4(filePath);
-          result.removed.push(`[${label}] commands/${file} (Phase 2: redirect removed)`);
-        }
-      }
-    } catch {}
+  if (state.genomeVersion === undefined || typeof state.genomeVersion !== "number") {
+    errors.push("current.yml: missing or invalid 'genomeVersion' field (number required)");
   }
-  for (const adapter of adapters) {
-    if (typeof adapter.cleanupLegacyCommands === "function") {
-      const removed = await adapter.cleanupLegacyCommands();
-      for (const file of removed) {
-        result.removed.push(`[${adapter.displayName}] ~commands/${file} (legacy user-level)`);
-      }
-    }
+  if (!Array.isArray(state.timeline)) {
+    errors.push("current.yml: missing or invalid 'timeline' field (array required)");
   }
-  await mkdir7(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(join11(ReapPaths.packageArtifactsDir, file));
-    const dest = join11(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}`);
+  if (state.type !== undefined) {
+    if (!VALID_GENERATION_TYPES.includes(state.type)) {
+      errors.push(`current.yml: invalid type "${state.type}" (valid: ${VALID_GENERATION_TYPES.join(", ")})`);
     }
   }
-  const domainGuideSrc = await readTextFileOrThrow(join11(ReapPaths.packageGenomeDir, "domain/README.md"));
-  const domainGuideDest = join11(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`);
+  if (state.parents !== undefined && !Array.isArray(state.parents)) {
+    errors.push("current.yml: 'parents' must be an array");
   }
-  const mergeTemplatesDir = join11(ReapPaths.userReapTemplates, "merge");
-  await mkdir7(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 = join11(ReapPaths.packageArtifactsDir, "merge");
-  for (const file of mergeArtifactFiles) {
-    const src = await readTextFileOrThrow(join11(mergeSourceDir, file));
-    const dest = join11(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}`);
+  if (typeof state.stage === "string" && !LifeCycle.isValid(state.stage)) {
+    const mergeStages = ["detect", "mate", "merge", "sync", "validation", "completion"];
+    if (!mergeStages.includes(state.stage)) {
+      errors.push(`current.yml: invalid stage "${state.stage}"`);
     }
   }
-  const migrations = await migrateHooks(dryRun);
-  for (const m of migrations.results) {
-    if (m.action === "migrated") {
-      result.updated.push(`[${m.agent}] hooks (migrated)`);
+  if (state.type === "recovery") {
+    if (!state.recovers || !Array.isArray(state.recovers) || state.recovers.length === 0) {
+      errors.push("current.yml: recovery generation must have non-empty 'recovers' array");
     }
   }
-  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`);
-    }
+  return state;
+}
+async function checkLineage(paths, errors, warnings) {
+  let entries;
+  try {
+    const items2 = await readdir11(paths.lineage, { withFileTypes: true });
+    entries = items2.map((i) => ({ name: i.name, isDir: i.isDirectory(), isFile: i.isFile() }));
+  } catch {
+    return;
   }
-  for (const adapter of adapters) {
-    if (typeof adapter.setupClaudeMd === "function") {
-      const mdResult = await adapter.setupClaudeMd(projectRoot);
-      if (mdResult.action !== "skipped") {
-        result.updated.push(`[${adapter.displayName}] .claude/CLAUDE.md (${mdResult.action})`);
-      } else {
-        result.skipped.push(`[${adapter.displayName}] .claude/CLAUDE.md`);
+  const items = await readdir11(paths.lineage, { withFileTypes: true });
+  const allMetaIds = new Set;
+  for (const item of items) {
+    if (item.isDirectory() && item.name.startsWith("gen-")) {
+      const metaPath = join12(paths.lineage, item.name, "meta.yml");
+      const metaContent = await readTextFile(metaPath);
+      if (metaContent === null) {
+        errors.push(`lineage/${item.name}: missing meta.yml`);
+        continue;
       }
-    }
-  }
-  if (await paths.isReapProject()) {
-    if (!dryRun) {
-      const backfillResult = await ConfigManager.backfill(paths);
-      if (backfillResult.added.length > 0) {
-        result.updated.push(`Config: added ${backfillResult.added.join(", ")}`);
+      let meta;
+      try {
+        meta = import_yaml6.default.parse(metaContent) ?? {};
+      } catch {
+        errors.push(`lineage/${item.name}/meta.yml: invalid YAML`);
+        continue;
       }
-    }
-    const skillsResult = await syncSkillsToProject(paths.projectRoot, dryRun);
-    if (skillsResult.installed > 0) {
-      result.updated.push(`.claude/skills/ (${skillsResult.installed} synced)`);
-    } else {
-      result.skipped.push(`.claude/skills/ (${skillsResult.total} unchanged)`);
-    }
-    const projectClaudeCommands = join11(paths.projectRoot, ".claude", "commands");
-    try {
-      const legacyFiles = (await readdir10(projectClaudeCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
-      for (const file of legacyFiles) {
-        if (!dryRun)
-          await unlink4(join11(projectClaudeCommands, file));
-        result.removed.push(`.claude/commands/${file} (legacy)`);
+      validateLineageMeta(meta, `lineage/${item.name}/meta.yml`, errors, warnings);
+      if (meta.id)
+        allMetaIds.add(meta.id);
+    } else if (item.isFile() && item.name.startsWith("gen-") && item.name.endsWith(".md")) {
+      const content = await readTextFile(join12(paths.lineage, item.name));
+      if (!content)
+        continue;
+      const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (!fmMatch) {
+        warnings.push(`lineage/${item.name}: compressed file missing frontmatter`);
+        continue;
       }
-    } catch {}
-    await migrateLegacyFiles(paths, dryRun, result);
-    const currentVersion = "0.15.2";
-    const migrationResult = await MigrationRunner.run(paths, currentVersion, dryRun);
-    for (const m of migrationResult.migrated) {
-      result.updated.push(`[migration] ${m}`);
-    }
-    for (const s of migrationResult.skipped) {
-      result.skipped.push(`[migration] ${s}`);
-    }
-    for (const e of migrationResult.errors) {
-      result.removed.push(`[migration error] ${e}`);
-    }
-    const gaps = await detectMigrationGaps(paths);
-    if (gaps.length > 0) {
-      const spec = buildMigrationSpec(paths);
-      console.log(JSON.stringify({
-        status: "prompt",
-        command: "migrate",
-        gaps,
-        spec,
-        prompt: "Analyze the gaps between current .reap/ structure and expected structure. Fix each gap after user confirmation."
-      }, null, 2));
-    }
-    if (migrationResult.errors.length > 0 && config?.autoIssueReport) {
+      let meta;
       try {
-        const { execSync: execSync3 } = await import("child_process");
-        const errorSummary = migrationResult.errors.join("\\n");
-        const title = `Migration failure: ${migrationResult.fromVersion} → ${migrationResult.toVersion}`;
-        const body = `## Migration Error\\n\\nFrom: ${migrationResult.fromVersion}\\nTo: ${migrationResult.toVersion}\\n\\n### Errors\\n\\n${errorSummary}`;
-        execSync3(`gh issue create --repo c-d-cc/reap --title "${title}" --label "auto-reported,migration" --body "${body}"`, { encoding: "utf-8", timeout: 15000, stdio: "pipe" });
-      } catch {}
+        meta = import_yaml6.default.parse(fmMatch[1]) ?? {};
+      } catch {
+        errors.push(`lineage/${item.name}: invalid frontmatter YAML`);
+        continue;
+      }
+      validateLineageMeta(meta, `lineage/${item.name}`, errors, warnings);
+      if (meta.id)
+        allMetaIds.add(meta.id);
     }
   }
-  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 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 unlink4(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)`);
-            }
-          }
+  for (const item of items) {
+    let parents = [];
+    if (item.isDirectory() && item.name.startsWith("gen-")) {
+      const metaContent = await readTextFile(join12(paths.lineage, item.name, "meta.yml"));
+      if (metaContent) {
+        try {
+          const meta = import_yaml6.default.parse(metaContent);
+          parents = meta?.parents ?? [];
+        } catch {}
+      }
+    } else if (item.isFile() && item.name.startsWith("gen-") && item.name.endsWith(".md")) {
+      const content = await readTextFile(join12(paths.lineage, item.name));
+      if (content) {
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (fmMatch) {
+          try {
+            const meta = import_yaml6.default.parse(fmMatch[1]);
+            parents = meta?.parents ?? [];
+          } catch {}
         }
       }
     }
-  } catch {}
-}
-async function removeDirIfExists(dirPath, label, dryRun, result) {
-  try {
-    const entries = await readdir10(dirPath);
-    if (entries.length > 0 || true) {
-      if (!dryRun)
-        await rm2(dirPath, { recursive: true });
-      result.removed.push(label);
+    for (const parent of parents) {
+      if (parent && !allMetaIds.has(parent)) {
+        const epochContent = await readTextFile(join12(paths.lineage, "epoch.md"));
+        let inEpoch = false;
+        if (epochContent) {
+          inEpoch = epochContent.includes(parent);
+        }
+        if (!inEpoch) {
+          warnings.push(`lineage/${item.name}: parent "${parent}" not found in lineage (may be in a compressed epoch)`);
+        }
+      }
     }
-  } catch {}
-}
-
-// src/cli/commands/status.ts
-init_paths();
-init_generation();
-init_config();
-async function getStatus(projectRoot) {
-  const paths = new ReapPaths(projectRoot);
-  const config = await ConfigManager.read(paths);
-  const mgr = new GenerationManager(paths);
-  const current = await mgr.current();
-  const completedGens = await mgr.listCompleted();
-  return {
-    version: config.version,
-    project: config.project,
-    entryMode: config.entryMode,
-    lastSyncedGeneration: config.lastSyncedGeneration,
-    generation: current ? {
-      id: current.id,
-      goal: current.goal,
-      stage: current.stage,
-      genomeVersion: current.genomeVersion,
-      startedAt: current.startedAt,
-      type: current.type,
-      parents: current.parents,
-      genomeHash: current.genomeHash
-    } : null,
-    totalGenerations: completedGens.length
-  };
-}
-
-// src/cli/commands/fix.ts
-init_paths();
-init_lifecycle();
-init_fs();
-var import_yaml8 = __toESM(require_dist(), 1);
-import { mkdir as mkdir8, stat as stat4, copyFile } from "fs/promises";
-import { join as join13 } from "path";
-
-// src/core/integrity.ts
-init_fs();
-init_lifecycle();
-init_types();
-var import_yaml7 = __toESM(require_dist(), 1);
-import { readdir as readdir11 } from "fs/promises";
-import { join as join12 } from "path";
-var VALID_BACKLOG_TYPES = ["genome-change", "environment-change", "task"];
-var VALID_BACKLOG_STATUSES = ["pending", "consumed"];
-var VALID_GENERATION_TYPES = ["normal", "merge", "recovery"];
-var GENOME_LINE_WARNING_THRESHOLD = 100;
-var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
-function isISODate(s) {
-  return ISO_DATE_RE.test(s) && !Number.isNaN(new Date(s).getTime());
-}
-async function checkIntegrity(paths) {
-  const errors = [];
-  const warnings = [];
-  await checkConfig(paths, errors, warnings);
-  const state = await checkCurrentYml(paths, errors, warnings);
-  await checkLineage(paths, errors, warnings);
-  await checkGenome(paths, errors, warnings);
-  await checkBacklog(paths, errors, warnings);
-  if (state) {
-    await checkArtifacts(paths, state, errors, warnings);
   }
-  return { errors, warnings };
 }
-async function checkConfig(paths, errors, warnings) {
-  const content = await readTextFile(paths.config);
-  if (content === null) {
-    errors.push("config.yml does not exist");
-    return;
-  }
-  let config;
-  try {
-    config = import_yaml7.default.parse(content) ?? {};
-  } catch {
-    errors.push("config.yml is not valid YAML");
-    return;
-  }
-  if (typeof config !== "object" || Array.isArray(config)) {
-    errors.push("config.yml root must be a YAML mapping");
-    return;
-  }
-  if (!config.project || typeof config.project !== "string") {
-    errors.push("config.yml: missing or invalid 'project' field (string required)");
+function validateLineageMeta(meta, location, errors, warnings) {
+  const requiredStrings = ["id", "goal", "startedAt", "completedAt"];
+  for (const field of requiredStrings) {
+    if (!meta[field] || typeof meta[field] !== "string") {
+      errors.push(`${location}: missing or invalid '${field}' field`);
+    }
   }
-  if (!config.entryMode || typeof config.entryMode !== "string") {
-    errors.push("config.yml: missing or invalid 'entryMode' field (string required)");
-  } else {
-    const validModes = ["greenfield", "migration", "adoption"];
-    if (!validModes.includes(config.entryMode)) {
-      errors.push(`config.yml: invalid entryMode "${config.entryMode}" (valid: ${validModes.join(", ")})`);
+  if (typeof meta.completedAt === "string") {
+    if (!isISODate(meta.completedAt)) {
+      errors.push(`${location}: completedAt "${meta.completedAt}" is not a valid ISO date`);
     }
   }
-  if (config.version !== undefined && typeof config.version !== "string") {
-    warnings.push("config.yml: 'version' should be a string");
+  if (typeof meta.startedAt === "string") {
+    if (!isISODate(meta.startedAt)) {
+      warnings.push(`${location}: startedAt "${meta.startedAt}" is not a valid ISO date`);
+    }
   }
-  if (config.strict !== undefined && typeof config.strict !== "boolean" && typeof config.strict !== "object") {
-    warnings.push("config.yml: 'strict' should be boolean or object");
+  if (!Array.isArray(meta.parents)) {
+    errors.push(`${location}: missing or invalid 'parents' field (array required)`);
   }
-  if (config.autoUpdate !== undefined && typeof config.autoUpdate !== "boolean") {
-    warnings.push("config.yml: 'autoUpdate' should be boolean");
+  if (!meta.type || typeof meta.type !== "string") {
+    errors.push(`${location}: missing or invalid 'type' field`);
+  } else if (!VALID_GENERATION_TYPES.includes(meta.type)) {
+    errors.push(`${location}: invalid type "${meta.type}"`);
   }
-  if (config.autoSubagent !== undefined && typeof config.autoSubagent !== "boolean") {
-    warnings.push("config.yml: 'autoSubagent' should be boolean");
+  if (meta.genomeHash !== undefined && typeof meta.genomeHash !== "string") {
+    warnings.push(`${location}: genomeHash should be a string`);
   }
 }
-async function checkCurrentYml(paths, errors, warnings) {
-  const content = await readTextFile(paths.currentYml);
-  if (content === null || !content.trim()) {
-    return null;
+async function checkGenome(paths, errors, warnings) {
+  const l1Files = [
+    { path: paths.principles, name: "principles.md" },
+    { path: paths.conventions, name: "conventions.md" },
+    { path: paths.constraints, name: "constraints.md" },
+    { path: paths.sourceMap, name: "source-map.md" }
+  ];
+  for (const gf of l1Files) {
+    if (!await fileExists(gf.path)) {
+      errors.push(`genome/${gf.name} does not exist`);
+      continue;
+    }
+    const content = await readTextFile(gf.path);
+    if (content === null)
+      continue;
+    const lines = content.split(`
+`).length;
+    if (lines > GENOME_LINE_WARNING_THRESHOLD) {
+      warnings.push(`genome/${gf.name}: ${lines} lines (exceeds ~${GENOME_LINE_WARNING_THRESHOLD} line guideline)`);
+    }
+    const stripped = content.split(`
+`).filter((l) => !l.startsWith("#") && !l.startsWith(">") && !l.startsWith("-") && l.trim() !== "").join("").trim();
+    if (stripped.length === 0) {
+      warnings.push(`genome/${gf.name}: appears to be placeholder-only (no substantive content)`);
+    }
   }
-  let state;
+}
+async function checkBacklog(paths, errors, warnings) {
+  let entries;
   try {
-    state = import_yaml7.default.parse(content) ?? {};
+    entries = await readdir11(paths.backlog);
   } catch {
-    errors.push("current.yml is not valid YAML");
-    return null;
-  }
-  if (typeof state !== "object" || Array.isArray(state)) {
-    errors.push("current.yml root must be a YAML mapping");
-    return null;
+    return;
   }
-  const requiredStrings = ["id", "goal", "stage", "startedAt"];
-  for (const field of requiredStrings) {
-    if (!state[field] || typeof state[field] !== "string") {
-      errors.push(`current.yml: missing or invalid '${field}' field (string required)`);
+  for (const filename of entries) {
+    if (!filename.endsWith(".md"))
+      continue;
+    const content = await readTextFile(join12(paths.backlog, filename));
+    if (!content)
+      continue;
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) {
+      errors.push(`backlog/${filename}: missing frontmatter`);
+      continue;
     }
-  }
-  if (state.genomeVersion === undefined || typeof state.genomeVersion !== "number") {
-    errors.push("current.yml: missing or invalid 'genomeVersion' field (number required)");
-  }
-  if (!Array.isArray(state.timeline)) {
-    errors.push("current.yml: missing or invalid 'timeline' field (array required)");
-  }
-  if (state.type !== undefined) {
-    if (!VALID_GENERATION_TYPES.includes(state.type)) {
-      errors.push(`current.yml: invalid type "${state.type}" (valid: ${VALID_GENERATION_TYPES.join(", ")})`);
+    let fm;
+    try {
+      fm = import_yaml6.default.parse(fmMatch[1]) ?? {};
+    } catch {
+      errors.push(`backlog/${filename}: invalid frontmatter YAML`);
+      continue;
+    }
+    if (!fm.type || typeof fm.type !== "string") {
+      errors.push(`backlog/${filename}: missing or invalid 'type' field in frontmatter`);
+    } else if (!VALID_BACKLOG_TYPES.includes(fm.type)) {
+      errors.push(`backlog/${filename}: invalid type "${fm.type}" (valid: ${VALID_BACKLOG_TYPES.join(", ")})`);
+    }
+    if (!fm.status || typeof fm.status !== "string") {
+      errors.push(`backlog/${filename}: missing or invalid 'status' field in frontmatter`);
+    } else if (!VALID_BACKLOG_STATUSES.includes(fm.status)) {
+      errors.push(`backlog/${filename}: invalid status "${fm.status}" (valid: ${VALID_BACKLOG_STATUSES.join(", ")})`);
+    }
+    if (fm.status === "consumed" && !fm.consumedBy) {
+      errors.push(`backlog/${filename}: status is 'consumed' but missing 'consumedBy' field`);
     }
   }
-  if (state.parents !== undefined && !Array.isArray(state.parents)) {
-    errors.push("current.yml: 'parents' must be an array");
-  }
-  if (typeof state.stage === "string" && !LifeCycle.isValid(state.stage)) {
-    const mergeStages = ["detect", "mate", "merge", "sync", "validation", "completion"];
-    if (!mergeStages.includes(state.stage)) {
-      errors.push(`current.yml: invalid stage "${state.stage}"`);
+}
+var STAGE_ARTIFACT_MAP = {
+  objective: "01-objective.md",
+  planning: "02-planning.md",
+  implementation: "03-implementation.md",
+  validation: "04-validation.md",
+  completion: "05-completion.md"
+};
+async function checkArtifacts(paths, state, errors, warnings) {
+  const currentStageIdx = LIFECYCLE_ORDER.indexOf(state.stage);
+  if (currentStageIdx < 0)
+    return;
+  for (let i = 0;i < currentStageIdx; i++) {
+    const stage = LIFECYCLE_ORDER[i];
+    const artifactName = STAGE_ARTIFACT_MAP[stage];
+    if (!artifactName)
+      continue;
+    const artifactPath = paths.artifact(artifactName);
+    if (!await fileExists(artifactPath)) {
+      errors.push(`artifact ${artifactName} missing (expected for completed stage '${stage}')`);
+      continue;
+    }
+    const content = await readTextFile(artifactPath);
+    if (content && !content.startsWith("# REAP MANAGED")) {
+      warnings.push(`artifact ${artifactName}: missing 'REAP MANAGED' header`);
     }
   }
-  if (state.type === "recovery") {
-    if (!state.recovers || !Array.isArray(state.recovers) || state.recovers.length === 0) {
-      errors.push("current.yml: recovery generation must have non-empty 'recovers' array");
+  const currentArtifact = STAGE_ARTIFACT_MAP[state.stage];
+  if (currentArtifact) {
+    const artifactPath = paths.artifact(currentArtifact);
+    if (!await fileExists(artifactPath)) {
+      warnings.push(`artifact ${currentArtifact} not yet created for current stage '${state.stage}'`);
     }
   }
-  return state;
 }
-async function checkLineage(paths, errors, warnings) {
+async function checkUserLevelArtifacts(projectRoot) {
+  const errors = [];
+  const warnings = [];
+  const home = homedir5();
+  await checkGlobPattern(join12(home, ".claude", "skills"), /^reap\./, "~/.claude/skills/", "user-level reap skill found (should only be project-level)", errors);
+  await checkGlobPattern(join12(home, ".claude", "commands"), /^reap\./, "~/.claude/commands/", "legacy reap command at user level (Phase 2 remnant)", warnings);
+  await checkGlobPattern(join12(home, ".config", "opencode", "commands"), /^reap\./, "~/.config/opencode/commands/", "legacy reap command at user level (Phase 2 remnant)", warnings);
+  await checkGlobPattern(join12(projectRoot, ".claude", "commands"), /^reap\./, ".claude/commands/", "legacy project-level reap command (should be migrated to skills/)", warnings);
+  return { errors, warnings };
+}
+async function checkGlobPattern(dir, pattern, displayDir, message, target) {
   let entries;
   try {
-    const items2 = await readdir11(paths.lineage, { withFileTypes: true });
-    entries = items2.map((i) => ({ name: i.name, isDir: i.isDirectory(), isFile: i.isFile() }));
+    entries = await readdir11(dir);
   } catch {
     return;
   }
-  const items = await readdir11(paths.lineage, { withFileTypes: true });
-  const allMetaIds = new Set;
-  for (const item of items) {
-    if (item.isDirectory() && item.name.startsWith("gen-")) {
-      const metaPath = join12(paths.lineage, item.name, "meta.yml");
-      const metaContent = await readTextFile(metaPath);
-      if (metaContent === null) {
-        errors.push(`lineage/${item.name}: missing meta.yml`);
-        continue;
-      }
-      let meta;
-      try {
-        meta = import_yaml7.default.parse(metaContent) ?? {};
-      } catch {
-        errors.push(`lineage/${item.name}/meta.yml: invalid YAML`);
-        continue;
-      }
-      validateLineageMeta(meta, `lineage/${item.name}/meta.yml`, errors, warnings);
-      if (meta.id)
-        allMetaIds.add(meta.id);
-    } else if (item.isFile() && item.name.startsWith("gen-") && item.name.endsWith(".md")) {
-      const content = await readTextFile(join12(paths.lineage, item.name));
-      if (!content)
-        continue;
-      const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-      if (!fmMatch) {
-        warnings.push(`lineage/${item.name}: compressed file missing frontmatter`);
-        continue;
-      }
-      let meta;
-      try {
-        meta = import_yaml7.default.parse(fmMatch[1]) ?? {};
-      } catch {
-        errors.push(`lineage/${item.name}: invalid frontmatter YAML`);
-        continue;
-      }
-      validateLineageMeta(meta, `lineage/${item.name}`, errors, warnings);
-      if (meta.id)
-        allMetaIds.add(meta.id);
+  for (const entry of entries) {
+    if (pattern.test(entry)) {
+      target.push(`${displayDir}${entry}: ${message}`);
     }
   }
-  for (const item of items) {
-    let parents = [];
-    if (item.isDirectory() && item.name.startsWith("gen-")) {
-      const metaContent = await readTextFile(join12(paths.lineage, item.name, "meta.yml"));
-      if (metaContent) {
-        try {
-          const meta = import_yaml7.default.parse(metaContent);
-          parents = meta?.parents ?? [];
-        } catch {}
-      }
-    } else if (item.isFile() && item.name.startsWith("gen-") && item.name.endsWith(".md")) {
-      const content = await readTextFile(join12(paths.lineage, item.name));
-      if (content) {
-        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-        if (fmMatch) {
-          try {
-            const meta = import_yaml7.default.parse(fmMatch[1]);
-            parents = meta?.parents ?? [];
-          } catch {}
-        }
-      }
+}
+
+// src/core/migration-spec.ts
+function buildMigrationSpec(paths) {
+  const sections = [];
+  sections.push(`## Config fields (config.yml)
+
+| Field | Type | Required | Default |
+|-------|------|----------|---------|
+| version | string | yes | — |
+| project | string | yes | — |
+| entryMode | greenfield \\| migration \\| adoption | yes | — |
+| stack | string | no | — |
+| preset | string | no | — |
+| agents | AgentName[] | no | auto-detect |
+| language | string | no | — |
+| autoUpdate | boolean | no | true |
+| autoSubagent | boolean | no | true |
+| autoIssueReport | boolean | no | false |
+| strict | boolean \\| { edit?: boolean; merge?: boolean } | no | false |`);
+  sections.push(`## Expected directory structure
+
+.reap/
+├── config.yml
+├── genome/
+│   ├── principles.md
+│   ├── conventions.md
+│   ├── constraints.md
+│   ├── source-map.md
+│   └── domain/
+├── environment/
+│   ├── summary.md
+│   ├── docs/
+│   └── resources/
+├── life/
+│   ├── current.yml
+│   ├── backlog/
+│   ├── 01-objective.md
+│   ├── 02-planning.md
+│   ├── 03-implementation.md
+│   ├── 04-validation.md
+│   └── 05-completion.md
+├── lineage/
+│   └── gen-NNN-hash/ or gen-NNN-hash.md
+└── hooks/
+    ├── conditions/
+    └── {event}.{name}.{sh|md}`);
+  sections.push(`## Slash commands (32)
+
+reap.objective, reap.planning, reap.implementation,
+reap.validation, reap.completion, reap.evolve,
+reap.evolve.recovery, reap.start, reap.next, reap.back, reap.abort,
+reap.status, reap.sync, reap.sync.genome, reap.sync.environment,
+reap.help, reap.update, reap.update-genome, reap.report,
+reap.refreshKnowledge,
+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,
+reap.config`);
+  sections.push(`## Hooks format
+
+File naming: {event}.{name}.{md|sh}
+Location: .reap/hooks/
+
+Frontmatter (md hooks):
+---
+event: onLifeStarted
+name: my-hook
+description: What this hook does
+---
+
+Condition files: .reap/hooks/conditions/{name}.yml`);
+  sections.push(`## Project root: ${paths.projectRoot}`);
+  return sections.join(`
+
+`);
+}
+async function detectMigrationGaps(paths) {
+  const result = await checkIntegrity(paths);
+  return result.errors;
+}
+
+// src/cli/commands/update.ts
+function selfUpgrade() {
+  try {
+    const installed = execSync3("reap --version", { encoding: "utf-8", timeout: 5000 }).trim();
+    if (installed.includes("+dev")) {
+      return { upgraded: false };
     }
-    for (const parent of parents) {
-      if (parent && !allMetaIds.has(parent)) {
-        const epochContent = await readTextFile(join12(paths.lineage, "epoch.md"));
-        let inEpoch = false;
-        if (epochContent) {
-          inEpoch = epochContent.includes(parent);
-        }
-        if (!inEpoch) {
-          warnings.push(`lineage/${item.name}: parent "${parent}" not found in lineage (may be in a compressed epoch)`);
-        }
-      }
+    const latest = execSync3("npm view @c-d-cc/reap version", { encoding: "utf-8", timeout: 1e4 }).trim();
+    if (installed === latest) {
+      return { upgraded: false };
     }
+    execSync3("npm update -g @c-d-cc/reap", { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
+    return { upgraded: true, from: installed, to: latest };
+  } catch {
+    return { upgraded: false };
   }
 }
-function validateLineageMeta(meta, location, errors, warnings) {
-  const requiredStrings = ["id", "goal", "startedAt", "completedAt"];
-  for (const field of requiredStrings) {
-    if (!meta[field] || typeof meta[field] !== "string") {
-      errors.push(`${location}: missing or invalid '${field}' field`);
+async function updateProject(projectRoot, dryRun = false) {
+  const paths = new ReapPaths(projectRoot);
+  const result = { updated: [], skipped: [], removed: [] };
+  const config = await paths.isReapProject() ? await ConfigManager.read(paths) : null;
+  const adapters = await AgentRegistry.getActiveAdapters(config ?? undefined);
+  const commandsDir = ReapPaths.packageCommandsDir;
+  const commandFiles = await readdir12(commandsDir);
+  await mkdir7(ReapPaths.userReapCommands, { recursive: true });
+  for (const file of commandFiles) {
+    if (!file.endsWith(".md"))
+      continue;
+    const src = await readTextFileOrThrow(join13(commandsDir, file));
+    const dest = join13(ReapPaths.userReapCommands, file);
+    const existing = await readTextFile(dest);
+    if (existing !== null && existing === src) {
+      result.skipped.push(`~/.reap/commands/${file}`);
+    } else {
+      if (!dryRun)
+        await writeTextFile(dest, src);
+      result.updated.push(`~/.reap/commands/${file}`);
     }
   }
-  if (typeof meta.completedAt === "string") {
-    if (!isISODate(meta.completedAt)) {
-      errors.push(`${location}: completedAt "${meta.completedAt}" is not a valid ISO date`);
-    }
+  for (const adapter of adapters) {
+    const agentCmdDir = adapter.getCommandsDir();
+    const label = adapter.displayName;
+    try {
+      const existing = await readdir12(agentCmdDir);
+      for (const file of existing) {
+        if (!file.startsWith("reap.") || !file.endsWith(".md"))
+          continue;
+        const filePath = join13(agentCmdDir, file);
+        const content = await readTextFile(filePath);
+        if (content !== null && content.includes("redirected to ~/.reap/commands/")) {
+          if (!dryRun)
+            await unlink5(filePath);
+          result.removed.push(`[${label}] commands/${file} (Phase 2: redirect removed)`);
+        }
+      }
+    } catch {}
   }
-  if (typeof meta.startedAt === "string") {
-    if (!isISODate(meta.startedAt)) {
-      warnings.push(`${location}: startedAt "${meta.startedAt}" is not a valid ISO date`);
+  for (const adapter of adapters) {
+    if (typeof adapter.cleanupLegacyCommands === "function") {
+      const removed = await adapter.cleanupLegacyCommands();
+      for (const file of removed) {
+        result.removed.push(`[${adapter.displayName}] ~commands/${file} (legacy user-level)`);
+      }
     }
   }
-  if (!Array.isArray(meta.parents)) {
-    errors.push(`${location}: missing or invalid 'parents' field (array required)`);
-  }
-  if (!meta.type || typeof meta.type !== "string") {
-    errors.push(`${location}: missing or invalid 'type' field`);
-  } else if (!VALID_GENERATION_TYPES.includes(meta.type)) {
-    errors.push(`${location}: invalid type "${meta.type}"`);
+  await mkdir7(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(join13(ReapPaths.packageArtifactsDir, file));
+    const dest = join13(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}`);
+    }
   }
-  if (meta.genomeHash !== undefined && typeof meta.genomeHash !== "string") {
-    warnings.push(`${location}: genomeHash should be a string`);
+  const domainGuideSrc = await readTextFileOrThrow(join13(ReapPaths.packageGenomeDir, "domain/README.md"));
+  const domainGuideDest = join13(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`);
   }
-}
-async function checkGenome(paths, errors, warnings) {
-  const l1Files = [
-    { path: paths.principles, name: "principles.md" },
-    { path: paths.conventions, name: "conventions.md" },
-    { path: paths.constraints, name: "constraints.md" },
-    { path: paths.sourceMap, name: "source-map.md" }
-  ];
-  for (const gf of l1Files) {
-    if (!await fileExists(gf.path)) {
-      errors.push(`genome/${gf.name} does not exist`);
-      continue;
+  const mergeTemplatesDir = join13(ReapPaths.userReapTemplates, "merge");
+  await mkdir7(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 = join13(ReapPaths.packageArtifactsDir, "merge");
+  for (const file of mergeArtifactFiles) {
+    const src = await readTextFileOrThrow(join13(mergeSourceDir, file));
+    const dest = join13(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 content = await readTextFile(gf.path);
-    if (content === null)
-      continue;
-    const lines = content.split(`
-`).length;
-    if (lines > GENOME_LINE_WARNING_THRESHOLD) {
-      warnings.push(`genome/${gf.name}: ${lines} lines (exceeds ~${GENOME_LINE_WARNING_THRESHOLD} line guideline)`);
+  }
+  const migrations = await migrateHooks(dryRun);
+  for (const m of migrations.results) {
+    if (m.action === "migrated") {
+      result.updated.push(`[${m.agent}] hooks (migrated)`);
     }
-    const stripped = content.split(`
-`).filter((l) => !l.startsWith("#") && !l.startsWith(">") && !l.startsWith("-") && l.trim() !== "").join("").trim();
-    if (stripped.length === 0) {
-      warnings.push(`genome/${gf.name}: appears to be placeholder-only (no substantive content)`);
+  }
+  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`);
     }
   }
-}
-async function checkBacklog(paths, errors, warnings) {
-  let entries;
-  try {
-    entries = await readdir11(paths.backlog);
-  } catch {
-    return;
+  for (const adapter of adapters) {
+    if (typeof adapter.setupAgentMd === "function") {
+      const mdResult = await adapter.setupAgentMd(projectRoot);
+      if (mdResult.action !== "skipped") {
+        result.updated.push(`[${adapter.displayName}] agent md (${mdResult.action})`);
+      } else {
+        result.skipped.push(`[${adapter.displayName}] agent md`);
+      }
+    }
   }
-  for (const filename of entries) {
-    if (!filename.endsWith(".md"))
-      continue;
-    const content = await readTextFile(join12(paths.backlog, filename));
-    if (!content)
-      continue;
-    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!fmMatch) {
-      errors.push(`backlog/${filename}: missing frontmatter`);
-      continue;
+  if (await paths.isReapProject()) {
+    if (!dryRun) {
+      const backfillResult = await ConfigManager.backfill(paths);
+      if (backfillResult.added.length > 0) {
+        result.updated.push(`Config: added ${backfillResult.added.join(", ")}`);
+      }
     }
-    let fm;
+    const skillsResult = await syncSkillsToProject(paths.projectRoot, dryRun);
+    if (skillsResult.installed > 0) {
+      result.updated.push(`.claude/skills/ (${skillsResult.installed} synced)`);
+    } else {
+      result.skipped.push(`.claude/skills/ (${skillsResult.total} unchanged)`);
+    }
+    const projectClaudeCommands = join13(paths.projectRoot, ".claude", "commands");
     try {
-      fm = import_yaml7.default.parse(fmMatch[1]) ?? {};
-    } catch {
-      errors.push(`backlog/${filename}: invalid frontmatter YAML`);
-      continue;
+      const legacyFiles = (await readdir12(projectClaudeCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
+      for (const file of legacyFiles) {
+        if (!dryRun)
+          await unlink5(join13(projectClaudeCommands, file));
+        result.removed.push(`.claude/commands/${file} (legacy)`);
+      }
+    } catch {}
+    await migrateLegacyFiles(paths, dryRun, result);
+    const currentVersion = "0.15.3";
+    const migrationResult = await MigrationRunner.run(paths, currentVersion, dryRun);
+    for (const m of migrationResult.migrated) {
+      result.updated.push(`[migration] ${m}`);
     }
-    if (!fm.type || typeof fm.type !== "string") {
-      errors.push(`backlog/${filename}: missing or invalid 'type' field in frontmatter`);
-    } else if (!VALID_BACKLOG_TYPES.includes(fm.type)) {
-      errors.push(`backlog/${filename}: invalid type "${fm.type}" (valid: ${VALID_BACKLOG_TYPES.join(", ")})`);
+    for (const s of migrationResult.skipped) {
+      result.skipped.push(`[migration] ${s}`);
     }
-    if (!fm.status || typeof fm.status !== "string") {
-      errors.push(`backlog/${filename}: missing or invalid 'status' field in frontmatter`);
-    } else if (!VALID_BACKLOG_STATUSES.includes(fm.status)) {
-      errors.push(`backlog/${filename}: invalid status "${fm.status}" (valid: ${VALID_BACKLOG_STATUSES.join(", ")})`);
+    for (const e of migrationResult.errors) {
+      result.removed.push(`[migration error] ${e}`);
     }
-    if (fm.status === "consumed" && !fm.consumedBy) {
-      errors.push(`backlog/${filename}: status is 'consumed' but missing 'consumedBy' field`);
+    const gaps = await detectMigrationGaps(paths);
+    if (gaps.length > 0) {
+      const spec = buildMigrationSpec(paths);
+      console.log(JSON.stringify({
+        status: "prompt",
+        command: "migrate",
+        gaps,
+        spec,
+        prompt: "Analyze the gaps between current .reap/ structure and expected structure. Fix each gap after user confirmation."
+      }, null, 2));
+    }
+    if (migrationResult.errors.length > 0 && config?.autoIssueReport) {
+      try {
+        const { execSync: execSync4 } = await import("child_process");
+        const errorSummary = migrationResult.errors.join("\\n");
+        const title = `Migration failure: ${migrationResult.fromVersion} → ${migrationResult.toVersion}`;
+        const body = `## Migration Error\\n\\nFrom: ${migrationResult.fromVersion}\\nTo: ${migrationResult.toVersion}\\n\\n### Errors\\n\\n${errorSummary}`;
+        execSync4(`gh issue create --repo c-d-cc/reap --title "${title}" --label "auto-reported,migration" --body "${body}"`, { encoding: "utf-8", timeout: 15000, stdio: "pipe" });
+      } catch {}
     }
   }
+  return result;
 }
-var STAGE_ARTIFACT_MAP = {
-  objective: "01-objective.md",
-  planning: "02-planning.md",
-  implementation: "03-implementation.md",
-  validation: "04-validation.md",
-  completion: "05-completion.md"
-};
-async function checkArtifacts(paths, state, errors, warnings) {
-  const currentStageIdx = LIFECYCLE_ORDER.indexOf(state.stage);
-  if (currentStageIdx < 0)
-    return;
-  for (let i = 0;i < currentStageIdx; i++) {
-    const stage = LIFECYCLE_ORDER[i];
-    const artifactName = STAGE_ARTIFACT_MAP[stage];
-    if (!artifactName)
-      continue;
-    const artifactPath = paths.artifact(artifactName);
-    if (!await fileExists(artifactPath)) {
-      errors.push(`artifact ${artifactName} missing (expected for completed stage '${stage}')`);
-      continue;
-    }
-    const content = await readTextFile(artifactPath);
-    if (content && !content.startsWith("# REAP MANAGED")) {
-      warnings.push(`artifact ${artifactName}: missing 'REAP MANAGED' header`);
+async function migrateLegacyFiles(paths, dryRun, result) {
+  await removeDirIfExists(paths.legacyCommands, ".reap/commands/", dryRun, result);
+  await removeDirIfExists(paths.legacyTemplates, ".reap/templates/", dryRun, result);
+  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 unlink5(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)`);
+            }
+          }
+        }
+      }
     }
-  }
-  const currentArtifact = STAGE_ARTIFACT_MAP[state.stage];
-  if (currentArtifact) {
-    const artifactPath = paths.artifact(currentArtifact);
-    if (!await fileExists(artifactPath)) {
-      warnings.push(`artifact ${currentArtifact} not yet created for current stage '${state.stage}'`);
+  } catch {}
+}
+async function removeDirIfExists(dirPath, label, dryRun, result) {
+  try {
+    const entries = await readdir12(dirPath);
+    if (entries.length > 0 || true) {
+      if (!dryRun)
+        await rm3(dirPath, { recursive: true });
+      result.removed.push(label);
     }
-  }
+  } catch {}
+}
+
+// src/cli/commands/status.ts
+init_paths();
+init_generation();
+init_config();
+async function getStatus(projectRoot) {
+  const paths = new ReapPaths(projectRoot);
+  const config = await ConfigManager.read(paths);
+  const mgr = new GenerationManager(paths);
+  const current = await mgr.current();
+  const totalCompleted = await mgr.countAllCompleted();
+  const integrityResult = await checkIntegrity(paths);
+  return {
+    version: config.version,
+    project: config.project,
+    entryMode: config.entryMode,
+    lastSyncedGeneration: config.lastSyncedGeneration,
+    generation: current ? {
+      id: current.id,
+      goal: current.goal,
+      stage: current.stage,
+      genomeVersion: current.genomeVersion,
+      startedAt: current.startedAt,
+      type: current.type,
+      parents: current.parents,
+      genomeHash: current.genomeHash
+    } : null,
+    totalGenerations: totalCompleted,
+    integrity: { errors: integrityResult.errors.length, warnings: integrityResult.warnings.length }
+  };
 }
 
 // src/cli/commands/fix.ts
+init_paths();
+init_lifecycle();
+init_fs();
+var import_yaml7 = __toESM(require_dist(), 1);
+import { mkdir as mkdir8, stat as stat4, copyFile } from "fs/promises";
+import { join as join14 } from "path";
 async function checkProject(projectRoot) {
   const paths = new ReapPaths(projectRoot);
-  return checkIntegrity(paths);
+  const [structureResult, userLevelResult] = await Promise.all([
+    checkIntegrity(paths),
+    checkUserLevelArtifacts(projectRoot)
+  ]);
+  return {
+    errors: [...structureResult.errors, ...userLevelResult.errors],
+    warnings: [...structureResult.warnings, ...userLevelResult.warnings]
+  };
 }
 async function dirExists(path) {
   try {
@@ -16136,7 +16376,7 @@ async function fixProject(projectRoot) {
   ];
   for (const gf of genomeFiles) {
     if (!await fileExists(gf.path)) {
-      const templateSrc = join13(ReapPaths.packageGenomeDir, gf.name);
+      const templateSrc = join14(ReapPaths.packageGenomeDir, gf.name);
       if (await fileExists(templateSrc)) {
         await copyFile(templateSrc, gf.path);
         fixed.push(`Restored missing genome/${gf.name} from template`);
@@ -16152,7 +16392,7 @@ async function fixProject(projectRoot) {
   if (currentContent !== null) {
     if (currentContent.trim()) {
       try {
-        const state = import_yaml8.default.parse(currentContent);
+        const state = import_yaml7.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.`);
         }
@@ -16177,8 +16417,8 @@ async function fixProject(projectRoot) {
 init_fs();
 init_paths();
 init_config();
-import { rm as rm3, readdir as readdir12, unlink as unlink5 } from "fs/promises";
-import { join as join14 } from "path";
+import { rm as rm4 } from "fs/promises";
+import { join as join15 } from "path";
 async function getProjectName(projectRoot) {
   try {
     const paths = new ReapPaths(projectRoot);
@@ -16191,77 +16431,26 @@ async function getProjectName(projectRoot) {
 async function destroyProject(projectRoot) {
   const removed = [];
   const skipped = [];
-  const reapDir = join14(projectRoot, ".reap");
+  const reapDir = join15(projectRoot, ".reap");
   if (await fileExists(reapDir)) {
-    await rm3(reapDir, { recursive: true, force: true });
+    await rm4(reapDir, { recursive: true, force: true });
     removed.push(".reap/");
   } else {
     skipped.push(".reap/ (not found)");
   }
-  const claudeCommandsDir = join14(projectRoot, ".claude", "commands");
-  await removeGlobFiles(claudeCommandsDir, "reap.", removed, skipped, ".claude/commands/");
-  const claudeSkillsDir = join14(projectRoot, ".claude", "skills");
-  await removeGlobDirs(claudeSkillsDir, "reap.", removed, skipped, ".claude/skills/");
-  await cleanClaudeMd(projectRoot, removed, skipped);
-  await cleanGitignore(projectRoot, removed, skipped);
-  return { removed, skipped };
-}
-async function removeGlobFiles(dir, prefix, removed, skipped, displayPrefix) {
-  try {
-    const files = await readdir12(dir);
-    const matched = files.filter((f) => f.startsWith(prefix));
-    if (matched.length === 0) {
-      skipped.push(`${displayPrefix}${prefix}* (none found)`);
-      return;
-    }
-    for (const file of matched) {
-      await unlink5(join14(dir, file));
-      removed.push(`${displayPrefix}${file}`);
-    }
-  } catch {
-    skipped.push(`${displayPrefix}${prefix}* (directory not found)`);
-  }
-}
-async function removeGlobDirs(dir, prefix, removed, skipped, displayPrefix) {
-  try {
-    const entries = await readdir12(dir);
-    const matched = entries.filter((e) => e.startsWith(prefix));
-    if (matched.length === 0) {
-      skipped.push(`${displayPrefix}${prefix}* (none found)`);
-      return;
-    }
-    for (const entry of matched) {
-      await rm3(join14(dir, entry), { recursive: true, force: true });
-      removed.push(`${displayPrefix}${entry}`);
+  const adapters = AgentRegistry.allAdapters();
+  for (const adapter of adapters) {
+    if (typeof adapter.cleanupProjectFiles === "function") {
+      const result = await adapter.cleanupProjectFiles(projectRoot);
+      removed.push(...result.removed);
+      skipped.push(...result.skipped);
     }
-  } catch {
-    skipped.push(`${displayPrefix}${prefix}* (directory not found)`);
-  }
-}
-async function cleanClaudeMd(projectRoot, removed, skipped) {
-  const claudeMdPath = join14(projectRoot, ".claude", "CLAUDE.md");
-  const content = await readTextFile(claudeMdPath);
-  if (content === null) {
-    skipped.push(".claude/CLAUDE.md (not found)");
-    return;
-  }
-  const marker = "# REAP Project";
-  if (!content.includes(marker)) {
-    skipped.push(".claude/CLAUDE.md (no REAP section)");
-    return;
-  }
-  const cleaned = content.replace(/# REAP Project[\s\S]*?(?=\n# |\s*$)/, "").trim();
-  if (cleaned.length === 0) {
-    await unlink5(claudeMdPath);
-    removed.push(".claude/CLAUDE.md (deleted, was REAP-only)");
-  } else {
-    await writeTextFile(claudeMdPath, cleaned + `
-`);
-    removed.push(".claude/CLAUDE.md (REAP section removed)");
   }
+  await cleanGitignore(projectRoot, removed, skipped);
+  return { removed, skipped };
 }
 async function cleanGitignore(projectRoot, removed, skipped) {
-  const gitignorePath = join14(projectRoot, ".gitignore");
+  const gitignorePath = join15(projectRoot, ".gitignore");
   const content = await readTextFile(gitignorePath);
   if (content === null) {
     skipped.push(".gitignore (not found)");
@@ -16297,8 +16486,8 @@ async function cleanGitignore(projectRoot, removed, skipped) {
 init_paths();
 init_fs();
 init_generation();
-import { rm as rm4, readdir as readdir13, mkdir as mkdir9 } from "fs/promises";
-import { join as join15 } from "path";
+import { rm as rm5, readdir as readdir13, mkdir as mkdir9 } from "fs/promises";
+import { join as join16 } from "path";
 async function hasActiveGeneration(projectRoot) {
   const paths = new ReapPaths(projectRoot);
   try {
@@ -16314,7 +16503,7 @@ async function cleanProject(projectRoot, options) {
   const actions = [];
   const warnings = [];
   if (options.lineage === "delete") {
-    await rm4(paths.lineage, { recursive: true, force: true });
+    await rm5(paths.lineage, { recursive: true, force: true });
     await mkdir9(paths.lineage, { recursive: true });
     actions.push("Lineage: 전체 삭제됨");
   } else {
@@ -16324,7 +16513,7 @@ async function cleanProject(projectRoot, options) {
   if (options.hooks === "reset") {
     const hooksDir = paths.hooks;
     if (await fileExists(hooksDir)) {
-      await rm4(hooksDir, { recursive: true, force: true });
+      await rm5(hooksDir, { recursive: true, force: true });
       await mkdir9(hooksDir, { recursive: true });
       actions.push("Hooks: 초기화됨");
     } else {
@@ -16343,7 +16532,7 @@ async function cleanProject(projectRoot, options) {
   const backlogDir = paths.backlog;
   if (options.backlog === "delete") {
     if (await fileExists(backlogDir)) {
-      await rm4(backlogDir, { recursive: true, force: true });
+      await rm5(backlogDir, { recursive: true, force: true });
       await mkdir9(backlogDir, { recursive: true });
       actions.push("Backlog: 삭제됨");
     } else {
@@ -16384,9 +16573,9 @@ async function compressLineage(paths, actions) {
   ].join(`
 `);
   for (const dir of genDirs) {
-    await rm4(join15(lineageDir, dir), { recursive: true, force: true });
+    await rm5(join16(lineageDir, dir), { recursive: true, force: true });
   }
-  await writeTextFile(join15(lineageDir, `${epochId}.md`), summary);
+  await writeTextFile(join16(lineageDir, `${epochId}.md`), summary);
   actions.push(`Lineage: ${genDirs.length}개 세대를 ${epochId}로 압축`);
 }
 async function cleanLife(paths, actions) {
@@ -16406,8 +16595,8 @@ async function cleanLife(paths, actions) {
   for (const entry of entries) {
     if (entry === "backlog")
       continue;
-    const entryPath = join15(lifeDir, entry);
-    await rm4(entryPath, { recursive: true, force: true });
+    const entryPath = join16(lifeDir, entry);
+    await rm5(entryPath, { recursive: true, force: true });
     removedCount++;
   }
   actions.push(`Life: ${removedCount}개 파일/디렉토리 정리됨`);
@@ -16415,14 +16604,14 @@ async function cleanLife(paths, actions) {
 async function resetGenomeToTemplate(paths, actions) {
   const genomeFiles = ["principles.md", "conventions.md", "constraints.md", "source-map.md"];
   for (const file of genomeFiles) {
-    const templatePath = join15(ReapPaths.packageGenomeDir, file);
-    const destPath = join15(paths.genome, file);
+    const templatePath = join16(ReapPaths.packageGenomeDir, file);
+    const destPath = join16(paths.genome, file);
     try {
       const templateContent = await readTextFileOrThrow(templatePath);
       await writeTextFile(destPath, templateContent);
     } catch {}
   }
-  const envSummaryTemplate = join15(ReapPaths.packageTemplatesDir, "environment", "summary.md");
+  const envSummaryTemplate = join16(ReapPaths.packageTemplatesDir, "environment", "summary.md");
   if (await fileExists(envSummaryTemplate)) {
     try {
       const content = await readTextFileOrThrow(envSummaryTemplate);
@@ -16438,8 +16627,8 @@ init_paths();
 init_fs();
 init_version();
 init_config();
-import { join as join32 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.15.2");
+import { join as join33 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.15.3");
 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();
@@ -16447,9 +16636,9 @@ program.command("init").description("Initialize a new REAP project (Genesis)").a
     let mode = options.mode;
     const modeExplicit = process.argv.some((a) => a === "-m" || a === "--mode");
     if (!modeExplicit && mode === "greenfield") {
-      const { existsSync: existsSync3 } = __require("fs");
+      const { existsSync: existsSync2 } = __require("fs");
       const signals = ["package.json", "go.mod", "Cargo.toml", "pom.xml", "pyproject.toml", "Makefile", "CMakeLists.txt"];
-      const hasExistingProject = signals.some((f) => existsSync3(__require("path").join(cwd, f)));
+      const hasExistingProject = signals.some((f) => existsSync2(__require("path").join(cwd, f)));
       if (hasExistingProject) {
         mode = "adoption";
         console.log(`Existing project detected. Automatically using adoption mode.`);
@@ -16496,12 +16685,22 @@ program.command("status").description("Show current project and Generation statu
     const paths = new ReapPaths(cwd);
     const config = await ConfigManager.read(paths);
     const skipCheck = config.autoUpdate === false;
-    const installedVersion = "0.15.2";
+    const installedVersion = "0.15.3";
     const versionLine = formatVersionLine(installedVersion, skipCheck);
     console.log(`${versionLine} | Project: ${status.project} (${status.entryMode})`);
     console.log(`Completed Generations: ${status.totalGenerations}`);
     const syncLabel = status.lastSyncedGeneration ? `synced (${status.lastSyncedGeneration})` : "never synced";
     console.log(`Genome Sync: ${syncLabel}`);
+    if (status.integrity.errors > 0 || status.integrity.warnings > 0) {
+      const parts = [];
+      if (status.integrity.errors > 0)
+        parts.push(`${status.integrity.errors} error${status.integrity.errors > 1 ? "s" : ""}`);
+      if (status.integrity.warnings > 0)
+        parts.push(`${status.integrity.warnings} warning${status.integrity.warnings > 1 ? "s" : ""}`);
+      console.log(`Integrity: ${parts.join(", ")} (run 'reap fix --check' for details)`);
+    } else {
+      console.log(`Integrity: ✓ OK`);
+    }
     if (status.generation) {
       console.log(`
 Active Generation: ${status.generation.id}`);
@@ -16583,6 +16782,21 @@ program.command("update").description("Upgrade REAP package and sync slash comma
     if (result.skipped.length > 0) {
       console.log(`Unchanged: ${result.skipped.length} files`);
     }
+    try {
+      const integrityResult = await checkProject(process.cwd());
+      if (integrityResult.errors.length > 0 || integrityResult.warnings.length > 0) {
+        const parts = [];
+        if (integrityResult.errors.length > 0)
+          parts.push(`${integrityResult.errors.length} error${integrityResult.errors.length > 1 ? "s" : ""}`);
+        if (integrityResult.warnings.length > 0)
+          parts.push(`${integrityResult.warnings.length} warning${integrityResult.warnings.length > 1 ? "s" : ""}`);
+        console.log(`
+Integrity: ${parts.join(", ")} (run 'reap fix --check' for details)`);
+      } else {
+        console.log(`
+Integrity: ✓ OK`);
+      }
+    } catch {}
   } catch (e) {
     console.error(`Error: ${e.message}`);
     process.exit(1);
@@ -16596,10 +16810,10 @@ program.command("help").description("Show REAP commands, slash commands, and wor
     if (l === "korean" || l === "ko")
       lang = "ko";
   }
-  const helpDir = join32(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join32(helpDir, `${lang}.txt`));
+  const helpDir = join33(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join33(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join32(helpDir, "en.txt"));
+    helpText = await readTextFile(join33(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;