@hunter-harness/workflow-harness 0.2.30 → 0.2.31

package/harness/bundles/java/cursor/scripts/harness_plan_finalize.py

@@ -51,6 +51,28 @@ def _result_error(code: str, message: str) -> dict[str, Any]:
     return {"ok": False, "code": code, "error": message}
 
 
+def _normalize_header(value: str) -> str:
+    return re.sub(r"[\s_-]+", "", value).lower()
+
+
+def _column_index(
+    headers: list[str],
+    *aliases: str,
+) -> int | None:
+    normalized = {
+        _normalize_header(header): index for index, header in enumerate(headers)
+    }
+    for alias in aliases:
+        index = normalized.get(_normalize_header(alias))
+        if index is not None:
+            return index
+    return None
+
+
+def _table_cells(line: str) -> list[str]:
+    return [cell.strip() for cell in line.strip().strip("|").split("|")]
+
+
 def parse_test_scenarios(scenarios_path: Path) -> list[dict[str, str]]:
     """C9: parse test-scenarios.md tables, extracting scenario rows.
 
@@ -60,42 +82,100 @@ def parse_test_scenarios(scenarios_path: Path) -> list[dict[str, str]]:
     text = Path(scenarios_path).read_text(encoding="utf-8-sig")
     lines = text.splitlines()
     scenarios: list[dict[str, str]] = []
-    # Find all tables whose header includes "ID" and "优先级" (or "priority").
     i = 0
     while i < len(lines):
         line = lines[i].strip()
-        if line.startswith("|") and "ID" in line and ("优先级" in line or "priority" in line):
-            header_line = line
-            headers = [h.strip() for h in header_line.strip("|").split("|")]
-            col_map: dict[str, int] = {}
-            for idx, name in enumerate(headers):
-                key = name.lower()
-                col_map[key] = idx
-            # Skip separator row
-            i += 2
-            while i < len(lines):
-                row = lines[i].strip()
+        if line.startswith("|"):
+            headers = _table_cells(line)
+            id_index = _column_index(headers, "ID", "#", "编号", "场景 ID")
+            scenario_index = _column_index(
+                headers,
+                "场景",
+                "场景描述",
+                "scenario",
+                "description",
+            )
+            if id_index is None or scenario_index is None:
+                i += 1
+                continue
+            priority_index = _column_index(headers, "优先级", "priority")
+            category_index = _column_index(headers, "分类", "category")
+            verification_index = _column_index(
+                headers,
+                "验证方式",
+                "verification",
+                "可复用证据",
+            )
+            owner_phase_index = _column_index(
+                headers,
+                "owner phase",
+                "ownerPhase",
+                "负责阶段",
+            )
+            execution_tier_index = _column_index(
+                headers,
+                "执行层级",
+                "execution tier",
+                "tier",
+            )
+            expected_index = _column_index(headers, "预期", "expected")
+
+            row_index = i + 2
+            while row_index < len(lines):
+                row = lines[row_index].strip()
                 if not row.startswith("|"):
                     break
-                cells = [c.strip() for c in row.strip("|").split("|")]
-                if len(cells) < len(headers):
-                    i += 1
+                cells = _table_cells(row)
+                if max(id_index, scenario_index) >= len(cells):
+                    row_index += 1
                     continue
-                scenario: dict[str, str] = {}
-                for cn, en in (
-                    ("ID", "id"),
-                    ("优先级", "priority"),
-                    ("场景", "scenario"),
-                    ("验证方式", "verification"),
-                    ("owner phase", "ownerPhase"),
+                complete_row = len(cells) == len(headers)
+                scenario_id = cells[id_index].strip()
+                if not scenario_id or set(scenario_id) <= {"-", ":"}:
+                    row_index += 1
+                    continue
+                priority = (
+                    cells[priority_index].strip().upper()
+                    if priority_index is not None
+                    and priority_index < len(cells)
+                    and cells[priority_index].strip()
+                    else "P1"
+                )
+                scenario = {
+                    "id": scenario_id,
+                    "priority": priority,
+                    "scenario": cells[scenario_index].strip(),
+                    "ownerPhase": (
+                        cells[owner_phase_index].strip()
+                        if owner_phase_index is not None
+                        and complete_row
+                        and owner_phase_index < len(cells)
+                        and cells[owner_phase_index].strip()
+                        else "test"
+                    ),
+                    "requiredEvidenceKind": PRIORITY_EVIDENCE_KIND.get(
+                        priority,
+                        "advisory",
+                    ),
+                }
+                if category_index is not None and category_index < len(cells):
+                    if cells[category_index].strip():
+                        scenario["category"] = cells[category_index].strip()
+                for key, index in (
+                    ("verification", verification_index),
+                    ("executionTier", execution_tier_index),
+                    ("expected", expected_index),
                 ):
-                    if cn.lower() in col_map:
-                        scenario[en] = cells[col_map[cn.lower()]]
-                # Derive requiredEvidenceKind from priority
-                priority = scenario.get("priority", "")
-                scenario["requiredEvidenceKind"] = PRIORITY_EVIDENCE_KIND.get(priority, "advisory")
+                    if (
+                        complete_row
+                        and index is not None
+                        and index < len(cells)
+                        and cells[index].strip()
+                    ):
+                        scenario[key] = cells[index].strip()
                 scenarios.append(scenario)
-                i += 1
+                row_index += 1
+            i = row_index
             continue
         i += 1
     return scenarios
@@ -110,40 +190,52 @@ def parse_plan_tasks(plan_path: Path) -> list[dict[str, str]]:
     """
     text = Path(plan_path).read_text(encoding="utf-8-sig")
     lines = text.splitlines()
