@c-d-cc/reap 0.1.3 → 0.2.2

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

@@ -4,58 +4,83 @@ description: "REAP Help — Contextual help based on current state"
 
 # Help
 
-Provide contextual help to the user based on the current REAP state.
+**ARGUMENTS**: $ARGUMENTS
 
-## Steps
+## File Access Rules
+- ONLY read `.reap/life/current.yml` and `.reap/config.yml`. No other files for basic help.
+- For topic help: also read `reap.{name}.md` from the same directory as this file.
+- Do NOT access global node_modules. Do NOT guess file paths.
 
-### 1. Read Current State
-- Read `.reap/life/current.yml`
-- Read `.reap/config.yml` for strict mode status
+## If ARGUMENTS is provided → skip to "Topic Help" section below.
 
-### 2. Contextual Guidance
+## Basic Help (no arguments)
 
-**If no active Generation:**
-- "No active Generation. To get started:"
-- "  `/reap.start` — Start a new Generation with a goal"
-- "  `/reap.evolve` — Start and run the full lifecycle autonomously"
-- If there are items in `.reap/life/backlog/`, mention them
+Read `.reap/life/current.yml` and `.reap/config.yml`, then output EXACTLY this format with values filled in. Use markdown formatting. Do NOT add extra explanation.
 
-**If active Generation exists:**
-- Show current generation ID, goal, and stage
-- Show the next action: "Current stage is [stage]. Run `/reap.[stage]` to proceed, or `/reap.next` to advance."
-- If in implementation stage with strict mode, note the planning scope restriction
+---
+
+**REAP** — Recursive Evolutionary Autonomous Pipeline
+
+AI와 사람이 협업하여 소프트웨어를 세대(Generation) 단위로 진화시키는 개발 파이프라인입니다.
+각 세대는 5단계 lifecycle을 거칩니다:
+
+`Objective` → `Planning` → `Implementation` → `Validation` → `Completion`
+
+Genome(`.reap/genome/`)에 프로젝트의 설계 원칙과 규칙을 기록하고, 세대를 거듭하며 점진적으로 진화합니다.
 
-### 3. Command Reference
+---
+
+[If active generation exists, show:]
+> 🔄 **{id}** — {goal}
+> Stage: `{stage}` → 다음: `/reap.{stage}` 또는 `/reap.next`
+
+[If no active generation, show:]
+> No active Generation → `/reap.start` 또는 `/reap.evolve`
+
+---
 
-Show available slash commands with brief descriptions:
+### 커맨드
 
 | Command | Description |
 |---------|-------------|
