Back to Details

beads-workflow

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Beads Workflow — From Plan to Actionable Tasks

Beads工作流——从计划到可执行任务

Core Principle: "Check your beads N times, implement once" — where N is as many as you can stomach.
Beads are so detailed and polished that you can mechanically unleash a big swarm of agents to implement them, and it will come out just about perfectly.
核心原则：“反复检查你的Beads，一次完成实现”——这里的“反复”次数越多越好。
Beads足够详细且经过打磨，你可以机械地调用大型Agent集群来实现它们，最终结果几乎完美。

What Are Beads?

什么是Beads？

Beads are epics/tasks/subtasks with dependency structure, optimized for AI coding agents. Think of them as Jira or Linear, but designed for machines.
Key properties:
  • Self-contained — Never need to refer back to the original markdown plan
  • Self-documenting — Include background, reasoning, justifications, considerations
  • Dependency-aware — Explicit structure of what blocks what
  • Rich descriptions — Long markdown comments, not short bullet points
Beads是带有依赖结构的史诗任务/任务/子任务，专为AI编码Agent优化。可以把它们看作是为机器设计的Jira或Linear。
关键特性：
  • 自包含——无需回溯原始Markdown计划
  • 自文档化——包含背景、推理、理由、注意事项
  • 感知依赖——明确的任务阻塞结构
  • 丰富描述——长篇Markdown注释，而非简短要点

Why Beads Work

Beads为何有效

┌─────────────────────────────────────────────────────────────┐
│ MARKDOWN PLAN (~3,500 lines)                                │
│   └─► Fits in context window                                │
│   └─► Models reason about entire system at once             │
├─────────────────────────────────────────────────────────────┤
│                    ↓ CONVERT TO BEADS ↓                     │
├─────────────────────────────────────────────────────────────┤
│ BEADS (distributed tasks)                                   │
│   └─► Each bead is self-contained                           │
│   └─► Any agent can pick up any bead                        │
│   └─► BV (Beads Viewer) handles prioritization              │
│   └─► Agent Mail handles coordination                       │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ MARKDOWN计划（约3500行）                                   │
│   └─► 适配上下文窗口                                       │
│   └─► 模型可一次性推理整个系统                             │
├─────────────────────────────────────────────────────────────┤
│                    ↓ 转换为Beads ↓                         │
├─────────────────────────────────────────────────────────────┤
│ BEADS（分布式任务）                                        │
│   └─► 每个Beads都是自包含的                               │
│   └─► 任意Agent都可承接任意Beads                           │
│   └─► BV（Beads查看器）处理任务优先级                       │
│   └─► Agent Mail处理协调工作                               │
└─────────────────────────────────────────────────────────────┘

Converting Plans to Beads

将计划转换为Beads

THE EXACT PROMPT — Plan to Beads Conversion (Claude Code + Opus 4.5)

精确提示词——计划转Beads转换（Claude Code + Opus 4.5）

OK so now read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md; please take ALL of that and elaborate on it and use it to create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.). The beads should be so detailed that we never need to consult back to the original markdown plan document. Remember to ONLY use the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.
Note: Replace 
PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md
with your actual plan filename.
OK so now read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md; please take ALL of that and elaborate on it and use it to create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.). The beads should be so detailed that we never need to consult back to the original markdown plan document. Remember to ONLY use the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.
注意： 将
PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md
替换为你的实际计划文件名。

Alternative Shorter Version

简化版提示词

OK so please take ALL of that and elaborate on it more and then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.)  Use only the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.
OK so please take ALL of that and elaborate on it more and then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.)  Use only the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.

What This Creates

转换结果

  • Tasks and subtasks with clear scope
  • Dependency links (what must complete before what)
  • Detailed descriptions with:
    • Background context
    • Reasoning and justification
    • Technical considerations
    • How it serves project goals
  • 带有明确范围的任务和子任务
  • 依赖链接（哪些任务必须先完成）
  • 包含以下内容的详细描述：
    • 背景上下文
    • 推理与理由
    • 技术注意事项
    • 对项目目标的作用

