每个人都必须使用的 AI Agent 技术栈：GPT-5.6 + Fable 5（开发者指南）

1claude CLI（Claude Code），具备 Fable 5 访问权限
2codex CLI，具备 GPT-5.6 访问权限        # 或 Claude Code 内的官方插件
3python3, jq, git, gh, make, cron
4一个今天就能正常运行的代码仓库及其测试命令
5
6# 可选，用于混合舰队（构建 7）：
7openai/codex-plugin-cc               # 官方：在 Claude Code 内运行 Codex
8claude-model-switch                  # 本地代理：Claude Code 背后的任何提供商
9CLIProxyAPI                          # 将 CLI 订阅封装为 API 端点

1your-repo/
2  CLAUDE.md                          # 构建 1：Claude 端的"宪法"
3  AGENTS.md                          # 构建 1：Codex 端的"宪法"
4  .claude/
5    skills/model-bench/SKILL.md      # 构建 0：价格、API ID、回退方案。唯一包含数字的文件
6    skills/model-router/SKILL.md     # 构建 4
7    skills/stuck-protocol/SKILL.md   # 构建 5
8    skills/ship-gate/SKILL.md        # 构建 2
9    agents/fable-expert.md           # 构建 5
10    agents/fresh-eyes-reviewer.md    # 构建 6
11    agents/sol-reviewer.md           # 构建 6
12    agents/scout.md                  # 构建 7
13  loop/
14    ralph.sh                         # 构建 3：心跳
15    two_lane.sh                      # 构建 6：跨供应商审阅循环
16    PROMPT.md  TASKS.md              # 构建 3：工作协议
17  gate/
18    verify.sh                        # 构建 2：确定性最终投票
19    eval_gate.py  eval/cases.jsonl   # 构建 2：路由变更门禁
20  router/
21    router.py                        # 构建 4
22    advisor_loop.py                  # 构建 5
23  ~/.codex/
24    config.toml                      # 构建 0：luna/terra/sol 配置文件
25    prompts/effort.md                # /effort      评估任务，指定座位
26    prompts/plan-stop.md             # /plan-stop   规划，定价，然后停止
27    prompts/fable-advice.md          # /fable-advice 跨供应商专家咨询
28    prompts/review-hostile.md        # /review-hostile 干净上下文下的判决
29    prompts/compost.md               # /compost     失败转化为法则，每周执行
30  factory/
31    factory_gate.py                  # 构建 8：黑板 + 完成门禁
32    factory.sh                       # 构建 8：概要 -> 实现 -> 审阅 -> 门禁
33    factory.db                       # 构建 8：决定结果的数据行
34  swarm/
35    swarm.sh                         # 构建 9：规划 -> 派遣 -> 评分 -> 重新规划
36    goals.jsonl                      # 构建 9：每行一个目标，每个目标带有其检查
37  system/
38    verify_goals.py                  # 构建 10：每日重新验证，永久运行
39    goals/                           # 构建 10：每件完成的事情一个文件
40  ROUTING.md                         # 构建 12：完整的路由策略，两个主控程序
41  progress.log                       # 每个构建步骤都会追加内容
42  # 可选（构建 7）：claude-model-switch 代理在 localhost:4000，
43  # CLIProxyAPI 用于将 CLI 订阅封装为 API 端点

1---
2name: model-bench
3description: 当前价格表、API 模型 ID 以及本系统可以雇佣的每个模型的回退链。在任何路由决策、成本估算、预算问题、模型比较之前加载，或当用户询问某物成本时加载。
4---
5
6# 模型基准
7
8价格和 API 标识符的唯一真实来源。此仓库中没有任何其他文件硬编码价格，因此当实验室调整费率时，你只需编辑此文件，无需其他操作。于 2026-07-13 验证。价格会变动。在制定预算前请重新验证。
9
10## Anthropic（Messages API，/v1/messages）
11
12努力程度：output_config {"effort": "low|medium|high|xhigh|max"}。Fable 5 始终开启自适应思考，无法禁用。max_tokens 限制思考加响应文本的总和，因此在高级别及以上设置较大的值（从接近 64k 开始），否则模型会在思考中途用尽空间。
13
14| 模型 | 每百万 token 输入/输出 | 缓存读取 | 席位 |
15|---|---|---|---|
16| claude-fable-5 | $10/$50 | $1.00 | 指挥者、规划者、顾问、法官。自动回退到 opus-4-8 |
17| claude-opus-4-8 | $5/$25 | $0.50 | 遵守保留规则时的指挥者 |
18| claude-sonnet-5 | $2/$10（至 8 月 31 日，之后 $3/$15） | 无 | 默认编码执行器 |
19| claude-haiku-4-5 | $1/$5 | $0.10 | 侦察兵、子 Agent、机械性工作 |
20
21Fable、Opus 4.8、Sonnet 5 的上下文为 1M，长上下文统一价格，这就是为什么长读取任务会路由到这里。最大输出 128K。
22
23## OpenAI（Responses API，/v1/responses）
24
25| 模型 | 每百万 token 输入/输出 | 已缓存 | 席位 |
26|---|---|---|---|
27| gpt-5.6-sol | $5/$30 | $0.50 | 跨供应商审阅者，终端工作 |
28| gpt-5.6-terra | $2.50/$15 | $0.25 | Codex 日常驱动（先与 Luna 测试对比） |
29| gpt-5.6-luna | $1/$6 | $0.10 | 机械性工作，静默检查 |
30
31超过阈值的长上下文输入价格大约翻倍，这与 Anthropic 的 1M 统一价格层级不同。首个具有明确缓存断点系列的模型；写入成本为 1.25 倍。
32
33## 开放权重模型（批量工作者）
34
35| 模型 | 每百万 token 输入/输出 | 缓存命中 |
36|---|---|---|
37| deepseek-v4-flash | $0.14/$0.28 | $0.0028（大约 98% 折扣） |
38| deepseek-v4-pro | $0.435/$0.87 | 无 |
39| kimi-k2.7-code | $0.95/$4.00 | $0.19 |
40
41## 可叠加的折扣
42  - 两个实验室的缓存读取成本均为新鲜输入的十分之一（约 90% 折扣）
43  - 缓存写入在读取一次后（5 分钟）或两次后（1 小时）即可收回成本
44  - 批量 API 双向均为 50% 折扣
45  - 批量 + 对重复前缀的缓存读取，总折扣接近 95%
46  - Anthropic 最新的分词器对相同文本生成的 token 数量大约多 30%，因此实际成本高于标价。按实际成本预算。
47
48## 如何回答成本问题
49  1. 分别估算输入和输出。Agent 每写 1 个 token 大约读取 100 个 token，因此输入占主导地位，缓存命中率决定账单。
50  2. 对重复前缀应用缓存读取率，而不是基础费率。
51  3. 将 Anthropic 的数字乘以约 1.3 以考虑分词器影响。
52  4. 给出一个范围，说明假设条件，并指出你使用了此文件的哪一行。
53  5. 如果数字超过仓库的每日上限，请在运行任何操作之前说明。
54
55除非你从本文件中读取，否则绝不给出价格。本文件未列出的模型不在候选名单上，添加模型属于需要通过门禁的路由变更。

