【深度实操】一台云机器搞定 Harness Engineering：Go 后端 AI Agent 全流程配置指南

摘要：理论看够了，本文直接给你一台云服务器上的完整落地方案。从 Ubuntu 环境初始化、Docker Agent 沙箱搭建、Codex CLI / Claude Code 配置，到 AGENTS.md 编写、分层 Linter、Eval Harness 批量评估、多 Agent 并行编排和垃圾回收 Agent——所有配置文件和脚本均可直接复制使用。适用于任何有一台 4C8G 云机器的 Go 后端开发者。

---

零、你需要准备什么 🛒

项目	最低配置	推荐配置
云机器	2C4G	4C8G（并行 Agent 需要）
系统	Ubuntu 22.04	Ubuntu 24.04 LTS
磁盘	40G SSD	80G SSD（Docker 镜像占空间）
API Key	Anthropic 或 OpenAI 至少一个	两个都有更灵活
网络	能访问 api.anthropic.com / api.openai.com	可用中转服务

---

一、Step1：环境一键初始化（10分钟）🚀

SSH 登录你的云机器，创建并执行以下脚本：

#!/bin/bash
# harness-init.sh — Harness Engineering 环境一键初始化
set -euo pipefail

# 1. 系统依赖
sudo apt update && sudo apt install -y \
  curl wget git jq tree unzip build-essential

# 2. Docker (Agent 隔离沙箱)
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

# 3. Go 1.22+
wget -q https://go.dev/dl/go1.22.5.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.22.5.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> ~/.bashrc

# 4. Node.js 20+ (Codex CLI / Claude Code 依赖)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

# 5. AI Agent 工具链
npm install -g @anthropic-ai/claude-code
npm install -g @openai/codex

# 6. Go 工具链
source ~/.bashrc
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
go install golang.org/x/tools/cmd/goimports@latest
go install github.com/golang/mock/mockgen@latest

# 7. 验证
echo "=== 环境检查 ==="
docker --version
go version
node --version
claude --version 2>/dev/null || echo "Claude Code: 需要配置 API Key"
codex --version 2>/dev/null || echo "Codex CLI: 需要配置 API Key"
golangci-lint --version
echo "✅ 全部安装完成！"

保存为 harness-init.sh，执行 bash harness-init.sh 即可。

---

二、Step2：API Key 与工具链配置 🔑

2.1 环境变量配置

# ~/.bashrc 末尾追加
# --- Harness Engineering API Keys ---
export ANTHROPIC_API_KEY="sk-ant-api03-xxxxxxxx"
export OPENAI_API_KEY="sk-xxxxxxxx"

# 可选：使用中转服务（国内网络）
# export OPENAI_BASE_URL="https://your-proxy.example.com/v1"
# export ANTHROPIC_BASE_URL="https://your-proxy.example.com"

# 刷新
source ~/.bashrc

⚠️ 安全原则：API Key 只放环境变量和 secrets，绝不硬编码到代码/配置文件中。

2.2 Codex CLI 配置

# ~/.codex/config.toml

# 模型与推理
model = "gpt-5.2"
model_reasoning_effort = "high"       # 推理强度：low/medium/high/xhigh
model_reasoning_summary = "detailed"  # 推理摘要详细度

# ⚠️ 仅在 Docker 隔离容器中使用！
approval_policy = "never"              # 全自动，无需批准
sandbox_mode = "danger-full-access"    # 完全访问权限

# MCP: 挂载 Claude Code 作为协作工具
[mcp_servers.claude]
command = "claude"
args = ["mcp", "serve"]

# 自定义模型提供方（可选）
# [model_providers.proxy]
# name = "My Proxy"
# base_url = "https://your-proxy.example.com/v1"
# env_key = "OPENAI_API_KEY"

2.3 Claude Code 权限配置

// 项目根目录/.claude/settings.json
{
  "permissions": {
    "allow": [
      "Read", "Write", "Edit", "Glob", "Grep",
      "Bash(go build:*)",
      "Bash(go test:*)",
      "Bash(golangci-lint run:*)",
      "Bash(goimports:*)",
      "Bash(git diff:*)",
      "Bash(git log:*)",
      "Bash(git status:*)",
      "Bash(make:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(sudo:*)",
      "Bash(curl:*)",
      "Bash(wget:*)"
    ]
  }
}

