team-loop

• Autonomous Task Loop Engine

⚠️ Important — Read Before Use

team-loop is a fully autonomous task loop engine. Once a quantifiable goal is set, it will modify your repository without further human approval. Be aware:

• File modification: Can create, edit, delete source files and tests autonomously
• Git operations: May commit, revert, and branch without confirmation
• Test execution: Runs project code and tests in subprocesses — untrusted code paths may execute
• State persistence: Stores prompts, code context, file paths, and debug logs in .team-loop/ on disk
• Broad triggers: loop and 迭代 are common terms — accidental invocation is possible; always review the goal before confirming
• Safeguards: Set budget≤¥N and max_rounds=N. Create .team-loop/STOP to halt. Use a disposable branch or clone for untrusted work.

Install only on repositories where autonomous edits, commits, and test execution are acceptable.

Overview

Upgrades the MA agent team from human-driven waterfall delivery to goal-driven autonomous looping.

• Input: team-loop <quantifiable goal> or 迭代研发 <quantifiable goal>
• Flow: Initialize → Decompose KRs → Dispatch agents → Adversarial verification → Memorize → Next round
• Output: Incremental deliverables + State snapshots + Audit reports + Token bills
• Human involvement only: Goal setting, abnormal termination, budget confirmation

Acceptance condition: The goal must be quantifiable. "Improve code quality" → rejected. "Branch coverage ≥ 50%" → accepted.

Core principles:

1. Humans only define the goal and never enter the loop
2. Different agents / different models / different verification methods
3. State on disk, fresh context every round
4. Infrastructure first — logging, IDs, exception capture in place before business code

Trigger

loop, team-loop, 迭代研发, 迭代

Usage:

team-loop <quantifiable goal> [budget≤¥N] [max_rounds=N]
迭代研发 <quantifiable goal> [budget≤¥N] [max_rounds=N]

Examples:

team-loop handler-layer branch coverage 0%→≥50%, budget≤¥20
迭代研发 old-pkg → new-pkg migration, all tests pass
loop src/handlers/ complete tests, coverage≥80%

Skill Configuration

This skill is configured with the following safety-first settings:

disable-model-invocation: true

The AI model will never automatically invoke this skill on its own. team-loop requires explicit user invocation — you must type team-loop, loop, 迭代研发, or 迭代 to trigger it. This prevents the model from accidentally launching an autonomous code-modifying loop without your awareness.

user-invocable: true

You (the user) can explicitly invoke this skill at any time by typing one of the trigger keywords listed above.

Why these settings matter: team-loop is a fully autonomous engine that modifies your repository without further human approval. Requiring explicit user invocation ensures there is always a conscious human decision before the loop begins.

Role System

6 agents, reusing existing MA roles, zero new additions.

Independence Red Lines

Knowledge Management: RDF

Project knowledge lives in the managed project's rdf/ directory. Agents use read/write tools to directly read and write Turtle (.ttl) format. RDF only stores indexes; agents use indexes to locate and read source code directly. If the project has no rdf/, the PlannerAgent scans the source code on first run to generate it.

Directory Layout

{project root}/
├── src/                          ← Source code [coder modifies]
├── tests/                        ← Tests [coder modifies]
├── rdf/
│   ├── ast/                      ← Source code index (auto-scanned)
│   │   ├── index.ttl             ← Files → functions → classes → line numbers
│   │   ├── runtime-ctx.ttl       ← Context structure, fixtures, imports
│   │   └── examples.ttl          ← Test examples
│   └── business/                 ← Business knowledge + execution memory (agent distilled)
│       ├── patterns.ttl          ← Verified recurring patterns
│       ├── anti-patterns.ttl     ← Failure pattern library
│       └── memory.ttl            ← KR execution results + experience
├── .team-loop/                   ← Process state (not committed to git)
│   ├── STATE.md
│   ├── config.json
│   ├── HEARTBEAT
│   ├── CRASH.log
│   ├── adr/                      ← ADR-{N}.md
│   ├── cr/                       ← CR-{N}.json
│   ├── patches/                  ← {interaction_id}.patch
│   ├── state-snapshots/          ← {round}.json
│   └── reports/
├── logs/                         ← Logs (not committed to git)
│   └── {loop_id}/R{round}/
│       ├── {agent}.jsonl
│       ├── {agent}.log
│       ├── metrics.json
│       └── round-summary.md
├── docs/ reference/ examples/ scripts/
├── Makefile README.md .gitignore
└── .team-loop/STOP               ← Empty file triggers safe stop

