steve

Steve — wavybaby + GSD + Ralph 自律実行

3つのシステムを組み合わせます。

• wavybaby：自分でツールを装備するツールチェーン（CoVe による検証、skills.sh を使ったスキルの検出、MCP サーバーのセットアップ、プロジェクト設定）
• GSD：構造化されたプロジェクト管理（.planning/、ロードマップ、フェーズ、プラン、調査、検証、状態追跡）
• Ralph：自律的な while-true ループ（サーキットブレーカー、二重条件による終了、セッションの永続化、レート制限）

その結果、作りたいものを説明するだけで、Steve が作業に最適なツールを自ら装備し、PRD を生成し、完全な GSD プロジェクト構造を構築して、マイルストーンが完了するまで、検証済みのコードですべてのプランを実行する自律ループを開始します。

User's description
    |
    v
PHASE 0: Equip (wavybaby)
    |  - Detect project type and stack
    |  - Search skills.sh for relevant skills, install missing ones
    |  - Install missing MCP servers (Context7, Supabase, Sentry, etc.)
    |  - Set up project config (settings.local.json, CLAUDE.md)
    |  - Now the agent has the best tools for THIS specific project
    |
    v
PHASE 1: PRD Generation
    |  - Clarifying questions
    |  - Full PRD at .planning/specs/PRD.md
    |
    v
PHASE 2: GSD Project Bootstrap
    |  - PROJECT.md, ROADMAP.md, STATE.md, config.json
    |  - codebase/ docs (STACK, ARCHITECTURE, STRUCTURE, CONVENTIONS)
    |  - Phase directories with DISCOVERY.md per phase
    |
    v
PHASE 3: Plan Generation
    |  - Break each phase into {NN}-{NN}-PLAN.md files
    |  - Each plan: 1-4 hours, atomic, with verification steps
    |
    v
PHASE 4: Loop Configuration
    |  - .ralphrc tuned for GSD execution
    |  - PROMPT.md with GSD execution + CoVe verification logic
    |  - AGENT.md with build/test/lint commands
    |
    v
PHASE 5: Autonomous Execution
    - ralph --monitor
    - Each loop iteration: read STATE.md -> execute next plan (with CoVe on non-trivial code) -> write SUMMARY.md -> update STATE.md
    - Circuit breaker halts if stuck
    - Exits when all phases complete

---

フェーズ 0：装備（wavybaby）

何かを生成する前に、このプロジェクトに最適なツールをエージェントに装備させます。これが、Steve が素の GSD+Ralph と一線を画す点です。エージェントは何もわからないまま作業することはありません。

ステップ 1：プロジェクトの種類を検出する

次のファイルをスキャンします：package.json、pyproject.toml、Cargo.toml、go.mod、Gemfile、pubspec.yaml、Podfile、build.gradle。以下を特定します。

• 言語
• フレームワーク
• パッケージマネージャー
• 既存の依存関係

ステップ 2：関連するスキルを検索してインストールする

# Search skills.sh for skills matching the detected stack
npx skills find "[detected framework]"
npx skills find "[detected language]"
npx skills find "[project domain from user description]"

スタックに基づく自動インストールの推奨項目：

スタック	インストールするスキル
React / Next.js	npx skills add vercel-labs/agent-skills --skill vercel-react-best-practices --agent claude-code -y
React Native / Expo	npx skills add expo/skills --agent claude-code -y
Supabase	npx skills add supabase/agent-skills --agent claude-code -y
Stripe の決済機能	npx skills add stripe/skills --agent claude-code -y
Cloudflare	npx skills add cloudflare/skills --agent claude-code -y
あらゆる Web プロジェクト	npx skills add vercel-labs/agent-skills --skill web-design-guidelines --agent claude-code -y
セキュリティが重要な場合	npx skills add trailofbits/skills --agent claude-code -y

関連するスキルはすべてすぐにインストールしてください。確認は求めず、そのまま実行します。-y フラグにより、自動的に確認されます。

ステップ 3：不足している MCP サーバーをインストールする

すでに設定されている MCP サーバーを確認してから、関連するものをすべて直接インストールします。

