@c-d-cc/reap 0.11.0 → 0.12.0

package/README.ja.md

@@ -218,8 +218,8 @@ Machine A:
 | コマンド | 説明 |
 |----------|------|
 | `reap init <name>` | プロジェクト初期化。`.reap/`構造を作成 |
-| `reap status` | 現在のGeneration状態を確認（バージョン + 最新状況表示） |
-| `reap update` | コマンド/テンプレート/hookを最新バージョンに同期。`~/.claude/commands/`のレガシーを自動クリーンアップ |
+| `reap status` | 現在のGeneration状態を確認 |
+| `reap update` | コマンド/テンプレート/hookを最新バージョンに同期 |
 | `reap fix` | `.reap/`構造の診断と修復 |
 | `reap help` | CLIコマンド + スラッシュコマンド + ワークフロー概要を出力（バージョン + 最新状況表示） |
 | `reap run <cmd>` | スラッシュコマンドのスクリプトを直接実行（1行`.md`ラッパーが内部的に使用） |
@@ -251,6 +251,25 @@ autoSubagent: true    # デフォルト: true
 
 Subagentは完全なコンテキストを受け取り、すべてのステージを自律的に実行します。本当にブロックされた場合のみユーザーに確認を求めます。
 
+### エラー時の自動Issue報告
+
+`reap run`の実行中に予期しないエラーが発生した場合、`gh issue create`を通じてGitHub Issueを自動作成できます：
+
+```yaml
+# .reap/config.yml
+autoIssueReport: true    # デフォルト: true（gh CLIがある場合）
+```
+
+### AI Migration Agent
+
+`reap update`の実行時にプロジェクトと最新REAPバージョン間の構造的な差分（不足しているconfigフィールド、古いテンプレートなど）が検出されると、AI支援のマイグレーションプロンプトが表示されます。エージェントが差分を分析し、対話的に変更を適用するため、手動マイグレーションは不要です。
+
+`reap init`ではすべてのconfigフィールドを明示的に宣言し、`reap update`時に不足しているフィールドは自動的に補完されます。
+
+### CLAUDE.md連携
+
+`reap init`と`reap update`の実行時に、`.claude/CLAUDE.md`にREAP管理セクションを追加し、Claude Codeセッションに必要なプロジェクトコンテキストを提供します。
+
 ### スラッシュコマンド [↗](https://reap.cc/docs/command-reference)
 
 スラッシュコマンドが`.claude/commands/`にインストールされ、ワークフロー全体を駆動します：
@@ -270,6 +289,7 @@ Subagentは完全なコンテキストを受け取り、すべてのステージ
 | `/reap.sync` | GenomeとEnvironmentを同時に同期 |
 | `/reap.sync.genome` | ソースコードベースでGenomeを最新化 |
 | `/reap.sync.environment` | 外部環境依存関係の発見と文書化 |
+| `/reap.config` | 現在のプロジェクト設定を表示 |
 | `/reap.report` | REAPプロジェクトにバグ/フィードバックを報告（プライバシー保護） |
 | `/reap.help` | 24+トピックのcontextual AIヘルプ |
 | `/reap.update` | REAPパッケージのアップグレード + コマンド/テンプレート/hook同期 |
@@ -403,7 +423,7 @@ my-project/
 ~/.claude/
 └── settings.json                 # SessionStart hookの登録
 
-.claude/commands/                 # プロジェクトレベル（セッション開始時にsymlink）
+.claude/commands/                 # プロジェクトレベルのスラッシュコマンド
 └── reap.*.md                     # アクティブなスラッシュコマンド（`reap run <cmd>`を呼び出し）
 ```
 

package/README.ko.md

@@ -218,8 +218,8 @@ Machine A:
 | 명령어 | 설명 |
 |--------|------|
 | `reap init <name>` | 프로젝트 초기화. `.reap/` 구조 생성 |
-| `reap status` | 현재 Generation 상태 확인 (버전 + 최신 여부 표시) |
-| `reap update` | 커맨드/템플릿/훅을 최신 버전으로 동기화. `~/.claude/commands/` 레거시 자동 정리 |
+| `reap status` | 현재 Generation 상태 확인 |
+| `reap update` | 커맨드/템플릿/훅을 최신 버전으로 동기화 |
 | `reap fix` | `.reap/` 구조 진단 및 복구 |
 | `reap help` | CLI 명령어 + 슬래시 커맨드 + 워크플로우 요약 출력 (버전 + 최신 여부 표시) |
 | `reap run <cmd>` | 슬래시 커맨드의 스크립트를 직접 실행 (1줄 `.md` wrapper가 내부적으로 사용) |
@@ -251,6 +251,25 @@ autoSubagent: true    # 기본값: true
 
 Subagent는 전체 컨텍스트를 받아 모든 stage를 자율적으로 실행하며, 정말로 막혔을 때만 사용자에게 확인을 요청합니다.
 
+### 에러 시 자동 이슈 리포트
+
+`reap run` 실행 중 예상치 못한 에러가 발생하면, `gh issue create`를 통해 GitHub Issue를 자동으로 생성할 수 있습니다:
+
+```yaml
+# .reap/config.yml
+autoIssueReport: true    # 기본값: true (gh CLI가 있을 때)
+```
+
+### AI Migration Agent
+
+`reap update` 실행 시 프로젝트와 최신 REAP 버전 사이의 구조적 차이(누락된 config 필드, 오래된 템플릿 등)가 감지되면, AI 기반 마이그레이션 프롬프트를 제공합니다. 에이전트가 차이를 분석하고 대화형으로 변경을 적용하므로 수동 마이그레이션이 필요 없습니다.
+
+`reap init`도 모든 config 필드를 명시적으로 선언하며, `reap update` 시 누락된 필드는 자동으로 채워집니다.
+
+### CLAUDE.md 연동
+
+`reap init`과 `reap update` 시 `.claude/CLAUDE.md`에 REAP 관리 섹션을 추가하여 Claude Code 세션에 필요한 프로젝트 컨텍스트를 제공합니다.
+
 ### Slash Commands
 
 Slash command가 `.claude/commands/`에 설치되어 전체 워크플로우를 구동합니다:
@@ -270,6 +289,7 @@ Slash command가 `.claude/commands/`에 설치되어 전체 워크플로우를
 | `/reap.sync` | Genome + Environment 동시 동기화 |
 | `/reap.sync.genome` | 소스 코드 기반 Genome 최신화 |
 | `/reap.sync.environment` | 외부 환경 의존성 탐색 및 문서화 |
+| `/reap.config` | 현재 프로젝트 설정 표시 |
 | `/reap.report` | REAP 프로젝트에 버그/피드백 보고 (개인정보 보호) |
 | `/reap.help` | 24+ 주제의 contextual AI 도움말 |
 | `/reap.update` | REAP 패키지 업그레이드 + 커맨드/템플릿/훅 동기화 |
@@ -403,7 +423,7 @@ my-project/
 ~/.claude/
 └── settings.json                 # SessionStart hook 등록
 
-.claude/commands/                 # 프로젝트 레벨 (세션 시작 시 symlink)
+.claude/commands/                 # 프로젝트 레벨 슬래시 커맨드
 └── reap.*.md                     # 활성 슬래시 커맨드 (`reap run <cmd>` 호출)
 ```
 