-| `/reap.start` | Start a new Generation |
-| `/reap.evolve` | Run the full lifecycle autonomously |
-| `/reap.objective` | Define goal + requirements |
-| `/reap.planning` | Task decomposition + plan |
-| `/reap.implementation` | Code implementation |
-| `/reap.validation` | Run tests + verify |
-| `/reap.completion` | Retrospective + genome updates |
-| `/reap.next` | Advance to the next stage |
-| `/reap.back` | Return to a previous stage |
-| `/reap.status` | Show current state |
-| `/reap.sync` | Synchronize Genome with source code |
-| `/reap.help` | This help |
-
-### 4. Topic Help (Optional)
-
-If the user provides a topic (e.g., `/reap.help workflow`), provide deeper explanation:
-
-- **workflow** — Explain the 5-stage lifecycle in detail
-- **commands** — Explain each slash command with examples
-- **strict** — Explain strict mode, how to enable/disable, and escape hatch
-- **genome** — Explain genome structure, immutability principle, and how to modify
-- **backlog** — Explain backlog types, status management, and archiving rules
-
-### 5. Configuration Info
-
-- Show strict mode status (enabled/disabled)
-- Show project name and entry mode
-- Show total completed generations
+| `/reap.start` | 새 Generation을 시작하고 goal을 설정 |
+| `/reap.evolve` | ⚡ 전체 lifecycle을 자율적으로 실행 (사람 개입 최소화) |
+| `/reap.objective` | 이번 Generation의 목표, 요구사항, 완료 기준을 정의 |
+| `/reap.planning` | 태스크를 분해하고 구현 계획을 수립 |
+| `/reap.implementation` | 계획에 따라 코드를 구현하고 진행 상황을 기록 |
+| `/reap.validation` | 테스트 실행, 완료 기준 충족 여부를 검증 |
+| `/reap.completion` | 회고, Genome 변경 반영, Generation 마무리 |
+| `/reap.next` | 다음 stage로 전진 (completion → archiving + commit) |
+| `/reap.back` | 이전 stage로 회귀 (regression 사유 기록) |
+| `/reap.status` | 프로젝트 상태, Generation 진행도, backlog, Genome 건강도 표시 |
+| `/reap.sync` | 현재 소스코드와 Genome 간 차이를 분석하고 동기화 |
+| `/reap.update` | REAP 최신 버전 확인 및 업그레이드 |
+| `/reap.help` | 도움말. `/reap.help {topic}`으로 주제별 상세 설명 |
+
+💡 `/reap.help {topic}` — workflow, genome, backlog, strict, agents, hooks, config, evolve, regression, author ...
+
+**Config**: Strict: {on/off} · Auto-Update: {on/off} · Language: {value}
+
+---
+
+## Topic Help
+
+If ARGUMENTS contains a topic, look up from the list below. **If NOT in the list, respond: "Unknown topic: '{topic}'. `/reap.help`로 available topics를 확인하세요."**
+
+For command-name topics: read `reap.{name}.md` from the same directory as this file, then explain.
+
+#### Topics
+
+- **workflow** / **lifecycle** — 5-stage lifecycle: objective → planning → implementation → validation → completion. Gate → Steps → Artifact. `/reap.next`로 전진, `/reap.back`으로 회귀.
+- **genome** — `.reap/genome/`: principles.md, conventions.md, constraints.md, domain/*.md. 불변 원칙: 현재 세대에서 직접 수정 금지 → backlog → completion에서 반영.
+- **backlog** — `.reap/life/backlog/`. genome-change, environment-change, task. status: pending/consumed. consumed → lineage, pending → 이월.
+- **strict** — `strict: true`: no generation = 코드 수정 차단, non-implementation = 차단, implementation = plan scope만. Escape: "override"/"bypass strict".
+- **agents** — AgentAdapter 추상화. auto-detect (Claude Code, OpenCode). config.yml `agents` 오버라이드.
+- **hooks** — config.yml: onGenerationStart, onStageTransition, onGenerationComplete, onRegression. command/prompt 타입.
+- **config** — `.reap/config.yml`: version, project, entryMode, strict, language, agents, autoUpdate, hooks.
+- **evolve** — `/reap.evolve`: 전체 lifecycle 자율 실행. 사람 확인 없이 objective~completion 순차 진행.
+- **regression** — `/reap.back`: 이전 stage 회귀. timeline + artifact에 Regression 섹션 기록.
+- **minor-fix** — 5분 이내, 설계 변경 없는 수정. stage 전환 없이 현재 artifact에 기록.
+- **compression** — 10,000줄 + 5세대 이상 시 lineage 자동 압축. L1(40줄), L2(60줄).
+- **author** — HyeonIL Choi. Email: hichoi@c-d.cc / Homepage: https://c-d.cc / LinkedIn: https://www.linkedin.com/in/hichoi-dev / GitHub: https://github.com/casamia918
+- **start** / **objective** / **planning** / **implementation** / **validation** / **completion** / **next** / **back** / **sync** / **status** / **update** / **help** — Read `reap.{name}.md` from same directory, explain.

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

@@ -6,11 +6,19 @@ description: "REAP Status — Show current generation state and project health"
 
 Display a comprehensive overview of the current REAP project state.
 
+## IMPORTANT: File Access Rules
+- ONLY read files explicitly listed in the steps below. Do NOT guess or infer file paths.
+- If a file read fails or the file does not exist, skip it silently and continue.
+- Do NOT attempt to read files like `reaprc.json`, `.reaprc`, or any file not specified in this command.
+- The REAP project structure uses ONLY: `.reap/config.yml`, `.reap/life/current.yml`, `.reap/life/backlog/`, `.reap/life/0X-*.md`, `.reap/genome/`, `.reap/lineage/`
+
 ## Steps
 
-### 1. Project Info
-- Read `.reap/config.yml` for project name, entryMode, preset, hooks
+### 1. Project Info (MUST execute all of these)
+- Read `.reap/config.yml` for project name, entryMode, strict, autoUpdate, language
 - Count completed generations in `.reap/lineage/`
+- **REQUIRED**: Run the shell command `reap --version` to get the installed version. You MUST actually execute this command, do not skip it.
+- Show "REAP: v{installed}" — do NOT run `npm view` here (slow network call). Users can run `/reap.update` to check for updates.
 
 ### 2. Current Generation
 - Read `.reap/life/current.yml`
@@ -48,7 +56,9 @@ Present as a structured summary the human can quickly scan:
 ```
 📊 REAP Status
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+REAP: v[installed] (run `/reap.update` to check for updates)
 Project: [name] ([entryMode])
+Strict: [on/off]  Auto-Update: [on/off]  Language: [lang]
 Genome Version: v[N]
 Completed Generations: [count]
 

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

@@ -0,0 +1,40 @@
+---
+description: "REAP Update — Check for updates and upgrade REAP"
+---
+
+# Update
+
+Check for REAP updates and upgrade to the latest version.
+
+## IMPORTANT: File Access Rules
+- Do NOT access global node_modules or any path outside the project.
+- If a command fails, report the error and stop.
+
+## Steps
+
+### 1. Check Current Version
+- Run `reap --version` to get the installed version
+- Run `npm view @c-d-cc/reap version` to get the latest published version
+- Compare the two versions
+
+### 2. Update Decision
+**If installed == latest:**
+- "REAP v{version} is already up to date. (latest)"
+- Then skip to Step 4.
+
+**If installed < latest:**
+- Show: "Update available: v{installed} → v{latest}"
+- Ask the user: "Update now? (yes/no)"
+- If yes: proceed to Step 3
+- If no: "Skipped. Run `/reap.update` anytime to update."
+
+### 3. Perform Update
+- Run: `npm update -g @c-d-cc/reap`
+- If the command fails, suggest: `sudo npm update -g @c-d-cc/reap` or `npm install -g @c-d-cc/reap@latest`
+- After npm update, run: `reap update` to sync commands, templates, and hooks to all detected agents
+- Show the update result summary
+
+### 4. Sync Check
+- Run: `reap update --dry-run` to check if commands/templates need syncing
+- If changes detected: run `reap update` and show results
+- If no changes: "All commands and templates are up to date."

package/dist/templates/hooks/opencode-session-start.js

@@ -0,0 +1,206 @@
+// REAP SessionStart plugin for OpenCode
+// Injects REAP guide + Genome + current generation context into every OpenCode session
+// Installed to ~/.config/opencode/plugins/reap-session-start.js
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+module.exports = async (ctx) => {
+  return {
+    "session.start": async ({ trigger }) => {
+      const projectRoot = process.cwd();
+      const reapDir = path.join(projectRoot, ".reap");
+
+      // Check if this is a REAP project
+      if (!fs.existsSync(reapDir)) return;
+
+      // Auto-update check (with PATH resolution for non-shell environments)
+      let autoUpdateMessage = "";
+      try {
+        const autoConfigPath = path.join(reapDir, "config.yml");
+        if (fs.existsSync(autoConfigPath)) {
+          const configRaw = fs.readFileSync(autoConfigPath, "utf8");
+          const autoUpdateMatch = configRaw.match(/^autoUpdate:\s*(.+)$/m);
+          if (autoUpdateMatch && autoUpdateMatch[1].trim() === "true") {
+            try {
+              // Resolve PATH: OpenCode plugin runs in Node.js context which may lack shell PATH
+              const userShell = process.env.SHELL || "/bin/bash";
+              const shellPath = execSync(`${userShell} -l -c 'echo $PATH' 2>/dev/null`, { encoding: "utf8" }).trim();
+              const execOpts = { encoding: "utf8", env: { ...process.env, PATH: shellPath || process.env.PATH } };
+
+              const installed = execSync("reap --version 2>/dev/null", execOpts).trim();
+              const latest = execSync("npm view @c-d-cc/reap version 2>/dev/null", execOpts).trim();
+              if (installed && latest && installed !== latest) {
+                execSync("npm update -g @c-d-cc/reap >/dev/null 2>&1", { ...execOpts, stdio: "ignore" });
+                execSync("reap update >/dev/null 2>&1", { ...execOpts, stdio: "ignore" });
+                autoUpdateMessage = `REAP auto-updated: v${installed} → v${latest}`;
+              }
+            } catch { /* update check failed, skip */ }
+          }
+        }
+      } catch { /* config read failed, skip */ }
+
+      const scriptDir = __dirname;
+      // Look for reap-guide.md relative to the package hooks dir
+      // The guide is installed alongside this plugin's source package
+      const guideLocations = [
+        path.join(scriptDir, "..", "hooks", "reap-guide.md"),
+        path.join(scriptDir, "reap-guide.md"),
+      ];
+
+      let reapGuide = "";
+      for (const loc of guideLocations) {
+        if (fs.existsSync(loc)) {
+          reapGuide = fs.readFileSync(loc, "utf8");
+          break;
+        }
+      }
+
+      // If guide not found from package, try to get it via the reap CLI
+      if (!reapGuide) {
+        try {
+          // Find the package hooks dir by looking up from the plugin location
+          const possiblePaths = [
+            path.join(require.resolve("@c-d-cc/reap/package.json"), "..", "dist", "templates", "hooks", "reap-guide.md"),
+          ];
+          for (const p of possiblePaths) {
+            if (fs.existsSync(p)) {
+              reapGuide = fs.readFileSync(p, "utf8");
+              break;
+            }
+          }
+        } catch { /* package not found */ }
+      }
+
+      // Read Genome files
+      const genomeDir = path.join(reapDir, "genome");
+      let genomeContent = "";
+      const L1_LIMIT = 500;
+      const L2_LIMIT = 200;
+      let l1Lines = 0;
+
+      if (fs.existsSync(genomeDir)) {
+        for (const file of ["principles.md", "conventions.md", "constraints.md"]) {
+          const filePath = path.join(genomeDir, file);
+          if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, "utf8");
+            const lines = content.split("\n").length;
+            l1Lines += lines;
+            if (l1Lines <= L1_LIMIT) {
+              genomeContent += `\n### ${file}\n${content}\n`;
+            } else {
+              genomeContent += `\n### ${file} [TRUNCATED]\n${content.split("\n").slice(0, 20).join("\n")}\n...\n`;
+            }
+          }
+        }
+
+        // L2: domain/ files
+        const domainDir = path.join(genomeDir, "domain");
+        if (fs.existsSync(domainDir)) {
+          let l2Lines = 0;
+          let l2Overflow = false;
+          const domainFiles = fs.readdirSync(domainDir).filter(f => f.endsWith(".md"));
+          for (const file of domainFiles) {
+            const filePath = path.join(domainDir, file);
+            const content = fs.readFileSync(filePath, "utf8");
+            const lines = content.split("\n").length;
+            l2Lines += lines;
+            if (!l2Overflow && l2Lines <= L2_LIMIT) {
+              genomeContent += `\n### domain/${file}\n${content}\n`;
+            } else {
+              l2Overflow = true;
+              const firstLine = content.split("\n").find(l => l.startsWith(">")) || content.split("\n")[0];
+              genomeContent += `\n### domain/${file} [summary]\n${firstLine}\n`;
+            }
+          }
+        }
+      }
+
+      // Read config (strict mode + language)
+      let strictMode = false;
+      let language = "";
+      const configPath = path.join(reapDir, "config.yml");
+      if (fs.existsSync(configPath)) {
+        const configContent = fs.readFileSync(configPath, "utf8");
+        const strictMatch = configContent.match(/^strict:\s*(.+)$/m);
+        if (strictMatch && strictMatch[1].trim() === "true") {
+          strictMode = true;
+        }
+        const langMatch = configContent.match(/^language:\s*(.+)$/m);
+        if (langMatch) {
+          language = langMatch[1].trim();
+        }
+      }
+
+      // Read current.yml
+      const currentPath = path.join(reapDir, "life", "current.yml");
+      let genStage = "none";
+      let generationContext = "No active Generation. Run `/reap.start` to start one.";
+
+      if (fs.existsSync(currentPath)) {
+        const content = fs.readFileSync(currentPath, "utf8").trim();
+        if (content) {
+          const idMatch = content.match(/^id:\s*(.+)$/m);
+          const goalMatch = content.match(/^goal:\s*(.+)$/m);
+          const stageMatch = content.match(/^stage:\s*(.+)$/m);
+          if (idMatch && goalMatch && stageMatch) {
+            genStage = stageMatch[1].trim();
+            generationContext = `Active Generation: ${idMatch[1].trim()} | Goal: ${goalMatch[1].trim()} | Stage: ${genStage}`;
+          }
+        }
+      }
+
+      // Map stage to command
+      const stageCommandMap = {
+        objective: "/reap.objective",
+        planning: "/reap.planning",
+        implementation: "/reap.implementation",
+        validation: "/reap.validation",
+        completion: "/reap.completion",
+      };
+      const nextCmd = stageCommandMap[genStage] || "/reap.start";
+
+      // Build strict mode section
+      let strictSection = "";
+      if (strictMode) {
+        if (genStage === "implementation") {
+          strictSection = "\n\n## Strict Mode (ACTIVE — SCOPED MODIFICATION ALLOWED)\n<HARD-GATE>\nStrict mode is enabled. Code modification is ALLOWED only within the scope of the current Generation's plan.\n- You MUST read `.reap/life/02-planning.md` before writing any code.\n- You may ONLY modify files and modules listed in the plan's task list.\n- Changes outside the plan's scope are BLOCKED.\n</HARD-GATE>";
+        } else if (genStage === "none") {
+          strictSection = "\n\n## Strict Mode (ACTIVE — CODE MODIFICATION BLOCKED)\n<HARD-GATE>\nStrict mode is enabled and there is NO active Generation.\nYou MUST NOT write, edit, or create any source code files.\nAllowed actions: reading files, analyzing code, answering questions, running commands.\nTo start coding, the user must first run `/reap.start` and advance to the implementation stage.\n</HARD-GATE>";
+        } else {
+          strictSection = `\n\n## Strict Mode (ACTIVE — CODE MODIFICATION BLOCKED)\n<HARD-GATE>\nStrict mode is enabled. Current stage is '${genStage}', which is NOT the implementation stage.\nYou MUST NOT write, edit, or create any source code files.\n</HARD-GATE>`;
+        }
+      }
+
+      // Detect genome staleness
+      let staleSection = "";
+      try {
+        const lastCommit = execSync(`git -C "${projectRoot}" log -1 --format="%H" -- ".reap/genome/" 2>/dev/null`, { encoding: "utf8" }).trim();
+        if (lastCommit) {
+          const commitsSince = parseInt(execSync(`git -C "${projectRoot}" rev-list --count "${lastCommit}..HEAD" 2>/dev/null`, { encoding: "utf8" }).trim(), 10);
+          if (commitsSince > 10) {
+            staleSection = `\n\n## Genome Staleness\nWARNING: Genome may be stale — ${commitsSince} commits since last Genome update. Consider running /reap.sync.`;
+          }
+        }
+      } catch { /* git not available or not a repo */ }
+
+      // Build language instruction
+      let langSection = "";
+      if (language) {
+        langSection = `\n\n## Language\nAlways respond in ${language}. Use ${language} for all explanations, comments, and communications with the user. Technical terms and code identifiers should remain in their original form.`;
+      }
+
+      // Build auto-update section
+      let updateSection = "";
+      if (autoUpdateMessage) {
+        updateSection = `\n\n## Auto-Update\n${autoUpdateMessage}. Tell the user: "${autoUpdateMessage}"`;
+      }
+
+      const context = `<REAP_WORKFLOW>\n${reapGuide}\n\n---\n\n## Genome (Project Knowledge)\n${genomeContent}\n\n---\n\n## Current State\n${generationContext}${staleSection}${strictSection}${updateSection}${langSection}\n\n## Rules\n1. ALL development work MUST follow the REAP lifecycle.\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 outside of the REAP lifecycle unless explicitly asked.\n6. Genome is the authoritative knowledge source.\n</REAP_WORKFLOW>`;
+
+      // Inject context into session via return value
+      return { systemPrompt: context };
+    },
+  };
+};