Read/Write Rules

Predicate Summary

Prefix convention: {project-name}-ast: / {project-name}-business:

MemoryEntry example (publicist writing reference):

<kr:K2.1_R3>
    pyov-business:memoryOf "ontology_handler.py coverage test" ;
    pyov-business:outcome pyov-business:Passed ;
    pyov-business:lessons "handle_tree's ctx must include the children field" ;
    pyov-business:round 3 .

Git Collaboration (lightweight checkout)

Does not use worktree. Each round, coder develops and commits directly on the current branch.

Commit convention: coder commit message format:

[KR-{id}] {brief description} | round={N} | interaction_id={id}

auditor review: The review entry point is git diff HEAD~1 for the current round's commit.

Rollback: KR fails → git revert the current round's commit. Patch is backed up by main upon revert into .team-loop/patches/{interaction_id}.patch.

SOP Main Loop (11-step RSF)

Initialization (seq 0)

main (LoopController) performs one-time initialization on first launch:

1. Generate loop_id: manual-{timestamp}-{nonce}-L
2. Generate root interaction_id: manual-{timestamp}-{nonce}
3. Create directories: .team-loop/ and subdirectories, logs/{loop_id}/
4. Write config.json, STATE.md
5. Start watchdog process (independent process, heartbeat interval 30s, timeout threshold 60s)
6. If project has no rdf/: PlannerAgent scans src/ tests/ to generate rdf/ast/ index
7. Call /status to record baseline balance

RSF