package/README.md

@@ -250,6 +250,25 @@ autoSubagent: true    # default: true
 
 The subagent receives the full context and runs autonomously through all stages, only surfacing when genuinely blocked.
 
+### Auto Issue Report
+
+When an unexpected error occurs during `reap run`, REAP can automatically create a GitHub Issue via `gh issue create`. This is controlled by:
+
+```yaml
+# .reap/config.yml
+autoIssueReport: true    # default: true (when gh CLI is available)
+```
+
+### AI Migration Agent
+
+When `reap update` detects structural gaps between your project and the latest REAP version (e.g., missing config fields, outdated templates), it offers an AI-assisted migration prompt. The agent analyzes the differences and applies changes interactively — no manual migration needed.
+
+`reap init` also ensures all config fields are explicitly declared, and `reap update` backfills any missing fields automatically.
+
+### CLAUDE.md Integration
+
+During `reap init` and `reap update`, REAP adds a managed section to `.claude/CLAUDE.md` containing essential project context for Claude Code sessions.
+
 ### Slash Commands [↗](https://reap.cc/docs/command-reference)
 
 Slash commands are installed in `.claude/commands/` and drive the entire workflow:
@@ -269,6 +288,7 @@ Slash commands are installed in `.claude/commands/` and drive the entire workflo
 | `/reap.sync` | Synchronize both Genome and Environment |
 | `/reap.sync.genome` | Synchronize Genome with current source code |
 | `/reap.sync.environment` | Discover and document external environment dependencies |
+| `/reap.config` | Display current project configuration |
 | `/reap.report` | Report a bug or feedback to the REAP project (privacy-safe) |
 | `/reap.help` | Contextual AI help with 24+ topics |
 | `/reap.update` | Upgrade REAP package + sync commands/templates/hooks |

package/README.zh-CN.md

@@ -218,8 +218,8 @@ Machine A:
 | 命令 | 说明 |
 |------|------|
 | `reap init <name>` | 初始化项目。创建`.reap/`结构 |
-| `reap status` | 查看当前Generation状态（显示版本 + 最新状态） |
-| `reap update` | 将命令/模板/hook同步到最新版本。自动清理`~/.claude/commands/`旧版文件 |
+| `reap status` | 查看当前Generation状态 |
+| `reap update` | 将命令/模板/hook同步到最新版本 |
 | `reap fix` | 诊断和修复`.reap/`结构 |
 | `reap help` | 输出CLI命令 + 斜杠命令 + 工作流摘要（显示版本 + 最新状态） |
 | `reap run <cmd>` | 直接执行斜杠命令的脚本（由1行`.md` wrapper内部调用） |
@@ -251,6 +251,25 @@ autoSubagent: true    # 默认值: true
 
 Subagent接收完整上下文后自主执行所有阶段，仅在确实遇到阻碍时才向用户确认。
 
+### 错误时自动Issue报告
+
+当`reap run`执行中发生意外错误时，可通过`gh issue create`自动创建GitHub Issue：
+
+```yaml
+# .reap/config.yml
+autoIssueReport: true    # 默认值: true（检测到gh CLI时）
+```
+
+### AI Migration Agent
+
+`reap update`执行时，如果检测到项目与最新REAP版本之间的结构性差异（缺失的config字段、过时的模板等），会提供AI辅助的迁移提示。代理分析差异并交互式地应用变更，无需手动迁移。
+
+`reap init`会明确声明所有config字段，`reap update`时自动补全缺失字段。
+
+### CLAUDE.md集成
+
+`reap init`和`reap update`执行时，会在`.claude/CLAUDE.md`中添加REAP管理段落，为Claude Code会话提供必要的项目上下文。
+
 ### 斜杠命令 [↗](https://reap.cc/docs/command-reference)
 
 斜杠命令安装在`.claude/commands/`中，驱动整个工作流：
@@ -270,6 +289,7 @@ Subagent接收完整上下文后自主执行所有阶段，仅在确实遇到阻
 | `/reap.sync` | 同时同步Genome和Environment |
 | `/reap.sync.genome` | 基于源代码同步Genome |
 | `/reap.sync.environment` | 发现和记录外部环境依赖 |
+| `/reap.config` | 显示当前项目配置 |
 | `/reap.report` | 向REAP项目报告bug/反馈（隐私保护） |
 | `/reap.help` | 24+主题的上下文AI帮助 |
 | `/reap.update` | 升级REAP包 + 同步命令/模板/hook |
@@ -403,7 +423,7 @@ my-project/
 ~/.claude/
 └── settings.json                 # SessionStart hook注册
 
-.claude/commands/                 # 项目级别（会话启动时symlink）
+.claude/commands/                 # 项目级斜杠命令
 └── reap.*.md                     # 活跃斜杠命令（调用`reap run <cmd>`）
 ```
 

package/dist/cli.js

@@ -9020,6 +9020,26 @@ class ConfigManager {
   static resolveAutoSubagent(value) {
     return value !== false;
   }
+  static async backfill(paths) {
+    const config = await ConfigManager.read(paths);
+    const added = [];
+    const defaults = {
+      strict: false,
+      autoUpdate: true,
+      autoSubagent: true,
+      autoIssueReport: false
+    };
+    for (const [key, defaultValue] of Object.entries(defaults)) {
+      if (config[key] === undefined) {
+        config[key] = defaultValue;
+        added.push(key);
+      }
+    }
+    if (added.length > 0) {
+      await ConfigManager.write(paths, config);
+    }
+    return { added };
+  }
   static resolveStrict(strict) {
     if (strict === undefined || strict === false) {
       return { edit: false, merge: false };
@@ -10048,7 +10068,14 @@ class GenerationManager {
     const lifeEntries = await readdir7(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-        await rename(join8(this.paths.life, entry), join8(genDir, entry));
+        const srcPath = join8(this.paths.life, entry);
+        const destPath = join8(genDir, entry);
+        let content = await readTextFile(srcPath);
+        if (content && content.startsWith("# REAP MANAGED")) {
+          content = content.replace(/^# REAP MANAGED[^\n]*\n/, "");
+        }
+        await writeTextFile(destPath, content ?? "");
+        await unlink3(srcPath);
       }
     }
     const backlogDir = join8(genDir, "backlog");
@@ -10271,7 +10298,7 @@ async function parseHookMeta(filePath, ext) {
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (fmMatch) {
       try {
-        const fm = import_yaml7.default.parse(fmMatch[1]) ?? {};
+        const fm = import_yaml8.default.parse(fmMatch[1]) ?? {};
         return {
           condition: String(fm.condition ?? "always"),
           order: Number(fm.order ?? 50)
@@ -10346,10 +10373,10 @@ async function executeMdHook(hook, event, hooksDir) {
     content: body
   };
 }
-var import_yaml7;
+var import_yaml8;
 var init_hook_engine = __esm(() => {
   init_fs();
-  import_yaml7 = __toESM(require_dist(), 1);
+  import_yaml8 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/next.ts
@@ -10571,7 +10598,7 @@ async function markBacklogConsumed(backlogDir, filename, genId) {
   frontmatter.consumedBy = genId;
   delete frontmatter.consumed;
   const newContent = `---