package/dist/templates/hooks/reap-guide.md

@@ -130,6 +130,10 @@ Only one of `command` or `prompt` should be set per entry.
 
 Hooks are executed by the AI agent.
 
+## Multi-Agent Support
+
+REAP supports multiple AI agents simultaneously through the AgentAdapter abstraction. Currently supported: **Claude Code** and **OpenCode**. Detected agents are listed in `.reap/config.yml` under the `agents` field (managed by `reap init` / `reap update`). Slash commands and session hooks are installed to each detected agent's configuration directory.
+
 ## Role Separation
 
 | Component | Role |

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

@@ -3,6 +3,15 @@
 # This script runs from the package directory but uses cwd to find the project's .reap/
 set -euo pipefail
 
+# Timing (node is guaranteed since REAP is an npm package)
+_reap_ms() { node -e 'process.stdout.write(String(Date.now()))'; }
+_reap_start_time=$(_reap_ms)
+_reap_log() {
+  local now=$(_reap_ms)
+  local elapsed=$(( now - _reap_start_time ))
+  echo "[REAP hook +${elapsed}ms] $1" >&2
+}
+
 # Script directory (package-internal) for guide file
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
 
@@ -13,17 +22,43 @@ CURRENT_YML="${REAP_DIR}/life/current.yml"
 GUIDE_FILE="${SCRIPT_DIR}/reap-guide.md"
 GENOME_DIR="${REAP_DIR}/genome"
 