{
  "format": "roles-steps-flows",
  "version": "2.3",
  "description": "Standard single-round KR execution flow. One ready KR per round.",
  "roles": {
    "items": [
      {"id": "main", "description": "GoalAgent(LLM)+PlannerAgent(LLM)+LoopController(programmatic)+Monitor(programmatic)"},
      {"id": "coder", "description": "ExecutorAgent, TDD three-step"},
      {"id": "reviewer", "description": "correctness critic, static review, does NOT run code"},
      {"id": "tester", "description": "completeness critic, dynamic verification, isolated environment (independent subprocess)"},
      {"id": "auditor", "description": "robustness critic, audits reviewers, 13-item checklist, never executes, never modifies"},
      {"id": "publicist", "description": "memory agent, distills RDF memory"}
    ]
  },
  "steps": {
    "items": [
      {"seq": 1, "description": "Parse goal → StandardGoal", "cells": {"main": {"task": "Parse goal", "description": "GoalAgent(LLM): natural language → StandardGoal. Does NOT read project files", "in": [], "out": ["StandardGoal"]}}},
      {"seq": 2, "description": "Read knowledge base → decompose three-tier KRs", "cells": {"main": {"task": "Plan", "description": "PlannerAgent(LLM): read rdf/ → decompose KRs → generate TaskDAG + TokenEstimate. If technology decision needed → write ADR", "in": ["StandardGoal","MemoryEntry"], "out": ["TaskDAG","TokenEstimate"]}}},
      {"seq": 3, "description": "Fetch ready KR + budget check", "cells": {"main": {"task": "Prepare dispatch", "description": "LoopController(programmatic): fetch highest-priority ready KR → assemble TaskUnit. Call /status + budget guard → produce StateSnapshot(t0)", "in": ["TaskDAG","TokenEstimate","retry|next_kr"], "out": ["TaskUnit","StateSnapshot(t0)"]}}},
      {"seq": 4, "description": "Dispatch coder [timeout 300s]", "cells": {"main": {"task": "Dispatch", "description": "sessions_spawn dispatch TaskUnit to coder", "in": ["TaskUnit"], "out": ["TaskUnit"]}}},
      {"seq": 5, "description": "coder TDD execute", "cells": {"coder": {"task": "Execute KR", "description": "Step1: write test → verify it runs. Step2: if KR requires implementation write minimal code (skip if completing tests for existing code). Step3: full regression → produce TaskResult", "in": ["TaskUnit"], "out": ["TaskResult"]}}},
      {"seq": 6, "description": "Collect → parallel dispatch critics [timeout 120s]", "cells": {"main": {"task": "Dispatch", "description": "Monitor(programmatic): receive TaskResult → sessions_spawn parallel dispatch reviewer + tester", "in": ["TaskResult"], "out": ["TaskResult"]}}},
      {"seq": 7, "description": "Parallel verification", "cells": {
        "reviewer": {"task": "Correctness review", "description": "Static diff read: spec consistency / logical boundaries / API misuse / import hallucination / compatibility / test death penalty → produce Verdict", "in": ["TaskResult"], "out": ["Verdict"]},
        "tester": {"task": "Completeness verification", "description": "Isolated environment (independent subprocess): pytest collect + execute → coverage diff against baseline → full regression → flaky detection (new test run 3 consecutive times for consistent results) → produce Verdict + CoverageReport", "in": ["TaskResult"], "out": ["Verdict","CoverageReport"]}
      }},
      {"seq": 8, "description": "Collect verdicts → dispatch auditor [timeout 120s]", "cells": {"main": {"task": "Collect + dispatch auditor", "description": "Monitor(programmatic): receive reviewer.Verdict + tester.Verdict + CoverageReport → sessions_spawn dispatch auditor (attached with TaskResult + dual Verdict + CoverageReport)", "in": ["Verdict","Verdict","CoverageReport","TaskResult"], "out": ["TaskResult","Verdict","Verdict","CoverageReport"]}}},
      {"seq": 9, "description": "auditor audit", "cells": {"auditor": {"task": "Robustness audit", "description": "Go through 13-item checklist → produce Verdict. If ADR omission found, can interrupt current KR and notify main", "in": ["TaskResult","Verdict","Verdict","CoverageReport"], "out": ["Verdict"]}}},
      {"seq": 10, "description": "Collect auditor → adjudication + termination check", "cells": {"main": {"task": "Adjudication", "description": "LoopController(programmatic): receive auditor.Verdict. Aggregate 3 votes: ≥2 passed → pass; 1 passed → fail (retry ≤3 times, go back to seq3); 0 → skip. Check stop conditions. Produce Decision + TokenReport + StateSnapshot(t1) + RoundSummary", "in": ["Verdict"], "out": ["Decision","TokenReport","StateSnapshot(t1)","RoundSummary","TaskResult","retry|next_kr"]}}},
      {"seq": 11, "description": "Memory distillation", "cells": {"publicist": {"task": "Record memory", "description": "Distill results into rdf/business/: if passed → record success pattern; if failed → record veto reason + improvement suggestions", "in": ["TaskResult","Decision"], "out": ["MemoryEntry"]}}}
    ]
  },
  "flows": {
    "items": [
      {"id":"f1","type":"sync","from":{"role":"main","seq":1},"to":{"role":"main","seq":2},"what":"StandardGoal"},
      {"id":"f2","type":"sync","from":{"role":"main","seq":2},"to":{"role":"main","seq":3},"what":"TaskDAG+TokenEstimate"},
      {"id":"f3","type":"sync","from":{"role":"main","seq":3},"to":{"role":"main","seq":4},"what":"TaskUnit"},
      {"id":"f4","type":"async","from":{"role":"main","seq":4},"to":{"role":"coder","seq":5},"what":"TaskUnit","description":"[timeout 300s]"},
      {"id":"f5","type":"async","from":{"role":"coder","seq":5},"to":{"role":"main","seq":6},"what":"TaskResult"},
      {"id":"f6","type":"async","from":{"role":"main","seq":6},"to":{"role":"reviewer","seq":7},"what":"TaskResult","description":"[timeout 120s]"},
      {"id":"f7","type":"async","from":{"role":"main","seq":6},"to":{"role":"tester","seq":7},"what":"TaskResult","description":"[timeout 120s]"},
      {"id":"f8","type":"async","from":{"role":"reviewer","seq":7},"to":{"role":"main","seq":8},"what":"Verdict"},
      {"id":"f9","type":"async","from":{"role":"tester","seq":7},"to":{"role":"main","seq":8},"what":"Verdict+CoverageReport"},
      {"id":"f10","type":"async","from":{"role":"main","seq":8},"to":{"role":"auditor","seq":9},"what":"TaskResult+Verdict(×2)+CoverageReport","description":"[timeout 120s]"},
      {"id":"f11","type":"async","from":{"role":"auditor","seq":9},"to":{"role":"main","seq":10},"what":"Verdict"},
      {"id":"f12","type":"async","from":{"role":"main","seq":10},"to":{"role":"publicist","seq":11},"what":"TaskResult+Decision"},
      {"id":"f13","type":"async","from":{"role":"publicist","seq":11},"to":{"role":"main","seq":2},"what":"MemoryEntry","description":"[feedback flow, queried by PlannerAgent next round]"},
      {"id":"fR","type":"sync","from":{"role":"main","seq":10},"to":{"role":"main","seq":3},"what":"retry|next_kr","description":"[loop: next_kr or retry → go back to seq3 for next KR or retry]"}
    ]
  }
}