Polishing Beads

打磨Beads

Why Polish?

为何要打磨？

Even after initial conversion, beads continue to improve with review. You get incremental improvements even at round 6+.
即使完成初始转换后，Beads也会随着审查不断改进。即使到第6轮及以后，仍能获得渐进式提升。

THE EXACT PROMPT — Polish Beads (Full Version)

精确提示词——打磨Beads（完整版）

Reread AGENTS dot md so it's still fresh in your mind. Then read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md . Use ultrathink. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things! DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY! Also make sure that as part of the beads we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. It's critical that EVERYTHING from the markdown plan be embedded into the beads so that we never need to refer back to the markdown plan and we don't lose any important context or ideas or insights into the new features planned and why we are making them.
Reread AGENTS dot md so it's still fresh in your mind. Then read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md . Use ultrathink. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things! DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY! Also make sure that as part of the beads we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. It's critical that EVERYTHING from the markdown plan be embedded into the beads so that we never need to refer back to the markdown plan and we don't lose any important context or ideas or insights into the new features planned and why we are making them.

THE EXACT PROMPT — Polish Beads (Standard Version)

精确提示词——打磨Beads（标准版）

Reread AGENTS dot md so it's still fresh in your mind. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things!

DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY!

Also, make sure that as part of these beads, we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. Remember to ONLY use the `bd` tool to create and modify the beads and to add the dependencies to beads. Use ultrathink.
Reread AGENTS dot md so it's still fresh in your mind. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things!

DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY!

Also, make sure that as part of these beads, we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. Remember to ONLY use the `bd` tool to create and modify the beads and to add the dependencies to beads. Use ultrathink.

Polishing Protocol

打磨流程

  1. Run the polishing prompt
  2. Review changes
  3. Repeat until steady-state (typically 6-9 rounds)
  4. If it flatlines, start a fresh CC session
  5. Optionally have Codex with GPT 5.2 do a final round
  1. 运行打磨提示词
  2. 审查变更
  3. 重复直到进入稳定状态（通常6-9轮）
  4. 如果进度停滞，开启新的Claude Code会话
  5. 可选：让Codex with GPT 5.2进行最终一轮审查

Fresh Session Technique

新会话技巧

If polishing starts to flatline, start a brand new Claude Code session:
如果打磨进度停滞，开启全新的Claude Code会话：

THE EXACT PROMPT — Re-establish Context

精确提示词——重建上下文

First read ALL of the AGENTS dot md file and README dot md file super carefully and understand ALL of both! Then use your code investigation agent mode to fully understand the code, and technical architecture and purpose of the project.  Use ultrathink.
First read ALL of the AGENTS dot md file and README dot md file super carefully and understand ALL of both! Then use your code investigation agent mode to fully understand the code, and technical architecture and purpose of the project.  Use ultrathink.

THE EXACT PROMPT — Then Review Beads

精确提示词——然后审查Beads

We recently transformed a markdown plan file into a bunch of new beads. I want you to very carefully review and analyze these using `bd` and `bv`.
Then follow up with the standard polish prompt.
We recently transformed a markdown plan file into a bunch of new beads. I want you to very carefully review and analyze these using `bd` and `bv`.
然后使用标准版打磨提示词跟进。

Cross-Model Review

跨模型审查

For extra polish, have different models review the beads:
ModelStrength
Claude Code + Opus 4.5Primary creation and refinement
Codex + GPT 5.2Final review pass
Gemini CLIAlternative perspective
为了获得更优质的打磨效果，可让不同模型审查Beads：
模型优势
Claude Code + Opus 4.5主要创建与优化工具
Codex + GPT 5.2最终审查环节
Gemini CLI提供替代视角

Bead Quality Checklist

Beads质量检查表

Before implementation, verify each bead:
  • Self-contained — Can be understood without external context
  • Clear scope — One coherent piece of work
  • Dependencies explicit — Links to blocking/blocked beads
  • Testable — Clear success criteria
  • Includes tests — Unit tests and e2e tests in scope
  • Preserves features — Nothing from the plan was lost
  • Not oversimplified — Complexity preserved where needed
