@c-d-cc/reap 0.7.8 → 0.8.0

package/dist/cli.js

@@ -9218,6 +9218,9 @@ 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");
   }
@@ -9752,6 +9755,7 @@ var COMMAND_NAMES = [
   "reap.start",
   "reap.next",
   "reap.back",
+  "reap.abort",
   "reap.status",
   "reap.sync",
   "reap.help",
@@ -9861,6 +9865,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 as execSync2 } from "child_process";
 
 // src/core/hooks.ts
 async function migrateHooks(dryRun = false) {
@@ -9947,12 +9952,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;
@@ -10058,7 +10108,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;
   });
@@ -10208,50 +10260,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;
@@ -10264,7 +10350,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);
@@ -10279,24 +10365,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;
@@ -10518,7 +10606,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) {
@@ -10647,6 +10735,19 @@ async function migrateLineage(paths) {
 }
 
 // src/cli/commands/update.ts
+function selfUpgrade() {
+  try {
+    const installed = execSync2("reap --version", { encoding: "utf-8", timeout: 5000 }).trim();
+    const latest = execSync2("npm view @c-d-cc/reap version", { encoding: "utf-8", timeout: 1e4 }).trim();
+    if (installed === latest) {
+      return { upgraded: false };
+    }
+    execSync2("npm update -g @c-d-cc/reap", { encoding: "utf-8", timeout: 60000, stdio: "pipe" });
+    return { upgraded: true, from: installed, to: latest };
+  } catch {
+    return { upgraded: false };
+  }
+}
 async function updateProject(projectRoot, dryRun = false) {
   const paths = new ReapPaths(projectRoot);
   const result = { updated: [], skipped: [], removed: [] };
@@ -10836,7 +10937,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 {
@@ -10864,6 +10966,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.");
   }
@@ -10894,8 +11013,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.8");
+import { join as join12 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.8.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();
@@ -10983,8 +11102,14 @@ program.command("fix").description("Diagnose and repair .reap/ directory structu
     process.exit(1);
   }
 });
-program.command("update").description("Sync slash commands, templates, and hooks to the latest version").option("--dry-run", "Show changes without applying them").action(async (options) => {
+program.command("update").description("Upgrade REAP package and sync slash commands, templates, and hooks").option("--dry-run", "Show changes without applying them").action(async (options) => {
   try {
+    if (!options.dryRun) {
+      const upgrade = selfUpgrade();
+      if (upgrade.upgraded) {
+        console.log(`Upgraded: v${upgrade.from} → v${upgrade.to}`);
+      }
+    }
     const result = await updateProject(process.cwd(), options.dryRun ?? false);
     if (options.dryRun) {
       console.log("[dry-run] Changes that would be applied:");
@@ -11017,10 +11142,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.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/package.json

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