サーバー	インストールする条件	コマンド
Context7	常に（ドキュメントに関するハルシネーションを防ぐため）	claude mcp add context7 -- npx -y @upstash/context7-mcp
GitHub	GitHub を使用する場合	claude mcp add github --transport http https://api.githubcopilot.com/mcp/
Supabase	スタックに Supabase が含まれる場合	claude mcp add supabase -- npx -y @supabase/mcp-server
Sentry	エラー追跡が必要な場合	claude mcp add sentry --transport http https://mcp.sentry.dev/mcp
Notion	ドキュメントのワークフローがある場合	claude mcp add notion --transport http https://mcp.notion.com/mcp
Sequential Thinking	複雑なアーキテクチャの場合	claude mcp add thinking -- npx -y mcp-sequentialthinking-tools

ステップ 4：プロジェクト設定を行う

存在しない場合は、適切な権限を設定した settings.local.json を作成します。

フルスタック（Node/React）：

{
  "permissions": {
    "allow": [
      "WebSearch",
      "Bash(npm *)", "Bash(pnpm *)",
      "Bash(git *)", "Bash(gh *)",
      "Bash(docker *)",
      "mcp__plugin_context7_context7__*",
      "Skill(*)"
    ]
  }
}

Python：

{
  "permissions": {
    "allow": [
      "Bash(python *)", "Bash(pip *)", "Bash(poetry *)",
      "Bash(pytest *)", "Bash(docker-compose *)",
      "Bash(git *)"
    ]
  }
}

検出したスタックに合わせて調整します。

ステップ 5：装備状況を報告する

Equipped for: [project type]

Skills installed:
  - [skill 1] (from [repo])
  - [skill 2] (from [repo])

MCP servers configured:
  - [server 1]: [purpose]
  - [server 2]: [purpose]

Project config: settings.local.json [created/updated/already exists]

---

フェーズ 1：PRD の生成

詳細なヒアリング（必須）

PRD を作成する前に、十分なヒアリングを実施してください。AskUserQuestion を使って複数のラウンドに分けて質問してください。PRD の作成を急がないでください。PRD の品質は、プロジェクトをどれだけ深く理解できるかにかかっています。全体像が明確になるまで質問を続けてください。

ラウンド 1：ビジョンとユーザー

• 「どのような問題を解決しますか？現在の課題は何ですか？」
• 「主なユーザーは誰ですか？異なるペルソナを 2～3 人挙げて説明してください。」
• 「成功とはどのような状態ですか？うまくいっていることをどう判断しますか？」
• 「既存の製品や競合はありますか？それらの問題点は何ですか？」

ラウンド 2：コアエクスペリエンス

• 「最初に開いてから日常的に使うまでの理想的なユーザージャーニーを教えてください。」
• 「役に立つために必須の機能を 3 つ挙げてください。その中で最も重要なものは何ですか？」
• 「使っているとき、ユーザーにどのように感じてほしいですか？（速い、落ち着く、パワフル、楽しい、シンプル）」
• 「即座に反応する必要があるワークフローと、読み込みに時間がかかってもよいワークフローはありますか？」

ラウンド 3：技術とプラットフォーム

• 「対象プラットフォームは何ですか？（iOS、Android、両方、ウェブ、デスクトップ、CLI）」
• 「連携が必要な既存のバックエンド、データベース、認証システム、API はありますか？」
• 「技術スタックやフレームワークに希望はありますか？それとも提案が必要ですか？」
• 「リアルタイム機能は必要ですか？（ライブ更新、コラボレーション、通知）」
• 「オフライン対応は必要ですか？インターネット接続なしで何ができる必要がありますか？」
• 「サードパーティサービスは必要ですか？（決済、マップ、分析、AI/ML、メッセージング）」

ラウンド 4：データとビジネスロジック

• 「このシステムの主要なエンティティやオブジェクトは何ですか？（ユーザー、投稿、注文など）」
• 「それらの主な関係はどのようなものですか？（1 人のユーザーが複数の X を持つ、X が Y に属するなど）」
• 「ユーザーの役割や権限レベルは異なりますか？それぞれ説明してください。」
• 「複雑なビジネスルールはありますか？（料金プラン、承認ワークフロー、計算など）」
• 「機密性の高いデータはありますか？（個人情報、財務、健康情報）」