+_reap_log "Starting..."
+
 # Check if this is a REAP project
 if [ ! -d "$REAP_DIR" ]; then
+  _reap_log "Not a REAP project, exiting"
   exit 0
 fi
 
+_reap_log "REAP project detected"
+
+_reap_log "Checking auto-update..."
+CONFIG_FILE="${REAP_DIR}/config.yml"
+auto_update_message=""
+if [ -f "$CONFIG_FILE" ]; then
+  auto_update=$(grep "^autoUpdate:" "$CONFIG_FILE" 2>/dev/null | sed 's/^autoUpdate: *//' | tr -d ' ' || true)
+  if [ "$auto_update" = "true" ]; then
+    installed=$(reap --version 2>/dev/null || echo "")
+    latest=$(npm view @c-d-cc/reap version 2>/dev/null || echo "")
+    if [ -n "$installed" ] && [ -n "$latest" ] && [ "$installed" != "$latest" ]; then
+      if npm update -g @c-d-cc/reap >/dev/null 2>&1; then
+        reap update >/dev/null 2>&1 || true
+        auto_update_message="REAP auto-updated: v${installed} → v${latest}"
+      fi
+    fi
+  fi
+fi
+
+_reap_log "Auto-update check done"
+
 # Read REAP guide
+_reap_log "Loading REAP guide..."
 reap_guide=""
 if [ -f "$GUIDE_FILE" ]; then
   reap_guide=$(cat "$GUIDE_FILE")
 fi
 