⚠️ 安全警告：approval_policy = "never" + sandbox_mode = "danger-full-access" = Agent 拥有完全自主权。必须在 Docker 容器内使用，绝不要在宿主机直接开放！

---

三、Step3：搭建项目 Harness 目录结构 📁

my-go-service/
├── AGENTS.md                     # 🗺️ Agent 导航地图（核心！）
├── .claude/
│   └── settings.json             # Claude Code 权限白名单
├── .harness/                     # Harness 工程目录
│   ├── constraints.yaml          # 架构约束（确定性检查）
│   ├── eval/                     # 评估任务定义
│   │   ├── task-001-crud-api.yaml
│   │   ├── task-002-auth-middleware.yaml
│   │   └── task-003-db-migration.yaml
│   ├── progress/                 # Agent 进度持久化
│   │   └── .gitkeep
│   └── lessons.md                # 经验教训库
├── scripts/
│   ├── arclint.go                # 分层依赖 Linter
│   ├── eval-runner.sh            # 批量 Eval 脚本
│   ├── gc-agent.sh               # 垃圾回收 Agent
│   └── harness-init.sh           # 环境初始化脚本
├── Dockerfile.agent              # Agent 隔离容器
├── docker-compose.agent.yaml     # 多 Agent 编排
├── Makefile
├── go.mod
├── cmd/
├── internal/
│   ├── domain/                   # 领域层（Layer 0）
│   ├── repository/               # 数据访问层（Layer 1）
│   ├── service/                  # 业务逻辑层（Layer 2）
│   └── handler/                  # HTTP 处理层（Layer 3）
└── docs/
    ├── architecture.md
    ├── api-conventions.md
    └── tech-decisions/

一键生成脚手架：

#!/bin/bash
# scaffold-harness.sh
mkdir -p .claude .harness/{eval,progress} scripts docs/tech-decisions
mkdir -p cmd internal/{domain,repository,service,handler} pkg
touch .harness/progress/.gitkeep .harness/lessons.md
echo "✅ Harness 目录结构创建完成"

---

四、Step4：编写 AGENTS.md（100行导航地图）🗺️

OpenAI 实验的核心发现：巨大的 AGENTS.md 会挤占上下文窗口，导致 Agent 退化。正确做法——约 100 行的"地图"，指向详细文档：

# AGENTS.md — Go 微服务 Agent 导航

## 项目概述
用户认证 + 订单管理微服务，Go 1.22 + Gin + GORM + PostgreSQL + Redis。
单体仓库，Clean Architecture 分层。

## 构建与测试
make build          # 编译
make test           # 全量测试
make lint           # golangci-lint
make test-cover     # 覆盖率（目标 ≥ 80%）
go run scripts/arclint.go ./...  # 架构分层检查

## ⚠️ 硬性规则（来自历史踩坑）
1. **依赖方向**：domain → repository → service → handler（单向！）
   - domain 层禁止 import 任何其他层的包
   - handler 禁止直接 import repository
   - 违反时运行 arclint.go 会报错
2. **数据库变更**：必须先读 docs/architecture.md
3. **新增 API**：必须遵循 docs/api-conventions.md
4. **错误处理**：必须用 pkg/errors 包装，禁止裸 error
5. **并发安全**：共享状态必须用 sync.Mutex 或 channel
6. **测试**：Table-Driven Test + gomock 隔离外部依赖

## 文档导航
| 领域 | 路径 | 何时读取 |
|------|------|---------|
| 架构设计 | docs/architecture.md | 修改核心逻辑前 |
| API规范 | docs/api-conventions.md | 新增/修改 API 时 |
| 技术决策 | docs/tech-decisions/ | 了解设计意图时 |
| 架构约束 | .harness/constraints.yaml | Agent 自检时 |
| 经验教训 | .harness/lessons.md | 开始新任务前 |

## 完成任务前的自检清单
- [ ] make test 全部通过
- [ ] make lint 无 error
- [ ] go run scripts/arclint.go ./... 无违规
- [ ] 新增代码有对应的测试
- [ ] 无 TODO/FIXME 遗留
- [ ] 提交信息格式：feat|fix|refactor(scope): 描述

---

五、Step5：架构约束——确定性 Linter 🔒

Harness 核心理念：不靠 Prompt 告诉 Agent 不要做什么，靠工程手段让它做不了。

5.1 分层依赖 Linter（Go 代码，可直接运行）

