@@ -2,7 +2,7 @@
 
 <!-- verified-against: 2026-09-30 -->
 
-`设计：/data/zhoutaichang/copilot/meta-improvement-engine-design.md v1（GPT-6 sol 批准 2026-09-29） · refactor-status: building (P0–P1 已落地)`
+`设计：/data/zhoutaichang/copilot/meta-improvement-engine-design.md v1（GPT-6 sol 批准 2026-09-29） · refactor-status: building (P0–P2 已落地)`
 
 ## 职责
 面向任意 trace/1 工作流的"取证—实验—提案"循环。**只提案**：引擎的写权限限于追加自己的 trace/1 记录、
@@ -19,18 +19,27 @@
 | `lints.py` | P1 | Tier 1 的 17 条确定性 lint（L01–L17，每条带版本与出处）；`Baseline` 稳健 z（MAD 下限 = 中位数的 10%）；L13 隔离 |
 | `ledger.py` | P1 | 每工作流 JSON 账本：周期统计、基线样本、提案状态机（open → experiment-registered → supported/neutral/refuted/underpowered → landed/closed；30 天无人触碰 → stale）、hold、通道活性；每次变更同时写 `decision` |
 | `cycle.py` | P1 | 周期：preflight（`improve_enabled` 是 kill switch）→ lints + 基线 → 账本 + Tier 1 提案（lint 恶化 ≥1.5× 且 ≥3 单元）→ stale 清扫 → 报告（`reports/cycle-*.md/json`）+ `decision(type=cycle)`；`is_due`/`maybe_run_weekly` 是周度槽位 |
-| `cli.py` | P0/P1 | `improve migrate-index|rebuild-index|rollback-index|compare-index|verify-index|cycle|ledger|lints` |
+| `adapters/__init__.py` | P2 | 结果适配器契约：金标矩阵（`match()` → recall 与阶段归因）与 finding 级有效性（`findings()` → precision）两个数据模型不混用；评审级判官分数（`review_scores()`）原样保留；`scores_from` 给每个数字标来源 |
+| `gold.py` | P2 | 策展金标集：`gold_id = sha256(item+path+规范化 concern)[:12]`，`draft` 由原始评论生成、只有 `curated` 才被使用，改措辞即新条目，文件 sha 即版本 |
+| `judges.py` | P2 | `run_judge`：API 判官走 `LLM.create`，CLI 判官走 `governed_subprocess`（预留判官次数、无工具、空工作区、流中出现工具调用即作废），都写 `model_call` |
+| `stats.py` | P2 | 配对、按 item 聚类的 t 区间（移植 `paired_analysis.py`）、所需 item 数、五种标签、Cohen κ |
+| `adapters/review_eval.py` | P2 | eval 评审适配器：导入 `judge_val` 配对 verdict 为 `judge_verdict` outcome；`gold_match` 判官（3 票多数、hit 须逐字引用）写 `gold_match` outcome；`match()` 只读记录 |
+| `adapters/rb_review.py` | P2 | RB 生产适配器：PR 线程代理标签（accepted/disputed/silent）→ finding 级有效性，`descriptive_only`，无金标、不注册实验 |
+| `forensics.py` | P2 | 覆盖矩阵（确定性）、S0–S10 阶段分类法、取证 agent（只读 trace 工具、全部输出围栏为不可信数据、必须引用记录 id）、双家族交叉复核（不一致 = disputed）、整改清单、测量健康 |
+| `meta.py` | P2 | 冻结元基准：`eval/dataset/meta/cases`（trace + 人工阶段标签）与 `meta/lints`（注入缺陷样本）的导出与加载 |
+| `cli.py` | P0–P2 | `improve migrate-index|rebuild-index|rollback-index|compare-index|verify-index|cycle|ledger|lints|gold draft/check|meta lint-check` |
 
 ## 接入点
 - 执行器：`settings.trace_store_root` 非空时绑定 store 并为每步绑定单元上下文；`settings.improve_shadow` 下拒绝非 read/report 步骤。
 - `tools.dispatch` / `LLM.create` / `HarnessLLM.create` / `run_harness_step` / MCP bridge：全保真采集。
 - `kb serve` 调度器：每 tick 调 `_improve_cycle()`，周度槽位到达即跑一次周期（与知识服务同一租约、异常隔离）。
