# loop

**Repository Path**: agent01/loop

## Basic Information

- **Project Name**: loop
- **Description**: No description available
- **Primary Language**: TypeScript
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-06-15
- **Last Updated**: 2026-07-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Super Loop Agents

本项目当前核心是 `super-loop-agents`：一个 OpenSpec-native AI 开发编排器。你给它一个自然语言任务，它会先生成 Prompt
Intake，再围绕同一个 OpenSpec change 完成初始化、评估、拆分、开发、技术测试、证据验证和结果验收，并输出结构化日志和最终报告。

## 核心目标

`super-loop-agents` 不是一个普通脚本集合，而是一个可审计的 AI 开发编排器。它的核心目标是：

- 把自然语言任务转换成可执行、可验证的开发流程。
- 用固定 agent 链路减少漏步骤、漏验收和口头完成。
- 强制关键 agent 产出 required artifacts，缺少产物就失败。
- 记录每次 agent 输入、输出、路由、token usage、任务状态和最终报告。
- 先支持 Claude Code CLI 真实执行，后续再扩展 Codex 等本地 AI CLI。

## 项目结构

```text
super-loop-agents/
├─ bin/
│  ├─ super-loop.mjs              # 推荐用户入口：start / continue / result
│  └─ super-loop-run.mjs          # 底层 runner CLI 入口，保持兼容
├─ config/
│  ├─ default-config.json         # 默认 agent、循环、超时、artifact、能力边界配置
│  └─ smoke-config.json           # smoke 场景配置
├─ lib/
│  ├─ orchestrator.mjs            # 主编排器：状态机、路由、重试、artifact 校验
│  ├─ agent-invocation-service.mjs # agent 调用服务
│  ├─ agent-adapters.mjs          # Claude CLI / adapter 输出适配
│  ├─ adapter-factory.mjs         # adapter 创建入口
│  ├─ agent-prompts.mjs           # 各 agent 的 JSON-only prompt 合约
│  ├─ schema-validator.mjs        # agent 输出、artifact、配置 schema 校验
│  ├─ workflow-artifacts.mjs      # workflow artifact 注册和查询
│  ├─ artifact-enforcement.mjs    # required artifacts 强制校验
│  ├─ dependency-graph.mjs        # 子任务依赖图和循环依赖检测
│  ├─ state-machine.mjs           # 顶层任务和子任务状态机
│  ├─ final-report-builder.mjs    # final-report.json 构建
│  ├─ log-store.mjs               # input-task / agent-runs / route-logs / task-state / final-report 写入
│  ├─ prompt-compiler.mjs         # 用户 prompt 结构化编译
│  ├─ runtime-context.mjs         # 运行目录、目标目录、工作区上下文
│  ├─ run-policy.mjs              # 语言、时间、日志、artifact、能力策略
│  └─ console-reporter.mjs        # 控制台可见输出
├─ schemas/
│  └─ communication-contracts.md  # 通信契约说明
├─ docs/
│  ├─ real-runner.md              # 真实 runner 说明
│  ├─ runtime-guide.md            # 运行上下文说明
│  ├─ adapter-boundaries.md       # adapter 边界说明
│  ├─ exception-cases.md          # 异常 case 说明
│  └─ v0.1-validation.md          # v0.1 验证记录
├─ demo/
│  └─ config-task/                # 示例任务和日志样例
└─ test/
   └─ *.test.mjs                  # Node test 测试集
```

## 核心流程

真实 runner 推荐入口：

```bash
node super-loop-agents/bin/super-loop.mjs start "你的任务" --target E:\data\ai\my-app
```

旧入口仍然兼容：

```bash
node super-loop-agents/bin/super-loop-run.mjs "你的任务"
```

OpenSpec-native 执行链路：

```text
用户任务
  -> Prompt Intake/prompt_intake
  -> execute-init/init_report
  -> OpenSpec change context
  -> evaluation
    -> pass=false: taskPerfect/planning -> evaluation
    -> pass=true: taskSplit
  -> dependency graph validation
  -> execute-dev/OpenSpec development + self_review
  -> execute-test/technical inspection
  -> verify gate/verification_report
    -> pass=false: route back to execute-dev
    -> pass=true: result-agent
  -> result-agent/result_report
    -> decision=accept: subtask completed
    -> decision!=accept: route back or fail with rework
  -> final-report.json
```