实施前，验证每个Beads是否满足：
  • 自包含——无需外部上下文即可理解
  • 范围明确——单一连贯的工作内容
  • 依赖明确——包含阻塞/被阻塞的Beads链接
  • 可测试——明确的成功标准
  • 包含测试——范围中包含单元测试和端到端测试
  • 完整保留功能——计划中的内容无遗漏
  • 未过度简化——必要的复杂度得以保留

Using bd (Beads CLI)

使用bd（Beads命令行工具）

Basic Commands

基础命令

bash
undefined
bash
undefined

Initialize beads in project

在项目中初始化Beads

bd init
bd init

Create a new bead

创建新的Bead

bd create "Implement user authentication" -t feature -p 1
bd create "Implement user authentication" -t feature -p 1

Add dependencies

添加依赖

bd depend BD-123 BD-100 # BD-123 depends on BD-100
bd depend BD-123 BD-100 # BD-123依赖于BD-100

Update status

更新状态

bd update BD-123 --status in_progress
bd update BD-123 --status in_progress

Close a bead

关闭Bead

bd close BD-123 --reason "Completed and tested"
bd close BD-123 --reason "Completed and tested"

List ready beads (no blockers)

列出可执行的Beads（无阻塞）

bd ready --json
undefined
bd ready --json
undefined

Robot Mode for Agents

面向Agent的机器人模式

bash
undefined
bash
undefined

Get triage recommendations

获取分类推荐

bv --robot-triage
bv --robot-triage

Get the single top pick

获取优先级最高的任务

bv --robot-next
bv --robot-next

Get parallel execution tracks

获取并行执行轨迹

bv --robot-plan
bv --robot-plan

Get graph insights (PageRank, bottlenecks, cycles)

获取图表洞察（PageRank、瓶颈、循环）

bv --robot-insights

**CRITICAL:** Never run bare `bv` — it launches interactive TUI. Always use `--robot-*` flags.

---
bv --robot-insights

**重要提示：** 不要直接运行`bv`——它会启动交互式终端界面。请始终使用`--robot-*`参数。

---

Integration with Agent Mail

与Agent Mail集成

Conventions

约定

  • Use Beads issue ID as Mail 
    thread_id
    : 
    send_message(..., thread_id="bd-123")
  • Prefix subjects: 
    [bd-123] Starting auth refactor
  • Include issue ID in file reservation 
    reason
    : 
    file_reservation_paths(..., reason="bd-123")
  • 使用Beads问题ID作为邮件
    thread_id
    ：
    send_message(..., thread_id="bd-123")
  • 主题前缀：
    [bd-123] Starting auth refactor
  • 在文件锁定
    reason
    中包含问题ID：
    file_reservation_paths(..., reason="bd-123")

Typical Flow

典型流程

bash
undefined
bash
undefined

1. Pick ready work

1. 选择可执行任务

bd ready --json
bd ready --json

2. Reserve files

2. 锁定文件

file_reservation_paths(project_key, agent_name, ["src/**"], reason="bd-123")
file_reservation_paths(project_key, agent_name, ["src/**"], reason="bd-123")

3. Announce start

3. 宣布开始工作

send_message(..., thread_id="bd-123", subject="[bd-123] Starting work")
send_message(..., thread_id="bd-123", subject="[bd-123] Starting work")

4. Work on the bead

4. 处理Bead

...

...

5. Complete

5. 完成任务

bd close bd-123 --reason "Completed" release_file_reservations(project_key, agent_name)

---
bd close bd-123 --reason "Completed" release_file_reservations(project_key, agent_name)

---

Test Coverage Beads

测试覆盖Beads

THE EXACT PROMPT — Add Test Coverage

精确提示词——添加测试覆盖

