2026-10-09 校注：本文是两份研究/实施建议草案的合并，不是已安装或验收的功能清单。上游现为 v2.2.0；增加目标分类、成功判据确认和跨子命令编排。核心协议支持 Claude Code、OpenCode、Codex，hook 护栏仅适用 Claude Code，属于纵深防护，不能等同沙箱。Hermes 当前 /goal 已有质量门与 completion contract，旧文中“缺机械指标”的说法已过时；所提 hermes-ar、3–5 轮及代码都是本地设计建议。依据：上游 README、Hermes Goals，并核对本机 hermes_cli/cli_loops_mixin.py 的 goals.max_turns 读取逻辑（默认 20）。

可以。下面这份我按**“给 Hermes / Manas 学习的研究报告”**来写，你可以直接复制给 Hermes，让它作为设计参考读入。

Hermes 应该从 uditgoenka/autoresearch 学什么

0. 总结一句话

autoresearch 最值得 Hermes 学的不是“自动改代码”，而是这套范式：

目标明确化 → 范围受限 → 指标机械化 → 修改原子化 → 验证自动化 → Git/TSV 外部记忆化 → 失败自动回滚 → 周期性复盘 → 可链式交接

它把 Agent 从“聊天式助手”推进到“可审计的实验执行器”。Hermes 如果要做长期自我维护、代码调试、网络修复、记忆系统优化、项目研究，应该吸收这套范式。

1. 这个项目的真实定位

uditgoenka/autoresearch 不是普通 Python/JS 库，而是一套面向 Claude Code / OpenCode / Codex 的 Markdown Skill + Command 协议系统。官方说明它把 Karpathy 原始 autoresearch 的思想泛化到任意有可测指标的领域，比如代码、内容、营销、销售、DevOps、安全等。它的核心原则来自：单一指标、受限范围、快速验证、自动回滚、Git 作为记忆。(GitHub)

其 v2.1.0 的架构调整是：把早期巨大的单体 SKILL.md 拆成一个很薄的路由文件和多个自包含命令文件。README 说 v2.1.0 把 813 行、约 100K token 的单体 skill，改成 41 行路由文件 + 12 个自包含命令文件，每次调用约 5–8K token，作者宣称同等能力下 token 消耗下降约 95%，本次未复测，不能从文件行数推出 token 数。(GitHub)

这对 Hermes 特别关键：不要把所有能力都塞进一个超级 prompt / 超级 skill，而是做“薄路由 + 专项协议文件”。

2. Hermes 最该学的 8 条核心原则

1）受限范围比“全能”更重要

原始 Karpathy autoresearch 只让 Agent 修改 train.py，prepare.py 固定，program.md 由人维护；这样可控、可复现、diff 可审查。(GitHub)

Hermes 应该学成：

任何自动修复/优化任务启动前，必须定义：
- ScopeRead：允许读取哪些文件
- ScopeWrite：允许修改哪些文件
- ScopeDeny：禁止读取/修改哪些文件
- Verify：如何验证改动有效
- Guard：如何保证别的东西没坏

尤其你现在有 WSL Hermes、Windows Mano、网络维护、NapCat、Discord、scope-recall/gbrain 这些混合系统，最怕的不是能力不够，而是 Agent 一次性读太多、改太多、权限太散。

2）机械指标优先，不要靠“感觉变好了”

autoresearch 明确要求机械验证：Verify 命令必须输出数字，Guard 命令用于防止回归；README 给的例子是 Verify 检查 p95 延迟，Guard 跑 npm test。(GitHub)

Hermes 应该把“任务成功”从自然语言评价改成指标：

核心思想：没有 Verify，就不应该进入自动循环。

3）一次只改一个点

autoresearch 的循环规定每次只做一个 focused change，先 commit，再跑验证；如果失败就 revert。(GitHub)

Hermes 应该采用：

One Iteration = One Atomic Change

禁止这种任务：

“顺便把网络、记忆、UI、bot 都优化一下”

应该拆成：

Iteration 1：只改代理检测
Iteration 2：只改 Discord 重连
Iteration 3：只改日志格式
Iteration 4：只改健康检查 timeout

这非常适合你的 Manas / daemon 架构：Manas 负责拆任务，daemon 负责执行单个原子任务。

4）Git 和结果日志是外部记忆，不要全靠上下文

autoresearch 每轮会读取 git history 和 results log，成功/失败都记录到 TSV；evals 后续分析趋势、平台期、回归、成功率。(GitHub)

Hermes 应该学成三层外部记忆：

1. Git commit：代码事实记忆
2. results.tsv：实验结果记忆
3. handoff.json：任务交接记忆

建议 Hermes 建这个目录：