-- 任务种类 `workflow_improve`（L2，READ_ONLY_KINDS）；playbook `workflow-improve`（preflight → lint → ledger → report）。
+- 任务种类 `workflow_improve`（L2，READ_ONLY_KINDS）；playbook `workflow-improve`（preflight → lint → forensics → ledger → report）。
+- `improve.forensics` 步骤：对每个有结果适配器的工作流建覆盖矩阵、用两个模型家族归因每个 miss、产出整改清单；单元数低于 `tier2_min_items` 或无 LLM 时跳过并说明。
 
 ## 不变量
 - P1 周期永远 dry-run：提案只在账本与 trace 里，不上 GitHub（P4）。
 - 引擎自身的记录（`playbook=workflow-improve`）是下一周期的 Tier 1 单元（自登记）。
 - lint 只读 trace，不调模型；无证据形态的 lint 不猜。
 
 ## 测试
-`test_improve_p0.py`、`test_improve_p0b.py`、`test_improve_p1.py`。
+`test_improve_p0.py`、`test_improve_p0b.py`、`test_improve_p1.py`、`test_improve_p2.py`。
@@ -0,0 +1,18 @@
+# The frozen meta-benchmark (meta-improvement engine, design §11.2)
+
+What the engine is measured against and may only READ. Changed by human pull
+requests only; a self-experiment whose fingerprint diff touches this directory
+is refused at registration.
+
+- `cases/<case>/` — one historical forensics case: `records.jsonl` (the unit's
+  trace/1 records), `blobs/` (the blobs they reference), `gold.json` (the
+  curated gold for the item), `case.json` (`item`, `workflow`, `unit_id`, and
+  `labels`: the HUMAN stage-of-loss label per missed gold entry, S0–S10).
+  Created with `improve.meta.export_case` after a human labels the cell.
+- `lints/<L##>/<name>.jsonl` — a unit that must trigger exactly that Tier 1
+  lint (`infermatrix-copilot improve meta lint-check`).
+
+The historical campaigns (T3, wave-2, wave-3) left narrative reports, not
+per-cell labels; the cases here are labelled fresh against the traces (design
+§6.1, P2). Labels are the benchmark, never the report text, so an investigator
+cannot recite them.
@@ -14,6 +14,7 @@ params: {}
 steps:
   - {id: preflight, step: improve.preflight}
   - {id: lint, step: improve.lint}
+  - {id: forensics, step: improve.forensics}
   - {id: ledger, step: improve.ledger}
   - {id: report, step: report.final_summary}
 success: one cycle recorded (decision type=cycle), the per-workflow ledgers
 
@@ -569,6 +569,19 @@ def _parse_mixture(cls, v):
     # the hard weekly envelope (P3 enforces it per model call)
     improve_budget_usd_week: float = 20.0
     improve_budget_judge_calls_week: int = 300
+    # the eval review adapter's inputs (design §6.1): the GT directory holding
+    # gt/curated/<item>.gold.json, the judgment sets, and the arm name whose
+    # verdicts belong to this copilot's units
+    improve_gt_dir: str = ""
+    improve_judgments_dir: str = ""
+    improve_eval_arm: str = ""
+    # the gold_match judge: "api:<model>" (through LLM.create) or
+    # "cli:<provider>:<model>" (cursor|claude|codex, tool-less); empty = no
+    # gold matching, cells stay unlabeled
+    improve_judge: str = ""
+    # the review bot's GitHub login, so its own replies never count as the
+    # author accepting or disputing a finding
+    improve_rb_bot_login: str = ""
 
     # Metrics (eval/METRICS_RESEARCH.md) — per-run metrics.json: CATQ = Q·S/C.
     # Reference budgets are EXPLICIT deployment assumptions (RQS3e precedent):
 