Do we have full unit test coverage without using mocks/fake stuff? What about complete e2e integration test scripts with great, detailed logging? If not, then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid with detailed comments.
Do we have full unit test coverage without using mocks/fake stuff? What about complete e2e integration test scripts with great, detailed logging? If not, then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid with detailed comments.

When Beads Are Ready

Beads就绪状态

Your beads are ready for implementation when:
  1. Steady-state reached — Multiple polishing rounds yield minimal changes
  2. Cross-model reviewed — At least one alternative model has reviewed
  3. No cycles — 
    bv --robot-insights | jq '.Cycles'
    returns empty
  4. Tests included — Each feature bead has associated test beads
  5. Dependencies clean — Graph makes logical sense
当满足以下条件时，你的Beads即可进入实施阶段：
  1. 达到稳定状态——多轮打磨后变更极小
  2. 跨模型审查——至少有一个替代模型完成审查
  3. 无循环依赖——
    bv --robot-insights | jq '.Cycles'
    返回空
  4. 包含测试——每个功能Bead都有对应的测试Bead
  5. 依赖清晰——依赖图逻辑合理

Example Bead Structure

Bead结构示例

A well-formed bead looks like:
ID: BD-123
Title: Implement OAuth2 login flow
Type: feature
Priority: P1
Status: open

Dependencies: [BD-100 (User model), BD-101 (Session management)]
Blocks: [BD-200 (Protected routes), BD-201 (User dashboard)]

Description:
Implement OAuth2 login flow supporting Google and GitHub providers.
一个格式规范的Bead如下：
ID: BD-123
Title: Implement OAuth2 login flow
Type: feature
Priority: P1
Status: open

Dependencies: [BD-100 (User model), BD-101 (Session management)]
Blocks: [BD-200 (Protected routes), BD-201 (User dashboard)]

Description:
Implement OAuth2 login flow supporting Google and GitHub providers.

Background

Background

This is the primary authentication mechanism for the application. Users should be able to sign in with existing Google/GitHub accounts to reduce friction.
This is the primary authentication mechanism for the application. Users should be able to sign in with existing Google/GitHub accounts to reduce friction.

Technical Approach

Technical Approach

  • Use NextAuth.js for OAuth2 implementation
  • Store provider tokens encrypted in Supabase
  • Create unified user record on first login
  • Handle account linking for multiple providers
  • Use NextAuth.js for OAuth2 implementation
  • Store provider tokens encrypted in Supabase
  • Create unified user record on first login
  • Handle account linking for multiple providers

Success Criteria

Success Criteria

  • User can click "Sign in with Google/GitHub"
  • OAuth flow completes and redirects to dashboard
  • User record created/updated in database
  • Session cookie set correctly
  • Logout clears session properly
  • User can click "Sign in with Google/GitHub"
  • OAuth flow completes and redirects to dashboard
  • User record created/updated in database
  • Session cookie set correctly
  • Logout clears session properly

Test Plan

Test Plan

  • Unit: Token encryption/decryption
  • Unit: User record creation
  • E2E: Full OAuth flow (mock provider)
  • E2E: Account linking scenario
  • Unit: Token encryption/decryption
  • Unit: User record creation
  • E2E: Full OAuth flow (mock provider)
  • E2E: Account linking scenario

Considerations

Considerations

  • Handle provider API rate limits
  • Graceful degradation if provider is down
  • GDPR compliance for EU users

---
  • Handle provider API rate limits
  • Graceful degradation if provider is down
  • GDPR compliance for EU users

---

Complete Prompt Reference

完整提示词参考

Plan to Beads (Full)

计划转Beads（完整版）

OK so now read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md; please take ALL of that and elaborate on it and use it to create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.). The beads should be so detailed that we never need to consult back to the original markdown plan document. Remember to ONLY use the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.
OK so now read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md; please take ALL of that and elaborate on it and use it to create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.). The beads should be so detailed that we never need to consult back to the original markdown plan document. Remember to ONLY use the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.

Plan to Beads (Short)

计划转Beads（简化版）