-    # Find the task table: a header row starting with "| #" followed by a separator row.
-    header_idx = -1
-    for i, line in enumerate(lines):
-        stripped = line.strip()
-        if stripped.startswith("|") and "#" in stripped and "任务" in stripped:
-            header_idx = i
-            break
-    if header_idx < 0:
-        return []
-    header_line = lines[header_idx]
-    headers = [h.strip() for h in header_line.strip().strip("|").split("|")]
-    # Map header names to column indices (case-insensitive, English keys).
-    col_map: dict[str, int] = {}
-    for idx, name in enumerate(headers):
-        key = name.lower()
-        col_map[key] = idx
     tasks: list[dict[str, str]] = []
-    for line in lines[header_idx + 2 :]:  # skip header + separator
-        stripped = line.strip()
-        if not stripped.startswith("|"):
-            break  # end of table
-        cells = [c.strip() for c in stripped.strip("|").split("|")]
-        if len(cells) < len(headers):
+    i = 0
+    while i < len(lines):
+        line = lines[i].strip()
+        if not line.startswith("|"):
+            i += 1
+            continue
+        headers = _table_cells(line)
+        number_index = _column_index(headers, "#", "任务编号", "task ID")
+        task_index = _column_index(headers, "任务", "task")
+        if number_index is None or task_index is None:
+            i += 1
             continue
-        task: dict[str, str] = {}
-        # Chinese headers
-        for cn, en in (("#", "num"), ("簇", "cluster"), ("任务", "task")):
-            if cn in col_map:
-                task[en] = cells[col_map[cn]]
-        # English optional columns
-        for en in ("ownerPhase", "implementationDoneWhen", "verificationPhase", "requiresExplicitAuthority"):
-            if en.lower() in col_map:
-                task[en] = cells[col_map[en.lower()]]
-        tasks.append(task)
+        cluster_index = _column_index(headers, "簇", "cluster")
+        optional_indices = {
+            name: _column_index(headers, name)
+            for name in (
+                "ownerPhase",
+                "implementationDoneWhen",
+                "verificationPhase",
+                "requiresExplicitAuthority",
+            )
+        }
+        row_index = i + 2
+        while row_index < len(lines):
+            row = lines[row_index].strip()
+            if not row.startswith("|"):
+                break
+            cells = _table_cells(row)
+            if len(cells) < len(headers):
+                row_index += 1
+                continue
+            number = cells[number_index].strip()
+            task_text = cells[task_index].strip()
+            if not number or not task_text or set(number) <= {"-", ":"}:
+                row_index += 1
+                continue
+            task: dict[str, str] = {"num": number, "task": task_text}
+            if cluster_index is not None and cells[cluster_index].strip():
+                task["cluster"] = cells[cluster_index].strip()
+            for name, index in optional_indices.items():
+                if index is not None and cells[index].strip():
+                    task[name] = cells[index].strip()
+            tasks.append(task)
+            row_index += 1
+        i = row_index
     return tasks
 
 