.hermes-runs/
  loop-260531-1530/
    config.json
    results.tsv
    handoff.json
    evals-summary.md
    patches/
    logs/

其中 results.tsv 可以固定为：

iteration    timestamp    commit    metric    delta    guard    status    description
0            ...          abc123    85.2      0.0      pass     baseline  initial state
1            ...          def456    87.1      +1.9     pass     keep      add reconnect backoff
2            ...          -         86.5      -0.6     pass     discard   changed proxy incorrectly

这样 Hermes 即使上下文压缩、重启、换模型，也能恢复任务状态。

5）失败不是垃圾，失败是实验数据

autoresearch 不只是保留成功，它还记录 discard、crash、metric-error、guard-failed 等状态；debug 命令甚至会记录被证伪的假设，因为“证伪也有价值”。(GitHub)

Hermes 应该把失败分成：

keep        指标提升且 guard 通过
discard     指标变差，已回滚
crash       命令运行失败，已回滚
guard_fail  指标提升但破坏其他东西
noop        没有实际修改
blocked     被安全规则阻止
uncertain   指标不可靠，需要人工判断

这对你很重要，因为你经常遇到 WSL/代理/机器人/权限这种“不稳定环境”。失败日志会让 Manas 判断：是继续试，换策略，还是停下来问你。

6）Hooks 提供执行护栏

autoresearch v2.1.1 有 9 个 hook，分为安全门、上下文注入、质量/通知。在 Claude Code hook 已正确安装且覆盖对应工具的条件下，它会拦截读 .env、SSH key、.git、node_modules 等，也会阻止 rm -rf、git reset --hard、强推等危险命令；同时还会把最近 TSV 迭代状态注入上下文，避免长任务后 Agent 忘记当前进度。(GitHub)

Hermes 应该实现自己的 hook 层：

PreReadGuard:
- 禁止默认读取 .env, .ssh, credentials, token 文件
- 允许 .env.example, .env.sample
- 需要用户批准才能读取敏感文件
 
PreExecGuard:
- 阻止 rm -rf /, rm -rf ~, git reset --hard, git clean -fd
- 阻止 curl | sh
- 阻止向外发送 token/key
 
PreEditGuard:
- 限制一次改动 LOC
- 限制 ScopeWrite 外文件
- 禁止修改 Guard 文件
 
ContextInject:
- 每 N 轮注入最近 results.tsv
- 注入当前 plan / scope / metric / guard

这比单纯“相信 Agent 会听话”可靠得多。

7）命令体系要分层，不要一个万能命令

autoresearch 有 core loop、plan、debug、fix、security、ship、scenario、predict、learn、reason、probe、improve、evals 等命令；README 也说明它们可以链式组合，比如 predict → scenario → debug → fix → ship，或者 probe → plan → autoresearch。(GitHub)

Hermes 可以吸收成自己的命令族：

你这里的分工可以更清楚：

Manas：probe / reason / evals / plan
daemon：loop / fix / ship / guard / rollback
Hermes tools：read / edit / bash / git / browser
Aspect：可视化 results.tsv、任务图、因果链、项目演化

8）链式 handoff 是多 Agent 协作的关键

autoresearch 每个命令结束后写 handoff.json，里面包含版本、来源、状态、结果 TSV、发现、配置，然后把结果传给下一个命令。(GitHub)

Hermes 应该统一 handoff 格式：

{
  "version": "hermes-ar-0.1",
  "source": "debug",
  "timestamp": "2026-05-31T15:30:00+08:00",
  "status": "COMPLETE",
  "project": "hermes-inner-gateway",
  "results_tsv": ".hermes-runs/debug-260531-1530/results.tsv",
  "findings": [
    {
      "id": "bug-001",
      "severity": "high",
      "summary": "Discord gateway exits on transient proxy timeout",
      "evidence": "gateway.py:2196",
      "recommendation": "add bounded retry with exponential backoff"
    }
  ],
  "config": {
    "scope_read": ["gateway.py", "logs/*.log"],
    "scope_write": ["gateway.py"],
    "metric": "gateway uptime minutes",
    "verify": "python scripts/healthcheck.py",
    "guard": "pytest"
  },
  "next_suggested": ["fix", "evals"]
}

这对你未来“WSL Hermes 主脑 + Windows Mano 维护 + XiaRen / OpenClaw / NapCat 多端协作”很重要。没有 handoff，多 Agent 很快就会混乱。

3. 不要照搬的部分

不要照搬 Claude Code 的 slash command 机制

autoresearch 官方支持 Claude Code、OpenCode、Codex，不同平台用不同调用方式：Claude 是 /autoresearch:plan，OpenCode 是 /autoresearch_debug，Codex 是 $autoresearch plan。(GitHub)

Hermes 不应该照抄这些入口语法，而应该抽象出自己的协议：