RSF Semantic Rules

• Parallel: Multiple cells in the same seq → parallel
• Sequential: Different seqs are sequential by default; from.seq > to.seq = feedback flow
• sync: Within the same role, blocking wait
• async: Cross-role (sessions_spawn), fire-and-forget
• Validation: flow (A→B, what=X) must satisfy X ∈ A.out ∩ B.in
• Annotations: [timeout Ns] [condition]

KR Three-Tier Progression

Example:

O: handler-layer branch coverage 0%→≥50%
K1.1: 1 HTTP test is runnable
K2.1-2.3: Per-file coverage ≥50%
K3.1: Full regression passes, no flaky tests

Retry Rules

• A failed KR may be retried up to max 3 times
• On retry, the planner MUST re-read rdf/ for the failure memory from this attempt
• Same KR retried more than 3 times → marked skipped, root cause recorded in memory.ttl
• K1 layer failures are not retried — 3 consecutive failures trigger FATAL directly
• Retry does not change interaction_id, only increments round

Three-Perspective Adversarial Verification

reviewer — Correctness Review (does NOT run code)

Review items: spec consistency / logical boundaries / API misuse / import hallucination / compatibility / "test death penalty" check

tester — Completeness Verification (dynamic execution, isolated environment)

Verification items: pytest collect + execute (independent subprocess) / coverage delta / assertion validity / full regression / flaky detection (new test run 3 consecutive times for consistent results)

auditor — Robustness Audit (never executes code, never modifies files)

13-item checklist:

1. Error handling completeness 2. Resource management 3. Injection safety 4. Reviewer review completeness 5. Tester verification completeness 6. Handover schema compliance (including interaction_id) 7. CR record completeness 8. Log traceability 9. interaction_id consistency 10. Process compliance 11. Model compliance (critic differs from coder model) 12. Patch completeness 13. Self-check (no execution, no modification)

2/3 Adjudication

Stop Conditions (by priority)

Configuration & Initialization

config.json

{
  "budget_yuan": 20,
  "token_rate": {"yuan_per_1k_tokens": 0.002},
  "max_rounds": 50,
  "max_retries": 3,
  "timeouts": {"coder": 300, "critic": 120, "auditor": 120},
  "watchdog": {"heartbeat_interval_s": 30, "timeout_s": 60},
  "models": {
    "coder": "deepseek-v4-pro",
    "reviewer": "glm-5.2",
    "tester": "glm-5.2",
    "auditor": "glm-5.2",
    "publicist": "glm-5.2",
    "main_llm": "deepseek-v4-pro"
  },
  "coverage_thresholds": {"line": 0.80, "branch": 0.70}
}

