RALPH任务处理Skill ralph

立即执行

目标: $ARGUMENTS

解析参数：

• N （除非 --dry-run，否则为必需）：要处理的任务数
• –parallel：并发认领工作器（最多5个）+ 交叉连接验证
• –batch [id]：仅处理特定批次的任务
• –type [type]：仅处理特定阶段的任务（提取、创建、反映、重编、验证、丰富）
• –dry-run：展示将执行的内容而不运行
• –handoff：在结束时输出结构化的RALPH HANDOFF块（用于管道链）

第0步：阅读词汇表

阅读 ops/derivation-manifest.md（或者回退到 ops/derivation.md）以获取领域词汇映射。所有输出必须使用领域本地术语。如果两个文件都不存在，则使用通用术语。

现在开始。 处理队列任务。

---

强制约束：子代理生成不是可选的

您必须使用任务工具为每个任务生成子代理。没有例外。

这不是建议。这不是您可以为“简单”任务跳过的优化。整个架构依赖于每个阶段的新鲜上下文隔离。在主会话中直接执行任务：

• 污染上下文（后续任务在降级注意力上运行）
• 跳过交接协议（学习未被捕获）
• 违反ralph模式（每个上下文窗口一个阶段）

如果您发现自己即将直接执行任务而不是生成子代理，请停止。 调用任务工具。每次。每个任务。包括创建任务。包括“简单”任务。

主会话的唯一工作是：读取队列，生成子代理，评估返回，更新队列，重复。

---

阶段配置

每个阶段映射到特定的任务工具参数。在生成子代理时精确使用这些。

阶段	调用的技能	目的
提取	/reduce	从源材料中提取声明
创建	（内联笔记创建）	编写 {DOMAIN:note} 文件
丰富	/enrich	为现有 {DOMAIN:note} 添加内容
反思	/reflect	查找连接，更新 {DOMAIN:topic map}s
重编	/reweave	使用新连接更新旧的 {DOMAIN:note_plural}
验证	/verify	描述质量 + 模式 + 健康检查

所有阶段使用相同的子代理配置：

• 子代理类型：知识工作者（如果可用）或默认
• 模式：dontAsk

子代理继承会话模型。运行opus的用户在处理阶段获得opus质量。运行sonnet的用户在任何地方都获得sonnet。每个阶段的新鲜上下文已经确保了效率 —— 每个阶段在智能区域中都获得了全部能力。

---

第1步：读取队列状态

读取队列文件。按顺序检查这些位置：

1. ops/queue.yaml
2. ops/queue/queue.yaml
3. ops/queue/queue.json

解析队列。识别所有待处理任务。

队列结构（v2模式）：

队列使用每个任务条目的 current_phase 和 completed_phases：

phase_order:
  claim: [create, reflect, reweave, verify]
  enrichment: [enrich, reflect, reweave, verify]

tasks:
  - id: source-name
    type: extract
    status: pending
    source: ops/queue/archive/2026-01-30-source/source.md
    file: source-name.md
    created: "2026-01-30T10:00:00Z"

  - id: claim-010
    type: claim
    status: pending
    target: "claim title here"
    batch: source-name
    file: source-name-010.md
    current_phase: reflect
    completed_phases: [create]

如果队列文件不存在或为空，则报告：“队列为空。使用 /seed 或 /pipeline 添加源。”

第2步：过滤任务

构建一个可执行任务列表 —— 任务 status == "pending"。按任务数组中的位置排序（第一个 = 最高优先级）。

应用过滤器：

• 如果指定了 --batch：仅保留 batch 匹配的任务
• 如果指定了 --type：仅保留 current_phase 匹配的任务（例如，--type reflect 查找 current_phase 为 “reflect” 的任务）

phase_order 头部定义了阶段序列：

• claim：创建 -> 反映 -> 重编 -> 验证
• enrichment：丰富 -> 反映 -> 重编 -> 验证

第3步：如果 --dry-run，报告并停止

展示此内容并停止（不处理）：

--=={ ralph dry-run }==--

队列：X总任务（Y待处理，Z完成）