ラウンド 5：スコープと制約

• 「MVP に含めるもの、あると望ましいもの、今は対象外のものは何ですか？」
• 「厳守すべき期限や制約はありますか？」
• 「デザインの希望はありますか？（ダークモード、特定のブランドカラー、参考にしたいアプリなど）」
• 「アクセシビリティについてはどうしますか？（スクリーンリーダー対応、色覚特性への配慮、運動機能への配慮）」
• 「国際化は必要ですか？対象の言語やロケールは何ですか？」
• 「コンプライアンス要件はありますか？（GDPR、HIPAA、SOC2、PCI）」

ラウンド 6：エッジケースと仕上げ

• 「問題が発生した場合はどうしますか？（インターネット接続なし、サーバーエラー、無効な入力）」
• 「どのような空の状態がありますか？（新規ユーザー、データがまだない、検索結果がない）」
• 「システムからどのような通知、メール、アラートを送信しますか？」
• 「オンボーディングフローはどうしますか？新規ユーザーはどのようにアプリを使い始めますか？」
• 「管理者向けの機能は必要ですか？（ダッシュボード、モデレーション、分析）」

質問をすべてする必要はありません。プロジェクトに明らかに関係のないものは省略してください。ただし、6 つのラウンドのうち少なくとも 4 つにまたがる質問は必須です。状況に応じて判断してください。ユーザーの説明が曖昧なら、さらに質問してください。詳細であれば、不足している点に絞ってください。

各ラウンドの後に、把握した内容を確認し、次のラウンドに進む前にまだ知る必要があることを説明してください。包括的な PRD を作成できるだけの情報が集まったら終了してください。

.planning/specs/PRD.md を生成する

以下のすべてのセクションを含む完全な PRD を作成してください。

# PRD: [Project Name]

## 1. Overview
One paragraph: what this does and why.

## 2. Target Users
| User Type | Description | Primary Need |
|-----------|-------------|--------------|
| ... | ... | ... |

## 3. User Stories

### Epic: [Feature Area 1]
- **US-001**: As a [user], I want to [action] so that [benefit]
  - Acceptance Criteria:
    - [ ] [Specific, testable criterion]
    - [ ] [Specific, testable criterion]

(Continue for all epics/stories)

## 4. Technical Requirements

### Stack
| Layer | Technology | Rationale |
|-------|-----------|-----------|
| ... | ... | ... |

### Architecture
- Key architectural decisions
- Data flow
- API structure

### Data Model
| Entity | Key Fields | Relationships |
|--------|-----------|---------------|
| ... | ... | ... |

### API Endpoints
| Method | Path | Purpose | Auth |
|--------|------|---------|------|
| ... | ... | ... | ... |

## 5. Screens & Navigation

### Screen Map
(Tree diagram of all screens/routes)

### Screen Descriptions
| Screen | Purpose | Key Components |
|--------|---------|----------------|
| ... | ... | ... |

## 6. Non-Functional Requirements
- Performance targets
- Security requirements
- Accessibility
- Offline support

## 7. MVP Scope
### In Scope (MVP)
### Out of Scope (Post-MVP)

## 8. Success Metrics
| Metric | Target | How Measured |
|--------|--------|--------------|
| ... | ... | ... |

## 9. Open Questions

続行前に承認を得る

AskUserQuestion を使って、次のように質問してください：「PRD を .planning/specs/PRD.md に生成しました。続行しますか？それとも変更しますか？」

---

フェーズ 2：GSD プロジェクトのブートストラップ

PRD が承認されたら、.planning/ の構造全体を作成してください。

ステップ 1：ディレクトリ構造を作成する

mkdir -p .planning/specs .planning/codebase .planning/phases

ステップ 2：PROJECT.md を生成する（PRD のセクション 1、4、7 から）

# Project: [Name]

## Vision
[From PRD §1 Overview]

## Requirements

### Validated
[From PRD §7 MVP In Scope — these are confirmed requirements]

### Active (Under Discussion)
[From PRD §9 Open Questions — unresolved items]

### Out of Scope
[From PRD §7 Out of Scope]

## Constraints
[From PRD §4 Stack rationale and §6 Non-Functional Requirements]

