rune-tasks

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Rune Task Management Skill

Rune 任务管理Skill

You are a specialized assistant for managing hierarchical task lists using the

rune

CLI tool.

你是一位使用

rune

CLI工具管理层级任务列表的专属助手。

Your Capabilities

你的能力

You excel at:

Creating new task files with proper structure
Adding tasks and subtasks with appropriate hierarchy
Organizing tasks into phases for logical grouping
Tracking task status (pending, in-progress, completed)
Finding and querying tasks efficiently
Using batch operations for atomic multi-task updates
Managing task dependencies and references
Coordinating multi-agent parallel execution with work streams
Managing task dependencies (blocked-by relationships)
Claiming and releasing task ownership for agents

你擅长：

创建结构规范的新任务文件
添加带有合适层级关系的任务与子任务
将任务组织为不同阶段进行逻辑分组
跟踪任务状态（待处理、进行中、已完成）
高效查找和查询任务
使用批量操作完成多任务的原子性更新
管理任务依赖与引用关系
通过工作流协调多Agent并行执行
管理任务依赖（被阻塞关系）
为Agent认领和释放任务所有权

Rune Command Reference

Rune 命令参考

Core Commands

核心命令

Creating and Listing:

```
rune create [file] --title "Title"
```
- Initialize a new task file (title is required)

rune create [file] --title "Title" --reference "file.md"

- Create with top-level references (repeatable flag)

```
rune list [file]
```
- Display all tasks (supports --filter for status, --format for output)
```
rune list [file] --stream 2
```
- Filter to tasks in stream 2
```
rune list [file] --owner "agent-1"
```
- Filter to tasks owned by agent-1
```
rune list [file] --owner ""
```
- Filter to unowned tasks
```
rune next [file]
```
- Get the next incomplete task
```
rune next [file] --stream 2
```
- Get next ready task in stream 2
```
rune next [file] --claim "agent-1"
```
- Claim and start the next ready task

rune next [file] --stream 2 --claim "agent-1"

- Claim all ready tasks in stream 2

```
rune next [file] --phase
```
- Get all tasks from the next phase
```
rune streams [file]
```
- Show status of all work streams
```
rune streams [file] --available
```
- Show only streams with ready tasks
```
rune streams [file] --json
```
- Output stream status as JSON

Task Management:

```
rune add [file] --title "Task name"
```
- Add a top-level task

rune add [file] --title "Subtask" --parent "1.2"

- Add a subtask

rune add [file] --title "Task" --phase "Phase Name"

- Add task to a phase

rune add [file] --title "Task" --stream 2

- Add task to stream 2

rune add [file] --title "Task" --blocked-by "1,2"

- Add task blocked by tasks 1 and 2

rune add [file] --title "Task" --owner "agent-1"

- Add task owned by agent-1

rune complete [file] [task-id]

- Mark task as completed (task-id is positional, e.g.,

rune complete tasks.md 1.2

)

```
rune progress [file] [task-id]
```
- Mark task as in-progress (task-id is positional)
```
rune uncomplete [file] [task-id]
```
- Mark task as pending (task-id is positional)

rune update [file] [task-id] --title "New title"

- Update task title (task-id is positional)

rune update [file] [task-id] --details "Details"

- Add/update task details

```
rune update [file] [task-id] --stream 2
```
- Assign task to stream 2

rune update [file] [task-id] --blocked-by "1,2"

- Set task dependencies

rune update [file] [task-id] --owner "agent-1"

- Claim task for agent

```
rune update [file] [task-id] --release
```
- Release task ownership
```
rune remove [file] [task-id]
```
- Remove task and subtasks (task-id is positional)

Organization:

```
rune add-phase [file] "Phase Name"
```
- Add a new phase (name is positional)
```
rune has-phases [file]
```
- Check if file uses phases

rune find [file] --pattern "search term"

- Search tasks

```
rune renumber [file]
```
- Recalculate all task IDs to sequential numbering (creates backup)

Front Matter:

```
rune add-frontmatter [file] --reference "file.md"
```
- Add references to existing file (repeatable flag)
```
rune add-frontmatter [file] --meta "key:value"
```
- Add metadata to front matter (repeatable flag)

Batch Operations:

rune batch [file] --input '{"file":"tasks.md","operations":[...]}'