// scripts/arclint.go — 分层架构 Linter
// 用法: go run scripts/arclint.go ./...
package main

import (
    "fmt"
    "go/parser"
    "go/token"
    "os"
    "path/filepath"
    "strings"
)

// 层级定义：数字越小越底层，不允许 import 数字更大的层
var layerOrder = []string{
    "domain",      // Layer 0: 纯领域模型
    "repository",  // Layer 1: 数据访问
    "service",     // Layer 2: 业务逻辑
    "handler",     // Layer 3: HTTP 入口
}

func layerIndex(pkg string) int {
    for i, layer := range layerOrder {
        if strings.Contains(pkg, "/"+layer) ||
           strings.HasSuffix(pkg, "/"+layer) {
            return i
        }
    }
    return -1
}

func main() {
    violations := 0
    modulePath := getModulePath()

    filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
        if err != nil || !strings.HasSuffix(path, ".go") ||
           strings.Contains(path, "vendor") ||
           strings.Contains(path, "_test.go") {
            return nil
        }

        fset := token.NewFileSet()
        node, err := parser.ParseFile(fset, path, nil, parser.ImportsOnly)
        if err != nil {
            return nil
        }

        srcLayer := layerIndex(path)
        if srcLayer == -1 {
            return nil
        }

        for _, imp := range node.Imports {
            impPath := strings.Trim(imp.Path.Value, "\"")
            if !strings.HasPrefix(impPath, modulePath) {
                continue
            }
            dstLayer := layerIndex(impPath)
            if dstLayer == -1 {
                continue
            }
            if dstLayer > srcLayer {
                violations++
                pos := fset.Position(imp.Pos())
                fmt.Printf("❌ %s:%d — %s (layer %d) imports %s (layer %d)\n",
                    pos.Filename, pos.Line,
                    layerOrder[srcLayer], srcLayer,
                    layerOrder[dstLayer], dstLayer)
                fmt.Printf("   修复：将被依赖的类型/接口下沉到 %s 层或更低\n",
                    layerOrder[srcLayer])
            }
        }
        return nil
    })

    if violations > 0 {
        fmt.Printf("\n🚨 发现 %d 处分层违规\n", violations)
        os.Exit(1)
    }
    fmt.Println("✅ 架构分层检查通过")
}

func getModulePath() string {
    data, _ := os.ReadFile("go.mod")
    for _, line := range strings.Split(string(data), "\n") {
        if strings.HasPrefix(line, "module ") {
            return strings.TrimSpace(strings.TrimPrefix(line, "module "))
        }
    }
    return ""
}

5.2 架构约束配置（.harness/constraints.yaml）

# .harness/constraints.yaml — 确定性架构约束
constraints:
  # 依赖分层
  layer_check:
    tool: "go run scripts/arclint.go ./..."
    action: "block"
    message: "分层违规，禁止提交"

  # 代码质量
  lint:
    tool: "golangci-lint run --timeout=5m"
    action: "block"

  # 测试覆盖率
  coverage:
    tool: "go test -coverprofile=coverage.out ./..."
    threshold: 80
    action: "warn"

  # 安全检查
  security:
    patterns:
      - pattern: 'password|secret|api_key'
        check: "禁止硬编码密钥"
        action: "block"
      - pattern: 'fmt\.Sprintf.*SELECT|INSERT|UPDATE|DELETE'
        check: "禁止SQL字符串拼接（SQL注入风险）"
        action: "block"

  # 数据库变更
  database:
    rules:
      - "ALTER TABLE 必须有对应的回滚脚本"
      - "DROP COLUMN 必须先标记 deprecated 一个版本"
    action: "warn_and_require_approval"

---

六、Step6：构建 Eval Harness——自动化评估反馈循环 🔄

Anthropic 方法论：Generator（写代码）和 Evaluator（评估）必须分离。

6.1 Eval 任务定义

# .harness/eval/task-001-crud-api.yaml
name: "实现用户 CRUD API"
description: |
  在 internal/handler/ 下实现用户增删改查四个端点：
  - POST   /api/v1/users
  - GET    /api/v1/users/:id
  - PUT    /api/v1/users/:id
  - DELETE /api/v1/users/:id

preconditions:
  - "docs/api-conventions.md 已存在"
  - "internal/domain/user.go 已定义 User 模型"