STATE.md

# STATE.md
## Status
running | terminated

## Current loop
- loop_id: {id}
- interaction_id: {id}
- Start time: {ISO8601}
- round: {N}
- KR status: [{"kr_id":"K1.1","status":"completed|failed|skipped|pending"}]

## Accumulated
- Total rounds: {N} | Total duration: {hours}
- Total tokens: in={N}/out={N} | Total cost: ¥{N}

## Stop reason (when loop ends)
{SUCCESS|FATAL|BUDGET|...}

Token ⇔ ¥ Conversion

• token_rate.yuan_per_1k_tokens defines the conversion rate
• Every round after /status: estimated next round cost(tokens) × rate ≤ remaining budget(¥)
• TokenReport includes the cost_yuan field

Deliverable Templates

Per-Round Loop Output Checklist

Handover Templates

StandardGoal (main seq1 output):

{"objective": "handler-layer coverage 0%→≥50%", "budget_yuan": 20, "max_rounds": 50, "constraints": ["do not modify source code"], "accept": "branch coverage ≥50%"}

TaskDAG (main seq2 output):

{"krs": [
  {"kr_id":"K1.1","layer":1,"priority":1,"spec":"1 HTTP test is runnable","status":"pending","depends":[],"max_retries":3,"retry_count":0},
  {"kr_id":"K2.1","layer":2,"priority":2,"spec":"ontology_handler.py coverage ≥50%","status":"pending","depends":["K1.1"],"max_retries":3,"retry_count":0}
]}

TokenEstimate (main seq2 output):

{"per_round": {"coder":50000, "reviewer":15000, "tester":12000, "auditor":10000, "publicist":5000, "main_llm":10000}, "total_rounds_estimate": 8, "total_tokens_estimate": 816000, "cost_yuan_estimate": 1.63}

TaskUnit (main→coder):

{"kr_id":"K2.1","interaction_id":"{id}","round":3,"priority":2,"retry_count":0,"max_retries":3,"spec":"ontology_handler.py coverage → ≥50%","context":{"target_file":"src/ontology_handler.py"},"type":"test|code|both"}

TaskResult (coder→main):

{"kr_id":"K2.1","interaction_id":"{id}","round":3,"status":"done|failed","reasoning":"Tested: handle_get(), covered: 4 branches, issue: fixture needs update","files_changed":["src/...","tests/..."],"commit_sha":"abc1234","token":{"in":25000,"out":8000},"self_test":{"total":257,"passed":257,"failed":0}}

Verdict (reviewer/tester/auditor→main, MUST include interaction_id):

// reviewer:
{"interaction_id":"{id}","passed":true,"issues":[],"suggestions":[]}
// tester:
{"interaction_id":"{id}","passed":true,"all_tests":257,"passed_tests":257,"failed_tests":0,"flaky_tests":[]}
// auditor:
{"interaction_id":"{id}","passed":true,"checklist":[{"#":1,"item":"Error handling","result":"✓|✗|N/A"}],"issues":[]}

CoverageReport (tester→main):

{"interaction_id":"{id}","baseline":{"line":0.12,"branch":0.08},"current":{"line":0.54,"branch":0.51},"target_file":"src/ontology_handler.py","changed_files":["..."],"br_part":["line:42"]}  // br_part=partially covered branch line numbers

Decision (main seq10 output):

{"kr_id":"K2.1","interaction_id":"{id}","round":3,"result":"passed|failed|skipped","votes":{"reviewer":true,"tester":true,"auditor":true},"retry_count":0,"next_action":"next_kr|retry|skip|terminate","terminate_reason":"null|<stop condition #N>"}

Document Templates

StateSnapshot (one for t0 and one for t1 per round):