Hermes Command Protocol:
- name
- purpose
- required_inputs
- default_iterations
- scope_policy
- verify_policy
- guard_policy
- output_schema
- handoff_schema

入口语法只是壳，核心是协议。

不要一开始就做“完全自动无限循环”

autoresearch 已经把 bounded default 当成关键规则：默认有限迭代，Iterations: unlimited 需要显式开启。(GitHub)

Hermes 更应该保守：

默认最多 3–5 轮
高风险任务最多 1 轮
需要用户确认才能超过 10 轮
涉及 token、账号、部署、删除、发布，一律禁止自动执行

你现在的系统还在搭积木阶段，自动循环太猛会把环境搞乱。

不要把主记忆系统和实验日志混在一起

autoresearch 的 TSV 是“实验运行记忆”，不是人格记忆、用户记忆、长期知识库。Hermes 应该区分：

短期上下文：当前对话
运行记忆：results.tsv / handoff.json
代码事实：git log / diff
长期知识：gbrain / scope-recall / Obsidian
可视化洞察：Aspect

不要把每轮失败都塞进长期记忆，否则记忆库会污染。

4. Hermes 版 Autoresearch 架构草案

建议你让 Hermes 学成这个结构：

hermes-ar/
  README.md
  commands/
    plan.md
    loop.md
    debug.md
    fix.md
    learn_repo.md
    probe.md
    reason.md
    evals.md
    ship.md
    security.md
  references/
    safety-policy.md
    metric-patterns.md
    handoff-schema.md
    tsv-schema.md
    persona-protocol.md
  hooks/
    pre_read_guard.py
    pre_exec_guard.py
    pre_edit_guard.py
    context_injector.py
  runtime/
    run_manager.py
    git_manager.py
    metric_extractor.py
    rollback_manager.py
    handoff_manager.py
  .hermes-runs/

其中最核心的是 4 个 runtime：

run_manager.py        管理 iteration、目录、状态
git_manager.py        commit / diff / revert
metric_extractor.py   从 verify 输出中提取数字
handoff_manager.py    写 handoff.json，交给下一个命令

5. 第一阶段最适合你做的最小版本

你不需要一口气迁移全部命令。建议 P0 只做 4 个。

P0：先做这 4 个

1. hermes.plan
把目标变成 Scope / Metric / Verify / Guard
 
2. hermes.learn_repo
研究 GitHub 项目，生成结构文档
 
3. hermes.debug
基于假设的 bug 搜索，不急着改
 
4. hermes.evals
读取 results.tsv，判断继续、停止、换策略

暂时不要先做：

- 自动 ship
- 自动 security fix
- 无限 loop
- 自动部署
- 跨项目批量修改

因为这些风险高，而且你现在更需要 Hermes 学会“研究、总结、判断”，不是上来就“动手改”。

6. Hermes 学习任务：可以直接复制给 Hermes

下面这段可以直接发给 Hermes：

你现在要学习 uditgoenka/autoresearch 的架构思想，但不要照搬 Claude Code 的实现细节。
 
学习目标：
把 autoresearch 的“可审计自动迭代范式”迁移成 Hermes / Manas 可用的内部协议。
 
你需要吸收的核心原则：
 
1. Thin Router + Command Files
不要做一个巨大的 skill/prompt。设计薄路由，把 plan/debug/fix/learn/evals/probe/reason 拆成独立协议文件。
 
2. Bounded by Default
所有循环默认有限迭代。默认 3–5 轮，高风险任务 1 轮。unlimited 必须显式用户批准。
 
3. Scope First
任何任务启动前必须定义：
- ScopeRead：允许读取
- ScopeWrite：允许修改
- ScopeDeny：禁止触碰
- GuardFiles：验证/测试文件默认只读
 
4. Mechanical Metric
任何自动优化必须有可机械验证指标：
- Metric：指标名
- Direction：higher_is_better / lower_is_better
- Verify：输出数字的命令
- Guard：防止其他东西坏掉的命令
 
5. One Change Per Iteration
每轮只做一个原子修改。禁止一轮内混合多个目标。
 
6. Git as Memory
每轮修改前读 git log / diff。每轮修改后 commit。失败用 revert，不用 reset --hard。失败也要记录。
 
7. TSV as Run Memory
每次运行写 results.tsv：
iteration, timestamp, commit, metric, delta, guard, status, description
 
8. Handoff as Agent Coordination
每个命令结束后写 handoff.json：
version, source, timestamp, status, results_tsv, findings, config, next_suggested
 
9. Hook Safety
实现 PreReadGuard / PreExecGuard / PreEditGuard / ContextInject：
- 阻止读取 .env, .ssh, credentials, token
- 阻止 rm -rf, git reset --hard, git clean -fd, force push, curl|sh
- 限制 ScopeWrite 外修改
- 每 N 轮注入最近 results.tsv 状态
 