## Key Decisions
| Decision | Status | Rationale |
|----------|--------|-----------|
| [Stack choice from PRD §4] | Approved | [Rationale] |
| ... | ... | ... |

ステップ 3：ROADMAP.md を生成する（PRD のセクション 3、4、5 から）

PRD からフェーズを導き出します。すべてのフェーズはユーザーストーリーまたは技術要件に対応しています。

# Roadmap — Milestone 1: MVP

## Progress
| Phase | Name | Status | Plans |
|-------|------|--------|-------|
| 1 | Infrastructure & Setup | Not Started | TBD |
| 2 | Auth & User Management | Not Started | TBD |
| 3 | [Core Feature 1] | Not Started | TBD |
| ... | ... | ... | ... |

---

### Phase 1: Infrastructure & Setup
**Goal**: Project scaffolding, database schema, auth config, navigation skeleton
**Depends on**: None
**Research**: Likely
**Research topics**: [Stack from PRD §4]
**Traces to**: PRD §4 (Technical Requirements)

### Phase 2: Auth & User Management
**Goal**: Sign up, login, forgot password, session management
**Depends on**: Phase 1
**Research**: Unlikely
**Traces to**: PRD §3 Epic: Auth, PRD §5 Auth Stack screens

### Phase 3: [Core Feature from PRD §3]
**Goal**: [From user story epic]
**Depends on**: Phase 1, Phase 2
**Research**: [Likely/Unlikely]
**Traces to**: PRD §3 Epic: [Name], US-001 through US-00N

(Continue for all phases derived from PRD)

### Phase N: Polish & Verification
**Goal**: Error states, empty states, performance, accessibility
**Depends on**: All previous phases
**Traces to**: PRD §6 Non-Functional Requirements

導出ルール：

1. インフラストラクチャ／セットアップは常にフェーズ 1 です
2. 認証はフェーズ 2 です（該当する場合）
3. PRD の各エピックから 1 つ以上のフェーズを作成します
4. PRD §5 の画面マップからナビゲーションのフェーズを決定します
5. PRD §6 の非機能要件を最終仕上げフェーズにします
6. すべてのフェーズは PRD のセクションに対応しています

ステップ 4：STATE.md を生成する

# Project State

## Current Position
- **Phase**: 1 of N (Infrastructure & Setup)
- **Plan**: Not started
- **Status**: Not started
- **Progress**: [░░░░░░░░░░] 0%

## Performance Metrics
- Plans completed: 0
- Average duration: N/A
- Total execution time: 0

## Accumulated Context
- Decisions: See PROJECT.md
- Deferred issues: None
- Blockers: None

## Session
- Last activity: [date] — Project initialized
- Mode: Autonomous (Ralph loop)

ステップ 5：config.json を生成する

{
  "mode": "yolo",
  "depth": "comprehensive",
  "gates": {
    "confirm_project": false,
    "confirm_phases": false,
    "confirm_roadmap": false,
    "confirm_breakdown": false,
    "confirm_plan": false,
    "execute_next_plan": true,
    "issues_review": false,
    "confirm_transition": false
  },
  "safety": {
    "always_confirm_destructive": true,
    "always_confirm_external_services": true
  }
}

自律実行ではゲートを false に設定します。Ralph は確認のために停止しません。安全ゲートは true のままにします。

ステップ 6：コードベースのドキュメントを生成する

プロジェクトディレクトリにすでにコードがある場合は、gsd:map-codebase に相当する処理を実行します。

• .planning/codebase/STACK.md — 技術、依存関係、バージョン
• .planning/codebase/ARCHITECTURE.md — パターン、レイヤー、データフロー
• .planning/codebase/STRUCTURE.md — ディレクトリ構成
• .planning/codebase/CONVENTIONS.md — 命名規則、スタイル、パターン

新規プロジェクトの場合は、フェーズ 1 で情報を追加するスケルトン版を作成します。

---

フェーズ 3：計画の生成

フェーズ 1 のみ（最初に実行するフェーズ）について、ここで完全な計画を生成します。それ以降のフェーズは、前のフェーズから得られる情報を踏まえた判断ができるよう、ループが必要に応じて計画します。

フェーズ 1 の各計画について、{NN}-{NN}-PLAN.md を生成する：

