@c-d-cc/reap 0.13.4 → 0.15.0

package/dist/cli.js

@@ -9951,14 +9951,15 @@ 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) {
+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 });
@@ -10197,6 +10198,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 +10279,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 readdir12 } from "fs/promises";
+import { join as join14 } 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 = join14(hooksDir, "conditions");
   const results = [];
   for (const hook of hooks) {
     const conditionMet = await evaluateCondition(conditionsDir, hook.condition, projectRoot);
@@ -10276,7 +10311,7 @@ async function executeHooks(hooksDir, event, projectRoot) {
 async function scanHooks(hooksDir, event) {
   let entries;
   try {
-    entries = await readdir10(hooksDir);
+    entries = await readdir12(hooksDir);
   } catch {
     return [];
   }
@@ -10286,7 +10321,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(join14(hooksDir, filename), match[2]);
     hooks.push({
       filename,
       name: match[1],
@@ -10333,7 +10368,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 = join14(conditionsDir, `${conditionName}.sh`);
   if (!await fileExists(scriptPath)) {
     return { met: false, reason: `condition script not found: ${conditionName}.sh` };
   }
@@ -10346,7 +10381,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 "${join14(hooksDir, hook.filename)}"`, {
       cwd: projectRoot,
       timeout: 60000,
       stdio: "pipe"
@@ -10372,7 +10407,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(join14(hooksDir, hook.filename));
   const body = content?.replace(/^---\n[\s\S]*?\n---\n?/, "").trim() ?? "";
   return {
     name: hook.name,
@@ -10388,111 +10423,6 @@ var init_hook_engine = __esm(() => {
   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"
-  };
-});
-
 // src/cli/commands/run/back.ts
 var exports_back = {};
 __export(exports_back, {
@@ -10596,12 +10526,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 readdir13 } from "fs/promises";
+import { join as join15 } from "path";
 async function scanBacklog(backlogDir) {
   let entries;
   try {
-    entries = await readdir11(backlogDir);
+    entries = await readdir13(backlogDir);
   } catch {
     return [];
   }
@@ -10609,7 +10539,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(join15(backlogDir, filename));
     if (!content)
       continue;
     const { frontmatter, body } = parseFrontmatter2(content);
@@ -10627,7 +10557,7 @@ async function scanBacklog(backlogDir) {
   return items;
 }
 async function markBacklogConsumed(backlogDir, filename, genId) {
-  const filePath = join14(backlogDir, filename);
+  const filePath = join15(backlogDir, filename);
   const content = await readTextFile(filePath);
   if (!content)
     return;
@@ -10644,14 +10574,14 @@ ${body}`;
 async function revertBacklogConsumed(backlogDir, genId) {
   let entries;
   try {
-    entries = await readdir11(backlogDir);
+    entries = await readdir13(backlogDir);
   } catch {
     return;
   }
   for (const filename of entries) {
     if (!filename.endsWith(".md"))
       continue;
-    const filePath = join14(backlogDir, filename);
+    const filePath = join15(backlogDir, filename);
     const content = await readTextFile(filePath);
     if (!content)
       continue;
@@ -10688,8 +10618,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 join16 } from "path";
+import { readdir as readdir14 } from "fs/promises";
 function getFlag2(args, name) {
   const idx = args.indexOf(`--${name}`);
   return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
@@ -10738,18 +10668,18 @@ async function execute3(paths, phase, argv = []) {
     }
     let genomeVersion = 1;
     try {
-      const lineageEntries = await readdir12(paths.lineage);
+      const lineageEntries = await readdir14(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 = join16(__require("os").homedir(), ".reap", "templates");
+    const templatePath = join16(templateDir, "01-objective.md");
     const destPath = paths.artifact("01-objective.md");
     if (await fileExists(templatePath)) {
       let template = await readTextFile(templatePath);
@@ -10808,12 +10738,204 @@ function checkSubmodules(projectRoot) {
 }
 var init_commit = () => {};
 
+// src/core/stage-transition.ts
+import { join as join17 } 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 = join17(__require("os").homedir(), ".reap", "templates");
+    const templatePath = join17(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 join18 } from "path";
+import { execSync as execSync6 } from "child_process";
+function detectGenomeImpact(projectRoot) {
+  const impact = {
+    newCommands: [],
+    packageJsonChanged: false,
+    coreChanges: []
+  };
+  let changedFiles;
+  try {
+    const output = execSync6("git diff --name-only HEAD~1", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 5000
+    });
+    changedFiles = output.trim().split(`
+`).filter(Boolean);
+  } catch {
+    return impact;
+  }
+  for (const file of changedFiles) {
+    if (file.startsWith("src/cli/commands/") && file.endsWith(".ts")) {
+      impact.newCommands.push(file);
+    }
+    if (file === "package.json") {
+      impact.packageJsonChanged = true;
+    }
+    if (file.startsWith("src/core/") && file.endsWith(".ts")) {
+      impact.coreChanges.push(file);
+    }
+  }
+  return impact;
+}
+function buildGenomeImpactPrompt(impact) {
+  const lines = [];
+  if (impact.newCommands.length > 0) {
+    lines.push(`- **Commands changed/added** (${impact.newCommands.length}): constraints.md의 Slash Commands 목록 업데이트 필요 여부 확인`);
+  }
+  if (impact.packageJsonChanged) {
+    lines.push("- **package.json changed**: constraints.md의 Tech Stack 및 environment.md 업데이트 필요 여부 확인");
+  }
+  if (impact.coreChanges.length > 0) {
+    lines.push(`- **Core modules changed** (${impact.coreChanges.length}): principles.md 및 source-map.md 업데이트 필요 여부 확인`);
+  }
+  if (lines.length === 0)
+    return "";
+  return [
+    "",
+    "",
+    "## Genome/Environment Impact Detection",
+    "다음 변경이 감지되었습니다. genome-change 또는 environment-change backlog 작성이 필요한지 검토하라:",
+    "",
+    ...lines
+  ].join(`
+`);
+}
+function buildMdHookPrompt(hookResults) {
+  const mdHooks = hookResults.filter((h) => h.type === "md" && h.status === "executed" && h.content);
+  if (mdHooks.length === 0)
+    return "";
+  const sections = mdHooks.map((h) => `### ${h.name}
+${h.content}`);
+  return [
+    "",
+    "",
+    "## Hook Prompts",
+    "다음 hook prompt를 순서대로 실행하라:",
+    "",
+    ...sections
+  ].join(`
+`);
+}
 async function execute4(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -10823,6 +10945,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.");
@@ -10833,8 +10957,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 = join18(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join18(templateDir, "05-completion.md");
       if (await fileExists(templatePath)) {
         const { writeTextFile: writeTextFile2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
         const template = await readTextFile(templatePath);
@@ -10842,6 +10966,8 @@ async function execute4(paths, phase) {
           await writeTextFile2(destPath, template);
       }
     }
+    setPhaseNonce(state, "completion", "retrospective");
+    await gm.save(state);
     emitOutput({
       status: "prompt",
       command: "completion",
@@ -10856,11 +10982,13 @@ async function execute4(paths, phase) {
         validationSummary: validationContent?.slice(0, 2000),
         implSummary: implContent?.slice(0, 2000)
       },
-      prompt: "Fill 05-completion.md: Summary (goal, period, result, key changes), Lessons Learned (max 5), Genome Change Proposals, Garbage Collection (check conventions violations), Backlog Cleanup (add deferred tasks). Then run: reap run completion --phase genome",
-      nextCommand: "reap run completion --phase genome"
+      prompt: "Fill 05-completion.md: Summary (goal, period, result, key changes), Lessons Learned (max 5), Genome Change Proposals, Garbage Collection (check conventions violations), Backlog Cleanup (add deferred tasks). Then run: reap run completion --phase feedKnowledge",
+      nextCommand: "reap run completion --phase feedKnowledge"
     });
   }
-  if (phase === "genome") {
+  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");
@@ -10868,6 +10996,8 @@ async function execute4(paths, phase) {
     for (const item of toConsume) {
       await markBacklogConsumed(paths.backlog, item.filename, state.id);
     }
+    const genomeImpact = detectGenomeImpact(paths.projectRoot);
+    const impactPrompt = buildGenomeImpactPrompt(genomeImpact);
     const hookResults = await executeHooks(paths.hooks, "onLifeCompleted", paths.projectRoot);
     const submodules = checkSubmodules(paths.projectRoot);
     const dirtySubmodules = submodules.filter((s) => s.dirty);
@@ -10897,9 +11027,10 @@ async function execute4(paths, phase) {
         consumedCount: toConsume.length,
         compression: { level1: compression.level1.length, level2: compression.level2.length },
         hookResults,
-        dirtySubmodules
+        dirtySubmodules,
+        genomeImpact
       },
-      prompt: dirtySubmodules.length > 0 ? `Dirty submodules detected: ${dirtySubmodules.map((s) => s.path).join(", ")}. Commit and push inside each submodule first, then commit the parent repo. Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.` : `Commit all changes (code + .reap/ artifacts). Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.`,
+      prompt: (dirtySubmodules.length > 0 ? `Dirty submodules detected: ${dirtySubmodules.map((s) => s.path).join(", ")}. Commit and push inside each submodule first, then commit the parent repo. Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.` : `Commit all changes (code + .reap/ artifacts). Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.`) + impactPrompt + buildMdHookPrompt(hookResults),
       message: `Generation ${state.id} archived. ${hasChanges ? "Genome/env changes applied." : "No genome/environment changes."} ${toConsume.length} backlog item(s) consumed.`
     });
   }
@@ -10936,7 +11067,7 @@ async function execute4(paths, phase) {
         hookResults,
         dirtySubmodules
       },
-      prompt: dirtySubmodules.length > 0 ? `Dirty submodules detected: ${dirtySubmodules.map((s) => s.path).join(", ")}. Commit and push inside each submodule first, then commit the parent repo. Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.` : `Commit all changes (code + .reap/ artifacts). Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.`,
+      prompt: (dirtySubmodules.length > 0 ? `Dirty submodules detected: ${dirtySubmodules.map((s) => s.path).join(", ")}. Commit and push inside each submodule first, then commit the parent repo. Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.` : `Commit all changes (code + .reap/ artifacts). Commit message: feat/fix/chore(${state.id}): [goal summary]. Generation complete.`) + buildMdHookPrompt(hookResults),
       message: `Generation ${state.id} archived.`
     });
   }
@@ -10947,6 +11078,7 @@ var init_completion = __esm(() => {
   init_backlog();
   init_hook_engine();
   init_commit();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/abort.ts
@@ -10954,8 +11086,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 join19 } from "path";
+import { readdir as readdir15, 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;
@@ -11030,15 +11162,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(join19(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 readdir15(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(join19(paths.life, entry));
         }
       }
     } catch {}
@@ -11097,8 +11229,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 join20 } from "path";
+import { readdir as readdir16 } from "fs/promises";
 async function execute7(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11115,13 +11247,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 readdir16(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(join20(paths.lineage, lastGen, "05-completion.md"));
         if (!prevCompletion) {
-          const compressed = await readTextFile(join18(paths.lineage, `${lastGen}.md`));
+          const compressed = await readTextFile(join20(paths.lineage, `${lastGen}.md`));
           if (compressed)
             prevCompletion = compressed.slice(0, 2000);
         }
@@ -11134,12 +11266,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 readdir16(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 = join20(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join20(templateDir, "01-objective.md");
       if (await fileExists(templatePath)) {
         let template = await readTextFile(templatePath);
         if (template) {
@@ -11148,6 +11280,8 @@ async function execute7(paths, phase) {
         }
       }
     }
+    setPhaseNonce(state, "objective", "work");
+    await gm.save(state);
     emitOutput({
       status: "prompt",
       command: "objective",
@@ -11209,6 +11343,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.");
@@ -11217,20 +11353,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
     });
   }
 }
@@ -11239,6 +11381,7 @@ var init_objective = __esm(() => {
   init_fs();
   init_backlog();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/planning.ts
@@ -11246,7 +11389,7 @@ var exports_planning = {};
 __export(exports_planning, {
   execute: () => execute8
 });
-import { join as join19 } from "path";
+import { join as join21 } from "path";
 async function execute8(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11256,6 +11399,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.");
@@ -11270,14 +11415,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 = join21(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join21(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",
@@ -11334,6 +11481,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.");
@@ -11342,20 +11491,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
     });
   }
 }
@@ -11363,6 +11518,7 @@ var init_planning = __esm(() => {
   init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/implementation.ts
@@ -11370,7 +11526,7 @@ var exports_implementation = {};
 __export(exports_implementation, {
   execute: () => execute9
 });
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 async function execute9(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11380,6 +11536,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.");
@@ -11392,14 +11550,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 = join22(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join22(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",
@@ -11459,24 +11619,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
     });
   }
 }
@@ -11484,6 +11652,7 @@ var init_implementation = __esm(() => {
   init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/validation.ts
@@ -11491,7 +11660,7 @@ var exports_validation = {};
 __export(exports_validation, {
   execute: () => execute10
 });
-import { join as join21 } from "path";
+import { join as join23 } from "path";
 async function execute10(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11501,6 +11670,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.");
@@ -11514,14 +11685,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 = join23(__require("os").homedir(), ".reap", "templates");
+      const templatePath = join23(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",
@@ -11591,24 +11764,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
     });
   }
 }
@@ -11616,6 +11797,7 @@ var init_validation = __esm(() => {
   init_generation();
   init_fs();
   init_hook_engine();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/evolve.ts
@@ -11627,10 +11809,15 @@ function buildSubagentPrompt(paths, state, genomeSummaries, backlogSummary) {
   const lines = [];
   lines.push("# REAP Subagent Instructions");
   lines.push("");
+  lines.push("## FIRST: Load REAP Context");
+  lines.push("Before doing anything else, run `reap run refreshKnowledge` to load full REAP context (Genome, Environment, Generation state, Workflow Guide).");
+  lines.push("Incorporate the returned context into your working knowledge before proceeding.");
+  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");
@@ -11665,7 +11852,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`");
@@ -11674,25 +11861,42 @@ 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 genome 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("## Interrupt Protection");
+  lines.push('- 사용자의 새 메시지가 중간에 들어와도, 명시적 kill/중단 요청("중단", "stop", "abort")이 아닌 한 현재 작업을 끝까지 완료하라.');
+  lines.push("- 작업을 shortcut으로 건너뛰거나 결과를 추정하지 마라. 모든 validation은 실제 실행 결과를 확인하라.");
+  lines.push("- E2E 테스트 등 외부 실행이 포함된 작업은 반드시 실제 실행하고 결과를 확인하라.");
   return lines.join(`
 `);
 }
@@ -11788,7 +11992,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.",
@@ -11804,10 +12008,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:",
@@ -11816,14 +12020,13 @@ 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 the human wants to pause: stop the loop"
         ].join(`
 `)
       });
@@ -11869,8 +12072,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 readdir17 } from "fs/promises";
+import { join as join24 } from "path";
 async function execute13(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11882,10 +12085,10 @@ async function execute13(paths, phase) {
     const sourceMapContent = await readTextFile(paths.sourceMap);
     const domainFiles = {};
     try {
-      const entries = await readdir15(paths.domain);
+      const entries = await readdir17(paths.domain);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
-          const content = await readTextFile(join22(paths.domain, entry));
+          const content = await readTextFile(join24(paths.domain, entry));
           if (content)
             domainFiles[entry] = content.slice(0, 1000);
         }
@@ -11893,7 +12096,7 @@ async function execute13(paths, phase) {
     } catch {}
     let genomeVersion = 0;
     try {
-      const lineageEntries = await readdir15(paths.lineage);
+      const lineageEntries = await readdir17(paths.lineage);
       genomeVersion = lineageEntries.filter((e) => e.startsWith("gen-")).length;
     } catch {}
     emitOutput({
@@ -11966,8 +12169,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 readdir18 } from "fs/promises";
+import { join as join25 } from "path";
 async function execute14(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
@@ -11976,10 +12179,10 @@ async function execute14(paths, phase) {
     const envSummary = await readTextFile(paths.environmentSummary);
     const envDocs = {};
     try {
-      const docsEntries = await readdir16(paths.environmentDocs);
+      const docsEntries = await readdir18(paths.environmentDocs);
       for (const entry of docsEntries) {
         if (entry.endsWith(".md")) {
-          const content = await readTextFile(join23(paths.environmentDocs, entry));
+          const content = await readTextFile(join25(paths.environmentDocs, entry));
           if (content)
             envDocs[entry] = content.slice(0, 1000);
         }
@@ -11987,7 +12190,7 @@ async function execute14(paths, phase) {
     } catch {}
     let linksContent = null;
     try {
-      linksContent = await readTextFile(join23(paths.environmentResources, "links.md"));
+      linksContent = await readTextFile(join25(paths.environmentResources, "links.md"));
     } catch {}
     emitOutput({
       status: "prompt",
@@ -12059,7 +12262,7 @@ var exports_help = {};
 __export(exports_help, {
   execute: () => execute15
 });
-import { join as join24 } from "path";
+import { join as join26 } from "path";
 function detectLanguage(configContent) {
   const raw = configContent?.match(/language:\s*(\S+)/)?.[1] ?? null;
   if (raw && raw in LANGUAGE_ALIASES)
@@ -12094,7 +12297,7 @@ async function execute15(paths) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
   const configContent = await readTextFile(paths.config);
-  const installedVersion = "0.13.4";
+  const installedVersion = "0.15.0";
   const autoUpdate = configContent?.match(/autoUpdate:\s*(true|false)/)?.[1] === "true";
   const versionDisplay = formatVersionLine(installedVersion, !autoUpdate);
   const rawLang = detectLanguage(configContent);
@@ -12105,7 +12308,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 = join26(ReapPaths.packageHooksDir, "reap-guide.md");
     const reapGuide = await readTextFile(guidePath) ?? "";
     emitOutput({
       status: "prompt",
@@ -12410,8 +12613,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 readdir19, mkdir as mkdir9, rename as rename3 } from "fs/promises";
+import { join as join27 } from "path";
 
 class MergeGenerationManager {
   paths;
@@ -12587,7 +12790,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 mkdir9(genDir, { recursive: true });
     const meta = {
       id: state.id,
       type: "merge",
@@ -12597,19 +12800,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(join27(genDir, "meta.yml"), import_yaml10.default.stringify(meta));
+    const lifeEntries = await readdir19(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(join27(this.paths.life, entry), join27(genDir, entry));
       }
     }
-    const backlogDir = join25(genDir, "backlog");
-    await mkdir8(backlogDir, { recursive: true });
+    const backlogDir = join27(genDir, "backlog");
+    await mkdir9(backlogDir, { recursive: true });
     try {
-      const backlogEntries = await readdir17(this.paths.backlog);
+      const backlogEntries = await readdir19(this.paths.backlog);
       for (const entry of backlogEntries) {
-        await rename3(join25(this.paths.backlog, entry), join25(backlogDir, entry));
+        await rename3(join27(this.paths.backlog, entry), join27(backlogDir, entry));
       }
     } catch {}
     await writeTextFile(this.paths.currentYml, "");
@@ -12806,6 +13009,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",
@@ -12834,24 +13039,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
@@ -12871,12 +13089,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",
@@ -12916,24 +13138,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
@@ -12953,6 +13188,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.");
@@ -12961,6 +13198,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",
@@ -12995,24 +13234,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
@@ -13032,6 +13284,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.");
@@ -13041,6 +13295,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",
@@ -13085,24 +13341,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
@@ -13122,12 +13391,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",
@@ -13164,28 +13437,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
@@ -13205,6 +13491,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.");
@@ -13214,6 +13502,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",
@@ -13244,6 +13534,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);
@@ -13270,6 +13562,7 @@ var init_merge_completion = __esm(() => {
   init_fs();
   init_hook_engine();
   init_commit();
+  init_stage_transition();
 });
 
 // src/cli/commands/run/merge-evolve.ts
@@ -13322,10 +13615,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:",
@@ -13335,9 +13628,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",
@@ -13503,9 +13804,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) {
@@ -13596,12 +13897,177 @@ var init_config2 = __esm(() => {
   init_config();
 });
 
+// src/cli/commands/run/refresh-knowledge.ts
+var exports_refresh_knowledge = {};
+__export(exports_refresh_knowledge, {
+  execute: () => execute28
+});
+import { join as join28 } from "path";
+import { readdir as readdir20 } from "fs/promises";
+async function loadGenome(genomeDir) {
+  let content = "";
+  let l1Lines = 0;
+  let smLimit = null;
+  const smContent = await readTextFile(join28(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(join28(genomeDir, file));
+    if (!fileContent)
+      continue;
+    const lines = fileContent.split(`
+`).length;
+    const limit = file === "source-map.md" && smLimit ? smLimit : L1_LIMIT;
+    l1Lines += lines;
+    if (l1Lines <= limit) {
+      content += `
+### ${file}
+${fileContent}
+`;
+    } else {
+      content += `
+### ${file} [TRUNCATED — L1 budget exceeded]
+${fileContent.split(`
+`).slice(0, 20).join(`
+`)}
+...
+`;
+    }
+  }
+  const domainDir = join28(genomeDir, "domain");
+  if (await fileExists(domainDir)) {
+    let l2Lines = 0;
+    let l2Overflow = false;
+    try {
+      const domainFiles = (await readdir20(domainDir)).filter((f) => f.endsWith(".md")).sort();
+      for (const file of domainFiles) {
+        const fileContent = await readTextFile(join28(domainDir, file));
+        if (!fileContent)
+          continue;
+        const lines = fileContent.split(`
+`).length;
+        l2Lines += lines;
+        if (!l2Overflow && l2Lines <= L2_LIMIT) {
+          content += `
+### domain/${file}
+${fileContent}
+`;
+        } else {
+          l2Overflow = true;
+          const firstLine = fileContent.split(`
+`).find((l) => l.startsWith(">")) || fileContent.split(`
+`)[0];
+          content += `
+### domain/${file} [summary]
+${firstLine}
+`;
+        }
+      }
+    } catch {}
+  }
+  return { content, l1Lines };
+}
+function buildStrictSection(strict, genStage) {
+  let sections = "";
+  if (strict.edit) {
+    if (genStage === "implementation") {
+      sections += `
+
+## Strict Mode — Edit (ACTIVE — SCOPED MODIFICATION ALLOWED)`;
+    } else if (genStage === "none") {
+      sections += `
+
+## Strict Mode — Edit (ACTIVE — CODE MODIFICATION BLOCKED)`;
+    } else {
+      sections += `
+
+## Strict Mode — Edit (ACTIVE — stage '${genStage}', CODE MODIFICATION BLOCKED)`;
+    }
+  }
+  if (strict.merge) {
+    sections += `
+
+## Strict Mode — Merge (ACTIVE)`;
+  }
+  return sections;
+}
+async function execute28(paths) {
+  const guidePath = join28(ReapPaths.packageHooksDir, "reap-guide.md");
+  const reapGuide = await readTextFile(guidePath) || "";
+  const { content: genomeContent } = await loadGenome(paths.genome);
+  const envSummary = await readTextFile(paths.environmentSummary) || "";
+  const gm = new GenerationManager(paths);
+  const state = await gm.current();
+  let generationContext;
+  let genStage;
+  if (state && state.id) {
+    genStage = state.stage;
+    generationContext = `Active Generation: ${state.id} | Goal: ${state.goal} | Stage: ${state.stage}`;
+  } else {
+    genStage = "none";
+    generationContext = "No active Generation.";
+  }
+  let strict = { edit: false, merge: false };
+  try {
+    const config = await ConfigManager.read(paths);
+    strict = ConfigManager.resolveStrict(config.strict);
+  } catch {}
+  const strictSection = buildStrictSection(strict, genStage);
+  const envSection = envSummary ? `
+
+---
+
+## Environment (External Context)
+${envSummary}` : "";
+  const reapContext = [
+    "<REAP_CONTEXT>",
+    reapGuide,
+    "",
+    "---",
+    "",
+    "## Genome (Project Knowledge)",
+    genomeContent,
+    envSection,
+    "",
+    "---",
+    "",
+    "## Current State",
+    generationContext,
+    strictSection,
+    "</REAP_CONTEXT>"
+  ].join(`
+`);
+  emitOutput({
+    status: "ok",
+    command: "refreshKnowledge",
+    phase: "done",
+    completed: ["load-guide", "load-genome", "load-environment", "load-state"],
+    context: {
+      hasGeneration: !!state?.id,
+      generationId: state?.id || null,
+      stage: genStage
+    },
+    prompt: reapContext
+  });
+}
+var L1_LIMIT = 500, L2_LIMIT = 200, L1_FILES;
+var init_refresh_knowledge = __esm(() => {
+  init_paths();
+  init_fs();
+  init_config();
+  init_generation();
+  L1_FILES = ["principles.md", "conventions.md", "constraints.md", "source-map.md"];
+});
+
 // src/cli/commands/run/index.ts
 var exports_run = {};
 __export(exports_run, {
   runCommand: () => runCommand
 });
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 async function runCommand(command, phase, argv = []) {
   const cwd = process.cwd();
   const paths = new ReapPaths(cwd);
@@ -13619,7 +14085,7 @@ async function runCommand(command, phase, argv = []) {
     try {
       const config = await ConfigManager.read(paths);
       if (config.autoIssueReport) {
-        const version = "0.13.4";
+        const version = "0.15.0";
         const errMsg = err instanceof Error ? err.message : String(err);
         const title = `[auto] reap run ${command}: ${errMsg.slice(0, 80)}`;
         const body = [
@@ -13629,7 +14095,7 @@ async function runCommand(command, phase, argv = []) {
           `**OS**: ${process.platform} ${process.arch}`,
           `**Node**: ${process.version}`
         ].join("\\n");
-        execSync6(`gh issue create --repo c-d-cc/reap --title "${title}" --label "auto-reported,bug" --body "${body}"`, { stdio: "ignore", timeout: 1e4 });
+        execSync7(`gh issue create --repo c-d-cc/reap --title "${title}" --label "auto-reported,bug" --body "${body}"`, { stdio: "ignore", timeout: 1e4 });
       }
     } catch {}
     emitError(command, err instanceof Error ? err.message : String(err));
@@ -13666,7 +14132,8 @@ var init_run = __esm(() => {
     "merge-evolve": () => Promise.resolve().then(() => (init_merge_evolve(), exports_merge_evolve)),
     merge: () => Promise.resolve().then(() => (init_merge2(), exports_merge)),
     pull: () => Promise.resolve().then(() => (init_pull(), exports_pull)),
-    config: () => Promise.resolve().then(() => (init_config2(), exports_config))
+    config: () => Promise.resolve().then(() => (init_config2(), exports_config)),
+    refreshKnowledge: () => Promise.resolve().then(() => (init_refresh_knowledge(), exports_refresh_knowledge))
   };
 });
 
@@ -13686,6 +14153,9 @@ var {
   Help
 } = import__.default;
 
+// src/cli/index.ts
+import { createInterface } from "readline";
+
 // src/cli/commands/init.ts
 init_paths();
 init_config();
@@ -14169,7 +14639,8 @@ var COMMAND_NAMES = [
   "reap.merge",
   "reap.pull",
   "reap.push",
-  "reap.config"
+  "reap.config",
+  "reap.refreshKnowledge"
 ];
 async function initProject(projectRoot, projectName, entryMode, preset, onProgress) {
   const log = onProgress ?? (() => {});
@@ -14205,7 +14676,7 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   }
   const detectedLanguage = await AgentRegistry.readLanguage();
   const config = {
-    version: "0.13.4",
+    version: "0.15.0",
     project: projectName,
     entryMode,
     strict: false,
@@ -14278,6 +14749,11 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   if (detectedAgents.length === 0) {
     log("  No AI agents detected.");
   }
+  const autoSynced = (entryMode === "adoption" || entryMode === "migration") && !preset;
+  if (!autoSynced) {
+    log(`
+\uD83D\uDCA1 Run /reap.sync to synchronize Genome with your project's actual state.`);
+  }
   return { agents: detectedAgents.map((a) => a.displayName) };
 }
 
@@ -14774,37 +15250,47 @@ async function updateProject(projectRoot, dryRun = false) {
         result.updated.push(`Config: added ${backfillResult.added.join(", ")}`);
       }
     }
-    const projectClaudeCommands = join10(paths.projectRoot, ".claude", "commands");
-    await mkdir6(projectClaudeCommands, { recursive: true });
+    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 destPath = join10(projectClaudeCommands, file);
-      try {
-        const s = await import("fs/promises").then((m) => m.lstat(destPath));
-        if (s.isSymbolicLink()) {
-          if (!dryRun)
-            await unlink4(destPath);
-        } else {
-          const existing = await readTextFile(destPath);
-          if (existing !== null && existing === src)
-            continue;
-          if (!dryRun)
-            await unlink4(destPath);
-        }
-      } catch {}
-      if (!dryRun)
-        await writeTextFile(destPath, src);
+      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/commands/ (${cmdInstalled} synced)`);
+      result.updated.push(`.claude/skills/ (${cmdInstalled} synced)`);
     } else {
-      result.skipped.push(`.claude/commands/ (${reapCmdFiles.length} unchanged)`);
+      result.skipped.push(`.claude/skills/ (${reapCmdFiles.length} unchanged)`);
     }
+    const projectClaudeCommands = join10(paths.projectRoot, ".claude", "commands");
+    try {
+      const legacyFiles = (await readdir9(projectClaudeCommands)).filter((f) => f.startsWith("reap.") && f.endsWith(".md"));
+      for (const file of legacyFiles) {
+        if (!dryRun)
+          await unlink4(join10(projectClaudeCommands, file));
+        result.removed.push(`.claude/commands/${file} (legacy)`);
+      }
+    } catch {}
     await migrateLegacyFiles(paths, dryRun, result);
-    const currentVersion = "0.13.4";
+    const currentVersion = "0.15.0";
     const migrationResult = await MigrationRunner.run(paths, currentVersion, dryRun);
     for (const m of migrationResult.migrated) {
       result.updated.push(`[migration] ${m}`);
@@ -14995,14 +15481,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 readdir10, unlink as unlink5 } from "fs/promises";
+import { join as join12 } 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 = join12(projectRoot, ".reap");
+  if (await fileExists(reapDir)) {
+    await rm3(reapDir, { recursive: true, force: true });
+    removed.push(".reap/");
+  } else {
+    skipped.push(".reap/ (not found)");
+  }
+  const claudeCommandsDir = join12(projectRoot, ".claude", "commands");
+  await removeGlobFiles(claudeCommandsDir, "reap.", removed, skipped, ".claude/commands/");
+  const claudeSkillsDir = join12(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 readdir10(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(join12(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 readdir10(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(join12(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 = join12(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 = join12(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 readdir11, mkdir as mkdir8 } from "fs/promises";
+import { join as join13 } 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 mkdir8(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 mkdir8(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 mkdir8(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 readdir11(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(join13(lineageDir, dir), { recursive: true, force: true });
+  }
+  await writeTextFile(join13(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 readdir11(lifeDir);
+  } catch {
+    actions.push("Life: 읽기 실패 (skip)");
+    return;
+  }
+  let removedCount = 0;
+  for (const entry of entries) {
+    if (entry === "backlog")
+      continue;
+    const entryPath = join13(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 = join13(ReapPaths.packageGenomeDir, file);
+    const destPath = join13(paths.genome, file);
+    try {
+      const templateContent = await readTextFileOrThrow(templatePath);
+      await writeTextFile(destPath, templateContent);
+    } catch {}
+  }
+  const envSummaryTemplate = join13(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 join26 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.13.4");
+import { join as join29 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.15.0");
 program.command("init").description("Initialize a new REAP project (Genesis)").argument("[project-name]", "Project name (defaults to current directory name)").option("-m, --mode <mode>", "Entry mode: greenfield, migration, adoption", "greenfield").option("-p, --preset <preset>", "Bootstrap with a genome preset (e.g., bun-hono-react)").action(async (projectName, options) => {
   try {
     const cwd = process.cwd();
@@ -15058,7 +15803,7 @@ 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.13.4";
+    const installedVersion = "0.15.0";
     const versionLine = formatVersionLine(installedVersion, skipCheck);
     console.log(`${versionLine} | Project: ${status.project} (${status.entryMode})`);
     console.log(`Completed Generations: ${status.totalGenerations}`);
@@ -15137,16 +15882,113 @@ program.command("help").description("Show REAP commands, slash commands, and wor
     if (l === "korean" || l === "ko")
       lang = "ko";
   }
-  const helpDir = join26(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join26(helpDir, `${lang}.txt`));
+  const helpDir = join29(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join29(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join26(helpDir, "en.txt"));
+    helpText = await readTextFile(join29(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 = `destroy ${projectName}`;
+    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 = [];
@@ -15160,4 +16002,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();