-${import_yaml8.default.stringify(frontmatter).trim()}
+${import_yaml9.default.stringify(frontmatter).trim()}
 ---
 ${body}`;
   await writeTextFile(filePath, newContent);
@@ -10595,7 +10622,7 @@ async function revertBacklogConsumed(backlogDir, genId) {
       frontmatter.status = "pending";
       delete frontmatter.consumedBy;
       const newContent = `---
-${import_yaml8.default.stringify(frontmatter).trim()}
+${import_yaml9.default.stringify(frontmatter).trim()}
 ---
 ${body}`;
       await writeTextFile(filePath, newContent);
@@ -10607,15 +10634,15 @@ function parseFrontmatter2(content) {
   if (!match)
     return { frontmatter: {}, body: content };
   try {
-    return { frontmatter: import_yaml8.default.parse(match[1]) ?? {}, body: match[2] };
+    return { frontmatter: import_yaml9.default.parse(match[1]) ?? {}, body: match[2] };
   } catch {
     return { frontmatter: {}, body: content };
   }
 }
-var import_yaml8;
+var import_yaml9;
 var init_backlog = __esm(() => {
   init_fs();
-  import_yaml8 = __toESM(require_dist(), 1);
+  import_yaml9 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/start.ts
@@ -11571,11 +11598,10 @@ function buildSubagentPrompt(paths, state, genomeSummaries, backlogSummary) {
   lines.push("   - `completion` -> `/reap.completion`");
   lines.push("3. Write the required artifact BEFORE completing the stage.");
   lines.push("4. Run the stage complete phase if applicable (e.g., `reap run <stage> --phase complete`).");
-  lines.push("5. Run `/reap.next` to advance to the next stage.");
-  lines.push("6. Repeat until `completion` stage is done.");
+  lines.push("5. If current stage is NOT `completion`: run `/reap.next` to advance, then go to step 1.");
+  lines.push("6. If current stage IS `completion`: `/reap.completion` auto-archives after genome phase. Done.");
   lines.push("");
-  lines.push("### Completion");
-  lines.push("- Run `/reap.completion` which handles: retrospective, genome updates, backlog consume, and archive.");
+  lines.push("Note: `/reap.next` is a transition command, NOT a lifecycle stage.");
   lines.push("");
   lines.push("## Project");
   lines.push(`- Path: ${paths.projectRoot}`);
@@ -11950,77 +11976,226 @@ var exports_help = {};
 __export(exports_help, {
   execute: () => execute15
 });
-async function execute15(paths, phase) {
+import { join as join24 } from "path";
+function detectLanguage(configContent) {
+  const raw = configContent?.match(/language:\s*(\S+)/)?.[1] ?? null;
+  if (raw && raw in LANGUAGE_ALIASES)
+    return LANGUAGE_ALIASES[raw];
+  return raw;
+}
+function isSupportedLanguage(lang) {
+  return lang !== null && SUPPORTED_LANGUAGES.includes(lang);
+}
+function buildCommandTable(lang) {
+  return [
+    "| Command | Description |",
+    "|---------|-------------|",
+    ...Object.entries(COMMAND_DESCRIPTIONS).map(([cmd, descs]) => `| \`${cmd}\` | ${descs[lang]} |`)
+  ];
+}
+function buildLines(versionDisplay, lang, stateDisplay) {
+  return [
+    versionDisplay,
+    REAP_INTRO[lang],
+    "",
+    stateDisplay,
+    "",
+    ...buildCommandTable(lang),
+    "",
+    TOPICS_LINE[lang],
+    "Usage: REAP_HELP_TOPIC=<topic> reap run help",
+    CONFIG_LINE[lang]
+  ];
+}
+async function execute15(paths) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
   const configContent = await readTextFile(paths.config);
-  const strict = configContent?.match(/strict:\s*(true|false)/)?.[1] === "true" ? "on" : "off";
-  const autoUpdate = configContent?.match(/autoUpdate:\s*(true|false)/)?.[1] === "true" ? "on" : "off";
-  const language = configContent?.match(/language:\s*(\w+)/)?.[1] ?? "ko";
   const configVersion = configContent?.match(/version:\s*([\d.]+)/)?.[1] ?? "0.0.0";
-  const skipCheck = autoUpdate !== "on";
-  const versionDisplay = formatVersionLine(configVersion, skipCheck);
+  const autoUpdate = configContent?.match(/autoUpdate:\s*(true|false)/)?.[1] === "true";
+  const versionDisplay = formatVersionLine(configVersion, !autoUpdate);
+  const rawLang = detectLanguage(configContent);
+  const supported = isSupportedLanguage(rawLang);
+  const lang = supported ? rawLang : "en";
   const topic = process.env.REAP_HELP_TOPIC;
