@c-d-cc/reap 0.14.0 → 0.15.1

package/dist/cli.js

@@ -9027,7 +9027,8 @@ class ConfigManager {
       strict: false,
       autoUpdate: true,
       autoSubagent: true,
-      autoIssueReport: false
+      autoIssueReport: false,
+      lastSyncedGeneration: ""
     };
     for (const [key, defaultValue] of Object.entries(defaults)) {
       if (config[key] === undefined) {
@@ -9035,6 +9036,14 @@ class ConfigManager {
         added.push(key);
       }
     }
+    if (config.lastSyncedCommit !== undefined) {
+      if (!config.lastSyncedGeneration && config.lastSyncedCommit) {
+        config.lastSyncedGeneration = "legacy";
+        added.push("lastSyncedGeneration(migrated)");
+      }
+      delete config.lastSyncedCommit;
+      added.push("lastSyncedCommit(removed)");
+    }
     if (added.length > 0) {
       await ConfigManager.write(paths, config);
     }
@@ -9064,8 +9073,8 @@ var exports_genome_sync = {};
 __export(exports_genome_sync, {
   syncGenomeFromProject: () => syncGenomeFromProject
 });
-import { join as join4 } from "path";
-import { readdir as readdir3, stat as stat2 } from "fs/promises";
+import { join as join5 } from "path";
+import { readdir as readdir4, stat as stat2 } from "fs/promises";
 async function scanProject(projectRoot) {
   const scan = {
     language: "Unknown",
@@ -9084,7 +9093,7 @@ async function scanProject(projectRoot) {
     directories: [],
     existingDocs: []
   };
-  const pkgContent = await readTextFile(join4(projectRoot, "package.json"));
+  const pkgContent = await readTextFile(join5(projectRoot, "package.json"));
   if (pkgContent) {
     try {
       const pkg = JSON.parse(pkgContent);
@@ -9143,16 +9152,16 @@ async function scanProject(projectRoot) {
         scan.buildTool = "Turbopack";
     } catch {}
   }
-  if (await fileExists(join4(projectRoot, "go.mod"))) {
+  if (await fileExists(join5(projectRoot, "go.mod"))) {
     scan.language = "Go";
     scan.runtime = "Go";
     scan.packageManager = "Go Modules";
   }
-  if (await fileExists(join4(projectRoot, "pyproject.toml")) || await fileExists(join4(projectRoot, "requirements.txt"))) {
+  if (await fileExists(join5(projectRoot, "pyproject.toml")) || await fileExists(join5(projectRoot, "requirements.txt"))) {
     scan.language = "Python";
     scan.runtime = "Python";
-    if (await fileExists(join4(projectRoot, "pyproject.toml"))) {
-      const pyproject = await readTextFile(join4(projectRoot, "pyproject.toml"));
+    if (await fileExists(join5(projectRoot, "pyproject.toml"))) {
+      const pyproject = await readTextFile(join5(projectRoot, "pyproject.toml"));
       if (pyproject?.includes("[tool.poetry]"))
         scan.packageManager = "Poetry";
       else if (pyproject?.includes("[tool.uv]") || pyproject?.includes("[project]"))
@@ -9167,23 +9176,23 @@ async function scanProject(projectRoot) {
         scan.framework = "Flask";
     }
   }
-  if (await fileExists(join4(projectRoot, "Cargo.toml"))) {
+  if (await fileExists(join5(projectRoot, "Cargo.toml"))) {
     scan.language = "Rust";
     scan.runtime = "Rust";
     scan.packageManager = "Cargo";
   }
-  if (await fileExists(join4(projectRoot, "tsconfig.json"))) {
+  if (await fileExists(join5(projectRoot, "tsconfig.json"))) {
     scan.hasTypeScript = true;
     scan.language = "TypeScript";
   }
-  scan.hasDocker = await fileExists(join4(projectRoot, "Dockerfile")) || await fileExists(join4(projectRoot, "docker-compose.yml"));
+  scan.hasDocker = await fileExists(join5(projectRoot, "Dockerfile")) || await fileExists(join5(projectRoot, "docker-compose.yml"));
   try {
-    const entries = await readdir3(projectRoot);
+    const entries = await readdir4(projectRoot);
     for (const entry of entries) {
       if (entry.startsWith(".") || entry === "node_modules")
         continue;
       try {
-        const s = await stat2(join4(projectRoot, entry));
+        const s = await stat2(join5(projectRoot, entry));
         if (s.isDirectory())
           scan.directories.push(entry);
       } catch {}
@@ -9191,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(join4(projectRoot, file));
+    const content = await readTextFile(join5(projectRoot, file));
     if (content) {
       scan.existingDocs.push({ file, content: content.substring(0, 2000) });
     }
@@ -9320,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(join4(genomePath, "constraints.md"), generateConstraints(scan));
+  await writeTextFile2(join5(genomePath, "constraints.md"), generateConstraints(scan));
   log("Generating conventions.md...");
-  await writeTextFile2(join4(genomePath, "conventions.md"), generateConventions(scan));
+  await writeTextFile2(join5(genomePath, "conventions.md"), generateConventions(scan));
   log("Generating principles.md...");
-  await writeTextFile2(join4(genomePath, "principles.md"), generatePrinciples(scan));
+  await writeTextFile2(join5(genomePath, "principles.md"), generatePrinciples(scan));
   log("Generating source-map.md...");
-  await writeTextFile2(join4(genomePath, "source-map.md"), generateSourceMap(scan));
-  const { mkdir: mkdir3 } = await import("fs/promises");
-  const domainDir = join4(genomePath, "domain");
-  await mkdir3(domainDir, { recursive: true });
-  const domainReadme = join4(domainDir, "README.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");
   if (!await fileExists(domainReadme)) {
     await writeTextFile2(domainReadme, [
       "# Domain Rules",
@@ -9473,8 +9482,12 @@ function gitCurrentBranch(cwd) {
 var init_git = () => {};
 
 // src/core/compression.ts
-import { readdir as readdir5, rm } from "fs/promises";
-import { join as join6 } from "path";
+import { readdir as readdir6, rm } from "fs/promises";
+import { join as join7 } from "path";
+function safeCompletedAtTime(dateStr) {
+  const t = new Date(dateStr).getTime();
+  return Number.isNaN(t) ? 0 : t;
+}
 function extractGenNum(name) {
   const match = name.match(/^gen-(\d{3})/);
   return match ? parseInt(match[1], 10) : 0;
@@ -9505,9 +9518,9 @@ async function countLines(filePath) {
 async function countDirLines(dirPath) {
   let total = 0;
   try {
-    const entries = await readdir5(dirPath, { withFileTypes: true });
+    const entries = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join6(dirPath, entry.name);
+      const fullPath = join7(dirPath, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         total += await countLines(fullPath);
       } else if (entry.isDirectory()) {
@@ -9518,7 +9531,7 @@ async function countDirLines(dirPath) {
   return total;
 }
 async function readDirMeta(dirPath) {
-  const content = await readTextFile(join6(dirPath, "meta.yml"));
+  const content = await readTextFile(join7(dirPath, "meta.yml"));
   if (content === null)
     return null;
   try {
@@ -9536,9 +9549,9 @@ async function readFileMeta(filePath) {
 async function scanLineage(paths) {
   const entries = [];
   try {
-    const items = await readdir5(paths.lineage, { withFileTypes: true });
+    const items = await readdir6(paths.lineage, { withFileTypes: true });
     for (const item of items) {
-      const fullPath = join6(paths.lineage, item.name);
+      const fullPath = join7(paths.lineage, item.name);
       if (item.isDirectory() && item.name.startsWith("gen-")) {
         const genNum = extractGenNum(item.name);
         const lines = await countDirLines(fullPath);
@@ -9579,11 +9592,10 @@ async function scanLineage(paths) {
     }
   } catch {}
   return entries.sort((a, b) => {
-    if (a.completedAt && b.completedAt) {
-      const cmp = a.completedAt.localeCompare(b.completedAt);
-      if (cmp !== 0)
-        return cmp;
-    }
+    const aTime = safeCompletedAtTime(a.completedAt);
+    const bTime = safeCompletedAtTime(b.completedAt);
+    if (aTime !== bTime)
+      return aTime - bTime;
     return a.genNum - b.genNum;
   });
 }
@@ -9594,7 +9606,7 @@ async function findLeafNodes(paths, entries) {
     if (entry.type === "level2")
       continue;
     let meta = null;
-    const fullPath = join6(paths.lineage, entry.name);
+    const fullPath = join7(paths.lineage, entry.name);
     if (entry.type === "dir") {
       meta = await readDirMeta(fullPath);
     } else {
@@ -9625,7 +9637,7 @@ async function compressLevel1(genDir, genName) {
   }
   let goal = "", completionConditions = "";
   {
-    const objective = await readTextFile(join6(genDir, "01-objective.md"));
+    const objective = await readTextFile(join7(genDir, "01-objective.md"));
     if (objective) {
       const goalMatch = objective.match(/## Goal\n([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -9637,7 +9649,7 @@ async function compressLevel1(genDir, genName) {
   }
   let lessons = "", genomeChanges = "", nextBacklog = "";
   {
-    const completion = await readTextFile(join6(genDir, "05-completion.md"));
+    const completion = await readTextFile(join7(genDir, "05-completion.md"));
     if (completion) {
       const lessonsMatch = completion.match(/### Lessons Learned\n([\s\S]*?)(?=\n###)/);
       if (lessonsMatch)
@@ -9652,7 +9664,7 @@ async function compressLevel1(genDir, genName) {
   }
   let summaryText = "";
   {
-    const completion = await readTextFile(join6(genDir, "05-completion.md"));
+    const completion = await readTextFile(join7(genDir, "05-completion.md"));
     if (completion) {
       const summaryMatch = completion.match(/## Summary\n([\s\S]*?)(?=\n##)/);
       if (summaryMatch)
@@ -9661,7 +9673,7 @@ async function compressLevel1(genDir, genName) {
   }
   let validationResult = "";
   {
-    const validation = await readTextFile(join6(genDir, "04-validation.md"));
+    const validation = await readTextFile(join7(genDir, "04-validation.md"));
     if (validation) {
       const resultMatch = validation.match(/## Result: (.+)/);
       if (resultMatch)
@@ -9670,7 +9682,7 @@ async function compressLevel1(genDir, genName) {
   }
   let deferred = "";
   {
-    const impl = await readTextFile(join6(genDir, "03-implementation.md"));
+    const impl = await readTextFile(join7(genDir, "03-implementation.md"));
     if (impl) {
       const deferredMatch = impl.match(/## Deferred Tasks\n([\s\S]*?)(?=\n##)/);
       if (deferredMatch) {
@@ -9756,7 +9768,7 @@ async function findForkedByOtherBranches(paths, cwd) {
 }
 async function compressLevel2Single(level1Files, paths) {
   const compressed = [];
-  const epochPath = join6(paths.lineage, "epoch.md");
+  const epochPath = join7(paths.lineage, "epoch.md");
   let existingMeta = { generations: [] };
   let existingBody = "";
   const existingContent = await readTextFile(epochPath);
@@ -9828,10 +9840,10 @@ async function compressLineageIfNeeded(paths, projectRoot) {
     const currentTotal = await countDirLines(paths.lineage);
     if (currentTotal <= LINEAGE_MAX_LINES)
       break;
-    const dirPath = join6(paths.lineage, dir.name);
+    const dirPath = join7(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 = join6(paths.lineage, `${genId}.md`);
+    const outPath = join7(paths.lineage, `${genId}.md`);
     await writeTextFile(outPath, compressed);
     await rm(dirPath, { recursive: true });
     result.level1.push(genId);
@@ -9852,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: join6(paths.lineage, e.name),
-        meta: await readFileMeta(join6(paths.lineage, e.name))
+        path: join7(paths.lineage, e.name),
+        meta: await readFileMeta(join7(paths.lineage, e.name))
       })));
       const compressed = await compressLevel2Single(filesWithMeta, paths);
       result.level2.push(...compressed);
@@ -9869,18 +9881,18 @@ var init_compression = __esm(() => {
 });
 
 // src/core/lineage.ts
-import { readdir as readdir6 } from "fs/promises";
-import { join as join7 } from "path";
+import { readdir as readdir7 } from "fs/promises";
+import { join as join8 } from "path";
 async function listCompleted(paths) {
   try {
-    const entries = await readdir6(paths.lineage);
+    const entries = await readdir7(paths.lineage);
     return entries.filter((e) => e.startsWith("gen-")).sort();
   } catch {
     return [];
   }
 }
 async function readMeta(paths, lineageDirName) {
-  const metaPath = join7(paths.lineage, lineageDirName, "meta.yml");
+  const metaPath = join8(paths.lineage, lineageDirName, "meta.yml");
   const content = await readTextFile(metaPath);
   if (content === null)
     return null;
@@ -9889,14 +9901,14 @@ async function readMeta(paths, lineageDirName) {
 async function listMeta(paths) {
   const metas = [];
   try {
-    const entries = await readdir6(paths.lineage, { withFileTypes: true });
+    const entries = await readdir7(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(join7(paths.lineage, entry.name));
+        const content = await readTextFile(join8(paths.lineage, entry.name));
         if (content) {
           const meta = parseFrontmatter(content);
           if (meta)
@@ -9923,10 +9935,14 @@ async function nextSeq(paths, currentId) {
   }
   return maxSeq + 1;
 }
+function safeCompletedAtTime2(dateStr) {
+  const t = new Date(dateStr).getTime();
+  return Number.isNaN(t) ? 0 : t;
+}
 async function resolveParents(paths) {
   const metas = await listMeta(paths);
   if (metas.length > 0) {
-    const sorted = metas.sort((a, b) => new Date(b.completedAt).getTime() - new Date(a.completedAt).getTime());
+    const sorted = metas.sort((a, b) => safeCompletedAtTime2(b.completedAt) - safeCompletedAtTime2(a.completedAt));
     return [sorted[0].id];
   }
   const dirs = await listCompleted(paths);
@@ -9949,16 +9965,17 @@ var init_lineage = __esm(() => {
 // src/core/generation.ts
 import { createHash, randomBytes } from "crypto";
 import { hostname } from "os";
-import { readdir as readdir7, mkdir as mkdir4, rename, unlink as unlink3 } from "fs/promises";
-import { join as join8 } from "path";
-function generateStageToken(genId, stage) {
+import { readdir as readdir8, mkdir as mkdir5, rename, unlink as unlink3 } from "fs/promises";
+import { join as join9 } from "path";
+function generateToken(genId, stage, phase) {
   const nonce = randomBytes(16).toString("hex");
-  const hash = createHash("sha256").update(nonce + genId + stage).digest("hex");
+  const input = phase ? `${nonce}${genId}${stage}:${phase}` : `${nonce}${genId}${stage}`;
+  const hash = createHash("sha256").update(input).digest("hex");
   return { nonce, hash };
 }
-function verifyStageToken(token, genId, stage, expectedHash) {
-  const computed = createHash("sha256").update(token + genId + stage).digest("hex");
-  return computed === expectedHash;
+function verifyToken(token, genId, stage, expectedHash, phase) {
+  const input = phase ? `${token}${genId}${stage}:${phase}` : `${token}${genId}${stage}`;
+  return createHash("sha256").update(input).digest("hex") === expectedHash;
 }
 function generateGenHash(parents, goal, genomeHash, machineId, startedAt) {
   const input = JSON.stringify({ parents, goal, genomeHash, machineId, startedAt });
@@ -9970,13 +9987,13 @@ function getMachineId() {
 async function computeGenomeHash(genomePath) {
   const hash = createHash("sha256");
   try {
-    const entries = (await readdir7(genomePath, { recursive: true, withFileTypes: true })).filter((e) => e.isFile()).sort((a, b) => {
-      const pathA = join8(e2path(a), a.name);
-      const pathB = join8(e2path(b), b.name);
+    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);
       return pathA.localeCompare(pathB);
     });
     for (const entry of entries) {
-      const filePath = join8(e2path(entry), entry.name);
+      const filePath = join9(e2path(entry), entry.name);
       const content = await readTextFile(filePath);
       if (content !== null) {
         hash.update(filePath.replace(genomePath, ""));
@@ -10038,6 +10055,32 @@ class GenerationManager {
     await writeTextFile(this.paths.currentYml, CURRENT_YML_HEADER + import_yaml4.default.stringify(state));
     return state;
   }
+  async createRecoveryGeneration(goal, genomeVersion, recovers) {
+    if (recovers.length === 0) {
+      throw new Error("Recovery generation requires at least one target generation ID");
+    }
+    const seq = await this.nextSeq();
+    const now = new Date().toISOString();
+    const genomeHash = await computeGenomeHash(this.paths.genome);
+    const machineId = getMachineId();
+    const parents = await this.resolveParents();
+    const hash = generateGenHash(parents, goal, genomeHash, machineId, now);
+    const id = formatGenId(seq, hash);
+    const state = {
+      id,
+      goal,
+      stage: "objective",
+      genomeVersion,
+      startedAt: now,
+      timeline: [{ stage: "objective", at: now }],
+      type: "recovery",
+      parents,
+      genomeHash,
+      recovers
+    };
+    await writeTextFile(this.paths.currentYml, CURRENT_YML_HEADER + import_yaml4.default.stringify(state));
+    return state;
+  }
   async advance() {
     const state = await this.current();
     if (!state)
@@ -10063,7 +10106,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 mkdir4(genDir, { recursive: true });
+    await mkdir5(genDir, { recursive: true });
     const meta = {
       id: state.id,
       type: state.type ?? "normal",
@@ -10071,14 +10114,15 @@ class GenerationManager {
       goal: state.goal,
       genomeHash: state.genomeHash ?? "unknown",
       startedAt: state.startedAt,
-      completedAt: now
+      completedAt: now,
+      ...state.type === "recovery" && state.recovers ? { recovers: state.recovers } : {}
     };
-    await writeTextFile(join8(genDir, "meta.yml"), import_yaml4.default.stringify(meta));
-    const lifeEntries = await readdir7(this.paths.life);
+    await writeTextFile(join9(genDir, "meta.yml"), import_yaml4.default.stringify(meta));
+    const lifeEntries = await readdir8(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-        const srcPath = join8(this.paths.life, entry);
-        const destPath = join8(genDir, entry);
+        const srcPath = join9(this.paths.life, entry);
+        const destPath = join9(genDir, entry);
         let content = await readTextFile(srcPath);
         if (content && content.startsWith("# REAP MANAGED")) {
           content = content.replace(/^# REAP MANAGED[^\n]*\n/, "");
@@ -10087,28 +10131,28 @@ class GenerationManager {
         await unlink3(srcPath);
       }
     }
-    const backlogDir = join8(genDir, "backlog");
-    await mkdir4(backlogDir, { recursive: true });
+    const backlogDir = join9(genDir, "backlog");
+    await mkdir5(backlogDir, { recursive: true });
     try {
-      const backlogEntries = await readdir7(this.paths.backlog);
+      const backlogEntries = await readdir8(this.paths.backlog);
       for (const entry of backlogEntries) {
-        const content = await readTextFile(join8(this.paths.backlog, entry));
+        const content = await readTextFile(join9(this.paths.backlog, entry));
         if (!content)
           continue;
         const isConsumed = /status:\s*consumed/i.test(content) || /consumed:\s*true/i.test(content);
-        await writeTextFile(join8(backlogDir, entry), content);
+        await writeTextFile(join9(backlogDir, entry), content);
         if (isConsumed) {
-          await unlink3(join8(this.paths.backlog, entry));
+          await unlink3(join9(this.paths.backlog, entry));
         }
       }
     } catch {}
     try {
-      const mutEntries = await readdir7(this.paths.mutations);
+      const mutEntries = await readdir8(this.paths.mutations);
       if (mutEntries.length > 0) {
-        const mutDir = join8(genDir, "mutations");
-        await mkdir4(mutDir, { recursive: true });
+        const mutDir = join9(genDir, "mutations");
+        await mkdir5(mutDir, { recursive: true });
         for (const entry of mutEntries) {
-          await rename(join8(this.paths.mutations, entry), join8(mutDir, entry));
+          await rename(join9(this.paths.mutations, entry), join9(mutDir, entry));
         }
       }
     } catch {}
@@ -10197,6 +10241,40 @@ function emitError(command, message, details) {
   process.exit(1);
 }
 
+// src/cli/commands/run/next.ts
+var exports_next = {};
+__export(exports_next, {
+  execute: () => execute
+});
+async function execute(paths, _phase) {
+  const gm = new GenerationManager(paths);
+  const state = await gm.current();
+  if (!state) {
+    emitError("next", "No active Generation. Run /reap.start first.");
+  }
+  const isMerge = state.type === "merge";
+  if (state.lastNonce) {
+    const nextCommand = isMerge ? `reap run merge-${state.stage}` : `reap run ${state.stage}`;
+    emitOutput({
+      status: "ok",
+      command: "next",
+      phase: "done",
+      completed: ["gate", "auto-transition-detected"],
+      context: {
+        generationId: state.id,
+        stage: state.stage,
+        type: state.type
+      },
+      message: `Stage already advanced to ${state.stage} by auto-transition. Run: ${nextCommand}`,
+      nextCommand
+    });
+  }
+  emitError("next", `Stage transition not available. The current stage '${state.stage}' has not been completed yet. Run the stage command with --phase complete first, which will auto-advance to the next stage.`);
+}
+var init_next = __esm(() => {
+  init_generation();
+});
+
 // src/core/merge-lifecycle.ts
 class MergeLifeCycle {
   static next(stage) {
@@ -10244,14 +10322,14 @@ var init_merge_lifecycle = __esm(() => {
 });
 
 // src/core/hook-engine.ts
-import { readdir as readdir10 } from "fs/promises";
-import { join as join12 } from "path";
+import { readdir as readdir14 } from "fs/promises";
+import { join as join16 } from "path";
 import { execSync as execSync4 } from "child_process";
 async function executeHooks(hooksDir, event, projectRoot) {
   const hooks = await scanHooks(hooksDir, event);
   if (hooks.length === 0)
     return [];
-  const conditionsDir = join12(hooksDir, "conditions");
+  const conditionsDir = join16(hooksDir, "conditions");
   const results = [];
   for (const hook of hooks) {
     const conditionMet = await evaluateCondition(conditionsDir, hook.condition, projectRoot);
@@ -10276,7 +10354,7 @@ async function executeHooks(hooksDir, event, projectRoot) {
 async function scanHooks(hooksDir, event) {
   let entries;
   try {
-    entries = await readdir10(hooksDir);
+    entries = await readdir14(hooksDir);
   } catch {
     return [];
   }
@@ -10286,7 +10364,7 @@ async function scanHooks(hooksDir, event) {
     const match = filename.match(pattern);
     if (!match)
       continue;
-    const meta = await parseHookMeta(join12(hooksDir, filename), match[2]);
+    const meta = await parseHookMeta(join16(hooksDir, filename), match[2]);
     hooks.push({
       filename,
       name: match[1],
@@ -10307,7 +10385,7 @@ async function parseHookMeta(filePath, ext) {
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (fmMatch) {
       try {
-        const fm = import_yaml8.default.parse(fmMatch[1]) ?? {};
+        const fm = import_yaml9.default.parse(fmMatch[1]) ?? {};
         return {
           condition: String(fm.condition ?? "always"),
           order: Number(fm.order ?? 50)
@@ -10333,7 +10411,7 @@ async function parseHookMeta(filePath, ext) {
 async function evaluateCondition(conditionsDir, conditionName, projectRoot) {
   if (conditionName === "always")
     return { met: true };
-  const scriptPath = join12(conditionsDir, `${conditionName}.sh`);
+  const scriptPath = join16(conditionsDir, `${conditionName}.sh`);
   if (!await fileExists(scriptPath)) {
     return { met: false, reason: `condition script not found: ${conditionName}.sh` };
   }
@@ -10346,7 +10424,7 @@ async function evaluateCondition(conditionsDir, conditionName, projectRoot) {
 }
 async function executeShHook(hook, event, projectRoot, hooksDir) {
   try {
-    const stdout = execSync4(`bash "${join12(hooksDir, hook.filename)}"`, {
+    const stdout = execSync4(`bash "${join16(hooksDir, hook.filename)}"`, {
       cwd: projectRoot,
       timeout: 60000,
       stdio: "pipe"
@@ -10372,7 +10450,7 @@ async function executeShHook(hook, event, projectRoot, hooksDir) {
   }
 }
 async function executeMdHook(hook, event, hooksDir) {
-  const content = await readTextFile(join12(hooksDir, hook.filename));
+  const content = await readTextFile(join16(hooksDir, hook.filename));
   const body = content?.replace(/^---\n[\s\S]*?\n---\n?/, "").trim() ?? "";
   return {
     name: hook.name,
@@ -10382,115 +10460,10 @@ async function executeMdHook(hook, event, hooksDir) {
     content: body
   };
 }
-var import_yaml8;
+var import_yaml9;
 var init_hook_engine = __esm(() => {
   init_fs();
-  import_yaml8 = __toESM(require_dist(), 1);
-});
-
-// src/cli/commands/run/next.ts
-var exports_next = {};
-__export(exports_next, {
-  execute: () => execute
-});
-import { join as join13 } from "path";
-async function execute(paths, _phase) {
-  const gm = new GenerationManager(paths);
-  const state = await gm.current();
-  if (!state) {
-    emitError("next", "No active Generation. Run /reap.start first.");
-  }
-  if (state.expectedTokenHash) {
-    const args = process.argv.slice(2);
-    const nonce = args.find((a) => !a.startsWith("-") && a !== "run" && a !== "next");
-    if (!nonce) {
-      emitError("next", `Stage transition blocked: no token provided. The stage command outputs a nonce that must be passed to /reap.next. Example: /reap.next <nonce>. This ensures the stage command was actually executed — you cannot skip stages.`);
-    }
-    if (!verifyStageToken(nonce, state.id, state.stage, state.expectedTokenHash)) {
-      emitError("next", `Token verification failed. The provided nonce does not match. Re-run the current stage command (reap run ${state.stage}) to get a valid token. You cannot forge or guess the token.`);
-    }
-  }
-  const isMerge = state.type === "merge";
-  let nextStage;
-  if (isMerge) {
-    nextStage = MergeLifeCycle.next(state.stage);
-  } else {
-    nextStage = LifeCycle.next(state.stage);
-  }
-  if (!nextStage) {
-    emitError("next", `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() });
-  state.expectedTokenHash = undefined;
-  await gm.save(state);
-  const artifactFile = isMerge ? MERGE_ARTIFACT[nextStage] : NORMAL_ARTIFACT[nextStage];
-  if (artifactFile) {
-    const templateDir = join13(__require("os").homedir(), ".reap", "templates");
-    const templatePath = join13(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 previousStage = state.timeline[state.timeline.length - 2]?.stage;
-  const STAGE_HOOK = {
-    planning: "onLifeObjected",
-    implementation: "onLifePlanned",
-    validation: "onLifeImplemented",
-    completion: "onLifeValidated",
-    mate: "onMergeDetected",
-    merge: "onMergeMated",
-    sync: "onMergeMerged",
-    "validation:merge": "onMergeSynced",
-    "completion:merge": "onMergeValidated"
-  };
-  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);
-  emitOutput({
-    status: "ok",
-    command: "next",
-    phase: "done",
-    completed: ["gate", "nonce-verify", "advance-stage", "create-artifact", "hooks"],
-    context: {
-      generationId: state.id,
-      previousStage,
-      stage: nextStage,
-      type: state.type,
-      artifactFile,
-      hookResults: [...stageHookResults, ...transitionHookResults]
-    },
-    message: `Advanced to ${nextStage}. Proceed with /reap.${nextStage}.`
-  });
-}
-var NORMAL_ARTIFACT, MERGE_ARTIFACT;
-var init_next = __esm(() => {
-  init_generation();
-  init_lifecycle();
-  init_merge_lifecycle();
-  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"
-  };
+  import_yaml9 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/back.ts
@@ -10596,12 +10569,12 @@ var init_back = __esm(() => {
 });
 
 // src/core/backlog.ts
-import { readdir as readdir11 } from "fs/promises";
-import { join as join14 } from "path";
+import { readdir as readdir15 } from "fs/promises";
+import { join as join17 } from "path";
 async function scanBacklog(backlogDir) {
   let entries;
   try {
-    entries = await readdir11(backlogDir);
+    entries = await readdir15(backlogDir);
   } catch {
     return [];
   }
@@ -10609,7 +10582,7 @@ async function scanBacklog(backlogDir) {
   for (const filename of entries) {
     if (!filename.endsWith(".md"))
       continue;
-    const content = await readTextFile(join14(backlogDir, filename));
+    const content = await readTextFile(join17(backlogDir, filename));
     if (!content)
       continue;
     const { frontmatter, body } = parseFrontmatter2(content);
@@ -10627,7 +10600,7 @@ async function scanBacklog(backlogDir) {
   return items;
 }
 async function markBacklogConsumed(backlogDir, filename, genId) {
-  const filePath = join14(backlogDir, filename);
+  const filePath = join17(backlogDir, filename);
   const content = await readTextFile(filePath);
   if (!content)
     return;
@@ -10636,7 +10609,7 @@ async function markBacklogConsumed(backlogDir, filename, genId) {
   frontmatter.consumedBy = genId;
   delete frontmatter.consumed;
   const newContent = `---
-${import_yaml9.default.stringify(frontmatter).trim()}
+${import_yaml10.default.stringify(frontmatter).trim()}
 ---
 ${body}`;
   await writeTextFile(filePath, newContent);
@@ -10644,14 +10617,14 @@ ${body}`;
 async function revertBacklogConsumed(backlogDir, genId) {
   let entries;
   try {
-    entries = await readdir11(backlogDir);
+    entries = await readdir15(backlogDir);
   } catch {
     return;
   }
   for (const filename of entries) {
     if (!filename.endsWith(".md"))
       continue;
-    const filePath = join14(backlogDir, filename);
+    const filePath = join17(backlogDir, filename);
     const content = await readTextFile(filePath);
     if (!content)
       continue;
@@ -10660,7 +10633,7 @@ async function revertBacklogConsumed(backlogDir, genId) {
       frontmatter.status = "pending";
       delete frontmatter.consumedBy;
       const newContent = `---
-${import_yaml9.default.stringify(frontmatter).trim()}
+${import_yaml10.default.stringify(frontmatter).trim()}
 ---
 ${body}`;
       await writeTextFile(filePath, newContent);
@@ -10672,15 +10645,15 @@ function parseFrontmatter2(content) {
   if (!match)
     return { frontmatter: {}, body: content };
   try {
-    return { frontmatter: import_yaml9.default.parse(match[1]) ?? {}, body: match[2] };
+    return { frontmatter: import_yaml10.default.parse(match[1]) ?? {}, body: match[2] };
   } catch {
     return { frontmatter: {}, body: content };
   }
 }
-var import_yaml9;
+var import_yaml10;
 var init_backlog = __esm(() => {
   init_fs();
-  import_yaml9 = __toESM(require_dist(), 1);
+  import_yaml10 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/start.ts
@@ -10688,8 +10661,8 @@ var exports_start = {};
 __export(exports_start, {
   execute: () => execute3
 });
-import { join as join15 } from "path";
-import { readdir as readdir12 } from "fs/promises";
+import { join as join18 } from "path";
+import { readdir as readdir16 } from "fs/promises";
 function getFlag2(args, name) {
   const idx = args.indexOf(`--${name}`);
   return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
@@ -10738,18 +10711,18 @@ async function execute3(paths, phase, argv = []) {
     }
     let genomeVersion = 1;
     try {
-      const lineageEntries = await readdir12(paths.lineage);
+      const lineageEntries = await readdir16(paths.lineage);
       genomeVersion = lineageEntries.filter((e) => e.startsWith("gen-")).length + 1;
     } catch {}
     const state = await gm.create(goal, genomeVersion);
-    const { nonce, hash } = generateStageToken(state.id, state.stage);
-    state.expectedTokenHash = hash;
+    const { nonce, hash } = generateToken(state.id, state.stage);
+    state.expectedHash = hash;
     await gm.save(state);
     if (backlogFile) {
       await markBacklogConsumed(paths.backlog, backlogFile, state.id);
     }
-    const templateDir = join15(__require("os").homedir(), ".reap", "templates");
-    const templatePath = join15(templateDir, "01-objective.md");
+    const templateDir = join18(__require("os").homedir(), ".reap", "templates");
+    const templatePath = join18(templateDir, "01-objective.md");
     const destPath = paths.artifact("01-objective.md");
     if (await fileExists(templatePath)) {
       let template = await readTextFile(templatePath);
@@ -10808,12 +10781,133 @@ 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 join16 } from "path";
+import { join as join20 } from "path";
 import { execSync as execSync6 } from "child_process";
 function detectGenomeImpact(projectRoot) {
   const impact = {
@@ -10894,6 +10988,8 @@ 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.");
@@ -10904,8 +11000,8 @@ async function execute4(paths, phase) {
     const implContent = await readTextFile(paths.artifact("03-implementation.md"));
     const destPath = paths.artifact("05-completion.md");
     if (!await fileExists(destPath)) {
-      const templateDir = join16(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join16(templateDir, "05-completion.md");
+      const templateDir = join20(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join20(templateDir, "05-completion.md");
       if (await fileExists(templatePath)) {
         const { writeTextFile: writeTextFile2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
         const template = await readTextFile(templatePath);
@@ -10913,6 +11009,8 @@ async function execute4(paths, phase) {
           await writeTextFile2(destPath, template);
       }
     }
+    setPhaseNonce(state, "completion", "retrospective");
+    await gm.save(state);
     emitOutput({
       status: "prompt",
       command: "completion",
@@ -10932,6 +11030,8 @@ async function execute4(paths, phase) {
     });
   }
   if (phase === "feedKnowledge") {
+    verifyPhaseEntry("completion", state, "completion", "retrospective");
+    await gm.save(state);
     const backlogItems = await scanBacklog(paths.backlog);
     const genomeChanges = backlogItems.filter((b) => b.type === "genome-change" && b.status !== "consumed");
     const envChanges = backlogItems.filter((b) => b.type === "environment-change" && b.status !== "consumed");
@@ -11021,6 +11121,7 @@ var init_completion = __esm(() => {
   init_backlog();
   init_hook_engine();
   init_commit();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/abort.ts
@@ -11028,8 +11129,8 @@ var exports_abort = {};
 __export(exports_abort, {
   execute: () => execute5
 });
-import { join as join17 } from "path";
-import { readdir as readdir13, unlink as unlink5 } from "fs/promises";
+import { join as join21 } from "path";
+import { readdir as readdir17, unlink as unlink6 } from "fs/promises";
 function getFlag3(args, name) {
   const idx = args.indexOf(`--${name}`);
   return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
@@ -11104,15 +11205,15 @@ 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(join17(paths.backlog, `aborted-${state.id}.md`), backlogContent);
+      await writeTextFile(join21(paths.backlog, `aborted-${state.id}.md`), backlogContent);
       backlogSaved = true;
     }
     await revertBacklogConsumed(paths.backlog, state.id);
     try {
-      const lifeEntries = await readdir13(paths.life);
+      const lifeEntries = await readdir17(paths.life);
       for (const entry of lifeEntries) {
         if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-          await unlink5(join17(paths.life, entry));
+          await unlink6(join21(paths.life, entry));
         }
       }
     } catch {}
@@ -11171,8 +11272,8 @@ var exports_objective = {};
 __export(exports_objective, {
   execute: () => execute7
 });
-import { join as join18 } from "path";
-import { readdir as readdir14 } from "fs/promises";
+import { join as join22 } from "path";
+import { readdir as readdir18 } from "fs/promises";
 async function execute7(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11189,13 +11290,13 @@ async function execute7(paths, phase) {
     const envSummary = await readTextFile(paths.environmentSummary);
     let prevCompletion = null;
     try {
-      const lineageEntries = await readdir14(paths.lineage);
+      const lineageEntries = await readdir18(paths.lineage);
       const genDirs = lineageEntries.filter((e) => e.startsWith("gen-")).sort();
       if (genDirs.length > 0) {
         const lastGen = genDirs[genDirs.length - 1];
-        prevCompletion = await readTextFile(join18(paths.lineage, lastGen, "05-completion.md"));
+        prevCompletion = await readTextFile(join22(paths.lineage, lastGen, "05-completion.md"));
         if (!prevCompletion) {
-          const compressed = await readTextFile(join18(paths.lineage, `${lastGen}.md`));
+          const compressed = await readTextFile(join22(paths.lineage, `${lastGen}.md`));
           if (compressed)
             prevCompletion = compressed.slice(0, 2000);
         }
@@ -11208,12 +11309,12 @@ async function execute7(paths, phase) {
     const configContent = await readTextFile(paths.config);
     let lineageCount = 0;
     try {
-      const entries = await readdir14(paths.lineage);
+      const entries = await readdir18(paths.lineage);
       lineageCount = entries.filter((e) => e.startsWith("gen-")).length;
     } catch {}
     if (!isReentry) {
-      const templateDir = join18(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join18(templateDir, "01-objective.md");
+      const templateDir = join22(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join22(templateDir, "01-objective.md");
       if (await fileExists(templatePath)) {
         let template = await readTextFile(templatePath);
         if (template) {
@@ -11222,6 +11323,8 @@ async function execute7(paths, phase) {
         }
       }
     }
+    setPhaseNonce(state, "objective", "work");
+    await gm.save(state);
     emitOutput({
       status: "prompt",
       command: "objective",
@@ -11283,6 +11386,8 @@ async function execute7(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("objective", state, "objective", "work");
+    await gm.save(state);
     const artifactPath = paths.artifact("01-objective.md");
     if (!await fileExists(artifactPath)) {
       emitError("objective", "01-objective.md does not exist. Complete the objective work first.");
@@ -11291,20 +11396,26 @@ 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 } = generateStageToken(state.id, state.stage);
-    state.expectedTokenHash = hash;
-    await gm.save(state);
+    const { nonce, hash } = generateToken(state.id, state.stage);
+    state.expectedHash = hash;
+    state.lastNonce = nonce;
     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}`;
     emitOutput({
       status: "ok",
       command: "objective",
       phase: "complete",
-      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "artifact-verify", "hooks"],
+      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "artifact-verify", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: `Objective stage complete. Advance with: /reap.next ${nonce}`
+      message: `Objective stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
@@ -11313,6 +11424,7 @@ var init_objective = __esm(() => {
   init_fs();
   init_backlog();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/planning.ts
@@ -11320,7 +11432,7 @@ var exports_planning = {};
 __export(exports_planning, {
   execute: () => execute8
 });
-import { join as join19 } from "path";
+import { join as join23 } from "path";
 async function execute8(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11330,6 +11442,8 @@ 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.");
@@ -11344,14 +11458,16 @@ async function execute8(paths, phase) {
     const principlesContent = await readTextFile(paths.principles);
     const implContent = await readTextFile(paths.artifact("03-implementation.md"));
     if (!isReentry) {
-      const templateDir = join19(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join19(templateDir, "02-planning.md");
+      const templateDir = join23(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join23(templateDir, "02-planning.md");
       if (await fileExists(templatePath)) {
         const template = await readTextFile(templatePath);
         if (template)
           await writeTextFile(artifactPath, template);
       }
     }
+    setPhaseNonce(state, "planning", "work");
+    await gm.save(state);
     emitOutput({
       status: "prompt",
       command: "planning",
@@ -11408,6 +11524,8 @@ async function execute8(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("planning", state, "planning", "work");
+    await gm.save(state);
     const artifactPath = paths.artifact("02-planning.md");
     if (!await fileExists(artifactPath)) {
       emitError("planning", "02-planning.md does not exist. Complete the planning work first.");
@@ -11416,20 +11534,26 @@ 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 } = generateStageToken(state.id, state.stage);
-    state.expectedTokenHash = hash;
-    await gm.save(state);
+    const { nonce, hash } = generateToken(state.id, state.stage);
+    state.expectedHash = hash;
+    state.lastNonce = nonce;
     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}`;
     emitOutput({
       status: "ok",
       command: "planning",
       phase: "complete",
-      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "artifact-verify", "hooks"],
+      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "artifact-verify", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: `Planning stage complete. Advance with: /reap.next ${nonce}`
+      message: `Planning stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
@@ -11437,6 +11561,7 @@ var init_planning = __esm(() => {
   init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/implementation.ts
@@ -11444,7 +11569,7 @@ var exports_implementation = {};
 __export(exports_implementation, {
   execute: () => execute9
 });
-import { join as join20 } from "path";
+import { join as join24 } from "path";
 async function execute9(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11454,6 +11579,8 @@ 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.");
@@ -11466,14 +11593,16 @@ async function execute9(paths, phase) {
     const conventionsContent = await readTextFile(paths.conventions);
     const constraintsContent = await readTextFile(paths.constraints);
     if (!isReentry) {
-      const templateDir = join20(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join20(templateDir, "03-implementation.md");
+      const templateDir = join24(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join24(templateDir, "03-implementation.md");
       if (await fileExists(templatePath)) {
         const template = await readTextFile(templatePath);
         if (template)
           await writeTextFile(artifactPath, template);
       }
     }
+    setPhaseNonce(state, "implementation", "work");
+    await gm.save(state);
     emitOutput({
       status: "prompt",
       command: "implementation",
@@ -11533,24 +11662,32 @@ async function execute9(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("implementation", state, "implementation", "work");
+    await gm.save(state);
     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 } = generateStageToken(state.id, state.stage);
-    state.expectedTokenHash = hash;
-    await gm.save(state);
+    const { nonce, hash } = generateToken(state.id, state.stage);
+    state.expectedHash = hash;
+    state.lastNonce = nonce;
     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}`;
     emitOutput({
       status: "ok",
       command: "implementation",
       phase: "complete",
-      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "hooks"],
+      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: `Implementation stage complete. Advance with: /reap.next ${nonce}`
+      message: `Implementation stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
@@ -11558,6 +11695,7 @@ var init_implementation = __esm(() => {
   init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/validation.ts
@@ -11565,7 +11703,7 @@ var exports_validation = {};
 __export(exports_validation, {
   execute: () => execute10
 });
-import { join as join21 } from "path";
+import { join as join25 } from "path";
 async function execute10(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11575,6 +11713,8 @@ 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.");
@@ -11588,14 +11728,16 @@ async function execute10(paths, phase) {
     const implContent = await readTextFile(implArtifact);
     const objectiveContent = await readTextFile(paths.artifact("01-objective.md"));
     if (!isReentry) {
-      const templateDir = join21(__require("os").homedir(), ".reap", "templates");
-      const templatePath = join21(templateDir, "04-validation.md");
+      const templateDir = join25(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join25(templateDir, "04-validation.md");
       if (await fileExists(templatePath)) {
         const template = await readTextFile(templatePath);
         if (template)
           await writeTextFile(artifactPath, template);
       }
     }
+    setPhaseNonce(state, "validation", "work");
+    await gm.save(state);
     emitOutput({
       status: "prompt",
       command: "validation",
@@ -11665,24 +11807,32 @@ async function execute10(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("validation", state, "validation", "work");
+    await gm.save(state);
     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 } = generateStageToken(state.id, state.stage);
-    state.expectedTokenHash = hash;
-    await gm.save(state);
+    const { nonce, hash } = generateToken(state.id, state.stage);
+    state.expectedHash = hash;
+    state.lastNonce = nonce;
     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";
     emitOutput({
       status: "ok",
       command: "validation",
       phase: "complete",
-      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "artifact-verify", "hooks"],
+      completed: ["gate", "context-collect", "artifact-ensure", "creative-work", "artifact-verify", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: `Validation stage complete. Advance with: /reap.next ${nonce}`
+      message: `Validation stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
@@ -11690,6 +11840,7 @@ var init_validation = __esm(() => {
   init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/evolve.ts
@@ -11707,8 +11858,9 @@ function buildSubagentPrompt(paths, state, genomeSummaries, backlogSummary) {
   lines.push("");
   lines.push("## Rules");
   lines.push("- ALWAYS use `reap run <cmd>` commands to drive lifecycle. NEVER modify `current.yml` directly.");
-  lines.push("- Use `/reap.next` to advance stages and `/reap.back` to regress.");
-  lines.push("- Each stage command runs its own hook automatically at completion.");
+  lines.push("- Each `--phase complete` auto-transitions to the next stage. No explicit `/reap.next` needed.");
+  lines.push("- Use `/reap.back` to regress to a previous stage.");
+  lines.push("- Each stage command verifies the stage chain token at entry (auto-verified from lastNonce).");
   lines.push("- `/reap.completion` handles archiving and the final commit.");
   lines.push("");
   lines.push("## Current State");
@@ -11743,7 +11895,7 @@ function buildSubagentPrompt(paths, state, genomeSummaries, backlogSummary) {
     lines.push(`Resume from stage: **${state.stage}**`);
   }
   lines.push("");
-  lines.push("### Stage Loop");
+  lines.push("### Stage Loop (Auto-Transition)");
   lines.push("1. Read `current.yml` to confirm the current stage.");
   lines.push("2. Execute the stage command:");
   lines.push("   - `objective` -> `/reap.objective`");
@@ -11752,31 +11904,48 @@ function buildSubagentPrompt(paths, state, genomeSummaries, backlogSummary) {
   lines.push("   - `validation` -> `/reap.validation`");
   lines.push("   - `completion` -> `/reap.completion`");
   lines.push("3. Write the required artifact BEFORE completing the stage.");
-  lines.push("4. Run the stage complete phase if applicable (e.g., `reap run <stage> --phase complete`).");
-  lines.push("5. If current stage is NOT `completion`: run `/reap.next` to advance, then go to step 1.");
-  lines.push("6. If current stage IS `completion`: `/reap.completion` auto-archives after feedKnowledge phase. Done.");
+  lines.push("4. Run `--phase complete` — this auto-transitions to the next stage.");
+  lines.push("5. If current stage IS `completion`: `/reap.completion` auto-archives after feedKnowledge phase. Done.");
+  lines.push("6. Otherwise: the output tells you the next command — go to step 1.");
   lines.push("");
-  lines.push("Note: `/reap.next` is a transition command, NOT a lifecycle stage.");
+  lines.push("Note: `--phase complete` auto-transitions. `/reap.next` is a fallback, not required.");
   lines.push("");
   lines.push("## Project");
   lines.push(`- Path: ${paths.projectRoot}`);
   lines.push("");
-  lines.push("## Stage Chain Token");
-  lines.push("- Each stage command returns a `stageToken` in its output context.");
-  lines.push("- You MUST pass this token to `/reap.next --token <TOKEN>` (or set `REAP_STAGE_TOKEN` env var).");
-  lines.push("- Without a valid token, stage transition will be REJECTED.");
-  lines.push("- If token is missing or mismatched, re-run the current stage command to obtain a new token.");
+  lines.push("## Stage Chain Token (Auto-Transition)");
+  lines.push("- Each `--phase complete` generates a stage chain token and auto-transitions to the next stage.");
+  lines.push("- The next stage command verifies the token at entry — this ensures stages were not skipped.");
+  lines.push("- `/reap.next` is maintained as a fallback but is no longer required in the normal flow.");
   lines.push("");
   lines.push("## Commit Rules");
   lines.push("- Create a git commit after implementation and after completion.");
   lines.push("- Use conventional commit format: `feat|fix|chore(scope): description`");
   lines.push("- Include the generation ID in the commit message.");
   lines.push("");
+  lines.push("## Submodule Commit Rules");
+  lines.push("- 커밋 전 반드시 `git -C tests status -s` 로 tests submodule의 dirty 상태를 확인하라.");
+  lines.push("- dirty 파일이 있으면:");
+  lines.push('  1. `git -C tests add -A && git -C tests commit -m "..." && git -C tests push`');
+  lines.push("  2. parent repo에서 `git add tests` 로 submodule ref 업데이트");
+  lines.push("  3. 그 다음 parent repo의 나머지 파일과 함께 커밋");
+  lines.push('- completion의 prompt에 "Dirty submodules detected"가 있으면 반드시 위 절차를 따르라.');
+  lines.push("");
   lines.push("## Hook Prompt Execution");
   lines.push("- completion output의 `prompt` 필드에 '## Hook Prompts' 섹션이 포함되어 있으면, 해당 hook prompt를 반드시 순서대로 실행하라.");
   lines.push("- Hook prompt는 `.md` hook 파일의 내용으로, AI가 따라야 할 지시사항이다.");
   lines.push("- Hook prompt에 유저 확인이 필요한 경우(예: 프리뷰+컨펌), autonomous mode에서도 이를 존중하라.");
   lines.push("");
+  lines.push("## Artifact Consistency & Design Pivot Detection");
+  lines.push("- Before proceeding to a new stage, verify that previous stage artifacts align with the current design direction.");
+  lines.push("- If the prompt context contains design corrections that contradict existing artifacts:");
+  lines.push("  1. Prioritize prompt instructions over the goal text.");
+  lines.push("  2. Use `/reap.back` to regress to the stage with the inconsistent artifact and rewrite it.");
+  lines.push("- Regression triggers (use `/reap.back` in these situations):");
+  lines.push("  - Artifacts contradict the design direction given in the prompt");
+  lines.push("  - Implementation approach differs from what objective/planning described");
+  lines.push("  - Prompt provides explicit design changes but earlier artifacts still reflect the old design");
+  lines.push("");
   lines.push("## Interrupt Protection");
   lines.push('- 사용자의 새 메시지가 중간에 들어와도, 명시적 kill/중단 요청("중단", "stop", "abort")이 아닌 한 현재 작업을 끝까지 완료하라.');
   lines.push("- 작업을 shortcut으로 건너뛰거나 결과를 추정하지 마라. 모든 validation은 실제 실행 결과를 확인하라.");
@@ -11876,7 +12045,7 @@ async function execute11(paths, phase) {
           "",
           "### HARD-GATE",
           "NEVER modify `current.yml` directly to change the stage.",
-          "ALWAYS use `/reap.next` to advance and `/reap.back` to regress.",
+          "Stage transitions happen automatically via `--phase complete`. Use `/reap.back` to regress.",
           "",
           "### Autonomous Override",
           "- Skip routine human confirmations. Proceed autonomously.",
@@ -11892,10 +12061,10 @@ async function execute11(paths, phase) {
           "- `/reap.validation` -> `onLifeValidated`",
           "- `/reap.completion` -> `onLifeCompleted` (before archiving and commit)",
           "",
-          "`/reap.next` only handles stage transitions -- it does NOT execute hooks or archiving.",
+          "`--phase complete` auto-transitions to the next stage. `/reap.next` is a fallback.",
           "`/reap.completion` handles archiving and the final commit.",
           "",
-          "### Lifecycle Loop",
+          "### Lifecycle Loop (Auto-Transition)",
           "Execute the following loop until the generation is complete:",
           "1. Read `current.yml` to determine the current stage",
           "2. Execute the corresponding stage command:",
@@ -11904,14 +12073,16 @@ async function execute11(paths, phase) {
           "   - `implementation` -> `/reap.implementation`",
           "   - `validation` -> `/reap.validation`",
           "   - `completion` -> `/reap.completion`",
-          "3. When the stage command completes (hooks already executed by the stage command):",
-          "   - If the current stage is `completion`: the loop ends.",
-          "   - Otherwise: run `/reap.next` to advance, then return to step 1.",
+          "3. `--phase complete` auto-transitions to the next stage.",
+          "   - If the stage is `completion`: the loop ends.",
+          "   - Otherwise: follow the `nextCommand` in the output to run the next stage.",
           "",
           "### Handling Issues",
           "- If validation fails: `/reap.back` to return to implementation (or earlier), then resume the loop",
-          "- If the human wants to pause: stop the loop",
-          "- If the human wants to skip a stage: advance with `/reap.next` without running the stage command"
+          "- If artifacts contradict the design direction in the prompt: `/reap.back` to fix the inconsistent artifact",
+          "- If implementation approach differs from what objective/planning described: `/reap.back` to objective or planning",
+          "- If the prompt provides design corrections that differ from existing artifacts: prioritize prompt instructions, `/reap.back` to rewrite artifacts with the corrected design",
+          "- If the human wants to pause: stop the loop"
         ].join(`
 `)
       });
@@ -11957,8 +12128,8 @@ var exports_sync_genome = {};
 __export(exports_sync_genome, {
   execute: () => execute13
 });
-import { readdir as readdir15 } from "fs/promises";
-import { join as join22 } from "path";
+import { readdir as readdir19 } from "fs/promises";
+import { join as join26 } from "path";
 async function execute13(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11970,10 +12141,10 @@ async function execute13(paths, phase) {
     const sourceMapContent = await readTextFile(paths.sourceMap);
     const domainFiles = {};
     try {
-      const entries = await readdir15(paths.domain);
+      const entries = await readdir19(paths.domain);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
-          const content = await readTextFile(join22(paths.domain, entry));
+          const content = await readTextFile(join26(paths.domain, entry));
           if (content)
             domainFiles[entry] = content.slice(0, 1000);
         }
@@ -11981,7 +12152,7 @@ async function execute13(paths, phase) {
     } catch {}
     let genomeVersion = 0;
     try {
-      const lineageEntries = await readdir15(paths.lineage);
+      const lineageEntries = await readdir19(paths.lineage);
       genomeVersion = lineageEntries.filter((e) => e.startsWith("gen-")).length;
     } catch {}
     emitOutput({
@@ -12032,20 +12203,26 @@ async function execute13(paths, phase) {
     });
   }
   if (phase === "complete") {
+    const genId = state?.id || "manual";
+    const config = await ConfigManager.read(paths);
+    config.lastSyncedGeneration = genId;
+    await ConfigManager.write(paths, config);
     emitOutput({
       status: "ok",
       command: "sync-genome",
       phase: "complete",
-      completed: ["gate", "context-collect", "analyze", "apply"],
+      completed: ["gate", "context-collect", "analyze", "apply", "update-sync-state"],
       context: {
-        hasActiveGeneration: hasActiveGen
+        hasActiveGeneration: hasActiveGen,
+        lastSyncedGeneration: genId
       },
-      message: hasActiveGen ? "Genome differences recorded as backlog items. Apply during Completion." : "Genome synchronized."
+      message: hasActiveGen ? "Genome differences recorded as backlog items. Apply during Completion." : `Genome synchronized. lastSyncedGeneration: ${genId}`
     });
   }
 }
 var init_sync_genome = __esm(() => {
   init_generation();
+  init_config();
   init_fs();
 });
 
@@ -12054,8 +12231,8 @@ var exports_sync_environment = {};
 __export(exports_sync_environment, {
   execute: () => execute14
 });
-import { readdir as readdir16 } from "fs/promises";
-import { join as join23 } from "path";
+import { readdir as readdir20 } from "fs/promises";
+import { join as join27 } from "path";
 async function execute14(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -12064,10 +12241,10 @@ async function execute14(paths, phase) {
     const envSummary = await readTextFile(paths.environmentSummary);
     const envDocs = {};
     try {
-      const docsEntries = await readdir16(paths.environmentDocs);
+      const docsEntries = await readdir20(paths.environmentDocs);
       for (const entry of docsEntries) {
         if (entry.endsWith(".md")) {
-          const content = await readTextFile(join23(paths.environmentDocs, entry));
+          const content = await readTextFile(join27(paths.environmentDocs, entry));
           if (content)
             envDocs[entry] = content.slice(0, 1000);
         }
@@ -12075,7 +12252,7 @@ async function execute14(paths, phase) {
     } catch {}
     let linksContent = null;
     try {
-      linksContent = await readTextFile(join23(paths.environmentResources, "links.md"));
+      linksContent = await readTextFile(join27(paths.environmentResources, "links.md"));
     } catch {}
     emitOutput({
       status: "prompt",
@@ -12147,7 +12324,7 @@ var exports_help = {};
 __export(exports_help, {
   execute: () => execute15
 });
-import { join as join24 } from "path";
+import { join as join28 } from "path";
 function detectLanguage(configContent) {
   const raw = configContent?.match(/language:\s*(\S+)/)?.[1] ?? null;
   if (raw && raw in LANGUAGE_ALIASES)
@@ -12182,7 +12359,7 @@ async function execute15(paths) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
   const configContent = await readTextFile(paths.config);
-  const installedVersion = "0.14.0";
+  const installedVersion = "0.15.1";
   const autoUpdate = configContent?.match(/autoUpdate:\s*(true|false)/)?.[1] === "true";
   const versionDisplay = formatVersionLine(installedVersion, !autoUpdate);
   const rawLang = detectLanguage(configContent);
@@ -12193,7 +12370,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 = join24(ReapPaths.packageHooksDir, "reap-guide.md");
+    const guidePath = join28(ReapPaths.packageHooksDir, "reap-guide.md");
     const reapGuide = await readTextFile(guidePath) ?? "";
     emitOutput({
       status: "prompt",
@@ -12498,8 +12675,8 @@ var init_merge = __esm(() => {
 });
 
 // src/core/merge-generation.ts
-import { readdir as readdir17, mkdir as mkdir8, rename as rename3 } from "fs/promises";
-import { join as join25 } from "path";
+import { readdir as readdir21, mkdir as mkdir10, rename as rename3 } from "fs/promises";
+import { join as join29 } from "path";
 
 class MergeGenerationManager {
   paths;
@@ -12510,7 +12687,7 @@ class MergeGenerationManager {
     const content = await readTextFile(this.paths.currentYml);
     if (content === null || !content.trim())
       return null;
-    const state = import_yaml10.default.parse(content);
+    const state = import_yaml11.default.parse(content);
     if (!state.type)
       state.type = "normal";
     if (!state.parents)
@@ -12543,7 +12720,7 @@ class MergeGenerationManager {
       genomeHash,
       commonAncestor: commonAncestor ?? undefined
     };
-    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
     return state;
   }
   async createFromBranch(targetBranch, projectRoot) {
@@ -12587,7 +12764,7 @@ class MergeGenerationManager {
       genomeHash,
       commonAncestor: commonAncestor ?? undefined
     };
-    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
     return { state, report };
   }
   async resolveLatestGenId(branch, cwd) {
@@ -12612,7 +12789,7 @@ class MergeGenerationManager {
       const content = gitShow(ref, metaFile, cwd);
       if (content) {
         try {
-          const meta = import_yaml10.default.parse(content);
+          const meta = import_yaml11.default.parse(content);
           if (meta?.id)
             metas.push(meta);
         } catch {}
@@ -12659,7 +12836,7 @@ class MergeGenerationManager {
     if (!state.timeline)
       state.timeline = [];
     state.timeline.push({ stage: next, at: new Date().toISOString() });
-    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
     return state;
   }
   async complete() {
@@ -12675,7 +12852,7 @@ class MergeGenerationManager {
     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 mkdir8(genDir, { recursive: true });
+    await mkdir10(genDir, { recursive: true });
     const meta = {
       id: state.id,
       type: "merge",
@@ -12685,19 +12862,19 @@ class MergeGenerationManager {
       startedAt: state.startedAt,
       completedAt: now
     };
-    await writeTextFile(join25(genDir, "meta.yml"), import_yaml10.default.stringify(meta));
-    const lifeEntries = await readdir17(this.paths.life);
+    await writeTextFile(join29(genDir, "meta.yml"), import_yaml11.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(join25(this.paths.life, entry), join25(genDir, entry));
+        await rename3(join29(this.paths.life, entry), join29(genDir, entry));
       }
     }
-    const backlogDir = join25(genDir, "backlog");
-    await mkdir8(backlogDir, { recursive: true });
+    const backlogDir = join29(genDir, "backlog");
+    await mkdir10(backlogDir, { recursive: true });
     try {
-      const backlogEntries = await readdir17(this.paths.backlog);
+      const backlogEntries = await readdir21(this.paths.backlog);
       for (const entry of backlogEntries) {
-        await rename3(join25(this.paths.backlog, entry), join25(backlogDir, entry));
+        await rename3(join29(this.paths.backlog, entry), join29(backlogDir, entry));
       }
     } catch {}
     await writeTextFile(this.paths.currentYml, "");
@@ -12705,7 +12882,7 @@ class MergeGenerationManager {
     return compression;
   }
   async save(state) {
-    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml11.default.stringify(state));
   }
 }
 function canFastForward(localLatestId, remoteLatestId, allMetas) {
@@ -12767,7 +12944,7 @@ function findCommonAncestor(idA, idB, metas) {
   }
   return null;
 }
-var import_yaml10;
+var import_yaml11;
 var init_merge_generation = __esm(() => {
   init_merge_lifecycle();
   init_compression();
@@ -12777,7 +12954,7 @@ var init_merge_generation = __esm(() => {
   init_merge();
   init_lineage();
   init_compression();
-  import_yaml10 = __toESM(require_dist(), 1);
+  import_yaml11 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/merge-start.ts
@@ -12894,6 +13071,8 @@ 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");
+    await mgm.save(state);
     emitOutput({
       status: "prompt",
       command: "merge-detect",
@@ -12922,24 +13101,37 @@ async function execute18(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("merge-detect", state, "detect", "review");
+    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}`;
     emitOutput({
       status: "ok",
       command: "merge-detect",
       phase: "complete",
-      completed: ["gate", "artifact-read", "review", "hooks"],
+      completed: ["gate", "artifact-read", "review", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: "Detect stage complete. Run /reap.next to advance to mate stage."
+      message: `Detect stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
 var init_merge_detect = __esm(() => {
   init_merge_generation();
+  init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/merge-mate.ts
@@ -12959,12 +13151,16 @@ 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") {
     const detectContent = await readTextFile(detectArtifact);
+    setPhaseNonce(state, "mate", "resolve");
+    await mgm.save(state);
     emitOutput({
       status: "prompt",
       command: "merge-mate",
@@ -13004,24 +13200,37 @@ async function execute19(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("merge-mate", state, "mate", "resolve");
+    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}`;
     emitOutput({
       status: "ok",
       command: "merge-mate",
       phase: "complete",
-      completed: ["gate", "artifact-read", "conflict-resolution", "hooks"],
+      completed: ["gate", "artifact-read", "conflict-resolution", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: "Mate stage complete. Run /reap.next to advance to merge stage."
+      message: `Mate stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
 var init_merge_mate = __esm(() => {
   init_merge_generation();
+  init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/merge-merge.ts
@@ -13041,6 +13250,8 @@ 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.");
@@ -13049,6 +13260,8 @@ async function execute20(paths, phase) {
     const mateContent = await readTextFile(mateArtifact);
     const detectContent = await readTextFile(paths.artifact("01-detect.md"));
     const targetBranch = state.goal.split(" + ").pop() ?? "";
+    setPhaseNonce(state, "merge", "work");
+    await mgm.save(state);
     emitOutput({
       status: "prompt",
       command: "merge-merge",
@@ -13083,24 +13296,37 @@ async function execute20(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("merge-merge", state, "merge", "work");
+    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}`;
     emitOutput({
       status: "ok",
       command: "merge-merge",
       phase: "complete",
-      completed: ["gate", "artifact-read", "source-merge", "hooks"],
+      completed: ["gate", "artifact-read", "source-merge", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: "Merge stage complete. Run /reap.next to advance to sync stage."
+      message: `Merge stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
 var init_merge_merge = __esm(() => {
   init_merge_generation();
+  init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/merge-sync.ts
@@ -13120,6 +13346,8 @@ 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.");
@@ -13129,6 +13357,8 @@ async function execute21(paths, phase) {
     const genomeConstraints = await readTextFile(paths.constraints);
     const genomePrinciples = await readTextFile(paths.principles);
     const mergeContent = await readTextFile(mergeArtifact);
+    setPhaseNonce(state, "sync", "verify");
+    await mgm.save(state);
     emitOutput({
       status: "prompt",
       command: "merge-sync",
@@ -13173,24 +13403,37 @@ async function execute21(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("merge-sync", state, "sync", "verify");
+    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}`;
     emitOutput({
       status: "ok",
       command: "merge-sync",
       phase: "complete",
-      completed: ["gate", "context-collect", "sync-verify", "hooks"],
+      completed: ["gate", "context-collect", "sync-verify", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: "Sync stage complete. Run /reap.next to advance to validation stage."
+      message: `Sync stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
 var init_merge_sync = __esm(() => {
   init_merge_generation();
+  init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/merge-validation.ts
@@ -13210,12 +13453,16 @@ 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") {
     const constraintsContent = await readTextFile(paths.constraints);
+    setPhaseNonce(state, "validation", "work");
+    await mgm.save(state);
     emitOutput({
       status: "prompt",
       command: "merge-validation",
@@ -13252,28 +13499,41 @@ async function execute22(paths, phase) {
     });
   }
   if (phase === "complete") {
+    verifyPhaseEntry("merge-validation", state, "validation", "work");
+    await mgm.save(state);
     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;
     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}`;
     emitOutput({
       status: "ok",
       command: "merge-validation",
       phase: "complete",
-      completed: ["gate", "context-collect", "validation-work", "hooks"],
+      completed: ["gate", "context-collect", "validation-work", "hooks", "auto-transition"],
       context: {
         id: state.id,
-        hookResults
+        hookResults,
+        nextStage: transition.nextStage,
+        artifactFile: transition.artifactFile,
+        transitionHookResults: [...transition.stageHookResults, ...transition.transitionHookResults]
       },
-      message: "Validation stage complete. Run /reap.next to advance to completion stage."
+      message: `Validation stage complete. Auto-advanced to ${transition.nextStage}. Run: ${nextCommand}`,
+      nextCommand
     });
   }
 }
 var init_merge_validation = __esm(() => {
   init_merge_generation();
+  init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/merge-completion.ts
@@ -13293,6 +13553,8 @@ 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.");
@@ -13302,6 +13564,8 @@ async function execute23(paths, phase) {
     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");
+    await mgm.save(state);
     emitOutput({
       status: "prompt",
       command: "merge-completion",
@@ -13332,6 +13596,8 @@ async function execute23(paths, phase) {
     });
   }
   if (phase === "archive") {
+    verifyPhaseEntry("merge-completion", state, "completion", "retrospective");
+    await mgm.save(state);
     const hookResults = await executeHooks(paths.hooks, "onMergeCompleted", paths.projectRoot);
     const submodules = checkSubmodules(paths.projectRoot);
     const dirtySubmodules = submodules.filter((s) => s.dirty);
@@ -13358,6 +13624,7 @@ var init_merge_completion = __esm(() => {
   init_fs();
   init_hook_engine();
   init_commit();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/merge-evolve.ts
@@ -13410,10 +13677,10 @@ async function execute24(paths, phase) {
       "- `/reap.merge.validation` -> `onMergeValidated`",
       "- `/reap.merge.completion` -> `onMergeCompleted` (before archiving and commit)",
       "",
-      "`/reap.next` only handles stage transitions -- it does NOT execute hooks or archiving.",
+      "`--phase complete` auto-transitions to the next stage. `/reap.next` is a fallback.",
       "`/reap.merge.completion` handles archiving and the final commit.",
       "",
-      "### Merge Lifecycle Loop",
+      "### Merge Lifecycle Loop (Auto-Transition)",
       "Execute the following loop until the generation is complete:",
       "1. Read `current.yml` to determine the current stage",
       "2. Execute the corresponding merge stage command:",
@@ -13423,9 +13690,17 @@ async function execute24(paths, phase) {
       "   - `sync` -> `/reap.merge.sync`",
       "   - `validation` -> `/reap.merge.validation`",
       "   - `completion` -> `/reap.merge.completion`",
-      "3. When a stage command completes (hooks already executed by the stage command):",
-      "   - If the current stage is `completion`: the loop ends.",
-      "   - Otherwise: run `/reap.next` to advance, then return to step 1.",
+      "3. `--phase complete` auto-transitions to the next stage.",
+      "   - If the stage is `completion`: the loop ends.",
+      "   - Otherwise: follow the `nextCommand` in the output to run the next stage.",
+      "",
+      "### Submodule Commit Rules",
+      "- 커밋 전 반드시 `git -C tests status -s` 로 tests submodule의 dirty 상태를 확인하라.",
+      "- dirty 파일이 있으면:",
+      '  1. `git -C tests add -A && git -C tests commit -m "..." && git -C tests push`',
+      "  2. parent repo에서 `git add tests` 로 submodule ref 업데이트",
+      "  3. 그 다음 parent repo의 나머지 파일과 함께 커밋",
+      '- completion의 prompt에 "Dirty submodules detected"가 있으면 반드시 위 절차를 따르라.',
       "",
       "### Handling Issues",
       "- If validation fails: `/reap.back merge` or `/reap.back mate`, then resume the loop",
@@ -13527,12 +13802,174 @@ var init_merge2 = __esm(() => {
   init_lineage();
 });
 
+// src/cli/commands/run/evolve-recovery.ts
+var exports_evolve_recovery = {};
+__export(exports_evolve_recovery, {
+  execute: () => execute26
+});
+import { join as join30 } from "path";
+import { readdir as readdir22 } from "fs/promises";
+function getFlag4(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
+}
+function getPositionals3(args, valueFlags) {
+  const result = [];
+  for (let i = 0;i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      const flagName = args[i].slice(2);
+      if (valueFlags.includes(flagName) && i + 1 < args.length)
+        i++;
+      continue;
+    }
+    result.push(args[i]);
+  }
+  return result;
+}
+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 [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"))
+    ]);
+    return {
+      objective: objective ?? "(not found)",
+      planning: planning ?? "(not found)",
+      implementation: implementation ?? "(not found)",
+      completion: completion ?? "(not found)"
+    };
+  }
+  try {
+    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));
+      if (content) {
+        return {
+          objective: content,
+          planning: "(compressed - see above)",
+          implementation: "(compressed - see above)",
+          completion: "(compressed - see above)"
+        };
+      }
+    }
+  } catch {}
+  return null;
+}
+async function execute26(paths, phase, argv = []) {
+  const positionals = getPositionals3(argv, ["reason"]);
+  const targetGenIds = positionals;
+  const reason = getFlag4(argv, "reason");
+  const gm = new GenerationManager(paths);
+  if (!phase || phase === "review") {
+    if (targetGenIds.length === 0) {
+      emitError("evolve-recovery", 'Target generation ID(s) required. Usage: reap run evolve-recovery <gen-id> [<gen-id>...] [--reason "..."]');
+    }
+    const state = await gm.current();
+    if (state && state.id) {
+      emitError("evolve-recovery", `Generation ${state.id} is in progress (stage: ${state.stage}). Complete it before starting a recovery.`);
+    }
+    const artifactsByGen = {};
+    const notFound = [];
+    for (const genId of targetGenIds) {
+      const artifacts = await loadLineageArtifacts(paths, genId);
+      if (artifacts) {
+        artifactsByGen[genId] = artifacts;
+      } else {
+        notFound.push(genId);
+      }
+    }
+    if (notFound.length > 0) {
+      emitError("evolve-recovery", `Generation(s) not found in lineage: ${notFound.join(", ")}`);
+    }
+    const artifactSections = [];
+    for (const [genId, artifacts] of Object.entries(artifactsByGen)) {
+      artifactSections.push(`### Generation: ${genId}`, "", "#### 01-objective.md", artifacts.objective.slice(0, 2000), "", "#### 02-planning.md", artifacts.planning.slice(0, 2000), "", "#### 03-implementation.md", artifacts.implementation.slice(0, 2000), "", "#### 05-completion.md", artifacts.completion.slice(0, 2000), "");
+    }
+    emitOutput({
+      status: "prompt",
+      command: "evolve-recovery",
+      phase: "review",
+      completed: ["gate", "artifact-load"],
+      context: {
+        targetGenIds,
+        reason: reason ?? null,
+        artifactsByGen
+      },
+      prompt: [
+        "## Recovery Review",
+        "",
+        "Review the following generation artifacts and determine if a recovery generation is needed.",
+        "",
+        "### Review Criteria",
+        "(a) **Artifact Inconsistency**: Are there contradictions or misalignments between objective, planning, implementation, and completion artifacts?",
+        "(b) **Structural Defects**: Are there architectural issues, missing edge cases, or technical debt introduced?",
+        "(c) **Human-Specified Corrections**: " + (reason ? `The human specified: "${reason}"` : "No specific corrections requested."),
+        "",
+        "### Target Generation Artifacts",
+        "",
+        ...artifactSections,
+        "",
+        "### Decision",
+        "If recovery is needed, run: `reap run evolve-recovery --phase create " + targetGenIds.join(" ") + (reason ? ` --reason "${reason}"` : "") + "`",
+        'If no recovery is needed, report: "No recovery needed" with your reasoning.'
+      ].join(`
+`)
+    });
+  }
+  if (phase === "create") {
+    if (targetGenIds.length === 0) {
+      emitError("evolve-recovery", "Target generation ID(s) required for create phase.");
+    }
+    const existing = await gm.current();
+    if (existing && existing.id) {
+      emitError("evolve-recovery", `Generation ${existing.id} is already in progress.`);
+    }
+    let genomeVersion = 1;
+    try {
+      const lineageEntries = await readdir22(paths.lineage);
+      genomeVersion = lineageEntries.filter((e) => e.startsWith("gen-")).length + 1;
+    } 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;
+    await gm.save(state);
+    emitOutput({
+      status: "prompt",
+      command: "evolve-recovery",
+      phase: "created",
+      completed: ["gate", "create-generation"],
+      context: {
+        generationId: state.id,
+        goal: state.goal,
+        type: state.type,
+        recovers: state.recovers,
+        parents: state.parents,
+        genomeHash: state.genomeHash
+      },
+      prompt: `Recovery generation ${state.id} created (corrects: ${targetGenIds.join(", ")}). Proceed with /reap.objective or /reap.evolve.`,
+      message: `Recovery generation ${state.id} started.`
+    });
+  }
+}
+var init_evolve_recovery = __esm(() => {
+  init_generation();
+  init_fs();
+  init_lineage();
+});
+
 // src/cli/commands/run/pull.ts
 var exports_pull = {};
 __export(exports_pull, {
-  execute: () => execute26
+  execute: () => execute27
 });
-async function execute26(paths, phase, argv = []) {
+async function execute27(paths, phase, argv = []) {
   const positionals = argv.filter((a) => !a.startsWith("--"));
   const targetBranchArg = positionals[0];
   const gm = new GenerationManager(paths);
@@ -13591,9 +14028,9 @@ async function execute26(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 rm3 of remoteMetasRaw) {
-        if (!allMetas.find((m) => m.id === rm3.id))
-          allMetas.push(rm3);
+      for (const rm5 of remoteMetasRaw) {
+        if (!allMetas.find((m) => m.id === rm5.id))
+          allMetas.push(rm5);
       }
       const ffResult = canFastForward(localLatest.id, remoteLatest.id, allMetas);
       if (ffResult.fastForward) {
@@ -13653,9 +14090,9 @@ var init_pull = __esm(() => {
 // src/cli/commands/run/config.ts
 var exports_config = {};
 __export(exports_config, {
-  execute: () => execute27
+  execute: () => execute28
 });
-async function execute27(paths) {
+async function execute28(paths) {
   const config = await ConfigManager.read(paths);
   const lines = [
     `REAP Configuration (${paths.config})`,
@@ -13684,25 +14121,119 @@ var init_config2 = __esm(() => {
   init_config();
 });
 
+// src/cli/commands/run/update-genome.ts
+var exports_update_genome = {};
+__export(exports_update_genome, {
+  execute: () => execute29
+});
+async function execute29(paths, phase) {
+  const gm = new GenerationManager(paths);
+  const current = await gm.current();
+  if (current !== null) {
+    emitError(COMMAND, `Active generation exists (${current.id}). Cannot run update-genome during a generation.`);
+  }
+  const backlogItems = await scanBacklog(paths.backlog);
+  const pending = backlogItems.filter((b) => b.type === "genome-change" && b.status === "pending");
+  if (phase === "apply") {
+    await applyPhase(paths, pending);
+  } else {
+    scanPhase(pending);
+  }
+}
+function scanPhase(pending) {
+  if (pending.length === 0) {
+    emitOutput({
+      status: "ok",
+      command: COMMAND,
+      phase: "scan",
+      completed: ["gate", "scan"],
+      message: "No pending genome changes."
+    });
+  }
+  emitOutput({
+    status: "prompt",
+    command: COMMAND,
+    phase: "scan",
+    completed: ["gate", "scan"],
+    context: {
+      pendingCount: pending.length,
+      items: pending.map((b) => ({
+        filename: b.filename,
+        title: b.title,
+        body: b.body
+      }))
+    },
+    prompt: [
+      "Pending genome-change backlog items are listed in context.items.",
+      "For each item, apply the described changes to the corresponding .reap/genome/ files.",
+      "Only modify files under .reap/genome/. Do NOT modify source code.",
+      "After all changes are applied, run: reap run update-genome --phase apply"
+    ].join(`
+`),
+    nextCommand: "reap run update-genome --phase apply"
+  });
+}
+async function applyPhase(paths, pending) {
+  if (pending.length === 0) {
+    emitOutput({
+      status: "ok",
+      command: COMMAND,
+      phase: "apply",
+      completed: ["gate", "scan", "apply"],
+      message: "No pending genome changes to apply."
+    });
+  }
+  for (const item of pending) {
+    await markBacklogConsumed(paths.backlog, item.filename, "update-genome");
+  }
+  const config = await ConfigManager.read(paths);
+  config.genomeVersion = (config.genomeVersion ?? 0) + 1;
+  await ConfigManager.write(paths, config);
+  emitOutput({
+    status: "ok",
+    command: COMMAND,
+    phase: "apply",
+    completed: ["gate", "scan", "apply", "version-bump"],
+    context: {
+      consumedCount: pending.length,
+      consumedFiles: pending.map((b) => b.filename),
+      genomeVersion: config.genomeVersion
+    },
+    message: `Applied ${pending.length} genome-change(s). genomeVersion → v${config.genomeVersion}. Please commit the changes.`,
+    prompt: [
+      `${pending.length} genome-change backlog item(s) consumed. genomeVersion bumped to v${config.genomeVersion}.`,
+      "Commit the genome changes with message:",
+      `  chore: update-genome v${config.genomeVersion} — ${pending.map((b) => b.title).join(", ")}`
+    ].join(`
+`)
+  });
+}
+var COMMAND = "update-genome";
+var init_update_genome = __esm(() => {
+  init_config();
+  init_generation();
+  init_backlog();
+});
+
 // src/cli/commands/run/refresh-knowledge.ts
 var exports_refresh_knowledge = {};
 __export(exports_refresh_knowledge, {
-  execute: () => execute28
+  execute: () => execute30
 });
-import { join as join26 } from "path";
-import { readdir as readdir18 } from "fs/promises";
+import { join as join31 } 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(join26(genomeDir, "source-map.md"));
+  const smContent = await readTextFile(join31(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(join26(genomeDir, file));
+    const fileContent = await readTextFile(join31(genomeDir, file));
     if (!fileContent)
       continue;
     const lines = fileContent.split(`
@@ -13724,14 +14255,14 @@ ${fileContent.split(`
 `;
     }
   }
-  const domainDir = join26(genomeDir, "domain");
+  const domainDir = join31(genomeDir, "domain");
   if (await fileExists(domainDir)) {
     let l2Lines = 0;
     let l2Overflow = false;
     try {
-      const domainFiles = (await readdir18(domainDir)).filter((f) => f.endsWith(".md")).sort();
+      const domainFiles = (await readdir23(domainDir)).filter((f) => f.endsWith(".md")).sort();
       for (const file of domainFiles) {
-        const fileContent = await readTextFile(join26(domainDir, file));
+        const fileContent = await readTextFile(join31(domainDir, file));
         if (!fileContent)
           continue;
         const lines = fileContent.split(`
@@ -13781,8 +14312,8 @@ function buildStrictSection(strict, genStage) {
   }
   return sections;
 }
-async function execute28(paths) {
-  const guidePath = join26(ReapPaths.packageHooksDir, "reap-guide.md");
+async function execute30(paths) {
+  const guidePath = join31(ReapPaths.packageHooksDir, "reap-guide.md");
   const reapGuide = await readTextFile(guidePath) || "";
   const { content: genomeContent } = await loadGenome(paths.genome);
   const envSummary = await readTextFile(paths.environmentSummary) || "";
@@ -13872,7 +14403,7 @@ async function runCommand(command, phase, argv = []) {
     try {
       const config = await ConfigManager.read(paths);
       if (config.autoIssueReport) {
-        const version = "0.14.0";
+        const version = "0.15.1";
         const errMsg = err instanceof Error ? err.message : String(err);
         const title = `[auto] reap run ${command}: ${errMsg.slice(0, 80)}`;
         const body = [
@@ -13918,8 +14449,10 @@ var init_run = __esm(() => {
     "merge-completion": () => Promise.resolve().then(() => (init_merge_completion(), exports_merge_completion)),
     "merge-evolve": () => Promise.resolve().then(() => (init_merge_evolve(), exports_merge_evolve)),
     merge: () => Promise.resolve().then(() => (init_merge2(), exports_merge)),
+    "evolve-recovery": () => Promise.resolve().then(() => (init_evolve_recovery(), exports_evolve_recovery)),
     pull: () => Promise.resolve().then(() => (init_pull(), exports_pull)),
     config: () => Promise.resolve().then(() => (init_config2(), exports_config)),
+    "update-genome": () => Promise.resolve().then(() => (init_update_genome(), exports_update_genome)),
     refreshKnowledge: () => Promise.resolve().then(() => (init_refresh_knowledge(), exports_refresh_knowledge))
   };
 });
@@ -13940,11 +14473,14 @@ var {
   Help
 } = import__.default;
 
+// src/cli/index.ts
+import { createInterface } from "readline";
+
 // src/cli/commands/init.ts
 init_paths();
 init_config();
-import { mkdir as mkdir3, readdir as readdir4, chmod } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir4, readdir as readdir5, chmod } from "fs/promises";
+import { join as join6 } from "path";
 
 // src/core/agents/claude-code.ts
 init_fs();
@@ -14394,6 +14930,42 @@ class AgentRegistry {
 
 // src/cli/commands/init.ts
 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";
+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"));
+  let installed = 0;
+  for (const file of reapCmdFiles) {
+    const src = await readTextFileOrThrow(join4(ReapPaths.userReapCommands, file));
+    const name = file.replace(/\.md$/, "");
+    const skillDir = join4(projectClaudeSkills, name);
+    const skillFile = join4(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;
+    const skillContent = `---
+name: ${name}
+description: "${description}"
+---
+${body}`;
+    const existing = await readTextFile(skillFile);
+    if (existing !== null && existing === skillContent)
+      continue;
+    if (!dryRun) {
+      await mkdir3(skillDir, { recursive: true });
+      await writeTextFile(skillFile, skillContent);
+    }
+    installed++;
+  }
+  return { installed, total: reapCmdFiles.length };
+}
+
+// src/cli/commands/init.ts
 var COMMAND_NAMES = [
   "reap.objective",
   "reap.planning",
@@ -14420,10 +14992,12 @@ var COMMAND_NAMES = [
   "reap.merge.validation",
   "reap.merge.completion",
   "reap.merge.evolve",
+  "reap.evolve.recovery",
   "reap.merge",
   "reap.pull",
   "reap.push",
   "reap.config",
+  "reap.update-genome",
   "reap.refreshKnowledge"
 ];
 async function initProject(projectRoot, projectName, entryMode, preset, onProgress) {
@@ -14433,21 +15007,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 = join5(ReapPaths.packageTemplatesDir, "presets", preset);
-    const presetExists = await fileExists(join5(presetDir, "principles.md"));
+    const presetDir = join6(ReapPaths.packageTemplatesDir, "presets", preset);
+    const presetExists = await fileExists(join6(presetDir, "principles.md"));
     if (!presetExists) {
       throw new Error(`Unknown preset: "${preset}". Available presets: bun-hono-react`);
     }
   }
   log("Creating .reap/ directory structure...");
-  await mkdir3(paths.genome, { recursive: true });
-  await mkdir3(paths.domain, { recursive: true });
-  await mkdir3(paths.environment, { recursive: true });
-  await mkdir3(join5(paths.environment, "docs"), { recursive: true });
-  await mkdir3(join5(paths.environment, "resources"), { recursive: true });
-  await mkdir3(paths.life, { recursive: true });
-  await mkdir3(paths.backlog, { recursive: true });
-  await mkdir3(paths.lineage, { recursive: true });
+  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 });
   log("Writing config.yml...");
   let hasGhCli = false;
   try {
@@ -14460,7 +15034,7 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   }
   const detectedLanguage = await AgentRegistry.readLanguage();
   const config = {
-    version: "0.14.0",
+    version: "0.15.1",
     project: projectName,
     entryMode,
     strict: false,
@@ -14473,10 +15047,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 ? join5(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
+  const genomeSourceDir = preset ? join6(ReapPaths.packageTemplatesDir, "presets", preset) : ReapPaths.packageGenomeDir;
   for (const file of genomeTemplates) {
-    const src = join5(genomeSourceDir, file);
-    const dest = join5(paths.genome, file);
+    const src = join6(genomeSourceDir, file);
+    const dest = join6(paths.genome, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
   if ((entryMode === "adoption" || entryMode === "migration") && !preset) {
@@ -14485,35 +15059,47 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
     await syncGenomeFromProject2(projectRoot, paths.genome, log);
   }
   log("Installing artifact templates...");
-  await mkdir3(ReapPaths.userReapTemplates, { recursive: true });
+  await mkdir4(ReapPaths.userReapTemplates, { recursive: true });
   const artifactFiles = ["01-objective.md", "02-planning.md", "03-implementation.md", "04-validation.md", "05-completion.md"];
   for (const file of artifactFiles) {
-    const src = join5(ReapPaths.packageArtifactsDir, file);
-    const dest = join5(ReapPaths.userReapTemplates, file);
+    const src = join6(ReapPaths.packageArtifactsDir, file);
+    const dest = join6(ReapPaths.userReapTemplates, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
-  const domainGuideSrc = join5(ReapPaths.packageGenomeDir, "domain/README.md");
-  const domainGuideDest = join5(ReapPaths.userReapTemplates, "domain-guide.md");
+  const domainGuideSrc = join6(ReapPaths.packageGenomeDir, "domain/README.md");
+  const domainGuideDest = join6(ReapPaths.userReapTemplates, "domain-guide.md");
   await writeTextFile(domainGuideDest, await readTextFileOrThrow(domainGuideSrc));
-  const mergeTemplatesDir = join5(ReapPaths.userReapTemplates, "merge");
-  await mkdir3(mergeTemplatesDir, { recursive: true });
+  const mergeTemplatesDir = join6(ReapPaths.userReapTemplates, "merge");
+  await mkdir4(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 = join5(ReapPaths.packageArtifactsDir, "merge");
+  const mergeSourceDir = join6(ReapPaths.packageArtifactsDir, "merge");
   for (const file of mergeArtifactFiles) {
-    const src = join5(mergeSourceDir, file);
-    const dest = join5(mergeTemplatesDir, file);
+    const src = join6(mergeSourceDir, file);
+    const dest = join6(mergeTemplatesDir, file);
     await writeTextFile(dest, await readTextFileOrThrow(src));
   }
   log("Installing hook conditions...");
-  const conditionsSourceDir = join5(ReapPaths.packageTemplatesDir, "conditions");
-  const conditionsDestDir = join5(paths.hooks, "conditions");
-  await mkdir3(conditionsDestDir, { recursive: true });
-  const conditionFiles = await readdir4(conditionsSourceDir);
+  const conditionsSourceDir = join6(ReapPaths.packageTemplatesDir, "conditions");
+  const conditionsDestDir = join6(paths.hooks, "conditions");
+  await mkdir4(conditionsDestDir, { recursive: true });
+  const conditionFiles = await readdir5(conditionsSourceDir);
   for (const file of conditionFiles) {
     if (!file.endsWith(".sh"))
       continue;
-    const src = join5(conditionsSourceDir, file);
-    const dest = join5(conditionsDestDir, file);
+    const src = join6(conditionsSourceDir, file);
+    const dest = join6(conditionsDestDir, file);
+    await writeTextFile(dest, await readTextFileOrThrow(src));
+    await chmod(dest, 493);
+  }
+  log("Installing hook scripts...");
+  const hooksSourceDir = join6(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);
     await writeTextFile(dest, await readTextFileOrThrow(src));
     await chmod(dest, 493);
   }
@@ -14533,6 +15119,11 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   if (detectedAgents.length === 0) {
     log("  No AI agents detected.");
   }
+  log("Syncing skills to project...");
+  const skillsResult = await syncSkillsToProject(projectRoot);
+  if (skillsResult.installed > 0) {
+    log(`  .claude/skills/ (${skillsResult.installed} synced)`);
+  }
   const autoSynced = (entryMode === "adoption" || entryMode === "migration") && !preset;
   if (!autoSynced) {
     log(`
@@ -14543,8 +15134,8 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
 
 // src/cli/commands/update.ts
 init_paths();
-import { readdir as readdir9, unlink as unlink4, rm as rm2, mkdir as mkdir6 } from "fs/promises";
-import { join as join10 } from "path";
+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";
 
 // src/core/hooks.ts
@@ -14571,15 +15162,15 @@ init_config();
 init_fs();
 init_generation();
 var import_yaml5 = __toESM(require_dist(), 1);
-import { readdir as readdir8, rename as rename2 } from "fs/promises";
-import { join as join9 } from "path";
+import { readdir as readdir9, rename as rename2 } from "fs/promises";
+import { join as join10 } from "path";
 async function needsMigration(paths) {
   try {
-    const entries = await readdir8(paths.lineage, { withFileTypes: true });
+    const entries = await readdir9(paths.lineage, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || !entry.name.startsWith("gen-"))
         continue;
-      const metaPath = join9(paths.lineage, entry.name, "meta.yml");
+      const metaPath = join10(paths.lineage, entry.name, "meta.yml");
       const content = await readTextFile(metaPath);
       if (content === null)
         return true;
@@ -14593,18 +15184,18 @@ async function migrateLineage(paths) {
   const result = { migrated: [], skipped: [], errors: [] };
   let entries;
   try {
-    const dirEntries = await readdir8(paths.lineage, { withFileTypes: true });
+    const dirEntries = await readdir9(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 = join9(paths.lineage, dirName, "meta.yml");
+    const metaPath = join10(paths.lineage, dirName, "meta.yml");
     const metaContent = await readTextFile(metaPath);
     const seq = parseGenSeq(dirName);
     let goal = "";
-    const objContent = await readTextFile(join9(paths.lineage, dirName, "01-objective.md"));
+    const objContent = await readTextFile(join10(paths.lineage, dirName, "01-objective.md"));
     if (objContent) {
       const goalMatch = objContent.match(/## Goal\n+([\s\S]*?)(?=\n##)/);
       if (goalMatch)
@@ -14619,7 +15210,7 @@ async function migrateLineage(paths) {
   let prevId = null;
   for (const entry of plan) {
     if (entry.hasMeta) {
-      const metaContent = await readTextFile(join9(paths.lineage, entry.dirName, "meta.yml"));
+      const metaContent = await readTextFile(join10(paths.lineage, entry.dirName, "meta.yml"));
       if (metaContent) {
         const meta = import_yaml5.default.parse(metaContent);
         prevId = meta.id;
@@ -14640,11 +15231,11 @@ async function migrateLineage(paths) {
         startedAt: `legacy-${entry.seq}`,
         completedAt: `legacy-${entry.seq}`
       };
-      await writeTextFile(join9(paths.lineage, entry.dirName, "meta.yml"), import_yaml5.default.stringify(meta));
+      await writeTextFile(join10(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(join9(paths.lineage, entry.dirName), join9(paths.lineage, newDirName));
+        await rename2(join10(paths.lineage, entry.dirName), join10(paths.lineage, newDirName));
       }
       prevId = newId;
       result.migrated.push(`${entry.dirName} → ${newDirName}`);
@@ -14921,13 +15512,13 @@ async function updateProject(projectRoot, dryRun = false) {
   const config = await paths.isReapProject() ? await ConfigManager.read(paths) : null;
   const adapters = await AgentRegistry.getActiveAdapters(config ?? undefined);
   const commandsDir = ReapPaths.packageCommandsDir;
-  const commandFiles = await readdir9(commandsDir);
-  await mkdir6(ReapPaths.userReapCommands, { recursive: true });
+  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(join10(commandsDir, file));
-    const dest = join10(ReapPaths.userReapCommands, file);
+    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}`);
@@ -14941,11 +15532,11 @@ async function updateProject(projectRoot, dryRun = false) {
     const agentCmdDir = adapter.getCommandsDir();
     const label = adapter.displayName;
     try {
-      const existing = await readdir9(agentCmdDir);
+      const existing = await readdir10(agentCmdDir);
       for (const file of existing) {
         if (!file.startsWith("reap.") || !file.endsWith(".md"))
           continue;
-        const filePath = join10(agentCmdDir, file);
+        const filePath = join11(agentCmdDir, file);
         const content = await readTextFile(filePath);
         if (content !== null && content.includes("redirected to ~/.reap/commands/")) {
           if (!dryRun)
@@ -14963,11 +15554,11 @@ async function updateProject(projectRoot, dryRun = false) {
       }
     }
   }
-  await mkdir6(ReapPaths.userReapTemplates, { recursive: true });
+  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(join10(ReapPaths.packageArtifactsDir, file));
-    const dest = join10(ReapPaths.userReapTemplates, file);
+    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}`);
@@ -14977,8 +15568,8 @@ async function updateProject(projectRoot, dryRun = false) {
       result.updated.push(`~/.reap/templates/${file}`);
     }
   }
-  const domainGuideSrc = await readTextFileOrThrow(join10(ReapPaths.packageGenomeDir, "domain/README.md"));
-  const domainGuideDest = join10(ReapPaths.userReapTemplates, "domain-guide.md");
+  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`);
@@ -14987,13 +15578,13 @@ async function updateProject(projectRoot, dryRun = false) {
       await writeTextFile(domainGuideDest, domainGuideSrc);
     result.updated.push(`~/.reap/templates/domain-guide.md`);
   }
-  const mergeTemplatesDir = join10(ReapPaths.userReapTemplates, "merge");
-  await mkdir6(mergeTemplatesDir, { recursive: true });
+  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 = join10(ReapPaths.packageArtifactsDir, "merge");
+  const mergeSourceDir = join11(ReapPaths.packageArtifactsDir, "merge");
   for (const file of mergeArtifactFiles) {
-    const src = await readTextFileOrThrow(join10(mergeSourceDir, file));
-    const dest = join10(mergeTemplatesDir, file);
+    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}`);
@@ -15034,47 +15625,23 @@ async function updateProject(projectRoot, dryRun = false) {
         result.updated.push(`Config: added ${backfillResult.added.join(", ")}`);
       }
     }
-    const projectClaudeSkills = join10(paths.projectRoot, ".claude", "skills");
-    const reapCmdFiles = (await readdir9(ReapPaths.userReapCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
-    let cmdInstalled = 0;
-    for (const file of reapCmdFiles) {
-      const src = await readTextFileOrThrow(join10(ReapPaths.userReapCommands, file));
-      const name = file.replace(/\.md$/, "");
-      const skillDir = join10(projectClaudeSkills, name);
-      const skillFile = join10(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;
-      const skillContent = `---
-name: ${name}
-description: "${description}"
----
-${body}`;
-      const existing = await readTextFile(skillFile);
-      if (existing !== null && existing === skillContent)
-        continue;
-      if (!dryRun) {
-        await mkdir6(skillDir, { recursive: true });
-        await writeTextFile(skillFile, skillContent);
-      }
-      cmdInstalled++;
-    }
-    if (cmdInstalled > 0) {
-      result.updated.push(`.claude/skills/ (${cmdInstalled} synced)`);
+    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/ (${reapCmdFiles.length} unchanged)`);
+      result.skipped.push(`.claude/skills/ (${skillsResult.total} unchanged)`);
     }
-    const projectClaudeCommands = join10(paths.projectRoot, ".claude", "commands");
+    const projectClaudeCommands = join11(paths.projectRoot, ".claude", "commands");
     try {
-      const legacyFiles = (await readdir9(projectClaudeCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
+      const legacyFiles = (await readdir10(projectClaudeCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
       for (const file of legacyFiles) {
         if (!dryRun)
-          await unlink4(join10(projectClaudeCommands, file));
+          await unlink4(join11(projectClaudeCommands, file));
         result.removed.push(`.claude/commands/${file} (legacy)`);
       }
     } catch {}
     await migrateLegacyFiles(paths, dryRun, result);
-    const currentVersion = "0.14.0";
+    const currentVersion = "0.15.1";
     const migrationResult = await MigrationRunner.run(paths, currentVersion, dryRun);
     for (const m of migrationResult.migrated) {
       result.updated.push(`[migration] ${m}`);
@@ -15150,7 +15717,7 @@ async function migrateLegacyFiles(paths, dryRun, result) {
 }
 async function removeDirIfExists(dirPath, label, dryRun, result) {
   try {
-    const entries = await readdir9(dirPath);
+    const entries = await readdir10(dirPath);
     if (entries.length > 0 || true) {
       if (!dryRun)
         await rm2(dirPath, { recursive: true });
@@ -15173,6 +15740,7 @@ async function getStatus(projectRoot) {
     version: config.version,
     project: config.project,
     entryMode: config.entryMode,
+    lastSyncedGeneration: config.lastSyncedGeneration,
     generation: current ? {
       id: current.id,
       goal: current.goal,
@@ -15191,21 +15759,361 @@ async function getStatus(projectRoot) {
 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 { mkdir as mkdir7, stat as stat3, copyFile } from "fs/promises";
-import { join as join11 } from "path";
-async function dirExists(path) {
+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 {
-    const s = await stat3(path);
-    return s.isDirectory();
+    config = import_yaml7.default.parse(content) ?? {};
   } catch {
-    return false;
+    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)");
+  }
+  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 (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 (config.autoUpdate !== undefined && typeof config.autoUpdate !== "boolean") {
+    warnings.push("config.yml: 'autoUpdate' should be boolean");
+  }
+  if (config.autoSubagent !== undefined && typeof config.autoSubagent !== "boolean") {
+    warnings.push("config.yml: 'autoSubagent' should be boolean");
   }
 }
-async function fixProject(projectRoot) {
-  const paths = new ReapPaths(projectRoot);
-  const issues = [];
-  const fixed = [];
+async function checkCurrentYml(paths, errors, warnings) {
+  const content = await readTextFile(paths.currentYml);
+  if (content === null || !content.trim()) {
+    return null;
+  }
+  let state;
+  try {
+    state = import_yaml7.default.parse(content) ?? {};
+  } 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;
+  }
+  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)`);
+    }
+  }
+  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(", ")})`);
+    }
+  }
+  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}"`);
+    }
+  }
+  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");
+    }
+  }
+  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;
+  }
+  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 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 {}
+        }
+      }
+    }
+    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)`);
+        }
+      }
+    }
+  }
+}
+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 (typeof meta.completedAt === "string") {
+    if (!isISODate(meta.completedAt)) {
+      errors.push(`${location}: completedAt "${meta.completedAt}" is not a valid ISO date`);
+    }
+  }
+  if (typeof meta.startedAt === "string") {
+    if (!isISODate(meta.startedAt)) {
+      warnings.push(`${location}: startedAt "${meta.startedAt}" is not a valid ISO date`);
+    }
+  }
+  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}"`);
+  }
+  if (meta.genomeHash !== undefined && typeof meta.genomeHash !== "string") {
+    warnings.push(`${location}: genomeHash should be a string`);
+  }
+}
+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)`);
+    }
+  }
+}
+async function checkBacklog(paths, errors, warnings) {
+  let entries;
+  try {
+    entries = await readdir11(paths.backlog);
+  } catch {
+    return;
+  }
+  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;
+    }
+    let fm;
+    try {
+      fm = import_yaml7.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`);
+    }
+  }
+}
+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`);
+    }
+  }
+  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}'`);
+    }
+  }
+}
+
+// src/cli/commands/fix.ts
+async function checkProject(projectRoot) {
+  const paths = new ReapPaths(projectRoot);
+  return checkIntegrity(paths);
+}
+async function dirExists(path) {
+  try {
+    const s = await stat4(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function fixProject(projectRoot) {
+  const paths = new ReapPaths(projectRoot);
+  const issues = [];
+  const fixed = [];
   const requiredDirs = [
     { path: paths.genome, name: "genome" },
     { path: paths.domain, name: "genome/domain" },
@@ -15216,7 +16124,7 @@ async function fixProject(projectRoot) {
   ];
   for (const dir of requiredDirs) {
     if (!await dirExists(dir.path)) {
-      await mkdir7(dir.path, { recursive: true });
+      await mkdir8(dir.path, { recursive: true });
       fixed.push(`Recreated missing directory: ${dir.name}/`);
     }
   }
@@ -15228,7 +16136,7 @@ async function fixProject(projectRoot) {
   ];
   for (const gf of genomeFiles) {
     if (!await fileExists(gf.path)) {
-      const templateSrc = join11(ReapPaths.packageGenomeDir, gf.name);
+      const templateSrc = join13(ReapPaths.packageGenomeDir, gf.name);
       if (await fileExists(templateSrc)) {
         await copyFile(templateSrc, gf.path);
         fixed.push(`Restored missing genome/${gf.name} from template`);
@@ -15244,7 +16152,7 @@ async function fixProject(projectRoot) {
   if (currentContent !== null) {
     if (currentContent.trim()) {
       try {
-        const state = import_yaml7.default.parse(currentContent);
+        const state = import_yaml8.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.`);
         }
@@ -15253,7 +16161,7 @@ async function fixProject(projectRoot) {
         if (!state.goal)
           issues.push("current.yml is missing 'goal' field. Manual correction required.");
         if (!await dirExists(paths.backlog)) {
-          await mkdir7(paths.backlog, { recursive: true });
+          await mkdir8(paths.backlog, { recursive: true });
           fixed.push("Recreated missing backlog/ directory for active generation");
         }
       } catch {
@@ -15265,14 +16173,273 @@ async function fixProject(projectRoot) {
   return { issues, fixed };
 }
 
+// src/cli/commands/destroy.ts
+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";
+async function getProjectName(projectRoot) {
+  try {
+    const paths = new ReapPaths(projectRoot);
+    const config = await ConfigManager.read(paths);
+    return config.project;
+  } catch {
+    return null;
+  }
+}
+async function destroyProject(projectRoot) {
+  const removed = [];
+  const skipped = [];
+  const reapDir = join14(projectRoot, ".reap");
+  if (await fileExists(reapDir)) {
+    await rm3(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}`);
+    }
+  } 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)");
+  }
+}
+async function cleanGitignore(projectRoot, removed, skipped) {
+  const gitignorePath = join14(projectRoot, ".gitignore");
+  const content = await readTextFile(gitignorePath);
+  if (content === null) {
+    skipped.push(".gitignore (not found)");
+    return;
+  }
+  const reapPatterns = [
+    /^# REAP.*$/m,
+    /^\.claude\/skills\/reap\..*$/m,
+    /^\.claude\/commands\/reap\..*$/m,
+    /^\.reap\/.*$/m
+  ];
+  let cleaned = content;
+  let anyRemoved = false;
+  for (const pattern of reapPatterns) {
+    if (pattern.test(cleaned)) {
+      cleaned = cleaned.replace(new RegExp(pattern.source, "gm"), "");
+      anyRemoved = true;
+    }
+  }
+  if (!anyRemoved) {
+    skipped.push(".gitignore (no REAP entries)");
+    return;
+  }
+  cleaned = cleaned.replace(/\n{3,}/g, `
+
+`).trim() + `
+`;
+  await writeTextFile(gitignorePath, cleaned);
+  removed.push(".gitignore (REAP entries removed)");
+}
+
+// src/cli/commands/clean.ts
+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";
+async function hasActiveGeneration(projectRoot) {
+  const paths = new ReapPaths(projectRoot);
+  try {
+    const mgr = new GenerationManager(paths);
+    const current = await mgr.current();
+    return current !== null;
+  } catch {
+    return false;
+  }
+}
+async function cleanProject(projectRoot, options) {
+  const paths = new ReapPaths(projectRoot);
+  const actions = [];
+  const warnings = [];
+  if (options.lineage === "delete") {
+    await rm4(paths.lineage, { recursive: true, force: true });
+    await mkdir9(paths.lineage, { recursive: true });
+    actions.push("Lineage: 전체 삭제됨");
+  } else {
+    await compressLineage(paths, actions);
+  }
+  await cleanLife(paths, actions);
+  if (options.hooks === "reset") {
+    const hooksDir = paths.hooks;
+    if (await fileExists(hooksDir)) {
+      await rm4(hooksDir, { recursive: true, force: true });
+      await mkdir9(hooksDir, { recursive: true });
+      actions.push("Hooks: 초기화됨");
+    } else {
+      actions.push("Hooks: 디렉토리 없음 (skip)");
+    }
+  } else {
+    actions.push("Hooks: 기존 유지");
+  }
+  if (options.genome === "template") {
+    await resetGenomeToTemplate(paths, actions);
+  } else if (options.genome === "keep") {
+    actions.push("Genome/Environment: 기존 유지");
+  } else {
+    actions.push("Genome/Environment: 수동 편집 모드 (변경 없음)");
+  }
+  const backlogDir = paths.backlog;
+  if (options.backlog === "delete") {
+    if (await fileExists(backlogDir)) {
+      await rm4(backlogDir, { recursive: true, force: true });
+      await mkdir9(backlogDir, { recursive: true });
+      actions.push("Backlog: 삭제됨");
+    } else {
+      actions.push("Backlog: 디렉토리 없음 (skip)");
+    }
+  } else {
+    actions.push("Backlog: 보존됨");
+  }
+  return { actions, warnings };
+}
+async function compressLineage(paths, actions) {
+  const lineageDir = paths.lineage;
+  if (!await fileExists(lineageDir)) {
+    actions.push("Lineage: 디렉토리 없음 (skip)");
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdir13(lineageDir);
+  } catch {
+    actions.push("Lineage: 읽기 실패 (skip)");
+    return;
+  }
+  const genDirs = entries.filter((e) => e.startsWith("gen-"));
+  if (genDirs.length === 0) {
+    actions.push("Lineage: 세대 기록 없음 (skip)");
+    return;
+  }
+  const epochId = `epoch-${new Date().toISOString().slice(0, 10).replace(/-/g, "")}`;
+  const summary = [
+    `# Epoch: ${epochId}`,
+    `# Compressed ${genDirs.length} generations`,
+    `# Date: ${new Date().toISOString()}`,
+    "",
+    "## Generations",
+    ...genDirs.map((d) => `- ${d}`),
+    ""
+  ].join(`
+`);
+  for (const dir of genDirs) {
+    await rm4(join15(lineageDir, dir), { recursive: true, force: true });
+  }
+  await writeTextFile(join15(lineageDir, `${epochId}.md`), summary);
+  actions.push(`Lineage: ${genDirs.length}개 세대를 ${epochId}로 압축`);
+}
+async function cleanLife(paths, actions) {
+  const lifeDir = paths.life;
+  if (!await fileExists(lifeDir)) {
+    actions.push("Life: 디렉토리 없음 (skip)");
+    return;
+  }
+  let entries;
+  try {
+    entries = await readdir13(lifeDir);
+  } catch {
+    actions.push("Life: 읽기 실패 (skip)");
+    return;
+  }
+  let removedCount = 0;
+  for (const entry of entries) {
+    if (entry === "backlog")
+      continue;
+    const entryPath = join15(lifeDir, entry);
+    await rm4(entryPath, { recursive: true, force: true });
+    removedCount++;
+  }
+  actions.push(`Life: ${removedCount}개 파일/디렉토리 정리됨`);
+}
+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);
+    try {
+      const templateContent = await readTextFileOrThrow(templatePath);
+      await writeTextFile(destPath, templateContent);
+    } catch {}
+  }
+  const envSummaryTemplate = join15(ReapPaths.packageTemplatesDir, "environment", "summary.md");
+  if (await fileExists(envSummaryTemplate)) {
+    try {
+      const content = await readTextFileOrThrow(envSummaryTemplate);
+      await writeTextFile(paths.environmentSummary, content);
+    } catch {}
+  }
+  actions.push("Genome/Environment: 템플릿으로 초기화됨");
+}
+
 // src/cli/index.ts
 init_lifecycle();
 init_paths();
 init_fs();
 init_version();
 init_config();
-import { join as join27 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.14.0");
+import { join as join32 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.15.1");
 program.command("init").description("Initialize a new REAP project (Genesis)").argument("[project-name]", "Project name (defaults to current directory name)").option("-m, --mode <mode>", "Entry mode: greenfield, migration, adoption", "greenfield").option("-p, --preset <preset>", "Bootstrap with a genome preset (e.g., bun-hono-react)").action(async (projectName, options) => {
   try {
     const cwd = process.cwd();
@@ -15310,8 +16477,9 @@ Initializing REAP project "${name}" (${mode} mode)...
     console.log(`
   Getting started:`);
     console.log(`    1. Open your AI agent (${initResult.agents[0] || "Claude Code or OpenCode"})`);
-    console.log(`    2. Run /reap.start to begin your first Generation`);
-    console.log(`    3. Or run /reap.evolve for autonomous execution`);
+    console.log(`    2. Run /reap.sync to synchronize Genome with your project`);
+    console.log(`    3. Run /reap.start to begin your first Generation`);
+    console.log(`    4. Or run /reap.evolve for autonomous execution`);
     if (initResult.agents.length === 0) {
       console.log(`
   ⚠ No AI agents detected. Install Claude Code or OpenCode, then run 'reap update'.`);
@@ -15328,10 +16496,12 @@ 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.14.0";
+    const installedVersion = "0.15.1";
     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.generation) {
       console.log(`
 Active Generation: ${status.generation.id}`);
@@ -15347,19 +16517,38 @@ No active Generation. Run '/reap.start' to start one.`);
     process.exit(1);
   }
 });
-program.command("fix").description("Diagnose and repair .reap/ directory structure").action(async () => {
+program.command("fix").description("Diagnose and repair .reap/ directory structure").option("--check", "Check-only mode: report issues without fixing anything").action(async (options) => {
   try {
-    const result = await fixProject(process.cwd());
-    if (result.fixed.length === 0 && result.issues.length === 0) {
-      console.log("✓ Project is healthy. No issues found.");
-    } else {
-      if (result.fixed.length > 0) {
-        console.log("Fixed:");
-        result.fixed.forEach((f) => console.log(`  ✓ ${f}`));
+    if (options.check) {
+      const result = await checkProject(process.cwd());
+      if (result.errors.length === 0 && result.warnings.length === 0) {
+        console.log("✓ Integrity check passed. No issues found.");
+      } else {
+        if (result.errors.length > 0) {
+          console.log("Errors:");
+          result.errors.forEach((e) => console.log(`  ✗ ${e}`));
+        }
+        if (result.warnings.length > 0) {
+          console.log("Warnings:");
+          result.warnings.forEach((w) => console.log(`  ⚠ ${w}`));
+        }
       }
-      if (result.issues.length > 0) {
-        console.log("Issues (require manual intervention):");
-        result.issues.forEach((i) => console.log(`  ✗ ${i}`));
+      if (result.errors.length > 0) {
+        process.exit(1);
+      }
+    } else {
+      const result = await fixProject(process.cwd());
+      if (result.fixed.length === 0 && result.issues.length === 0) {
+        console.log("✓ Project is healthy. No issues found.");
+      } else {
+        if (result.fixed.length > 0) {
+          console.log("Fixed:");
+          result.fixed.forEach((f) => console.log(`  ✓ ${f}`));
+        }
+        if (result.issues.length > 0) {
+          console.log("Issues (require manual intervention):");
+          result.issues.forEach((i) => console.log(`  ✗ ${i}`));
+        }
       }
     }
   } catch (e) {
@@ -15407,16 +16596,113 @@ program.command("help").description("Show REAP commands, slash commands, and wor
     if (l === "korean" || l === "ko")
       lang = "ko";
   }
-  const helpDir = join27(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join27(helpDir, `${lang}.txt`));
+  const helpDir = join32(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join32(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join27(helpDir, "en.txt"));
+    helpText = await readTextFile(join32(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;
   }
   console.log(helpText);
 });
+program.command("destroy").description("Remove all REAP files from this project").action(async () => {
+  try {
+    const cwd = process.cwd();
+    const projectName = await getProjectName(cwd);
+    if (!projectName) {
+      console.error("Error: Not a REAP project (cannot read .reap/config.yml).");
+      process.exit(1);
+    }
+    const expectedInput = "yes destroy";
+    console.log(`
+This will permanently remove all REAP files from this project.`);
+    console.log(`To confirm, type '${expectedInput}':
+`);
+    const answer = await prompt("> ");
+    if (answer.trim() !== expectedInput) {
+      console.log(`
+Confirmation mismatch. Destroy cancelled.`);
+      process.exit(0);
+    }
+    console.log("");
+    const result = await destroyProject(cwd);
+    if (result.removed.length > 0) {
+      console.log("Removed:");
+      result.removed.forEach((f) => console.log(`  - ${f}`));
+    }
+    if (result.skipped.length > 0) {
+      console.log("Skipped:");
+      result.skipped.forEach((f) => console.log(`  - ${f}`));
+    }
+    console.log(`
+REAP has been removed from this project.`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+});
+program.command("clean").description("Reset REAP project with interactive options").action(async () => {
+  try {
+    const cwd = process.cwd();
+    const paths = new ReapPaths(cwd);
+    if (!await paths.isReapProject()) {
+      console.error("Error: Not a REAP project (.reap/ not found).");
+      process.exit(1);
+    }
+    if (await hasActiveGeneration(cwd)) {
+      console.log(`
+⚠ Warning: There is an active generation in progress.`);
+      const proceed = await prompt("Continue and discard it? (y/N): ");
+      if (proceed.trim().toLowerCase() !== "y") {
+        console.log("Clean cancelled.");
+        process.exit(0);
+      }
+    }
+    console.log(`
+--- REAP Clean ---
+`);
+    console.log("1. Lineage (generation history):");
+    console.log("   [1] Compress into epoch summary");
+    console.log("   [2] Delete entirely");
+    const lineageChoice = await prompt("   Choice (1/2): ");
+    const lineage = lineageChoice.trim() === "2" ? "delete" : "compress";
+    console.log(`
+2. Hooks:`);
+    console.log("   [1] Keep existing hooks");
+    console.log("   [2] Reset to defaults");
+    const hooksChoice = await prompt("   Choice (1/2): ");
+    const hooks = hooksChoice.trim() === "2" ? "reset" : "keep";
+    console.log(`
+3. Genome / Environment:`);
+    console.log("   [1] Override with templates (then run /reap.sync)");
+    console.log("   [2] Keep current files");
+    console.log("   [3] Manual editing (no changes)");
+    const genomeChoice = await prompt("   Choice (1/2/3): ");
+    const genome = genomeChoice.trim() === "1" ? "template" : genomeChoice.trim() === "3" ? "manual" : "keep";
+    console.log(`
+4. Backlog:`);
+    console.log("   [1] Keep existing backlog items");
+    console.log("   [2] Delete all");
+    const backlogChoice = await prompt("   Choice (1/2): ");
+    const backlog = backlogChoice.trim() === "2" ? "delete" : "keep";
+    console.log(`
+Applying...
+`);
+    const result = await cleanProject(cwd, { lineage, hooks, genome, backlog });
+    for (const action of result.actions) {
+      console.log(`  - ${action}`);
+    }
+    for (const warning of result.warnings) {
+      console.log(`  ⚠ ${warning}`);
+    }
+    console.log(`
+Clean complete. Run /reap.start to begin a new generation.`);
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(1);
+  }
+});
 program.command("run <command>").description("Run a REAP command script (internal, used by slash commands)").option("--phase <phase>", "Start from a specific phase").allowUnknownOption().action(async (command, options, cmd) => {
   const rawArgs = cmd.args.slice(1);
   const passArgs = [];
@@ -15430,4 +16716,13 @@ program.command("run <command>").description("Run a REAP command script (interna
   const { runCommand: runCommand2 } = await Promise.resolve().then(() => (init_run(), exports_run));
   await runCommand2(command, options.phase, passArgs);
 });
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer ?? "");
+    });
+  });
+}
 program.parse();