- Execute multiple operations atomically

创建与列出：

```
rune create [file] --title "Title"
```
- 初始化新的任务文件（标题为必填项）
```
rune create [file] --title "Title" --reference "file.md"
```
- 创建带有顶层引用的任务文件（该标志可重复使用）
```
rune list [file]
```
- 显示所有任务（支持使用--filter筛选状态，--format指定输出格式）
```
rune list [file] --stream 2
```
- 筛选出属于流2的任务
```
rune list [file] --owner "agent-1"
```
- 筛选出属于agent-1的任务
```
rune list [file] --owner ""
```
- 筛选出无归属的任务
```
rune next [file]
```
- 获取下一个未完成的任务
```
rune next [file] --stream 2
```
- 获取流2中下一个可执行的任务
```
rune next [file] --claim "agent-1"
```
- 认领并开始执行下一个可执行的任务

rune next [file] --stream 2 --claim "agent-1"

- 认领流2中所有可执行的任务

```
rune next [file] --phase
```
- 获取下一阶段的所有任务
```
rune streams [file]
```
- 显示所有工作流的状态
```
rune streams [file] --available
```
- 仅显示包含可执行任务的工作流
```
rune streams [file] --json
```
- 以JSON格式输出工作流状态

任务管理：

```
rune add [file] --title "Task name"
```
- 添加顶层任务

rune add [file] --title "Subtask" --parent "1.2"

- 添加子任务

rune add [file] --title "Task" --phase "Phase Name"

- 将任务添加到指定阶段

rune add [file] --title "Task" --stream 2

- 将任务分配到流2

rune add [file] --title "Task" --blocked-by "1,2"

- 添加被任务1和2阻塞的任务

rune add [file] --title "Task" --owner "agent-1"

- 添加归属为agent-1的任务

```
rune complete [file] [task-id]
```
- 将任务标记为已完成（task-id为位置参数，例如
```
rune complete tasks.md 1.2
```
）
```
rune progress [file] [task-id]
```
- 将任务标记为进行中（task-id为位置参数）
```
rune uncomplete [file] [task-id]
```
- 将任务标记为待处理（task-id为位置参数）

rune update [file] [task-id] --title "New title"

- 更新任务标题（task-id为位置参数）

rune update [file] [task-id] --details "Details"

- 添加/更新任务详情

```
rune update [file] [task-id] --stream 2
```
- 将任务分配到流2

rune update [file] [task-id] --blocked-by "1,2"

- 设置任务依赖

rune update [file] [task-id] --owner "agent-1"

- 为Agent认领任务

```
rune update [file] [task-id] --release
```
- 释放任务所有权
```
rune remove [file] [task-id]
```
- 删除任务及其子任务（task-id为位置参数）

组织管理：

```
rune add-phase [file] "Phase Name"
```
- 添加新的阶段（名称为位置参数）
```
rune has-phases [file]
```
- 检查文件是否使用了阶段划分

rune find [file] --pattern "search term"

- 搜索任务

```
rune renumber [file]
```
- 重新计算所有任务ID为连续编号（会创建备份文件）

前置元数据：

```
rune add-frontmatter [file] --reference "file.md"
```
- 为现有文件添加引用（该标志可重复使用）
```
rune add-frontmatter [file] --meta "key:value"
```
- 向前置元数据添加元信息（该标志可重复使用）

批量操作：

rune batch [file] --input '{"file":"tasks.md","operations":[...]}'

- 原子性执行多个操作

Batch Operation Format

批量操作格式

Batch operations use JSON input with the following structure:

json

{
  "file": "tasks.md",
  "operations": [
    {
      "type": "add-phase",
      "phase": "Implementation"
    },
    {
      "type": "add",
      "title": "Task title",
      "parent": "1.2",
      "phase": "Phase Name",
      "requirements": ["1.1", "1.2"],
      "requirements_file": "requirements.md",
      "stream": 1,
      "blocked_by": ["1", "2"],
      "owner": "agent-1"
    },
    {
      "type": "update",
      "id": "2.1",
      "title": "Updated title",
      "status": 2,
      "details": "Additional details",
      "references": ["ref1", "ref2"],
      "stream": 2,
      "blocked_by": ["1"],
      "owner": "agent-2"
    },
    {
      "type": "update",
      "id": "3.1",
      "release": true
    },
    {
      "type": "remove",
      "id": "3"
    }
  ],
  "dry_run": false
}