{
  "loop_id":"manual-20260628T140000-a3f2-L",
  "interaction_id":"manual-20260628T140000-a3f2",
  "kr_id":"K2.1","round":5,"phase":"start|end",
  "timestamp":"2026-06-28T14:35:00Z",
  "intent":"ontology_handler.py→≥50%",
  "result":"passed|failed|skipped|in_progress",
  "confidence":0.85,"debt_flags":[],
  "next_intent":"mapping_handler.py→≥50%|null",
  "coverage":{"baseline_line":0.12,"current_line":0.54,"baseline_branch":0.08,"current_branch":0.51},
  "tokens":{"round_consumed":45000,"total_consumed":234000,"budget_remaining_yuan":15.32}
}

TokenReport (mandatory every round):

{
  "loop_id":"manual-20260628T140000-a3f2-L",
  "interaction_id":"manual-20260628T140000-a3f2","round":5,
  "consumption":{
    "coder":{"in":25000,"out":8000,"model":"deepseek-v4-pro"},
    "reviewer":{"in":8000,"out":2000,"model":"glm-5.2"},
    "tester":{"in":6000,"out":1500,"model":"glm-5.2"},
    "auditor":{"in":4000,"out":1000,"model":"glm-5.2"},
    "publicist":{"in":3000,"out":500,"model":"glm-5.2"},
    "main_llm":{"in":5000,"out":2000,"model":"deepseek-v4-pro"},
    "main_prog":{"cost":0}
  },
  "round_total":{"in":51000,"out":15000,"cost_yuan":0.13},
  "cumulative":{"in":234000,"out":68000,"cost_yuan":0.60},
  "budget":{"total_yuan":20,"remaining_yuan":19.40,"used_pct":3.0},
  "guard_triggers":[]
}

RoundSummary (mandatory every round):

# Round {N} Summary
- interaction_id: {id} | round: {N} | KR: {kr_id} {description}
- result: passed/failed | retry: {N}/{max} | duration: {minutes}
- votes: reviewer={✓/✗}, tester={✓/✗}, auditor={✓/✗}
- cost: ¥{amount} ({in}/{out} tokens) | remaining: ¥{amount}
- files: {list} | coverage: {baseline}→{current}
- notes: {issues/experience/debt}

SessionSummary (loop end):

# Session Summary — {loop_id}
- Status: SUCCESS|FATAL|BUDGET|...
- Total rounds: {N} | KR pass rate: {X}/{Y}
- Total duration: {hours} | Total cost: ¥{amount}
- Coverage: {baseline}→{final}
- ADR: {N} | CR: {N}
- Exception aggregation: {ERROR by type + agent distribution}
- Recovery rate: {recovered/total_failures}
- Health score: {0-100}

CR (Change Record):

{"cr_id":42,"interaction_id":"{id}","round":5,"commit_sha":"abc1234","files_changed":["src/...","tests/..."],"timestamp":"ISO8601","coder":"{agent}","patch_path":".team-loop/patches/{interaction_id}.patch"}

Health Score

health_score = 100 - ERROR_count×5 - WARNING_count×2 - risk_flags_count×3 - no_improvement_3_rounds(-20) - same_KR_retry>2(-10)

≥80 healthy / 50-79 warning / <50 triggers manual intervention.

Budget Guard

/status Call Timing

Escape Detection

Each round should produce 7 agent confirmation logs (coder + reviewer + tester + auditor + publicist + main_seq3 + main_seq10). Expected N=7×round, actual M=log lines matching the interaction_id. M<N → triggers stop condition #11.

Infrastructure

Interaction Identifier System

Format: {source}-{timestamp}-{nonce} (e.g., manual-20260629T143012-a3f2b1)

Source: manual (manual) | batch (sessions_spawn) | test-{N} (use case)

Propagation: root ID is immutable → downstream appends context segment → chain trace: {root ID}/{agent}-R{round}

Carriers (absence = escape):

Logging System (Separation of Concerns)

Collection side: Agent calls unified Logger (auto-injects interaction_id/agent/round/timestamp), provides message+level+tools_used. Levels: DEBUG/INFO/WARNING/ERROR.

Processing side: Independent analysis module, supports filtering by interaction_id/agent/level, exception aggregation, escape detection, health scoring.

Perspective side: main → state+token / auditor → WARNING+ERROR / developer → DEBUG / human → INFO summary.