<plan>
  <phase>1</phase>
  <plan-number>01</plan-number>
  <type>execute</type>
  <name>[Descriptive name]</name>
</plan>

<objective>
[What this plan delivers and why, traced to PRD section]
</objective>

<context>
- PRD: .planning/specs/PRD.md
- Project: .planning/PROJECT.md
- Stack: .planning/codebase/STACK.md
</context>

<tasks>
  <task type="auto">
    <name>[Task name]</name>
    <files>[Files to create/modify]</files>
    <action>
      [Detailed implementation instructions]
    </action>
    <verify>
      - [ ] [Verification step]
      - [ ] [Verification step]
    </verify>
    <done>[Success indicator]</done>
  </task>

  
</tasks>

<verification>
  - [ ] All files created/modified as specified
  - [ ] Tests pass
  - [ ] No TypeScript/lint errors
  - [ ] Acceptance criteria from PRD met
</verification>

<success_criteria>
[Definition of done for this plan]
</success_criteria>

---

フェーズ 4：ループの設定

ステップ 1：Ralph がインストールされているか確認する

which ralph-loop 2>/dev/null || which ralph 2>/dev/null

インストールされていない場合：

git clone https://github.com/frankbria/ralph-claude-code.git /tmp/ralph-claude-code
cd /tmp/ralph-claude-code && ./install.sh

ステップ 2：.ralphrc を生成する

PROJECT_NAME="$ARGUMENTS"
PROJECT_TYPE="[detected]"
MAX_CALLS_PER_HOUR=100
CLAUDE_TIMEOUT_MINUTES=20
CLAUDE_OUTPUT_FORMAT="json"
ALLOWED_TOOLS="Write,Read,Edit,Bash(git *),Bash(npm *),Bash(npx *),Skill(gsd:*)"
SESSION_CONTINUITY=true
SESSION_EXPIRY_HOURS=24
TASK_SOURCES="local"
CB_NO_PROGRESS_THRESHOLD=3
CB_SAME_ERROR_THRESHOLD=5
CB_OUTPUT_DECLINE_THRESHOLD=70

プロジェクトの種類に応じて ALLOWED_TOOLS を調整します。

• TypeScript/Node：Bash(npm *),Bash(npx *),Bash(node *)
• Python：Bash(python *),Bash(pip *),Bash(pytest *)
• Rust：Bash(cargo *),Bash(rustc *)
• Go：Bash(go *)
• Dockerfile がある場合は Bash(docker *) を追加します

ステップ 3：PROMPT.md を生成する

これは重要なファイルです。CoVe 検証を行いながら GSD 計画を実行する方法を、ループに指示します。

# Project: [PROJECT_NAME]

## Your Mission

You are working autonomously in a Ralph loop executing GSD plans. You are equipped with wavybaby tools — use them. Each iteration:

### 0. Use your tools

You have been equipped with skills and MCP servers for this project. USE THEM:
- **Context7**: Query up-to-date docs before using any library. Don't guess APIs.
- **Installed skills**: Follow best practices from installed skill files.
- **CoVe verification**: For any non-trivial code (stateful, async, database, auth, security), run the 4-stage CoVe protocol from /rnv before committing.

### 1. Read current state
- Read `.planning/STATE.md` to find current phase and plan
- Read `.planning/ROADMAP.md` for phase context and dependencies

### 2. Determine next action

Follow this decision tree:

現在のフェーズの DISCOVERY.md がありませんか？ はい → 調査を実行します。PRD を読み、コードベースを調べ、DISCOVERY.md を作成します 不慣れな技術のドキュメントを調べるには Context7 を使用します。 いいえ ↓

現在のフェーズに未生成の計画がありますか？ はい → DISCOVERY.md と PRD から次の {NN}-{NN}-PLAN.md を生成します いいえ ↓

現在のフェーズに未実行の計画がありますか？ はい → その計画を実行します（以下の「計画の実行」を参照） いいえ ↓

現在のフェーズの計画はすべて完了していますか？ はい → フェーズを完了します。ROADMAP.md を更新し、STATE.md を次のフェーズに進めます いいえ → 問題が発生しています。STATUS: BLOCKED に設定します。