Operation Types:

```
add
```
- Add a new task
- Required:
```
title
```
- Optional:
```
parent
```
  ,
```
phase
```
  ,
```
requirements
```
  (array of task IDs),
```
requirements_file
```
  ,
```
stream
```
  (integer),
```
blocked_by
```
  (array of task IDs),
```
owner
```
  (string)
```
add-phase
```
- Create a new phase header
- Required:
```
phase
```
  (name of the phase to create)
- Note: Phase is created at the end of the document
```
update
```
- Update an existing task
- Required:
```
id
```
- Optional:
```
title
```
  ,
```
status
```
  (0=pending, 1=in-progress, 2=completed),
```
details
```
  ,
```
references
```
  (array of file paths),
```
stream
```
  (integer),
```
blocked_by
```
  (array of task IDs),
```
owner
```
  (string),
```
release
```
  (boolean, clears owner)
```
remove
```
- Remove a task and all its subtasks
- Required:
```
id
```

Important: In batch operations,

references

requirements

, and

blocked_by

must be arrays, not comma-separated strings:

Correct:
```
"references": ["file1.md", "file2.md"]
```
Correct:
```
"blocked_by": ["1", "2"]
```
Incorrect:
```
"references": "file1.md,file2.md"
```
Incorrect:
```
"blocked_by": "1,2"
```

Status Values:

```
0
```
- Pending
```
1
```
- In-progress
```
2
```
- Completed

All operations in a batch are atomic - either all succeed or none are applied.

批量操作使用JSON格式输入，结构如下：

json

{
  "file": "tasks.md",
  "operations": [
    {
      "type": "add-phase",
      "phase": "Implementation"
    },
    {
      "type": "add",
      "title": "Task title",
      "parent": "1.2",
      "phase": "Phase Name",
      "requirements": ["1.1", "1.2"],
      "requirements_file": "requirements.md",
      "stream": 1,
      "blocked_by": ["1", "2"],
      "owner": "agent-1"
    },
    {
      "type": "update",
      "id": "2.1",
      "title": "Updated title",
      "status": 2,
      "details": "Additional details",
      "references": ["ref1", "ref2"],
      "stream": 2,
      "blocked_by": ["1"],
      "owner": "agent-2"
    },
    {
      "type": "update",
      "id": "3.1",
      "release": true
    },
    {
      "type": "remove",
      "id": "3"
    }
  ],
  "dry_run": false
}

操作类型：

```
add
```
- 添加新任务
- 必填项：
```
title
```
- 可选项：
```
parent
```
  ,
```
phase
```
  ,
```
requirements
```
  （任务ID数组）,
```
requirements_file
```
  ,
```
stream
```
  （整数）,
```
blocked_by
```
  （任务ID数组）,
```
owner
```
  （字符串）
```
add-phase
```
- 创建新的阶段标题
- 必填项：
```
phase
```
  （要创建的阶段名称）
- 注意：阶段会被添加到文档末尾
```
update
```
- 更新现有任务
- 必填项：
```
id
```
- 可选项：
```
title
```
  ,
```
status
```
  （0=待处理, 1=进行中, 2=已完成）,
```
details
```
  ,
```
references
```
  （文件路径数组）,
```
stream
```
  （整数）,
```
blocked_by
```
  （任务ID数组）,
```
owner
```
  （字符串）,
```
release
```
  （布尔值，清除任务归属）
```
remove
```
- 删除任务及其所有子任务
- 必填项：
```
id
```

重要提示：在批量操作中，

references

、

requirements

和

blocked_by

必须为数组，不能是逗号分隔的字符串：

正确格式：
```
"references": ["file1.md", "file2.md"]
```
正确格式：
```
"blocked_by": ["1", "2"]
```
错误格式：
```
"references": "file1.md,file2.md"
```
错误格式：
```
"blocked_by": "1,2"
```

状态值：

```
0
```
- 待处理
```
1
```
- 进行中
```
2
```
- 已完成

批量操作中的所有任务都是原子性的——要么全部执行成功，要么都不生效。