OK so please take ALL of that and elaborate on it more and then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.)  Use only the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.
OK so please take ALL of that and elaborate on it more and then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid, with detailed comments so that the whole thing is totally self-contained and self-documenting (including relevant background, reasoning/justification, considerations, etc.-- anything we'd want our "future self" to know about the goals and intentions and thought process and how it serves the over-arching goals of the project.)  Use only the `bd` tool to create and modify the beads and add the dependencies. Use ultrathink.

Polish Beads (Full)

打磨Beads（完整版）

Reread AGENTS dot md so it's still fresh in your mind. Then read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md . Use ultrathink. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things! DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY! Also make sure that as part of the beads we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. It's critical that EVERYTHING from the markdown plan be embedded into the beads so that we never need to refer back to the markdown plan and we don't lose any important context or ideas or insights into the new features planned and why we are making them.
Reread AGENTS dot md so it's still fresh in your mind. Then read ALL of PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md . Use ultrathink. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things! DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY! Also make sure that as part of the beads we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. It's critical that EVERYTHING from the markdown plan be embedded into the beads so that we never need to refer back to the markdown plan and we don't lose any important context or ideas or insights into the new features planned and why we are making them.

Polish Beads (Standard)

打磨Beads（标准版）

Reread AGENTS dot md so it's still fresh in your mind. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things!

DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY!

Also, make sure that as part of these beads, we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. Remember to ONLY use the `bd` tool to create and modify the beads and to add the dependencies to beads. Use ultrathink.
Reread AGENTS dot md so it's still fresh in your mind. Check over each bead super carefully-- are you sure it makes sense? Is it optimal? Could we change anything to make the system work better for users? If so, revise the beads. It's a lot easier and faster to operate in "plan space" before we start implementing these things!

DO NOT OVERSIMPLIFY THINGS! DO NOT LOSE ANY FEATURES OR FUNCTIONALITY!

Also, make sure that as part of these beads, we include comprehensive unit tests and e2e test scripts with great, detailed logging so we can be sure that everything is working perfectly after implementation. Remember to ONLY use the `bd` tool to create and modify the beads and to add the dependencies to beads. Use ultrathink.

Fresh Session — Context

新会话——重建上下文

First read ALL of the AGENTS dot md file and README dot md file super carefully and understand ALL of both! Then use your code investigation agent mode to fully understand the code, and technical architecture and purpose of the project.  Use ultrathink.
First read ALL of the AGENTS dot md file and README dot md file super carefully and understand ALL of both! Then use your code investigation agent mode to fully understand the code, and technical architecture and purpose of the project.  Use ultrathink.

Fresh Session — Review

新会话——审查Beads

We recently transformed a markdown plan file into a bunch of new beads. I want you to very carefully review and analyze these using `bd` and `bv`.
We recently transformed a markdown plan file into a bunch of new beads. I want you to very carefully review and analyze these using `bd` and `bv`.

Add Test Coverage

添加测试覆盖

Do we have full unit test coverage without using mocks/fake stuff? What about complete e2e integration test scripts with great, detailed logging? If not, then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid with detailed comments.
Do we have full unit test coverage without using mocks/fake stuff? What about complete e2e integration test scripts with great, detailed logging? If not, then create a comprehensive and granular set of beads for all this with tasks, subtasks, and dependency structure overlaid with detailed comments.

Common Mistakes

常见错误

  1. Oversimplifying — Preserve complexity where it's needed
  2. Losing features — Every plan feature should become beads
  3. Skipping tests — Include unit and e2e test beads
  4. Single review — Keep polishing until truly steady-state
  5. Missing dependencies — Make all blocking relationships explicit
  6. Short descriptions — Beads should be verbose and self-documenting
  1. 过度简化——必要的复杂度需保留
  2. 功能遗漏——计划中的每个功能都应转换为Beads
  3. 跳过测试——包含单元测试和端到端测试Beads
  4. 单一审查——持续打磨直到真正进入稳定状态
  5. 依赖缺失——明确所有阻塞关系
  6. 描述简短——Beads应详细且自文档化