+_reap_log "Loading Genome..."
 # Read Genome files with tiered loading
 # L1 (~500 lines max): principles.md, conventions.md, constraints.md — always full load
 # L2 (~200 lines max): domain/*.md — full load if within budget, otherwise title+summary only
@@ -74,7 +109,7 @@ genome_stale_warning=""
 if command -v git &>/dev/null && [ -d "$PROJECT_ROOT/.git" ]; then
   last_genome_commit=$(git -C "$PROJECT_ROOT" log -1 --format="%H" -- ".reap/genome/" 2>/dev/null || echo "")
   if [ -n "$last_genome_commit" ]; then
-    commits_since=$(git -C "$PROJECT_ROOT" rev-list --count "${last_genome_commit}..HEAD" 2>/dev/null || echo "0")
+    commits_since=$(git -C "$PROJECT_ROOT" rev-list --count "${last_genome_commit}..HEAD" -- src/ tests/ package.json tsconfig.json scripts/ 2>/dev/null || echo "0")
     if [ "$commits_since" -gt 10 ]; then
       genome_stale_warning="WARNING: Genome may be stale — ${commits_since} commits since last Genome update. Consider running /reap.sync to synchronize."
     fi
@@ -120,13 +155,7 @@ esac
 
 # Escape for JSON
 escape_for_json() {
-  local s="$1"
-  s="${s//\\/\\\\}"
-  s="${s//\"/\\\"}"
-  s="${s//$'\n'/\\n}"
-  s="${s//$'\r'/\\r}"
-  s="${s//$'\t'/\\t}"
-  printf '%s' "$s"
+  printf '%s' "$1" | node -e 'let d="";process.stdin.on("data",c=>d+=c);process.stdin.on("end",()=>process.stdout.write(JSON.stringify(d).slice(1,-1)))'
 }
 
 # Build strict mode section
