[Project] 3. Harness-Everything — AI 自主代码改进 Harness

1
2
3
4

while True:
    代码 = 读取项目所有文件()
    回复 = LLM("这是代码,帮我改进:" + 代码)
    写回文件(回复)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

LLM: "我想看 harness/core/llm.py"
      ↓
你的代码: open("harness/core/llm.py").read() → 返回文件内容
      ↓
LLM: "我想搜索哪些文件引用了 _check_path"
      ↓  
你的代码: grep -r "_check_path" → 返回搜索结果
      ↓
LLM: "我要改这个文件的第 285 行"
      ↓
你的代码: 执行修改

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

for turn in range(max_turns):
    # 1. 问 LLM:"你想做什么?"
    response = await api.messages.create(messages=对话, tools=工具列表)
    
    # 2. 如果 LLM 没有要调工具 → 它说完了,退出
    if not response.tool_calls:
        return response.text
    
    # 3. LLM 要调工具 → 你的代码执行 → 把结果喂回去
    for call in response.tool_calls:
        result = await registry.execute(call.name, config, call.input)
    
    # 4. 结果追加到对话历史,继续循环
    对话.append(tool_results)

1

LLM 改了代码 → py_compile 报错 → 错误信息喂回 LLM → LLM 再改 → 通过

1
2
3
4
5

LLM 改了代码
  ├── Basic evaluator:    "这个改动有安全问题" → 5 分
  └── Diffusion evaluator: "但不会影响其他模块" → 7 分
  
合计 12 分。跟其他方案比,选最高分的。

1
2
3
4
5
6
7
8
9

Outer Round 1:
  Phase 1: 分析代码,找问题（debate 模式,只看不改）
  Phase 2: 改进核心框架（implement 模式,用工具改文件）
  Phase 3: 安全加固 + 删死代码
  Phase 4: 整合工具 + 加测试
  Phase 5: 改善可追踪性

Outer Round 2:
  ...重复,但基于 Round 1 的改进继续

1
2
3
4
5

服务器跑 10 轮 → git commit + push → 打 tag → push tag
                                                 ↓
GitHub Actions 看到 tag → SSH 到服务器 → 部署新代码 → 重启进程
                                                         ↓
                                              新代码生效,再跑 10 轮...

1
2
3
4

瓶颈 1（评判趋平）      → MultiAxisEvaluator（5 维向量评估）
瓶颈 2（无跨周期学习）  → ExperienceStore（结构化经验记忆）
瓶颈 3（纯 exploitation）→ Exploration Mode（探索机制）
瓶颈 4（无法自修改）    → EvalConfig 热重载 + MetaAgent（策略层）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

旧（V4 memory.jsonl）:
  {"cycle": 5, "score": 7.2, "proposal": "改了一堆东西..."}
  → 流水账，没有提炼，没有检索，没有复用

新（V5 ExperienceStore）:
  Experience(
    cycle=5,
    eval_vector=[8,7,6,5,9],          # 多轴向量
    action_summary="合并两个 AST 工具减少重复",
    reflection="共享的 boilerplate 提取为 _ast_utils 是正确的……",  # LLM 的自我反思
    abstraction="当多个工具共享超过 30% 代码时，提取公共模块到 core/",  # 提炼出可复用的模式
    tags=["tool_merge", "dedup", "ast"],
    was_reverted=false,
  )

1
2
3
4
5
6
7
8
9

正常轮（exploitation，默认）:
  权重: correctness 0.35, code_quality 0.25, arch 0.15, novelty 0.10, alignment 0.15
  → 小步优化，稳妥为主

探索轮（exploration，每 N 轮插入一次）:
  权重: correctness 0.15, code_quality 0.10, arch 0.10, novelty 0.50, alignment 0.15
  → 新颖度权重从 10% 提到 50%，鼓励大胆尝试
  → 放松 gate（允许编译失败），范围限定在单一模块，防止炸毁全局
  → 每 3 轮（可在 pipeline JSON 里配置 exploration_interval）插入一次

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────┐
│ MetaAgent（每 5-10 轮运行一次，不写代码，只出策略）    │
│                                                     │
│ 输入:                                                │
│   • ExperienceStore 里最近 20 条经验的格式化上下文      │
│   • 各维度分数趋势（正确性在涨但新颖度在下滑？）        │
│   • 当前评估权重                                      │
│                                                     │
│ 输出 (结构化的策略调整):                               │
│   • focus_axis: "novelty"（接下来重点优化哪个维度）     │
│   • adjust_weights: {"novelty": 0.3, ...}（调整权重）  │
│   • exploration_frequency: 2（调整探索频率）            │
│   • reasoning: "代码越来越规范但缺乏新方向，增加..."     │
│                                                     │
│ MetaAgent 的决策 → 写入 eval_weights.json → 下次评估   │
│ 热加载新权重 → 不重启就生效                             │
└─────────────────────────────────────────────────────┘

1
2
3
4

bash("cat harness/core/llm.py")           → 读文件
bash("grep -rn '_check_path' harness/")   → 搜索
bash("sed -i 's/old/new/' file.py")       → 改文件
bash("python3 -m py_compile file.py")     → 检查语法

1
2
3
4
5
6
7

文件操作:    read_file, write_file, edit_file, delete_file, move_file, copy_file
目录操作:    list_directory, create_directory, tree
搜索:       glob_search, grep_search
Git:        git_status, git_diff, git_log
执行:       bash, python_eval, test_runner
分析:       code_analysis, symbol_extractor, cross_reference, ...
可选:       web_search (需要显式开启)

1
2
3
4

resolved = os.path.realpath(path)  # 解析符号链接
# 检查 null bytes、Unicode 伪装字符、路径越界
if path 不在 allowed_paths 内:
    拒绝执行

