@c-d-cc/reap 0.8.0 → 0.9.1

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,8 +9767,11 @@ var COMMAND_NAMES = [
   "reap.abort",
   "reap.status",
   "reap.sync",
+  "reap.sync.genome",
+  "reap.sync.environment",
   "reap.help",
   "reap.update",
+  "reap.report",
   "reap.merge.start",
   "reap.merge.detect",
   "reap.merge.mate",
@@ -9789,15 +9801,27 @@ 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 });
   log("Writing config.yml...");
+  let hasGhCli = false;
+  try {
+    const { execSync } = await import("child_process");
+    execSync("which gh", { stdio: "ignore" });
+    hasGhCli = true;
+  } catch {}
+  if (!hasGhCli) {
+    log("GitHub CLI(gh) not found. Install from https://cli.github.com for auto issue reporting.");
+  }
   const config = {
     version: "0.1.0",
     project: projectName,
     entryMode,
     autoUpdate: true,
+    autoIssueReport: hasGhCli,
     ...preset && { preset }
   };
   await ConfigManager.write(paths, config);
@@ -10738,6 +10762,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 +10870,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 +11070,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.1");
 program.command("init").description("Initialize a new REAP project (Genesis)").argument("[project-name]", "Project name (defaults to current directory name)").option("-m, --mode <mode>", "Entry mode: greenfield, migration, adoption", "greenfield").option("-p, --preset <preset>", "Bootstrap with a genome preset (e.g., bun-hono-react)").action(async (projectName, options) => {
   try {
     const cwd = process.cwd();

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.report.md

@@ -0,0 +1,127 @@
+---
+description: "REAP Report — Report a bug or issue to the REAP project"
+---
+
+# Report
+
+Report a bug, malfunction, or feedback to the REAP project via GitHub Issue.
+**Language**: All user-facing messages must follow the user's configured language setting (see REAP Guide § Language).
+
+## Gate (Preconditions)
+- Check if `gh` CLI is available: `which gh`
+- If not available: inform user that GitHub CLI is required (https://cli.github.com), then `gh auth login`. **STOP**
+- Check if authenticated: `gh auth status`
+- If not authenticated: inform user to run `gh auth login`. **STOP**
+- Read `.reap/config.yml` — check `autoIssueReport` is not explicitly `false`
+- If `autoIssueReport: false`: inform user that issue reporting is disabled and how to enable it in config.yml. **STOP**
+
+## Mode Detection
+
+**Auto mode** (called by agent when malfunction detected):
+- The agent provides error context as arguments
+- Skip to Step 2 with pre-filled context
+
+**Manual mode** (user calls `/reap.report` directly):
+- Ask the user what they want to report:
+  - Bug / malfunction
+  - Feature request
+  - Other feedback
+- Gather description from the user
+
+## Steps
+
+### 1. Collect Context
+Automatically gather (do NOT ask the user for these):
+- REAP version: `reap --version`
+- Node version: `node --version`
+- OS: `uname -sr`
+- Agent: detect from environment (Claude Code, OpenCode, etc.)
+- Generation state: read `.reap/life/current.yml` (id, stage — if active)
+- Genome hash: compute from `.reap/genome/`
+- Config: read `.reap/config.yml`
+
+### 2. Draft Issue
+
+<PRIVACY_GATE>
+**BEFORE writing any issue content, apply these rules:**
+- Do NOT include: file contents, source code, environment variables, API keys,
+  tokens, passwords, usernames, email addresses, IP addresses, domain names,
+  database URLs, project-specific business logic, or any proprietary information.
+- ONLY include: REAP version, Node version, OS, generation ID, stage name,
+  command name, genome hash, generic error messages, and REAP config structure
+  (with all values masked).
+- When in doubt, OMIT the information rather than include it.
+</PRIVACY_GATE>
+
+Draft the issue using this template (issue body is always in English for the public repo):
+
+```markdown
+## {Bug Report / Feature Request / Feedback} (Auto-generated by REAP)
+
+**REAP Version**: v{version}
+**Node Version**: v{nodeVersion}
+**OS**: {os}
+**Agent**: {agentName}
+
+### Context
+- **Generation**: {genId or "none"} (stage: {stage or "n/a"})
+- **Command**: {command that triggered the issue}
+- **Genome Hash**: {genomeHash}
+
+### Description
+{user description or auto-detected malfunction description}
+
+### Expected Behavior
+{what should have happened}
+
+### Actual Behavior
+{what actually happened}
+
+### Steps to Reproduce
+1. {step}
+
+### Config
+```yaml
+version: {version}
+project: {projectName}
+strict: {on/off}
+autoUpdate: {on/off}
+# all other values masked
+```
+
+---
+*Auto-reported by REAP agent. Repository: c-d-cc/reap*
+```
+
+### 3. Post-format Sanitization
+Scan the drafted issue body and mask/remove:
+- Email patterns: `*@*.*` → `[REDACTED_EMAIL]`
+- API key/token patterns: `sk-*`, `ghp_*`, `Bearer *`, `token:*` → `[REDACTED]`
+- URLs with credentials: `https://user:pass@` → `https://[REDACTED]@`
+- Environment variable values: `KEY=value` → `KEY=[REDACTED]`
+- User paths: `/Users/{name}/` or `/home/{name}/` → `/Users/***/`
+- IP addresses: digit patterns like `\d+\.\d+\.\d+\.\d+` → `[REDACTED_IP]`
+- Source code blocks: if any project source code is included, remove it
+
+### 4. User Confirmation
+Show the sanitized issue to the user (in user's language):
+- Explain that this report greatly helps improve the REAP project
+- Ask the user to verify no sensitive information is included
+- Present the full issue body
+- Ask: yes / no / edit
+  - **yes**: proceed to Step 5
+  - **no**: report cancelled
+  - **edit**: let user modify, then re-run Step 3 sanitization and re-confirm
+
+### 5. Submit
+- Determine labels (comma-separated, always include `auto-reported`):
+  - Bug: `bug,auto-reported`
+  - Feature request: `enhancement,auto-reported`
+  - Feedback: `feedback,auto-reported`
+  - Add context labels if applicable: `lifecycle`, `genome`, `cli`
+- Run: `gh issue create --repo c-d-cc/reap --title "{title}" --label "{labels}" --body "{sanitized body}"`
+- Show the issue URL to the user
+- Thank the user for their contribution to improving REAP
+
+## Completion
+- "Issue #{number} reported: {url}"

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

@@ -21,7 +21,11 @@ description: "REAP Start — Start a new 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)
+3. Generate the next generation ID:
+   - Format: `gen-{NNN}-{hash}` (e.g. `gen-042-a3f8c2`)
+   - `{NNN}`: zero-padded 3-digit sequence (existing count + 1)
+   - `{hash}`: 6-character hex (0-9a-f only) — first 6 chars of `sha256(JSON.stringify({parents, goal, genomeHash, machineId, startedAt}))`
+   - Generate: `node -e "const c=require('crypto'),o=require('os');console.log(c.createHash('sha256').update(JSON.stringify({parents:[],goal:'YOUR_GOAL',genomeHash:'',machineId:o.hostname(),startedAt:new Date().toISOString()})).digest('hex').slice(0,6))"`
 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

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/reap-guide.md

@@ -58,6 +58,11 @@ Objective → Planning → Implementation ⟷ Validation → Completion
 ### Generation
 A single generation. Carries one goal through the Life Cycle. State is tracked in `life/current.yml`.
 
+**Generation ID format**: `gen-{NNN}-{hash}` (e.g. `gen-042-a3f8c2`)
+- `{hash}`: 6-char hex from sha256. **MUST be real hex (0-9a-f), NEVER words/slugs.**
+- Lineage directory appends a goal slug: `gen-042-a3f8c2-fix-login-bug`
+- See `/reap.start` for generation details.
+
 ### Backlog
 All items to be carried forward to the next generation are stored in `.reap/life/backlog/`. Each item uses markdown + frontmatter format:
 - `type: genome-change` — Applied to genome during Completion (genome defects discovered mid-generation)
@@ -199,3 +204,4 @@ When `strict: true` is set in `.reap/config.yml`, the AI agent enforces code mod
 3. **ALL development work MUST follow the REAP lifecycle.** Do NOT bypass it unless the human explicitly asks.
 4. **Genome is the authoritative source of truth.** When making any decision about architecture, conventions, constraints, or domain rules, ALWAYS consult the Genome first. If you observe code that contradicts the Genome, flag it as a potential `genome-change` backlog item. Do NOT silently ignore discrepancies.
 5. **Keep Genome fresh.** If you notice the Genome is missing information about current code patterns, or contains outdated information, inform the human and suggest `/reap.sync`. The human may choose to defer sync — respect that choice, but always flag the staleness.
+6. **Report malfunctions.** If you detect unexpected behavior during REAP operations (state inconsistency, command failure, corrupted files), suggest `/reap.report` to the user. This helps improve REAP for everyone.

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