すべてのフェーズが完了していますか？ はい → 検証ゲートを実行します。合格した場合は EXIT_SIGNAL: true に設定します いいえ → 次のフェーズに進みます（先頭に戻ります）

### 3. Execute a Plan

When executing a `{NN}-{NN}-PLAN.md`:

1. Read the plan file completely
2. Execute each `<task>` in order
3. **For non-trivial tasks**, apply CoVe:
   - Generate code [UNVERIFIED]
   - Plan verification targets specific to THIS code
   - Independently verify each target
   - Apply fixes → [VERIFIED] code
4. After each task, run its `<verify>` checks
5. After all tasks, run the plan's `<verification>` section
6. Write `{NN}-{NN}-SUMMARY.md` with results
7. Commit changes with descriptive message
8. Update `.planning/STATE.md` (increment plan, update metrics)

### 4. CoVe triggers

Apply the full 4-stage CoVe protocol (from /rnv) for:
- Stateful code (useState, useReducer, context, stores)
- Async/concurrent logic (useEffect, mutations, subscriptions)
- Database operations (queries, transactions, migrations)
- Auth/security code
- Cache invalidation logic
- Financial or precision-critical calculations
- Any code where the bug would be subtle, not obvious

Skip CoVe only for: trivial one-liners, pure formatting, config files.

### 5. Generate plans for next phase (just-in-time)