success_criteria:
  deterministic:
    - "go build ./... 无编译错误"
    - "go test ./internal/handler/... 全部通过"
    - "golangci-lint run 无 error"
    - "go run scripts/arclint.go ./... 无分层违规"
  llm_review:
    - "错误处理是否使用 pkg/errors 包装"
    - "是否遵循 RESTful 命名规范"

scoring:
  pass_threshold: 0.8
  weights:
    deterministic: 0.6
    llm_review: 0.3
    human_review: 0.1

6.2 批量 Eval 运行脚本

#!/bin/bash
# scripts/eval-runner.sh — 批量 Eval Harness 运行器
set -euo pipefail

EVAL_DIR=".harness/eval"
RESULTS_DIR=".harness/eval-results/$(date +%Y%m%d-%H%M%S)"
mkdir -p "$RESULTS_DIR"

echo "🚀 Eval Harness 批量运行开始"
echo "================================="

total=0; passed=0; failed=0

for task_file in "$EVAL_DIR"/*.yaml; do
    task_name=$(basename "$task_file" .yaml)
    total=$((total + 1))
    echo ""
    echo "📋 任务 [$total]: $task_name"

    # Step 1: 创建隔离分支
    git checkout -b "eval/$task_name" main 2>/dev/null || \
        git checkout "eval/$task_name"

    # Step 2: 用 Claude Code headless 执行任务
    task_desc=$(cat "$task_file" | head -20)
    claude -p "请完成以下任务。严格遵守 AGENTS.md 中的规则。
任务文件：$task_file
任务描述：$task_desc
完成后运行自检清单中的所有检查。" \
        --allowedTools "Read,Write,Edit,Bash(go *),Bash(make *),Bash(golangci-lint *)" \
        --max-turns 15 \
        --output-format json > "$RESULTS_DIR/${task_name}-agent.json" 2>&1

    # Step 3: 确定性验证
    score=0; checks=0

    checks=$((checks + 1))
    go build ./... 2>/dev/null && score=$((score + 1)) && echo "  ✅ 编译通过" || echo "  ❌ 编译失败"

    checks=$((checks + 1))
    go test ./... 2>/dev/null && score=$((score + 1)) && echo "  ✅ 测试通过" || echo "  ❌ 测试失败"

    checks=$((checks + 1))
    golangci-lint run --timeout=5m 2>/dev/null && score=$((score + 1)) && echo "  ✅ Lint 通过" || echo "  ❌ Lint 失败"

    checks=$((checks + 1))
    go run scripts/arclint.go ./... 2>/dev/null && score=$((score + 1)) && echo "  ✅ 架构检查通过" || echo "  ❌ 架构违规"

    pass_rate=$(echo "scale=2; $score / $checks" | bc)
    echo "📊 得分: $score/$checks ($pass_rate)"

    if (( $(echo "$pass_rate >= 0.80" | bc -l) )); then
        passed=$((passed + 1)); echo "🎉 PASS"
    else
        failed=$((failed + 1)); echo "💀 FAIL"
    fi

    echo "{\"task\": \"$task_name\", \"score\": $score, \"total\": $checks, \"rate\": $pass_rate}" \
        > "$RESULTS_DIR/${task_name}-result.json"

    git checkout main
done

echo ""
echo "================================="
echo "📊 Eval 汇总: $passed/$total 通过, $failed 失败"
echo "结果目录: $RESULTS_DIR"

6.3 用 Codex CLI 做 Eval（替代方案）

# 用 Codex exec（headless 模式）执行 Eval 任务
codex exec "阅读 .harness/eval/task-001-crud-api.yaml，\
按照其中的要求实现功能。\
严格遵守 AGENTS.md 中的架构规则。\
完成后运行 make test 和 make lint 确认通过。" \
  --json > eval-result.jsonl

# 解析结果
cat eval-result.jsonl | jq -r 'select(.type == "message") | .content'

---

七、Step7：Docker 隔离——多 Agent 并行安全容器 🐳

Anthropic 构建 C 编译器时使用 16 个并行 Agent，每个在独立容器中运行。一台 4C8G 云机器可安全并行 2-4 个 Agent。

7.1 Dockerfile.agent

# Dockerfile.agent — Agent 隔离沙箱
FROM golang:1.22-bookworm

# 基础工具
RUN apt-get update && apt-get install -y \
    git curl jq tree && \
    rm -rf /var/lib/apt/lists/*

# Node.js
RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - && \
    apt-get install -y nodejs

# AI Agent 工具链
RUN npm install -g @anthropic-ai/claude-code @openai/codex

# Go 工具链
RUN go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest && \
    go install golang.org/x/tools/cmd/goimports@latest

WORKDIR /workspace

# 非 root 用户
RUN useradd -m agent && chown -R agent:agent /workspace
USER agent

ENTRYPOINT ["claude", "-p"]

7.2 docker-compose.agent.yaml

# docker-compose.agent.yaml — 多 Agent 并行编排
version: "3.8"

services:
  # Agent 1: 实现 CRUD API
  agent-crud:
    build:
      context: .
      dockerfile: Dockerfile.agent
    volumes:
      - ./:/workspace
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    network_mode: "none"    # 🔒 网络隔离！
    mem_limit: 2g
    cpus: 1.0
    command: >
      阅读 AGENTS.md 和 .harness/eval/task-001-crud-api.yaml，
      实现用户 CRUD API。完成后运行 make test 和 make lint。
    working_dir: /workspace

  # Agent 2: 实现认证中间件
  agent-auth:
    build:
      context: .
      dockerfile: Dockerfile.agent
    volumes:
      - ./:/workspace
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    network_mode: "none"
    mem_limit: 2g
    cpus: 1.0
    command: >
      阅读 AGENTS.md 和 .harness/eval/task-002-auth-middleware.yaml，
      实现 JWT 认证中间件。完成后运行 make test 和 make lint。
    working_dir: /workspace

  # Agent 3: 评估者（只读挂载！）
  agent-evaluator:
    build:
      context: .
      dockerfile: Dockerfile.agent
    volumes:
      - ./:/workspace:ro      # 只读！评估者不能改代码
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    network_mode: "none"
    mem_limit: 1g
    cpus: 0.5
    depends_on:
      - agent-crud
      - agent-auth
    command: >
      你是代码评估者。审查 /workspace 中的代码变更：
      1. 运行 go test ./...
      2. 运行 golangci-lint run
      3. 运行 go run scripts/arclint.go ./...
      4. 输出 JSON 格式的评估报告
    working_dir: /workspace

启动命令：

# 构建镜像
docker compose -f docker-compose.agent.yaml build

# 并行启动
docker compose -f docker-compose.agent.yaml up

# 单独启动某个 Agent
docker compose -f docker-compose.agent.yaml run agent-crud

💡 安全设计：network_mode: "none" = Agent 不能访问外网；Evaluator 用 :ro 只读挂载 = 不能改代码；API Key 通过环境变量注入，不写入镜像。

---

八、Step8：进度持久化——跨会话记忆 🧠

LLM 是无状态的。Harness 通过 JSON 进度文件解决跨会话记忆：

// .harness/progress/task-001-crud-api.json
{
  "task_id": "task-001-crud-api",
  "status": "in_progress",
  "started_at": "2026-03-26T14:30:00Z",
  "agent_session": "claude-session-abc123",
  "completed_steps": [
    {
      "step": "理解 API 规范",
      "completed_at": "2026-03-26T14:32:00Z",
      "output": "已阅读 docs/api-conventions.md"
    },
    {
      "step": "实现 CreateUser handler",
      "completed_at": "2026-03-26T14:38:00Z",
      "output": "internal/handler/user_handler.go 已创建"
    }
  ],
  "current_step": "实现 GetUser handler",
  "current_file": "internal/handler/user_handler.go",
  "current_line": 45,
  "next_steps": ["UpdateUser", "DeleteUser", "Table-Driven Test"],
  "resume_hint": "从 GetUser handler 的 error handling 部分继续"
}

恢复进度：

claude -p "阅读 .harness/progress/task-001-crud-api.json，
从 resume_hint 位置继续工作。完成后更新 progress 文件。" \
  --resume --session-id "ci-review-42" \
  --allowedTools "Read,Write,Edit,Bash(go *),Bash(make *)"

---

九、Step9：经验教训库——永不犯同样的错 📝

OpenAI 核心理念：每当 Agent 犯一个错，就花时间设计方案，使它永远不再犯同样的错误。

# .harness/lessons.md

## 2026-03-26: handler 层直接调用 repository
**现象**: Agent 在 user_handler.go 中直接 import 了 repository
**根因**: AGENTS.md 只写了"依赖方向单向"，没给具体示例
**解决**: AGENTS.md 增加示例 + arclint.go 增加检测
**验证**: 重新执行一次通过 ✅

## 2026-03-26: 用 fmt.Errorf 而不是 pkg/errors
**现象**: 新增代码全部使用 fmt.Errorf，丢失调用栈
**根因**: fmt.Errorf 是合法的，golangci-lint 不报错
**解决**: golangci-lint 配置增加 wrapcheck + AGENTS.md 硬性规则
**验证**: 重新执行正确使用 errors.Wrap ✅

---

十、Step10：垃圾回收 Agent——定期扫描 AI 技术债 🗑️

#!/bin/bash
# scripts/gc-agent.sh — 每周 cron 运行
set -euo pipefail

echo "🗑️ GC Agent 启动 — $(date)"

# 1. 架构违规扫描
echo "📐 检查架构分层..."
if ! go run scripts/arclint.go ./... 2>/dev/null; then
    claude -p "运行 arclint.go 查看违规并修复，修复后确认通过。" \
      --allowedTools "Read,Write,Edit,Bash(go *)" \
      --max-turns 10 --output-format json > /tmp/gc-arclint.json
fi

# 2. TODO/FIXME 审计
todo_count=$(grep -rn "TODO\|FIXME\|HACK" --include="*.go" . | \
    grep -v vendor | grep -v _test.go | wc -l)
echo "📝 遗留标记: $todo_count"

# 3. 文档一致性检查
claude -p "对比 docs/api-conventions.md 和 internal/handler/ 的实际端点，列出不一致。" \
  --allowedTools "Read,Glob,Grep" --output-format text

echo "✅ GC 完成"

定时执行：

# 每周一早上9点
crontab -e
0 9 * * 1 cd /path/to/project && bash scripts/gc-agent.sh >> /var/log/gc-agent.log 2>&1

---

十一、日常工作流速查 🎯

场景 A：接到新需求，用 Agent 开发

ssh dev@your-server
cd /home/dev/my-go-service
git checkout -b feat/user-export

# 启动交互式 Agent
claude
# > 阅读 AGENTS.md 和 .harness/lessons.md
# > 实现用户导出 API：GET /api/v1/users/export
# > 完成后运行自检清单

# 人工 Review + 提交
git add -A && git commit -m "feat(user): add export API"

场景 B：CI 失败，用 Agent 自动修复

claude -p "查看最近 CI 失败的日志，定位原因并修复。
修复后重新运行 make test 确认通过。" \
  --allowedTools "Read,Write,Edit,Bash(go *),Bash(make *)" \
  --max-turns 10 --output-format json > ci-fix.json

场景 C：批量 Eval，评估 Agent 能力

bash scripts/eval-runner.sh
# 或 Docker 并行
docker compose -f docker-compose.agent.yaml up

场景 D：代码审查

git diff HEAD~3 | claude -p \
  --append-system-prompt "你是安全工程师。审查变更中的安全漏洞。" \
  --allowedTools "Read,Glob,Grep" \
  --output-format json > review.json

---

十二、完整配置清单 ✅

文件	用途	维护者
AGENTS.md	Agent 导航地图	人类 + Agent
.claude/settings.json	Claude Code 权限	人类
~/.codex/config.toml	Codex CLI 全局配置	人类
.harness/constraints.yaml	架构约束	人类
.harness/eval/*.yaml	Eval 任务定义	人类
.harness/progress/*.json	进度持久化	Agent
.harness/lessons.md	经验教训库	人类（踩坑后补充）
scripts/arclint.go	分层 Linter	人类
scripts/eval-runner.sh	批量 Eval	人类
scripts/gc-agent.sh	垃圾回收	Cron + Agent
Dockerfile.agent	Agent 沙箱	人类
docker-compose.agent.yaml	多 Agent 编排	人类

---

参考资料

1. OpenAI — Harness Engineering: Leveraging Codex in an Agent-First World
2. Anthropic — Demystifying Evals for AI Agents
3. Claude Code Docs — 以编程方式运行 Claude Code
4. Codex 全面实战教程：从安装到工程协作
5. 探索AGI — 不要等下一代模型了，立即做 Harness
6. 开发超人 — AI 时代下 Harness Engineering 全面指南
7. 腾讯云 — Multi-Agent 系统 Harness Engineering 架构
8. Codex + Claude Code MCP 多 Agent 联合编排

---

💬 本文所有配置文件和脚本均已实际验证，可直接复制到你的云服务器使用。如有问题欢迎评论区交流。