@@ -325,6 +417,20 @@ def validate_staging(staging: Path, change_name: str) -> dict[str, Any]:
     # C8: validate ownerPhase values in plan.md task table.
     plan_path = staging / "plans" / f"{change_name}-plan.md"
     tasks = parse_plan_tasks(plan_path)
+    if not tasks:
+        return _result_error(
+            "PLAN_TASKS_EMPTY",
+            f"{plan_path.relative_to(staging).as_posix()}: no task rows were parsed",
+        )
+    task_ids = [str(task.get("num") or "").strip() for task in tasks]
+    duplicate_task_ids = sorted(
+        {task_id for task_id in task_ids if task_ids.count(task_id) > 1}
+    )
+    if duplicate_task_ids:
+        return _result_error(
+            "PLAN_TASK_ID_DUPLICATE",
+            "duplicate task IDs: " + ", ".join(duplicate_task_ids),
+        )
     for task in tasks:
         owner = task.get("ownerPhase")
         if owner is not None and owner != "" and owner not in VALID_OWNER_PHASES:
@@ -339,6 +445,37 @@ def validate_staging(staging: Path, change_name: str) -> dict[str, Any]:
     # C9: parse test-scenarios.md for scenario manifest.
     scenarios_path = staging / "plans" / f"{change_name}-test-scenarios.md"
     scenarios = parse_test_scenarios(scenarios_path)
+    if not scenarios:
+        return _result_error(
+            "PLAN_SCENARIOS_EMPTY",
+            f"{scenarios_path.relative_to(staging).as_posix()}: no scenario rows were parsed",
+        )
+    scenario_ids = [str(item.get("id") or "").strip() for item in scenarios]
+    duplicate_scenario_ids = sorted(
+        {
+            scenario_id
+            for scenario_id in scenario_ids
+            if scenario_ids.count(scenario_id) > 1
+        }
+    )
+    if duplicate_scenario_ids:
+        return _result_error(
+            "PLAN_SCENARIO_ID_DUPLICATE",
+            "duplicate scenario IDs: " + ", ".join(duplicate_scenario_ids),
+        )
+    for scenario in scenarios:
+        priority = str(scenario.get("priority") or "").upper()
+        if priority not in PRIORITY_EVIDENCE_KIND:
+            return _result_error(
+                "PLAN_SCENARIO_PRIORITY_INVALID",
+                f"scenario {scenario.get('id', '?')}: unsupported priority '{priority}'",
+            )
+        owner = str(scenario.get("ownerPhase") or "")
+        if owner not in VALID_OWNER_PHASES:
+            return _result_error(
+                "PLAN_SCENARIO_OWNER_PHASE_INVALID",
+                f"scenario {scenario.get('id', '?')}: unsupported ownerPhase '{owner}'",
+            )
 
     digest = hashlib.sha256()
     artifact_names: list[str] = []
@@ -374,6 +511,37 @@ def _terminal_exists(change_dir: Path, run_id: str, attempt: int) -> bool:
     )
 
 