-  emitOutput({
-    status: "prompt",
-    command: "help",
-    phase: "respond",
-    completed: ["gate", "context-collect"],
-    context: {
-      hasActiveGeneration: !!(state && state.id),
-      generationId: state?.id,
-      goal: state?.goal,
-      stage: state?.stage,
-      version: configVersion,
-      versionDisplay,
-      config: { strict, autoUpdate, language },
-      topic: topic || null
-    },
-    prompt: [
-      "## Help — Contextual Help",
-      "",
-      topic ? `Topic requested: "${topic}". Look up the topic from the known topics list below.` : "No specific topic. Show the basic help overview.",
-      "",
-      "### Basic Help (no topic)",
-      "Show REAP overview, current state, and command table.",
-      state?.id ? `> Current: **${state.id}** — ${state.goal} (Stage: ${state.stage})` : "> No active Generation -> `/reap.start` or `/reap.evolve`",
-      "",
-      "### Command Table",
-      "| Command | Description |",
-      "|---------|-------------|",
-      "| `/reap.start` | 새 Generation을 시작하고 goal을 설정 |",
-      "| `/reap.evolve` | 전체 lifecycle을 자율적으로 실행 |",
-      "| `/reap.objective` | 목표, 요구사항, 완료 기준을 정의 |",
-      "| `/reap.planning` | 태스크를 분해하고 구현 계획을 수립 |",
-      "| `/reap.implementation` | 계획에 따라 코드를 구현 |",
-      "| `/reap.validation` | 테스트 실행, 완료 기준 충족 여부를 검증 |",
-      "| `/reap.completion` | 회고, Genome 변경 반영, Generation 마무리 |",
-      "| `/reap.next` | 다음 stage로 전진 |",
-      "| `/reap.back` | 이전 stage로 회귀 |",
-      "| `/reap.status` | 프로젝트 상태 표시 |",
-      "| `/reap.sync` | Genome/Environment 동기화 |",
-      "| `/reap.update` | REAP 최신 버전 확인 및 업그레이드 |",
-      "| `/reap.help` | 도움말 |",
-      "| `/reap.push` | REAP 상태 검증 + git push |",
-      "| `/reap.report` | 버그/이슈 리포트 |",
-      "",
-      `${versionDisplay} | Strict: ${strict} | Auto-Update: ${autoUpdate} | Language: ${language}`,
-      "",
-      "### Topic Help",
-      "If a topic is provided, look up from these known topics:",
-      "- workflow/lifecycle, genome, backlog, strict, agents, hooks, config, evolve, regression, minor-fix, compression, merge/collaboration, author",
-      "- Command topics: start, objective, planning, implementation, validation, completion, next, back, sync, status, update, help, pull, push, merge.*",
-      "",
-      "For command-name topics: read `reap.{name}.md` from `~/.reap/commands/` or the template commands directory, then explain.",
-      "If the topic is NOT in the list: respond 'Unknown topic'."
-    ].join(`
+  const stateDisplay = state?.id ? `Active: **${state.id}** — ${state.goal} (Stage: ${state.stage})` : "No active Generation → `/reap.start` or `/reap.evolve`";
+  const lines = buildLines(versionDisplay, lang, stateDisplay);
+  if (topic) {
+    const guidePath = join24(ReapPaths.packageHooksDir, "reap-guide.md");
+    const reapGuide = await readTextFile(guidePath) ?? "";
+    emitOutput({
+      status: "prompt",
+      command: "help",
+      phase: "respond",
+      completed: ["gate", "context-collect"],
+      context: { topic, reapGuide },
+      message: lines.join(`
+`),
+      prompt: [
+        `Topic requested: "${topic}".`,
+        "Look up from known topics: workflow/lifecycle, genome, backlog, strict, agents, hooks, config, evolve, regression, minor-fix, compression, merge/collaboration.",
+        "Command topics: read `reap.{name}.md` from `~/.reap/commands/` or template commands directory, then explain.",
+        "If the topic is NOT known: respond 'Unknown topic'.",
+        "Use the reapGuide content in context as the primary knowledge source for explaining REAP topics."
+      ].join(`
 `)
-  });
+    });
+  } else if (!supported && rawLang !== null) {
+    emitOutput({
+      status: "prompt",
+      command: "help",
+      phase: "respond",
+      completed: ["gate", "context-collect"],
+      message: lines.join(`
+`),
+      prompt: [
+        `The user's configured language is "${rawLang}", which is not natively supported.`,
+        "Below is the help message in English. Translate the descriptions and intro text to the target language.",
+        "Keep command names (e.g. /reap.start) and topic names in English.",
+        `Target language: ${rawLang}`
+      ].join(`
+`)
+    });
+  } else {
+    emitOutput({
+      status: "ok",
+      command: "help",
+      phase: "respond",
+      completed: ["gate", "context-collect"],
+      message: lines.join(`
+`)
+    });
+  }
 }