10. Manas / daemon 分工
Manas 负责：
- probe：审问需求
- reason：架构辩论
- plan：定义目标和指标
- evals：评估是否继续
 
daemon 负责：
- loop：执行迭代
- fix：单错误修复
- rollback：失败回滚
- guard：安全检查
 
Hermes tool layer 负责：
- read/edit/bash/git/browser 等实际工具调用
 
请输出：
1. Hermes 版 autoresearch 协议目录结构
2. P0/P1/P2 实施路线
3. results.tsv schema
4. handoff.json schema
5. pre_exec_guard 规则清单
6. 一个用于研究 GitHub 项目的 hermes.learn_repo 协议草案
7. 一个用于修复 Hermes gateway 的 hermes.debug → hermes.fix → hermes.evals 链式示例
 
限制：
- 不要安装 autoresearch
- 不要改现有 Hermes 源码
- 先输出设计文档
- 所有自动循环默认最多 3 轮

7. 给 Hermes 的 learn_repo 协议草案

这个最适合你现在用来研究 GitHub 项目。

Command: hermes.learn_repo
 
Purpose:
研究一个 GitHub 仓库，生成可复用知识文档，不默认修改源码。
 
Inputs:
- RepoPath 或 RepoURL
- Mode: summarize | architecture | migration | risk | compare
- ScopeRead: 默认整个仓库，但排除 node_modules/.git/dist/build
- ScopeWrite: 默认只允许 docs/hermes-study/
- Depth: quick | standard | deep
- Iterations: 默认 3
 
Safety:
- 禁止读取 .env / credentials / ssh key
- 禁止运行 install 脚本，除非用户明确批准
- 禁止修改仓库源码
- 禁止 push / deploy
 
Workflow:
1. Scout
   - 读取 README、docs、package/pyproject、入口文件
   - 生成目录地图
 
2. Classify
   - 判断项目类型：library / app / skill / plugin / agent / infra
   - 判断运行方式、配置方式、扩展点
 
3. Extract
   - 提取核心概念
   - 提取命令体系
   - 提取安全机制
   - 提取可迁移设计
 
4. Map to Hermes
   - 哪些能直接学
   - 哪些不能照搬
   - 哪些适合 Manas
   - 哪些适合 daemon
   - 哪些适合 tool/hook 层
 
5. Validate
   - 检查报告是否覆盖：
     项目定位、架构、核心循环、命令表、安全机制、迁移建议、风险
 
6. Log
   - 写 results.tsv
   - 写 summary.md
   - 写 handoff.json
 
Outputs:
- docs/hermes-study/summary.md
- docs/hermes-study/architecture.md
- docs/hermes-study/migration-plan.md
- .hermes-runs/learn_repo-*/results.tsv
- .hermes-runs/learn_repo-*/handoff.json

8. 最终建议

你现在真正该让 Hermes 学的是：

autoresearch 不是一个工具，而是一种 Agent 工作纪律。

对你的体系来说，它可以变成：

Manas = 目标、约束、判断、复盘
daemon = 执行、验证、回滚、记录
Hermes = 工具调用与环境操作
Aspect = 可视化运行历史、因果链、项目演化
gbrain/scope-recall = 长期知识沉淀
Git/TSV/handoff = 实验级外部记忆

最优先落地的不是“自动改代码循环”，而是：

P0：learn_repo + plan + evals
P1：debug + fix
P2：loop + security + ship

这样 Hermes 会先变聪明、变可审计，再逐渐变自动化。

可以。我的结论是：Hermes 不需要“移植 autoresearch”，而应该用官方现有功能拼出一个 Hermes-native 的 autoresearch-lite 自动化体系。

核心组合是：

Skills / Bundles 负责“命令协议”
/goal 负责“持续迭代循环”
Checkpoints + Git Worktree 负责“安全回滚与隔离”
execute_code 负责“机械化验证与日志处理”
Plugin hooks 负责“安全护栏、审计、指标采集、上下文注入”
Kanban + Profiles 负责“多 Agent 持久协作”
Cron 负责“定期触发”
Memory / Context Files 负责“长期规则与项目局部规则”
MCP 负责“接外部工具，比如 Codex、GitHub、文件系统”

官方文档里这些能力都已经存在：Hermes 的功能概览明确列出了工具集、Skills、持久记忆、上下文文件、上下文引用、检查点、Cron、子 Agent 委派、代码执行、事件 Hook、MCP、插件等能力；这些正好对应 autoresearch 的路由、命令、循环、验证、回滚、日志和外部工具层。(Hermes Agent)

