@c-d-cc/reap 0.16.4 → 0.16.6

package/README.de.md

@@ -19,16 +19,16 @@ REAP ist eine generationsbasierte Entwicklungspipeline, in der KI und Menschen z
 
 - [Was ist REAP?](#was-ist-reap)
 - [Installation](#installation)
-- [Schnellstart](#schnellstart)
+- [Schnellstart](#schnellstart-)
 - [Lebenszyklus](#lebenszyklus-)
 - [Kernkonzepte](#kernkonzepte-)
 - [Merge-Lebenszyklus](#merge-lebenszyklus-)
 - [Selbstentwickelnde Funktionen](#selbstentwickelnde-funktionen-)
-- [Slash Commands](#slash-commands)
+- [Slash Commands](#slash-commands-)
 - [Agentenintegration](#agentenintegration-)
 - [Projektstruktur](#projektstruktur)
 - [Konfiguration](#konfiguration-)
-- [Upgrade von v0.15](#upgrade-von-v015)
+- [Upgrade von v0.15](#upgrade-von-v015-)
 
 ## Was ist REAP? [↗](https://reap.cc/docs/introduction)
 
@@ -57,11 +57,13 @@ REAP löst diese Probleme mit einem **selbstentwickelnden Generationsmodell**:
 npm install -g @c-d-cc/reap
 ```
 
-> **Voraussetzungen**: [Node.js](https://nodejs.org) v18+, [Claude Code](https://claude.ai/claude-code) CLI.
+> **Voraussetzungen**: [Node.js](https://nodejs.org) v18+ und ein unterstützter KI-Agent:
+> - [Claude Code](https://claude.ai/claude-code) CLI (Standard)
+> - [OpenCode](https://opencode.ai) — setzen Sie `agentClient: opencode` in `.reap/config.yml` nach `/reap.init`
 
 ## Schnellstart [↗](https://reap.cc/docs/quick-start)
 
-Öffnen Sie Ihren KI-Agenten (Claude Code) und verwenden Sie Slash Commands:
+Öffnen Sie Ihren KI-Agenten (Claude Code oder OpenCode) und verwenden Sie Slash Commands:
 
 ```bash
 # REAP in Ihrem Projekt initialisieren (erkennt automatisch Greenfield vs. bestehende Codebasis)
@@ -73,6 +75,8 @@ npm install -g @c-d-cc/reap
 
 `/reap.evolve` steuert den gesamten Generationslebenszyklus — vom Lernen bis zum Abschluss. Die KI erkundet das Projekt, plant die Arbeit, implementiert sie, validiert und reflektiert. Dies ist der primäre Befehl für die tägliche Entwicklung.
 
+> **OpenCode-Benutzer**: Nach `/reap.init` setzen Sie `agentClient: opencode` in `.reap/config.yml` und führen `reap update` aus, um client-spezifische Assets neu zu generieren (`opencode.json`, `.opencode/plugins/reap-plugin.ts`, `AGENTS.md` und Slash-Befehle unter `~/.config/opencode/commands/`).
+
 > **Hinweis:** Benutzer interagieren mit REAP über `/reap.*` Slash Commands in ihrem KI-Agenten. Die CLI ist die interne Engine, die diese Befehle antreibt.
 
 ## Lebenszyklus [↗](https://reap.cc/docs/lifecycle)
@@ -210,6 +214,7 @@ N Generationen für autonome Ausführung vorab genehmigen:
 | `/reap.start` | Eine neue Generation starten |
 | `/reap.next` | Zur nächsten Phase vorrücken |
 | `/reap.back` | Zu einer vorherigen Phase zurückkehren |
+| `/reap.early-close` | Schlankes Beenden — bewahrt Teilwerte, verschiebt unvollständige Aufgaben automatisch |
 | `/reap.abort` | Aktuelle Generation abbrechen |
 | `/reap.knowledge` | Genome/Environment überprüfen und verwalten |
 | `/reap.merge` | Merge-Lebenszyklus-Operationen |
@@ -223,13 +228,19 @@ N Generationen für autonome Ausführung vorab genehmigen:
 
 ## Agentenintegration
 
-REAP integriert sich über Slash Commands und Lebenszyklus-Hooks mit KI-Agenten. Derzeit unterstützt: **Claude Code**. Die Architektur verwendet ein Adapter-Muster für zukünftige Agentenunterstützung.
+REAP integriert sich über eine Adapterschicht, die auf dem `agentClient`-Konfigurationsfeld basiert, mit KI-Agenten. Aktuell unterstützte Clients:
+
+- **Claude Code** (`agentClient: claude-code`, Standard) — statisches Wissen über `@`-Imports in `CLAUDE.md`; dynamischer Zustand über den `SessionStart`-Hook (`reap load-context`); Slash-Befehle installiert unter `~/.claude/commands/reap.*.md`.
+- **OpenCode** (`agentClient: opencode`) — statisches Wissen über das `instructions`-Feld von `opencode.json`; dynamischer Zustand über `.reap/.session-state.md`, automatisch aktualisiert vom gebündelten OpenCode-Plugin (`.opencode/plugins/reap-plugin.ts`) bei `session.created` / `tool.execute.before`; Slash-Befehle installiert unter `~/.config/opencode/commands/reap.*.md`.
+
+Wechseln Sie Clients, indem Sie `.reap/config.yml` bearbeiten, dann `reap install-skills` gefolgt von `reap update` ausführen. REAP regeneriert die Entry-Point-Datei (CLAUDE.md vs AGENTS.md), die Session-Integration und alle client-spezifischen Assets. Das Präfix `reap.` in Slash-Befehlsverzeichnissen ist reserviert — Installationen sind cleanup-then-copy und überschreiben alle `reap.*.md`-Dateien an diesen Orten. Verwenden Sie für benutzerdefinierte Befehle ein anderes Präfix (`mytool.md`, `team.md` usw.).
 
 ### Funktionsweise
 
-1. **CLAUDE.md** weist die KI an, Genome, Environment und reap-guide beim Sitzungsstart zu laden
-2. **Slash Commands** rufen `reap run <cmd>` auf, das strukturierte JSON-Anweisungen für die KI zurückgibt
+1. **Entry-Point-Datei** (`CLAUDE.md` für claude-code, `AGENTS.md` für opencode) weist die KI an, Genome, Environment und reap-guide beim Sitzungsstart zu laden
+2. **Slash-Befehle** — `/reap.start`, `/reap.status`, `/reap.evolve` usw. funktionieren in Claude Code und OpenCode; jeder ruft `reap run <cmd>` auf, das strukturierte JSON-Anweisungen an die KI zurückgibt
 3. **Signaturbasiertes Locking** (Nonce-Chain) erzwingt die Phasenreihenfolge auf Code-Ebene — kein Überspringen, keine Fälschung, kein Replay
+4. **Dynamischer Zustands-Dump** — jeder REAP-Lebenszyklusbefehl schreibt synchron in `.reap/.session-state.md`, sodass OpenCode-Benutzer in der nächsten Sitzung immer den Zustand nach dem Befehl sehen
 
 ### Subagent-Modus
 

package/README.ja.md

@@ -19,16 +19,16 @@ REAPは、AIと人間が協力してソフトウェアを構築・進化させ
 
 - [REAPとは？](#reapとは)
 - [インストール](#インストール)
-- [クイックスタート](#クイックスタート)
+- [クイックスタート](#クイックスタート-)
 - [ライフサイクル](#ライフサイクル-)
 - [コアコンセプト](#コアコンセプト-)
 - [マージライフサイクル](#マージライフサイクル-)
 - [自己進化機能](#自己進化機能-)
-- [スラッシュコマンド](#スラッシュコマンド)
+- [スラッシュコマンド](#スラッシュコマンド-)
 - [エージェント統合](#エージェント統合-)
 - [プロジェクト構造](#プロジェクト構造)
 - [設定](#設定-)
-- [v0.15からのアップグレード](#v015からのアップグレード)
+- [v0.15からのアップグレード](#v015からのアップグレード-)
 
 ## REAPとは？ [↗](https://reap.cc/docs/introduction)
 
@@ -57,11 +57,13 @@ REAPはこれらを**自己進化型ジェネレーションモデル**で解決
 npm install -g @c-d-cc/reap
 ```
 
-> **要件**: [Node.js](https://nodejs.org) v18以上、[Claude Code](https://claude.ai/claude-code) CLI。
+> **要件**: [Node.js](https://nodejs.org) v18以上、およびサポートされるAIエージェントの1つ:
+> - [Claude Code](https://claude.ai/claude-code) CLI（デフォルト）
+> - [OpenCode](https://opencode.ai) — `/reap.init` 後に `.reap/config.yml` で `agentClient: opencode` に設定
 
 ## クイックスタート [↗](https://reap.cc/docs/quick-start)
 
-AIエージェント（Claude Code）を開き、スラッシュコマンドを使います：
+AIエージェント（Claude Code または OpenCode）を開き、スラッシュコマンドを使います：
 
 ```bash
 # プロジェクトにREAPを初期化（新規/既存コードベースを自動判別）
@@ -73,6 +75,8 @@ AIエージェント（Claude Code）を開き、スラッシュコマンドを
 
 `/reap.evolve` はジェネレーションライフサイクル全体を駆動します — 学習から完了まで。AIがプロジェクトを探索し、作業を計画し、実装し、検証し、振り返ります。日常の開発で使うメインコマンドです。
 
+> **OpenCodeユーザー**: `/reap.init` 後、`.reap/config.yml` で `agentClient: opencode` に設定し、`reap update` を実行してクライアント固有のアセット（`opencode.json`、`.opencode/plugins/reap-plugin.ts`、`AGENTS.md`、`~/.config/opencode/commands/` のスラッシュコマンド）を再生成してください。
+
 > **注意:** ユーザーはAIエージェント内の `/reap.*` スラッシュコマンドを通じてREAPとやり取りします。CLIはそれらのコマンドを動かす内部エンジンです。
 
 ## ライフサイクル [↗](https://reap.cc/docs/lifecycle)
@@ -210,6 +214,7 @@ N世代分の自律実行を事前承認：
 | `/reap.start` | 新しいジェネレーションを開始 |
 | `/reap.next` | 次のステージへ進む |
 | `/reap.back` | 前のステージに戻る |
+| `/reap.early-close` | 軽量終了 — 部分的な価値を保存、未完了タスクを自動的に次世代へ繰り越し |
 | `/reap.abort` | 現在のジェネレーションを中止 |
 | `/reap.knowledge` | genome/environment のレビューと管理 |
 | `/reap.merge` | マージライフサイクル操作 |
@@ -223,13 +228,19 @@ N世代分の自律実行を事前承認：
 
 ## エージェント統合
 
-REAPはスラッシュコマンドとライフサイクルフックを通じてAIエージェントと統合します。現在サポート: **Claude Code**。アーキテクチャはアダプターパターンを採用しており、将来のエージェントサポートに対応しています。
+REAPは`agentClient` configフィールドをキーとするアダプタレイヤーを通じてAIエージェントと統合します。現在サポートされているクライアント:
+
+- **Claude Code** (`agentClient: claude-code`, デフォルト) — `CLAUDE.md`の`@`インポートで静的ナレッジ; SessionStartフック(`reap load-context`)で動的状態を注入; スラッシュコマンドは`~/.claude/commands/reap.*.md`にインストール。
+- **OpenCode** (`agentClient: opencode`) — `opencode.json`の`instructions`フィールドで静的ナレッジ; `.reap/.session-state.md`で動的状態を伝達、バンドルされたOpenCodeプラグイン(`.opencode/plugins/reap-plugin.ts`)が`session.created` / `tool.execute.before`時に自動更新; スラッシュコマンドは`~/.config/opencode/commands/reap.*.md`にインストール。
+
+`.reap/config.yml`を編集してから`reap install-skills`に続いて`reap update`を実行することでクライアントを切り替えます。REAPはエントリーポイントファイル(CLAUDE.md vs AGENTS.md)、セッション統合、およびクライアント固有のアセットを再生成します。スラッシュコマンドディレクトリの`reap.`プレフィックスは予約されています — インストールはcleanup-then-copy方式で、その場所の`reap.*.md`ファイルを上書きします。カスタムコマンドには別のプレフィックス(`mytool.md`、`team.md`など)を使用してください。
 
 ### 仕組み
 
-1. **CLAUDE.md** がセッション開始時に genome、environment、reap-guide をロードするようAIに指示
-2. **スラッシュコマンド** が `reap run <cmd>` を呼び出し、AI向けの構造化されたJSON命令を返す
+1. **エントリーポイントファイル** (claude-codeでは`CLAUDE.md`、opencodeでは`AGENTS.md`)がセッション開始時にgenome、environment、reap-guideをロードするようAIに指示
+2. **スラッシュコマンド** — `/reap.start`、`/reap.status`、`/reap.evolve`などはClaude CodeとOpenCodeの両方で動作; それぞれが`reap run <cmd>`を呼び出し、AIに構造化されたJSON指示を返す
 3. **署名ベースのロック**（nonceチェーン）がコードレベルでステージの順序を強制 — スキップ・偽造・リプレイ不可
+4. **動的状態ダンプ** — すべてのREAPライフサイクルコマンドが同期的に`.reap/.session-state.md`に書き込むため、OpenCodeユーザーは次のセッションで常にコマンド後の状態を確認可能
 
 ### Subagent Mode
 

package/README.ko.md

@@ -19,16 +19,16 @@ REAP는 AI와 인간이 협력하여 소프트웨어를 구축하고 진화시
 
 - [REAP란 무엇인가?](#reap란-무엇인가)
 - [설치](#설치)
-- [빠른 시작](#빠른-시작)
+- [빠른 시작](#빠른-시작-)
 - [생명 주기](#생명-주기-)
 - [핵심 개념](#핵심-개념-)
 - [병합 생명 주기](#병합-생명-주기-)
 - [자기 진화 기능](#자기-진화-기능-)
-- [슬래시 명령어](#슬래시-명령어)
+- [슬래시 명령어](#슬래시-명령어-)
 - [에이전트 통합](#에이전트-통합-)
 - [프로젝트 구조](#프로젝트-구조)
 - [설정](#설정-)
-- [v0.15에서 업그레이드](#v015에서-업그레이드)
+- [v0.15에서 업그레이드](#v015에서-업그레이드-)
 
 ## REAP란 무엇인가? [↗](https://reap.cc/docs/introduction)
 
@@ -57,11 +57,13 @@ REAP는 이러한 문제를 **자기 진화 세대 모델**로 해결합니다:
 npm install -g @c-d-cc/reap
 ```
 
-> **요구 사항**: [Node.js](https://nodejs.org) v18+, [Claude Code](https://claude.ai/claude-code) CLI.
+> **요구 사항**: [Node.js](https://nodejs.org) v18+ 및 지원되는 AI 에이전트 중 하나:
+> - [Claude Code](https://claude.ai/claude-code) CLI (기본값)
+> - [OpenCode](https://opencode.ai) — `/reap.init` 후 `.reap/config.yml`에서 `agentClient: opencode`로 설정
 
 ## 빠른 시작 [↗](https://reap.cc/docs/quick-start)
 
-AI 에이전트(Claude Code)를 열고 슬래시 명령어를 사용하세요:
+AI 에이전트(Claude Code 또는 OpenCode)를 열고 슬래시 명령어를 사용하세요:
 
 ```bash
 # 프로젝트에 REAP 초기화 (신규 프로젝트 vs 기존 코드베이스 자동 감지)
@@ -73,6 +75,8 @@ AI 에이전트(Claude Code)를 열고 슬래시 명령어를 사용하세요:
 
 `/reap.evolve`는 학습부터 완료까지 전체 세대 생명 주기를 주도합니다. AI가 프로젝트를 탐색하고, 작업을 계획하고, 구현하고, 검증하고, 회고합니다. 일상적인 개발에서 사용하는 주요 명령어입니다.
 
+> **OpenCode 사용자**: `/reap.init` 후 `.reap/config.yml`에서 `agentClient: opencode`로 설정하고 `reap update`를 실행하여 클라이언트별 자산(`opencode.json`, `.opencode/plugins/reap-plugin.ts`, `AGENTS.md`, `~/.config/opencode/commands/`의 슬래시 명령)을 재생성하세요.
+
 > **참고:** 사용자는 AI 에이전트에서 `/reap.*` 슬래시 명령어를 통해 REAP와 상호작용합니다. CLI는 이러한 명령어를 구동하는 내부 엔진입니다.
 
 ## 생명 주기 [↗](https://reap.cc/docs/lifecycle)
@@ -210,6 +214,7 @@ N개 세대를 사전 승인하여 자율 실행:
 | `/reap.start` | 새 세대 시작 |
 | `/reap.next` | 다음 단계로 진행 |
 | `/reap.back` | 이전 단계로 돌아감 |
+| `/reap.early-close` | 경량 종료 — 부분 가치 보존, 미완 task 자동 승계 |
 | `/reap.abort` | 현재 세대 중단 |
 | `/reap.knowledge` | genome/environment 검토 및 관리 |
 | `/reap.merge` | 병합 생명 주기 작업 |
@@ -223,13 +228,19 @@ N개 세대를 사전 승인하여 자율 실행:
 
 ## 에이전트 통합
 
-REAP는 슬래시 명령어와 생명 주기 훅을 통해 AI 에이전트와 통합됩니다. 현재 지원: **Claude Code**. 향후 에이전트 지원을 위해 어댑터 패턴 아키텍처를 사용합니다.
+REAP는 `agentClient` config 필드를 기준으로 adapter layer를 통해 AI 에이전트와 통합됩니다. 현재 지원되는 클라이언트:
+
+- **Claude Code** (`agentClient: claude-code`, 기본값) — `CLAUDE.md`의 `@` import로 정적 knowledge 로드; SessionStart hook(`reap load-context`)으로 동적 상태 주입; 슬래시 명령은 `~/.claude/commands/reap.*.md`에 설치.
+- **OpenCode** (`agentClient: opencode`) — `opencode.json`의 `instructions` 필드로 정적 knowledge 로드; `.reap/.session-state.md`로 동적 상태 전달, 번들된 OpenCode plugin(`.opencode/plugins/reap-plugin.ts`)이 `session.created` / `tool.execute.before` 시점에 자동 갱신; 슬래시 명령은 `~/.config/opencode/commands/reap.*.md`에 설치.
+
+`.reap/config.yml`을 편집한 뒤 `reap install-skills`와 `reap update`를 실행하면 클라이언트 전환이 완료됩니다. REAP가 entry-point 파일(CLAUDE.md vs AGENTS.md), 세션 통합, 클라이언트별 자산을 재생성합니다. 슬래시 명령 디렉토리의 `reap.` 접두사는 예약되어 있으며 — 설치는 cleanup-then-copy 방식이라 해당 디렉토리의 `reap.*.md` 파일을 덮어씁니다. 사용자 정의 명령은 다른 접두사(`mytool.md`, `team.md` 등)를 사용하세요.
 
 ### 동작 방식
 
-1. **CLAUDE.md**가 세션 시작 시 genome, environment, reap-guide를 로딩하도록 AI에 지시
-2. **슬래시 명령어**가 `reap run <cmd>`를 호출하고, AI에게 구조화된 JSON 지시를 반환
+1. **Entry-point 파일** (claude-code는 `CLAUDE.md`, opencode는 `AGENTS.md`)이 세션 시작 시 genome, environment, reap-guide를 로딩하도록 AI에 지시
+2. **슬래시 명령** — `/reap.start`, `/reap.status`, `/reap.evolve` 등은 Claude Code와 OpenCode 모두에서 작동; 각각 `reap run <cmd>`를 호출하여 AI에 구조화된 JSON 지시 반환
 3. **서명 기반 잠금** (nonce 체인)이 코드 수준에서 단계 순서를 강제 — 건너뛰기, 위조, 재생 불가
+4. **동적 상태 dump** — 모든 REAP 라이프사이클 명령이 동기적으로 `.reap/.session-state.md`에 기록하므로, OpenCode 사용자는 다음 세션에서 항상 명령 직후 상태를 확인 가능
 
 ### 서브에이전트 모드
 

package/README.md

@@ -21,16 +21,16 @@ REAP is a generation-based development pipeline where AI and humans collaborate
 
 - [What is REAP?](#what-is-reap)
 - [Installation](#installation)
-- [Quick Start](#quick-start)
+- [Quick Start](#quick-start-)
 - [Life Cycle](#life-cycle-)
 - [Core Concepts](#core-concepts-)
 - [Merge Lifecycle](#merge-lifecycle-)
 - [Self-Evolving Features](#self-evolving-features-)
-- [Slash Commands](#slash-commands)
+- [Slash Commands](#slash-commands-)
 - [Agent Integration](#agent-integration-)
 - [Project Structure](#project-structure)
 - [Configuration](#configuration-)
-- [Upgrading from v0.15](#upgrading-from-v015)
+- [Upgrading from v0.15](#upgrading-from-v015-)
 
 ## What is REAP? [↗](https://reap.cc/docs/introduction)
 
@@ -59,11 +59,13 @@ REAP solves these with a **self-evolving generation model**:
 npm install -g @c-d-cc/reap
 ```
 
-> **Requirements**: [Node.js](https://nodejs.org) v18+, [Claude Code](https://claude.ai/claude-code) CLI.
+> **Requirements**: [Node.js](https://nodejs.org) v18+ and one supported AI agent:
+> - [Claude Code](https://claude.ai/claude-code) CLI (default)
+> - [OpenCode](https://opencode.ai) — set `agentClient: opencode` in `.reap/config.yml` after `/reap.init`
 
 ## Quick Start [↗](https://reap.cc/docs/quick-start)
 
-Open your AI agent (Claude Code) and use slash commands:
+Open your AI agent (Claude Code or OpenCode) and use slash commands:
 
 ```bash
 # Initialize REAP in your project (auto-detects greenfield vs existing codebase)
@@ -75,6 +77,8 @@ Open your AI agent (Claude Code) and use slash commands:
 
 `/reap.evolve` drives the entire generation lifecycle — from learning through completion. The AI explores the project, plans the work, implements it, validates, and reflects. This is the primary command for day-to-day development.
 
+> **OpenCode users**: After `/reap.init`, edit `.reap/config.yml` to set `agentClient: opencode`, then run `reap update` to regenerate client-specific assets (`opencode.json`, `.opencode/plugins/reap-plugin.ts`, `AGENTS.md`, and slash commands at `~/.config/opencode/commands/`).
+
 > **Note:** Users interact with REAP through `/reap.*` slash commands in their AI agent. The CLI is the internal engine that powers those commands.
 
 ## Life Cycle [↗](https://reap.cc/docs/lifecycle)
@@ -85,13 +89,13 @@ Each generation follows a five-stage lifecycle.
 learning → planning → implementation ⟷ validation → completion
 ```
 
-| Stage | What happens | Artifact |
-|-------|-------------|----------|
-| **Learning** | Explore the project, build context, review genome and environment | `01-learning.md` |
-| **Planning** | Define goal, decompose tasks, map dependencies | `02-planning.md` |
-| **Implementation** | Build with AI-human collaboration | `03-implementation.md` |
-| **Validation** | Run tests, verify completion criteria | `04-validation.md` |
-| **Completion** | Reflect, collect fitness feedback, adapt genome, archive | `05-completion.md` |
+| Stage              | What happens                                                      | Artifact               |
+| ------------------ | ----------------------------------------------------------------- | ---------------------- |
+| **Learning**       | Explore the project, build context, review genome and environment | `01-learning.md`       |
+| **Planning**       | Define goal, decompose tasks, map dependencies                    | `02-planning.md`       |
+| **Implementation** | Build with AI-human collaboration                                 | `03-implementation.md` |
+| **Validation**     | Run tests, verify completion criteria                             | `04-validation.md`     |
+| **Completion**     | Reflect, collect fitness feedback, adapt genome, archive          | `05-completion.md`     |
 
 ## Core Concepts [↗](https://reap.cc/docs/core-concepts)
 
@@ -152,6 +156,7 @@ DAG metadata is preserved for branch-aware lineage traversal.
 ### Hooks [↗](https://reap.cc/docs/hooks)
 
 File-based lifecycle event hooks in `.reap/hooks/`:
+
 - `.md` files: AI prompts executed by the agent
 - `.sh` files: Shell scripts executed directly
 
@@ -170,14 +175,14 @@ When multiple developers or agents work in parallel, REAP provides a genome-firs
 detect → mate → merge → reconcile → validation → completion
 ```
 
-| Stage | Purpose |
-|-------|---------|
-| **Detect** | Identify divergence between branches |
-| **Mate** | Resolve genome conflicts first (human decides) |
-| **Merge** | Merge source code guided by finalized genome |
-| **Reconcile** | Verify genome-source consistency |
-| **Validation** | Run tests |
-| **Completion** | Commit merged result and archive |
+| Stage          | Purpose                                        |
+| -------------- | ---------------------------------------------- |
+| **Detect**     | Identify divergence between branches           |
+| **Mate**       | Resolve genome conflicts first (human decides) |
+| **Merge**      | Merge source code guided by finalized genome   |
+| **Reconcile**  | Verify genome-source consistency               |
+| **Validation** | Run tests                                      |
+| **Completion** | Commit merged result and archive               |
 
 ## Self-Evolving Features [↗](https://reap.cc/docs/self-evolving)
 
@@ -200,42 +205,77 @@ The AI adjusts its communication style based on how well-defined the current con
 ### Cruise Mode
 
 Pre-approve N generations for autonomous execution:
+
 - The AI selects goals from vision gaps and runs the full lifecycle autonomously
 - If uncertainty or risk is detected, cruise pauses and requests human feedback
 - After all N generations complete, human reviews the batch
 
 ## Slash Commands [↗](https://reap.cc/docs/command-reference)
 
-| Command | Description |
-|---------|-------------|
-| `/reap.evolve` | Run an entire generation (recommended) |
-| `/reap.start` | Start a new generation |
-| `/reap.next` | Advance to the next stage |
-| `/reap.back` | Return to a previous stage |
-| `/reap.abort` | Abort current generation |
-| `/reap.knowledge` | Review and manage genome/environment |
-| `/reap.merge` | Merge lifecycle operations |
-| `/reap.pull` | Fetch + merge lifecycle |
-| `/reap.push` | Validate + push |
-| `/reap.status` | Check current state |
-| `/reap.help` | Show available commands |
-| `/reap.init` | Initialize REAP in a project |
-| `/reap.run` | Execute a lifecycle command directly |
-| `/reap.config` | View/edit project configuration |
+| Command           | Description                            |
+| ----------------- | -------------------------------------- |
+| `/reap.evolve`    | Run an entire generation (recommended) |
+| `/reap.start`     | Start a new generation                 |
+| `/reap.next`      | Advance to the next stage              |
+| `/reap.back`      | Return to a previous stage             |
+| `/reap.early-close` | Lightweight termination — preserves partial value, auto-defers incomplete tasks |
+| `/reap.abort`     | Abort current generation               |
+| `/reap.knowledge` | Review and manage genome/environment   |
+| `/reap.merge`     | Merge lifecycle operations             |
+| `/reap.pull`      | Fetch + merge lifecycle                |
+| `/reap.push`      | Validate + push                        |
+| `/reap.status`    | Check current state                    |
+| `/reap.help`      | Show available commands                |
+| `/reap.init`      | Initialize REAP in a project           |
+| `/reap.run`       | Execute a lifecycle command directly   |
+| `/reap.config`    | View/edit project configuration        |
+| `/reap.report`    | Submit a bug report or feature request |
 
 ## Agent Integration
-REAP integrates with AI agents through slash commands and lifecycle hooks. Currently supported: **Claude Code**. The architecture uses an adapter pattern for future agent support.
+
+REAP integrates with AI agents through an adapter layer keyed by the `agentClient` config field. Currently supported clients:
+
+- **Claude Code** (`agentClient: claude-code`, default) — static knowledge via `@` imports in `CLAUDE.md`; dynamic state via `SessionStart` hook (`reap load-context`); slash commands installed to `~/.claude/commands/reap.*.md`.
+- **OpenCode** (`agentClient: opencode`) — static knowledge via `opencode.json`'s `instructions` field; dynamic state via `.reap/.session-state.md`, auto-refreshed by the bundled OpenCode plugin (`.opencode/plugins/reap-plugin.ts`) on `session.created` / `tool.execute.before`; slash commands installed to `~/.config/opencode/commands/reap.*.md`.
+
+Switch clients by editing `.reap/config.yml`, then run `reap install-skills` followed by `reap update`. REAP regenerates the entry-point file (CLAUDE.md vs AGENTS.md), the session integration, and any client-specific assets. The `reap.` prefix in slash command directories is reserved — installs are cleanup-then-copy and will overwrite any `reap.*.md` file in those locations. Use a different prefix (`mytool.md`, `team.md`, etc.) for custom commands.
 
 ### How It Works
 
-1. **CLAUDE.md** instructs the AI to load genome, environment, and reap-guide at session start
-2. **Slash commands** call `reap run <cmd>`, which returns structured JSON instructions for the AI
+1. **Entry-point file** (`CLAUDE.md` for claude-code, `AGENTS.md` for opencode) instructs the AI to load genome, environment, and reap-guide at session start
+2. **Slash commands** — `/reap.start`, `/reap.status`, `/reap.evolve`, etc. work in both Claude Code and OpenCode; each invokes `reap run <cmd>`, which returns structured JSON instructions for the AI
 3. **Signature-based locking** (nonce chain) enforces stage ordering at the code level — no skipping, no forgery, no replay
+4. **Dynamic state dump** — every REAP lifecycle command synchronously writes `.reap/.session-state.md`, so OpenCode users always see the post-command state on the next session
 
 ### Subagent Mode
 
 `/reap.evolve` can delegate the entire generation to a subagent that runs autonomously through all stages, surfacing only when genuinely blocked.
 
+### Evaluator Agent (opt-in)
+
+REAP ships a second subagent definition, `reap-evaluate`, that runs as an **independent reviewer** of the builder's work. It is read-only (Read/Glob/Grep/Bash only), produces qualitative assessments (no scores), and acts as an **advisor** — its concerns surface to you, but the builder owns the final lifecycle verdict.
+
+Enable it by adding one line to `.reap/config.yml`:
+
+```yaml
+evaluator: true   # default: false
+```
+
+When enabled, the validation stage instructs the builder to launch `reap-evaluate` as a subagent before declaring pass/partial/fail. The evaluator:
+
+- runs typecheck, build, and the full test suite independently,
+- cross-checks completion criteria from `02-planning.md` against the implementation,
+- surfaces concerns about genome convention drift, sycophancy red flags, and regression risk,
+- escalates per a confidence × impact matrix.
+
+If the subagent invocation fails for any reason, the builder continues normal validation — the evaluator is opt-in advice, not a gate.
+
+Agent definitions are installed automatically by `reap install-skills` **and** `reap update`:
+- Claude Code → `~/.claude/agents/reap-*.md`
+- OpenCode → `~/.config/opencode/agent/reap-*.md`
+
+**Fitness phase + cruise mode** (gen-067): the evaluator also runs during the fitness phase. After receiving its reply, the builder persists the verdict on the generation state via `reap run validation --phase report-evaluator --severity <high|low|none> --summary "..."`. High-severity concerns recorded during validation **automatically abort cruise mode** when the next fitness phase runs — `cruiseCount` is cleared from `config.yml`, the cruise prompt is replaced with a supervised fallback, and the human reviews the concern before composing fitness feedback. Cruise can be resumed manually with `reap cruise <N>` once the concern is resolved. Low-severity concerns surface in the prompt's "Prior Evaluator Concerns" section without aborting cruise.
+
 ## Project Structure
 
 ```
@@ -269,20 +309,23 @@ my-project/
 Project settings in `.reap/config.yml`:
 
 ```yaml
-project: my-project           # Project name
-language: english              # Artifact/prompt language
-autoSubagent: true             # Auto-delegate to subagent in evolve
-strictEdit: false               # Restrict code changes to REAP lifecycle
-strictMerge: false              # Restrict direct git pull/push/merge
-agentClient: claude-code       # AI agent client
+project: my-project # Project name
+language: english # Artifact/prompt language
+autoSubagent: true # Auto-delegate to subagent in evolve
+strictEdit: false # Restrict code changes to REAP lifecycle
+strictMerge: false # Restrict direct git pull/push/merge
+agentClient: claude-code # AI agent client
 # cruiseCount: 1/5             # Present = cruise mode (current/total)
+# evaluator: true              # Opt-in: launch reap-evaluate during validation
 ```
 
 Key settings:
+
 - **`cruiseCount`**: When present, enables cruise mode. Format `current/total`. Removed after cruise completes.
 - **`strictEdit`**: Restricts code changes to the implementation stage within the planned scope.
 - **`strictMerge`**: Restricts direct git pull/push/merge — use `/reap.pull`, `/reap.push`, `/reap.merge` instead.
 - **`agentClient`**: Determines which adapter is used for skill deployment.
+- **`evaluator`**: Opt-in independent reviewer. When `true`, the validation stage launches the `reap-evaluate` subagent as an advisor (read-only, qualitative-only). Default `false` keeps validation byte-identical to pre-gen-066 behaviour. See [Evaluator Agent](#evaluator-agent-opt-in) above.
 
 ## Upgrading from v0.15 [↗](https://reap.cc/docs/migration-guide)
 
@@ -291,25 +334,28 @@ REAP v0.16 is a complete rewrite built on the [Self-Evolving Pipeline](https://r
 ### Migration Steps
 
 1. **Install v0.16:**
+
    ```bash
    npm install -g @c-d-cc/reap
    ```
+
    This automatically installs v0.16 skills to `~/.claude/commands/` and removes legacy v0.15 project-level skills.
 
 2. **Open Claude Code in your project** and run:
+
    ```
    /reap.update
    ```
 
 3. **Follow the multi-phase migration:**
 
-   | Phase | What happens | Your role |
-   |-------|-------------|-----------|
-   | **Confirm** | Shows what will change, creates backup at `.reap/v15/` | Review and confirm |
-   | **Execute** | Restructures directories, migrates config/hooks/lineage/backlog | Automatic |
-   | **Genome Convert** | AI reconstructs genome from v0.15 files into new 3-file structure | Review AI's work |
-   | **Vision** | Set up vision/goals.md and memory | Provide project direction |
-   | **Complete** | Summary of migration results | Verify |
+   | Phase              | What happens                                                      | Your role                 |
+   | ------------------ | ----------------------------------------------------------------- | ------------------------- |
+   | **Confirm**        | Shows what will change, creates backup at `.reap/v15/`            | Review and confirm        |
+   | **Execute**        | Restructures directories, migrates config/hooks/lineage/backlog   | Automatic                 |
+   | **Genome Convert** | AI reconstructs genome from v0.15 files into new 3-file structure | Review AI's work          |
+   | **Vision**         | Set up vision/goals.md and memory                                 | Provide project direction |
+   | **Complete**       | Summary of migration results                                      | Verify                    |
 
 4. **Verify** your project works:
    ```
@@ -330,27 +376,32 @@ All v0.15 files are preserved at `.reap/v15/`. After verifying the migration, yo
 ### What Changed
 
 **Lifecycle redesigned:**
+
 - The first stage is now `learning` (was `objective`). The AI explores the project before setting goals.
 - Completion is now 4 phases: `reflect` → `fitness` → `adapt` → `commit` (was 5 phases).
 - New concepts: embryo generations, cruise mode, vision-driven planning.
 
 **Vision layer added:**
+
 - `vision/goals.md` — long-term objectives, gap-driven goal selection at adapt phase
 - `vision/memory/` — 3-tier memory (longterm, midterm, shortterm) for cross-generation context
 - `vision/design/` — planning documents and specs
 
 **Genome restructured (3 files):**
+
 - `application.md` — project identity, architecture, conventions, constraints
 - `evolution.md` — AI behavior guide, evolution direction, soft lifecycle rules
 - `invariants.md` — absolute constraints (human-only edits)
 
 **New features:**
+
 - Clarity-driven interaction: AI adjusts communication depth based on context clarity
 - Cruise mode: pre-approve N generations, AI runs autonomously with self-assessment
 - Merge lifecycle with reconcile stage for genome-source consistency verification
 - Vision system with 3-tier memory for cross-generation context
 
 **Deprecated commands:**
+
 - `/reap.sync` → `/reap.knowledge`
 - `/reap.refreshKnowledge` → `/reap.knowledge`
 

package/README.zh-CN.md

@@ -19,16 +19,16 @@ REAP 是一个基于代际迭代的开发管道，AI 与人类协作构建和进
 
 - [什么是 REAP？](#什么是-reap)
 - [安装](#安装)
-- [快速开始](#快速开始)
+- [快速开始](#快速开始-)
 - [生命周期](#生命周期-)
 - [核心概念](#核心概念-)
 - [合并生命周期](#合并生命周期-)
 - [自进化特性](#自进化特性-)
-- [斜杠命令](#斜杠命令)
+- [斜杠命令](#斜杠命令-)
 - [智能体集成](#智能体集成-)
 - [项目结构](#项目结构)
 - [配置](#配置-)
-- [从 v0.15 升级](#从-v015-升级)
+- [从 v0.15 升级](#从-v015-升级-)
 
 ## 什么是 REAP？ [↗](https://reap.cc/docs/introduction)
 
@@ -57,11 +57,13 @@ REAP 通过**自进化代际模型**解决这些问题：
 npm install -g @c-d-cc/reap
 ```
 
-> **前提条件**：[Node.js](https://nodejs.org) v18+，[Claude Code](https://claude.ai/claude-code) CLI。
+> **前提条件**：[Node.js](https://nodejs.org) v18+ 以及以下任一受支持的 AI 智能体：
+> - [Claude Code](https://claude.ai/claude-code) CLI（默认）
+> - [OpenCode](https://opencode.ai) — `/reap.init` 后在 `.reap/config.yml` 中设置 `agentClient: opencode`
 
 ## 快速开始 [↗](https://reap.cc/docs/quick-start)
 
-打开你的 AI 智能体（Claude Code）并使用斜杠命令：
+打开你的 AI 智能体（Claude Code 或 OpenCode）并使用斜杠命令：
 
 ```bash
 # 在你的项目中初始化 REAP（自动检测是全新项目还是已有代码库）
@@ -73,6 +75,8 @@ npm install -g @c-d-cc/reap
 
 `/reap.evolve` 驱动整个代际迭代生命周期——从学习到完成。AI 探索项目、规划工作、实施、验证并反思。这是日常开发的主要命令。
 
+> **OpenCode 用户**：`/reap.init` 后，在 `.reap/config.yml` 中设置 `agentClient: opencode`，然后运行 `reap update` 以重新生成客户端特定的资产（`opencode.json`、`.opencode/plugins/reap-plugin.ts`、`AGENTS.md` 以及 `~/.config/opencode/commands/` 中的斜杠命令）。
+
 > **注意：** 用户通过 AI 智能体中的 `/reap.*` 斜杠命令与 REAP 交互。CLI 是驱动这些命令的内部引擎。
 
 ## 生命周期 [↗](https://reap.cc/docs/lifecycle)
@@ -210,6 +214,7 @@ AI 根据当前上下文的明确程度调整其沟通风格：
 | `/reap.start` | 开始一个新的代际迭代 |
 | `/reap.next` | 推进到下一阶段 |
 | `/reap.back` | 返回上一阶段 |
+| `/reap.early-close` | 轻量级终止 — 保留部分价值，自动延迟未完成任务 |
 | `/reap.abort` | 中止当前代际迭代 |
 | `/reap.knowledge` | 审阅和管理 genome/environment |
 | `/reap.merge` | 合并生命周期操作 |
@@ -223,13 +228,19 @@ AI 根据当前上下文的明确程度调整其沟通风格：
 
 ## 智能体集成
 
-REAP 通过斜杠命令和生命周期钩子与 AI 智能体集成。当前支持：**Claude Code**。架构使用适配器模式以支持未来的智能体。
+REAP 通过基于 `agentClient` 配置字段的适配器层与 AI 智能体集成。当前支持的客户端：
+
+- **Claude Code** (`agentClient: claude-code`，默认) — 通过 `CLAUDE.md` 中的 `@` 导入加载静态知识；通过 SessionStart 钩子 (`reap load-context`) 注入动态状态；斜杠命令安装到 `~/.claude/commands/reap.*.md`。
+- **OpenCode** (`agentClient: opencode`) — 通过 `opencode.json` 的 `instructions` 字段加载静态知识；通过 `.reap/.session-state.md` 传递动态状态，捆绑的 OpenCode 插件 (`.opencode/plugins/reap-plugin.ts`) 在 `session.created` / `tool.execute.before` 时自动刷新；斜杠命令安装到 `~/.config/opencode/commands/reap.*.md`。
+
+通过编辑 `.reap/config.yml`，然后运行 `reap install-skills` 和 `reap update` 即可切换客户端。REAP 会重新生成入口点文件 (CLAUDE.md vs AGENTS.md)、会话集成以及任何客户端特定的资产。斜杠命令目录中的 `reap.` 前缀已保留 — 安装为先清理后复制方式，将覆盖这些位置中的任何 `reap.*.md` 文件。自定义命令请使用其他前缀 (`mytool.md`、`team.md` 等)。
 
 ### 工作原理
 
-1. **CLAUDE.md** 指示 AI 在会话开始时加载 genome、environment 和 reap-guide
-2. **斜杠命令** 调用 `reap run <cmd>`，返回结构化 JSON 指令给 AI
+1. **入口点文件** (claude-code 为 `CLAUDE.md`，opencode 为 `AGENTS.md`) 指示 AI 在会话开始时加载 genome、environment 和 reap-guide
+2. **斜杠命令** — `/reap.start`、`/reap.status`、`/reap.evolve` 等在 Claude Code 和 OpenCode 中均可工作；每个命令调用 `reap run <cmd>`，向 AI 返回结构化的 JSON 指令
 3. **基于签名的锁定**（nonce 链）在代码层面强制执行阶段顺序——不可跳过、不可伪造、不可重放
+4. **动态状态转储** — 每个 REAP 生命周期命令同步写入 `.reap/.session-state.md`，因此 OpenCode 用户在下次会话中始终能看到命令执行后的状态
 
 ### Subagent 模式
 

package/RELEASE_NOTICE.md

@@ -1,5 +1,11 @@
 # Release Notices
 
+## v0.16.6
+### en
+Evaluator Agent integration (opt-in `evaluator: true`): independent `reap-evaluate` subagent runs during validation and fitness phases as an advisor. High-severity concerns automatically abort cruise mode for human review.
+### ko
+Evaluator Agent 통합 (opt-in `evaluator: true`): `reap-evaluate` 서브에이전트가 validation/fitness 단계에서 독립 검토자로 실행됨 (advisor 모델). high-severity concern 발생 시 cruise mode 자동 중단.
+
 ## v0.16.4
 ### en
 Restore missing npm metadata (license, author, repository, homepage, keywords). Fix GitHub Releases showing empty release notes.

package/dist/adapters/claude-code/skills/reap.early-close.md

@@ -0,0 +1,5 @@
+---
+description: "REAP Early-close — Close the current generation as a partial save (lightweight termination between abort and full completion)"
+---
+
+Run `reap run early-close $ARGUMENTS` and follow the stdout instructions exactly.

package/dist/adapters/claude-code/skills/reap.evolve.md

@@ -3,3 +3,5 @@ description: "REAP Evolve — Run the full lifecycle for a Generation"
 ---
 
 Run `reap run evolve` and follow the stdout instructions exactly.
+
+IMPORTANT: The subagent is the sole lifecycle executor. If it returns before completion (e.g., needing user input), use SendMessage to resume the same subagent after collecting the user's response. Never execute lifecycle commands directly.