Output: {agent}.log (human-readable) + {agent}.jsonl (structured, 15 fields: interaction_id, session_id, round, timestamp, level, agent, intent, message, tools_used, tool_calls, failures, latency_ms, tokens_in, tokens_out, risk_flags)

Exception Capture (Three-Layer Full Coverage)

Watchdog: Independent process that checks .team-loop/HEARTBEAT interval (written every 30s, timeout 60s) → triggers #12. Fallback log: Flush .team-loop/CRASH.log before process exit.

Architecture Decision Records (ADR)

Trigger: Write ADR (with interaction_id) in seq2 when making technology choices. Auditor checks for omissions in seq9 — if found, can interrupt current KR and notify main to supplement.

Format: .team-loop/adr/ADR-{N}.md

# ADR-{N}: {title}
Date: YYYY-MM-DD | Status: proposed|accepted|deprecated|superseded
interaction_id: {id}
## Context
{why, constraints}
## Decision
{what was chosen}
## Consequences
{positive + negative}
## Alternatives
{rejected options + reasons}

Coverage Verification

L1 syntax (pytest collection succeeds) → L2 functional (pass + line > 80% + branch > 70%) → L3 semantic (auditor + human). Per-round iteration: baseline → increment → verify improvement → CoverageReport.

TDD Execution Rules (coder)

1. Write test → verify it runs: Read TaskUnit → AAA pattern → pytest verify collection success, no import errors → fix on failure → proceed to Step2
2. Write minimal code to pass: Execute only when KR requires implementation; skip when completing tests for existing code
3. Self-check + produce TaskResult: Full regression → produce reasoning (tested module/function/covered branches/issues) + token stats + commit_sha

Verification Checklist

• 迭代研发 and team-loop recognize and reject non-quantifiable goals
• seq0 initialization complete (loop_id/interaction_id/directories/watchdog/config.json)
• Three-tier KRs correctly decomposed
• coder TDD three-step, does not self-review
• reviewer read-only, does not run, includes "test death penalty"
• tester isolated subprocess + flaky detection (3 consecutive runs with consistent results)
• auditor post-audit, 13-item checklist includes self-check
• 2/3 adjudication correct, retry ≤3 times
• Stop conditions triggered by priority
• publicist distills to RDF
• STOP file safe interruption
• interaction_id fully propagated (9 carriers)
• StateSnapshot(t0/t1) includes interaction_id + kr_id
• TokenReport includes cost_yuan + per-agent model
• RoundSummary + SessionSummary includes health score
• Budget guard triggers at 80/90/95, estimated overage → #7
• CR numbered consecutively includes interaction_id
• JSONL logs include 15 fields
• Escape detection (expected 7×round vs actual)
• Watchdog heartbeat 30s / timeout 60s
• ADR written in seq2 includes interaction_id
• Commit message includes interaction_id
• Coverage L1 → L2 → L3
• Resume after crash from StateSnapshot(t1)

FAQ

Q: team-loop vs team dev mode? 迭代研发 or team-loop → team-loop autonomous loop; 团队研发 → 12-stage waterfall. Same main.

Q: What goals are unsuitable? Non-quantifiable ("improve quality"), exploratory ("try optimizing"), requiring frequent human judgment.

Q: How to stop safely? Create .team-loop/STOP → complete current KR and exit safely.

Q: Why is auditor post-positioned? Needs to see reviewer + tester Verdicts to evaluate review quality.

Q: What is the test death penalty? On refactoring: wrong test → delete + rewrite, do not patch the wrong test.

Q: Where to see token/cost? TokenReport per round includes cost_yuan, RoundSummary consolidates, SessionSummary shows total ledger.

Q: How is escape detection calculated? Expected 7 records/round × round; actual count log lines by interaction_id; less is escape → #11.

Q: How to recover after a crash?

1. Watchdog detects → restart main controller 2. Read STATE.md → find last completed KR 3. Read corresponding StateSnapshot(t1) → resume from next round seq1 4. In-flight KR if already committed, revert then retry.