1. 先给 Hermes 一个定位：不要复制项目，复制“工作纪律”

autoresearch 的核心不是某个命令，而是：

目标 → 范围 → 指标 → 验证 → 单点修改 → 记录 → 回滚 → 复盘 → 交接

在 Hermes 里可以拆成：

Hermes 的 Skills 系统本身就支持渐进式披露：先只列出技能摘要，需要时再加载完整 skill 或指定 reference 文件；每个 skill 存在 ~/.hermes/skills/，SKILL.md 可以包含用途、流程、陷阱和验证方法，这正适合仿照 autoresearch 的“薄路由 + 子命令文件”设计。(Hermes Agent)

2. 最推荐的落地架构：三层，不要一步到位写插件

第一层：Skill-only，不写代码

先做一个 hermes-autoresearch-lite skill，里面只放规则、模板和流程。Hermes 的 skill 可以直接作为斜杠命令使用，例如 /plan、/github-pr-workflow 这类形式；官方也支持 skill bundle，把多个 skills 组合成一个命令。(Hermes Agent)

建议目录：

~/.hermes/skills/automation/hermes-autoresearch-lite/
  SKILL.md
  references/
    ar-plan.md
    ar-debug.md
    ar-fix.md
    ar-evals.md
    ar-loop.md
    safety-policy.md
    results-schema.md
    handoff-schema.md
  templates/
    results.tsv.template
    handoff.json.template
    run-config.json.template

这个阶段只要求 Hermes 按规则做事，不强行扩展工具。

第二层：Goal + Checkpoint + Worktree，形成安全循环

Hermes 的 /goal 就是官方持续循环机制：设置一个跨轮次目标后，每轮结束会由轻量裁判判断是否完成；如果未完成，Hermes 会自动注入续行 prompt 继续工作，直到目标达成、暂停、清除或预算耗尽。默认最大续行轮次是 20，可配置。(Hermes Agent)

但是 /goal 本身只负责“继续”，不负责“安全”。所以要配：

/goal        = 自动继续
checkpoints  = 文件修改前快照
git commit   = 实验版本记录
worktree     = 隔离实验目录

Hermes 的 Checkpoints 默认可按需启用，会在 write_file、patch、以及 rm、mv、sed -i、git reset/clean/checkout 等破坏性命令前创建影子 git 快照，并可用 /rollback 恢复。(Hermes Agent)

Git Worktrees 则适合并行实验：每个 agent 拥有独立 branch 和工作目录，Hermes 在该目录内工作，checkpoint 历史也按 worktree 隔离。(Hermes Agent)

第三层：Plugin hooks，做真正的 autoresearch 内核

等 skill 版跑顺后，再写一个 Hermes 插件。官方插件系统可以不改核心代码就添加自定义工具、hook、斜杠命令、CLI 命令，放在 ~/.hermes/plugins/ 下，由 plugin.yaml 和 Python 代码组成；用户插件默认禁用，需要显式启用，这正好符合安全原则。(Hermes Agent)

插件应该实现这些东西：

工具：
- ar_init_run
- ar_log_result
- ar_write_handoff
- ar_read_recent_results
- ar_extract_metric
- ar_check_scope
 
Hooks：
- pre_tool_call：阻断危险命令、ScopeWrite 外修改
- post_tool_call：记录工具调用、耗时、错误率
- pre_llm_call：注入当前 run 状态、最近 results.tsv、当前 metric/guard
- transform_terminal_output：脱敏 token、裁剪日志

官方 plugin hooks 支持 pre_tool_call 阻断工具调用、pre_llm_call 注入上下文，post_tool_call 做指标采集，transform_terminal_output 和 transform_tool_result 可在结果交给模型前处理输出。(Hermes Agent)

3. Hermes 官方能力如何对应 autoresearch 自动化

A. Skills：复制“命令文件系统”

Hermes Skills 已经是 Markdown 协议系统。每个 skill 可以有 SKILL.md、references/、templates/、scripts/、assets/，这和 autoresearch 的“命令 + references + 模板”非常接近。(Hermes Agent)

建议拆成 5 个技能：

/ar-plan    把模糊目标变成 Scope / Metric / Verify / Guard
/ar-debug   假设驱动调试，不急着改
/ar-fix     单问题修复，每轮只改一个点
/ar-evals   读取 results.tsv，判断继续/停止/换策略
/ar-loop    在 /goal 下执行小步迭代

也可以建一个 bundle：

/ar-dev = ar-plan + ar-debug + ar-fix + ar-evals
/ar-research = ar-plan + repo-learn + ar-evals

官方 Skill Bundle 就是为这种“某类任务总是加载同一组 skills”设计的。(Hermes Agent)

B. /goal：复制“自动继续循环”