阶段分布：
 声明：       {create: N, reflect: N, reweave: N, verify: N}
  丰富：      {enrich: N, reflect: N, reweave: N, verify: N}

接下来要处理的任务：
1. {id} — 阶段：{current_phase} — {target}
2. {id} — 阶段：{current_phase} — {target}
...

估计：~{N}个子代理生成

---

第4步：处理循环（串行模式）

如果设置了 --parallel，请跳至第6步。

处理多达N个任务（默认1）。对于每次迭代：

4a. 选择下一个任务

从过滤列表中选择第一个待处理的任务。读取其元数据：id，type，file，target，batch，current_phase，completed_phases。

current_phase 决定调用哪个技能。

报告：

=== 处理任务 {i}/{N}：{id} — 阶段：{current_phase} ===
目标：{target}
文件：{file}

4b. 构建子代理提示

根据 current_phase 构建提示。每个提示必须包括：

• 参考任务文件路径（来自队列的 file 字段）
• 任务身份（id，current_phase，target）
• 使用 --handoff 调用的技能
• ONE PHASE ONLY 约束
• 输出RALPH HANDOFF块的指令

阶段特定提示：

对于提取阶段（仅提取=任务）：

阅读任务文件 ops/queue/{FILE} 以获取上下文。

您正在处理工作队列中的任务 {ID}。
阶段：提取 | 目标：{TARGET}

在任务文件中引用的源文件上运行 /reduce --handoff。
提取后：为每个声明创建任务文件，更新队列中的新条目
（每个声明条目1个，带 current_phase/completed_phases），输出RALPH HANDOFF。
仅一个阶段。不要运行反映或其他阶段。

对于创建阶段：

阅读任务文件 ops/queue/{FILE} 以获取上下文。

您正在处理工作队列中的任务 {ID}。
阶段：创建 | 目标声明：{TARGET}

在此声明的 {DOMAIN:notes}/[claim as sentence].md 中创建一个 {DOMAIN:note}
遵循笔记设计模式：
- YAML前事带有描述（添加超出标题的信息），主题
- 正文：150-400字，显示推理与连接词
- 页脚：来源（wiki链接），相关笔记（带上下文），主题
更新任务文件的 ## Create 部分。
仅一个阶段。不要运行反映。

对于丰富阶段：

阅读任务文件 ops/queue/{FILE} 以获取上下文。

您正在处理工作队列中的任务 {ID}。
阶段：丰富 | 目标：{TARGET}

使用任务文件作为上下文，运行 /enrich --handoff。
任务文件指定要丰富哪个现有的 {DOMAIN:note} 以及添加什么内容。
仅一个阶段。不要运行反映。

对于反映阶段：

构建兄弟列表： 查询队列中其他在同批次且 completed_phases 包括 “create”（笔记已存在）的声明。格式化为wiki链接。

阅读任务文件 ops/queue/{FILE} 以获取上下文。

您正在处理工作队列中的任务 {ID}。
阶段：反映 | 目标：{TARGET}

此批次中的其他声明（在常规发现旁边检查与这些的连接）：
{对于批次中已完成_phases包括"create"的每个兄弟：}
- [[{SIBLING_TARGET}]]
{结束for，或者如果这是第一个声明则为"尚无"}

在：{TARGET} 上运行 /reflect --handoff。
使用双重发现：{DOMAIN:topic map} 探索和语义搜索。
在真正连接存在的地方添加内联链接 —— 包括上面列出的兄弟声明。
用这个 {DOMAIN:note} 更新相关的 {DOMAIN:topic map}。
仅一个阶段。不要运行重编。

对于重编阶段：

与反映相同的兄弟列表（为最新状态重新查询队列）：

阅读任务文件 ops/queue/{FILE} 以获取上下文。

您正在处理工作队列中的任务 {ID}。
阶段：重编 | 目标：{TARGET}

此批次中的其他声明：
{对于批次中已完成_phases包括"create"的每个兄弟：}
- [[{SIBLING_TARGET}]]
{结束for}

为：{TARGET} 运行 /reweave --handoff。
这是向后传递。找到应该引用这个 {DOMAIN:note} 但没有的旧 {DOMAIN:note_plural} 和兄弟声明。
添加从旧 {DOMAIN:note_plural} 到这个 {DOMAIN:note} 的内联链接。
仅一个阶段。不要运行验证。

