crank

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Crank Skill

Quick Ref: Autonomous epic execution. Local mode:
/swarm
for each wave with runtime-native spawning. Distributed mode:
/swarm --mode=distributed
(tmux + Agent Mail). Output: closed issues + final vibe.

YOU MUST EXECUTE THIS WORKFLOW. Do not just describe it.

Autonomous execution: implement all issues until the epic is DONE.

CLI dependencies: bd (issue tracking), ao (knowledge flywheel). Both optional — see

skills/shared/SKILL.md

for fallback table. If bd is unavailable, use TaskList for issue tracking and skip beads sync. If ao is unavailable, skip knowledge injection/extraction.

快速参考： 自主执行史诗级任务。本地模式：每轮任务使用/swarm命令，通过运行时原生生成方式执行。分布式模式：使用/swarm --mode=distributed命令（tmux + Agent Mail）。输出：已关闭的任务 + 最终反馈。

你必须执行此工作流，而非仅进行描述。

自主执行：完成所有任务直至史诗级任务全部结束。

CLI依赖项： bd（任务追踪工具）、ao（知识飞轮工具）。二者均为可选工具——如需备选方案，请查看

skills/shared/SKILL.md

中的 fallback 表格。若bd不可用，使用TaskList进行任务追踪并跳过beads同步。若ao不可用，跳过知识注入/提取步骤。

Architecture: Crank + Swarm

架构：Crank + Swarm

Beads mode (bd available):

Crank (orchestrator)           Swarm (executor)
    |                              |
    +-> bd ready (wave issues)     |
    |                              |
    +-> TaskCreate from beads  --->+-> Select spawn backend (codex sub-agents | claude teams | fallback)
    |                              |
    +-> /swarm                 --->+-> Spawn workers per backend
    |                              |   (fresh context per wave)
    +-> Verify + bd update     <---+-> Workers report via backend channel
    |                              |
    +-> Loop until epic DONE   <---+-> Cleanup backend resources after wave

TaskList mode (bd unavailable):

Crank (orchestrator, TaskList mode)    Swarm (executor)
    |                                      |
    +-> TaskList() (wave tasks)            |
    |                                      |
    +-> /swarm                         --->+-> Select spawn backend per wave
    |                                      |
    +-> Verify via TaskList()          <---+-> Workers report via backend channel
    |                                      |
    +-> Loop until all completed       <---+-> Cleanup backend resources after wave

Separation of concerns:

Crank = Orchestration, epic/task lifecycle, knowledge flywheel
Swarm = Runtime-native parallel execution (Ralph Wiggum pattern via fresh worker set per wave)

Beads模式（bd可用时）：

Crank (编排器)           Swarm (执行器)
    |                              |
    +-> bd ready (本轮任务)     |
    |                              |
    +-> 从beads创建Task  --->+-> 选择生成后端（Codex子代理 | Claude团队 | 备选方案）
    |                              |
    +-> /swarm                 --->+-> 基于后端生成工作进程
    |                              |   (每轮任务使用全新上下文)
    +-> 验证 + 更新bd     <---+-> 工作进程通过后端渠道汇报
    |                              |
    +-> 循环直至史诗任务完成   <---+-> 本轮任务结束后清理后端资源

TaskList模式（bd不可用时）：

Crank (编排器，TaskList模式)    Swarm (执行器)
    |                                      |
    +-> TaskList() (本轮任务)            |
    |                                      |
    +-> /swarm                         --->+-> 为每轮任务选择生成后端
    |                                      |
    +-> 通过TaskList()验证          <---+-> 工作进程通过后端渠道汇报
    |                                      |
    +-> 循环直至所有任务完成       <---+-> 本轮任务结束后清理后端资源

关注点分离：

Crank = 编排、史诗/任务生命周期管理、知识飞轮
Swarm = 运行时原生并行执行（每轮任务使用全新工作进程组的Ralph Wiggum模式）

Global Limits