/goal 提供持续循环；当前官方版本还支持可执行质量门与完成契约，可验证机械指标。它仍不等于 autoresearch 的完整修改、指标记录与回滚流程，回滚须结合 checkpoints/worktree 等单独配置。它适合这类任务：

/goal 在当前 worktree 中修复 failing tests。每轮只允许修改一个文件；
每轮必须运行 pytest；
每轮必须把结果追加到 .hermes-runs/current/results.tsv；
如果测试数下降或 guard 失败，回滚本轮修改。

/goal 支持 /goal pause、/goal resume、/goal clear，并且用户真实消息始终优先于续行循环；这对你手动打断 Manas/Hermes 很重要。(Hermes Agent)

C. execute_code：复制“机械验证器”

execute_code 允许 Hermes 写 Python 脚本，通过 RPC 调用 web_search、web_extract、read_file、write_file、search_files、patch、terminal 等工具；只有脚本 print() 的最终输出进入模型上下文，中间工具结果不进上下文，适合批量扫描、跑测试、解析指标、生成 TSV。(Hermes Agent)

这正适合做：

verify.py:
- 运行 pytest / npm test / curl healthcheck
- 提取 metric 数字
- 判断 higher/lower is better
- 写 results.tsv
- 输出 JSON summary 给 Hermes

官方文档也强调 execute_code 有环境变量清理、工具白名单、超时、stdout 上限、工具调用上限等不变量，所以它比让 LLM 一步步手工解析大量日志更适合机械流水线。(Hermes Agent)

D. Hooks：复制“护栏和审计系统”

当前 Hermes 官方文档列出四类 hook：Gateway hooks、Plugin hooks、Shell hooks、Outbound webhooks（签名的生命周期 HTTP 事件）。Gateway hooks 适合日志、告警、webhook；Plugin hooks 适合工具拦截、指标和护栏；Shell hooks 适合阻断、自动格式化、上下文注入。(Hermes Agent)

autoresearch 最重要的安全能力，应该放到 Plugin hooks：

pre_tool_call:
- 禁止 rm -rf
- 禁止 git reset --hard
- 禁止 git clean -fd
- 禁止 curl | sh
- 禁止读取 .env / .ssh / token 文件
- 禁止 ScopeWrite 外 patch/write_file
- 禁止未定义 Verify 时进入 ar-loop
 
post_tool_call:
- 记录工具名、参数摘要、耗时、是否失败
- 追加到 .hermes-runs/current/tool_calls.jsonl
 
pre_llm_call:
- 注入当前 run_id
- 注入最近 5 条 results.tsv
- 注入当前 Scope / Metric / Verify / Guard

官方文档明确说 pre_tool_call 可以返回 block 来否决工具调用，pre_llm_call 可以在当前用户消息旁边注入上下文，而不是修改系统 prompt，这能保留 prompt 缓存。(Hermes Agent)

E. Kanban + Profiles：复制“多 Agent 持久流水线”

delegate_task 是短生命周期的同步委派：父 agent 会阻塞等待子 agent 完成，子 agent 只有 goal/context，没有父上下文历史，适合临时并行研究或审查。官方也说明子 agent 默认不能调用 memory、send_message、execute_code、clarify，并有并发、超时和深度限制。(Hermes Agent)

但真正接近“持久自动研究流水线”的是 Kanban。Hermes Kanban 是持久化任务看板，任务、评论、交接都保存在 SQLite，多个具名 profile worker 可以协作；它和 delegate_task 的区别是：delegate 是函数调用，Kanban 是可恢复的工作队列，支持人工介入、重试、审计追踪和跨 agent 接手。(Hermes Agent)

你可以这样设角色：

profile: manas-orchestrator
职责：拆任务、建 kanban、定义指标、评估结果
 
profile: researcher
职责：只读研究仓库、文档、issue、官方资料
 
profile: fixer
职责：在 worktree 中做单点修改
 
profile: reviewer
职责：读取 diff、results.tsv、测试结果，决定 keep/discard
 
profile: daemon-ops
职责：跑 healthcheck、cron、gateway 维护

Profiles 本身就是独立 Hermes 主目录，每个 profile 有自己的配置、API key、记忆、会话、skills、cron、gateway 状态，适合你给 Manas、daemon、researcher、reviewer 分不同身份。(Hermes Agent)

F. Cron：复制“周期性自动研究/维护”

Cron 可以创建一次性或周期性任务，附加一个或多个 skills，指定 workdir/profile，并把结果投递到 Discord、Telegram、Slack、企业微信、微信、QQ Bot 等平台。(Hermes Agent)

适合做：

每晚 3 点：
- 检查 Hermes gateway 日志
- 检查 cron 失败任务
- 检查 kanban blocked/running 超时任务
- 生成 .hermes-runs/daily-evals.md
- 发到 Discord #ops