常用命令：

```bash
node super-loop-agents/bin/super-loop.mjs start "目标：修复登录链路 bug。验收：补测试并跑通。" --target E:\data\ai\my-app
node super-loop-agents/bin/super-loop.mjs continue
node super-loop-agents/bin/super-loop.mjs result --target E:\data\ai\my-app
```

`start` 启动完整链路；`continue` 继续最近一次未完成 run；`result` 只复核已有结果，运行 verify gate 和 result-agent。

主要路由规则：

- `Prompt Intake` 先抽取目标、约束、验收标准、用户断言、证据计划和 OpenSpec 意图。
- `execute-init` 初始化目标项目上下文，产出 `init_report`，并识别 OpenSpec 状态。
- runner 构建 `openspec_change_context`，后续 split、dev、test、verify 和 result 阶段共享同一个事实源。
- `evaluation` 判断任务是否可执行、是否完整、风险是否可控。
- `evaluation.pass=false` 时进入 `taskPerfect`，补齐任务并产出 `planning`，然后重新评估。
- `evaluation.pass=true` 后进入 `taskSplit`，拆成带依赖、验收标准和 OpenSpec trace 的子任务。
- runner 检测依赖图，发现循环依赖会失败并记录 `CASE_DEPENDENCY_CYCLE`。
- 每个 ready 子任务进入 `execute-dev`，要求按 OpenSpec SDD 真实开发，并输出 `self_review`。
- `execute-test` 只负责技术证据；失败会打回 `execute-dev` 重试。
- verify gate 把技术证据映射到验收标准，缺证据时记录 `CASE_VERIFICATION_EVIDENCE_MISSING`。
- result-agent 从用户、维护者、新手和生产视角验收；非 `accept` 时记录 `CASE_RESULT_REJECTED`。
- 超过循环或重试上限后，最终状态为 `failed` 或 `failed_with_partial_completion`。

## 关键配置

默认配置文件：

```text
super-loop-agents/config/default-config.json
```

核心配置项：

```json
{
  "loops": {
    "evaluation_task_perfect": {
      "max_iterations": 5
    },
    "dev_test": {
      "max_attempts": 3
    }
  },
  "thresholds": {
    "feasibility_score": 70,
    "completeness_score": 80,
    "min_agent_completion_score": 60
  },
  "timeouts": {
    "subAgent_executeInit_ms": 180000,
    "subAgent_evaluation_ms": 120000,
    "subAgent_taskPerfect_ms": 180000,
    "subAgent_taskSplit_ms": 120000,
    "subAgent_executeDev_ms": 600000,
    "subAgent_executeTest_ms": 300000,
    "subAgent_resultAgent_ms": 180000
  }
}
```

required artifacts 配置：

```json
{
  "workflow_artifacts": {
    "required_by_agent_type": {
      "execute-init": [
        "init_report"
      ],
      "taskPerfect": [
        "planning"
      ],
      "execute-dev": [
        "openspec_change",
        "openspec_proposal",
        "openspec_design",
        "openspec_specs",
        "openspec_tasks",
        "implementation"
      ],
      "execute-test": [
        "inspection_report"
      ],
      "result-agent": [
        "result_report"
      ]
    }
  }
}
```

缺少 required artifacts 时，runner 会失败并记录：

```text
CASE_REQUIRED_ARTIFACT_MISSING: <artifact_type>
```

## 前置条件

本机需要能执行 Claude Code CLI：

```bash
claude -p "hello" --output-format json
```

如果该命令不可用，只能用 `--adapter-command` 做 runner 编排调试，不能算完整真实 Claude/OpenSpec/browser smoke。

## 基本用法

在项目根目录 `E:\data\ai\loop` 下运行：

```bash
node super-loop-agents/bin/super-loop.mjs start "写一个计算器功能。要求能在网页运行，并给出验收证据。" --target E:\data\ai\test
```

更推荐的任务写法：

```text
目标：要做什么
目标目录：E:\data\ai\test
约束：不能改哪些东西 / 必须遵守什么
验收：怎么证明完成
```

示例：

