easy-coding-harness 1.0.1 → 1.1.0-beta.1

package/templates/shared-hooks/easy_coding_state.py

@@ -16,6 +16,10 @@ from datetime import datetime, timezone
 from pathlib import Path
 import sys
 
+from easy_coding_inputs import (
+    evidence_operation, memo, digest, input_spec, capture, changed_inputs, command_covers,
+)
+
 from easy_dev_spec import (
     EasyDevSpecError,
     inspect_manifest,
@@ -121,8 +125,8 @@ WIDE_WORKFLOW_CONTRACT_PATTERN = re.compile(
 )
 DEFAULT_APPROVAL_MODE = "guard"
 DEFAULT_WORKFLOW_MODE = "adaptive"
-DEFAULT_TDD_ENABLED = False
-DEFAULT_TDD_COVERAGE_THRESHOLD = 90
+DEFAULT_UNIT_TEST_MODE = "none"
+DEFAULT_UT_COVERAGE_THRESHOLD = 90
 TDD_READINESS_SCHEMA = "easy-coding/tdd-readiness-v1"
 TDD_READINESS_SCOPE = "changed-production-lines"
 TDD_READINESS_PATH = Path(".easy-coding/tdd/readiness.json")
@@ -454,7 +458,7 @@ def read_memory_config(root: Path) -> dict[str, int]:
     return config
 
 
-def parse_tdd_threshold(value: object, source: str) -> int:
+def parse_ut_threshold(value: object, source: str) -> int:
     if isinstance(value, bool):
         raise StateError(f"Invalid {source}: expected an integer from 1 to 100.")
     try:
@@ -466,18 +470,13 @@ def parse_tdd_threshold(value: object, source: str) -> int:
     return threshold
 
 
-def parse_yaml_bool(value: str | None, source: str) -> bool:
-    if value is None:
-        return DEFAULT_TDD_ENABLED
-    normalized = value.lower()
-    if normalized in {"true", "yes", "on"}:
-        return True
-    if normalized in {"false", "no", "off"}:
-        return False
-    raise StateError(f"Invalid {source}: expected true or false.")
+def parse_unit_test_mode(value: object, source: str) -> str:
+    if not isinstance(value, str) or value not in {"none", "ut", "tdd"}:
+        raise StateError(f"Invalid {source}: expected none, ut, or tdd.")
+    return str(value)
 
 
-def read_project_behavior(root: Path) -> tuple[str, str, bool, int]:
+def read_project_behavior(root: Path) -> tuple[str, str, str, int]:
     path = root / ".easy-coding" / "config.yaml"
     try:
         lines = path.read_text(encoding="utf-8").splitlines()
@@ -485,8 +484,8 @@ def read_project_behavior(root: Path) -> tuple[str, str, bool, int]:
         return (
             DEFAULT_APPROVAL_MODE,
             DEFAULT_WORKFLOW_MODE,
-            DEFAULT_TDD_ENABLED,
-            DEFAULT_TDD_COVERAGE_THRESHOLD,
+            DEFAULT_UNIT_TEST_MODE,
+            DEFAULT_UT_COVERAGE_THRESHOLD,
         )
 
     in_behavior = False
@@ -538,16 +537,20 @@ def read_project_behavior(root: Path) -> tuple[str, str, bool, int]:
             "Invalid behavior.workflow_mode in .easy-coding/config.yaml: "
             "expected adaptive, fast, standard, or strict."
         )
-    if schema_version >= 4:
-        tdd_enabled = parse_yaml_bool(behavior.get("tdd_enabled"), "behavior.tdd_enabled")
-        tdd_threshold = parse_tdd_threshold(
-            behavior.get("tdd_coverage_threshold", DEFAULT_TDD_COVERAGE_THRESHOLD),
-            "behavior.tdd_coverage_threshold",
+    if schema_version >= 6:
+        unit_test_mode = parse_unit_test_mode(
+            behavior.get("unit_test_mode", DEFAULT_UNIT_TEST_MODE), "behavior.unit_test_mode"
+        )
+        threshold = parse_ut_threshold(
+            behavior.get("ut_coverage_threshold", DEFAULT_UT_COVERAGE_THRESHOLD),
+            "behavior.ut_coverage_threshold",
         )
     else:
-        tdd_enabled = DEFAULT_TDD_ENABLED
-        tdd_threshold = DEFAULT_TDD_COVERAGE_THRESHOLD
-    return approval_mode, workflow_mode, tdd_enabled, tdd_threshold
+        if schema_version >= 4:
+            raise StateError("Run easy-coding upgrade to migrate unit-test settings to schema 6.")
+        unit_test_mode = DEFAULT_UNIT_TEST_MODE
+        threshold = DEFAULT_UT_COVERAGE_THRESHOLD
+    return approval_mode, workflow_mode, unit_test_mode, threshold
 
 
 def safe_tdd_report_pattern(value: object) -> bool:
@@ -719,13 +722,13 @@ def require_tdd_readiness(root: Path) -> None:
 
 def resolve_behavior(
     root: Path, session: dict
-) -> tuple[str, str | None, str, str, str | None, str, bool, bool | None, bool, int, int | None, int]:
-    project_approval, project_workflow, project_tdd, project_threshold = read_project_behavior(root)
+) -> tuple[str, str | None, str, str, str | None, str, str, str | None, str, int, int | None, int]:
+    project_approval, project_workflow, project_unit_test, project_threshold = read_project_behavior(root)
     legacy = session.get("confirm_mode")
     session_approval = session.get("approval_mode")
     session_workflow = session.get("workflow_mode")
-    session_tdd = session.get("tdd_enabled")
-    session_threshold = session.get("tdd_coverage_threshold")
+    session_unit_test = session.get("unit_test_mode")
+    session_threshold = session.get("ut_coverage_threshold")
     if session_approval is None:
         if legacy == "lite":
             session_approval = "guard"