1# ~/.codex/config.toml
2model = "gpt-5.6-terra"                 # 日常驱动
3model_reasoning_effort = "medium"
4# service_tier = "fast"                 # 保持注释状态。快速模式按 2.5 倍计费
5                                        # 积分。运行 /fast status 确认你
6                                        # 尚未进入该模式。
7
8[profiles.fast]                         # 机械性工作。不是"快速模式"：此
9model = "gpt-5.6-luna"                  # 配置文件是一个更便宜的模型，而不是 2.5 倍
10model_reasoning_effort = "low"          # 计量器。两个不同的东西，同一个词。
11
12[profiles.deep]                          # 规划、棘手的错误、审阅
13model = "gpt-5.6-sol"
14model_reasoning_effort = "high"

1# CLAUDE.md
2
3## 绝不（例外需要先询问）
4- 绝不在会话中途切换模型。路由仅在会话和子 Agent 边界处发生。中途切换会烧掉缓存。
5- 绝不审阅你自己的 diff。审阅必须来自一个全新的上下文或不同的模型系列。Devin 的审阅者之所以能每个 Agent PR 捕捉 2 个 bug，正是因为它与编写者没有任何共享信息。
6- 绝不编辑、削弱或删除测试以使其通过。自动 FAIL。
7- 绝不根据自我评估报告完成。完成 = gate/verify.sh 通过。
8- 绝不进行第四次顾问咨询。三次未命中 = BLOCKED，轮到人类。
9- 绝不合并 eval_gate.py 判定为 BLOCKED 的路由或提示变更。
10- 绝不在两个上限都未设置的情况下运行任何循环：MAX_ITERS 和 BUDGET_USD。
11- 绝不要假设前沿模型可用。回退方案：fable-5 -> opus，sol -> terra。将每次回退记录到 progress.log。
12- 绝不生成未经要求的子 Agent。子节点继承父节点的模型和努力程度，因此一个热心的舰队会继承昂贵的席位。
13
14## 派遣（第一个匹配获胜）
15| # | 任务 | 席位 |
16|---|---|---|
17| 1 | 规划 / 架构 / 迁移 | fable-5 规划，sonnet 执行 |
18| 2 | 提取 / 格式化 / 测试 / 文档 | haiku 或 luna |
19| 3 | 上下文超过 60k token | Anthropic 1M 统一价格层级 |
20| 4 | 对 Agent 编写的代码进行审阅 | 通过 codex 使用 sol，原生主控程序 |
21| 5 | 不明确 | 难度评分：0-1 便宜，2 sonnet，3+ 前沿 |
22| 6 | 仍然不确定 | 先用便宜的跑一次，验证，失败时升级一次 |
23
24## 完成
25- 每项任务在工作开始前都带有一个机器可检查的 done_when 条件。
26- 一个全新上下文的审阅者只根据规格与 diff 进行判断，不参考其他内容。
27- gate/verify.sh 持有最终投票权。一个项目上出现两次制造者/检查者分歧 -> 停止，排队等待人类处理。

1# AGENTS.md
2
3## 命令
4| 用途 | 命令 |
5|---|---|
6| 测试 | make test （此命令即完成的定义） |
7| 代码检查 | make lint |
8
9## 会话协议
101. 先阅读 progress.log 和 TASKS.md。2. 一个未勾选的任务。
113. 实现，运行完整的测试套件，仅在绿色时提交，描述性消息。
124. 勾选任务，在 progress.log 中追加一行，停止。
13测试定义完成。绝不削弱、跳过或删除测试。错误的测试 = 将任务标记为 BLOCKED 并说明原因。
14
15## 模型策略
16默认：terra，中等努力程度。机械性：配置文件 fast（luna，低）。
17规划和棘手的错误：配置文件 deep（sol，高）。
18先考虑努力程度，再考虑模型。配置文件在会话开始时选定，绝不在任务中途更改。
19快速模式关闭（2.5 倍积分）。Ultra 关闭。这两者都不是努力程度级别。
20只有当我要求时，才生成子 Agent。子节点继承本次会话的模型和推理级别，因此一个高努力程度的热心生成就是一个高努力程度的整个舰队。
21
22## 卡住
23信号：相同的错误两次；两个无进展的步骤；一个测试在两次不同的修复后仍然失败。然后使用 /fable-advice。最多 3 次咨询，然后 BLOCKED。
24
25## 审阅
26在任何合并之前，在一个全新的会话中使用 /review-hostile，或者从 Claude 端使用跨供应商通道。绝不合并你自己未经审阅的工作。