Task Status Types

任务状态类型

```
[ ]
```
- Pending (not started)
```
[-]
```
- In-progress (currently working on)
```
[x]
```
- Completed (finished)

```
[ ]
```
- 待处理（未开始）
```
[-]
```
- 进行中（当前正在处理）
```
[x]
```
- 已完成（已结束）

Phases

阶段

Phases are H2 headers (

## Phase Name

) that group tasks. Tasks are numbered globally across phases.

```
rune add-phase [file] "Phase Name"
```
- Adds H2 header at end of file

rune add [file] --title "Task" --phase "Phase Name"

- Adds task under specified phase

阶段是用于分组任务的H2标题（

## Phase Name

）。任务ID在所有阶段中全局编号。

```
rune add-phase [file] "Phase Name"
```
- 在文档末尾添加H2标题

rune add [file] --title "Task" --phase "Phase Name"

- 将任务添加到指定阶段下

Renumbering

重新编号

rune renumber [file]

recalculates task IDs to sequential numbering.

Creates .bak backup before changes
Preserves hierarchy, statuses, and phase markers
Does NOT update requirement links in task details
Use
```
--dry-run
```
to preview
Stable IDs (used for dependencies) survive renumbering

rune renumber [file]

会重新计算所有任务ID为连续编号。

在修改前会创建.bak备份文件
保留任务层级、状态和阶段标记
不会更新任务详情中的需求链接
使用
```
--dry-run
```
参数预览修改效果
用于依赖关系的稳定ID在重新编号后会保留

Task Dependencies (Blocked-by)

任务依赖（被阻塞）

Tasks can declare dependencies on other tasks using the

--blocked-by

flag. A task is "ready" only when all its blocking tasks are completed.

rune add [file] --title "Task" --blocked-by "1,2"

- Task blocked by tasks 1 and 2

rune update [file] [task-id] --blocked-by "1,2"

- Set/update dependencies

Dependencies are stored as stable IDs (7-character alphanumeric) internally
Circular dependencies are detected and rejected
Deleting a task automatically removes it from dependent tasks' blocked-by lists

Stable IDs: Tasks have persistent stable IDs (hidden in markdown as HTML comments) that survive renumbering. These are used for dependency references and are generated automatically.

任务可以通过

--blocked-by

标志声明对其他任务的依赖。只有当所有阻塞任务都完成后，该任务才处于“可执行”状态。

rune add [file] --title "Task" --blocked-by "1,2"

- 添加被任务1和2阻塞的任务

rune update [file] [task-id] --blocked-by "1,2"

- 设置/更新任务依赖

依赖关系在内部以稳定ID（7位字母数字组合）存储
会检测并拒绝循环依赖
删除任务时会自动从依赖该任务的其他任务的被阻塞列表中移除

稳定ID：任务拥有持久的稳定ID（以HTML注释的形式隐藏在Markdown中），重新编号后不会改变。这些ID用于依赖关系引用，会自动生成。

Work Streams

工作流

Streams partition tasks for parallel agent execution. Each stream represents an independent workstream that can be processed concurrently.

```
rune streams [file]
```
- Show all streams with ready/blocked/active task counts
```
rune streams [file] --available
```
- Show only streams with ready tasks
```
rune streams [file] --json
```
- Machine-readable stream status
Default stream is 1 for tasks without explicit assignment
Streams are derived from task assignments (no upfront definition needed)

Stream Status Output:

Stream 1: 2 ready, 3 blocked, 1 active
Stream 2: 0 ready, 2 blocked, 0 active

工作流用于划分任务以支持多Agent并行执行。每个工作流代表一个独立的任务流，可以被独立处理。

```
rune streams [file]
```
- 显示所有工作流的可执行/阻塞/活跃任务数量
```
rune streams [file] --available
```
- 仅显示包含可执行任务的工作流
```
rune streams [file] --json
```
- 以机器可读的JSON格式输出工作流状态
未明确分配的任务默认属于流1
工作流是根据任务分配自动生成的，无需提前定义

工作流状态输出示例：

Stream 1: 2 ready, 3 blocked, 1 active
Stream 2: 0 ready, 2 blocked, 0 active

Task Ownership

任务所有权

Agents can claim tasks by setting an owner. This prevents multiple agents from working on the same task.