```bash
node super-loop-agents/bin/super-loop.mjs start "目标：修复登录链路 bug。约束：不能改数据库 schema。验收：补充测试并跑通登录相关测试。" --target E:\data\ai\my-app
```

## 指定输出目录

```bash
node super-loop-agents/bin/super-loop.mjs start "目标：检查并修复登录 bug。验收：测试通过。" --target E:\data\ai\my-app \
  --runs-dir super-loop-agents/runs
```

运行后会生成：

```text
super-loop-agents/runs/<task_id>/
├─ input-task.json
└─ logs/
   ├─ agent-runs.jsonl
   ├─ route-logs.jsonl
   ├─ task-state.json
   └─ final-report.json
```

重点查看：

- `input-task.json`：用户原始任务、目标目录、运行策略、编译后的任务摘要。
- `agent-runs.jsonl`：每个 agent 的输入、输出、状态、artifact、token usage 和错误。
- `route-logs.jsonl`：runner 每次路由决策、反馈类型、循环计数和失败 marker。
- `task-state.json`：顶层任务状态、子任务状态、依赖、失败原因和历史。
- `final-report.json`：最终状态、完成/失败原因、workflow artifacts、Prompt Intake 摘要、OpenSpec context 摘要、verification
  summary、result summary、状态机摘要、验收证据和 token usage。

## 指定配置

```bash
node super-loop-agents/bin/super-loop-run.mjs "你的任务" \
  --config-path super-loop-agents/config/default-config.json \
  --runs-dir super-loop-agents/runs \
  --timeout-ms 600000
```

## 断点续跑

可以用 `--resume` 继续最近一次 run：

```bash
node super-loop-agents/bin/super-loop.mjs continue \
  --runs-dir super-loop-agents/runs
```

也可以指定 task id：

```bash
node super-loop-agents/bin/super-loop-run.mjs "继续指定任务" \
  --runs-dir super-loop-agents/runs \
  --resume task1_20260616103000
```

## 使用 adapter-command 调试

如果不想真实调用 Claude Code CLI，可以用 adapter command 模拟 agent 输出：

```bash
node super-loop-agents/bin/super-loop-run.mjs "目标：测试 runner。目标目录是 E:\data\ai\test。" \
  --runs-dir super-loop-agents/runs \
  --adapter-command "node path/to/adapter.mjs"
```

注意：`--adapter-command` 适合调试 runner 编排、日志、状态机和 artifact 校验，不等于完整真实 Claude/OpenSpec/browser smoke。

## 各 agent 职责和出参示意

### main

`main` 是 runner 内部调度角色，负责状态机、路由、schema 校验、日志写入和 required artifact 检查。当前真实 runner 主要在
`orchestrator.mjs` 内确定性执行这些职责。

出参示意：

```json
{
  "routing_decision": "route_to_taskSplit",
  "reason": "evaluation 通过，进入任务拆分。",
  "next_agent_type": "taskSplit",
  "state_update": {
    "status": "in_progress"
  },
  "failure_marker": null,
  "required_artifact_check": {
    "missing_artifacts": []
  }
}
```

### execute-init

`execute-init` 在正式评估前初始化目标项目。它读取 README、CLAUDE/AGENTS/GEMINI 指令、OpenSpec 状态、构建入口、测试入口、运行入口和浏览器验证入口。

必需 artifact：`init_report`

出参示意：

```json
{
  "task_id": "task1_20260616103000",
  "attempt": 1,
  "project_profile": {
    "name": "my-app",
    "type": "web-app",
    "package_manager": "npm"
  },
  "openspec_status": {
    "enabled": true,
    "config_found": true,
    "changes_dir": "openspec/changes"
  },
  "project_instructions": [
    "README.md",
    "CLAUDE.md"
  ],
  "dev_commands": [
    "npm install",
    "npm run dev"
  ],
  "test_commands": [
    "npm test"
  ],
  "run_commands": [
    "npm run dev"
  ],
  "browser_verification_plan": {
    "required": true,
    "entrypoints": [
      "http://localhost:5173"
    ],
    "fallbacks": [
      "静态检查 HTML/CSS/JS"
    ]
  },
  "write_scope": {
    "allowed_roots": [
      "E:\\data\\ai\\test"
    ],
    "denied_patterns": [
      ".git/**",
      "node_modules/**"
    ]
  },
  "autonomy_policy": {
    "require_user_handoff": false
  },
  "risks": [],
  "created_or_updated_files": [],
  "evidence": [
    "读取 package.json",
    "发现 npm test"
  ],
  "completion_score": 90,
  "artifacts": [
    {
      "artifact_type": "init_report",
      "path": "runs/current/artifacts/init-report.json",
      "summary": "目标项目初始化报告。",
      "evidence": [
        "project_profile 已记录"
      ]
    }
  ]
}
```