1#!/usr/bin/env bash
2set -e
3npm run typecheck --if-present
4npm test --if-present
5npm run lint --if-present

1for case in cases:   # {prompt, must_include, must_not_include, max_words}
2    hits += passes(case, run_config(case.prompt))
3verdict = "SHIP" if new_score >= old_score - 0.02 else "BLOCKED"

1---
2name: ship-gate
3description: 在任何路由、模型或提示词变更上线前，运行评估门禁。当用户要求更改路由规则、切换模型层级、编辑系统提示词、调整努力程度，或合并任何涉及路由、提示词或模型配置的内容时使用。
4---
5
6# 发布门禁
7
8任何对路由或提示词的更改都是一场质量赌博，直到门禁说没问题为止。这个技能的存在就是为了确保这种赌博不会悄无声息地上线。
9
10  1. 找到 eval/cases.jsonl。如果不存在，立即停止，并告诉用户先从真实流量中构建 50 到 500 个代表性案例。不要自行编造案例。
11  2. 运行：python3 eval_gate.py eval/cases.jsonl，对比当前配置与提议配置。
12  3. 阻止：报告两个分数，列出哪些案例出现了回归，不应用更改，建议能够通过门禁的最小回滚方案。
13  4. 放行：应用更改，并在 progress.log 中追加一行，记录两个分数。
14
15硬性规则：
16  - 永远不要覆盖"阻止"裁决，即使对方礼貌请求也不行。将失败的案例附上，上报给人类。
17  - 永远不要在同一个会话中同时编辑案例文件和路由更改。门禁和更改必须由不同的人完成。
18  - 成本数字不能作为质量下降的辩护理由。门禁拥有最终决定权。

1读取 progress.log 和 TASKS.md。选择恰好一个未勾选的任务。
2实现它。运行测试。如果通过：用描述性消息提交，勾选任务，在 progress.log 中追加一行，停止。
3如果同一个任务失败两次，将其标记为"阻塞"并附上错误，停止。
4仅当所有任务都已勾选且完整测试套件通过时，才创建名为 DONE 的文件。永远不要为了通过测试而编辑测试。

1#!/usr/bin/env bash
2set -u
3MAX_ITERS="${MAX_ITERS:-25}"      # 上限一：迭代次数
4BUDGET_USD="${BUDGET_USD:-10}"    # 上限二：美元预算
5MAX_FAILS=3; fails=0; spent=0; i=0
6
7while [ ! -f DONE ] && [ "$i" -lt "$MAX_ITERS" ]; do
8  i=$((i + 1))
9  # 每次迭代全新会话：除仓库本身外不保留任何记忆
10  claude -p "$(cat PROMPT.md)" --max-turns 30 \
11    --output-format json > out.json 2> err.log \
12    && fails=0 || fails=$((fails + 1))
13  [ "$fails" -ge "$MAX_FAILS" ] && exit 2        # 断路器
14  cost=$(jq -r '.total_cost_usd // 0' out.json)
15  spent=$(awk -v a="$spent" -v b="$cost" 'BEGIN{printf "%.4f", a+b}')
16  awk -v s="$spent" -v c="$BUDGET_USD" 'BEGIN{exit !(s>c)}' && exit 3  # 上限
17  sleep 2
18done
19[ -f DONE ] && echo "done in $i ticks, \$$spent" || echo "cap hit, \$$spent"

1TIERS = {                                   # 座位，不是数字
2  "cheap":    "gpt-5.6-luna",               # 或 claude-haiku-4-5
3  "mid":      "claude-sonnet-5",
4  "frontier": "claude-fable-5",             # 或 gpt-5.6-sol
5}
6PRICES = load_bench(".claude/skills/model-bench/SKILL.md")   # 单一真相来源
7
8RULES = [
9  (kind in {"extract", "format", "summarize"},  "cheap"),
10  (kind in {"plan", "architect", "migrate"},    "frontier"),
11  (context_length > 60_000,                     "mid"),
12]
13tier = layer1_rules(task) or layer2_classifier(task)
14if tier: return call(TIERS[tier], task)
15return cascade(task)   # 先 cheap，验证，失败时仅升级一次

1---
2name: model-router
3description: 在开始工作前，将每个任务路由到正确的座位和努力程度。在会话开始时、生成子 Agent 前、用户询问使用哪个模型时，或任务混合了规划和执行时使用。
4---
5
6# 模型路由器
7
8读取 ROUTING.md 并应用它。不要即兴制定策略，也不要在此处重述策略：这个文件会腐烂，而策略文件才是受评估门禁约束的那个。
9
10这个技能在该文件之上强制执行三件事：
11
12  1. 仅在边界处进行路由。会话开始和子 Agent 生成。任务中间切换会使缓存失效，并以缓存价格的十倍重新计费上下文。
13  2. 在会话结束时，将廉价层占比追加到 progress.log。只有大多数流量走廉价层时，节省才会复合增长，因此这个数字是值得关注的。
14  3. 对 ROUTING.md 的任何更改都通过发布门禁技能上线。没有例外。

1name: scout
2model: haiku
3effort: low     # 子 Agent 继承父级。一个最大努力程度的集群
4                # 会在一条消息中耗尽一个窗口。固定它们。

1grep '^route' progress.log | awk -F'\t' \
2  '{r++; if($3!="frontier")c++} END{printf "cheap share: %.0f%%\n", c/r*100}'