官方文档还说明 Cron 设置 workdir 后会加载该目录的 AGENTS.md、CLAUDE.md、.cursorrules，并让 terminal/file/execute_code 以该目录为工作目录；这正适合项目级自动化。(Hermes Agent)

G. MCP：复制“外部工具生态连接层”

MCP 让 Hermes 接入外部工具服务器，比如 GitHub、数据库、文件系统、浏览器栈、内部 API；Hermes 支持 stdio 和 HTTP MCP，并在启动时把 MCP 工具注册进普通工具注册表。(Hermes Agent)

尤其重要的是，官方 MCP 文档已有 Codex 预设：

hermes mcp add codex --preset codex

这等价于让 Hermes 通过 stdio 运行 codex mcp-server，所以你的理想架构不是“让 Hermes 复制 Codex”，而是：

Manas/Hermes：定目标、管权限、评估结果
Codex MCP：负责具体代码智能执行
Hermes hooks：审计/拦截危险动作
Kanban：记录任务和交接

MCP 还支持按服务器过滤工具，能只暴露 GitHub issue、search_code 等最小工具集；这对安全很关键。(Hermes Agent)

4. 我建议的实施路线

P0：完全不用写插件，先用现成功能

先做：

1. 开启 checkpoints
2. 用 git worktree 做实验目录
3. 写 hermes-autoresearch-lite skill
4. 用 /goal 执行有限轮迭代
5. 用 execute_code 写 results.tsv
6. 每轮要求 Hermes 自己读 results.tsv 后再继续

配置建议：

checkpoints:
  enabled: true
  max_snapshots: 20
  max_total_size_mb: 500
 
goals:
  max_turns: 5
 
terminal:
  backend: local
  timeout: 180

这里我建议先把 /goal 最大轮次降到 5，而不是默认 20。你现在的系统还在搭建期，太长的自动循环容易把环境搞乱。

P1：加一个 hermes-ar 插件

插件做 4 件事就够：

1. ar_log_result：写 results.tsv
2. ar_write_handoff：写 handoff.json
3. pre_tool_call：阻断危险操作
4. pre_llm_call：注入最近 results 状态

先不要做复杂 UI、不要接数据库、不要碰长期记忆。

P2：Kanban 多 Agent 流水线

等 P0/P1 稳定后，再上：

manas-orchestrator → researcher → fixer → reviewer → daemon-ops

任务流：

1. manas 创建 kanban task
2. researcher 只读分析，写 findings
3. fixer 在 worktree 中改一处
4. reviewer 跑 verify/guard，判断 keep/discard
5. manas 读 handoff，决定下一轮

5. 可以直接发给 Hermes 的版本

下面这段你可以直接复制给 Hermes/Manas：

Hermes Autoresearch-Lite 学习与落地任务

你现在要学习 autoresearch 的自动化范式，但不要直接移植它，也不要修改 Hermes 核心源码。

目标：用 Hermes 官方已有功能拼出一个 Hermes-native 的 autoresearch-lite 系统。

一、核心原则

你要吸收的是工作纪律，不是照搬项目代码：

1. Goal First：任何自动循环前必须明确目标。

2. Scope First：必须定义 ScopeRead、ScopeWrite、ScopeDeny。

3. Metric First：没有机械指标，不进入自动优化循环。

4. Verify Required：每轮必须有验证命令。

5. Guard Required：每轮必须有防回归命令。

6. One Change Per Iteration：每轮只做一个原子修改。

7. Log Everything：每轮都写 results.tsv。

8. Handoff Everything：每个阶段结束写 handoff.json。

9. Rollback Safe：失败必须能回滚。

10. Bounded by Default：默认最多 3–5 轮，不允许无限循环。

二、Hermes 官方能力映射

使用 Hermes 官方已有能力：

• Skills / Bundles：实现命令协议，例如 ar-plan、ar-debug、ar-fix、ar-evals、ar-loop。

• /goal：实现持续迭代，但只作为续航器，不作为完整安全系统。

• Checkpoints：在文件修改和破坏性命令前自动快照，允许 /rollback。

• Git Worktrees：为实验任务创建独立 branch 和工作目录。

• execute_code：运行 verify/guard、解析指标、写 TSV、输出 JSON 摘要。

• Plugin hooks：后续用于 pre_tool_call、post_tool_call、pre_llm_call 安全与审计。

• Kanban：后续用于多 Agent 持久任务队列。

• Profiles：为 manas、researcher、fixer、reviewer、daemon-ops 设置独立身份。

• Cron：用于定时健康检查、日志复盘、kanban 状态总结。

• MCP：用于接 Codex、GitHub、filesystem 或其他外部工具。