### evaluation

`evaluation` 判断任务是否可执行。它输出多维评分、缺失字段、风险、视角评审和是否允许进入执行。

出参示意：

```json
{
  "feasibility_score": 85,
  "completeness_score": 65,
  "requirement_completeness_score": 70,
  "evidence_quality_score": 60,
  "acceptance_testability_score": 75,
  "risk_score": 30,
  "project_fit_score": 80,
  "codebase_robustness_score": 75,
  "autonomy_readiness_score": 70,
  "missing_fields": [
    "验收标准不明确"
  ],
  "blocking_unknowns": [],
  "risk_reasons": [
    "缺少可验证入口"
  ],
  "next_decision_options": [
    "进入 taskPerfect 补齐任务"
  ],
  "perspective_reviews": [
    {
      "perspective": "testing",
      "score": 65,
      "finding": "验收标准需要更具体。",
      "recommendation": "补充命令和浏览器验收。"
    }
  ],
  "suggestions": [
    "补充目标目录和验收命令"
  ],
  "needs_taskPerfect": true,
  "allow_execution": false,
  "pass": false,
  "reason": "任务可行，但完整性不足。",
  "completion_score": 90
}
```

### taskPerfect

`taskPerfect` 在 evaluation 未通过时补齐任务。它基于项目证据、边界条件、依赖和多视角分析形成 planning artifact。

必需 artifact：`planning`

出参示意：

```json
{
  "task_description": "实现网页计算器，目标目录 E:\\data\\ai\\test，支持加减乘除并通过浏览器验收。",
  "user_intent": "创建可运行、可验证的网页功能。",
  "technical_feasibility": "可用现有前端构建入口实现。",
  "acceptance_criteria": [
    "页面可打开",
    "输入 1 + 2 返回 3",
    "测试命令通过"
  ],
  "boundary_conditions": [
    "不得修改目标目录以外文件"
  ],
  "dependencies": [
    "确认运行入口",
    "实现 UI",
    "补充测试"
  ],
  "rejected_paths_to_avoid": [
    "只给方案不改代码"
  ],
  "risk_notes": [
    "浏览器工具不可用时使用静态和 Node fallback 验证"
  ],
  "research_evidence": [
    "读取 README",
    "发现 npm run dev"
  ],
  "assumption_register": [
    "默认使用现有包管理器"
  ],
  "autonomous_decisions": [
    "不反问，按可推断入口执行"
  ],
  "fallback_plan": [
    "用文件系统证据验证 HTML/JS"
  ],
  "no_user_handoff_reason": "上下文足够，可自主推进。",
  "perspective_synthesis": {
    "testing": "需要命令和浏览器双重证据。"
  },
  "completion_score": 92,
  "artifacts": [
    {
      "artifact_type": "planning",
      "planning_notes_path": "runs/current/artifacts/planning.md",
      "path": "runs/current/artifacts/planning.md",
      "summary": "补齐后的任务计划。",
      "evidence": [
        "acceptance_criteria 已补齐"
      ]
    }
  ]
}
```

### taskSplit

`taskSplit` 把通过评估的任务拆成带依赖关系和验收标准的子任务。runner 会检查依赖图，防止循环依赖。

出参示意：

```json
{
  "tasks": [
    {
      "task_id": "task1_20260616103000-1",
      "description": "实现计算器页面和交互逻辑。",
      "dependencies": [],
      "acceptance_criteria": [
        "页面包含数字、运算符和结果区域"
      ]
    },
    {
      "task_id": "task1_20260616103000-2",
      "description": "补充计算器测试和验收证据。",
      "dependencies": [
        "task1_20260616103000-1"
      ],
      "acceptance_criteria": [
        "测试覆盖加减乘除",
        "测试命令通过"
      ]
    }
  ],
  "completion_score": 90
}
```