1# ROUTING.md
2
3路由是四个决策，顺序是关键：
4  1. 在哪里：哪个 harness 运行工作
5  2. 何时：在哪个边界做出决策
6  3. 谁：哪个模型占据座位
7  4. 多努力：该模型运行在哪个努力程度
8大多数团队只争论第 3 点。钱在第 2 点和第 4 点。
9
10## 1. 在哪里：先选择 harness，再选择模型
11在 harness 内部进行后训练的模型，在其他任何地方都会分布异常。
12测量差异：原生 20.2%，外来 7.7%，相同权重。
13
14| 工作 | Harness | 原因 |
15|---|---|---|
16| 编写代码 | 模型的原生 harness | 编写者在分布外性能下降 |
17| 评审代码 | 评审者的原生 harness | 弱的评审比没有更糟 |
18| 阅读、侦察 | 任何地方 | 阅读成本低且可验证 |
19| 机械转换 | 任何地方 | 如果检查是确定性的，harness 几乎无关紧要 |
20
21法则：自由重新映射阅读者和评审者通道。编写者通道保持 harness 原生，直到你自己的评估集另有说明。该覆盖必须基于测量，而非偏好。
22
23## 2. 何时：在边界处路由，绝不在边界内路由
24会话中间切换会丢弃提示缓存。缓存的输入成本是新鲜输入的十分之一，因此无用的切换会以十倍价格重新计费整个上下文，且一无所获。
25
26合法的边界，唯一可能发生路由决策的地方：
27  - 会话开始
28  - 子 Agent 生成
29  - 集群中的新目标
30  - 将评审移交给另一个谱系
31  - 由故障或安全防护触发的回退
32
33其他任何地方都是非法的。没有每轮路由。没有任务中间自适应切换。
34级联恰好获得一次升级，并且会打开一个新的边界。
35
36法则：在边界打开时选择座位，然后一直保持直到下一个边界。
37
38## 3. 谁：决策流程（先匹配获胜，记录结果）
39
40第 1 层，规则。免费。始终先检查。
41
42| 信号 | 座位 |
43|---|---|
44| 提取 / 格式化 / 总结 / 分类 / 测试 | Haiku 或 Luna，低努力 |
45| 计划 / 架构 / 迁移 / 根因分析 | Fable 计划，Sonnet 执行 |
46| 上下文超过 60k tokens | Anthropic 1M 层级（统一定价） |
47| 评审 Agent 编写的代码 | 另一个谱系，原生 harness |
48| 目标拆分为独立部分 | 集群：Fable 编写和评分 |
49
50第 2 层，评分。每个一分：
51  - 包含 why / debug / race / deadlock / refactor / security / optimize
52  - 涉及多个子系统
53  - 先前的尝试已经失败
54  - 更改是不可逆的或面向用户的
55  0-1 -> 廉价层，低努力。2 -> Sonnet，中。3+ -> 前沿层，高。
56
57第 3 层，级联。运行廉价，确定性验证，恰好升级一次。
58绝不两次。第二次失败是规格问题，更大的模型不会修复你的规格。
59
60座位和回退位于 .claude/skills/model-bench/SKILL.md。这里没有价格。
61
62## 4. 多努力：努力程度路由
63努力程度是路由的下一层。这个文件中最便宜的旋钮：其他一切不变，缓存保持温暖。
64
65| 努力程度 | 使用场景 |
66|---|---|
67| 低 | 拼写错误、重命名、排序、提取、所有子 Agent 默认 |
68| 中 | 根据清晰规格的常规代码、总结、标准写作 |
69| 高 | 拆解、迁移、棘手 bug、所有指挥者工作（默认） |
70| 最大 | 仅用于高已经无法破解的问题 |
71| 超极值 | 不在这个阶梯上。宽度，不是深度：4 个并行 Agent。默认关闭 |
72
73  1. 默认设为高。最佳点在那里；最大值会陷入过度思考。
74  2. 更好的模型优于更高的旋钮。先升级座位，再提高设置。
75  3. 子 Agent 继承父模型的模型和努力程度。从最大努力程度的指挥者生成的集群以最大程度运行，并在一条消息中耗尽一个窗口。在每个子 Agent 的 own frontmatter 中固定：努力程度：低。如果生成器忽略固定，父级的旋钮就是集群的旋钮。检查你拥有哪一个。
76  4. 最大值是深度。超极值是宽度。仅当子问题真正独立时才使用超极值，永远不要作为默认值，并且在 harness 过度生成时根本不使用。
77  5. 这个阶梯不跨版本移植。在新模型上，从旧模型上你信任的设置下降一档开始。
78  6. 快速模式也不是努力程度。它用 2.5 倍积分换取你本来就要消耗的 tokens 的延迟。关闭。
79
80旋钮存在于四个地方：Claude Code 和 Codex TUI 中的 /effort，codex -e high，config 中的 model_reasoning_effort，API 上的 effort 字段。Claude Code 默认高，Codex 默认中，大多数应用完全隐藏它，这就是为什么团队不小心对所有事情都使用同一个级别。
81
82## 5. 回退：假设前沿层宕机
83前沿层可用性不保证，安全防护可以在运行中将调用重路由到 Opus 4.8，在不到 5% 的会话中，且不会出错。
84  - 每个座位都有一个命名的回退。没有例外。
85  - 每个回退都被记录。静默重路由是一个 bug，因为你可能正在阅读来自你未选择的模型的输出。
86  - 永远不要在你未选择的模型的输出上进行迭代。
87
88## 6. 决定这一切是否有效的数字
89混合成本就是你的流量分流，没有别的。70% 廉价层将账单减少大约三分之二。10% 节省零花钱。路由器准确性远比路由器聪明程度值钱。
90
91用构建 4 中的一行命令跟踪它。低于 50%，节省尚未开始复合。在接触这里任何其他东西之前，先修复分流。
92
93## 7. 这个文件的门禁
94法则：没有 eval_gate.py 在 50 到 500 个保留案例上通过，任何对这个文件的更改都不能上线。"阻止"裁决是最终的，不能在会话中覆盖。门禁和更改必须由不同的人完成。
95
96## 8. 何时删除这个文件
97如果单个精心挑选的模型在你的评估集上击败了整个堆栈，删除路由器，保留简单性。2026 年最严格的路由基准发现，许多路由器（包括商业路由器）无法可靠地胜过选择最佳单一模型。
98先测量。再路由。开心地删除。