+var SUPPORTED_LANGUAGES, REAP_INTRO, COMMAND_DESCRIPTIONS, TOPICS_LINE, CONFIG_LINE, LANGUAGE_ALIASES;
 var init_help = __esm(() => {
+  init_paths();
   init_generation();
   init_fs();
   init_version();
+  SUPPORTED_LANGUAGES = ["en", "ko", "ja", "zh-CN"];
+  REAP_INTRO = {
+    en: "REAP (Recursive Evolutionary Autonomous Pipeline) — A development pipeline that evolves software generation by generation through AI+Human collaboration.",
+    ko: "REAP (Recursive Evolutionary Autonomous Pipeline) — AI+Human 협업으로 소프트웨어를 세대 단위로 진화시키는 개발 파이프라인.",
+    ja: "REAP (Recursive Evolutionary Autonomous Pipeline) — AI+Humanの協業でソフトウェアを世代単位で進化させる開発パイプライン。",
+    "zh-CN": "REAP (Recursive Evolutionary Autonomous Pipeline) — 通过AI+Human协作，以世代为单位进化软件的开发管道。"
+  };
+  COMMAND_DESCRIPTIONS = {
+    "/reap.start": {
+      en: "Start a new Generation and set the goal",
+      ko: "새 Generation을 시작하고 goal을 설정",
+      ja: "新しいGenerationを開始し、ゴールを設定",
+      "zh-CN": "开始新的Generation并设定目标"
+    },
+    "/reap.evolve": {
+      en: "Run the entire lifecycle autonomously",
+      ko: "전체 lifecycle을 자율적으로 실행",
+      ja: "ライフサイクル全体を自律的に実行",
+      "zh-CN": "自主运行整个生命周期"
+    },
+    "/reap.objective": {
+      en: "Define goals, requirements, and completion criteria",
+      ko: "목표, 요구사항, 완료 기준을 정의",
+      ja: "目標、要件、完了基準を定義",
+      "zh-CN": "定义目标、需求和完成标准"
+    },
+    "/reap.planning": {
+      en: "Decompose tasks and create an implementation plan",
+      ko: "태스크를 분해하고 구현 계획을 수립",
+      ja: "タスクを分解し、実装計画を策定",
+      "zh-CN": "分解任务并制定实施计划"
+    },
+    "/reap.implementation": {
+      en: "Implement code according to the plan",
+      ko: "계획에 따라 코드를 구현",
+      ja: "計画に従ってコードを実装",
+      "zh-CN": "按照计划实现代码"
+    },
+    "/reap.validation": {
+      en: "Run tests and verify completion criteria are met",
+      ko: "테스트 실행, 완료 기준 충족 여부를 검증",
+      ja: "テストを実行し、完了基準の充足を検証",
+      "zh-CN": "运行测试，验证是否满足完成标准"
+    },
+    "/reap.completion": {
+      en: "Retrospective, apply Genome changes, finalize Generation",
+      ko: "회고, Genome 변경 반영, Generation 마무리",
+      ja: "振り返り、Genome変更を反映、Generationを完了",
+      "zh-CN": "回顾，应用Genome变更，完成Generation"
+    },
+    "/reap.next": {
+      en: "Advance to the next stage",
+      ko: "다음 stage로 전진",
+      ja: "次のステージへ進む",
+      "zh-CN": "进入下一阶段"
+    },
+    "/reap.back": {
+      en: "Return to the previous stage",
+      ko: "이전 stage로 회귀",
+      ja: "前のステージへ戻る",
+      "zh-CN": "返回上一阶段"
+    },
+    "/reap.status": {
+      en: "Show project status",
+      ko: "프로젝트 상태 표시",
+      ja: "プロジェクトの状態を表示",
+      "zh-CN": "显示项目状态"
+    },
+    "/reap.config": {
+      en: "Show current project settings",
+      ko: "현재 프로젝트 설정 표시",
+      ja: "現在のプロジェクト設定を表示",
+      "zh-CN": "显示当前项目设置"
+    },
+    "/reap.sync": {
+      en: "Synchronize Genome/Environment",
+      ko: "Genome/Environment 동기화",
+      ja: "Genome/Environmentを同期",
+      "zh-CN": "同步Genome/Environment"
+    },
+    "/reap.update": {
+      en: "Check for latest REAP version and upgrade",
+      ko: "REAP 최신 버전 확인 및 업그레이드",
+      ja: "REAP最新バージョンの確認とアップグレード",
+      "zh-CN": "检查REAP最新版本并升级"
+    },
+    "/reap.help": {
+      en: "Help",
+      ko: "도움말",
+      ja: "ヘルプ",
+      "zh-CN": "帮助"
+    },
+    "/reap.push": {
+      en: "Validate REAP state + git push",
+      ko: "REAP 상태 검증 + git push",
+      ja: "REAP状態検証 + git push",
+      "zh-CN": "验证REAP状态 + git push"
+    },
+    "/reap.report": {
+      en: "Bug/issue report",
+      ko: "버그/이슈 리포트",
+      ja: "バグ/イシューレポート",
+      "zh-CN": "Bug/问题报告"
+    }
+  };
+  TOPICS_LINE = {
+    en: "Topics: workflow, lifecycle, genome, backlog, strict, agents, hooks, config, evolve, regression, minor-fix, compression, merge, collaboration, start, objective, planning, implementation, validation, completion, next, back, sync, status, update, help, pull, push, abort, report",
+    ko: "Topics: workflow, lifecycle, genome, backlog, strict, agents, hooks, config, evolve, regression, minor-fix, compression, merge, collaboration, start, objective, planning, implementation, validation, completion, next, back, sync, status, update, help, pull, push, abort, report",
+    ja: "Topics: workflow, lifecycle, genome, backlog, strict, agents, hooks, config, evolve, regression, minor-fix, compression, merge, collaboration, start, objective, planning, implementation, validation, completion, next, back, sync, status, update, help, pull, push, abort, report",
+    "zh-CN": "Topics: workflow, lifecycle, genome, backlog, strict, agents, hooks, config, evolve, regression, minor-fix, compression, merge, collaboration, start, objective, planning, implementation, validation, completion, next, back, sync, status, update, help, pull, push, abort, report"
+  };
+  CONFIG_LINE = {
+    en: "Settings: /reap.config",
+    ko: "설정 확인: /reap.config",
+    ja: "設定確認: /reap.config",
+    "zh-CN": "查看设置: /reap.config"
+  };
+  LANGUAGE_ALIASES = {
+    korean: "ko",
+    english: "en",
+    japanese: "ja",
+    chinese: "zh-CN"
+  };
 });
 
 // src/cli/commands/run/report.ts