### execute-dev

`execute-dev` 对单个子任务执行真实开发。它必须使用 OpenSpec SDD 流程，并产出 OpenSpec 和 implementation artifacts。

必需 artifacts：`openspec_change`、`openspec_proposal`、`openspec_design`、`openspec_specs`、`openspec_tasks`、
`implementation`

出参示意：

```json
{
  "task_id": "task1_20260616103000-1",
  "attempt": 1,
  "implementation_summary": "实现计算器 UI、状态管理和四则运算逻辑。",
  "changed_artifacts": [
    "openspec/changes/add-calculator/proposal.md",
    "src/App.tsx",
    "src/App.test.tsx"
  ],
  "test_notes": [
    "已运行 npm test"
  ],
  "known_risks": [],
  "status": "completed",
  "completion_score": 88,
  "artifacts": [
    {
      "artifact_type": "openspec_change",
      "path": "openspec/changes/add-calculator",
      "summary": "OpenSpec change 目录。",
      "evidence": [
        "change id 已创建"
      ]
    },
    {
      "artifact_type": "openspec_proposal",
      "path": "openspec/changes/add-calculator/proposal.md",
      "summary": "变更提案。",
      "evidence": [
        "说明 why/what/impact"
      ]
    },
    {
      "artifact_type": "openspec_design",
      "path": "openspec/changes/add-calculator/design.md",
      "summary": "设计说明。",
      "evidence": [
        "覆盖 UI 和计算逻辑"
      ]
    },
    {
      "artifact_type": "openspec_specs",
      "path": "openspec/changes/add-calculator/specs/calculator/spec.md",
      "summary": "delta spec。",
      "evidence": [
        "包含验收场景"
      ]
    },
    {
      "artifact_type": "openspec_tasks",
      "path": "openspec/changes/add-calculator/tasks.md",
      "summary": "OpenSpec 任务清单。",
      "evidence": [
        "任务勾选完成"
      ]
    },
    {
      "artifact_type": "implementation",
      "path": "src/App.tsx",
      "summary": "业务实现文件。",
      "evidence": [
        "计算器功能已实现"
      ]
    }
  ]
}
```

### execute-test

`execute-test` 对开发结果做技术检查。它应运行测试命令、检查文件系统证据，并尽量使用 gstack/browser 能力验证页面。浏览器工具不可用时，必须记录
fallback；最终用户验收由 verify gate 和 result-agent 完成。

必需 artifact：`inspection_report`

出参示意：

```json
{
  "task_id": "task1_20260616103000-1",
  "attempt": 1,
  "pass": true,
  "verification_plan": {
    "commands": [
      "npm test"
    ],
    "browser_entrypoints": [
      "http://localhost:5173"
    ]
  },
  "commands_run": [
    {
      "command": "npm test",
      "status": "passed",
      "summary": "测试通过。"
    }
  ],
  "browser_runs": [
    {
      "entrypoint": "http://localhost:5173",
      "status": "passed",
      "evidence": "页面可交互。"
    }
  ],
  "console_errors": [],
  "network_failures": [],
  "dom_or_visual_evidence": [
    "结果区域显示 3"
  ],
  "acceptance_results": [
    {
      "criterion": "输入 1 + 2 返回 3",
      "status": "passed",
      "evidence": "浏览器验证通过。"
    }
  ],
  "output_contract_results": [],
  "failed_cases": [],
  "suggestion": "",
  "positive_feedback": [
    "验收标准全部通过"
  ],
  "negative_feedback": [],
  "verification_confidence_score": 90,
  "fallbacks_used": [],
  "completion_score": 95,
  "artifacts": [
    {
      "artifact_type": "inspection_report",
      "path": "runs/current/artifacts/inspection-report.json",
      "summary": "技术检查报告。",
      "evidence": [
        "commands_run passed",
        "acceptance_results passed"
      ]
    }
  ]
}
```

### verify gate

verify gate 是确定性代码，不是 agent。它把 `inspection_report` 中的命令、浏览器、DOM、接口、日志和 acceptance evidence
映射到验收标准。

必需 artifact：`verification_report`