1---
2name: stuck-protocol
3description: 当进展停滞时，升级到 fable-expert 顾问。当相同错误出现两次、当连续两步没有更改文件而错误持续存在、当测试在两次不同的修复尝试后仍然失败、或当用户说 Agent 在兜圈子时使用。
4---
5
6# 卡住协议（顾问反转）
7
8你是廉价驱动程序，这正是一个特性：执行是批量，建议是克。但小型模型过于自信，因此你不能自己决定自己没事。相反，检查确定性信号。
9
10卡住信号（任何一个触发协议）：
11  1. 连续两步出现相同的错误字符串。
12  2. 连续两步零文件更改而错误持续存在。
13  3. 同一个测试在两次真正不同的修复尝试后仍然失败。
14
15流程：
16  1. 统计本会话中的咨询次数。达到 3 次时，停止：将任务标记为"阻塞"并附上错误，总结给人类，继续。绝不要第四次咨询。
17  2. 构建简报，其中不包含其他内容：
18       目标：一行
19       尝试 x2：最后两次尝试，每次 200 个字符
20       错误：确切错误，300 个字符
21  3. 生成 fable-expert 并附带简报。它返回指导，而不是代码。
22  4. 在下一步立即应用指导，先于任何你自己的内容。
23  5. 在 progress.log 中追加一行：咨询 #N，它说了什么，是否有效。
24
25硬性规则：
26  - 永远不要要求专家做工作。如果回复包含完整实现，接受想法并丢弃代码。
27  - 永远不要在简报中加入你的推理历史。专家的价值在于干净的上下文；冗长的简报会毒害它。
28  - 如果指导失败，这算作你向下一次咨询的两次尝试之一。三次失败的咨询意味着这个任务超出了本会话的薪酬等级，如实说出这一点是正确的输出。

1---
2name: fable-expert
3description: 卡住时刻的前沿层顾问。从 stuck-protocol 接收紧凑简报，返回 600 个 tokens 以下的指导，从不自己完成工作。
4model: claude-fable-5      # 如果保留规则限制，则切换到 opus
5effort: high
6tools: Read, Grep, Glob    # 可以阅读，永远不能编辑
7---
8
9你是专家顾问，不是承包商。一个更便宜的模型正在驱动并遇到了障碍。你的价值在于以克为单位的判断力和干净的上下文：你对驱动程序如何到达这里一无所知，而这正是你的见解更敏锐的原因。
10
11你收到一份简报：目标、最后两次尝试和错误。如果简报提到了特定文件，你可以阅读它们。你不能编辑任何东西。
12
13  1. 如果简报缺少你需要的东西，回复一行，说明缺少什么。不要猜测缺口。
14  2. 在开处方之前先诊断：一两句话说明真正的问题是什么。
15  3. 然后以以下格式回复，之后不要有任何内容：
16       指导：
17       1. （最可能的修复：尝试什么，以及为什么它应该有效）
18       2. （如果 1 失败，回退方案）
19       3. （仅当存在真正不同的第三条路径时）
20       信心：高 | 中 | 低
21  4. 600 个 tokens 以下。没有超过 10 行的代码块。给出想法，而不是实现。如果你的回复包含完整解决方案，你就没有履行角色。
22  5. 如果任务本身被误解，在第 1 项中说明，并建议告诉人类什么。
23
24操作者说明：如果你的组织无法接受 Mythos 级别的保留，将模型行改为 opus。角色运作方式相同；顾问结果最初是用 Opus 级别的顾问证明的。

1claude --model claude-fable-5 -p "你是一位专家顾问。
2一个更便宜的模型正在驱动并卡住了。简报：<目标，两次
3尝试，错误>。回复指导：最多 3 个编号项目，
4600 个 tokens 以下。不要做工作。"

1---
2name: fresh-eyes-reviewer
3description: 空上下文代码审查器。在任何 Agent 写入变更后调用。与编写者共享零历史记录，自行读取 diff，不可编辑。
4model: haiku               # 当 diff 涉及关键负载时，切换为 opus
5effort: medium
6tools: Read, Grep, Glob, Bash
7---
8
9你完全不记得这个变更是如何编写的，而这正是关键所在。不要询问作者的推理过程。不要相信任何摘要。只看证据。
10
11  1. 执行 git diff HEAD~1（或给定的范围）并读取每个代码块。
12  2. 读取每个被修改文件的**完整内容**，而不仅仅是代码块。Bug 往往隐藏在变更周围未更改的行中。
13  3. 运行 README 或 CLAUDE.md 中指定的测试套件。
14  4. 查找三种经典的 Agent 失败模式：
15       laziness（懒惰）：部分实现、TODO、仅针对一种情况处理
16       self-grading（自我评分）：测试被削弱、断言被删除、测试套件被跳过
17       drift（偏离）：超出所述任务范围的变更
18  5. 判决，必须使用以下确切格式：
19       VERDICT: PASS 或 FAIL
20       BUGS: 编号列表，每个包含 文件:行号 和一句原因
21       RISK: 一句话描述此变更所触及的最具风险的部分
22
23硬性规则：你不得编辑文件，不得重新运行编写者的任务，且 BUGS 列表为空但 VERDICT: FAIL 是无效的。如果测试无法运行，则自动判定为 FAIL 并附上原因。