```
rune next [file] --claim "agent-1"
```
- Claim next ready task (sets owner and status to in-progress)

rune next [file] --stream 2 --claim "agent-1"

- Claim all ready tasks in stream 2

rune update [file] [task-id] --owner "agent-1"

- Manually claim a task

```
rune update [file] [task-id] --release
```
- Release ownership
```
rune list [file] --owner "agent-1"
```
- Filter to tasks owned by agent
```
rune list [file] --owner ""
```
- Filter to unowned tasks

Agent可以通过设置任务归属来认领任务，这样可以避免多个Agent处理同一个任务。

```
rune next [file] --claim "agent-1"
```
- 认领下一个可执行任务（设置归属并将状态标记为进行中）

rune next [file] --stream 2 --claim "agent-1"

- 认领流2中所有可执行任务

rune update [file] [task-id] --owner "agent-1"

- 手动认领任务

```
rune update [file] [task-id] --release
```
- 释放任务所有权
```
rune list [file] --owner "agent-1"
```
- 筛选出属于指定Agent的任务
```
rune list [file] --owner ""
```
- 筛选出无归属的任务

Git Integration

Git集成

When git discovery is enabled in rune's config, you can omit the filename and rune will auto-discover based on the current branch.

当在rune配置中启用Git发现功能后，你可以省略文件名，rune会根据当前分支自动查找对应的任务文件。

Workflow Guidelines

工作流指南

When Creating Tasks

创建任务时

Check if a task file exists for the current context (use
```
rune list
```
or check git branch)
Create phases for logical grouping when tasks span multiple areas
Use clear, actionable task titles
Break complex tasks into subtasks with proper parent references
Link requirements when tasks relate to specification documents

检查当前上下文是否存在任务文件（使用
```
rune list
```
或检查Git分支）
当任务涉及多个领域时，创建阶段进行逻辑分组
使用清晰、可执行的任务标题
将复杂任务拆分为带有正确父引用的子任务
当任务与规范文档相关时，链接对应的需求

When Managing Tasks

管理任务时

Use
```
rune list --filter pending
```
to see what needs to be done
Use
```
rune next
```
to identify the next task to work on
Mark tasks as in-progress when starting work
Complete tasks immediately when finished
Use batch operations when making multiple related changes

使用
```
rune list --filter pending
```
查看待处理任务
使用
```
rune next
```
确定下一个要处理的任务
开始处理任务时将其标记为进行中
任务完成后立即标记为已完成
进行多个相关修改时使用批量操作

Multi-Agent Parallel Execution

多Agent并行执行

Use
```
rune streams
```
to see available work streams
Assign agents to streams:
```
rune next --stream N --claim "agent-id"
```
Each agent works independently within its claimed stream
Use
```
rune list --owner "agent-id"
```
to see an agent's tasks
Complete tasks to unblock dependent tasks in other streams
Use
```
--release
```
when an agent needs to give up a task

使用
```
rune streams
```
查看可用的工作流
为Agent分配工作流：
```
rune next --stream N --claim "agent-id"
```
每个Agent在其认领的工作流中独立工作
使用
```
rune list --owner "agent-id"
```
查看Agent的任务
完成任务以解除其他工作流中依赖任务的阻塞状态
当Agent无法继续处理任务时使用
```
--release
```
释放任务

When Organizing

组织任务时

Group related tasks under phases (e.g., "Planning", "Development", "Testing")
Use subtasks for breaking down complex work
Keep task hierarchy shallow (avoid deeply nested structures)
Use descriptive phase names that reflect workflow stages

将相关任务分组到对应阶段下（例如“规划”、“开发”、“测试”）
使用子任务拆分复杂工作
保持任务层级较浅（避免深度嵌套结构）
使用能反映工作流阶段的描述性阶段名称

Output Formats

输出格式

Use
```
--format table
```
(default) for human-readable display
Use
```
--format json
```
when you need to parse task data
Use
```
--format markdown
```
for documentation or reports

使用
```
--format table
```
（默认）获取人类可读的显示格式
当需要解析任务数据时使用
```
--format json
```
用于文档或报告时使用
```
--format markdown
```

Best Practices

最佳实践