@@ -12031,12 +12206,7 @@ __export(exports_report, {
 async function execute16(paths, phase) {
   const gm = new GenerationManager(paths);
   const state = await gm.current();
-  const configContent = await readTextFile(paths.config);
   if (!phase || phase === "collect") {
-    const autoIssueReport = configContent?.match(/autoIssueReport:\s*false/);
-    if (autoIssueReport) {
-      emitError("report", "Issue reporting is disabled. Set `autoIssueReport: true` in .reap/config.yml to enable.");
-    }
     emitOutput({
       status: "prompt",
       command: "report",
@@ -12088,7 +12258,6 @@ async function execute16(paths, phase) {
 }
 var init_report = __esm(() => {
   init_generation();
-  init_fs();
 });
 
 // src/core/merge.ts
@@ -12158,7 +12327,7 @@ var init_merge = __esm(() => {
 
 // src/core/merge-generation.ts
 import { readdir as readdir17, mkdir as mkdir8, rename as rename3 } from "fs/promises";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 class MergeGenerationManager {
   paths;
@@ -12169,7 +12338,7 @@ class MergeGenerationManager {
     const content = await readTextFile(this.paths.currentYml);
     if (content === null || !content.trim())
       return null;
-    const state = import_yaml9.default.parse(content);
+    const state = import_yaml10.default.parse(content);
     if (!state.type)
       state.type = "normal";
     if (!state.parents)
@@ -12202,7 +12371,7 @@ class MergeGenerationManager {
       genomeHash,
       commonAncestor: commonAncestor ?? undefined
     };
-    await writeTextFile(this.paths.currentYml, import_yaml9.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
     return state;
   }
   async createFromBranch(targetBranch, projectRoot) {
@@ -12246,7 +12415,7 @@ class MergeGenerationManager {
       genomeHash,
       commonAncestor: commonAncestor ?? undefined
     };
-    await writeTextFile(this.paths.currentYml, import_yaml9.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
     return { state, report };
   }
   async resolveLatestGenId(branch, cwd) {
@@ -12271,7 +12440,7 @@ class MergeGenerationManager {
       const content = gitShow(ref, metaFile, cwd);
       if (content) {
         try {
-          const meta = import_yaml9.default.parse(content);
+          const meta = import_yaml10.default.parse(content);
           if (meta?.id)
             metas.push(meta);
         } catch {}
@@ -12318,7 +12487,7 @@ class MergeGenerationManager {
     if (!state.timeline)
       state.timeline = [];
     state.timeline.push({ stage: next, at: new Date().toISOString() });
-    await writeTextFile(this.paths.currentYml, import_yaml9.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
     return state;
   }
   async complete() {
@@ -12344,19 +12513,19 @@ class MergeGenerationManager {
       startedAt: state.startedAt,
       completedAt: now
     };
-    await writeTextFile(join24(genDir, "meta.yml"), import_yaml9.default.stringify(meta));
+    await writeTextFile(join25(genDir, "meta.yml"), import_yaml10.default.stringify(meta));
     const lifeEntries = await readdir17(this.paths.life);
     for (const entry of lifeEntries) {
       if (/^\d{2}-[a-z]+(?:-[a-z]+)*\.md$/.test(entry)) {
-        await rename3(join24(this.paths.life, entry), join24(genDir, entry));
+        await rename3(join25(this.paths.life, entry), join25(genDir, entry));
       }
     }
-    const backlogDir = join24(genDir, "backlog");
+    const backlogDir = join25(genDir, "backlog");
     await mkdir8(backlogDir, { recursive: true });
     try {
       const backlogEntries = await readdir17(this.paths.backlog);
       for (const entry of backlogEntries) {
-        await rename3(join24(this.paths.backlog, entry), join24(backlogDir, entry));
+        await rename3(join25(this.paths.backlog, entry), join25(backlogDir, entry));
       }
     } catch {}
     await writeTextFile(this.paths.currentYml, "");
@@ -12364,7 +12533,7 @@ class MergeGenerationManager {
     return compression;
   }
   async save(state) {
-    await writeTextFile(this.paths.currentYml, import_yaml9.default.stringify(state));
+    await writeTextFile(this.paths.currentYml, import_yaml10.default.stringify(state));
   }
 }
 function canFastForward(localLatestId, remoteLatestId, allMetas) {
@@ -12426,7 +12595,7 @@ function findCommonAncestor(idA, idB, metas) {
   }
   return null;
 }
-var import_yaml9;
+var import_yaml10;
 var init_merge_generation = __esm(() => {
   init_merge_lifecycle();
   init_compression();
@@ -12436,7 +12605,7 @@ var init_merge_generation = __esm(() => {
   init_merge();
   init_lineage();
   init_compression();
-  import_yaml9 = __toESM(require_dist(), 1);
+  import_yaml10 = __toESM(require_dist(), 1);
 });
 
 // src/cli/commands/run/merge-start.ts
@@ -13307,11 +13476,46 @@ var init_pull = __esm(() => {
   init_merge_generation();
 });
 
+// src/cli/commands/run/config.ts
+var exports_config = {};
+__export(exports_config, {
+  execute: () => execute27
+});
+async function execute27(paths) {
+  const config = await ConfigManager.read(paths);
+  const lines = [
+    `REAP Configuration (${paths.config})`,
+    "",
+    `  version:         ${config.version}`,
+    `  project:         ${config.project}`,
+    `  entryMode:       ${config.entryMode}`,
+    `  strict:          ${config.strict ?? false}`,
+    `  language:        ${config.language ?? "(not set)"}`,
+    `  autoUpdate:      ${config.autoUpdate ?? true}`,
+    `  autoSubagent:    ${config.autoSubagent ?? true}`,
+    `  autoIssueReport: ${config.autoIssueReport ?? false}`,
+    "",
+    "Edit .reap/config.yml to change settings."
+  ].join(`
+`);
+  emitOutput({
+    status: "ok",
+    command: "config",
+    phase: "show",
+    completed: ["read-config"],
+    message: lines
+  });
+}
+var init_config2 = __esm(() => {
+  init_config();
+});
+
 // src/cli/commands/run/index.ts
 var exports_run = {};
 __export(exports_run, {
   runCommand: () => runCommand
 });
+import { execSync as execSync6 } from "child_process";
 async function runCommand(command, phase) {
   const cwd = process.cwd();
   const paths = new ReapPaths(cwd);
@@ -13322,12 +13526,33 @@ async function runCommand(command, phase) {
   if (!loader) {
     emitError(command, `Unknown command: ${command}. Available: ${Object.keys(COMMANDS).join(", ")}`);
   }
-  const mod = await loader();
-  await mod.execute(paths, phase);
+  try {
+    const mod = await loader();
+    await mod.execute(paths, phase);
+  } catch (err) {
+    try {
+      const config = await ConfigManager.read(paths);
+      if (config.autoIssueReport) {
+        const version = "0.12.0";
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const title = `[auto] reap run ${command}: ${errMsg.slice(0, 80)}`;
+        const body = [
+          `**REAP Version**: ${version}`,
+          `**Command**: reap run ${command}${phase ? ` --phase ${phase}` : ""}`,
+          `**Error**: ${errMsg}`,
+          `**OS**: ${process.platform} ${process.arch}`,
+          `**Node**: ${process.version}`
+        ].join("\\n");
+        execSync6(`gh issue create --repo c-d-cc/reap --title "${title}" --label "auto-reported,bug" --body "${body}"`, { stdio: "ignore", timeout: 1e4 });
+      }
+    } catch {}
+    emitError(command, err instanceof Error ? err.message : String(err));
+  }
 }
 var COMMANDS;
 var init_run = __esm(() => {
   init_paths();
+  init_config();
   COMMANDS = {
     next: () => Promise.resolve().then(() => (init_next(), exports_next)),
     back: () => Promise.resolve().then(() => (init_back(), exports_back)),
@@ -13354,7 +13579,8 @@ var init_run = __esm(() => {
     "merge-completion": () => Promise.resolve().then(() => (init_merge_completion(), exports_merge_completion)),
     "merge-evolve": () => Promise.resolve().then(() => (init_merge_evolve(), exports_merge_evolve)),
     merge: () => Promise.resolve().then(() => (init_merge2(), exports_merge)),
-    pull: () => Promise.resolve().then(() => (init_pull(), exports_pull))
+    pull: () => Promise.resolve().then(() => (init_pull(), exports_pull)),
+    config: () => Promise.resolve().then(() => (init_config2(), exports_config))
   };
 });
 
@@ -13572,6 +13798,30 @@ class ClaudeCodeAdapter {
     } catch {}
     return removed;
   }
+  async setupClaudeMd(projectRoot) {
+    const claudeMdPath = join2(projectRoot, ".claude", "CLAUDE.md");
+    const marker = "# REAP Project";
+    const reapSection = `# REAP Project
+This project uses REAP. Session-start hook loads project knowledge on session start.
+If context was compacted and REAP knowledge is lost, re-run the session-start hook.
+`;
+    await mkdir(join2(projectRoot, ".claude"), { recursive: true });
+    const existing = await readTextFile(claudeMdPath);
+    if (existing === null) {
+      await writeTextFile(claudeMdPath, reapSection);
+      return { action: "created" };
+    }
+    if (existing.includes(marker)) {
+      const updated = existing.replace(/# REAP Project[\s\S]*?(?=\n# |\n*$)/, reapSection.trim());
+      if (updated === existing)
+        return { action: "skipped" };
+      await writeTextFile(claudeMdPath, updated);
+      return { action: "updated" };
+    }
+    await writeTextFile(claudeMdPath, reapSection + `
+` + existing);
+    return { action: "created" };
+  }
   getHookEntry() {
     const sessionStartPath = join2(ReapPaths.packageHooksDir, "session-start.cjs");
     return {
@@ -13832,7 +14082,8 @@ var COMMAND_NAMES = [
   "reap.merge.evolve",
   "reap.merge",
   "reap.pull",
-  "reap.push"
+  "reap.push",
+  "reap.config"
 ];
 async function initProject(projectRoot, projectName, entryMode, preset, onProgress) {
   const log = onProgress ?? (() => {});
@@ -13866,11 +14117,15 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
   if (!hasGhCli) {
     log("GitHub CLI(gh) not found. Install from https://cli.github.com for auto issue reporting.");
   }
+  const detectedLanguage = await AgentRegistry.readLanguage();
   const config = {
-    version: "0.11.0",
+    version: "0.12.0",
     project: projectName,
     entryMode,
+    strict: false,
+    ...detectedLanguage && { language: detectedLanguage },
     autoUpdate: true,
+    autoSubagent: true,
     autoIssueReport: hasGhCli,
     ...preset && { preset }
   };
@@ -13929,6 +14184,10 @@ async function initProject(projectRoot, projectName, entryMode, preset, onProgre
     await adapter.installCommands(COMMAND_NAMES, sourceDir);
     log(`  Registering session hook for ${adapter.displayName}...`);
     await adapter.registerSessionHook();
+    if (typeof adapter.setupClaudeMd === "function") {
+      const mdResult = await adapter.setupClaudeMd(projectRoot);
+      log(`  .claude/CLAUDE.md: ${mdResult.action}`);
+    }
   }
   if (detectedAgents.length === 0) {
     log("  No AI agents detected.");
@@ -14159,6 +14418,140 @@ class MigrationRunner {
   }
 }
 
+// src/core/migration-spec.ts
+init_fs();
+var import_yaml6 = __toESM(require_dist(), 1);
+import { existsSync as existsSync2 } from "fs";
+function buildMigrationSpec(paths) {
+  const sections = [];
+  sections.push(`## Config fields (config.yml)
+
+| Field | Type | Required | Default |
+|-------|------|----------|---------|
+| version | string | yes | — |
+| project | string | yes | — |
+| entryMode | greenfield \\| migration \\| adoption | yes | — |
+| stack | string | no | — |
+| preset | string | no | — |
+| agents | AgentName[] | no | auto-detect |
+| language | string | no | — |
+| autoUpdate | boolean | no | true |
+| autoSubagent | boolean | no | true |
+| autoIssueReport | boolean | no | false |
+| strict | boolean \\| { edit?: boolean; merge?: boolean } | no | false |`);
+  sections.push(`## Expected directory structure
+
+.reap/
+├── config.yml
+├── genome/
+│   ├── principles.md
+│   ├── conventions.md
+│   ├── constraints.md
+│   ├── source-map.md
+│   └── domain/
+├── environment/
+│   ├── summary.md
+│   ├── docs/
+│   └── resources/
+├── life/
+│   ├── current.yml
+│   ├── backlog/
+│   ├── 01-objective.md
+│   ├── 02-planning.md
+│   ├── 03-implementation.md
+│   ├── 04-validation.md
+│   └── 05-completion.md
+├── lineage/
+│   └── gen-NNN-hash/ or gen-NNN-hash.md
+└── hooks/
+    ├── conditions/
+    └── {event}.{name}.{sh|md}`);
+  sections.push(`## Slash commands (29)
+
+reap.objective, reap.planning, reap.implementation,
+reap.validation, reap.completion, reap.evolve,
+reap.start, reap.next, reap.back, 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,
+reap.merge.merge, reap.merge.sync, reap.merge.validation,
+reap.merge.completion, reap.merge.evolve,
+reap.merge,
+reap.pull, reap.push,
+reap.config`);
+  sections.push(`## Hooks format
+
+File naming: {event}.{name}.{md|sh}
+Location: .reap/hooks/
+
+Frontmatter (md hooks):
+---
+event: onLifeStarted
+name: my-hook
+description: What this hook does
+---
+
+Condition files: .reap/hooks/conditions/{name}.yml`);
+  sections.push(`## Project root: ${paths.projectRoot}`);
+  return sections.join(`
+
+`);
+}
+async function detectMigrationGaps(paths) {
+  const gaps = [];
+  const configContent = await readTextFile(paths.config);
+  if (configContent === null) {
+    gaps.push("config.yml missing");
+  } else {
+    try {
+      const config = import_yaml6.default.parse(configContent);
+      if (!config?.version)
+        gaps.push("config.yml: missing required field 'version'");
+      if (!config?.project)
+        gaps.push("config.yml: missing required field 'project'");
+      if (!config?.entryMode)
+        gaps.push("config.yml: missing required field 'entryMode'");
+    } catch {
+      gaps.push("config.yml: invalid YAML");
+    }
+  }
+  if (!existsSync2(paths.genome)) {
+    gaps.push("genome/ directory missing");
+  } else {
+    const genomeFiles = [
+      { path: paths.principles, label: "genome/principles.md" },
+      { path: paths.conventions, label: "genome/conventions.md" },
+      { path: paths.constraints, label: "genome/constraints.md" },
+      { path: paths.sourceMap, label: "genome/source-map.md" }
+    ];
+    for (const { path, label } of genomeFiles) {
+      if (!existsSync2(path)) {
+        gaps.push(`${label} missing`);
+      }
+    }
+  }
+  if (!existsSync2(paths.environment)) {
+    gaps.push("environment/ directory missing");
+  }
+  if (!existsSync2(paths.life)) {
+    gaps.push("life/ directory missing");
+  } else {
+    if (!existsSync2(paths.backlog)) {
+      gaps.push("life/backlog/ directory missing");
+    }
+  }
+  if (!existsSync2(paths.lineage)) {
+    gaps.push("lineage/ directory missing");
+  }
+  if (!existsSync2(paths.hooks)) {
+    gaps.push("hooks/ directory missing");
+  }
+  if (!existsSync2(paths.hookConditions)) {
+    gaps.push("hooks/conditions/ directory missing");
+  }
+  return gaps;
+}
+
 // src/cli/commands/update.ts
 function selfUpgrade() {
   try {
@@ -14278,7 +14671,23 @@ async function updateProject(projectRoot, dryRun = false) {
       result.skipped.push(`[${adapter.displayName}] session hook`);
     }
   }
+  for (const adapter of adapters) {
+    if (typeof adapter.setupClaudeMd === "function") {
+      const mdResult = await adapter.setupClaudeMd(projectRoot);
+      if (mdResult.action !== "skipped") {
+        result.updated.push(`[${adapter.displayName}] .claude/CLAUDE.md (${mdResult.action})`);
+      } else {
+        result.skipped.push(`[${adapter.displayName}] .claude/CLAUDE.md`);
+      }
+    }
+  }
   if (await paths.isReapProject()) {
+    if (!dryRun) {
+      const backfillResult = await ConfigManager.backfill(paths);
+      if (backfillResult.added.length > 0) {
+        result.updated.push(`Config: added ${backfillResult.added.join(", ")}`);
+      }
+    }
     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"));
@@ -14309,7 +14718,7 @@ async function updateProject(projectRoot, dryRun = false) {
       result.skipped.push(`.claude/commands/ (${reapCmdFiles.length} unchanged)`);
     }
     await migrateLegacyFiles(paths, dryRun, result);
-    const currentVersion = "0.11.0";
+    const currentVersion = "0.12.0";
     const migrationResult = await MigrationRunner.run(paths, currentVersion, dryRun);
     for (const m of migrationResult.migrated) {
       result.updated.push(`[migration] ${m}`);
@@ -14320,6 +14729,17 @@ async function updateProject(projectRoot, dryRun = false) {
     for (const e of migrationResult.errors) {
       result.removed.push(`[migration error] ${e}`);
     }
+    const gaps = await detectMigrationGaps(paths);
+    if (gaps.length > 0) {
+      const spec = buildMigrationSpec(paths);
+      console.log(JSON.stringify({
+        status: "prompt",
+        command: "migrate",
+        gaps,
+        spec,
+        prompt: "Analyze the gaps between current .reap/ structure and expected structure. Fix each gap after user confirmation."
+      }, null, 2));
+    }
     if (migrationResult.errors.length > 0 && config?.autoIssueReport) {
       try {
         const { execSync: execSync3 } = await import("child_process");
@@ -14415,7 +14835,7 @@ async function getStatus(projectRoot) {
 init_paths();
 init_lifecycle();
 init_fs();
-var import_yaml6 = __toESM(require_dist(), 1);
+var import_yaml7 = __toESM(require_dist(), 1);
 import { mkdir as mkdir7, stat as stat3, copyFile } from "fs/promises";
 import { join as join11 } from "path";
 async function dirExists(path) {
@@ -14468,7 +14888,7 @@ async function fixProject(projectRoot) {
   if (currentContent !== null) {
     if (currentContent.trim()) {
       try {
-        const state = import_yaml6.default.parse(currentContent);
+        const state = import_yaml7.default.parse(currentContent);
         if (!state.stage || !LifeCycle.isValid(state.stage)) {
           issues.push(`Invalid stage "${state.stage}" in current.yml. Valid stages: ${LifeCycle.stages().join(", ")}. Manual correction required.`);
         }
@@ -14495,8 +14915,8 @@ init_paths();
 init_fs();
 init_version();
 init_config();
-import { join as join25 } from "path";
-program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.11.0");
+import { join as join26 } from "path";
+program.name("reap").description("REAP — Recursive Evolutionary Autonomous Pipeline").version("0.12.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();
@@ -14504,9 +14924,9 @@ program.command("init").description("Initialize a new REAP project (Genesis)").a
     let mode = options.mode;
     const modeExplicit = process.argv.some((a) => a === "-m" || a === "--mode");
     if (!modeExplicit && mode === "greenfield") {
-      const { existsSync: existsSync2 } = __require("fs");
+      const { existsSync: existsSync3 } = __require("fs");
       const signals = ["package.json", "go.mod", "Cargo.toml", "pom.xml", "pyproject.toml", "Makefile", "CMakeLists.txt"];
-      const hasExistingProject = signals.some((f) => existsSync2(__require("path").join(cwd, f)));
+      const hasExistingProject = signals.some((f) => existsSync3(__require("path").join(cwd, f)));
       if (hasExistingProject) {
         mode = "adoption";
         console.log(`Existing project detected. Automatically using adoption mode.`);
@@ -14630,10 +15050,10 @@ program.command("help").description("Show REAP commands, slash commands, and wor
     if (l === "korean" || l === "ko")
       lang = "ko";
   }
-  const helpDir = join25(ReapPaths.packageTemplatesDir, "help");
-  let helpText = await readTextFile(join25(helpDir, `${lang}.txt`));
+  const helpDir = join26(ReapPaths.packageTemplatesDir, "help");
+  let helpText = await readTextFile(join26(helpDir, `${lang}.txt`));
   if (!helpText)
-    helpText = await readTextFile(join25(helpDir, "en.txt"));
+    helpText = await readTextFile(join26(helpDir, "en.txt"));
   if (!helpText) {
     console.log("Help file not found. Run 'reap update' to install templates.");
     return;

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

@@ -0,0 +1,5 @@
+---
+description: "REAP Config — Show current project configuration"
+---
+
+Run `reap run config` and follow the stdout instructions exactly.

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

@@ -156,21 +156,21 @@ REAP supports multiple AI agents simultaneously through the AgentAdapter abstrac
 
 ## Execution Flow
 
+**Lifecycle stages** (5 stages, in order):
 ```
-1. /reap.start → Start a new Generation
-2. /reap.objective → Define goal + requirements
-3. /reap.next
-4. /reap.planning → Task decomposition + implementation plan
-5. /reap.next
-6. /reap.implementation → Code implementation
-7. /reap.next
-8. /reap.validation → Verification
-9. /reap.next
-10. /reap.completion → Retrospective + genome updates
-11. /reap.next → Archiving, generation ends
+objective → planning → implementation → validation → completion
 ```
 
-Each slash command follows a 3-step structure: Gate (precondition check) → Steps (work execution) → Artifact generation.
+**Execution sequence**:
+1. `/reap.start` — Create a new Generation
+2. `/reap.objective` — Define goal + requirements → `/reap.next`
+3. `/reap.planning` — Task decomposition + plan → `/reap.next`
+4. `/reap.implementation` — Code implementation → `/reap.next`
+5. `/reap.validation` — Verification → `/reap.next`
+6. `/reap.completion` — Retrospective + genome updates + archiving (auto)
+
+`/reap.next` is a **transition command**, not a lifecycle stage. It advances `current.yml` to the next stage.
+`/reap.completion` auto-archives after the genome phase — no separate `/reap.next` needed at the end.
 
 ## Language
 
@@ -204,3 +204,4 @@ When `strict: true` is set in `.reap/config.yml`, the AI agent enforces code mod
 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.
+   - If `reap run` returns an unexpected error (not a gate failure), and the error repeats 2+ times, automatically run `/reap.report`.

package/package.json

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