出参示意：

```json
{
  "task_id": "task1_20260616103000",
  "subtask_id": "task1_20260616103000-1",
  "pass": true,
  "acceptance_results": [
    {
      "criterion": "输入 1 + 2 返回 3",
      "pass": true,
      "evidence": [
        "commands_run[0]",
        "dom_or_visual_evidence[0]"
      ]
    }
  ],
  "missing_evidence": [],
  "evidence_sources": [
    "commands_run",
    "dom_or_visual_evidence"
  ],
  "failure_marker": null,
  "completion_score": 95
}
```

### result-agent

`result-agent` 只在 verify gate 通过后运行。它从原始用户、维护者、新手用户和生产使用者视角验收最终结果。

必需 artifact：`result_report`

出参示意：

```json
{
  "task_id": "task1_20260616103000-1",
  "attempt": 1,
  "decision": "accept",
  "user_perspective_findings": [
    "满足原始目标"
  ],
  "maintainer_findings": [
    "变更可追踪"
  ],
  "usability_findings": [
    "使用路径清楚"
  ],
  "production_risk_findings": [],
  "rejection_targets": [],
  "required_rework": [],
  "final_acceptance_score": 92,
  "positive_feedback": [
    "验收通过"
  ],
  "negative_feedback": [],
  "completion_score": 92,
  "artifacts": [
    {
      "artifact_type": "result_report",
      "path": "runs/current/artifacts/result-report.json",
      "summary": "最终结果验收报告。",
      "evidence": [
        "verification_report pass"
      ]
    }
  ]
}
```

## WorkflowArtifact 通用格式

所有 workflow artifact 被归一化后都应满足统一结构：

```json
{
  "artifact_id": "run-001-init_report-1",
  "artifact_type": "init_report",
  "agent_run_id": "run-001",
  "task_id": "task1_20260616103000",
  "subtask_id": null,
  "path": "runs/current/artifacts/init-report.json",
  "status": "created",
  "summary": "目标项目初始化报告。",
  "evidence": [
    "读取 README.md"
  ],
  "created_at": "20260616103000"
}
```

支持的 `artifact_type`：

```text
prompt_intake
openspec_change_context
planning
openspec_change
openspec_proposal
openspec_design
openspec_specs
openspec_tasks
implementation
init_report
inspection_report
verification_report
result_report
token_usage
auxiliary_validation
```

## 日志和最终报告示例

`agent-runs.jsonl` 每行是一条 agent run：

```json
{
  "agent_run_id": "run-002",
  "agent_id": "super-loop-evaluation-agent",
  "agent_type": "evaluation",
  "task_id": "task-001",
  "parent_agent_run_id": "run-001",
  "attempt": 1,
  "input_summary": "评估原始任务。",
  "output_summary": "可行性 85，完整性 65，未通过。",
  "status": "completed",
  "artifacts": [],
  "token_usage": {
    "usage_status": "available",
    "input_tokens": 1200,
    "output_tokens": 500
  }
}
```

`route-logs.jsonl` 记录路由决策：

```json
{
  "timestamp_compact": "20260616103000",
  "from_agent_type": "evaluation",
  "to_agent_type": "taskPerfect",
  "task_id": "task-001",
  "routing_decision": "route_to_taskPerfect",
  "reason": "evaluation 未通过，进入 superpowers planning。",
  "feedback_type": "negative",
  "counters": {
    "evaluation_loop": 1,
    "evaluation_loop_max": 5,
    "dev_retry": 0,
    "dev_retry_max": 3
  },
  "failure_reason": null
}
```

`task-state.json` 记录顶层任务和子任务状态：

```json
{
  "task_id": "task-001",
  "status": "completed",
  "failure_reason": null,
  "subtasks": [
    {
      "task_id": "task-001-1",
      "status": "completed",
      "dependencies": [],
      "acceptance_criteria": [
        "测试通过"
      ]
    }
  ]
}
```

`final-report.json` 是最终汇总：

