@c-d-cc/reap 0.7.9 → 0.9.0

package/dist/cli.js

@@ -9218,9 +9218,21 @@ class ReapPaths {
   get constraints() {
     return join(this.genome, "constraints.md");
   }
+  get sourceMap() {
+    return join(this.genome, "source-map.md");
+  }
   get environment() {
     return join(this.root, "environment");
   }
+  get environmentSummary() {
+    return join(this.environment, "summary.md");
+  }
+  get environmentDocs() {
+    return join(this.environment, "docs");
+  }
+  get environmentResources() {
+    return join(this.environment, "resources");
+  }
   get life() {
     return join(this.root, "life");
   }
@@ -9752,8 +9764,11 @@ var COMMAND_NAMES = [
   "reap.start",
   "reap.next",
   "reap.back",
+  "reap.abort",
   "reap.status",
   "reap.sync",
+  "reap.sync.genome",
+  "reap.sync.environment",
   "reap.help",
   "reap.update",
   "reap.merge.start",
@@ -9785,6 +9800,8 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   await mkdir3(paths.genome, { recursive: true });
   await mkdir3(paths.domain, { recursive: true });
   await mkdir3(paths.environment, { recursive: true });
+  await mkdir3(join5(paths.environment, "docs"), { recursive: true });
+  await mkdir3(join5(paths.environment, "resources"), { recursive: true });
   await mkdir3(paths.life, { recursive: true });
   await mkdir3(paths.backlog, { recursive: true });
   await mkdir3(paths.lineage, { recursive: true });
@@ -9861,7 +9878,7 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
 // src/cli/commands/update.ts
 import { readdir as readdir9, unlink as unlink3, rm as rm2, mkdir as mkdir6 } from "fs/promises";
 import { join as join10 } from "path";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 
 // src/core/hooks.ts
 async function migrateHooks(dryRun = false) {
@@ -9948,12 +9965,57 @@ init_fs();
 var import_yaml2 = __toESM(require_dist(), 1);
 import { readdir as readdir5, rm } from "fs/promises";
 import { join as join6 } from "path";
+
+// src/core/git.ts
+import { execSync } from "child_process";
+function gitShow(ref, path, cwd) {
+  try {
+    return execSync(`git show ${ref}:${path}`, { cwd, encoding: "utf-8", timeout: 1e4 });
+  } catch {
+    return null;
+  }
+}
+function gitLsTree(ref, path, cwd) {
+  try {
+    const output = execSync(`git ls-tree -r --name-only ${ref} -- ${path}`, {
+      cwd,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    return output.trim().split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function gitAllBranches(cwd) {
+  try {
+    const output = execSync("git branch -a --format='%(refname:short)'", {
+      cwd,
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    return output.trim().split(`
+`).filter(Boolean).map((b) => b.replace(/^origin\//, ""));
+  } catch {
+    return [];
+  }
+}
+function gitCurrentBranch(cwd) {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf-8", timeout: 5000 }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/core/compression.ts
 var LINEAGE_MAX_LINES = 5000;
 var MIN_GENERATIONS_FOR_COMPRESSION = 5;
 var LEVEL1_MAX_LINES = 40;
-var LEVEL2_MAX_LINES = 60;
-var LEVEL2_BATCH_SIZE = 5;
-var RECENT_PROTECTED_COUNT = 3;
+var LEVEL1_PROTECTED_COUNT = 3;
+var LEVEL2_MIN_LEVEL1_COUNT = 100;
+var LEVEL2_PROTECTED_COUNT = 9;
 function extractGenNum(name) {
   const match = name.match(/^gen-(\d{3})/);
   return match ? parseInt(match[1], 10) : 0;
@@ -10059,7 +10121,9 @@ async function scanLineage(paths) {
   } catch {}
   return entries.sort((a, b) => {
     if (a.completedAt && b.completedAt) {
-      return a.completedAt.localeCompare(b.completedAt);
+      const cmp = a.completedAt.localeCompare(b.completedAt);
+      if (cmp !== 0)
+        return cmp;
     }
     return a.genNum - b.genNum;
   });
@@ -10209,50 +10273,84 @@ async function compressLevel1(genDir, genName) {
   }
   return result;
 }
-async function compressLevel2(level1Files, epochNum) {
-  const lines = [];
-  const genIds = level1Files.map((f) => f.name.replace(".md", "").match(/^gen-\d{3}(?:-[a-f0-9]{6})?/)?.[0] ?? f.name);
-  const first = genIds[0];
-  const last = genIds[genIds.length - 1];
-  lines.push(`# Epoch ${String(epochNum).padStart(3, "0")} (${first} ~ ${last})`);
-  lines.push("");
+async function findForkedByOtherBranches(paths, cwd) {
+  const forked = new Set;
+  const currentBranch = gitCurrentBranch(cwd);
+  const branches = gitAllBranches(cwd).filter((b) => b !== currentBranch && b !== "HEAD");
+  for (const branch of branches) {
+    const files = gitLsTree(branch, ".reap/lineage/", cwd);
+    for (const file of files) {
+      if (!file.endsWith("meta.yml"))
+        continue;
+      const content = gitShow(branch, file, cwd);
+      if (!content)
+        continue;
+      try {
+        const meta = import_yaml2.default.parse(content);
+        for (const parent of meta.parents) {
+          forked.add(parent);
+        }
+      } catch {}
+    }
+  }
+  return forked;
+}
+async function compressLevel2Single(level1Files, paths) {
+  const compressed = [];
+  const epochPath = join6(paths.lineage, "epoch.md");
+  let existingMeta = { generations: [] };
+  let existingBody = "";
+  const existingContent = await readTextFile(epochPath);
+  if (existingContent) {
+    const parsed = parseFrontmatter(existingContent);
+    if (parsed?.generations)
+      existingMeta = parsed;
+    existingBody = existingContent.replace(/^---\n[\s\S]*?\n---\n?/, "").trim();
+  }
+  const newBodyLines = [];
   for (const file of level1Files) {
     const content = await readTextFileOrThrow(file.path);
-    const bodyContent = content.replace(/^---\n[\s\S]*?\n---\n?/, "");
-    const headerMatch = bodyContent.match(/^# (gen-\d{3}(?:-[a-f0-9]{6})?)/m);
-    const goalMatch = bodyContent.match(/- Goal: (.+)/);
-    const periodMatch = bodyContent.match(/- (?:Started|Period): (.+)/);
-    const genomeMatch = bodyContent.match(/- Genome.*: (.+)/);
-    const resultMatch = bodyContent.match(/## Result: (.+)/);
-    const genId = headerMatch?.[1] ?? "unknown";
-    const goal = goalMatch?.[1] ?? "";
-    const result2 = resultMatch?.[1] ?? "";
-    lines.push(`## ${genId}: ${goal}`);
-    if (periodMatch)
-      lines.push(`- ${periodMatch[0].trim()}`);
-    if (genomeMatch)
-      lines.push(`- ${genomeMatch[0].trim()}`);
-    if (result2)
-      lines.push(`- Result: ${result2}`);
-    const changeSection = bodyContent.match(/## Genome Changes\n([\s\S]*?)(?=\n##|$)/);
-    if (changeSection && !changeSection[1].match(/^\|\s*\|\s*\|\s*\|\s*\|$/)) {
-      lines.push(`- Genome Changes: ${changeSection[1].trim().split(`
-`)[0]}`);
+    const meta = file.meta;
+    const bodyContent = content.replace(/^---\n[\s\S]*?\n---\n?/, "").trim();
+    if (meta) {
+      existingMeta.generations.push({
+        id: meta.id,
+        parents: meta.parents,
+        genomeHash: meta.genomeHash
+      });
     }
-    lines.push("");
-  }
-  let result = lines.join(`
+    const headerMatch = bodyContent.match(/^# (gen-\d{3}(?:-[a-f0-9]{6})?)/m);
+    const genId = headerMatch?.[1] ?? meta?.id ?? "unknown";
+    const goalMatch = bodyContent.match(/## Objective\n([\s\S]*?)(?=\n##|$)/);
+    const goal = goalMatch?.[1]?.trim().split(`
+`)[0] ?? "";
+    newBodyLines.push(`## ${genId}: ${goal}`);
+    newBodyLines.push("");
+    compressed.push(genId);
+  }
+  const frontmatter = `---
+${import_yaml2.default.stringify(existingMeta).trim()}
+---
+`;
+  const allIds = existingMeta.generations.map((g) => g.id);
+  const first = allIds[0] ?? "?";
+  const last = allIds[allIds.length - 1] ?? "?";
+  const header = `# Epoch (${first} ~ ${last})
+
+`;
+  const body = existingBody ? existingBody + `
+
+` + newBodyLines.join(`
+`) : newBodyLines.join(`
 `);
-  const resultLines = result.split(`
+  await writeTextFile(epochPath, frontmatter + header + body.trim() + `
 `);
-  if (resultLines.length > LEVEL2_MAX_LINES) {
-    result = resultLines.slice(0, LEVEL2_MAX_LINES - 1).join(`
-`) + `
-[...truncated]`;
+  for (const file of level1Files) {
+    await rm(file.path);
   }
-  return result;
+  return compressed;
 }
-async function compressLineageIfNeeded(paths) {
+async function compressLineageIfNeeded(paths, projectRoot) {
   const result = { level1: [], level2: [] };
   const entries = await scanLineage(paths);
   const totalEntries = entries.filter((e) => e.type === "dir" || e.type === "level1").length;
@@ -10265,7 +10363,7 @@ async function compressLineageIfNeeded(paths) {
   }
   const leafNodes = await findLeafNodes(paths, entries);
   const allDirs = entries.filter((e) => e.type === "dir");
-  const recentIds = new Set(allDirs.slice(Math.max(0, allDirs.length - RECENT_PROTECTED_COUNT)).map((e) => e.genId));
+  const recentIds = new Set(allDirs.slice(Math.max(0, allDirs.length - LEVEL1_PROTECTED_COUNT)).map((e) => e.genId));
   const compressibleDirs = allDirs.filter((dir) => !recentIds.has(dir.genId) && !leafNodes.has(dir.genId));
   for (const dir of compressibleDirs) {
     const currentTotal = await countDirLines(paths.lineage);
@@ -10280,24 +10378,26 @@ async function compressLineageIfNeeded(paths) {
     result.level1.push(genId);
   }
   const level1s = (await scanLineage(paths)).filter((e) => e.type === "level1");
-  if (level1s.length >= LEVEL2_BATCH_SIZE) {
-    const existingEpochs = (await scanLineage(paths)).filter((e) => e.type === "level2");
-    let epochNum = existingEpochs.length + 1;
-    const batchCount = Math.floor(level1s.length / LEVEL2_BATCH_SIZE);
-    for (let i = 0;i < batchCount; i++) {
-      const batch = level1s.slice(i * LEVEL2_BATCH_SIZE, (i + 1) * LEVEL2_BATCH_SIZE);
-      const files = batch.map((e) => ({
-        name: e.name,
-        path: join6(paths.lineage, e.name)
-      }));
-      const compressed = await compressLevel2(files, epochNum);
-      const outPath = join6(paths.lineage, `epoch-${String(epochNum).padStart(3, "0")}.md`);
-      await writeTextFile(outPath, compressed);
-      for (const file of files) {
-        await rm(file.path);
+  if (level1s.length > LEVEL2_MIN_LEVEL1_COUNT) {
+    const forkedIds = projectRoot ? await findForkedByOtherBranches(paths, projectRoot) : new Set;
+    let forkCutoff = level1s.length;
+    for (let i = 0;i < level1s.length; i++) {
+      if (forkedIds.has(level1s[i].genId)) {
+        forkCutoff = i;
+        break;
       }
-      result.level2.push(`epoch-${String(epochNum).padStart(3, "0")}`);
-      epochNum++;
+    }
+    const protectedStart = Math.max(0, level1s.length - LEVEL2_PROTECTED_COUNT);
+    const compressEnd = Math.min(forkCutoff, protectedStart);
+    const compressible = level1s.slice(0, compressEnd);
+    if (compressible.length > 0) {
+      const filesWithMeta = await Promise.all(compressible.map(async (e) => ({
+        name: e.name,
+        path: join6(paths.lineage, e.name),
+        meta: await readFileMeta(join6(paths.lineage, e.name))
+      })));
+      const compressed = await compressLevel2Single(filesWithMeta, paths);
+      result.level2.push(...compressed);
     }
   }
   return result;
@@ -10519,7 +10619,7 @@ class GenerationManager {
       }
     } catch {}
     await writeTextFile(this.paths.currentYml, "");
-    const compression = await compressLineageIfNeeded(this.paths);
+    const compression = await compressLineageIfNeeded(this.paths, this.paths.projectRoot);
     return compression;
   }
   async save(state) {
@@ -10650,12 +10750,15 @@ async function migrateLineage(paths) {
 // src/cli/commands/update.ts
 function selfUpgrade() {
   try {
-    const installed = execSync("reap --version", { encoding: "utf-8", timeout: 5000 }).trim();
-    const latest = execSync("npm view @c-d-cc/reap version", { encoding: "utf-8", timeout: 1e4 }).trim();
+    const installed = execSync2("reap --version", { encoding: "utf-8", timeout: 5000 }).trim();
+    if (installed.includes("+dev")) {
+      return { upgraded: false };
+    }
+    const latest = execSync2("npm view @c-d-cc/reap version", { encoding: "utf-8", timeout: 1e4 }).trim();
     if (installed === latest) {
       return { upgraded: false };
     }
-    execSync("npm update -g @c-d-cc/reap", { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
+    execSync2("npm update -g @c-d-cc/reap", { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
     return { upgraded: true, from: installed, to: latest };
   } catch {
     return { upgraded: false };
@@ -10756,6 +10859,35 @@ async function updateProject(projectRoot, dryRun = false) {
     }
   }
   if (await paths.isReapProject()) {
+    const projectClaudeCommands = join10(paths.projectRoot, ".claude", "commands");
+    await mkdir6(projectClaudeCommands, { recursive: true });
+    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 unlink3(destPath);
+        } else {
+          const existing = await readTextFile(destPath);
+          if (existing !== null && existing === src)
+            continue;
+          if (!dryRun)
+            await unlink3(destPath);
+        }
+      } catch {}
+      if (!dryRun)
+        await writeTextFile(destPath, src);
+      cmdInstalled++;
+    }
+    if (cmdInstalled > 0) {
+      result.updated.push(`.claude/commands/ (${cmdInstalled} synced)`);
+    } else {
+      result.skipped.push(`.claude/commands/ (${reapCmdFiles.length} unchanged)`);
+    }
     await migrateLegacyFiles(paths, dryRun, result);
     if (await needsMigration(paths)) {
       if (!dryRun) {
@@ -10850,7 +10982,8 @@ async function getStatus(projectRoot) {
 
 // src/cli/commands/fix.ts
 var import_yaml6 = __toESM(require_dist(), 1);
-import { mkdir as mkdir7, stat as stat3 } from "fs/promises";
+import { mkdir as mkdir7, stat as stat3, copyFile } from "fs/promises";
+import { join as join11 } from "path";
 init_fs();
 async function dirExists(path) {
   try {
@@ -10878,6 +11011,23 @@ async function fixProject(projectRoot) {
       fixed.push(`Recreated missing directory: ${dir.name}/`);
     }
   }
+  const genomeFiles = [
+    { path: paths.principles, name: "principles.md" },
+    { path: paths.conventions, name: "conventions.md" },
+    { path: paths.constraints, name: "constraints.md" },
+    { path: paths.sourceMap, name: "source-map.md" }
+  ];
+  for (const gf of genomeFiles) {
+    if (!await fileExists(gf.path)) {
+      const templateSrc = join11(ReapPaths.packageGenomeDir, gf.name);
+      if (await fileExists(templateSrc)) {
+        await copyFile(templateSrc, gf.path);
+        fixed.push(`Restored missing genome/${gf.name} from template`);
+      } else {
+        issues.push(`genome/${gf.name} is missing and no template found`);
+      }
+    }
+  }
   if (!await fileExists(paths.config)) {
     issues.push("config.yml is missing. Run 'reap init' to recreate the project.");
   }
@@ -10908,8 +11058,8 @@ async function fixProject(projectRoot) {
 
 // src/cli/index.ts
 init_fs();
-import { join as join11 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.7.9");
+import { join as join12 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.9.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();
@@ -11037,10 +11187,10 @@ program.command("help").description("Show REAP commands, slash commands, and wor
     if (l === "korean" || l === "ko")
       lang = "ko";
   }
-  const helpDir = join11(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join11(helpDir, `${lang}.txt`));
+  const helpDir = join12(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join12(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join11(helpDir, "en.txt"));
+    helpText = await readTextFile(join12(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;

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

@@ -0,0 +1,73 @@
+---
+description: "REAP Abort — Abort the current generation and return to initial state"
+---
+
+# Abort
+
+Abort the current generation and return to initial state.
+
+## Gate (Preconditions)
+- Read `.reap/life/current.yml`
+- If no active Generation: ERROR — "No active Generation to abort." **STOP**
+
+## Steps
+
+### 1. Show Current State
+- Display: generation id, goal, current stage
+- Ask: "이 generation을 abort 하시겠습니까?"
+- If no: **STOP**
+
+### 2. Abort Reason
+- Ask: "abort 사유를 입력해주세요"
+
+### 3. Source Code Handling
+- Check `git diff --name-only` for uncommitted changes
+- If no changes: skip to Step 4
+- If changes exist, present the changed files and ask:
+  - **rollback**: `git checkout .` — 모든 변경 revert
+  - **stash**: `git stash push -m "reap-abort: {gen-id}"` — stash에 저장
+  - **hold**: 변경 유지 (working tree에 그대로)
+
+### 4. Backlog Save
+- Ask: "Goal과 진행 상황을 backlog에 저장할까요? (yes/no)"
+- If yes:
+  - Read `01-objective.md` for goal/spec content
+  - Read `03-implementation.md` if exists for progress
+  - Create `.reap/life/backlog/aborted-{gen-id}.md`:
+    ```markdown
+    ---
+    type: task
+    status: pending
+    aborted: true
+    abortedFrom: {gen-id}
+    abortReason: "{reason}"
+    stage: {current stage}
+    sourceAction: rollback|stash|hold
+    stashRef: "reap-abort: {gen-id}"  # only if stash
+    changedFiles:
+      - {file1}
+      - {file2}
+    ---
+
+    # [Aborted] {goal}
+
+    ## Original Goal
+    {goal from objective}
+
+    ## Progress
+    {stage} 단계에서 중단.
+    {implementation summary if available}
+
+    ## Resume Guide
+    {if stash: "git stash pop으로 코드 복구"}
+    {if hold: "코드 변경이 working tree에 유지됨"}
+    {if rollback: "코드 변경이 revert됨. objective부터 재시작 필요"}
+    ```
+
+### 5. Cleanup
+- Delete all artifact files from `.reap/life/` (`01-*.md` through `05-*.md`)
+- Clear `current.yml` (write empty content)
+- Do NOT record in lineage (incomplete generation)
+
+## Completion
+- "Generation {gen-id} aborted. {backlog saved / not saved}."

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

@@ -104,6 +104,25 @@ Do NOT finalize Genome changes without running Validation Commands.
 19. 반복 패턴이 없으면 skip — "반복 패턴이 감지되지 않았습니다."
 20. **Limit**: 한 번에 최대 2개까지만 제안 (과부하 방지)
 
+### Phase 6: Lineage Compression
+
+21. Check if lineage compression is needed:
+    - Count total lines in `.reap/lineage/` and number of generations
+    - **Level 1 trigger**: total lines > 5,000 AND generations >= 5
+    - **Level 2 trigger**: Level 1 compressed `.md` files > 100
+22. If Level 1 triggered:
+    - Compress oldest uncompressed generation directories into single `.md` files
+    - Protect: recent 3 generations + DAG leaf nodes
+    - Preserve DAG metadata in frontmatter (id, parents, genomeHash)
+23. If Level 2 triggered:
+    - Run `git fetch --all` to update remote refs
+    - Scan all branches (local + remote) for fork points
+    - Compress eligible Level 1 files into single `epoch.md` (append if exists)
+    - Protect: recent 9 Level 1 files + all generations at/after fork points
+    - epoch.md frontmatter contains `generations` array with hash chain (id, parents, genomeHash)
+24. Report compression results: "Compressed N generations (Level 1: X, Level 2: Y)"
+    - If no compression needed: skip silently
+
 ## Self-Verification
 Before saving the artifact, verify:
 - [ ] Are lessons concrete and applicable to the next generation? (No vague "do better next time")

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

@@ -9,6 +9,7 @@ Start a merge generation by specifying a target branch to merge into the current
 ## Gate
 - Verify no active generation exists
 - Verify the target branch exists (`git rev-parse --verify {branch}`)
+- Verify that the common ancestor is NOT inside `epoch.md`. If it is: ERROR — "The common ancestor has been epoch-compressed and cannot be used as a merge base. The generation is archived in epoch.md for historical reference only."
 
 ## Steps
 

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

@@ -25,22 +25,11 @@ Brainstorming is triggered based on goal complexity — simple tasks skip it, co
 
 ## Steps
 
-### 1. Environment Scan
-- Read all files in `.reap/environment/`
-- This directory stores external context: external API docs, product requirements, team decision logs, reference materials, etc.
-- **If empty (first time setup)**, conduct an interactive Environment setup:
-  1. **Brief the human on what Environment means**:
-     > "Environment is where we record information **external to this project** — things that affect development but are outside the project's direct control.
-     > Unlike the Genome (design and knowledge the team decides), Environment captures the **constraints and context from the outside world**:
-     > connected systems, infrastructure, organizational rules, external API specs, etc."
-  2. **Ask questions interactively** (one at a time, skip if not applicable):
-     - "Are there any **connected systems**? (other services, external APIs, legacy systems, etc.)"
-     - "What is the **infrastructure/deployment environment**? (cloud, on-premise, containers, etc.)"
-     - "Are there **organizational rules or guidelines** to follow? (company standards, coding policies, security policies, regulatory compliance, etc.)"
-     - "Are there **external reference documents** to incorporate? (API specs, system architecture diagrams, integration guides, etc.)"
-  3. **Save collected information** to `.reap/environment/` as structured markdown files (e.g., `integrations.md`, `infrastructure.md`, `org-guidelines.md`)
-  4. If the human has nothing to add, that's fine — Environment is optional
-- If files already exist, review them and ask if any updates are needed
+### 1. Environment Check
+- Read `.reap/environment/summary.md`
+- If summary.md exists: review it for relevant context to this generation's goal
+- **If empty or missing**: inform the user — "Environment가 설정되지 않았습니다. `/reap.sync.environment`로 외부 환경 정보를 설정할 수 있습니다."
+  - Do NOT block — proceed with the objective. Environment is optional but recommended.
 
 ### 2. Previous Generation Reference
 - If a `05-completion.md` exists for the most recent generation in `.reap/lineage/`, read it

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

@@ -45,7 +45,20 @@ Do NOT make technical decisions without reading the Genome (conventions.md, cons
 - Each task must be **one logical unit of change**
 - Specify dependencies and parallelization potential between tasks
 
-### 5. Human Confirmation
+### 5. E2E Test Scenarios (lifecycle 변경 시 필수)
+- If this generation modifies lifecycle logic (compression, generation, merge, abort, stage transitions, etc.):
+  - Define specific E2E test scenarios with expected outcomes
+  - Each scenario: setup → action → assertion
+  - Example:
+    ```
+    ## E2E Test Scenarios
+    1. Normal abort + rollback → source reverted, artifacts deleted, current.yml empty
+    2. Abort + stash → stash created, recoverable
+    3. No active generation → error message
+    ```
+- If not a lifecycle change: skip this step
+
+### 6. Human Confirmation
 - Finalize the plan with the human
 
 ## Task Format

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

@@ -15,14 +15,15 @@ description: "REAP Start — Start a new Generation"
 - If backlog items exist:
   - Present the list with title and priority for each item
   - Ask: "Would you like to select one of these, or enter a new goal?"
-  - If the human selects a backlog item: use its title/content as the goal, then update the selected item's frontmatter to `status: consumed` and add `consumedBy: gen-XXX-{hash}`
+  - If the human selects a backlog item: **note the selection** (do NOT mark consumed yet — ID is not generated)
   - If the human wants a new goal: proceed to Step 1
 - If no backlog items exist: proceed to Step 1
 
-1. Ask the human for the goal of this generation
+1. Ask the human for the goal of this generation (or use selected backlog item's goal)
 2. Count existing generations in `.reap/lineage/` to determine the genomeVersion
 3. Generate the next generation ID (existing count + 1, in `gen-XXX-{hash}` format where `{hash}` is a short content hash)
-4. Write the following to `current.yml`:
+4. **If a backlog item was selected in Step 0**: now mark it as `status: consumed` and add `consumedBy: gen-XXX-{hash}` (using the ID just generated)
+6. Write the following to `current.yml`:
    ```yaml
    id: gen-XXX-{hash}
    goal: [goal provided by the human]
@@ -33,10 +34,10 @@ description: "REAP Start — Start a new Generation"
      - stage: objective
        at: [current ISO 8601 timestamp]
    ```
-5. Immediately create `.reap/life/01-objective.md` from the artifact template with the Goal section filled in
+7. Immediately create `.reap/life/01-objective.md` from the artifact template with the Goal section filled in
 
 ### Hook Execution (Generation Start)
-6. Scan `.reap/hooks/` for files matching `onGenerationStart.*`
+8. Scan `.reap/hooks/` for files matching `onGenerationStart.*`
    - For each matched file (sorted by `order` from frontmatter, then alphabetically):
      1. Read the frontmatter (`condition`, `order`)
      2. Evaluate `condition` by running `.reap/hooks/conditions/{condition}.sh` (exit 0 = met, non-zero = skip):

package/dist/templates/commands/reap.sync.environment.md

@@ -0,0 +1,84 @@
+---
+description: "REAP Sync Environment — Discover and document external environment dependencies"
+---
+
+# Sync Environment
+
+Discover external systems, APIs, infrastructure, and constraints that affect this project. Populate the `.reap/environment/` 3-layer structure.
+
+## Gate (Preconditions)
+- Read `.reap/life/current.yml`
+- If active Generation exists: switch to **Backlog Mode** (record as `type: environment-change`)
+- If no active Generation: proceed with **Sync Mode** (modify environment directly after human confirmation)
+
+## Environment 3-Layer Structure
+
+```
+.reap/environment/
+├── summary.md          # Session context (~100 lines max)
+├── docs/               # Main reference docs (agent reads these)
+└── resources/          # Raw materials (user-managed)
+    ├── *.pdf, *.md     # Original documents
+    └── links.md        # External URLs + summaries
+```
+
+- **summary.md**: Auto-generated overview of all docs/. Loaded into session context.
+- **docs/**: One file per environment topic. ~100 lines each. AI + human maintained.
+- **resources/**: User-provided originals. No line limit. AI reads when deeper detail needed.
+
+## Steps
+
+### 1. Source Code Scan
+Detect hints of external dependencies from:
+- `package.json` / `requirements.txt` / `go.mod` — SDK/client libraries (e.g., `discord.js`, `@aws-sdk/*`, `stripe`)
+- Config files — `.env`, `.env.example`, `wrangler.toml`, `docker-compose.yml`, `vercel.json`
+- API client code — HTTP clients, webhook handlers, OAuth configs
+- Infrastructure — Dockerfile, CI/CD configs, deployment scripts
+
+Present findings:
+```
+🔍 Detected external dependencies:
+  - discord.js → Discord Bot API
+  - @supabase/supabase-js → Supabase (DB + Auth)
+  - wrangler.toml → Cloudflare Workers
+```
+
+### 2. User Interview
+Ask the user to confirm and expand. Goal: **capture ALL external systems** that affect this project.
+
+Questions (one at a time, skip if already covered):
+1. "감지된 외부 서비스들이 맞나요? 추가/수정할 것이 있나요?"
+2. "그 외에 연동되는 외부 서비스, API, 시스템이 있나요?"
+3. "배포/인프라 환경을 알려주세요 (호스팅, CI/CD, 도메인 등)"
+4. "따라야 하는 조직 규칙이나 외부 제약이 있나요? (보안 정책, 규제 등)"
+5. "참고해야 할 외부 문서나 링크가 있나요? (API docs, 스펙 등)"
+
+For each confirmed item:
+- Ask: "관련 문서/링크가 있으면 알려주세요 (없으면 skip)"
+- If provided: save to `resources/` (file or `links.md` entry)
+
+### 3. Generate docs/
+For each confirmed environment topic, create a file in `docs/`:
+- File name: `{topic-slug}.md` (e.g., `discord-api.md`, `infrastructure.md`)
+- Content: structured markdown with key info the agent needs during implementation
+- Sections: Overview, Key Constraints, API/Config Details, References (→ resources/)
+- ~100 lines max per file
+
+### 4. Generate summary.md
+Aggregate all docs/ into a concise summary:
+- One section per environment topic
+- Key constraints and gotchas highlighted
+- Links to docs/ files for detail
+- **~100 lines max** (this gets loaded into every session)
+
+### 5. Verify
+- List all created/updated files
+- Show summary.md content to user for confirmation
+- Ask: "빠진 환경 정보가 있나요?"
+
+## Backlog Mode (active Generation)
+- Record each discovered environment item as `type: environment-change` in `.reap/life/backlog/`
+- "Environment 변경사항이 backlog에 기록되었습니다. Completion에서 적용됩니다."
+
+## Completion
+- "Environment synced. {N} docs created, summary.md updated."

package/dist/templates/commands/reap.sync.genome.md

@@ -0,0 +1,109 @@
+---
+description: "REAP Sync Genome — Synchronize Genome with current source code"
+---
+
+# Sync Genome
+
+Analyze the current source code and update the Genome to reflect reality.
+
+<HARD-GATE>
+If an active Generation exists (`.reap/life/current.yml` has content), do NOT modify Genome directly.
+Instead, record discovered differences as `type: genome-change` items in `.reap/life/backlog/` and inform the human.
+Only proceed with direct Genome modification when NO active Generation exists.
+</HARD-GATE>
+
+## Gate (Preconditions)
+- Read `.reap/life/current.yml`
+- If active Generation exists: switch to **Backlog Mode** (record differences, do not modify Genome)
+- If no active Generation: proceed with **Sync Mode** (modify Genome directly after human confirmation)
+
+## Steps
+
+### 1. Read Current Genome
+- Read all files in `.reap/genome/` (principles.md, conventions.md, constraints.md, domain/)
+- Note current genomeVersion from the most recent generation in `.reap/lineage/`
+
+### 2. Analyze Source Code
+Scan the project to understand its current state:
+
+**Tech Stack & Dependencies**:
+- package.json, tsconfig.json, Dockerfile, docker-compose.yml, etc.
+- New dependencies added, removed, or version-changed since Genome was last updated
+
+**Architecture & Structure**:
+- Directory structure and patterns (layers, modules, services)
+- Entry points, routing, API structure
+- Database, ORM, migration setup
+
+**Conventions**:
+- Linter/formatter configs (.eslintrc, .prettierrc, biome.json, etc.)
+- Test setup and patterns (test framework, file naming, coverage config)
+- Git hooks, CI/CD config
+- Code patterns observed in the source (naming, error handling, etc.)
+
+**Constraints**:
+- Build commands, test commands, validation commands
+- Environment requirements, runtime constraints
+- External service dependencies
+
+**Domain Knowledge** (→ `genome/domain/`):
+- Read `~/.reap/templates/domain-guide.md` for domain file writing principles
+- Scan source code for business rules NOT derivable from infrastructure analysis:
+  - State machines and status transitions (e.g., post lifecycle, order states)
+  - Policy rules with thresholds, limits, or conditions (e.g., rate limits, scoring criteria)
+  - Classification/branching logic driven by business categories (e.g., template selection by type)
+  - Hardcoded domain constants (keyword lists, prompt templates, magic numbers with business meaning)
+  - Workflow orchestration sequences (e.g., approval flows, pipeline stages)
+- For each discovered domain rule cluster, evaluate:
+  - "Would an agent implementing this feature ask 'where is this rule?'" → YES = create domain file
+  - "Does a single item in an upper-level genome file require 3+ lines of explanation?" → YES = extract to domain file
+- Even if `genome/domain/` is currently empty, treat it as "not yet created" rather than "not needed"
+
+### 3. Diff Analysis
+Compare source analysis with current Genome and identify:
+- **Additions**: Things in code but not in Genome
+- **Changes**: Things in Genome that no longer match code
+- **Removals**: Things in Genome that no longer exist in code
+- **Gaps**: Areas where Genome has placeholders but code has established patterns
+- **Domain gaps**: Business rules in code that have no corresponding `domain/` file
+
+### 4. Report to Human
+Present a structured diff report:
+
+```
+🔄 Genome Sync Report
+━━━━━━━━━━━━━━━━━━━━━
+
+📝 principles.md
+  + [New] API-first design pattern observed
+  ~ [Changed] Layer structure: added shared/ directory
+
+📝 conventions.md
+  + [New] Biome used for linting (replacing ESLint)
+  ~ [Changed] Test pattern: using vitest instead of jest
+
+📝 constraints.md
+  + [New] Validation command: bun test
+  ~ [Changed] Runtime: Node.js compatible (was Bun-only)
+
+📁 domain/
+  + [Suggest] Create lifecycle-rules.md for REAP lifecycle logic
+```
+
+### 5. Apply Changes
+
+**Sync Mode** (no active Generation):
+- For each difference, ask the human: "Apply this change? (yes/no/modify)"
+- Apply confirmed changes to the corresponding Genome files
+- Follow Genome writing principles:
+  - Each file ≤ 100 lines
+  - If exceeding, extract to `domain/`
+  - Follow `~/.reap/templates/domain-guide.md` for domain files
+
+**Backlog Mode** (active Generation):
+- Record each difference as a `type: genome-change` backlog item in `.reap/life/backlog/`
+- Inform: "Genome changes recorded in backlog. They will be applied at the Completion stage."
+
+## Completion
+- **Sync Mode**: "Genome synchronized. [N] changes applied."
+- **Backlog Mode**: "Genome differences recorded as [N] backlog items. Apply during Completion."

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

@@ -1,109 +1,17 @@
 ---
-description: "REAP Sync — Synchronize Genome with current source code"
+description: "REAP Sync — Synchronize both Genome and Environment with current state"
 ---
 
-# Sync (Genome Synchronization)
+# Sync (Full)
 
-Analyze the current source code and update the Genome to reflect reality.
-
-<HARD-GATE>
-If an active Generation exists (`.reap/life/current.yml` has content), do NOT modify Genome directly.
-Instead, record discovered differences as `type: genome-change` items in `.reap/life/backlog/` and inform the human.
-Only proceed with direct Genome modification when NO active Generation exists.
-</HARD-GATE>
-
-## Gate (Preconditions)
-- Read `.reap/life/current.yml`
-- If active Generation exists: switch to **Backlog Mode** (record differences, do not modify Genome)
-- If no active Generation: proceed with **Sync Mode** (modify Genome directly after human confirmation)
+Run both Genome and Environment synchronization.
 
 ## Steps
 
-### 1. Read Current Genome
-- Read all files in `.reap/genome/` (principles.md, conventions.md, constraints.md, domain/)
-- Note current genomeVersion from the most recent generation in `.reap/lineage/`
-
-### 2. Analyze Source Code
-Scan the project to understand its current state:
-
-**Tech Stack & Dependencies**:
-- package.json, tsconfig.json, Dockerfile, docker-compose.yml, etc.
-- New dependencies added, removed, or version-changed since Genome was last updated
-
-**Architecture & Structure**:
-- Directory structure and patterns (layers, modules, services)
-- Entry points, routing, API structure
-- Database, ORM, migration setup
-
-**Conventions**:
-- Linter/formatter configs (.eslintrc, .prettierrc, biome.json, etc.)
-- Test setup and patterns (test framework, file naming, coverage config)
-- Git hooks, CI/CD config
-- Code patterns observed in the source (naming, error handling, etc.)
-
-**Constraints**:
-- Build commands, test commands, validation commands
-- Environment requirements, runtime constraints
-- External service dependencies
-
-**Domain Knowledge** (→ `genome/domain/`):
-- Read `~/.reap/templates/domain-guide.md` for domain file writing principles
-- Scan source code for business rules NOT derivable from infrastructure analysis:
-  - State machines and status transitions (e.g., post lifecycle, order states)
-  - Policy rules with thresholds, limits, or conditions (e.g., rate limits, scoring criteria)
-  - Classification/branching logic driven by business categories (e.g., template selection by type)
-  - Hardcoded domain constants (keyword lists, prompt templates, magic numbers with business meaning)
-  - Workflow orchestration sequences (e.g., approval flows, pipeline stages)
-- For each discovered domain rule cluster, evaluate:
-  - "Would an agent implementing this feature ask 'where is this rule?'" → YES = create domain file
-  - "Does a single item in an upper-level genome file require 3+ lines of explanation?" → YES = extract to domain file
-- Even if `genome/domain/` is currently empty, treat it as "not yet created" rather than "not needed"
-
-### 3. Diff Analysis
-Compare source analysis with current Genome and identify:
-- **Additions**: Things in code but not in Genome
-- **Changes**: Things in Genome that no longer match code
-- **Removals**: Things in Genome that no longer exist in code
-- **Gaps**: Areas where Genome has placeholders but code has established patterns
-- **Domain gaps**: Business rules in code that have no corresponding `domain/` file
-
-### 4. Report to Human
-Present a structured diff report:
-
-```
-🔄 Genome Sync Report
-━━━━━━━━━━━━━━━━━━━━━
-
-📝 principles.md
-  + [New] API-first design pattern observed
-  ~ [Changed] Layer structure: added shared/ directory
-
-📝 conventions.md
-  + [New] Biome used for linting (replacing ESLint)
-  ~ [Changed] Test pattern: using vitest instead of jest
-
-📝 constraints.md
-  + [New] Validation command: bun test
-  ~ [Changed] Runtime: Node.js compatible (was Bun-only)
-
-📁 domain/
-  + [Suggest] Create lifecycle-rules.md for REAP lifecycle logic
-```
-
-### 5. Apply Changes
-
-**Sync Mode** (no active Generation):
-- For each difference, ask the human: "Apply this change? (yes/no/modify)"
-- Apply confirmed changes to the corresponding Genome files
-- Follow Genome writing principles:
-  - Each file ≤ 100 lines
-  - If exceeding, extract to `domain/`
-  - Follow `~/.reap/templates/domain-guide.md` for domain files
-
-**Backlog Mode** (active Generation):
-- Record each difference as a `type: genome-change` backlog item in `.reap/life/backlog/`
-- Inform: "Genome changes recorded in backlog. They will be applied at the Completion stage."
+1. Execute `/reap.sync.genome` — synchronize Genome with source code
+2. Execute `/reap.sync.environment` — discover and document external environment
 
-## Completion
-- **Sync Mode**: "Genome synchronized. [N] changes applied."
-- **Backlog Mode**: "Genome differences recorded as [N] backlog items. Apply during Completion."
+## Usage
+- `/reap.sync` — full sync (recommended after init or major changes)
+- `/reap.sync.genome` — genome only
+- `/reap.sync.environment` — environment only

package/dist/templates/hooks/session-start.cjs

@@ -79,7 +79,9 @@ let updateAvailableMessage = '';
 const { configContent } = gl.parseConfig(configFile);
 const installed = gl.exec('reap --version');
 const latest = gl.exec('npm view @c-d-cc/reap version');
-if (installed && latest && installed !== latest) {
+if (installed && installed.includes('+dev')) {
+  // Local dev build — skip version check entirely
+} else if (installed && latest && installed !== latest) {
   const autoUpdate = configContent ? /^autoUpdate:\s*true/m.test(configContent) : false;
   if (autoUpdate) {
     const updated = gl.exec('npm update -g @c-d-cc/reap');
@@ -100,6 +102,10 @@ const reapGuide = gl.readFile(guideFile) || '';
 log('Loading Genome...');
 const { content: genomeContent, l1Lines } = gl.loadGenome(genomeDir);
 
+// Step 3b: Load Environment summary
+const envSummaryFile = path.join(reapDir, 'environment', 'summary.md');
+const envSummary = gl.readFile(envSummaryFile) || '';
+
 // Step 4: Check Genome staleness
 log('Checking sync...');
 const { genomeStaleWarning, commitsSince } = gl.detectStaleness(projectRoot);
@@ -160,7 +166,9 @@ const sessionInitDisplay = initFormat
 // Step 6: Output JSON
 log('Done. Injecting context.');
 
-const reapContext = `<REAP_WORKFLOW>\n${reapGuide}\n\n---\n\n## Genome (Project Knowledge — treat as authoritative source of truth)\n${genomeContent}\n\n---\n\n## Current State\n${generationContext}${staleSection}${strictSection}${updateSection}\n\n## Session Init (display to user on first message)\n${sessionInitDisplay}\n\n## Rules\n1. ALL development work MUST follow the REAP lifecycle. Do NOT bypass it.\n2. Before writing any code, check if a Generation is active and what stage it is in.\n3. If a Generation is active, use \`${nextCmd}\` to proceed with the current stage.\n4. If no Generation is active, use \`/reap.start\` to start a new one.\n5. Do NOT implement features, fix bugs, or make changes outside of the REAP lifecycle unless the user explicitly asks to bypass it.\n6. When the user says "reap evolve", "next stage", "proceed", or similar — invoke the appropriate REAP skill.\n7. **Genome is the authoritative knowledge source.** When making decisions about architecture, conventions, or constraints, ALWAYS reference the Genome first. If code contradicts Genome, flag it as a potential genome-change backlog item.\n8. If you notice the Genome is outdated or missing information relevant to your current task, inform the user and suggest running \`/reap.sync\`.\n</REAP_WORKFLOW>`;
+const envSection = envSummary ? `\n\n---\n\n## Environment (External Context)\n${envSummary}` : '';
+
+const reapContext = `<REAP_WORKFLOW>\n${reapGuide}\n\n---\n\n## Genome (Project Knowledge — treat as authoritative source of truth)\n${genomeContent}${envSection}\n\n---\n\n## Current State\n${generationContext}${staleSection}${strictSection}${updateSection}\n\n## Session Init (display to user on first message)\n${sessionInitDisplay}\n\n## Rules\n1. ALL development work MUST follow the REAP lifecycle. Do NOT bypass it.\n2. Before writing any code, check if a Generation is active and what stage it is in.\n3. If a Generation is active, use \`${nextCmd}\` to proceed with the current stage.\n4. If no Generation is active, use \`/reap.start\` to start a new one.\n5. Do NOT implement features, fix bugs, or make changes outside of the REAP lifecycle unless the user explicitly asks to bypass it.\n6. When the user says "reap evolve", "next stage", "proceed", or similar — invoke the appropriate REAP skill.\n7. **Genome is the authoritative knowledge source.** When making decisions about architecture, conventions, or constraints, ALWAYS reference the Genome first. If code contradicts Genome, flag it as a potential genome-change backlog item.\n8. If you notice the Genome is outdated or missing information relevant to your current task, inform the user and suggest running \`/reap.sync\`.\n</REAP_WORKFLOW>`;
 
 process.stdout.write(JSON.stringify({
   hookSpecificOutput: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c-d-cc/reap",
-  "version": "0.7.9",
+  "version": "0.9.0",
   "description": "Recursive Evolutionary Autonomous Pipeline — AI and humans evolve software across generations",
   "type": "module",
   "license": "MIT",