对于验证阶段：

阅读任务文件 ops/queue/{FILE} 以获取上下文。

您正在处理工作队列中的任务 {ID}。
阶段：验证 | 目标：{TARGET}

在：{TARGET} 上运行 /verify --handoff。
组合验证：背诵（冷读预测测试），验证（模式检查），
审查（每条笔记的健康状况）。
重要提示：背诵首先运行 —— 仅阅读标题+描述，预测内容，
然后在阅读完整的 {DOMAIN:note}。
这是这个声明的最后阶段。仅一个阶段。

4c. 生成子代理（强制性 —— 永不跳过）

用构建的提示调用任务工具：

Task(
  prompt = {4b中构建的提示},
  description = "{current_phase}: {short target}" （最多5个词）
)

重复：您必须在这里调用任务工具。 不要自己执行提示。不要通过在行内运行任务来“优化”。任务工具调用是这一步唯一可接受的操作。

等待子代理完成并捕获其返回值。

4d. 评估返回

当子代理返回时：

1. 查找RALPH HANDOFF块 —— 搜索 === RALPH HANDOFF 和 === END HANDOFF === 标记
2. 如果找到交接：解析完成的工作、学习部分和队列更新部分
3. 如果没有找到交接：记录警告但继续 —— 工作已完成
4. 捕获学习：如果学习部分有非NONE条目，则记录它们以供最终报告

4e. 更新队列（阶段进展）

评估返回后，将任务推进到下一个阶段。

阶段进展逻辑： 从队列头部查找 phase_order 以确定下一个阶段。在数组中找到 current_phase。如果有下一个阶段，则推进。如果是最后一个阶段，则标记为完成。

如果不是最后一个阶段 —— 推进到下一个：

• 将 current_phase 设置为序列中的下一个阶段
• 将完成的阶段追加到 completed_phases

如果是最后一个阶段（验证） —— 标记任务完成：

• 设置 status: done
• 设置 completed 为当前UTC时间戳
• 将 current_phase 设置为null
• 将完成的阶段追加到 completed_phases

对于提取任务仅：在标记完成后重新读取队列。减少技能在执行期间将新任务条目（每个声明/丰富条目1个，带 current_phase/completed_phases）写入队列。主程序必须在后续迭代中拾取这些。

4f. 报告进度

=== 任务 {id} 完成 ({i}/{N}) ===
阶段：{current_phase} -> {下一个阶段或 "done"}

如果捕获了学习，显示一个简短的摘要。 如果还有更多未阻塞的任务，显示下一个。

4g. 重新过滤任务

在下一次迭代之前，重新读取队列并重新过滤任务。阶段进展可能已更改资格（例如，在完成 create 阶段后，任务现在处于 reflect —— 如果过滤为 --type reflect，则它变得符合条件）。

---

第5步：批次后交叉连接（串行模式）

在将任务推进到 “done”（第4e步）后，检查该批次中的所有任务是否现在都有 status: "done"。如果是，并且批次中有2个或更多已完成的声明：

1. 收集所有笔记路径 从完成的批次任务中。对于每个声明任务 status: "done"，读取任务文件的 ## Create 部分以找到创建的笔记路径。

2. 为交叉连接验证生成一个子代理：

Task(
  prompt = "您正在为批次 '{BATCH}' 运行批次后交叉连接验证。

在此批次中创建的笔记：
{从完成的批次任务中列出所有笔记标题+路径}

验证这些笔记之间是否存在兄弟连接。添加任何因为兄弟笔记在早期声明的反映运行时还不存在而错过的连接。
检查向后链接间隙。完成后输出 RALPH HANDOFF 块。",
  description = "cross-connect: batch {BATCH}"
)

3. 解析交接块，捕获学习。将交叉连接结果包括在最终报告中。

跳过如果：批次中只有一个声明（没有兄弟）或批次中的任务仍在等待。

---

第6步：并行模式 (–parallel)

当存在 --parallel 标志时，完全跳过第4步，改用此部分。