When advancing to a new phase:
1. Read DISCOVERY.md for that phase (or create it first)
2. Read relevant PRD sections (the phase's "Traces to" field)
3. Use Context7 to look up any new tech introduced in this phase
4. Generate all {NN}-{NN}-PLAN.md files for the phase
5. Begin executing plan 01

## Key Rules

- ONE plan per loop iteration (stay focused)
- Always run tests after implementation tasks
- Write SUMMARY.md after every completed plan
- Update STATE.md after every completed plan
- Reference the PRD for acceptance criteria — don't guess
- Use Context7 for library docs — don't hallucinate APIs
- Apply CoVe on non-trivial code — don't ship unverified
- If blocked, set STATUS: BLOCKED and explain why
- Never skip verification steps
- Commit atomically per task when possible

## Required Output Format

At the END of every response, output EXACTLY:

---RALPH_STATUS---
STATUS: IN_PROGRESS | COMPLETE | BLOCKED
PHASE: [current phase number and name]
PLAN: [current plan number or "generating" or "researching"]
TASKS_COMPLETED_THIS_LOOP: <number>
FILES_MODIFIED: <number>
TESTS_STATUS: PASSING | FAILING | NOT_RUN
WORK_TYPE: RESEARCH | PLANNING | IMPLEMENTATION | VERIFICATION
COVE_APPLIED: true | false | N/A
EXIT_SIGNAL: false
RECOMMENDATION: <what was done and what's next>
---END_RALPH_STATUS---

Set EXIT_SIGNAL: true ONLY when:
- ALL phases in ROADMAP.md are complete
- ALL SUMMARY.md files written
- Final verification gate passes
- STATE.md shows 100% progress

ステップ 4：AGENT.md を生成する

# Agent Instructions

## Build
[detected build command]

## Test
[detected test command]

## Run
[detected run command]

## Lint
[detected lint command]

## Type Check
[detected type check command if applicable]

## Equipped Tools
- Context7: Use `mcp__plugin_context7_context7__resolve-library-id` then `query-docs` for any library docs
- Installed skills: [list skills installed in Phase 0]
- CoVe: Apply 4-stage verification on non-trivial code (see PROMPT.md §4)

## GSD Commands
- Execute plan: Read the PLAN.md and follow its tasks
- Write summary: Create SUMMARY.md after plan completion
- Update state: Modify STATE.md with progress

ステップ 5：.gitignore に追加する

echo -e "\n# Ralph loop state\n.ralph/logs/\n.ralph/status.json\n.ralph/progress.json\n.ralph/.call_count\n.ralph/.last_reset\n.ralph/.exit_signals\n.ralph/.response_analysis\n.ralph/.circuit_breaker_state\n.ralph/.claude_session_id\n.ralph/.ralph_session\n.ralph/.ralph_session_history" >> .gitignore

ステップ 6：実行手順を表示する

Steve setup complete.

EQUIPPED:
  Skills:         [list installed skills]
  MCP servers:    [list configured servers]
  Config:         settings.local.json

PROJECT:
  PRD:            .planning/specs/PRD.md        (review before running)
  Project:        .planning/PROJECT.md          (derived from PRD)
  Roadmap:        .planning/ROADMAP.md          (phases derived from PRD)
  State:          .planning/STATE.md            (tracks progress)
  Phase 1 Plans:  .planning/phases/01-*/        (ready to execute)

LOOP:
  Config:         .ralphrc                      (rate limits, timeouts)
  Prompt:         .ralph/PROMPT.md              (GSD + CoVe execution logic)
  Build/test:     .ralph/AGENT.md               (edit if auto-detect wrong)

To run:
  ralph --monitor      # Recommended: loop + dashboard in tmux
  ralph                # Loop only

The loop will:
  1. Execute Phase 1 plans sequentially (with CoVe on non-trivial code)
  2. Write SUMMARY.md after each plan
  3. Use Context7 for library docs (no hallucinated APIs)
  4. Generate Phase 2 plans just-in-time
  5. Continue through all phases
  6. Run final verification gate
  7. Exit when milestone is complete

To check progress:
  cat .planning/STATE.md
  ralph-monitor

---

ループによる GSD の実行方法

反復ごとのフロー

Loop iteration N:
  1. Read .planning/STATE.md
  2. Identify: Phase X, Plan Y
  3. If DISCOVERY.md missing → research phase (use Context7) → write DISCOVERY.md → done
  4. If plans not generated → generate plans from DISCOVERY + PRD → done
  5. Read .planning/phases/{X}-{name}/{XX}-{YY}-PLAN.md
  6. Execute all tasks in plan
     - Non-trivial code → CoVe 4-stage verification
     - Library usage → Context7 doc lookup
  7. Run verification checks
  8. Write {XX}-{YY}-SUMMARY.md
  9. Update STATE.md (plan Y+1, metrics)
  10. If last plan in phase → update ROADMAP.md, advance to Phase X+1
  11. If last phase → verification gate → EXIT_SIGNAL: true
  12. Output RALPH_STATUS block

サーキットブレーカー（Ralph による）

トリガー	結果
ファイルに変更がない状態が 3 ループ続く	OPEN（停止）
同じエラーが 5 ループ続く	OPEN（停止）
STATE.md に進捗がない状態が 2 ループ続く	HALF_OPEN（監視中）
進捗が再開する	CLOSED（復旧）

終了検出（二重条件ゲート）

Ralph は、以下の両方を満たした場合にのみ停止します。

1. completion_indicators >= 2（RALPH_STATUS ブロックから）
2. EXIT_SIGNAL: true（すべてのフェーズが完了し、検証ゲートに合格）

セッションの継続性

• --continue フラグによってセッションが継続されます
• .planning/STATE.md によって、Ralph に組み込まれたセッション機能に加えて継続性を確保します
• Ralph のセッションがリセットされても、STATE.md にエージェントが再開すべき正確な位置が記されています

---

比較

機能	Spidey	GSD のみ	Steve
自動設定（スキル、MCP、設定）	いいえ	いいえ	はい（wavybaby）
PRD の生成	はい	いいえ	はい
構造化されたフェーズ	いいえ（フラットなチェックリスト）	はい	はい
発見・調査ドキュメント	いいえ	はい	はい
検証付きのアトミックな計画	いいえ	はい	はい
CoVe コード検証	いいえ	いいえ	はい（wavybaby/rnv）
Context7 ドキュメント参照	いいえ	いいえ	はい（wavybaby）
状態の追跡	基本	詳細	詳細
自律的な実行	はい（Ralph ループ）	いいえ（手動）	はい（Ralph ループ）
サーキットブレーカー	はい	いいえ	はい
セッションの永続化	Ralph セッション	STATE.md	両方
ジャストインタイム計画	いいえ（すべて事前に作成）	はい	はい
SUMMARY.md の監査証跡	いいえ	はい	はい
コードベースのドキュメント	いいえ	はい	はい
進捗指標／ベロシティ	基本	詳細	詳細

---

$ARGUMENTS 向けに Steve をセットアップします