```json
{
  "task_id": "task-001",
  "status": "completed",
  "failure_reason": null,
  "partial_completion": false,
  "completed_tasks": [
    "task-001-1"
  ],
  "unfinished_tasks": [],
  "workflow_artifacts": [
    {
      "artifact_type": "inspection_report",
      "path": "runs/current/artifacts/inspection-report.json",
      "status": "created",
      "summary": "技术检查报告。"
    },
    {
      "artifact_type": "verification_report",
      "path": "runs/current/artifacts/verification-report.json",
      "status": "created",
      "summary": "验收标准证据映射报告。"
    },
    {
      "artifact_type": "result_report",
      "path": "runs/current/artifacts/result-report.json",
      "status": "created",
      "summary": "最终结果验收报告。"
    }
  ],
  "prompt_intake_summary": {
    "primary_goal": "修复登录链路 bug",
    "acceptance_criteria": [
      "登录相关测试通过"
    ]
  },
  "openspec_context_summary": {
    "change_id": "fix-login-flow"
  },
  "inspection_summary": [],
  "verification_summary": {
    "pass": true,
    "missing_evidence": []
  },
  "result_summary": {
    "decision": "accept",
    "final_acceptance_score": 92
  },
  "token_usage_summary": [],
  "route_decisions": [],
  "runtime_context": {},
  "run_policy": {},
  "evaluation_gate": {
    "status": "passed",
    "allow_execution": true
  },
  "state_machine": {
    "status": "completed"
  }
}
```

## 常见失败 case

- `CASE_REQUIRED_ARTIFACT_MISSING`：agent 没有产出配置要求的 artifact。
- `CASE_DEPENDENCY_CYCLE`：`taskSplit.tasks` 中存在循环依赖。
- `CASE_EVALUATION_MAX_LOOP`：evaluation 和 taskPerfect 循环超过上限。
- `CASE_PROMPT_INTAKE_INCOMPLETE`：Prompt Intake 缺少必要字段。
- `CASE_OPENSPEC_NOT_INITIALIZED`：开发任务需要 OpenSpec，但目标项目缺少可用 OpenSpec 环境。
- `CASE_OPENSPEC_TASK_TRACE_MISSING`：子任务缺少 OpenSpec task 或 spec scenario trace。
- `CASE_VERIFICATION_EVIDENCE_MISSING`：verify gate 发现验收标准缺少真实证据。
- `CASE_RESULT_REJECTED`：result-agent 从用户或维护视角拒收结果。
- `CASE_ARCHIVE_BLOCKED_BY_RESULT`：result-agent 通过前尝试 sync/archive。
- `CASE_AGENT_ADAPTER_FAILED`：Claude CLI 或 adapter 调用失败。
- `CASE_INCOMPLETE_ROUTING_INPUT`：adapter 输出不是合法 JSON，或缺少 schema 必需字段。
- `failed_with_partial_completion`：部分子任务完成，但仍有子任务失败或未完成。

## 和 /loop 配合

可以让 Claude Code 周期性执行任务。

每 10 分钟继续优化：

```text
/loop 10m 继续优化 E:\data\ai\loop\super-loop-agents，优先修复真实 runner smoke、required artifacts、final-report 验收链路，完成后跑测试并汇报结果
```

每 30 分钟检查一次：

```text
/loop 30m 检查 E:\data\ai\loop\super-loop-agents 当前测试和 runner smoke 状态，发现问题就修复并跑全量测试
```

`/loop` 语法：

```text
/loop [interval] <prompt>
```

interval 支持：`Ns`、`Nm`、`Nh`、`Nd`，例如 `5m`、`30m`、`2h`、`1d`。不写 interval 时默认 10 分钟。

## 当前推荐命令

真实跑一次 Super Loop Agents：

```bash
node super-loop-agents/bin/super-loop.mjs start "继续优化 Super Loop Agents。要求：保持 required artifacts 严格校验，跑通全量测试，并在 final-report 中给出 prompt_intake、verification_report 和 result_report 证据。" --target E:\data\ai\loop \
  --runs-dir super-loop-agents/runs \
  --timeout-ms 600000
```

如果是在当前 Claude Code 会话里继续开发，可以直接说：

```text
继续优化 super-loop-agents，别反问，直接修问题、跑测试、给结果。
```

## 测试

运行全部测试：

```bash
node --test "super-loop-agents/test/*.test.mjs"
```

当前 README 记录的最近验证结果：

```text
tests 123
pass 123
fail 0
```