@@ -264,22 +264,56 @@ async def _run_step(self, spec, params: dict, state: dict, item,
                 last = StepResult(False, FailureKind.BLOCKED,
                                   f"unhandled error: {type(exc).__name__}: {exc}")
             if last.ok or last.failure is not FailureKind.RETRYABLE:
+                self._record_step_decision(spec, unit, attempt, last)
                 return last
             self.trace.record("step_retry", spec=spec.name, attempt=attempt)
+        self._record_step_decision(spec, unit, attempts, last)
         return last  # exhausted retries
 
+    @staticmethod
+    def _record_step_decision(spec, unit: dict, attempt: int, result: StepResult | None) -> None:
+        """The unit's terminal ``decision`` record (trace/1): every step call
+        ends with one, carrying the rendered artifact a reviewer or judge
+        would see (`review_text`, `answer_draft`) and the published findings,
+        so an outcome adapter judges what was actually produced — never an
+        empty body. Written only when a store is bound; never raises."""
+        from ..trace_store import current_store, trace_context
+
+        store = current_store()
+        if store is None or result is None:
+            return
+        outputs = result.outputs or {}
+        blobs: dict[str, str] = {}
+        for key, name in (("review_text", "review"), ("answer_draft", "answer"), ("report_text", "report")):
+            text = outputs.get(key)
+            if isinstance(text, str) and text.strip():
+                blobs[name] = text
+        findings = []
+        for f in (outputs.get("review_comments") or [])[:60]:
+            if isinstance(f, dict):
+                findings.append({k: (str(f[k])[:200] if isinstance(f.get(k), str) else f.get(k))
+                                 for k in ("id", "file", "path", "line", "severity", "comment", "title", "disposition")
+                                 if k in f})
+        try:
+            with trace_context(attempt=attempt, **unit):
+                store.append("decision", outputs=blobs,
+                             result={"type": "step_result", "step": spec.name, "status": "ok" if result.ok else "failed",
+                                     "failure": result.failure.value if result.failure else "",
+                                     "summary": str(result.summary or "")[:300],
+                                     "findings": findings, "verdict": str(outputs.get("review_verdict") or "")})
+        except Exception:  # noqa: BLE001 - capture never changes a step's outcome
+            pass
+
 
     # -- trace/1 unit context ---------------------------------------------------
     def _declarations(self) -> dict:
         """Workflow declarations, loaded once per executor (a malformed file is a
         loud configuration error, never a silent Tier 1 downgrade)."""
         cached = getattr(self, "_decls", None)
         if cached is None:
-            from ..improve.enroll import load_declarations
+            from ..improve.enroll import declarations_for
 
-            extra = [d for d in (getattr(self.settings, "improve_workflows_dirs", "") or "")
-                     .split(os.pathsep) if d.strip()]
-            cached = load_declarations(extra)
+            cached = declarations_for(self.settings)
             self._decls = cached
         return cached
 
 
@@ -128,3 +128,155 @@ async def _ledger_summary(ctx: StepContext) -> StepResult:
                      f"{len(open_)} live proposal(s)" + (f", HOLD: {wl.hold}" if wl.hold else ""))
     summary = "\n".join(lines) or "no workflows in the ledger yet"
     return StepResult(True, summary=summary[:400], outputs={"ledger_summary": summary})