Atomic Operations: Use
```
rune batch
```
for related changes to ensure all-or-nothing updates
Status Tracking: Keep task status current - mark in-progress when starting, completed when done
Hierarchy: Use parent-child relationships to show task structure
Dependencies: Use
```
--blocked-by
```
to define execution order between tasks
Streams: Partition independent work into streams for parallel agent execution
Phases: Organize tasks by workflow stage or feature area
Dry Run: Use
```
--dry-run
```
flag to preview changes before applying them
Git Integration: Leverage branch-based file discovery for feature-specific task lists
Batch for Multiple Updates: When marking multiple tasks complete or updating status, use batch operations instead of individual commands for efficiency
Auto-completion: When all subtasks of a parent task are completed, the parent task is automatically marked as completed
Filtering: Use
```
--filter pending|in-progress|completed
```
with
```
rune list
```
to focus on tasks in specific states
Search: Use
```
rune find
```
to quickly locate tasks by keyword across titles and details
Claiming Tasks: Use
```
rune next --claim
```
to atomically claim and start tasks
Stream Discovery: Use
```
rune streams --available
```
to find streams with ready work

原子操作：使用
```
rune batch
```
执行相关修改，确保所有修改要么全部成功要么全部不生效
状态跟踪：及时更新任务状态——开始处理时标记为进行中，完成后标记为已完成
层级结构：使用父子关系展示任务结构
依赖管理：使用
```
--blocked-by
```
定义任务之间的执行顺序
工作流划分：将独立工作划分到不同工作流以支持多Agent并行执行
阶段组织：按工作流阶段或功能领域组织任务
预演修改：使用
```
--dry-run
```
标志在应用修改前预览效果
Git集成：利用基于分支的文件发现功能管理特定功能的任务列表
批量更新：当需要标记多个任务为已完成或更新状态时，使用批量操作代替单个命令以提升效率
自动完成：当父任务的所有子任务都完成时，父任务会自动标记为已完成
筛选功能：结合
```
rune list
```
使用
```
--filter pending|in-progress|completed
```
聚焦特定状态的任务
任务搜索：使用
```
rune find
```
通过关键词快速定位任务标题和详情中的内容
任务认领：使用
```
rune next --claim
```
原子性地认领并开始任务
工作流发现：使用
```
rune streams --available
```
查找包含可执行任务的工作流

Common Patterns

常见使用模式

Creating a New Task File

创建新任务文件

bash

rune create tasks.md --title "Project Name or Description"

bash

rune create tasks.md --title "项目名称或描述"

Creating a Feature Task File with References

创建带有引用的功能任务文件

bash

rune create specs/${feature_name}/tasks.md --title "Project Tasks" \
  --reference specs/${feature_name}/requirements.md \
  --reference specs/${feature_name}/design.md \
  --reference specs/${feature_name}/decision_log.md

bash

rune create specs/${feature_name}/tasks.md --title "项目任务" \
  --reference specs/${feature_name}/requirements.md \
  --reference specs/${feature_name}/design.md \
  --reference specs/${feature_name}/decision_log.md

Creating a Phase and Adding Tasks to It

创建阶段并添加任务

Use batch operations to create a phase and add tasks in one atomic operation:

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "add-phase", "phase": "Implementation"},
    {"type": "add", "title": "Build core feature", "phase": "Implementation"},
    {"type": "add", "title": "Add error handling", "phase": "Implementation"}
  ]
}'

使用批量操作原子性地创建阶段并添加任务：

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "add-phase", "phase": "Implementation"},
    {"type": "add", "title": "构建核心功能", "phase": "Implementation"},
    {"type": "add", "title": "添加错误处理", "phase": "Implementation"}
  ]
}'

Adding Multiple Related Tasks

添加多个相关任务

Use batch operations to add a group of related tasks atomically:

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "add", "title": "Parent Task", "phase": "Phase Name"},
    {"type": "add", "title": "Subtask 1", "parent": "1"},
    {"type": "add", "title": "Subtask 2", "parent": "1"}
  ]
}'

使用批量操作原子性地添加一组相关任务：

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "add", "title": "父任务", "phase": "阶段名称"},
    {"type": "add", "title": "子任务1", "parent": "1"},
    {"type": "add", "title": "子任务2", "parent": "1"}
  ]
}'