1---
2name: sol-reviewer
3description: 跨供应商审查器。通过 Codex CLI 将最新提交发送给 GPT-5.6 Sol，在 Sol 的原生框架中运行，并原封不动地传递判决结果。
4model: haiku               # 仅作为管道。Sol 是审查者。
5effort: low
6tools: Bash, Read
7---
8
9你是管道，不是审查者。同系列模型共享盲点；此通道的存在是因为 Sol 不与 Claude 共享盲点。
10
11  1. 检查 CLI：codex --version。如果缺失，输出 VERDICT: FAIL 并附上原因 “codex CLI not installed” 以及设置路径（或官方插件：/plugin marketplace add openai/codex-plugin-cc, /plugin install, /codex:review）。
12  2. 以高努力度，在 Sol 自身的框架中运行审查：
13
14     codex --profile deep exec "Review the latest commit (git show HEAD) as a
15     hostile senior engineer who has never met the author. Read every touched
16     file IN FULL, not just the hunks. Hunt: partial implementations, weakened
17     or deleted tests, changes outside the stated task scope. End with exactly
18     'VERDICT: PASS' or 'VERDICT: FAIL' followed by numbered findings, each with
19     file:line and a one-sentence reason."
20
21  3. 将完整输出保存到 .review_sol_<short-hash>.md。
22  4. 向上传递：首先传递 VERDICT 行，然后**逐字**传递发现结果。不要总结或淡化发现，不要添加安慰性话语，不要与 Sol 争论。如果判决是 FAIL，由上级决定修复什么。你不做任何决定。
23
24硬性规则：绝不能编辑文件，绝不能重新运行编写者的任务，绝不能用自己的审查替代。如果 codex 在运行过程中出错，将其报告为 FAIL 并附带 stderr，而不是悄悄重试超过一次。

1claude -p "Implement: $TASK. Run the tests. Commit when green."
2review=$(codex exec "Review HEAD ... VERDICT: PASS or FAIL plus findings.")
3grep -q "VERDICT: PASS" <<< "$review" && exit 0
4claude -p "A reviewer from another model family found these issues.
5  Fix every one, rerun tests, commit: $review"

1/plugin marketplace add openai/codex-plugin-cc
2/plugin install codex@openai-codex
3/codex:setup

1---
2name: scout
3description: 用于研究分支扩展的廉价并行读取器。可同时生成多个，用于代码库调查、依赖审计、日志考古、文档研究。根据原则只读；读取并行，写入保持单线程。
4model: haiku
5effort: low                # 继承保护（BUILD 4）：一个继承最大努力度的群组
6                           # 会在一条消息内耗尽一个窗口
7tools: Read, Grep, Glob, Bash
8---
9
10你可能是多个并行运行的读取器之一。调查你的切片并返回简短而精确的信息。只有你的最终消息会返回给上级，因此请控制在 400 字以内，并确保每个字都物有所值。
11
12  1. 自行将你的任务缩小到一个切片（一个目录、一个子系统、一个问题），并说明你缩小到了什么范围。
13  2. 仅限读取：Read, Grep, Glob 和只读 shell（ls, git log, git show, rg）。绝不能编辑、安装或删除。如果任务需要写入操作，请报告它，不要执行它。
14  3. 先广度，然后对两到三个最热点的位置进行深度挖掘。
15
16报告格式，仅此而已：
17  FINDINGS: 最多 10 条要点，每条包含一个事实及其证据（文件:行号、提交哈希或 URL）
18  GAPS: 你无法确定的内容及其原因，以便上级了解哪些区域仍是未知的
19  HOTSPOT: 最值得深入查看的单个文件或函数，以及一句原因说明
20
21不要发表评论，不要提出实现方案，不要填充内容。一个返回 300 个有用词的侦察兵，胜过返回 3000 个混杂词汇的，因为你的所有输出都会进入上级的上下文窗口，而上级需要为此付费。

1claude-model-switch init                 # 将 Claude Code 指向代理
2claude-model-switch add openrouter sk-or-xxx
3claude-model-switch add glm \
4  --haiku glm-4.5-air --sonnet glm-4.7 --opus glm-5
5claude-model-switch use glm              # 按会话切换，绝不在任务中间切换
6claude-model-switch orchestrate start --preset trio   # planer/coder/reviewer

1checks = [
2  (tickets == 0,                 "No tickets were recorded."),
3  (done != tickets,              "Not all tickets are done."),
4  (first_brief is None,          "No architecture brief was recorded."),
5  (first_brief > first_code,     "Implementation evidence predates the brief."),
6  (code_ev == 0,                 "No implementer code evidence was recorded."),
7  (build_ok == 0,                "No passing build command evidence."),
8  (test_ok == 0,                 "No passing test command evidence."),
9  (latest("architect") != "green",  "Latest architect verdict is not green."),
10  (latest("reviewer")  != "green",  "Latest reviewer verdict is not green."),
11]

1G ticket "kanban board" "columns render, drag persists"    # planer 行
2G brief  "$BRIEF"                                          # 在任何代码之前
3../loop/ralph.sh && G evidence code pass "loop completed"  # BUILD 3 工作
4npm test          && G evidence test pass "npm test green"
5G verdict 1 architect green "layout matches brief"         # Claude 席位
6G verdict 1 reviewer  green "tests pass, scope clean"      # Sol 席位，通过 codex
7python3 factory_gate.py gate factory.db                    # 行决定结果