+
+
+def _forensics_agents(ctx: StepContext) -> dict:
+    """Two investigator families from the configured tiers (eco and, when
+    configured, performance); one family only when that is all there is —
+    the report then says `single_family`."""
+    from ...agent_loop import run_agent
+
+    if ctx.llm is None or not getattr(ctx.llm, "available", False):
+        return {}
+    agents = {}
+    for mode in ("eco", "performance"):
+        try:
+            target = ctx.settings.tier_target(mode)
+        except Exception:  # noqa: BLE001 - an unconfigured tier is simply absent
+            continue
+        family = f"{target.provider_id or target.source}:{target.model}"
+        if family in agents:
+            continue
+        llm = ctx.llm.for_target(target) if hasattr(ctx.llm, "for_target") else ctx.llm
+
+        def make(llm_=llm, model_=target.model):
+            def agent(system, prompt, scope, extra_tools, max_iters):
+                return run_agent(llm_, system=system, prompt=prompt, scope=scope, trace=ctx.trace,
+                                 model=model_, max_iters=max_iters, extra_tools=extra_tools).text
+            return agent
+        agents[family] = make()
+    return agents
+
+
+@step("improve.forensics", "agent", "read",
+      "Tier 2: coverage matrices + stage-of-loss attribution for workflows with an outcome adapter.")
+async def _forensics(ctx: StepContext) -> StepResult:
+    """For each Tier 2 workflow in the last cycle's window: import outcomes,
+    build the gold × unit matrix, attribute every miss with two agent
+    families, rank the punch list. Params: `workflow` (restrict), `max_cells`.
+    Publishes `improve_forensics` (punch lists + measurement health)."""
+    from ...improve.adapters import load_adapter
+    from ...improve.enroll import declarations_for
+    from ...improve.forensics import attribute, coverage_matrix, measurement_health, punch_list, unit_scores
+    from ...improve.reader import collect_units
+    from ...trace_store import bind_store, trace_context
+
+    store = _trace_store(ctx)
+    if store is None:
+        return StepResult(False, FailureKind.BLOCKED, "no trace store (set TRACE_STORE_ROOT)")
+    cycle = ctx.state.get("improve_cycle") or {}
+    since, until = cycle.get("since"), cycle.get("until")
+    if since is None or until is None:
+        return StepResult(False, FailureKind.BLOCKED, "improve.forensics needs the cycle window (run improve.lint first)")
+    only = str(ctx.params.get("workflow") or "")
+    decls = declarations_for(ctx.settings)
+    agents = _forensics_agents(ctx)
+    results: dict = {}
+    with bind_store(store), trace_context(playbook="workflow-improve", run_id=ctx.run_dir.name):
+        units, _ = collect_units(store, float(since), float(until))
+        for name, decl in decls.items():
+            if not decl.tier2 or (only and name != only):
+                continue
+            wf_units = [u for u in units.values() if u.workflow == name]
+            if len(wf_units) < decl.tier2_min_items and not ctx.params.get("force"):
+                results[name] = {"skipped": f"{len(wf_units)} units < tier2_min_items {decl.tier2_min_items}"}
+                continue
+            adapter = load_adapter(decl.outcome_adapter, **_adapter_kwargs(ctx, decl))
+            collected = _collect_outcomes(ctx, adapter, wf_units, store)
+            outcomes: dict = {}
+            cells, golds = coverage_matrix(adapter, wf_units, store, outcomes=outcomes)
+            scored = unit_scores(adapter, wf_units, outcomes, golds)
+            entry: dict = {"units": len(wf_units), "cells": len(cells), "collected": collected,
+                           "outcomes": len(outcomes), "finding_labels": scored["findings"],
+                           "scores": scored["units"],
+                           "misses": sum(1 for c in cells if c.status == "miss"),
+                           "unlabeled": sum(1 for c in cells if c.status == "unlabeled"),
+                           "descriptive_only": bool(getattr(adapter, "descriptive_only", False)),
+                           "families": sorted(agents), "single_family": len(agents) < 2}
+            if cells and agents:
+                attributions = attribute(store, {u.unit_id: u for u in wf_units}, golds, cells, agents=agents,
+                                         max_cells=int(ctx.params.get("max_cells") or 40))
+                entry["punch_list"] = punch_list(attributions, golds, {u.unit_id: u for u in wf_units})
+                entry["measurement"] = measurement_health(attributions)
+            elif cells and not agents:
+                entry["skipped"] = "no LLM configured for the forensics agents"
+            results[name] = entry
+    ctx.state["improve_forensics"] = results
+    done = [n for n, r in results.items() if "punch_list" in r]
+    return StepResult(True, summary=f"forensics: {len(done)} workflow(s) attributed, "
+                                    f"{sum(1 for r in results.values() if 'skipped' in r)} skipped",
+                      outputs={"forensics": results, "state_updates": {"improve_forensics": results}})
+
+
+def _adapter_kwargs(ctx: StepContext, decl) -> dict:
+    """Construction arguments per adapter, from settings/params (never
+    secrets): the eval adapter needs the GT and judgment dirs and the arm
+    name; the bot adapter needs nothing."""
+    if decl.outcome_adapter.endswith(":ReviewEvalAdapter"):
+        return {"gt_dir": str(ctx.params.get("gt_dir") or getattr(ctx.settings, "improve_gt_dir", "") or "eval/dataset/gt"),
+                "judgments_dir": ctx.params.get("judgments_dir") or getattr(ctx.settings, "improve_judgments_dir", "") or None,
+                "arm": str(ctx.params.get("arm") or getattr(ctx.settings, "improve_eval_arm", "") or "")}
+    if decl.outcome_adapter.endswith(":RbReviewAdapter"):
+        return {"bot_login": str(getattr(ctx.settings, "improve_rb_bot_login", "") or "")}
+    return {}
+
+
+def _judge_spec(ctx: StepContext):
+    """The gold_match judge from settings.improve_judge: "api:<model>" or
+    "cli:<provider>:<model>"; None when unset (cells stay unlabeled and the
+    report says so)."""
+    from ...improve.judges import JudgeSpec
+
+    raw = str(ctx.params.get("judge") or getattr(ctx.settings, "improve_judge", "") or "")
+    if not raw:
+        return None
+    parts = raw.split(":")
+    if parts[0] == "api" and len(parts) == 2:
+        return JudgeSpec("api", parts[1])
+    if parts[0] == "cli" and len(parts) == 3:
+        return JudgeSpec("cli", parts[2], provider=parts[1])
+    raise ValueError(f"improve_judge must be api:<model> or cli:<provider>:<model>, got {raw!r}")
+
+
+def _collect_outcomes(ctx: StepContext, adapter, units, store) -> dict:
+    """Outcome collection BEFORE the matrix: the bot adapter fetches thread
+    labels inside fetch(); the eval adapter imports the paired judge's
+    verdicts and, when a judge is configured, decides every undecided gold
+    entry with gold_match. Nothing here is fabricated: without a judge the
+    cells stay unlabeled and the report counts them."""
+    from ...improve.adapters.review_eval import ReviewEvalAdapter
+    from ...improve.judges import JudgeError
+
+    summary = {"verdicts": 0, "gold_matched": 0, "judge": "", "errors": []}
+    if not isinstance(adapter, ReviewEvalAdapter):
+        return summary
+    judge = _judge_spec(ctx)
+    if judge is not None:
+        adapter.judge = judge
+        adapter.llm = ctx.llm if judge.kind == "api" else None
+        adapter.governor = getattr(ctx, "governor", None)
+        summary["judge"] = f"{judge.kind}:{judge.provider + ':' if judge.provider else ''}{judge.model}"
+    for unit in units:
+        try:
+            summary["verdicts"] += adapter.collect_judge_verdicts(unit, store)
+        except Exception as exc:  # noqa: BLE001 - one bad judgment file must not stop the rest
+            summary["errors"].append(f"{unit.unit_id}: verdicts: {exc}"[:200])
+        gold = adapter.gold(unit.item)
+        if gold is None or judge is None:
+            continue
+        try:
+            summary["gold_matched"] += adapter.gold_match(unit, gold, store)
+        except JudgeError as exc:
+            summary["errors"].append(f"{unit.unit_id}: gold_match: {exc}"[:200])
+    summary["inconclusive"] = len(getattr(adapter, "inconclusive", []) or [])
+    return summary