@c-d-cc/reap 0.8.0 → 0.9.0

package/dist/cli.js

@@ -9224,6 +9224,15 @@ class ReapPaths {
   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");
   }
@@ -9758,6 +9767,8 @@ var COMMAND_NAMES = [
   "reap.abort",
   "reap.status",
   "reap.sync",
+  "reap.sync.genome",
+  "reap.sync.environment",
   "reap.help",
   "reap.update",
   "reap.merge.start",
@@ -9789,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 });
@@ -10738,6 +10751,9 @@ async function migrateLineage(paths) {
 function selfUpgrade() {
   try {
     const installed = execSync2("reap --version", { encoding: "utf-8", timeout: 5000 }).trim();
+    if (installed.includes("+dev")) {
+      return { upgraded: false };
+    }
     const latest = execSync2("npm view @c-d-cc/reap version", { encoding: "utf-8", timeout: 1e4 }).trim();
     if (installed === latest) {
       return { upgraded: false };
@@ -10843,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) {
@@ -11014,7 +11059,7 @@ async function fixProject(projectRoot) {
 // src/cli/index.ts
 init_fs();
 import { join as join12 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.8.0");
+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();

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.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.8.0",
+  "version": "0.9.0",
   "description": "Recursive Evolutionary Autonomous Pipeline — AI and humans evolve software across generations",
   "type": "module",
   "license": "MIT",