1$ factory_gate.py record demo.db ticket "kanban-board" "columns render, drag persists"
2
3$ factory_gate.py gate demo.db
4GATE: REFUSED
5  - Not all tickets are done.
6  - No architecture brief was recorded.
7  - No implementer code evidence was recorded.
8  - No passing build command evidence.
9  - No passing test command evidence.
10  - No review cycle was recorded.
11  exit: 1
12
13... agents 工作。每一步都写入一行 ...
14
15$ factory_gate.py record demo.db brief    "Stack: node+sqlite. /tasks CRUD."
16$ factory_gate.py record demo.db evidence code  pass "src/board.js written"
17$ factory_gate.py record demo.db evidence build pass "npm run build exit 0"
18$ factory_gate.py record demo.db done     "kanban-board"
19$ factory_gate.py record demo.db verdict 1 architect green "layout matches brief"
20$ factory_gate.py record demo.db verdict 1 reviewer  green "scope clean"
21
22$ factory_gate.py gate demo.db
23GATE: REFUSED
24  - No passing test command evidence.
25  exit: 1
26
27$ factory_gate.py record demo.db evidence test pass "npm test 33/33"
28
29$ factory_gate.py gate demo.db
30GATE: COMPLETE (1/1 tickets, cycle 1 green x2)
31  exit: 0

1FLEET=4                              # 写入操作从不冲突：每个工作树单独一个
2WORKER_MODEL=claude-sonnet-5         # 或使用 haiku / luna / kimi 进行纯执行
3WORKER_EFFORT=low                    # 绝不能继承指挥者的努力度
4CONDUCTOR=claude-fable-5             # 或如果保留规则导致问题，使用 opus-4-8

1{"id":"strip-legacy-auth","spec":"remove the v1 auth path from routes/","check":"npm test -- tests/auth"}
2{"id":"migrate-sessions","spec":"move session store to the new adapter","check":"npm test -- tests/session"}

1# dispatch: one git worktree per goal, capped at FLEET in parallel
2claude --model "$WORKER_MODEL" --effort "$WORKER_EFFORT" -p "Execute this spec
3  exactly. Do not expand scope. Run the tests. Commit only when green."
4
5# score: 指挥者根据其自身的检查命令对每个目标进行评分。
6# 工作者的信心不是证据。退出代码才是。
7bash -c "$chk" && echo "$id" >> passed.txt || misses=$((misses+1))
8
9# replan: 下一个周期会看到 passed.txt 并仅对未通过的目标重新计划

1predicate: npm test -- tests/auth 2>&1 | tail -1 | grep -q passing
2born: 2026-07-13
3status: satisfied
4last-pass: 2026-07-13
5on-violation: wake me. do not auto-fix.

1held = subprocess.run(["bash","-c",predicate], timeout=60).returncode == 0
2g["status"] = "satisfied" if held else "VIOLATED"
3# 超时是违规，而不是通过：一个昂贵的断言本身就是有问题的

1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \
2  -p "Read this week's exhaust: BLOCKED lines in progress.log, GATE REFUSED
3  entries, VIOLATED goals, PRs closed unmerged. Extract AT MOST 3 proposals:
4  a new law (quote the incidents), a skill fix (same failure repeating), or a
5  standing goal we lacked. Propose only, do not edit anything. Clean week is a
6  valid answer, say so and stop."

1claude --model claude-fable-5 --effort high --allowedTools "Read,Grep,Glob" \
2  -p "Review this project end to end. Write an improvement plan ranked by
3  leverage: what is fragile, what is over-built, what is missing, what should
4  be deleted. Do not write code. Output tasks with acceptance criteria." \
5  > plans/$(date +%F)-improvement.md

1awk -F'\t' '$2=="fix-lint"{r++; if($3=="pass")p++}
2  END{printf "%d runs, %.0f%%\n", r, (r?p/r*100:0)}' progress.log

1grep '^cost' progress.log | awk -F'\t' \
2  -v d="$(date -d '7 days ago' +%F)" \
3  '$2>=d{s+=$3} END{printf "week: $%.2f\n", s}'

1# 任务循环：每日心跳，两个上限都设置
20 7 * * 1-5   cd /path/to/repo/loop && BUDGET_USD=5 ./ralph.sh >> ../progress.log 2>&1
3
4# 系统循环：没有已通过一次就不再被监控的东西
530 7 * * *    cd /path/to/repo && python3 system/verify_goals.py goals/ >> progress.log 2>&1
6
7# 系统循环：失败变成规则，每周一次，仅限提案
80 9 * * 1     cd /path/to/repo && codex --profile deep exec \
9              "$(cat ~/.codex/prompts/compost.md)" >> proposals/$(date +\%F).md 2>&1

1# /effort - 在花费之前选择努力级别
2
3先不要回答任务。先对其进行路由。
4
5给它打分。每项一分：
6  - 包含为什么、调试、竞态、死锁、重构、安全问题或优化
7  - 涉及多个子系统
8  - 之前的尝试已经失败
9  - 更改是不可逆的，或者面向用户
10
11然后映射：
12
13| 分数 | 努力级别 | 席位 |
14|---|---|---|
15| 0-1 | 低 | codex -e low，或 profile fast（Luna）。永远不要将前沿席位放在上面。 |
16| 2 | 中 | Terra 在中等努力级别是合适的席位。 |
17| 3+ | 高 | 这是真正工作的默认设置，也是最佳点所在。 |
18
19只有当高努力级别已经尝试过但失败时：才推荐最高级别，并明确说明额外的思考预期能带来什么。你正在反驳的基础概率大约是成本翻倍，而收益通常无法弥补。
20
21
22在推荐升级之前有两个提醒：
23  1. 低努力级别的更好模型通常优于高努力级别的较弱模型。先更换席位，再调整调节器。
24  2. 如果此任务会生成子 Agent，请明确说明它们的努力级别（除非有证据，否则默认为低）。子 Agent 继承父级设置，一个满负荷的集群在一次消息中就能清空上下文窗口。
25
26精确输出：
27  EFFORT: low | medium | high | max
28  SEAT: <model>
29  WHY: <one line, naming the points that scored>
30  SUBAGENTS: <effort to pin, or none>
31然后停止。人类按照你指定的级别运行任务。