不兼容的标志： --parallel 不能与 --type 结合使用。并行模式处理声明端到端（所有阶段）。如果也设置了 --type，请报告错误：

错误：--parallel 和 --type 不兼容。并行处理完整的声明管道，而不是单个阶段。
使用串行模式进行每个阶段的过滤：/ralph N --type reflect

并行架构

两阶段设计： 工人在开始时就收到兄弟声明信息，因此他们可以主动链接。第二阶段验证并捕获任何间隙。

Ralph Lead (你) — 仅编排
|
+-- 第A阶段：并行声明处理（并发）
|   +-- worker-001：声明001的所有4个阶段（具有兄弟意识）
|   +-- worker-002：声明002的所有4个阶段（具有兄弟意识）
|   +-- worker-003：声明003的所有4个阶段（具有兄弟意识）
|   +-- ...最多5个并发工人
|
+-- [语义搜索索引同步]
|
+-- 第B阶段：交叉连接验证（一个子代理，一次通过）
|   +-- 验证兄弟链接，添加工人错过的任何链接
|
+-- 清理 + 最终报告

为什么两个阶段？ 工人在第A阶段具有兄弟意识（声明标题在生成提示时）并在反映/重编期间主动链接。但时机意味着一些兄弟笔记可能在工人的反映阶段还不存在。第B阶段在所有笔记存在后运行单一交叉连接通过。

6a. 确定可并行化的声明

从过滤队列中找到待处理的声明。当其 status == "pending" 时，声明可以并行处理。最多限制为5个并发工人（或N，以较小者为准）。

报告：

=== 并行模式 ===
可并行化声明：{count}
最大并发工人：{min(count, N, 5)}

6b. 生成声明工人

对于每个可并行化的声明（最多N个请求，最多5个并发）：

构建具有兄弟意识的工人提示：

您是处理声明 "{TARGET}" 的声明工人，来自批次 "{BATCH}"。

声明ID：{CLAIM_ID}
任务文件：ops/queue/{FILE}
当前阶段：{CURRENT_PHASE}
已完成阶段：{COMPLETED_PHASES}

此批次中的兄弟声明（在真正连接存在的地方链接到这些）：
{对于批次中的其他声明：}
- "{SIBLING_TARGET}"（任务文件：ops/queue/{SIBLING_FILE}）
{结束for}

在 REFLECT 和 REWEAVE 期间，检查您的声明是否真正连接到任何兄弟。
如果兄弟 {DOMAIN:note} 存在于 {DOMAIN:notes}/ 中，请在真正连接存在的地方内联链接到它。如果它还没有存在（仍在创建中），请跳过 —— 交叉连接将在之后捕获它。

阅读任务文件以获取完整上下文。从 current_phase 开始执行阶段。如果 completed_phases 不为空，则跳过这些阶段（恢复模式）。

完成后，将队列条目更新为状态 "done" 并报告创建的
{DOMAIN:note} 标题、路径和声明ID。领导需要这些进行交叉连接。

通过任务工具生成：

Task(
  prompt = {构建的提示},
  description = "claim: {short target}" （最多5个词）
)

并行生成工人 —— 在单个消息中启动所有任务工具调用，而不是顺序执行。

6c. 监控工人（第A阶段）

等待工人完成。随着工人完成：

1. 解析完成消息 —— 提取创建的笔记标题和路径（第B阶段需要）
2. 记录任何学习 来自工人的报告
3. 检查问题 —— 失败、跳过阶段、资源冲突

收集所有创建的笔记 —— 维护来自工人完成消息的 {note_title, note_path} 列表。您需要这些进行交叉连接验证阶段。

完成门： 第B阶段不能在所有生成的工人报告回来之前开始（无论是成功还是错误）。跟踪完成情况：

生成的工人：{total_spawned}
完成的工人：{completion_count}
有错误的工人：{error_count}

第B阶段准备就绪：{completion_count + error_count == total_spawned}

不要在任何工人仍在运行时进入第B阶段。

6d. 交叉连接验证（第B阶段）

轻量级验证通过。 工人在第A阶段具有兄弟意识并主动链接。此阶段验证他们的工作并捕获间隙。

