steve

Steve — wavybaby + GSD + Ralph 自主执行

结合三个系统：

• 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）

在生成任何内容之前，先为 Agent 配备最适合此项目的工具。这正是 Steve 区别于原始 GSD+Ralph 的地方——Agent 不会盲目行动。

第 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、两者、Web、桌面端、CLI）”
• “是否有需要集成的现有后端、数据库、身份验证系统或 API？”
• “对技术栈或框架有偏好吗？还是需要我提出建议？”
• “是否需要实时功能？（实时更新、协作、通知）”
• “是否需要离线支持？断网时哪些功能仍应可用？”
• “是否涉及第三方服务？（支付、地图、分析、AI/ML、消息传递）”

第 4 轮：数据与业务逻辑

• “系统中的核心实体或对象有哪些？（用户、帖子、订单等）”
• “它们之间有哪些关键关系？（一个用户拥有多个 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 中的每个 Epic 都对应一个或多个阶段
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
  }
}

自主执行时，Gates 设为 false——Ralph 不会停下来询问。安全 Gates 仍设为 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（已停止）
连续 2 次循环未推进 STATE.md	HALF_OPEN（监控中）
恢复进展	CLOSED（已恢复）

退出检测（双重条件门禁）

Ralph 仅在以下两项都满足时停止：

1. completion_indicators >= 2（来自 RALPH_STATUS 块）
2. EXIT_SIGNAL: true（所有阶段均已完成，且验证门禁已通过）

会话连续性

• 会话通过 --continue 标志保持
• .planning/STATE.md 在 Ralph 内置会话之外提供额外的连续性
• 即使 Ralph 会话重置，STATE.md 也会准确告知 Agent 从何处继续

对比

特性	Spidey	仅 GSD	Steve
自动配置（技能、MCP、配置）	否	否	是（wavybaby）
PRD 生成	是	否	是
结构化阶段	否（扁平清单）	是	是
探索/研究文档	否	是	是
带验证的原子计划	否	是	是
CoVe 代码验证	否	否	是（wavybaby/rnv）
Context7 文档查询	否	否	是（wavybaby）
状态跟踪	基本	详细	详细
自主执行	是（Ralph 循环）	否（手动）	是（Ralph 循环）
熔断器	是	否	是
会话持久化	Ralph 会话	STATE.md	两者兼有
即时规划	否（全部预先规划）	是	是
SUMMARY.md 审计记录	否	是	是
代码库文档	否	是	是
进度指标/速度	基本	详细	详细

---

现在正在为以下内容设置 Steve：$ARGUMENTS