1EFFORT: high
2SEAT: gpt-5.6-sol
3WHY: contains "why", touches auth and sessions, prior attempt failed
4SUBAGENTS: low

1# /plan-stop - 计划工作，然后停止
2
3这些模型运行时间长。当计划正确时，这是一个特性；当计划错误时，这是一种昂贵的犯错方式。此命令在花费之前购买检查点。
4
5计划任务。不要编辑任何文件。不要运行构建。不要开始。
6
7生成：
8  GOAL: <one line>
9  ASSUMPTIONS: <what you take for granted; if these are wrong, so is the plan>
10  STEPS: <numbered, each one commit's worth of work>
11  DONE_WHEN: <the exact shell command that proves each step landed>
12  BLAST RADIUS: <files and systems touched; name auth, payments, migrations, prod
13    config explicitly>
14  COST: <rough tokens or dollars, and which seat runs each step>
15  UNKNOWNS: <what you would ask a human if you could ask exactly one question>
16
17然后停止并等待。
18
19计划时的规则：
20  - 歧义放在 UNKNOWNS 中。不要通过猜测并继续来解决它。一个在计划中猜测并延续到执行中的问题，其成本是一个问题的一百倍。
21  - 如果计划需要的凭据、端点或约定没有记录在此仓库中，请停止并说明。永远不要凭空发明一个。
22  - 如果任何 DONE_WHEN 不是一个 shell 命令，请重写该步骤直到它是一个 shell 命令为止。如果 shell 无法检查它，那么审查者也同样无法检查。
23  - 如果影响范围触及 AGENTS.md 中的“永不”列表，请将其放在顶部，并建议排队等待人类处理。
24
25你在这里为计划付费，而不是为差异付费。一个简短、诚实、包含真实未知数的计划，胜过一份自信满满但悄悄假设了错误内容的计划。

1# /compost - 将本周的失败转化为下周的规则
2
3阅读本周的所有输出，仅此而已：
4  - progress.log 中的 BLOCKED 行（击败了三次顾问咨询的任务）
5  - GATE: REFUSED 条目（无法证明完成运行的记录）
6  - VIOLATED standing goals（某事完成后不再成立）
7  - 断路器和预算退出（代码 2 和 3）
8  - 由循环打开但未合并关闭的 PR（人类默默表示反对）
9  - 任何通过率低于 90% 的任务类
10
11最多提取三个提案。三个是硬性上限，而非目标。干净的一周是有效的发现，说出来比制造工作更有用。
12
13每个提案必须是以下之一：
14  1. 针对 CLAUDE.md 或 AGENTS.md 的新规则。引用本可以防止的事件。只有一个事件支持的规则是巧合；等待第二个事件。
15  2. 技能修复，当同样的失败在同个地方重复出现时。命名技能、模式以及能打破它的最小改动。
16  3. 你缺失的持续性目标，当有东西在无声中腐烂时。将谓词写成一个 shell 命令，否则不要提出它。
17
18输出：
19  WEEK: <dates>
20  EXHAUST: <counts: blocked, refused, violated, reverted>
21  PROPOSAL n: <law | skill fix | standing goal>
22    EVIDENCE: <the incidents, quoted>
23    CHANGE: <the exact text or predicate to add>
24    COST OF NOT DOING IT: <one line>
25  VERDICT: <what you would do first if you could only do one>
26
27硬性规则：
28  - 仅提议。不要编辑 CLAUDE.md、AGENTS.md、任何技能或任何目标文件。人类签字，否则不执行。
29  - 不要提议放宽门禁、提高预算或放松“永不”列表的规则。那些是系统在请求被允许更舒适地失败。
30  - 空输出：说“干净的一周”并停止。不要去寻找工作来证明运行的价值。

1# the daily tick, capped in both dimensions
2BUDGET_USD=5 MAX_ITERS=20 ./loop/ralph.sh
3
4# plan first, spend later (the single highest-leverage habit here)
5codex -e high exec "$(cat ~/.codex/prompts/plan-stop.md)
6
7TASK: migrate the session store off the legacy adapter"
8
9# cross-vendor review of the last commit, in Sol's native harness
10codex --profile deep exec "$(cat ~/.codex/prompts/review-hostile.md)"
11
12# the mirrored lane: Codex stuck, Claude advises
13claude --model claude-fable-5 --effort high -p "$(cat ~/.codex/prompts/fable-advice.md)"
14
15# the goal loop: Fable plans, the fleet runs, Fable scores
16CYCLES=3 FLEET=4 WORKER_EFFORT=low ./swarm/swarm.sh "split the auth migration"
17
18# the system loop: nothing that passed once goes unwatched
19python3 system/verify_goals.py goals/          # exit 1 names what rotted
20python3 gate/eval_gate.py eval/cases.jsonl     # exit 1 blocks the routing change
21
22# rung 3, the factory: rows decide, not transcripts
23./factory/factory.sh "build the kanban and notes app per PRD.md"
24python3 factory/factory_gate.py gate factory.db
25
26# the weekly institution-building run
27codex --profile deep exec "$(cat ~/.codex/prompts/compost.md)"
28
29# the one number that says whether any of this worked
30grep '^route' progress.log | awk -F'\t' \
31  '{n++; if($3!="frontier") c++} END{printf "cheap share: %.0f%%\n", c/n*100}'