1
2
3
4
5
6

Turn  1: 发送 [系统提示 + 文件上下文 + 用户指令]       ≈ 20K tokens
Turn  5: 发送 [上面 + 4 轮工具调用和结果]               ≈ 30K tokens
Turn 10: 发送 [上面 + 9 轮]                             ≈ 40K tokens
Turn 20: 发送 [上面 + 19 轮]                            ≈ 60K tokens  ← 最贵

一个 20-turn 循环总共: ≈ 0.5M input tokens

1
2
3
4
5
6
7
8

Cache miss: $0.28 / 百万 input tokens
Cache hit:  $0.028 / 百万 input tokens (缓存命中率约 90%)
Output:     $0.42 / 百万 output tokens

一个 chunk (6-10 轮 × 4-5 阶段):
  Input:  ~30M tokens → ~$3
  Output: ~1M tokens  → ~$0.4
  合计:   ~$3.5 / chunk

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

PipelineLoop.run()
│
├── for outer in range(10):                    ← 外层: 10 轮
│   │
│   ├── _run_outer_round()
│   │   │
│   │   └── for phase in [分析, 改进, 安全, 整合, 追踪]:  ← 5 个阶段
│   │       │
│   │       └── PhaseRunner.run_phase()
│   │           │
│   │           ├── 注入代码上下文 (最相关的 30K 字符)
│   │           │
│   │           ├── for inner in range(2):       ← 2 次尝试
│   │           │   │
│   │           │   ├── debate 模式: 并行,只分析不改
│   │           │   └── implement 模式: 顺序,用工具改文件
│   │           │       └── call_with_tools()    ← 工具循环 (最多 20 轮)
│   │           │
│   │           ├── DualEvaluator.evaluate()      ← 双重评估,选最好的
│   │           ├── Synthesis                     ← 合成最佳方案
│   │           └── Hooks: 语法检查 + git commit  ← 验证 + 提交
│   │
│   ├── auto_push (git pull --rebase + push)     ← 每轮推到 GitHub
│   ├── patience 检查 (连续 5 轮没进步 → 早停)
│   └── 优雅关闭检查 (收到 SIGTERM → 干完当前阶段退出)
│
├── auto_tag_at_end → 打 tag + push tag          ← 触发 CI 部署
└── 写 summary.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

prior_best (上一轮最佳方案)
    ↓
Phase 1 (分析) → synthesis → 传给 Phase 2
    ↓
Phase 2 (改进) → 改文件 → commit → synthesis → 传给 Phase 3
    ↓
Phase 3 (安全) → 改文件 → commit → synthesis → 传给 Phase 4
    ↓
...每个 phase 的合成结论传给下一个 phase 作为 prior_best
    ↓
Round 结束 → 最终 prior_best 传给下一个 Round

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 进程启动时
import harness.core.llm  # 加载到内存,之后不再变

# Round 5: LLM 改了磁盘上的 llm.py
edit_file("harness/core/llm.py", ...)  # 磁盘变了

# Round 6: 进程还是用内存里的旧版本
# Python 不会自动重新 import

# 只有重启进程,新代码才生效

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

PipelineConfig                     # 顶层配置
├── harness: HarnessConfig         #   模型/API/workspace/工具
│   ├── model: "deepseek-chat"
│   ├── base_url: "https://api.deepseek.com/anthropic"
│   ├── workspace: "/home/ubuntu/harness-everything"
│   ├── allowed_paths: [workspace]
│   └── max_tool_turns: 20
├── phases: [PhaseConfig]          #   阶段列表
│   ├── name, mode (debate/implement)
│   ├── system_prompt (含 $file_context 等模板变量)
│   └── glob_patterns (注入哪些文件)
├── outer_rounds: 10               #   每个 chunk 跑几轮
├── patience: 5                    #   几轮没进步就早停
├── auto_push_interval: 1          #   每轮 push
├── auto_tag_at_end: true          #   退出必打 tag
├── evaluation_engine: "multi_axis"# V5 评估引擎（"dual" 或 "multi_axis"）
├── exploration_interval: 3        # V5 探索轮频率（0=禁用）
├── meta_agent_interval: 5         # V5 策略层频率（0=禁用）
└── eval_weights: {correctness:0.35,...} # V5 多轴权重

EvalVector (V5)                    # 多轴评估向量
├── correctness: float             #   正确性（0-10）
├── code_quality: float            #   代码质量（0-10）
├── arch_health: float             #   架构健康（0-10）
├── novelty: float                 #   新颖度（0-10）
└── alignment: float               #   策略一致性（0-10）

Experience (V5)                    # 结构化经验条目
├── eval_vector: [float]           #   多轴评估向量
├── action_summary: str            #   做了什么
├── reflection: str                #   LLM 的自我反思
├── abstraction: str               #   提炼出的可复用模式
├── tags: [str]                    #   可检索标签
└── was_reverted: bool             #   是否被回滚

MetaStrategy (V5)                  # MetaAgent 输出
├── focus_axis: str                #   重点优化维度
├── adjust_weights: dict           #   权重调整
├── exploration_frequency: int     #   探索频率建议
└── reasoning: str                 #   策略推理过程

InnerResult                        # 单次尝试的结果
├── proposal: str                  #   LLM 的提案或改动
├── eval_vector: EvalVector (V5)   #   多轴评估（V4 为 dual_score）
│   ├── basic: (score, critique)   #     缺陷评估（V4 legacy）
│   └── diffusion: (score, critique)#    波及效应（V4 legacy）
└── tool_call_log: [dict]          #   工具调用记录

PhaseResult                        # 阶段结果
├── synthesis: str                 #   合成后的最终方案
├── best_score: float              #   最高分（加权平均）
└── inner_results: [InnerResult]   #   所有尝试