@@ -147,9 +176,17 @@ if [ -n "$genome_stale_warning" ]; then
   stale_section="\n\n## Genome Staleness\n${genome_stale_warning}\nIf the user wants to proceed without syncing, ask: \"The Genome may be stale. Would you like to run /reap.sync now, or do it later?\" and respect their choice."
 fi
 
-reap_context="<REAP_WORKFLOW>\n${reap_guide}\n\n---\n\n## Genome (Project Knowledge — treat as authoritative source of truth)\n${genome_content}\n\n---\n\n## Current State\n${generation_context}${stale_section}${strict_section}\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 \`${next_cmd}\` 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>"
+# Build auto-update section
+update_section=""
+if [ -n "$auto_update_message" ]; then
+  update_section="\n\n## Auto-Update\n${auto_update_message}. Tell the user: \"${auto_update_message}\""
+fi
+
+reap_context="<REAP_WORKFLOW>\n${reap_guide}\n\n---\n\n## Genome (Project Knowledge — treat as authoritative source of truth)\n${genome_content}\n\n---\n\n## Current State\n${generation_context}${stale_section}${strict_section}${update_section}\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 \`${next_cmd}\` 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>"
 
+_reap_log "Building context..."
 escaped_context=$(escape_for_json "$reap_context")
+_reap_log "Done. Outputting JSON."
 
 cat <<EOF
 {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@c-d-cc/reap",
-  "version": "0.1.3",
+  "version": "0.2.2",
   "description": "Recursive Evolutionary Autonomous Pipeline — AI and humans evolve software across generations",
   "type": "module",
   "license": "MIT",
-  "author": "HiChoi <hichoi@c-d.cc> (C to D)",
+  "author": "HyeonIL Choi <hichoi@c-d.cc> (C to D)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/c-d-cc/reap.git"