全局限制

MAX_EPIC_WAVES = 50 (hard limit across entire epic)

This prevents infinite loops on circular dependencies or cascading failures.

Why 50?

Typical epic: 5-10 issues
With retries: ~5 waves max
50 = safe upper bound

MAX_EPIC_WAVES = 50（整个史诗任务的硬限制）

此限制用于防止因循环依赖或级联故障导致的无限循环。

为何设置为50？

典型史诗任务包含5-10个任务
加上重试，最多约5轮任务
50是安全的上限值

Completion Enforcement (The Sisyphus Rule)

完成强制规则（西西弗斯规则）

THE SISYPHUS RULE: Not done until explicitly DONE.

After each wave, output completion marker:

```
<promise>DONE</promise>
```
- Epic truly complete, all issues closed
```
<promise>BLOCKED</promise>
```
- Cannot proceed (with reason)
```
<promise>PARTIAL</promise>
```
- Incomplete (with remaining items)

Never claim completion without the marker.

西西弗斯规则： 除非明确标记为完成，否则任务未结束。

每轮任务结束后，输出完成标记：

```
<promise>DONE</promise>
```
- 史诗任务真正完成，所有子任务已关闭
```
<promise>BLOCKED</promise>
```
- 无法继续执行（需说明原因）
```
<promise>PARTIAL</promise>
```
- 任务未完成（需列出剩余项）

未输出标记时，绝不能宣称任务完成。

Execution Steps

执行步骤

Given

/crank [epic-id | plan-file.md | "description"]

给定命令

/crank [epic-id | plan-file.md | "描述文本"]

：

Step 0: Load Knowledge Context (ao Integration)

步骤0：加载知识上下文（ao集成）

Search for relevant learnings before starting the epic:

bash

undefined

开始史诗任务前，搜索相关经验：

bash

undefined

If ao CLI available, inject prior knowledge about epic execution

若ao CLI可用，注入与史诗任务执行相关的过往经验

if command -v ao &>/dev/null; then # Search for relevant learnings ao search "epic execution implementation patterns" 2>/dev/null | head -20

# Check flywheel status
ao flywheel status 2>/dev/null

# Get current ratchet state
ao ratchet status 2>/dev/null


If ao not available, skip this step and proceed. The knowledge flywheel enhances but is not required.

if command -v ao &>/dev/null; then # 搜索相关经验 ao search "epic execution implementation patterns" 2>/dev/null | head -20

# 检查知识飞轮状态
ao flywheel status 2>/dev/null

# 获取当前棘轮状态
ao ratchet status 2>/dev/null


若ao不可用，跳过此步骤继续执行。知识飞轮仅用于增强功能，非必需项。

Step 0.5: Detect Tracking Mode

步骤0.5：检测追踪模式

bash

if command -v bd &>/dev/null; then
  TRACKING_MODE="beads"
else
  TRACKING_MODE="tasklist"
  echo "Note: bd CLI not found. Using TaskList for issue tracking."
fi

Tracking mode determines the source of truth for the rest of the workflow:

	Beads Mode	TaskList Mode
Source of truth	`bd` (beads issues)	TaskList (Claude-native)
Find work	`bd ready`	`TaskList()` → pending, unblocked
Get details	`bd show <id>`	`TaskGet(taskId)`
Mark complete	`bd update <id> --status closed`	`TaskUpdate(taskId, status="completed")`
Track retries	`bd comments add`	Task description update
Epic tracking	`bd update <epic-id> --append-notes`	In-memory wave counter

bash

if command -v bd &>/dev/null; then
  TRACKING_MODE="beads"
else
  TRACKING_MODE="tasklist"
  echo "注意：未找到bd CLI。将使用TaskList进行任务追踪。"
fi

追踪模式决定了后续工作流的事实来源：

	Beads模式	TaskList模式