如果只处理了一个声明则跳过（没有兄弟连接）。

为交叉连接验证生成一个子代理：

Task(
  prompt = "您正在为批次 '{BATCH}' 运行批次后交叉连接验证。

在此批次中创建的笔记：
{从第A阶段列出所有新创建的笔记标题及其路径}

验证这些笔记之间是否存在兄弟连接。添加工人错过的任何连接，
因为兄弟笔记在工人的反映运行时还不存在。
检查向后链接间隙。完成后输出 RALPH HANDOFF 块。",
  description = "cross-connect: batch {BATCH}"
)

解析交接块，捕获学习。

第B阶段后报告：

=== 交叉连接验证完成 ===
兄弟连接验证：{count}
添加的缺失连接：{count}

6e. 清理

在第B阶段完成后（或者如果跳过交叉连接则在第A阶段后）：

1. 清理任何创建的锁文件
2. 跳至第7步进行最终报告，注明并行模式在输出中

---

第7步：最终报告

在所有迭代后（或者当没有更多未阻塞的任务时）：

--=={ ralph }==--

处理：{count} 任务
  {按阶段类型分解}

生成的子代理：{count} （必须等于处理的任务）

捕获的学习：
  {列出任何摩擦、惊喜、方法论见解，或"None"}

队列状态：
  待处理：{count}
  完成：{count}
  阶段分布：{create: N, reflect: N, reweave: N, verify: N}

下一步：
  {如果还有更多待处理任务}：运行 /ralph {remaining} 继续
  {如果批次完成}：运行 /archive-batch {batch-id}
  {如果队列空}：所有任务已处理

验证： “生成的子代理” 计数必须等于 “处理的任务”。如果不等于，领导在行内执行了任务 —— 这是流程违规。在最终报告中将其报告为错误。

如果设置了 --handoff 标志，还输出：

=== RALPH HANDOFF：编排 ===
目标：队列处理

完成的工作：
- 处理 {count} 任务：{任务ID列表}
- 类型：{按类型分解}

学习：
- [Friction]：{description} | NONE
- [Surprise]：{description} | NONE
- [Methodology]：{description} | NONE
- [Process gap]：{description} | NONE

队列更新：
- 标记完成：{完成的任务ID列表}
=== END HANDOFF ===

---

错误恢复

子代理在阶段中崩溃： 队列仍然显示 current_phase 在失败的阶段。任务文件确认相应的部分为空。重新运行 /ralph 自动拾起它 —— 任务在该阶段仍然是待处理的。

队列损坏： 如果队列文件格式错误，报告错误并停止。不要尝试自动修复。

所有任务阻塞： 报告哪些任务被阻塞以及原因。建议补救措施。

空队列： 报告 “队列为空。使用 /seed 或 /pipeline 添加源。”

---

质量门

门1：生成的子代理

每个任务都必须通过任务工具处理。如果领导检测到它在行内执行了任务，将其记录为错误并在最终报告中标记。

门2：交接存在

每个子代理应该返回一个 RALPH HANDOFF 块。如果缺失：记录警告，标记任务完成，继续。

门3：提取产量

对于提取任务：如果提取的声明为零，记录为观察结果。不要自动重试。

门4：任务文件更新

每个阶段后，任务文件的相应部分（创建、反映、重编、验证）应该被填写。如果子代理完成后为空，记录警告。

---

关键约束

永远不要：

• 在领导会话中行内执行任务（使用任务工具）
• 每个子代理处理多个阶段（上下文污染）
• 在没有人工输入的情况下自动重试失败的任务
• 跳过队列阶段推进（破坏管道状态）
• 处理不是待处理状态的任务
• 如果队列文件不存在或格式错误则运行
• 在并行模式中：与 --type 结合（不兼容）

总是：

• 为每个任务通过任务工具生成子代理（领导只编排）
• 在反映和重编提示中包含兄弟声明标题
• 在提取任务后重新读取队列（子代理添加新条目）
• 在迭代之间重新过滤任务（阶段推进创建新资格）
• 从交接块记录学习
• 清晰报告失败以供人工审核
• 验证子代理计数等于任务计数在最终报告中