三、第一阶段：不要写插件，只做 Skill-only

请设计一个 skill：

路径建议：

~/.hermes/skills/automation/hermes-autoresearch-lite/
SKILL.md
references/
ar-plan.md
ar-debug.md
ar-fix.md
ar-evals.md
ar-loop.md
safety-policy.md
results-schema.md
handoff-schema.md
templates/
results.tsv.template
handoff.json.template
run-config.json.template

要求：

SKILL.md 只做薄路由，不写太多细节。具体流程放到 references 里。

四、命令协议

设计这些子协议：

ar-plan

输入：

• Goal

• Project path

• Risk level

• Expected output

输出：

• ScopeRead

• ScopeWrite

• ScopeDeny

• Metric

• Direction

• Verify

• Guard

• MaxIterations

• Rollback plan

ar-debug

要求：

• 先列假设

• 每次只验证一个假设

• 不急着修改

• 记录被证伪的假设

ar-fix

要求：

• 每轮只改一个点

• 修改前检查 git diff

• 修改后运行 Verify 和 Guard

• 成功则记录 keep

• 失败则回滚并记录 discard/crash/guard_fail

ar-evals

读取 results.tsv，输出：

• 是否继续

• 是否停止

• 是否换策略

• 是否需要人工确认

• 哪一轮最有效

• 哪些失败可以沉淀为经验

ar-loop

要求：

• 默认最多 3 轮

• 高风险任务最多 1 轮

• 不能无限循环

• 每轮必须写 results.tsv

• 每轮必须写 handoff.json

• 每轮必须明确 keep/discard

五、results.tsv schema

字段：

iteration
timestamp
run_id
commit
metric_name
metric_value
delta
verify_command
verify_status
guard_command
guard_status
status
changed_files
summary

status 只允许：

baseline
keep
discard
crash
guard_fail
blocked
noop
uncertain

六、handoff.json schema

字段：

version
run_id
source
timestamp
status
project
goal
scope_read
scope_write
scope_deny
metric
verify
guard
results_tsv
changed_files
findings
next_suggested
requires_user_input

七、安全规则

默认禁止：

• rm -rf

• git reset —hard

• git clean -fd

• force push

• curl | sh

• 读取 .env

• 读取 ~/.ssh

• 读取 token、credential、secret 文件

• 修改 ScopeWrite 之外文件

• 修改测试/guard 文件来伪造通过

• 在没有 Verify 的情况下进入 loop

• 在没有 Guard 的情况下自动修改生产代码

八、推荐运行方式

首次只读研究：

1. 不修改源码

2. 只生成 docs/hermes-study/

3. 只写 .hermes-runs/

4. 不运行 install 脚本

5. 不写全局配置

6. 不触碰 .env / token / ssh key

代码实验：

1. 先创建 git worktree

2. 开启 checkpoints

3. 用 /goal 执行有限循环

4. 每轮运行 verify/guard

5. 每轮写 results.tsv

6. 每轮写 handoff.json

7. 失败立即回滚

九、Manas / daemon 分工

Manas 负责：

• ar-plan

• ar-evals

• probe

• reason

• 是否继续/停止/换策略

daemon 负责：

• ar-loop

• ar-fix

• verify

• guard

• rollback

• 写 results.tsv

researcher 负责：

• 只读仓库研究

• 文档总结

• issue / README / docs 分析

reviewer 负责：

• 检查 diff

• 检查测试

• 判断 keep/discard

十、请输出

请先不要实现插件。先输出设计文档：

1. Hermes-autoresearch-lite 的 skill 目录结构

2. SKILL.md 草案

3. references/ar-plan.md 草案

4. references/ar-debug.md 草案

5. references/ar-fix.md 草案

6. references/ar-evals.md 草案

7. references/ar-loop.md 草案

8. results.tsv 模板

9. handoff.json 模板

10. 第一阶段测试方案

限制：

• 不要改 Hermes 核心源码

• 不要安装第三方 autoresearch

• 不要启用无限循环

• 不要自动修改真实项目

• 先只在 sandbox 或 worktree 中实验

6. 最后判断

你现在最应该让 Hermes 学的是这个：

Hermes 已经有足够的官方积木。
缺的不是功能，而是把功能组织成“可审计自动研究协议”。

最稳路线：

第一步：Skills/Bundles 复制命令协议
第二步：/goal + checkpoints + worktree 复制有限自动循环
第三步：execute_code 复制机械验证与 TSV 日志
第四步：plugin hooks 复制安全门和上下文注入
第五步：Kanban + Profiles 复制持久多 Agent 协作
第六步：MCP 接 Codex/GitHub，让 Hermes 做总控，不亲自做所有脏活

这比直接把 autoresearch 塞进 Hermes 更符合 Hermes 官方架构。