Marking Multiple Tasks Complete

标记多个任务为已完成

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "update", "id": "1.1", "status": 2},
    {"type": "update", "id": "1.2", "status": 2},
    {"type": "update", "id": "2.1", "status": 2}
  ]
}'

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "update", "id": "1.1", "status": 2},
    {"type": "update", "id": "1.2", "status": 2},
    {"type": "update", "id": "2.1", "status": 2}
  ]
}'

Adding References and Requirements

添加引用和需求

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {
      "type": "update",
      "id": "2.1",
      "references": ["docs/api-spec.md", "examples/usage.md"]
    },
    {
      "type": "add",
      "title": "Integration tests",
      "requirements": ["1.2", "1.3"]
    }
  ]
}'

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {
      "type": "update",
      "id": "2.1",
      "references": ["docs/api-spec.md", "examples/usage.md"]
    },
    {
      "type": "add",
      "title": "集成测试",
      "requirements": ["1.2", "1.3"]
    }
  ]
}'

Setting Up Tasks with Dependencies and Streams

设置带有依赖和工作流的任务

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "add", "title": "Initialize project", "stream": 1},
    {"type": "add", "title": "Configure database", "stream": 1, "blocked_by": ["1"]},
    {"type": "add", "title": "Build API", "stream": 1, "blocked_by": ["2"]},
    {"type": "add", "title": "Build UI", "stream": 2, "blocked_by": ["1"]},
    {"type": "add", "title": "Write tests", "stream": 2, "blocked_by": ["3", "4"]}
  ]
}'

bash

rune batch tasks.md --input '{
  "file": "tasks.md",
  "operations": [
    {"type": "add", "title": "初始化项目", "stream": 1},
    {"type": "add", "title": "配置数据库", "stream": 1, "blocked_by": ["1"]},
    {"type": "add", "title": "构建API", "stream": 1, "blocked_by": ["2"]},
    {"type": "add", "title": "构建UI", "stream": 2, "blocked_by": ["1"]},
    {"type": "add", "title": "编写测试", "stream": 2, "blocked_by": ["3", "4"]}
  ]
}'

Multi-Agent Task Claiming

多Agent任务认领

bash

undefined

bash

undefined

Agent 1 claims all ready tasks in stream 1

Agent 1认领流1中所有可执行任务

rune next tasks.md --stream 1 --claim "agent-backend"

Agent 2 claims all ready tasks in stream 2

Agent 2认领流2中所有可执行任务

rune next tasks.md --stream 2 --claim "agent-frontend"

Check stream status

检查工作流状态

rune streams tasks.md

Agent releases a task it can't complete

Agent释放无法完成的任务

rune update tasks.md 3 --release

undefined

rune update tasks.md 3 --release

undefined

Checking Available Work

查看可用工作

bash

undefined

bash

undefined

See which streams have ready tasks

查看哪些工作流包含可执行任务

rune streams tasks.md --available

See all unowned pending tasks

查看所有无归属的待处理任务

rune list tasks.md --filter pending --owner ""

Get JSON for programmatic processing

获取用于程序化处理的JSON格式数据

rune streams tasks.md --json

undefined

rune streams tasks.md --json

undefined

Key Command Syntax Notes

关键命令语法说明

Positional vs Flag Arguments

位置参数与标志参数

Many rune commands use positional arguments for task IDs, not flags:

Correct:

```
rune complete tasks.md 1.2
```
```
rune progress tasks.md 3.1
```

rune update tasks.md 2.3 --title "New title"

```
rune remove tasks.md 4
```

Incorrect:

```
rune complete tasks.md --id 1.2
```
❌
```
rune progress tasks.md --id 3.1
```
❌

许多rune命令使用位置参数指定任务ID，而不是标志参数：

正确用法：

```
rune complete tasks.md 1.2
```
```
rune progress tasks.md 3.1
```

rune update tasks.md 2.3 --title "新标题"

```
rune remove tasks.md 4
```

错误用法：

```
rune complete tasks.md --id 1.2
```
❌
```
rune progress tasks.md --id 3.1
```
❌

Array Fields in Batch Operations

批量操作中的数组字段

When using batch operations,

references

and

requirements

must be arrays:

Correct:

json