事实来源	`bd` （beads任务）	TaskList（Claude原生工具）
获取任务	`bd ready`	`TaskList()` → 待处理、未阻塞的任务
获取详情	`bd show <id>`	`TaskGet(taskId)`
标记完成	`bd update <id> --status closed`	`TaskUpdate(taskId, status="completed")`
追踪重试	`bd comments add`	更新任务描述
史诗任务追踪	`bd update <epic-id> --append-notes`	内存中的轮次计数器

Step 1: Identify the Epic / Work Source

步骤1：确定史诗任务/工作来源

Beads mode:

If epic ID provided: Use it directly. Do NOT ask for confirmation.

If no epic ID: Discover it:

bash

bd list --type epic --status open 2>/dev/null | head -5

If multiple epics found, ask user which one.

TaskList mode:

If input is an epic ID → Error: "bd CLI required for beads epic tracking. Install bd or provide a plan file / task list."

If input is a plan file path (

.md

Read the plan file
Decompose into TaskList tasks (one
```
TaskCreate
```
per distinct work item)
Set up dependencies via
```
TaskUpdate(addBlockedBy)
```
Proceed to Step 3

If no input:

Check
```
TaskList()
```
for existing pending tasks
If tasks exist, use them as the work items
If no tasks, ask user what to work on

If input is a description string:

Decompose into tasks (
```
TaskCreate
```
for each)
Set up dependencies
Proceed to Step 3

Beads模式：

若提供了史诗ID： 直接使用该ID，无需确认。

若未提供史诗ID： 自动发现：

bash

bd list --type epic --status open 2>/dev/null | head -5

若发现多个史诗任务，询问用户选择哪一个。

TaskList模式：

若输入为史诗ID → 报错："需要bd CLI以支持beads史诗任务追踪。请安装bd或提供计划文件/任务列表。"

若输入为计划文件路径（

.md

）：

读取计划文件
将其分解为TaskList任务（每个独立工作项对应一个
```
TaskCreate
```
）
通过
```
TaskUpdate(addBlockedBy)
```
设置依赖关系
进入步骤3

若未提供输入：

检查
```
TaskList()
```
中是否存在待处理任务
若存在任务，将其作为工作项
若无任务，询问用户需要处理的内容

若输入为描述文本：

将其分解为任务（每个任务对应一个
```
TaskCreate
```
）
设置依赖关系
进入步骤3

Step 1a: Initialize Wave Counter

步骤1a：初始化轮次计数器

Beads mode:

bash

undefined

Beads模式：

bash

undefined

Initialize crank tracking in epic notes

在史诗任务备注中初始化Crank追踪

bd update <epic-id> --append-notes "CRANK_START: wave=0 at $(date -Iseconds)" 2>/dev/null


**TaskList mode:** Track wave counter in memory only. No external state needed.

Track in memory: `wave=0`

bd update <epic-id> --append-notes "CRANK_START: wave=0 at $(date -Iseconds)" 2>/dev/null


**TaskList模式：** 仅在内存中追踪轮次计数器，无需外部状态。

内存中记录：`wave=0`

Step 2: Get Epic Details

步骤2：获取史诗任务详情

Beads mode:

bash

bd show <epic-id> 2>/dev/null

TaskList mode:

TaskList()

to see all tasks and their status/dependencies.

Beads模式：

bash

bd show <epic-id> 2>/dev/null

TaskList模式： 使用

TaskList()

查看所有任务及其状态/依赖关系。

Step 3: List Ready Issues (Current Wave)

步骤3：列出可执行任务（当前轮次）

Beads mode:

Find issues that can be worked on (no blockers):

bash

bd ready 2>/dev/null

bd ready
returns the current wave - all unblocked issues. These can be executed in parallel because they have no dependencies on each other.

TaskList mode:

TaskList()

→ filter for status=pending, no blockedBy (or all blockers completed). These are the current wave.

Beads模式：

查找可执行的无阻塞任务：

bash

bd ready 2>/dev/null

bd ready
返回当前轮次任务 - 所有未被阻塞的任务。这些任务可并行执行，因为彼此之间无依赖关系。

TaskList模式：

TaskList()

→ 筛选状态为pending、无blockBy（或所有阻塞项已完成）的任务。这些任务即为当前轮次任务。

Step 3a: Pre-flight Check - Issues Exist

步骤3a：预检查 - 任务存在性

Verify there are issues to work on:

If 0 ready issues found (beads mode) or 0 pending unblocked tasks (TaskList mode):

STOP and return error:
  "No ready issues found for this epic. Either:
   - All issues are blocked (check dependencies)
   - Epic has no child issues (run /plan first)
   - All issues already completed"

Also verify: epic has at least 1 child issue total. An epic with 0 children means /plan was not run.

Do NOT proceed with empty issue list - this produces false "epic complete" status.

验证是否有可执行的任务：

若未找到可执行任务（Beads模式）或未找到待处理的无阻塞任务（TaskList模式）：

停止执行并返回错误：
  "未找到该史诗任务的可执行任务。可能原因：
   - 所有任务均被阻塞（请检查依赖关系）
   - 史诗任务无子任务（请先运行/plan命令）
   - 所有任务已完成"

同时需验证：史诗任务至少包含1个子任务。若史诗任务无子任务，说明未运行/plan命令。

任务列表为空时，请勿继续执行 - 这会导致错误的“史诗任务完成”状态。

Step 4: Execute Wave via Swarm

步骤4：通过Swarm执行本轮任务

BEFORE each wave:

bash

wave=$((wave + 1))
WAVE_START_SHA=$(git rev-parse HEAD)

if [[ "$TRACKING_MODE" == "beads" ]]; then
    bd update <epic-id> --append-notes "CRANK_WAVE: $wave at $(date -Iseconds)" 2>/dev/null
fi

每轮任务执行前：

bash

wave=$((wave + 1))
WAVE_START_SHA=$(git rev-parse HEAD)

if [[ "$TRACKING_MODE" == "beads" ]]; then
    bd update <epic-id> --append-notes "CRANK_WAVE: $wave at $(date -Iseconds)" 2>/dev/null
fi

CHECK GLOBAL LIMIT

检查全局限制

if [[ $wave -ge 50 ]]; then echo "<promise>BLOCKED</promise>" echo "Global wave limit (50) reached." # STOP - do not continue fi


**Cross-cutting constraint injection (SDD):**

Before spawning workers, check for cross-cutting constraints:

```bash

if [[ $wave -ge 50 ]]; then echo "<promise>BLOCKED</promise>" echo "已达到全局轮次限制（50轮）。" # 停止执行 - 请勿继续 fi


**横切约束注入（SDD）：**

生成工作进程前，检查横切约束：

```bash

Guard clause: skip if plan has no boundaries (backward compat)

防护子句：若计划无边界则跳过（向后兼容）

PLAN_FILE=$(ls -t .agents/plans/*.md 2>/dev/null | head -1) if [[ -n "$PLAN_FILE" ]] && grep -q "## Boundaries" "$PLAN_FILE"; then # Extract "Always" boundaries and convert to cross_cutting checks # Read the plan's ## Cross-Cutting Constraints section or derive from ## Boundaries # Inject into every TaskCreate's metadata.validation.cross_cutting fi

PLAN_FILE=$(ls -t .agents/plans/*.md 2>/dev/null | head -1) if [[ -n "$PLAN_FILE" ]] && grep -q "## Boundaries" "$PLAN_FILE"; then # 提取“Always”边界并转换为横切检查 # 读取计划的## Cross-Cutting Constraints部分或从## Boundaries推导 # 将其注入每个TaskCreate的metadata.validation.cross_cutting中 fi

"Ask First" boundaries: in auto mode, log as annotation only (no blocking)

"Ask First"边界：自动模式下仅记录为注释（不阻塞执行）

In --interactive mode, prompt before proceeding

--interactive模式下，执行前需提示用户


When creating TaskCreate for each wave issue, include cross-cutting constraints in metadata:
```json
{
  "validation": {
    "files_exist": [...],
    "content_check": {...},
    "cross_cutting": [
      {"name": "...", "type": "content_check", "file": "...", "pattern": "..."}
    ]
  }
}

For wave execution details (beads sync, TaskList bridging, swarm invocation), read
skills/crank/references/team-coordination.md
.

Cross-cutting validation (SDD):

After per-task validation passes, run cross-cutting checks across all files modified in the wave:

bash

undefined


为每轮任务创建TaskCreate时，在元数据中包含横切约束：
```json
{
  "validation": {
    "files_exist": [...],
    "content_check": {...},
    "cross_cutting": [
      {"name": "...", "type": "content_check", "file": "...", "pattern": "..."}
    ]
  }
}

关于轮次执行的详细信息（beads同步、TaskList桥接、swarm调用），请查看
skills/crank/references/team-coordination.md
。

横切验证（SDD）：

每个任务的验证通过后，对本轮任务中修改的所有文件执行横切检查：

bash

undefined

Only if cross_cutting constraints were injected

仅当注入了横切约束时执行

if [[ -n "$CROSS_CUTTING_CHECKS" ]]; then WAVE_FILES=$(git diff --name-only "${WAVE_START_SHA}..HEAD") for check in $CROSS_CUTTING_CHECKS; do run_validation_check "$check" "$WAVE_FILES" done fi

undefined

if [[ -n "$CROSS_CUTTING_CHECKS" ]]; then WAVE_FILES=$(git diff --name-only "${WAVE_START_SHA}..HEAD") for check in $CROSS_CUTTING_CHECKS; do run_validation_check "$check" "$WAVE_FILES" done fi

undefined

Step 5: Verify and Sync to Beads (MANDATORY)

步骤5：验证并同步至Beads（强制要求）

Swarm executes per-task validation (see
skills/shared/validation-contract.md
). Crank trusts swarm validation and focuses on beads sync.

For verification details, retry logic, and failure escalation, read
skills/crank/references/team-coordination.md
and
skills/crank/references/failure-recovery.md
.

Swarm负责每个任务的验证（详见
skills/shared/validation-contract.md
）。Crank信任Swarm的验证结果，专注于与beads的同步工作。

关于验证详情、重试逻辑与故障升级，请查看
skills/crank/references/team-coordination.md
和
skills/crank/references/failure-recovery.md
。

Step 5.5: Wave Vibe Gate (MANDATORY)

步骤5.5：轮次反馈校验门（强制要求）

Principle: Fresh context catches what saturated context misses. No self-grading.

For wave vibe gate details (diff computation, acceptance criteria, verdict gating), read
skills/crank/references/wave-patterns.md
.

原则： 全新上下文能发现饱和上下文遗漏的问题。禁止自我评分。

关于轮次反馈校验门的详细信息（差异计算、验收标准、 verdict 校验），请查看
skills/crank/references/wave-patterns.md
。

Step 5.7: Wave Checkpoint

步骤5.7：轮次检查点

After each wave completes (post-vibe-gate, pre-next-wave), write a checkpoint file:

bash

mkdir -p .agents/crank

cat > ".agents/crank/wave-${wave}-checkpoint.json" <<EOF
{
  "wave": ${wave},
  "timestamp": "$(date -Iseconds)",
  "tasks_completed": $(echo "$COMPLETED_IDS" | jq -R 'split(" ")'),
  "tasks_failed": $(echo "$FAILED_IDS" | jq -R 'split(" ")'),
  "files_changed": $(git diff --name-only "${WAVE_START_SHA}..HEAD" | jq -R . | jq -s .),
  "git_sha": "$(git rev-parse HEAD)"
}
EOF

```
COMPLETED_IDS
```
/
```
FAILED_IDS
```
: space-separated issue IDs from the wave results.
On retry of the same wave, the file is overwritten (same path).
Checkpoint files are informational — no resume logic reads them yet (future work).

每轮任务完成后（反馈校验门之后，下一轮任务之前），写入检查点文件：

bash

mkdir -p .agents/crank

cat > ".agents/crank/wave-${wave}-checkpoint.json" <<EOF
{
  "wave": ${wave},
  "timestamp": "$(date -Iseconds)",
  "tasks_completed": $(echo "$COMPLETED_IDS" | jq -R 'split(" ")'),
  "tasks_failed": $(echo "$FAILED_IDS" | jq -R 'split(" ")'),
  "files_changed": $(git diff --name-only "${WAVE_START_SHA}..HEAD" | jq -R . | jq -s .),
  "git_sha": "$(git rev-parse HEAD)"
}
EOF

```
COMPLETED_IDS
```
/
```
FAILED_IDS
```
: 本轮任务结果中的任务ID（空格分隔）。
若重试同一轮任务，将覆盖该文件（路径相同）。
检查点文件仅用于信息参考 —— 目前暂无恢复逻辑读取这些文件（后续功能）。

Step 6: Check for More Work

步骤6：检查是否有更多任务

After completing a wave, check for newly unblocked issues (beads:

bd ready

, TaskList:

TaskList()

). Loop back to Step 4 if work remains, or proceed to Step 7 when done.

For detailed check/retry logic, read
skills/crank/references/team-coordination.md
.

完成一轮任务后，检查是否有新的未阻塞任务（Beads模式：

bd ready

，TaskList模式：

TaskList()

）。若仍有任务，返回步骤4；否则进入步骤7。

关于详细的检查/重试逻辑，请查看
skills/crank/references/team-coordination.md
。

Step 7: Final Batched Validation

步骤7：最终批量验证

When all issues complete, run ONE comprehensive vibe on recent changes. Fix CRITICAL issues before completion.

For detailed validation steps, read
skills/crank/references/failure-recovery.md
.

所有任务完成后，对近期变更执行一次全面的反馈校验。完成前修复所有CRITICAL级别的问题。

关于详细的验证步骤，请查看
skills/crank/references/failure-recovery.md
。

Step 8: Extract Learnings (ao Integration)

步骤8：提取经验（ao集成）

If ao CLI available: run

ao forge transcript

ao flywheel status

, and

ao pool list --tier=pending

to extract and review learnings. If ao unavailable, skip and recommend

/post-mortem

manually.

若ao CLI可用：运行

ao forge transcript

、

ao flywheel status

和

ao pool list --tier=pending

以提取并回顾经验。若ao不可用，跳过此步骤并建议手动运行

/post-mortem

命令。

Step 9: Report Completion

步骤9：报告完成状态

Tell the user:

Epic ID and title
Number of issues completed
Total iterations used (of 50 max)
Final vibe results
Flywheel status (if ao available)
Suggest running
```
/post-mortem
```
to review and promote learnings

Output completion marker:

<promise>DONE</promise>
Epic: <epic-id>
Issues completed: N
Iterations: M/50
Flywheel: <status from ao flywheel status>

If stopped early:

<promise>BLOCKED</promise>
Reason: <global limit reached | unresolvable blockers>
Issues remaining: N
Iterations: M/50

告知用户：

史诗任务ID与标题
已完成的任务数量
已使用的总轮次（上限为50轮）
最终反馈结果
知识飞轮状态（若ao可用）
建议运行
```
/post-mortem
```
命令以回顾并推广经验

输出完成标记：

<promise>DONE</promise>
Epic: <epic-id>
已完成任务数: N
已用轮次: M/50
知识飞轮: <来自ao flywheel status的状态>

若提前停止：

<promise>BLOCKED</promise>
原因: <达到全局轮次限制 | 无法解决的阻塞问题>
剩余任务数: N
已用轮次: M/50

The FIRE Loop

FIRE循环

Crank follows FIRE (Find → Ignite → Reap → Vibe → Escalate) for each wave. Loop until all issues are CLOSED (beads) or all tasks are completed (TaskList).

For FIRE loop details, parallel wave models, and wave vibe gate, read
skills/crank/references/wave-patterns.md
.

Crank为每轮任务遵循FIRE流程（Find → Ignite → Reap → Vibe → Escalate）。循环执行直至所有任务关闭（Beads模式）或所有任务完成（TaskList模式）。

关于FIRE循环的详细信息、并行轮次模型与轮次反馈校验门，请查看
skills/crank/references/wave-patterns.md
。

Key Rules

核心规则

Auto-detect tracking - check for
```
bd
```
at start; use TaskList if absent
Plan files as input -
```
/crank plan.md
```
decomposes plan into tasks automatically
If epic ID given, USE IT - don't ask for confirmation (beads mode only)
Swarm for each wave - delegates parallel execution to swarm
Fresh context per issue - swarm provides Ralph pattern isolation
Batch validation at end - ONE vibe at the end saves context
Fix CRITICAL before completion - address findings before reporting done
Loop until done - don't stop until all issues closed / tasks completed
Autonomous execution - minimize human prompts
Respect wave limit - STOP at 50 waves (hard limit)
Output completion markers - DONE, BLOCKED, or PARTIAL (required)
Knowledge flywheel - load learnings at start, forge at end (ao optional)
Beads ↔ TaskList sync - in beads mode, crank bridges beads issues to TaskList for swarm

自动检测追踪模式 - 启动时检查
```
bd
```
是否可用；若不可用则使用TaskList
支持计划文件作为输入 -
```
/crank plan.md
```
会自动将计划分解为任务
若提供史诗ID则直接使用 - 无需确认（仅Beads模式）
每轮任务使用Swarm - 将并行执行委托给Swarm
每个任务使用全新上下文 - Swarm提供Ralph模式隔离
最终执行批量验证 - 仅执行一次反馈校验以节省上下文
完成前修复CRITICAL问题 - 报告完成前解决所有严重问题
循环直至完成 - 所有任务关闭/完成前请勿停止
自主执行 - 尽量减少人工提示
遵守轮次限制 - 达到50轮时停止执行（硬限制）
输出完成标记 - 必须输出DONE、BLOCKED或PARTIAL
知识飞轮集成 - 启动时加载经验，结束时提取经验（ao为可选工具）
Beads ↔ TaskList同步 - Beads模式下，Crank将beads任务桥接至TaskList以适配Swarm

Distributed Mode: Agent Mail Orchestration (Experimental)

分布式模式：Agent Mail编排（实验性）

Status: Experimental. Local mode (TaskList + swarm) is the recommended execution method.

For distributed mode details (architecture, execution steps, Chiron pattern, file reservations, checkpoint handling), read
skills/crank/references/distributed-mode.md
.

状态：实验性。 推荐使用本地模式（TaskList + swarm）执行任务。

关于分布式模式的详细信息（架构、执行步骤、Chiron模式、文件预留、检查点处理），请查看
skills/crank/references/distributed-mode.md
。

References

参考资料

Wave patterns:

skills/crank/references/wave-patterns.md

Team coordination:

skills/crank/references/team-coordination.md

Failure recovery:

skills/crank/references/failure-recovery.md

Distributed mode:

skills/crank/references/distributed-mode.md

Agent Mail Protocol:
```
skills/shared/agent-mail-protocol.md
```
Parser (Go):
```
cli/internal/agentmail/
```

轮次模式：

skills/crank/references/wave-patterns.md

团队协同：

skills/crank/references/team-coordination.md

故障恢复：

skills/crank/references/failure-recovery.md

分布式模式：

skills/crank/references/distributed-mode.md

Agent Mail协议：
```
skills/shared/agent-mail-protocol.md
```
解析器（Go语言）：
```
cli/internal/agentmail/
```