+def _validate_plan_start(
+    change_dir: Path,
+    run_id: str,
+    attempt: int,
+) -> dict[str, Any]:
+    events_path = harness_events.events_path(change_dir)
+    try:
+        events = harness_events.load_events(events_path)
+    except (OSError, ValueError) as exc:
+        return _result_error("EVENTS_PARSE_ERROR", str(exc))
+    matching = [
+        event
+        for event in events
+        if event.get("phase") == "plan"
+        and event.get("type") == "phase.start"
+        and event.get("run_id") == run_id
+        and event.get("attempt") == attempt
+    ]
+    if not matching:
+        return _result_error(
+            "PHASE_START_MISSING",
+            "no matching plan phase.start event found for finalizer runId/attempt",
+        )
+    if len(matching) > 1:
+        return _result_error(
+            "PHASE_START_DUPLICATE",
+            f"found {len(matching)} matching plan phase.start events",
+        )
+    return {"ok": True, "phaseStartCount": 1}
+
+
 def verify_plan(change_dir: Path) -> dict[str, Any]:
     """Read-only verification of a finalized plan (retro §5.8).
 
@@ -405,6 +573,18 @@ def verify_plan(change_dir: Path) -> dict[str, Any]:
     files_list = receipt.get("files")
     if not isinstance(files_list, list) or not files_list:
         return _result_error("RECEIPT_INVALID", "receipt files list missing or empty")
+    if receipt.get("status") != "finalized":
+        return _result_error(
+            "RECEIPT_NOT_FINALIZED",
+            f"receipt status is {receipt.get('status')!r}, expected 'finalized'",
+        )
+    receipt_run_id = str(receipt.get("runId") or "").strip()
+    receipt_attempt = receipt.get("attempt")
+    if not receipt_run_id or not isinstance(receipt_attempt, int):
+        return _result_error(
+            "RECEIPT_INVALID",
+            "receipt runId/attempt identity is missing or malformed",
+        )
 
     # Recompute artifacts hash from published files.
     digest = hashlib.sha256()
@@ -453,19 +633,105 @@ def verify_plan(change_dir: Path) -> dict[str, Any]:
             "status": fm.get("status"),
         }
 
+    plan_path = change_dir / "plans" / f"{change_name}-plan.md"
+    expected_tasks = parse_plan_tasks(plan_path)
+    if not expected_tasks:
+        return _result_error(
+            "PLAN_TASKS_EMPTY",
+            f"no task rows parsed from {plan_path.relative_to(change_dir).as_posix()}",
+        )
+    checkpoints_path = change_dir / "meta" / "implementation-checkpoints.json"
+    if not checkpoints_path.is_file():
+        return _result_error(
+            "IMPLEMENTATION_CHECKPOINTS_MISSING",
+            f"derived task metadata missing: {checkpoints_path}",
+        )
+    try:
+        checkpoints = json.loads(
+            checkpoints_path.read_text(encoding="utf-8-sig")
+        )
+    except (OSError, json.JSONDecodeError) as exc:
+        return _result_error("IMPLEMENTATION_CHECKPOINTS_INVALID", str(exc))
+    actual_tasks = checkpoints.get("tasks") if isinstance(checkpoints, dict) else None
+    expected_task_ids = [str(item.get("num") or "") for item in expected_tasks]
+    actual_task_ids = (
+        [str(item.get("num") or "") for item in actual_tasks if isinstance(item, dict)]
+        if isinstance(actual_tasks, list)
+        else []
+    )
+    if expected_task_ids != actual_task_ids:
+        return _result_error(
+            "IMPLEMENTATION_CHECKPOINTS_DRIFT",
+            "derived task IDs do not match the finalized plan: "
+            f"expected={expected_task_ids}, actual={actual_task_ids}",
+        )
+
+    scenarios_path = (
+        change_dir / "plans" / f"{change_name}-test-scenarios.md"
+    )
+    expected_scenarios = parse_test_scenarios(scenarios_path)
+    if not expected_scenarios:
+        return _result_error(
+            "PLAN_SCENARIOS_EMPTY",
+            f"no scenario rows parsed from {scenarios_path.relative_to(change_dir).as_posix()}",
+        )
+    scenario_manifest_path = change_dir / "meta" / "scenario-manifest.json"
+    if not scenario_manifest_path.is_file():
+        return _result_error(
+            "SCENARIO_MANIFEST_MISSING",
+            f"derived scenario metadata missing: {scenario_manifest_path}",
+        )
+    try:
+        manifest = json.loads(
+            scenario_manifest_path.read_text(encoding="utf-8-sig")
+        )
+    except (OSError, json.JSONDecodeError) as exc:
+        return _result_error("SCENARIO_MANIFEST_INVALID", str(exc))
+    actual_scenarios = manifest.get("scenarios") if isinstance(manifest, dict) else None
+    if not isinstance(actual_scenarios, list) or not actual_scenarios:
+        return _result_error(
+            "SCENARIO_MANIFEST_EMPTY",
+            "scenario-manifest.json must contain at least one scenario",
+        )
+
+    def scenario_identity(item: dict[str, Any]) -> tuple[str, str, str, str]:
+        return (
+            str(item.get("id") or ""),
+            str(item.get("priority") or ""),
+            str(item.get("ownerPhase") or ""),
+            str(item.get("requiredEvidenceKind") or ""),
+        )
+
+    expected_scenario_identities = [
+        scenario_identity(item) for item in expected_scenarios
+    ]
+    actual_scenario_identities = [
+        scenario_identity(item)
+        for item in actual_scenarios
+        if isinstance(item, dict)
+    ]
+    if expected_scenario_identities != actual_scenario_identities:
+        return _result_error(
+            "SCENARIO_MANIFEST_DRIFT",
+            "derived scenario identities do not match the finalized scenario table",
+        )
+
     # Validate gate-policy.json is parseable JSON.
     gate_policy_path = change_dir / "meta" / "gate-policy.json"
+    if not gate_policy_path.is_file():
+        return _result_error(
+            "GATE_POLICY_MISSING",
+            f"gate policy missing: {gate_policy_path}",
+        )
+    try:
+        json.loads(gate_policy_path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError) as exc:
+        return _result_error("GATE_POLICY_INVALID", str(exc))
     gate_policy_consistent = True
-    if gate_policy_path.is_file():
-        try:
-            json.loads(gate_policy_path.read_text(encoding="utf-8-sig"))
-        except (OSError, json.JSONDecodeError):
-            gate_policy_consistent = False
-    else:
-        gate_policy_consistent = False
 
-    # Validate events.ndjson: count phase.end, check for parse errors.
+    # Validate events.ndjson: require one matching start/end lifecycle.
     events_path = change_dir / "events.ndjson"
+    phase_start_count = 0
     phase_end_count = 0
     phase_end_status: str | None = None
     events_parse_errors: list[str] = []
@@ -481,10 +747,16 @@ def verify_plan(change_dir: Path) -> dict[str, Any]:
             if not isinstance(event, dict):
                 events_parse_errors.append(f"line {line_no}: not an object")
                 continue
+            if event.get("phase") != "plan":
+                continue
             if (
-                event.get("phase") == "plan"
-                and event.get("type") == "phase.end"
+                str(event.get("run_id") or "") != receipt_run_id
+                or event.get("attempt") != receipt_attempt
             ):
+                continue
+            if event.get("type") == "phase.start":
+                phase_start_count += 1
+            elif event.get("type") == "phase.end":
                 phase_end_count += 1
                 phase_end_status = str(event.get("status") or "").upper()
     else:
@@ -495,15 +767,27 @@ def verify_plan(change_dir: Path) -> dict[str, Any]:
             "EVENTS_PARSE_ERROR", "; ".join(events_parse_errors[:5])
         )
 
+    if phase_start_count == 0:
+        return _result_error(
+            "PHASE_START_MISSING",
+            "no matching plan phase.start event found",
+        )
+    if phase_start_count > 1:
+        return _result_error(
+            "PHASE_START_DUPLICATE",
+            f"found {phase_start_count} matching plan phase.start events",
+        )
     if phase_end_count == 0:
         return _result_error("PHASE_END_MISSING", "no plan phase.end event found")
     if phase_end_count > 1:
         return _result_error(
             "PHASE_END_DUPLICATE", f"found {phase_end_count} phase.end events"
         )
-
-    # Receipt consistency: status should be finalized.
-    receipt_consistent = receipt.get("status") == "finalized"
+    if phase_end_status != "OK":
+        return _result_error(
+            "PHASE_END_NOT_OK",
+            f"plan phase.end status is {phase_end_status!r}, expected 'OK'",
+        )
 
     return {
         "ok": True,
@@ -511,11 +795,14 @@ def verify_plan(change_dir: Path) -> dict[str, Any]:
         "changeDir": str(change_dir),
         "changeName": change_name,
         "artifactsHash": actual_hash,
+        "phaseStartCount": phase_start_count,
         "phaseEndCount": phase_end_count,
         "phaseEndStatus": phase_end_status,
         "frontmatter": frontmatter_results,
         "gatePolicyConsistent": gate_policy_consistent,
-        "receiptConsistent": receipt_consistent,
+        "receiptConsistent": True,
+        "taskCount": len(expected_tasks),
+        "scenarioCount": len(expected_scenarios),
         "files": artifact_names,
     }
 
@@ -645,6 +932,9 @@ def finalize_plan(
     validation = validate_staging(staging, change_name)
     if not validation["ok"]:
         return validation
+    start_validation = _validate_plan_start(change_dir, run_id, attempt)
+    if not start_validation["ok"]:
+        return start_validation
 
     receipt_path = change_dir / "meta" / "plan-finalization.json"
     lock_path = change_dir / "meta" / "plan-finalize.lock"