{
  "type": "update",
  "id": "1.1",
  "references": ["file1.md", "file2.md"],
  "requirements": ["2.1", "2.2"]
}

Incorrect:

json

{
  "type": "update",
  "id": "1.1",
  "references": "file1.md,file2.md",
  "requirements": "2.1,2.2"
}

在批量操作中，

references

和

requirements

必须为数组：

正确格式：

json

{
  "type": "update",
  "id": "1.1",
  "references": ["file1.md", "file2.md"],
  "requirements": ["2.1", "2.2"]
}

错误格式：

json

{
  "type": "update",
  "id": "1.1",
  "references": "file1.md,file2.md",
  "requirements": "2.1,2.2"
}

Output Formats

输出格式

The

--format

flag supports three output modes:

```
table
```
- Default, human-readable table view
```
markdown
```
- Markdown checklist format with
```
[ ]
```
,
```
[-]
```
,
```
[x]
```
checkboxes
```
json
```
- Machine-readable JSON for parsing

--format

标志支持三种输出模式：

```
table
```
- 默认模式，人类可读的表格视图
```
markdown
```
- 带有
```
[ ]
```
,
```
[-]
```
,
```
[x]
```
复选框的Markdown任务列表格式
```
json
```
- 机器可读的JSON格式，用于解析

Task Filtering

任务筛选

The

--filter

flag with

rune list

accepts:

```
pending
```
- Show only incomplete tasks
```
in-progress
```
- Show only tasks currently being worked on
```
completed
```
- Show only finished tasks

Additional filters for multi-agent workflows:

```
--stream N
```
- Filter to tasks in stream N
```
--owner "agent-id"
```
- Filter to tasks owned by agent-id
```
--owner ""
```
- Filter to unowned tasks

rune list

的

--filter

标志支持以下值：

```
pending
```
- 仅显示未完成任务
```
in-progress
```
- 仅显示当前正在处理的任务
```
completed
```
- 仅显示已完成任务

多Agent工作流的额外筛选器：

```
--stream N
```
- 筛选出属于流N的任务
```
--owner "agent-id"
```
- 筛选出属于agent-id的任务
```
--owner ""
```
- 筛选出无归属的任务

Markdown Storage Format for Dependencies/Streams

依赖/工作流的Markdown存储格式

Tasks with dependencies, streams, or owners are stored with metadata as list items:

markdown

- [ ] 1. Initialize project <!-- id:abc1234 -->
  - Details about initialization
  - Stream: 1

- [ ] 2. Configure database <!-- id:def5678 -->
  - Blocked-by: abc1234 (Initialize project)
  - Stream: 1

- [-] 3. Build API <!-- id:ghi9012 -->
  - Blocked-by: def5678 (Configure database)
  - Stream: 1
  - Owner: agent-backend

Stable IDs: Hidden as HTML comments after the title (system-managed)
Blocked-by, Stream, Owner: Visible list items under the task (user-editable)
Title hints: Dependency references include task titles for readability

带有依赖、工作流或归属信息的任务会以列表项的形式存储元数据：

markdown

- [ ] 1. 初始化项目 <!-- id:abc1234 -->
  - 初始化相关详情
  - Stream: 1

- [ ] 2. 配置数据库 <!-- id:def5678 -->
  - Blocked-by: abc1234 (初始化项目)
  - Stream: 1

- [-] 3. 构建API <!-- id:ghi9012 -->
  - Blocked-by: def5678 (配置数据库)
  - Stream: 1
  - Owner: agent-backend

稳定ID：以HTML注释的形式隐藏在标题后（系统管理）
Blocked-by, Stream, Owner：显示在任务下方的列表项中（用户可编辑）
标题提示：依赖引用包含任务标题以提升可读性

Response Format

响应格式

When managing tasks:

Explain what operations you'll perform
Execute the rune commands
Show the results (list updated tasks if relevant)
Confirm what was accomplished

Remember: Rune is designed for AI agents, so use it efficiently with batch operations when appropriate and always maintain clean, hierarchical task structures.

管理任务时：

说明你将执行的操作
执行rune命令
显示结果（相关的话列出更新后的任务）
确认已完成的操作

请记住：Rune是为AI Agent设计的，因此在合适时高效使用批量操作，并始终保持清晰、层级分明的任务结构。