@@ -744,11 +747,11 @@ def resolve_behavior(
         raise StateError(
             "Invalid session workflow_mode: expected adaptive, fast, standard, or strict."
         )
-    if session_tdd is not None and not isinstance(session_tdd, bool):
-        raise StateError("Invalid session tdd_enabled: expected true or false.")
+    if session_unit_test is not None:
+        session_unit_test = parse_unit_test_mode(session_unit_test, "session unit_test_mode")
     if session_threshold is not None:
-        session_threshold = parse_tdd_threshold(
-            session_threshold, "session tdd_coverage_threshold"
+        session_threshold = parse_ut_threshold(
+            session_threshold, "session ut_coverage_threshold"
         )
     return (
         project_approval,
@@ -757,9 +760,9 @@ def resolve_behavior(
         project_workflow,
         str(session_workflow) if session_workflow else None,
         str(session_workflow or project_workflow),
-        project_tdd,
-        session_tdd,
-        session_tdd if session_tdd is not None else project_tdd,
+        project_unit_test,
+        session_unit_test,
+        session_unit_test if session_unit_test is not None else project_unit_test,
         project_threshold,
         session_threshold,
         session_threshold if session_threshold is not None else project_threshold,
@@ -771,7 +774,22 @@ def resolve_approval_mode(root: Path, session: dict) -> tuple[str, str | None, s
     return behavior[0], behavior[1], behavior[2]
 
 
+def migrate_unit_test_settings(record: dict) -> bool:
+    changed = False
+    if "tdd_enabled" in record:
+        enabled = record.pop("tdd_enabled")
+        if "unit_test_mode" not in record and isinstance(enabled, bool):
+            record["unit_test_mode"] = "tdd" if enabled else "none"
+        changed = True
+    if "tdd_coverage_threshold" in record:
+        threshold = record.pop("tdd_coverage_threshold")
+        record.setdefault("ut_coverage_threshold", threshold)
+        changed = True
+    return changed
+
+
 def materialize_legacy_session_behavior(session: dict) -> None:
+    migrate_unit_test_settings(session)
     legacy = session.get("confirm_mode")
     if legacy == "lite":
         session.setdefault("approval_mode", "guard")
@@ -1260,7 +1278,7 @@ def normalize_legacy_stage(stage: object) -> object:
 def normalize_legacy_task(task: dict) -> bool:
     """Normalize legacy task state without touching artifacts outside task.json."""
     legacy_status = str(task.get("status") or "")
-    changed = False
+    changed = migrate_unit_test_settings(task)
 
     for field in ("created_by", "last_agent"):
         normalized_agent = canonical_agent_identity(
@@ -1825,13 +1843,42 @@ def is_valid_review_finding(value: object) -> bool:
     )
 
 
+def gate_identity(record: dict) -> tuple:
+    return (str(record.get("source_task_id") or ""), str(record.get("unit_id") or ""),
+            str(record.get("dimension") or record.get("check") or ""),
+            str(record.get("review_scope") or record.get("coverage_scope") or ""))
+
+
+def failure_label(record: dict) -> str:
+    _, unit, name, scope = gate_identity(record)
+    label = f"{record['type']}:{name}"
+    if scope:
+        label += f":{scope}"
+    if unit:
+        label += f":unit={unit}"
+    return label
+
+
+def require_unit_evidence(plan: dict, records: list[dict], label: str, dimensions: int = 0) -> None:
+    if not any(record.get("unit_id") for record in records):
+        return
+    for unit in plan.get("units", []):
+        applicable = [record for record in records
+                      if record.get("unit_id") == unit["id"] or
+                      (not record.get("unit_id") and
+                       (not record.get("source_task_id") or
+                        record["source_task_id"] == unit.get("source_task_id")))]
+        if not applicable or (dimensions and len({r.get("dimension") for r in applicable}) < dimensions):
+            raise StateError(f"{label} evidence does not cover Unit {unit['id']} at the required depth.")
+
+
 def validate_quality_gate_record_schemas(
     review_records: list[dict], verification_records: list[dict]
 ) -> None:
     latest_reviews: dict[tuple[str, str], dict] = {}
     for index, record in enumerate(review_records):
         dimension = str(record.get("dimension") or f"<missing-{index}>")
-        latest_reviews[(str(record.get("source_task_id") or ""), dimension)] = record
+        latest_reviews[gate_identity(record)] = record
     for record in latest_reviews.values():
         findings = record.get("findings")
         if (
@@ -1859,13 +1906,7 @@ def validate_quality_gate_record_schemas(
     latest_verifications: dict[tuple[str, str, str], dict] = {}
     for index, record in enumerate(verification_records):
         check = str(record.get("check") or f"<missing-{index}>")
-        latest_verifications[
-            (
-                str(record.get("source_task_id") or ""),
-                check,
-                str(record.get("coverage_scope") or ""),
-            )
-        ] = record
+        latest_verifications[gate_identity(record)] = record
     for record in latest_verifications.values():
         applicable = record.get("applicable") is not False
         if (
@@ -2249,6 +2290,34 @@ def require_spec_context(
         raise StateError("Current session must consume the bound Canonical Spec via resume-spec-context before advancing.")
 
 
+def refresh_correction_plan(root: Path, task_id: str, task: dict, inspection: dict) -> None:
+    plan = latest_execution_plan(root, task_id)
+    if plan is None:
+        raise StateError("A correction must preserve its original execution plan.")
+    selection = select_tasks(inspection, task["selected_spec_tasks"], allow_pending_hard_dependencies=True)
+    steps = {s["step_id"]: s for s in selection["selected_steps"]}
+    changes = {c["change_id"]: c for c in selection["selected_changes"]}
+    tests = {t["test_id"]: t for t in selection["selected_tests"]}
+    correction = task["correction"]
+    plan["spec_design_sha256"] = inspection["design_sha256"]
+    for unit in plan["units"]:
+        if unit["id"] not in correction["unit_ids"]:
+            continue
+        source_steps = [steps[s] for s in unit["source_step_ids"] if s in steps]
+        selected_changes = [changes[c] for s in source_steps for c in s.get("change_ids", [])]
+        original_files = set(unit["files"])
+        mapped_files = {c["path"] for c in selected_changes}
+        if not mapped_files <= original_files:
+            raise StateError("Source design expands the correction scope; analyze the new requirement.")
+        unit["source_step_ids"] = [s["step_id"] for s in source_steps]
+        unit["files"] = sorted(mapped_files | (original_files & set(correction["files"])))
+        unit["symbols"] = sorted({symbol for c in selected_changes for symbol in c.get("symbols", [])})
+        unit["test_commands"] = sorted({tests[t]["command"] for s in source_steps for t in s.get("test_ids", [])})
+        unit["acceptance_criteria"] = [correction["summary"]]
+        unit["contracts"] = [correction["summary"]]
+    append_execution_record(root, task_id, plan)
+
+
 def begin_spec_change(
     root: Path, affected_task_ids: list[str], summary: str, agent: str,
     task_id: str | None = None, session_file: str | Path | None = None,
@@ -2375,7 +2444,7 @@ def is_valid_spec_execution_plan(root: Path, task: dict, plan: object) -> bool:
         if (
             not step_change_ids.issubset(change_by_id)
             or not step_test_ids.issubset(test_by_id)
-            or set(unit.get("files", [])) != step_files
+            or (set(unit.get("files", [])) - set(task.get("correction", {}).get("files", []))) != (step_files - set(task.get("correction", {}).get("files", [])))
             or set(unit["symbols"]) != step_symbols
             or not set(unit["test_commands"]).issuperset(step_commands)
         ):
@@ -2397,9 +2466,10 @@ def is_valid_spec_execution_plan(root: Path, task: dict, plan: object) -> bool:
         steps = covered_steps[source_task_id]
         if len(steps) != len(set(steps)) or set(steps) != set(source_task.get("step_ids", [])):
             return False
-        if covered_files[source_task_id] != {
+        restoration_files = set(task.get("correction", {}).get("files", []))
+        if covered_files[source_task_id] - restoration_files != {
             str(change["path"]) for change in changes_by_task[source_task_id]
-        }:
+        } - restoration_files:
             return False
         if covered_symbols[source_task_id] != {
             str(symbol)
@@ -2545,7 +2615,7 @@ def has_valid_execution_plan(root: Path, task_id: str) -> bool:
                 return False
             if isinstance(record, dict) and record.get("type") == "plan":
                 latest_plan = record
-            elif isinstance(record, dict) and record.get("type") == "spec-design-sync":
+            elif isinstance(record, dict) and record.get("type") == "spec-design-sync" and not record.get("preserve_plan"):
                 latest_plan = None
     except OSError:
         return False
@@ -2583,7 +2653,7 @@ def latest_execution_plan(root: Path, task_id: str) -> dict | None:
     for record in execution_records(root, task_id):
         if record.get("type") == "plan":
             latest = record
-        elif record.get("type") == "spec-design-sync":
+        elif record.get("type") == "spec-design-sync" and not record.get("preserve_plan"):
             latest = None
     if latest is None or not is_valid_execution_plan(latest, allow_empty_files=True):
         return None
@@ -2833,7 +2903,7 @@ def tdd_baseline_marker_reasons(
 def contains_tdd_threshold(content: str, threshold: int) -> bool:
     return re.search(
         rf"(?<!\d){threshold}\s*%|--threshold(?:\s+|=){threshold}(?!\d)|"
-        rf"tdd_coverage_threshold\s*[:=]\s*{threshold}(?!\d)",
+        rf"ut_coverage_threshold\s*[:=]\s*{threshold}(?!\d)",
         content,
         re.IGNORECASE,
     ) is not None
@@ -3076,220 +3146,176 @@ def tdd_infrastructure_fingerprint(repositories: set[Path]) -> str:
     return digest.hexdigest()
 
 
+def check_identity(record: dict) -> tuple:
+    return tuple(str(record.get(key) or "") for key in (
+        "type", "unit_id", "source_task_id", "dimension", "review_scope", "check", "check_type", "command", "coverage_scope"
+    ))
+
+
+def prepare_check(root: Path, task_id: str, task: dict, descriptor: dict, agent: str) -> dict:
+    if task.get("status") not in {"IMPLEMENT", "QUALITY"}:
+        raise StateError("Checks belong to IMPLEMENT or QUALITY.")
+    if descriptor.get("type") not in {"review", "verify"}:
+        raise StateError("A check must identify type review or verify.")
+    if descriptor.get("type") == "verify" and not is_non_empty_string(descriptor.get("command")):
+        raise StateError("Verification must identify the actual command before execution.")
+    plan = latest_execution_plan(root, task_id) or {}
+    if descriptor.get("unit_id"):
+        owner = next((u for u in plan.get("units", []) if u["id"] == descriptor["unit_id"]), None)
+        if owner is None:
+            raise StateError("Check unit does not belong to the current plan.")
+        for field in ("repo_id", "source_task_id"):
+            if field in owner:
+                descriptor[field] = owner[field]
+    inputs = capture(input_spec(root, task, plan, descriptor))
+    records = execution_records(root, task_id)
+    previous = next((r for r in reversed(records)
+                     if check_identity(r) == check_identity(descriptor)), None)
+    if previous and previous.get("passed") is True and previous.get("inputs") == inputs:
+        return {"reusable": True, "evidence_index": records.index(previous),
+                "input_signature": inputs["signature"], "changed_inputs": []}
+    prepared_id = digest([descriptor, inputs["signature"]])
+    if not any(r.get("prepared_id") == prepared_id and r.get("type") == "check-inputs" for r in records):
+        append_execution_record(root, task_id, {
+            "type": "check-inputs", "prepared_id": prepared_id, "descriptor": descriptor,
+            "inputs": inputs, "timestamp": now_iso(), "agent": agent,
+        })
+    return {"reusable": False, "prepared_id": prepared_id,
+            "input_signature": inputs["signature"],
+            "changed_inputs": changed_inputs(previous["inputs"], inputs)
+            if previous and isinstance(previous.get("inputs"), dict) else ["no matching input-bound evidence"]}
+
+
+def record_check(root: Path, task_id: str, task: dict, prepared_id: str, result: dict, agent: str) -> dict:
+    prepared = next((r for r in reversed(execution_records(root, task_id))
+                     if r.get("type") == "check-inputs" and r.get("prepared_id") == prepared_id), None)
+    if prepared is None:
+        raise StateError("Prepare the check before executing it.")
+    descriptor = prepared["descriptor"]
+    current = capture(input_spec(root, task, latest_execution_plan(root, task_id) or {}, descriptor))
+    changes = changed_inputs(prepared["inputs"], current)
+    if changes:
+        raise StateError("Check inputs changed during execution: " + "; ".join(changes))
+    if type(result.get("passed")) is not bool:
+        raise StateError("Check result must include passed.")
+    if descriptor["type"] == "verify" and result.get("applicable") is not False:
+        if type(result.get("exit_code")) is not int or result["passed"] != (result["exit_code"] == 0):
+            raise StateError("Verification passed must agree with its real exit_code.")
+    context = None
+    if task.get("status") == "QUALITY":
+        context = ensure_quality_attempt_context(root, task_id, task, agent, persist=True)
+    elif task.get("status") != "IMPLEMENT":
+        raise StateError("Record checks only during implementation or quality.")
+    record = {
+        **result, **descriptor, **evidence_fingerprints(root, task_id),
+        "inputs": current, "prepared_id": prepared_id, "timestamp": now_iso(),
+        "quality_attempt": context["attempt"] if context else 0,
+    }
+    append_execution_record(root, task_id, record)
+    return {"recorded": True, "passed": record["passed"], "input_signature": current["signature"]}
+
+
+def carry_forward_scoped_evidence(root: Path, task_id: str, task: dict, context: dict) -> None:
+    plan = latest_execution_plan(root, task_id) or {}
+    latest = {}
+    for index, record in enumerate(execution_records(root, task_id)):
+        if record.get("type") in {"review", "verify"}:
+            latest[check_identity(record)] = (index, record)
+    for index, record in latest.values():
+        if record.get("passed") is not True or not isinstance(record.get("inputs"), dict):
+            continue
+        if any(f.get("severity") == "error" for f in record.get("findings", [])):
+            continue
+        if record.get("unit_id") and not any(u["id"] == record["unit_id"] for u in plan.get("units", [])):
+            continue
+        current = capture(input_spec(root, task, plan, record))
+        if current != record["inputs"]:
+            continue
+        if record.get("quality_attempt") == context["attempt"]:
+            continue
+        # 仅运行时生成引用，保留原始执行时间与输入；Agent 不重新包装历史结论。
+        append_execution_record(root, task_id, {
+            **record, "reused_from": index, "quality_attempt": context["attempt"],
+            "implementation_fingerprint": context["implementation_fingerprint"],
+            "config_fingerprint": context["config_fingerprint"],
+        })
+
+
+def begin_correction(root: Path, task_id: str, task: dict, files: list[str], summary: str,
+                     risks: list[str], agent: str) -> dict:
+    if task.get("status") not in {"IMPLEMENT", "QUALITY", "MEMORY", "ANALYSIS"}:
+        raise StateError("A correction needs an active implementation task.")
+    plan = latest_execution_plan(root, task_id) or {}
+    units = plan.get("units", [])
+    allowed = {f for unit in units for f in unit.get("files", [])}
+    if not files or not set(files) <= allowed or not summary.strip():
+        raise StateError("A correction must name existing task files and the confirmed change.")
+    cancel_active_quality_attempt(root, task_id, task, agent, summary, "manual-return")
+    task = load_task(root, task_id) or task
+    cleanup_verification_checkpoint(root, task_id, task)
+    task["correction"] = {
+        "files": sorted(set(files)), "summary": summary.strip(), "risks": risks,
+        "unit_ids": [u["id"] for u in units if set(u.get("files", [])) & set(files)],
+        "started_at": now_iso(),
+    }
+    records = validated_quality_records(root, task_id)
+    if records:
+        task["quality_consumed_attempt"] = records[-1][1]["attempt"]
+    task.pop("quality_return_required", None)
+    task.pop("pending_transition", None)
+    task["status"] = "IMPLEMENT"
+    append_stage_history(task, "IMPLEMENT", agent)
+    write_task(root, task_id, task)
+    task["workflow_mode"], reasons = calculate_workflow_floor(root, task_id)
+    write_task(root, task_id, task)
+    if isinstance(task.get("spec_source"), dict):
+        writeback_ready_tasks_for_implement(root, task_id, task, agent, source_task_ids={
+            str(u["source_task_id"]) for u in units if u["id"] in task["correction"]["unit_ids"]
+        })
+    append_execution_record(root, task_id, {
+        "type": "correction", **task["correction"], "workflow_mode": task["workflow_mode"],
+    })
+    return {"task_id": task_id, "status": "IMPLEMENT", "workflow_mode": task["workflow_mode"],
+            "reasons": reasons, "correction": task["correction"]}
+
+
 def implementation_fingerprint(root: Path, task_id: str) -> str:
     plan = latest_execution_plan(root, task_id)
     if not plan:
         raise StateError("Cannot calculate implementation fingerprint without a valid plan.")
-    task = load_task(root, task_id)
-    workflow_mode = str(task.get("workflow_mode") or "") if task else ""
-    digest = hashlib.sha256()
-    digest.update(b"workflow-mode\0")
-    digest.update(workflow_mode.encode("utf-8"))
-    digest.update(b"\0")
-    if task and task.get("tdd_enabled") is True:
-        digest.update(b"tdd\0enabled\0")
-        digest.update(str(task.get("tdd_coverage_threshold") or "").encode("utf-8"))
-        digest.update(b"\0")
-        digest.update(
-            json.dumps(
-                task.get("tdd_baselines") or {},
-                sort_keys=True,
-                separators=(",", ":"),
-            ).encode("utf-8")
-        )
-        digest.update(b"\0")
-        digest.update(tdd_infrastructure_fingerprint(
-            {root.resolve(), *task_repository_roots(root, task, plan)}
-        ).encode("ascii"))
-    digest.update(b"execution-plan\0")
-    digest.update(
-        json.dumps(
-            plan,
-            ensure_ascii=False,
-            sort_keys=True,
-            separators=(",", ":"),
-        ).encode("utf-8")
-    )
-    digest.update(b"\0")
-    if task and isinstance(task.get("spec_source"), dict):
-        digest.update(b"canonical-spec\0")
-        source = task.get("spec_source") or {}
-        digest.update(
-            json.dumps(
-                {
-                    "source": {
-                        "schema": source.get("schema"),
-                        "spec_id": source.get("spec_id"),
-                        "revision": source.get("revision"),
-                        "design_sha256": source.get("design_sha256"),
-                    },
-                    "selected_tasks": task.get("selected_spec_tasks"),
-                },
-                ensure_ascii=False,
-                sort_keys=True,
-                separators=(",", ":"),
-            ).encode("utf-8")
-        )
-        digest.update(b"\0")
-    update_git_worktree_fingerprint(digest, root, task, plan)
-    repo_paths = task.get("repo_paths") if task else None
-    file_entries: set[tuple[str, str | None]] = {
-        (str(file_name), str(unit.get("repo_id")) if unit.get("repo_id") else None)
-        for unit in plan.get("units", [])
-        if isinstance(unit, dict)
-        for file_name in unit.get("files", [])
-        if is_non_empty_string(file_name)
-    }
-    for file_name, repo_id in sorted(file_entries, key=lambda item: (item[0], item[1] or "")):
-        candidate = Path(file_name)
-        was_absolute = candidate.is_absolute()
-        base = root
-        if (
-            task
-            and isinstance(task.get("spec_source"), dict)
-            and isinstance(repo_paths, dict)
-            and repo_id
-            and is_non_empty_string(repo_paths.get(repo_id))
-        ):
-            raw_base = Path(str(repo_paths[repo_id]))
-            base = raw_base if raw_base.is_absolute() else root / raw_base
-        if not was_absolute:
-            candidate = base / candidate
-        resolved = candidate.resolve()
-        if not was_absolute:
-            try:
-                resolved.relative_to(base.resolve())
-            except ValueError as error:
-                raise StateError(f"Execution plan file escapes repository: {file_name}") from error
-        digest.update(f"{repo_id or ''}:{file_name}".encode("utf-8"))
-        digest.update(b"\0")
-        try:
-            digest.update(resolved.read_bytes())
-        except OSError:
-            digest.update(b"<missing>")
-        digest.update(b"\0")
-    return digest.hexdigest()
+    task = load_task(root, task_id) or {}
+    # 候选只绑定实际输入与验收契约，执行状态、revision、模式和计划说明不参与。
+    return capture(input_spec(root, task, plan, {"type": "review"}))["signature"]
 
 
-def canonical_repository_fingerprints(
-    root: Path, task_id: str, task: dict
-) -> dict[str, str]:
+def canonical_repository_fingerprints(root: Path, task_id: str, task: dict) -> dict[str, str]:
     if not isinstance(task.get("spec_source"), dict):
         return {}
     plan = latest_execution_plan(root, task_id) or {}
-    repo_paths = task.get("repo_paths") if isinstance(task.get("repo_paths"), dict) else {}
-    fingerprints: dict[str, str] = {}
-    for repo_id in sorted(
-        {
-            str(unit.get("repo_id"))
-            for unit in plan.get("units", [])
-            if isinstance(unit, dict) and is_non_empty_string(unit.get("repo_id"))
-        }
-    ):
-        raw_base = repo_paths.get(repo_id)
-        if not is_non_empty_string(raw_base):
-            continue
-        base = Path(str(raw_base))
-        if not base.is_absolute():
-            base = root / base
-        base = base.resolve()
-        digest = hashlib.sha256()
-        if task.get("tdd_enabled") is True:
-            digest.update(tdd_infrastructure_fingerprint({root.resolve(), base}).encode("ascii"))
-        units = [
-            unit
-            for unit in plan.get("units", [])
-            if isinstance(unit, dict) and unit.get("repo_id") == repo_id
-        ]
-        digest.update(
-            json.dumps(
-                units,
-                ensure_ascii=False,
-                sort_keys=True,
-                separators=(",", ":"),
-            ).encode("utf-8")
-        )
-        digest.update(b"\0")
-        repository = git_repository_root(base)
-        if repository is not None and repository.resolve() == base:
-            update_git_repository_content_fingerprint(
-                digest,
-                root,
-                repository,
-                [base],
-                set(),
-            )
-        else:
-            for unit in units:
-                for file_name in sorted(
-                    str(value)
-                    for value in unit.get("files", [])
-                    if is_non_empty_string(value)
-                ):
-                    candidate = (base / file_name).resolve()
-                    try:
-                        candidate.relative_to(base)
-                    except ValueError as error:
-                        raise StateError(
-                            f"Execution plan file escapes repository: {file_name}"
-                        ) from error
-                    digest.update(file_name.encode("utf-8"))
-                    digest.update(b"\0")
-                    try:
-                        digest.update(candidate.read_bytes())
-                    except OSError:
-                        digest.update(b"<missing>")
-                    digest.update(b"\0")
-        fingerprints[repo_id] = digest.hexdigest()
-    return fingerprints
+    return {
+        repo: digest([capture(input_spec(root, task, plan, {
+            "type": "review", "unit_id": unit["id"]
+        }))["signature"] for unit in plan.get("units", []) if unit.get("repo_id") == repo])
+        for repo in sorted({unit["repo_id"] for unit in plan.get("units", [])})
+    }
 
 
-def config_without_frozen_tdd_settings(payload: bytes) -> bytes:
-    """任务冻结 TDD 契约后，从证据指纹中排除仅影响未来任务的实时 TDD 配置。"""
-    try:
-        lines = payload.decode("utf-8").splitlines(keepends=True)
-    except UnicodeDecodeError:
-        return payload
-    filtered: list[str] = []
-    in_behavior = False
-    behavior_indent = 0
-    behavior_key_indent: int | None = None
-    for line in lines:
-        clean = line.split("#", 1)[0].rstrip()
-        stripped = clean.strip()
-        indent = len(clean) - len(clean.lstrip(" "))
-        if stripped == "behavior:":
-            in_behavior = True
-            behavior_indent = indent
-            behavior_key_indent = None
-            filtered.append(line)
-            continue
-        if in_behavior and stripped and indent <= behavior_indent:
-            in_behavior = False
-        if in_behavior and stripped:
-            if behavior_key_indent is None:
-                behavior_key_indent = indent
-            key = stripped.split(":", 1)[0]
-            if (
-                indent == behavior_key_indent
-                and key in {"tdd_enabled", "tdd_coverage_threshold"}
-            ):
-                continue
-        filtered.append(line)
-    return "".join(filtered).encode("utf-8")
+def unit_test_contract(task: dict) -> dict:
+    mode = task.get("unit_test_mode")
+    # 旧证据的序列化键保持不变，配置字段改名不触发全局失效；UT 单独标识。
+    contract = {
+        "tdd_enabled": None if mode is None else mode != "none",
+        "tdd_coverage_threshold": task.get("ut_coverage_threshold"),
+        "tdd_baselines": task.get("tdd_baselines"),
+    }
+    if mode == "ut":
+        contract["unit_test_mode"] = "ut"
+    return contract
 
 
 def behavior_config_fingerprint(root: Path, task: dict | None = None) -> str:
-    path = root / ".easy-coding" / "config.yaml"
-    digest = hashlib.sha256()
-    try:
-        payload = path.read_bytes()
-        if task and isinstance(task.get("tdd_enabled"), bool):
-            payload = config_without_frozen_tdd_settings(payload)
-        digest.update(payload)
-    except OSError:
-        digest.update(b"<missing-config>")
-    return digest.hexdigest()
+    # 审批方式、记忆策略等配置不影响已经执行的测试。
+    return digest(unit_test_contract(task or {}))
 
 
 def evidence_fingerprints(root: Path, task_id: str) -> dict[str, str]:
@@ -3599,6 +3625,7 @@ def ensure_quality_attempt_context(
             )
         if (
             finalized.get("outcome") in {"passed", "repair", "replan"}
+            and finalized.get("attempt") != task.get("quality_consumed_attempt")
             and finalized.get("implementation_fingerprint")
             == expected["implementation_fingerprint"]
             and finalized.get("config_fingerprint") == expected["config_fingerprint"]
@@ -3612,6 +3639,7 @@ def ensure_quality_attempt_context(
     )
     if persist:
         append_canonical_quality_carry_forward(root, task_id, task, context, agent)
+        carry_forward_scoped_evidence(root, task_id, task, context)
         task["quality_attempt"] = context
         task["last_agent"] = agent
         write_task(root, task_id, task)
@@ -3888,19 +3916,9 @@ def finalize_quality_attempt(
     latest_failure_records: dict[tuple[str, str], dict] = {}
     for record in [*current_reviews, *current_verifications]:
         owner = str(record.get("source_task_id")) if canonical else task_id
-        if record.get("type") == "review" and is_non_empty_string(
-            record.get("dimension")
-        ):
-            label = f"review:{record['dimension']}"
-        elif record.get("type") == "verify" and is_non_empty_string(
-            record.get("check")
-        ):
-            coverage_scope = str(record.get("coverage_scope") or "")
-            label = f"verify:{record['check']}"
-            if coverage_scope:
-                label = f"{label}:{coverage_scope}"
-        else:
+        if record.get("type") not in {"review", "verify"}:
             continue
+        label = failure_label(record)
         latest_failure_records[(owner, label)] = record
     evidence_failure_classes: set[str] = set()
     for owner, labels in failures.items():
@@ -4212,12 +4230,10 @@ def verification_contract_fingerprint(root: Path, task_id: str, task: dict) -> s
     source = task.get("spec_source") if isinstance(task.get("spec_source"), dict) else {}
     contract = {
         "workflow_mode": task.get("workflow_mode"),
-        "tdd_enabled": task.get("tdd_enabled"),
-        "tdd_coverage_threshold": task.get("tdd_coverage_threshold"),
-        "tdd_baselines": task.get("tdd_baselines"),
+        **unit_test_contract(task),
         **({"tdd_infrastructure": tdd_infrastructure_fingerprint(
             {root.resolve(), *task_repository_roots(root, task, plan)}
-        )} if task.get("tdd_enabled") is True else {}),
+        )} if task.get("unit_test_mode") in {"ut", "tdd"} else {}),
         "plan": plan,
         "canonical": {
             "schema": source.get("schema"),
@@ -4981,8 +4997,10 @@ def validate_spec_implementation_results(root: Path, task_id: str, task: dict) -
         default=-1,
     )
     lifecycle_by_unit: dict[str, list[dict]] = {unit_id: [] for unit_id in unit_by_id}
-    for record in records[latest_plan_index + 1 :]:
+    for index, record in enumerate(records):
         unit_id = str(record.get("unit_id") or "")
+        if index <= latest_plan_index and unit_id in task.get("correction", {}).get("unit_ids", list(unit_by_id)):
+            continue
         if record.get("type") in {"dispatch", "result"} and unit_id in unit_by_id:
             lifecycle_by_unit[unit_id].append(record)
     missing_dispatches = sorted(
@@ -5065,7 +5083,7 @@ def validate_review_readiness(
         ):
             dimension = str(record["dimension"])
             source_task_id = str(record.get("source_task_id") or "")
-            record_key = f"{dimension}\0{source_task_id}" if is_spec_task else dimension
+            record_key = gate_identity(record)
             latest_by_dimension[record_key] = record
     if not latest_by_dimension:
         raise StateError(
@@ -5121,6 +5139,9 @@ def validate_review_readiness(
                 "Canonical Spec review evidence does not cover selected source tasks: "
                 + ", ".join(missing_review_tasks)
             )
+    require_unit_evidence(latest_execution_plan(root, task_id) or {},
+                          list(latest_by_dimension.values()), "Review",
+                          2 if task.get("workflow_mode") == "strict" else 1)
     has_failed_dimension = False
     for record in latest_by_dimension.values():
         findings = record.get("findings")
@@ -5136,7 +5157,7 @@ def validate_review_readiness(
         raise StateError(
             "QUALITY cannot advance while a review dimension is not passed or has error findings."
         )
-    if task.get("tdd_enabled") is True:
+    if task.get("unit_test_mode") == "tdd":
         if is_spec_task:
             missing_tdd_reviews = sorted(
                 source_task_id
@@ -5167,7 +5188,7 @@ def validate_review_readiness(
                     "Strict Canonical Spec review requires at least two passed dimensions for "
                     "every selected source task: " + ", ".join(missing_strict_dimensions)
                 )
-        elif len(latest_by_dimension) < 2:
+        elif len({record["dimension"] for record in latest_by_dimension.values()}) < 2:
             raise StateError(
                 "Strict workflow requires at least two passed review dimensions for the current implementation fingerprint."
             )
@@ -5208,17 +5229,13 @@ def validate_verification_readiness(
             and is_non_empty_string(record.get("check"))
         ):
             if (
-                task.get("tdd_enabled") is True
+                task.get("unit_test_mode") in {"ut", "tdd"}
                 and record.get("check_type") == "coverage"
                 and record.get("coverage_scope") == "gitlab"
             ):
                 # 远程 CI 只作为生成的自动化能力，历史 pending/failed 记录不再参与本地验收。
                 continue
-            check = str(record["check"])
-            if task.get("tdd_enabled") is True and record.get("check_type") == "coverage":
-                check = f"{check}\0{record.get('coverage_scope') or ''}"
-            if is_spec_task:
-                check = f"{check}\0{record.get('source_task_id') or ''}"
+            check = gate_identity(record)
             previous = latest_by_check.get(check)
             if (
                 record.get("applicable") is False
@@ -5273,6 +5290,7 @@ def validate_verification_readiness(
     applicable_records = [
         record for record in latest_by_check.values() if record.get("applicable") is not False
     ]
+    require_unit_evidence(latest_execution_plan(root, task_id) or {}, applicable_records, "Verification")
     if not applicable_records:
         raise StateError(
             "QUALITY cannot advance to MEMORY without at least one applicable executed check."
@@ -5314,13 +5332,13 @@ def validate_verification_readiness(
                 "TDD initialization cannot advance to MEMORY until readiness passes: "
                 + "; ".join(str(reason) for reason in readiness["reasons"])
             )
-    if task.get("tdd_enabled") is not True and any(
+    if task.get("unit_test_mode") not in {"ut", "tdd"} and any(
         record.get("check_type") == "coverage" for record in latest_by_check.values()
     ):
         raise StateError(
-            "Coverage verification evidence is not allowed when the frozen TDD mode is off."
+            "Coverage verification evidence is not allowed when the frozen unit test mode is none."
         )
-    if task.get("tdd_enabled") is True:
+    if task.get("unit_test_mode") in {"ut", "tdd"}:
         require_tdd_readiness(root)
         test_records = [
             record
@@ -5335,7 +5353,7 @@ def validate_verification_readiness(
         ]
         if not coverage_records:
             raise StateError(
-                "TDD verification requires changed-production-line JaCoCo coverage evidence."
+                "Unit test verification requires changed-production-line JaCoCo coverage evidence."
             )
         if is_spec_task:
             tested_source_tasks = {
@@ -5346,7 +5364,7 @@ def validate_verification_readiness(
             )
             if missing_test_tasks:
                 raise StateError(
-                    "TDD Canonical verification requires local unit-test evidence for every selected source task: "
+                    "Unit test Canonical verification requires local unit-test evidence for every selected source task: "
                     + ", ".join(missing_test_tasks)
                 )
             covered_source_tasks = {
@@ -5357,33 +5375,33 @@ def validate_verification_readiness(
             )
             if missing_coverage_tasks:
                 raise StateError(
-                    "TDD Canonical verification requires separate coverage evidence for every selected source task: "
+                    "Unit test Canonical verification requires separate coverage evidence for every selected source task: "
                     + ", ".join(missing_coverage_tasks)
                 )
         elif not test_records:
             raise StateError(
-                "TDD verification requires passed local unit-test evidence."
+                "Unit test verification requires passed local unit-test evidence."
             )
         for record in coverage_records:
             scope = str(record.get("coverage_scope") or "")
             if scope != "local":
                 raise StateError(
-                    "TDD coverage evidence must identify coverage_scope as local."
+                    "Unit test coverage evidence must identify coverage_scope as local."
                 )
-        expected_threshold = task.get("tdd_coverage_threshold")
+        expected_threshold = task.get("ut_coverage_threshold")
         expected_baselines = task.get("tdd_baselines")
         if (
             type(expected_threshold) is not int
             or expected_threshold < 1
             or expected_threshold > 100
         ):
-            raise StateError("TDD task is missing a valid frozen coverage threshold.")
+            raise StateError("Unit test task is missing a valid frozen coverage threshold.")
         if not isinstance(expected_baselines, dict) or not expected_baselines:
-            raise StateError("TDD task is missing frozen Git baselines.")
+            raise StateError("Unit test task is missing frozen Git baselines.")
         for record in coverage_records:
             coverage = record.get("coverage")
             if not isinstance(coverage, dict):
-                raise StateError("TDD coverage evidence must include the coverage result object.")
+                raise StateError("Unit test coverage evidence must include the coverage result object.")
             total = coverage.get("total_lines")
             covered = coverage.get("covered_lines")
             percentage = coverage.get("percentage")
@@ -5419,7 +5437,7 @@ def validate_verification_readiness(
                 )
             ):
                 raise StateError(
-                    "TDD coverage evidence must preserve the exact gate command, baseline, counts, percentage, frozen threshold, reports, and report fingerprint."
+                    "Unit test coverage evidence must preserve the exact gate command, baseline, counts, percentage, frozen threshold, reports, and report fingerprint."
                 )
             if total == 0:
                 if record.get("applicable") is not False or record.get("passed") is not True:
@@ -5428,7 +5446,7 @@ def validate_verification_readiness(
                     )
             elif abs(percentage - round(covered * 100.0 / total, 2)) > 0.01:
                 raise StateError(
-                    "TDD coverage evidence percentage does not match covered/total counts."
+                    "Unit test coverage evidence percentage does not match covered/total counts."
                 )
             elif (
                 record.get("applicable") is False
@@ -5436,7 +5454,7 @@ def validate_verification_readiness(
                 or percentage < threshold
             ):
                 raise StateError(
-                    f"TDD changed-line coverage must meet the frozen {threshold}% threshold."
+                    f"Unit test changed-line coverage must meet the frozen {threshold}% threshold."
                 )
     if task.get("workflow_mode") == "strict":
         if is_spec_task:
@@ -5506,7 +5524,10 @@ def validate_verification_readiness(
             for record in applicable_records
             if is_non_empty_string(record.get("command"))
         }
-        missing_commands = sorted(required_test_commands - executed_commands)
+        missing_commands = sorted(required for required in required_test_commands if not any(
+            actual[:2] == required[:2] and command_covers(actual[2], required[2])
+            for actual in executed_commands
+        ))
         if missing_commands:
             raise StateError(
                 "Canonical Spec verification is missing source test commands: "
@@ -5575,7 +5596,7 @@ def quality_repair_failures_for_window(
         and is_non_empty_string(unit.get("source_task_id"))
         and is_non_empty_string(unit.get("repo_id"))
     }
-    fingerprints = evidence_fingerprints(root, task_id)
+    fingerprints = evidence_fingerprints(root, task_id) if not (implementation_fingerprint_value and config_fingerprint_value) else {}
     implementation = (
         implementation_fingerprint_value or fingerprints["implementation_fingerprint"]
     )
@@ -5640,12 +5661,12 @@ def quality_repair_failures_for_window(
                 )
             ):
                 owner = source_task_id if canonical else task_id
-                latest_reviews[(owner, str(record["dimension"]))] = record
+                latest_reviews[(owner, *gate_identity(record)[1:])] = record
         elif record_type == "verify" and record.get(
             "implementation_fingerprint"
         ) == implementation and record.get("config_fingerprint") == config:
             if (
-                task.get("tdd_enabled") is True
+                task.get("unit_test_mode") in {"ut", "tdd"}
                 and record.get("check_type") == "coverage"
                 and record.get("coverage_scope") == "gitlab"
             ):
@@ -5669,16 +5690,10 @@ def quality_repair_failures_for_window(
             ):
                 continue
             owner = source_task_id if canonical else task_id
-            latest_verifications[
-                (
-                    owner,
-                    str(record["check"]),
-                    str(record.get("coverage_scope") or ""),
-                )
-            ] = record
+            latest_verifications[(owner, *gate_identity(record)[1:])] = record
 
     failures: dict[str, list[str]] = {}
-    for (source_task_id, dimension), record in latest_reviews.items():
+    for (source_task_id, unit_id, dimension, _scope), record in latest_reviews.items():
         findings = record.get("findings")
         has_error = isinstance(findings, list) and any(
             isinstance(finding, dict)
@@ -5686,13 +5701,10 @@ def quality_repair_failures_for_window(
             for finding in findings
         )
         if record.get("passed") is not True or has_error:
-            failures.setdefault(source_task_id, []).append(f"review:{dimension}")
-    for (source_task_id, check, scope), record in latest_verifications.items():
+            failures.setdefault(source_task_id, []).append(failure_label(record))
+    for (source_task_id, unit_id, check, scope), record in latest_verifications.items():
         if record.get("applicable") is not False and record.get("passed") is not True:
-            label = f"verify:{check}"
-            if scope:
-                label = f"{label}:{scope}"
-            failures.setdefault(source_task_id, []).append(label)
+            failures.setdefault(source_task_id, []).append(failure_label(record))
     return failures
 
 
@@ -6419,9 +6431,27 @@ def validate_analysis_readiness(
     test_strategy = task_dir / "test-strategy.md"
     reasons: list[str] = []
     behavior = resolve_behavior(root, session or default_session())
-    tdd_enabled = behavior[8] if task_type != TDD_INIT_TASK_TYPE else False
+    unit_test_mode = behavior[8] if task_type != TDD_INIT_TASK_TYPE else "none"
     tdd_threshold = behavior[11]
 
+    if unit_test_mode == "ut":
+        require_tdd_readiness(root)
+        plan = latest_execution_plan(root, task_id) or {}
+        if not any(str(file).endswith(".java") for unit in plan.get("units", []) for file in unit.get("files", [])):
+            reasons.append("UT is enabled but the confirmed implementation scope has no Java source")
+        if reasons:
+            raise StateError("; ".join(reasons))
+
+    if dev_spec.is_file() and unit_test_mode != "tdd":
+        compact = dev_spec.read_text(encoding="utf-8")
+        if compact.startswith("<!-- easy-coding:compact -->"):
+            mode, _ = calculate_workflow_floor(root, task_id)
+            if mode != "fast" or not has_valid_execution_plan(root, task_id):
+                raise StateError("Compact analysis requires a valid Fast implementation plan.")
+            if re.findall(r"^decision_status:\s*(\w+)\s*$", compact, re.MULTILINE) != ["closed"]:
+                raise StateError("Compact analysis must record the confirmed scope.")
+            return
+
     dev_spec_content = ""
     if not dev_spec.exists():
         reasons.append("dev-spec.md is missing")
@@ -6528,7 +6558,7 @@ def validate_analysis_readiness(
     plan_is_valid = has_valid_execution_plan(root, task_id)
     if not plan_is_valid:
         reasons.append("execution.jsonl has no valid plan record")
-    if tdd_enabled:
+    if unit_test_mode == "tdd":
         readiness = tdd_readiness(root)
         if readiness["status"] != "ready":
             reasons.append(
@@ -6591,6 +6621,8 @@ def validate_analysis_readiness(
                     dev_spec_content, strategy_content, baselines
                 )
             )
+    elif unit_test_mode == "ut":
+        pass
     elif task_type == TDD_INIT_TASK_TYPE:
         try:
             strategy_content = test_strategy.read_text(encoding="utf-8")
@@ -6940,12 +6972,12 @@ def snapshot_state(
         project_workflow_mode,
         session_workflow_mode,
         configured_workflow_mode,
-        project_tdd_enabled,
-        session_tdd_enabled,
-        effective_tdd_enabled,
-        project_tdd_coverage_threshold,
-        session_tdd_coverage_threshold,
-        effective_tdd_coverage_threshold,
+        project_unit_test_mode,
+        session_unit_test_mode,
+        effective_unit_test_mode,
+        project_ut_coverage_threshold,
+        session_ut_coverage_threshold,
+        effective_ut_coverage_threshold,
     ) = resolve_behavior(root, resolved_session)
     concrete_workflow_mode = None
     if task:
@@ -6953,26 +6985,26 @@ def snapshot_state(
         proposal = task.get("workflow_mode_proposal")
         if concrete_workflow_mode is None and isinstance(proposal, dict):
             concrete_workflow_mode = proposal.get("selected_mode")
-    task_tdd_enabled = task.get("tdd_enabled") if task else None
-    task_tdd_coverage_threshold = task.get("tdd_coverage_threshold") if task else None
-    frozen_tdd = bool(
+    task_unit_test_mode = task.get("unit_test_mode") if task else None
+    task_ut_coverage_threshold = task.get("ut_coverage_threshold") if task else None
+    frozen_unit_test = bool(
         task
         and status not in {"ANALYSIS", "INIT"}
-        and isinstance(task_tdd_enabled, bool)
+        and task_unit_test_mode in {"none", "ut", "tdd"}
     )
     is_tdd_init = bool(
         task and str(task.get("type") or "").strip().lower() == TDD_INIT_TASK_TYPE
     )
-    displayed_tdd_enabled = (
-        False if is_tdd_init else task_tdd_enabled if frozen_tdd else effective_tdd_enabled
+    displayed_unit_test_mode = (
+        "none" if is_tdd_init else task_unit_test_mode if frozen_unit_test else effective_unit_test_mode
     )
-    displayed_tdd_threshold = (
-        task_tdd_coverage_threshold
-        if frozen_tdd and isinstance(task_tdd_coverage_threshold, int)
-        else effective_tdd_coverage_threshold
+    displayed_ut_threshold = (
+        task_ut_coverage_threshold
+        if frozen_unit_test and isinstance(task_ut_coverage_threshold, int)
+        else effective_ut_coverage_threshold
     )
     should_check_readiness = bool(
-        effective_tdd_enabled or task_tdd_enabled is True or is_tdd_init
+        effective_unit_test_mode in {"ut", "tdd"} or task_unit_test_mode in {"ut", "tdd"} or is_tdd_init
     )
     readiness = (
         tdd_readiness(root)
@@ -6999,19 +7031,19 @@ def snapshot_state(
         "session_workflow_mode": session_workflow_mode,
         "configured_workflow_mode": configured_workflow_mode,
         "concrete_workflow_mode": concrete_workflow_mode,
-        "project_tdd_enabled": project_tdd_enabled,
-        "session_tdd_enabled": session_tdd_enabled,
-        "effective_tdd_enabled": effective_tdd_enabled,
-        "project_tdd_coverage_threshold": project_tdd_coverage_threshold,
-        "session_tdd_coverage_threshold": session_tdd_coverage_threshold,
-        "effective_tdd_coverage_threshold": effective_tdd_coverage_threshold,
-        "task_tdd_enabled": task_tdd_enabled,
-        "task_tdd_coverage_threshold": task_tdd_coverage_threshold,
+        "project_unit_test_mode": project_unit_test_mode,
+        "session_unit_test_mode": session_unit_test_mode,
+        "effective_unit_test_mode": effective_unit_test_mode,
+        "project_ut_coverage_threshold": project_ut_coverage_threshold,
+        "session_ut_coverage_threshold": session_ut_coverage_threshold,
+        "effective_ut_coverage_threshold": effective_ut_coverage_threshold,
+        "task_unit_test_mode": task_unit_test_mode,
+        "task_ut_coverage_threshold": task_ut_coverage_threshold,
         "task_tdd_baselines": task.get("tdd_baselines") if task else None,
-        "displayed_tdd_enabled": displayed_tdd_enabled,
-        "displayed_tdd_coverage_threshold": displayed_tdd_threshold,
-        "tdd_readiness_status": readiness["status"],
-        "tdd_readiness_reasons": readiness["reasons"],
+        "displayed_unit_test_mode": displayed_unit_test_mode,
+        "displayed_ut_coverage_threshold": displayed_ut_threshold,
+        "unit_test_readiness_status": readiness["status"],
+        "unit_test_readiness_reasons": readiness["reasons"],
         "spec_summary": spec_task_summary(task),
         # Compatibility output aliases for pre-0.9 clients.
         "project_confirm_mode": project_approval_mode,
@@ -7044,8 +7076,8 @@ def build_status_line(
     approval = str(state["effective_approval_mode"]).capitalize()
     workflow = str(state["concrete_workflow_mode"] or state["configured_workflow_mode"]).capitalize()
     status_brand = f"> **Easy Coding** · **Approval: {approval}** · **Workflow: {workflow}**"
-    if state["displayed_tdd_enabled"] is True:
-        status_brand += " · **TDD**"
+    if state["displayed_unit_test_mode"] in {"ut", "tdd"}:
+        status_brand += f" · **{state['displayed_unit_test_mode'].upper()}**"
     task_id = state["current_task"]
     if task_id:
         status = str(state["status"])
@@ -7090,10 +7122,10 @@ def build_machine_breadcrumbs(
     ]
     if state.get("concrete_workflow_mode"):
         lines.append(f"[easy-coding:workflow-mode:{state['concrete_workflow_mode']}]")
-    if state.get("displayed_tdd_enabled") is True:
-        lines.append("[easy-coding:tdd:enabled]")
+    if state.get("displayed_unit_test_mode") in {"ut", "tdd"}:
+        lines.append(f"[easy-coding:unit-test-mode:{state['displayed_unit_test_mode']}]")
         lines.append(
-            f"[easy-coding:tdd-coverage-threshold:{state['displayed_tdd_coverage_threshold']}]"
+            f"[easy-coding:ut-coverage-threshold:{state['displayed_ut_coverage_threshold']}]"
         )
 
     if task_id:
@@ -7423,42 +7455,43 @@ def clear_session_workflow_mode(
     return snapshot
 
 
-def set_session_tdd(
+def set_session_unit_test_mode(
     root: Path,
-    enabled: bool,
+    mode: str,
     agent: str,
     threshold: int | None = None,
     session_file: str | Path | None = None,
 ) -> dict:
-    if enabled:
+    mode = parse_unit_test_mode(mode, "session unit_test_mode")
+    if mode != "none":
         require_tdd_readiness(root)
     session = ensure_session(root, session_file)
     materialize_legacy_session_behavior(session)
-    session["tdd_enabled"] = enabled
+    session["unit_test_mode"] = mode
     if threshold is not None:
-        session["tdd_coverage_threshold"] = parse_tdd_threshold(
-            threshold, "session tdd_coverage_threshold"
+        session["ut_coverage_threshold"] = parse_ut_threshold(
+            threshold, "session ut_coverage_threshold"
         )
     session["last_agent"] = agent
     write_session(root, session, session_file)
     snapshot = snapshot_state(root, session_file, session)
-    snapshot["action"] = "set-tdd"
+    snapshot["action"] = "set-unit-test-mode"
     return snapshot
 
 
-def clear_session_tdd(
+def clear_session_unit_test_mode(
     root: Path,
     agent: str,
     session_file: str | Path | None = None,
 ) -> dict:
     session = ensure_session(root, session_file)
     materialize_legacy_session_behavior(session)
-    session.pop("tdd_enabled", None)
-    session.pop("tdd_coverage_threshold", None)
+    session.pop("unit_test_mode", None)
+    session.pop("ut_coverage_threshold", None)
     session["last_agent"] = agent
     write_session(root, session, session_file)
     snapshot = snapshot_state(root, session_file, session)
-    snapshot["action"] = "clear-tdd"
+    snapshot["action"] = "clear-unit-test-mode"
     return snapshot
 
 
@@ -8592,7 +8625,8 @@ def reconcile_local_result_evidence(
             and check.get("passed") is True
             and is_non_empty_string(check.get("command"))
         }
-        missing_unit_commands = sorted(set(unit.get("test_commands", [])) - passed_commands)
+        missing_unit_commands = sorted(command for command in unit.get("test_commands", [])
+                                       if not any(command_covers(actual, command) for actual in passed_commands))
         if missing_unit_commands:
             unresolved.append(
                 f"{unit_id}:missing-passed-command=" + ",".join(missing_unit_commands)
@@ -8630,7 +8664,7 @@ def reconcile_local_result_evidence(
             missing_commands = [
                 str(test.get("command"))
                 for test in tests
-                if str(test.get("command")) not in passed_commands
+                if not any(command_covers(actual, str(test.get("command"))) for actual in passed_commands)
             ]
             if missing_commands:
                 unresolved.append(
@@ -9035,23 +9069,29 @@ def sync_spec_design_state(
     progress.pop("pending_action", None)
     task.pop("spec_change", None)
     task.pop("spec_context", None)
-    if task.get("status") not in {"INIT", "ANALYSIS"}:
-        cleanup_verification_checkpoint(root, resolved_task_id, task)
-        task["status"] = "ANALYSIS"
-        append_stage_history(task, "ANALYSIS", agent)
-    task.pop("pending_transition", None)
-    task["last_agent"] = agent
     already_acknowledged = any(
         record.get("type") == "spec-design-sync"
         and record.get("idempotency_key") == idempotency_key
         for record in execution_records(root, resolved_task_id)
     )
+    if task.get("correction") and not already_acknowledged:
+        refresh_correction_plan(root, resolved_task_id, task, inspection)
+    if task.get("correction") and not already_acknowledged:
+        task["status"] = "IMPLEMENT"
+        append_stage_history(task, "IMPLEMENT", agent)
+    if not task.get("correction") and task.get("status") not in {"INIT", "ANALYSIS"}:
+        cleanup_verification_checkpoint(root, resolved_task_id, task)
+        task["status"] = "ANALYSIS"
+        append_stage_history(task, "ANALYSIS", agent)
+    task.pop("pending_transition", None)
+    task["last_agent"] = agent
     if not already_acknowledged:
         append_execution_record(
             root,
             resolved_task_id,
             {
                 "type": "spec-design-sync",
+                "preserve_plan": bool(task.get("correction")),
                 "affected_task_ids": requested_task_ids,
                 "event_id": event["event_id"],
                 "design_sha256": details["design_sha256"],
@@ -9061,6 +9101,10 @@ def sync_spec_design_state(
             },
         )
     write_task(root, resolved_task_id, task)
+    if task.get("correction"):
+        writeback_ready_tasks_for_implement(root, resolved_task_id, task, agent,
+                                           source_task_ids=set(requested_task_ids),
+                                           restart_statuses={"not_started"})
     snapshot = snapshot_state(root, session_file, session)
     snapshot["action"] = "sync-spec-design"
     return snapshot
@@ -9297,7 +9341,7 @@ def writeback_verified_tasks(
                     if record.get("passed") is True
                     and str(record.get("source_task_id") or "") == source_task_id
                     and str(record.get("repo_id") or "") == repo_id
-                    and str(record.get("command") or "") == command
+                    and command_covers(str(record.get("command") or ""), command)
                 ),
                 None,
             )
@@ -9569,52 +9613,16 @@ def resolve_current_task(
 
 
 def validate_workflow_mode_proposal(
-    root: Path,
-    session: dict,
-    proposal: object,
-    task_id: str | None = None,
+    root: Path, session: dict, proposal: object, task_id: str | None = None,
 ) -> dict:
-    if not isinstance(proposal, dict):
-        raise StateError("workflow_mode_proposal is missing.")
-    configured = str(proposal.get("configured_mode") or "")
-    selected = str(proposal.get("selected_mode") or "")
-    minimum = str(proposal.get("minimum_mode") or "")
-    source = str(proposal.get("source") or "")
-    reasons = proposal.get("reasons")
-    effective_configured = resolve_behavior(root, session)[5]
-    if configured != effective_configured:
-        raise StateError(
-            "Workflow proposal configured_mode no longer matches the effective project/session setting."
-        )
-    if configured not in CONFIGURED_WORKFLOW_MODES:
-        raise StateError("Invalid configured workflow mode.")
-    if selected not in WORKFLOW_MODES or minimum not in WORKFLOW_MODES:
-        raise StateError("selected_mode and minimum_mode must be fast, standard, or strict.")
-    if source not in {"project", "session", "adaptive", "user", "migration"}:
-        raise StateError("Invalid workflow proposal source.")
-    if not is_string_list(reasons, allow_empty=False):
-        raise StateError("Workflow proposal reasons must contain at least one non-empty reason.")
-    required_rank = WORKFLOW_MODE_RANK[minimum]
-    if configured in WORKFLOW_MODES and WORKFLOW_MODE_RANK[minimum] < WORKFLOW_MODE_RANK[configured]:
-        raise StateError(
-            f"Workflow minimum {minimum} is below configured floor {configured}."
-        )
-    if task_id:
-        calculated_minimum, calculated_reasons = calculate_workflow_floor(root, task_id)
-        calculated_rank = WORKFLOW_MODE_RANK[calculated_minimum]
-        if WORKFLOW_MODE_RANK[minimum] < calculated_rank:
-            raise StateError(
-                f"Workflow minimum {minimum} is below calculated floor {calculated_minimum}: "
-                + ", ".join(calculated_reasons)
-            )
-        required_rank = max(required_rank, calculated_rank)
-    if configured in WORKFLOW_MODES:
-        required_rank = max(required_rank, WORKFLOW_MODE_RANK[configured])
-    if WORKFLOW_MODE_RANK[selected] < required_rank:
-        raise StateError(
-            f"Workflow mode {selected} is below the allowed minimum for this task."
-        )
-    return proposal
+    if task_id is None:
+        raise StateError("A task is required to calculate the mechanical workflow mode.")
+    mode, reasons = calculate_workflow_floor(root, task_id)
+    return {
+        "configured_mode": resolve_behavior(root, session)[5],
+        "selected_mode": mode, "minimum_mode": mode, "source": "adaptive",
+        "reasons": reasons,
+    }
 
 
 def calculate_workflow_floor(root: Path, task_id: str) -> tuple[str, list[str]]:
@@ -9626,6 +9634,12 @@ def calculate_workflow_floor(root: Path, task_id: str) -> tuple[str, list[str]]:
     if not plan:
         raise StateError("Cannot calculate workflow floor without a valid execution plan.")
     units = [unit for unit in plan.get("units", []) if isinstance(unit, dict)]
+    correction = task.get("correction")
+    if isinstance(correction, dict):
+        files = set(correction["files"])
+        units = [{**unit, "files": sorted(set(unit.get("files", [])) & files),
+                  "risks": correction.get("risks", []), "contracts": []}
+                 for unit in units if unit["id"] in correction["unit_ids"]]
     missing_local_baseline = [
         str(unit.get("id") or "<unknown>")
         for unit in units
@@ -9642,7 +9656,7 @@ def calculate_workflow_floor(root: Path, task_id: str) -> tuple[str, list[str]]:
         for file_name in unit.get("files", [])
         if is_non_empty_string(file_name)
     }
-    repositories = workflow_plan_repository_roots(root, task, plan)
+    repositories = workflow_plan_repository_roots(root, task, {"units": units})
     ignored_values = {"none", "no", "n/a", "无", "无风险"}
     risk_values = [
         str(item)
@@ -9711,7 +9725,7 @@ def propose_workflow_mode(
         "proposed_at": now_iso(),
         "proposed_by": agent,
     }
-    validate_workflow_mode_proposal(root, session, proposal, resolved_task_id)
+    proposal.update(validate_workflow_mode_proposal(root, session, proposal, resolved_task_id))
     task["workflow_mode_proposal"] = proposal
     task["last_agent"] = agent
     write_task(root, resolved_task_id, task)
@@ -9731,35 +9745,36 @@ def freeze_workflow_mode(
     task["workflow_mode_confirmed_by"] = agent
 
 
-def freeze_tdd_mode(
+def freeze_unit_test_mode(
     root: Path, session: dict, task_id: str, task: dict, agent: str
 ) -> None:
     behavior = resolve_behavior(root, session)
     task_type = str(task.get("type") or "").strip().lower()
-    task["tdd_enabled"] = (
-        behavior[8] if task_type != TDD_INIT_TASK_TYPE else False
+    task["unit_test_mode"] = (
+        behavior[8] if task_type != TDD_INIT_TASK_TYPE else "none"
     )
-    task["tdd_coverage_threshold"] = behavior[11]
-    if task["tdd_enabled"] is True:
+    task["ut_coverage_threshold"] = behavior[11]
+    if task["unit_test_mode"] in {"ut", "tdd"}:
         require_tdd_readiness(root)
         plan = latest_execution_plan(root, task_id)
         if plan is None:
-            raise StateError("Cannot freeze TDD baseline without a valid execution plan.")
+            raise StateError("Cannot freeze unit test baseline without a valid execution plan.")
         baselines = {
             key: git_head_sha(repository)
             for key, repository in tdd_repositories(root, task, plan).items()
         }
-        task_dir = task_json_path(root, task_id).parent
-        try:
-            dev_spec_content = (task_dir / "dev-spec.md").read_text(encoding="utf-8")
-            strategy_content = (task_dir / "test-strategy.md").read_text(encoding="utf-8")
-        except OSError as error:
-            raise StateError("Cannot freeze TDD without readable analysis artifacts.") from error
-        marker_reasons = tdd_baseline_marker_reasons(
-            dev_spec_content, strategy_content, baselines
-        )
-        if marker_reasons:
-            raise StateError("; ".join(marker_reasons))
+        if task["unit_test_mode"] == "tdd":
+            task_dir = task_json_path(root, task_id).parent
+            try:
+                dev_spec_content = (task_dir / "dev-spec.md").read_text(encoding="utf-8")
+                strategy_content = (task_dir / "test-strategy.md").read_text(encoding="utf-8")
+            except OSError as error:
+                raise StateError("Cannot freeze TDD without readable analysis artifacts.") from error
+            marker_reasons = tdd_baseline_marker_reasons(
+                dev_spec_content, strategy_content, baselines
+            )
+            if marker_reasons:
+                raise StateError("; ".join(marker_reasons))
         task["tdd_baselines"] = baselines
     else:
         task.pop("tdd_baselines", None)
@@ -9784,21 +9799,8 @@ def raise_workflow_mode(
         )
     if stage != "IMPLEMENT":
         raise StateError("A frozen workflow mode can only be raised during active execution.")
-    current = str(task.get("workflow_mode") or "")
-    if current not in WORKFLOW_MODES or mode not in WORKFLOW_MODES:
-        raise StateError("Workflow mode must be frozen before it can be raised.")
-    if WORKFLOW_MODE_RANK[mode] <= WORKFLOW_MODE_RANK[current]:
-        raise StateError(f"Workflow mode can only be raised above {current}.")
+    mode, _reasons = calculate_workflow_floor(root, resolved_task_id)
     task["workflow_mode"] = mode
-    task.setdefault("workflow_mode_escalations", []).append(
-        {
-            "from": current,
-            "to": mode,
-            "reason": reason.strip(),
-            "raised_at": now_iso(),
-            "raised_by": agent,
-        }
-    )
     task["last_agent"] = agent
     write_task(root, resolved_task_id, task)
     snapshot = snapshot_state(root, session_file, session)
@@ -9932,7 +9934,7 @@ def apply_transition(
         validate_analysis_readiness(root, resolved_task_id, session)
         if task.get("workflow_mode_legacy") is not True:
             freeze_workflow_mode(root, session, resolved_task_id, task, agent)
-        freeze_tdd_mode(root, session, resolved_task_id, task, agent)
+        freeze_unit_test_mode(root, session, resolved_task_id, task, agent)
     repair_source_task_ids: set[str] | None = None
     quality_exit_outcome: str | None = None
     if previous == "QUALITY" and stage in {"IMPLEMENT", "ANALYSIS"}:
@@ -9987,7 +9989,7 @@ def apply_transition(
     if (
         previous == "QUALITY"
         and stage in {"IMPLEMENT", "ANALYSIS"}
-        and quality_exit_outcome in {"repair", "replan"}
+        and quality_exit_outcome in {"repair", "replan", "cancelled"}
     ):
         quality_records = validated_quality_records(root, resolved_task_id)
         task["quality_consumed_attempt"] = quality_records[-1][1]["attempt"]
@@ -10012,6 +10014,11 @@ def apply_transition(
         task = load_task(root, resolved_task_id) or task
     if stage in {"ANALYSIS", "IMPLEMENT", "MEMORY", "COMPLETE", "CLOSED"}:
         cleanup_verification_checkpoint(root, resolved_task_id, task)
+    if previous == "IMPLEMENT" and stage == "QUALITY":
+        quality_records = validated_quality_records(root, resolved_task_id)
+        if quality_records:
+            task["quality_consumed_attempt"] = quality_records[-1][1]["attempt"]
+        task.pop("quality_return_required", None)
     task.pop("pending_transition", None)
     if stage == "MEMORY" and previous != stage:
         task["memory_progress"] = {}
@@ -10501,6 +10508,7 @@ def parse_evidence_args(values: list[str]) -> list[dict]:
     return evidence
 
 
+@evidence_operation()
 def main() -> int:
     configure_stdio()
     common = argparse.ArgumentParser(add_help=False)
@@ -10638,13 +10646,13 @@ def main() -> int:
     clear_workflow_mode_parser = subcommands.add_parser("clear-workflow-mode", parents=[common])
     clear_workflow_mode_parser.add_argument("--agent", required=True)
 
-    set_tdd_parser = subcommands.add_parser("set-tdd", parents=[common])
-    set_tdd_parser.add_argument("--enabled", required=True, choices=["true", "false"])
-    set_tdd_parser.add_argument("--threshold", type=int)
-    set_tdd_parser.add_argument("--agent", required=True)
+    set_unit_test_parser = subcommands.add_parser("set-unit-test-mode", parents=[common])
+    set_unit_test_parser.add_argument("--mode", required=True, choices=["none", "ut", "tdd"])
+    set_unit_test_parser.add_argument("--threshold", type=int)
+    set_unit_test_parser.add_argument("--agent", required=True)
 
-    clear_tdd_parser = subcommands.add_parser("clear-tdd", parents=[common])
-    clear_tdd_parser.add_argument("--agent", required=True)
+    clear_unit_test_parser = subcommands.add_parser("clear-unit-test-mode", parents=[common])
+    clear_unit_test_parser.add_argument("--agent", required=True)
 
     # Compatibility aliases for pre-0.9 callers.
     set_confirm_mode_parser = subcommands.add_parser("set-confirm-mode", parents=[common])
@@ -10660,20 +10668,20 @@ def main() -> int:
         "propose-workflow-mode", parents=[common]
     )
     propose_workflow_parser.add_argument(
-        "--configured", required=True, choices=sorted(CONFIGURED_WORKFLOW_MODES)
+        "--configured", default="adaptive", choices=sorted(CONFIGURED_WORKFLOW_MODES)
     )
     propose_workflow_parser.add_argument(
-        "--selected", required=True, choices=sorted(WORKFLOW_MODES)
+        "--selected", default="fast", choices=sorted(WORKFLOW_MODES)
     )
     propose_workflow_parser.add_argument(
-        "--minimum", required=True, choices=sorted(WORKFLOW_MODES)
+        "--minimum", default="fast", choices=sorted(WORKFLOW_MODES)
     )
     propose_workflow_parser.add_argument(
         "--source",
-        required=True,
+        default="adaptive",
         choices=["project", "session", "adaptive", "user", "migration"],
     )
-    propose_workflow_parser.add_argument("--reason", required=True, action="append")
+    propose_workflow_parser.add_argument("--reason", action="append", default=[])
     propose_workflow_parser.add_argument("--agent", required=True)
     propose_workflow_parser.add_argument("--task-id")
 
@@ -10691,6 +10699,22 @@ def main() -> int:
     fingerprints_parser.add_argument("--agent", required=True)
     fingerprints_parser.add_argument("--task-id")
 
+    for name in ("prepare-check", "record-check"):
+        check_parser = subcommands.add_parser(name, parents=[common])
+        check_parser.add_argument("--agent", required=True)
+        check_parser.add_argument("--task-id")
+        if name == "prepare-check":
+            check_parser.add_argument("--record", required=True)
+        else:
+            check_parser.add_argument("--prepared-id", required=True)
+            check_parser.add_argument("--result", required=True)
+    correction_parser = subcommands.add_parser("begin-correction", parents=[common])
+    correction_parser.add_argument("--file", action="append", required=True)
+    correction_parser.add_argument("--summary", required=True)
+    correction_parser.add_argument("--risk", action="append", default=[])
+    correction_parser.add_argument("--agent", required=True)
+    correction_parser.add_argument("--task-id")
+
     finalize_quality_parser = subcommands.add_parser(
         "finalize-quality", parents=[common]
     )
@@ -11139,13 +11163,13 @@ def main() -> int:
                     session_file,
                 )
             )
-        elif command == "set-tdd":
+        elif command == "set-unit-test-mode":
             emit(
                 attach_status_context(
                     root,
-                    set_session_tdd(
+                    set_session_unit_test_mode(
                         root,
-                        args.enabled == "true",
+                        args.mode,
                         agent,
                         args.threshold,
                         session_file,
@@ -11154,11 +11178,11 @@ def main() -> int:
                     session_file,
                 )
             )
-        elif command == "clear-tdd":
+        elif command == "clear-unit-test-mode":
             emit(
                 attach_status_context(
                     root,
-                    clear_session_tdd(root, agent, session_file),
+                    clear_session_unit_test_mode(root, agent, session_file),
                     agent,
                     session_file,
                 )
@@ -11261,6 +11285,16 @@ def main() -> int:
                     session_file,
                 )
             )
+        elif command in {"prepare-check", "record-check", "begin-correction"}:
+            session, task_id, task = resolve_current_task(root, args.task_id, session_file)
+            require_spec_context(root, task, agent, session_file)
+            if command == "prepare-check":
+                result = prepare_check(root, task_id, task, json.loads(args.record), agent)
+            elif command == "record-check":
+                result = record_check(root, task_id, task, args.prepared_id, json.loads(args.result), agent)
+            else:
+                result = begin_correction(root, task_id, task, args.file, args.summary, args.risk, agent)
+            emit(result)
         elif command == "finalize-quality":
             emit(
                 attach_status_context(
@@ -11547,7 +11581,7 @@ def main() -> int:
                 )
             )
         return 0
-    except (StateError, EasyDevSpecError) as error:
+    except (StateError, EasyDevSpecError, ValueError) as error:
         print(json.dumps({"error": str(error)}, ensure_ascii=False), file=sys.stderr)
         return 1
     finally: