@hunter-harness/workflow-harness 0.2.15 → 0.2.16

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

@@ -83,6 +83,23 @@ def _git_common_dir(cwd: Path) -> Path | None:
     return common
 
 
+def common_root(project_root: Path) -> Path:
+    """Resolve the shared "common" root for a project.
+
+    For a linked worktree, ``git rev-parse --git-common-dir`` points at the
+    main repository's ``.git`` directory; its parent is the main project root.
+    For the main worktree, the common dir is ``<root>/.git`` so the parent is
+    the project root itself. Falls back to the resolved input when not in a
+    git repo (e.g. exploratory scratch dirs).
+    """
+    cwd = Path(project_root).resolve()
+    common = _git_common_dir(cwd)
+    if common is None:
+        return cwd
+    # common dir is <root>/.git — its parent is the main project root.
+    return common.parent.resolve()
+
+
 def _root_commit(cwd: Path) -> str | None:
     raw = _git_text(cwd, "rev-list", "--max-parents=0", "HEAD")
     if not raw:

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

@@ -30,11 +30,117 @@ if hasattr(sys.stderr, "reconfigure"):
 SCHEMA_VERSION = 1
 _LINK = re.compile(r"\[[^\]]+\]\(([^)]+)\)")
 
+# C8: valid ownerPhase values (lifecycle phases that can own tasks).
+VALID_OWNER_PHASES = {"plan", "run", "test", "review", "submit"}
+
+# C9: map scenario priority to required evidence kind.
+PRIORITY_EVIDENCE_KIND = {
+    "P0": "ledger",
+    "P1": "ledger",
+    "P2": "advisory",
+}
+
 
 def _result_error(code: str, message: str) -> dict[str, Any]:
     return {"ok": False, "code": code, "error": message}
 
 
+def parse_test_scenarios(scenarios_path: Path) -> list[dict[str, str]]:
+    """C9: parse test-scenarios.md tables, extracting scenario rows.
+
+    Returns a list of dicts with keys: id / priority / scenario / verification /
+    ownerPhase / requiredEvidenceKind (last one derived from priority).
+    """
+    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 not row.startswith("|"):
+                    break
+                cells = [c.strip() for c in row.strip("|").split("|")]
+                if len(cells) < len(headers):
+                    i += 1
+                    continue
+                scenario: dict[str, str] = {}
+                for cn, en in (
+                    ("ID", "id"),
+                    ("优先级", "priority"),
+                    ("场景", "scenario"),
+                    ("验证方式", "verification"),
+                    ("owner phase", "ownerPhase"),
+                ):
+                    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")
+                scenarios.append(scenario)
+                i += 1
+            continue
+        i += 1
+    return scenarios
+
+
+def parse_plan_tasks(plan_path: Path) -> list[dict[str, str]]:
+    """C8: parse plan.md task table rows, extracting optional ownerPhase/implementationDoneWhen/verificationPhase columns.
+
+    Returns a list of dicts with keys: # / 簇 / 任务 / ownerPhase / implementationDoneWhen /
+    verificationPhase / requiresExplicitAuthority (last four optional, only present when
+    the column header includes them).
+    """
+    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):
+            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)
+    return tasks
+
+
 def _atomic_write_json(path: Path, payload: dict[str, Any]) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     fd, raw_tmp = tempfile.mkstemp(
@@ -146,6 +252,21 @@ def validate_staging(staging: Path, change_name: str) -> dict[str, Any]:
                         f"{rel.as_posix()}: missing reference {raw_link}",
                     )
 
+    # C8: validate ownerPhase values in plan.md task table.
+    plan_path = staging / "plans" / f"{change_name}-plan.md"
+    tasks = parse_plan_tasks(plan_path)
+    for task in tasks:
+        owner = task.get("ownerPhase")
+        if owner is not None and owner != "" and owner not in VALID_OWNER_PHASES:
+            return _result_error(
+                "PLAN_OWNER_PHASE_INVALID",
+                f"task {task.get('num', '?')}: ownerPhase '{owner}' not in {sorted(VALID_OWNER_PHASES)}",
+            )
+
+    # C9: parse test-scenarios.md for scenario manifest.
+    scenarios_path = staging / "plans" / f"{change_name}-test-scenarios.md"
+    scenarios = parse_test_scenarios(scenarios_path)
+
     digest = hashlib.sha256()
     artifact_names: list[str] = []
     for path in files:
@@ -159,6 +280,8 @@ def validate_staging(staging: Path, change_name: str) -> dict[str, Any]:
         "ok": True,
         "files": artifact_names,
         "artifactsHash": "sha256:" + digest.hexdigest(),
+        "tasks": tasks,
+        "scenarios": scenarios,
     }
 
 
@@ -367,6 +490,30 @@ def finalize_plan(
             finally:
                 tmp.unlink(missing_ok=True)
 
+        # C8: write implementation-checkpoints.json with parsed task ownerPhase.
+        tasks = validation.get("tasks") or []
+        if tasks:
+            checkpoints_path = change_dir / "meta" / "implementation-checkpoints.json"
+            checkpoints_payload = {
+                "schemaVersion": 1,
+                "changeName": change_name,
+                "tasks": tasks,
+                "foundationGate": "approved",
+            }
+            _atomic_write_json(checkpoints_path, checkpoints_payload)
+            created.append(checkpoints_path)
+
+        # C9: write scenario-manifest.json with parsed scenarios.
+        scenarios = validation.get("scenarios") or []
+        manifest_path = change_dir / "meta" / "scenario-manifest.json"
+        manifest_payload = {
+            "schemaVersion": 1,
+            "changeName": change_name,
+            "scenarios": scenarios,
+        }
+        _atomic_write_json(manifest_path, manifest_payload)
+        created.append(manifest_path)
+
         pending_receipt = {
             "schemaVersion": SCHEMA_VERSION,
             "changeName": change_name,

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

@@ -27,6 +27,12 @@ import sys
 from pathlib import Path
 from typing import Any
 
+SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIR))
+
+import harness_paths  # noqa: E402
+
 
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8")
@@ -358,14 +364,53 @@ def empty_profile_skeleton(excluded: tuple[str, ...] | list[str]) -> dict[str, A
 
 
 def load_profile(project: Path) -> dict[str, Any] | None:
-    path = project / PROFILE_REL
-    if not path.is_file():
-        return None
-    try:
-        data = read_json(path)
-    except (OSError, json.JSONDecodeError):
+    """C7: 分层读取 — 先读 common_root 的 build-profile.json，再叠加 execution root 的 override。
+
+    common_root 是 worktree 共享的主项目根（git common dir 的父目录）；
+    execution root 是当前工作目录（可能是 linked worktree）。
+    override 合并策略：execution 的 buildCommands 覆盖 common 的同名 key；
+    common 独有的 key 保留。
+    """
+    project = Path(project).resolve()
+    common = harness_paths.common_root(project)
+    common_path = common / PROFILE_REL
+    exec_path = project / PROFILE_REL
+
+    common_data: dict[str, Any] | None = None
+    if common_path.is_file():
+        try:
+            data = read_json(common_path)
+            if isinstance(data, dict):
+                common_data = data
+        except (OSError, json.JSONDecodeError):
+            pass
+
+    exec_data: dict[str, Any] | None = None
+    if exec_path.is_file():
+        try:
+            data = read_json(exec_path)
+            if isinstance(data, dict):
+                exec_data = data
+        except (OSError, json.JSONDecodeError):
+            pass
+
+    if common_data is None and exec_data is None:
         return None
-    return data if isinstance(data, dict) else None
+    if common_data is None:
+        return exec_data
+    if exec_data is None:
+        return common_data
+
+    # Merge: start from common, overlay execution's buildCommands.
+    merged = dict(common_data)
+    common_cmds = common_data.get("buildCommands") or {}
+    exec_cmds = exec_data.get("buildCommands") or {}
+    if common_cmds or exec_cmds:
+        merged_cmds = dict(common_cmds) if isinstance(common_cmds, dict) else {}
+        if isinstance(exec_cmds, dict):
+            merged_cmds.update(exec_cmds)
+        merged["buildCommands"] = merged_cmds
+    return merged
 
 
 def _merge_user_overrides(
@@ -616,6 +661,8 @@ def resolve_command(
     *,
     test_classes: list[str] | None = None,
     modules: list[str] | None = None,
+    common_root: Path | None = None,
+    execution_root: Path | None = None,
 ) -> dict[str, Any]:
     cmd = (profile.get("commands") or {}).get(key)
     if not isinstance(cmd, dict):
@@ -625,6 +672,10 @@ def resolve_command(
         replacements["{testClasses}"] = ",".join(test_classes)
     if modules is not None:
         replacements["{modules}"] = ",".join(modules)
+    if common_root is not None:
+        replacements["{commonRoot}"] = str(common_root)
+    if execution_root is not None:
+        replacements["{executionRoot}"] = str(execution_root)
 
     command = cmd.get("command", "")
     for placeholder, val in replacements.items():

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

@@ -14,6 +14,7 @@ Python 3.10+, stdlib only.
 from __future__ import annotations
 
 import argparse
+import datetime as dt
 import hashlib
 import json
 import os
@@ -270,6 +271,112 @@ def _emit(payload: Any, *, as_json: bool) -> int:
     return 0 if payload.get("ok") else 1
 
 
+def dispatch_review(
+    *,
+    change_dir: Path,
+    run_id: str,
+    budget_seconds: int = 300,
+) -> dict[str, Any]:
+    """C11: dispatch a bounded review task.
+
+    Returns reviewTaskId / deadline / heartbeatAt. The caller is expected to
+    poll the review subagent and collect partial findings on timeout.
+    """
+    now = dt.datetime.now(dt.timezone.utc).astimezone()
+    task_id = f"review-{uuid.uuid4().hex}"
+    deadline = now + dt.timedelta(seconds=budget_seconds)
+    # heartbeat at midpoint of the budget
+    heartbeat = now + dt.timedelta(seconds=budget_seconds // 2)
+    return {
+        "ok": True,
+        "code": "DISPATCHED",
+        "reviewTaskId": task_id,
+        "runId": run_id,
+        "deadline": deadline.isoformat(timespec="milliseconds"),
+        "heartbeatAt": heartbeat.isoformat(timespec="milliseconds"),
+        "budgetSeconds": budget_seconds,
+    }
+
+
+def collect_partial_findings(
+    *,
+    change_dir: Path,
+    run_id: str,
+    completed_dimensions: list[str],
+    pending_dimensions: list[str],
+) -> dict[str, Any]:
+    """C11: collect partial findings after timeout — completed dimensions only.
+
+    Applies the degradation matrix to decide the fallback path.
+    """
+    matrix = degradation_matrix(
+        subagent_timed_out=bool(pending_dimensions),
+        main_session_available=True,
+    )
+    return {
+        "ok": True,
+        "code": "PARTIAL_FINDINGS",
+        "runId": run_id,
+        "completedDimensions": list(completed_dimensions),
+        "pendingDimensions": list(pending_dimensions),
+        "degradationMatrix": matrix,
+    }
+
+
+def degradation_matrix(
+    *,
+    subagent_timed_out: bool,
+    main_session_available: bool,
+) -> dict[str, Any]:
+    """C11: degradation matrix — subagent timeout → main session; main fail → ADVISORY."""
+    if not subagent_timed_out:
+        return {"fallback": "none", "status": "OK"}
+    if main_session_available:
+        return {"fallback": "main-session", "status": "DEGRADED"}
+    return {"fallback": "advisory", "status": "ADVISORY"}
+
+
+def validate_codegraph_identity(
+    *,
+    response: dict[str, Any],
+    expected_repository_id: str,
+    expected_head: str,
+) -> dict[str, Any]:
+    """C12: validate CodeGraph identity — repositoryId/indexedHead must match.
+
+    On mismatch, signal CODEGRAPH_IDENTITY_MISMATCH with fallback to Grep/Glob + Read.
+    """
+    repo_id = response.get("repositoryId")
+    indexed_head = response.get("indexedHead")
+    indexed_at = response.get("indexedAt")
+    if (
+        repo_id == expected_repository_id
+        and indexed_head == expected_head
+        and indexed_at
+    ):
+        return {
+            "ok": True,
+            "code": "IDENTITY_OK",
+            "repositoryId": repo_id,
+            "indexedHead": indexed_head,
+            "indexedAt": indexed_at,
+        }
+    return {
+        "ok": False,
+        "code": "CODEGRAPH_IDENTITY_MISMATCH",
+        "expected": {
+            "repositoryId": expected_repository_id,
+            "indexedHead": expected_head,
+        },
+        "actual": {
+            "repositoryId": repo_id,
+            "indexedHead": indexed_head,
+            "indexedAt": indexed_at,
+        },
+        "fallback": "grep-glob-read",
+    }
+
+
 def cmd_validate_findings(args: argparse.Namespace) -> int:
     doc = _read_json(Path(args.input))
     problems = validate_findings(doc)

package/harness/manifests/general/claude-code.json

@@ -2,12 +2,12 @@
   "schema_version": 2,
   "profile": "general",
   "adapter": "claude-code",
-  "bundle_version": "0.2.14",
+  "bundle_version": "0.2.15",
   "generator": "harness_deploy.py",
   "files": [
     {
       "path": ".harness-build.json",
-      "sha256": "f7e5fcab41c868a1acf53d59f58cad0ca69f7da5dca394b3081de73b6e530074"
+      "sha256": "d1e1ee4711727013db2693d31573711e91b87080f36fa1442089b1c911c87774"
     },
     {
       "path": "agents/harness-evaluator.md",
@@ -47,7 +47,7 @@
     },
     {
       "path": "harness-archive/SKILL.md",
-      "sha256": "55d393fc6b7accab0802115fc6628c68545e1069cbc1aa0e16c412d6a8edfa5a"
+      "sha256": "9104b7b4bbc074301e29b8e270243770c96647222dd70fb60f6fd5def3bfaa3f"
     },
     {
       "path": "harness-archive/templates/render-summary.mjs",
@@ -67,7 +67,7 @@
     },
     {
       "path": "harness-codebase-map/SKILL.md",
-      "sha256": "8901d29948bd75933d22dea87d15b9b47eeab660063af3e4c13718e7e5fdc4a4"
+      "sha256": "36517926819e5a197d8a02bab37ea0579c511faef6f70c74cb71e21a60689b3b"
     },
     {
       "path": "harness-codebase-map/templates/ARCHITECTURE.md",
@@ -127,15 +127,15 @@
     },
     {
       "path": "harness-knowledge-ingest/scripts/harness_knowledge.py",
-      "sha256": "48620b3aa57da3cbc39c556b73006108e0ae4e40d7b662709869dfc1877158ee"
+      "sha256": "062115a524d5bd4aec27e40e2b57cf4e7ed6e0509d4a8e6e78a79a62ee32e2c5"
     },
     {
       "path": "harness-knowledge-ingest/SKILL.md",
-      "sha256": "013252318d6a27d6c62bcf5247e0e3a2f78187fe7758950edf93e44340943fd9"
+      "sha256": "088a51365d7bd7a918e415432cedc039c85a478f21a8894b5376dfe4b0c48f2e"
     },
     {
       "path": "harness-knowledge-query/SKILL.md",
-      "sha256": "5e0d111527aa23bc2ecd60e9808a8d65e23f21344920447c247aa8592ad176fd"
+      "sha256": "18f05a403ae56a9c7ad08c58e3bd67243de67a684df895596312584650f8b5f0"
     },
     {
       "path": "harness-plan/checklist.md",
@@ -151,7 +151,7 @@
     },
     {
       "path": "harness-plan/SKILL.md",
-      "sha256": "c73337d7896b89c67ecdbc623145ee1ffad679302b72eeb054b7d1508dee4a86"
+      "sha256": "91b0e08f29cc598ac1e3ffea2465245354eea4ee5553afda58c34dae72afb58e"
     },
     {
       "path": "harness-review/checklist.md",
@@ -163,11 +163,11 @@
     },
     {
       "path": "harness-review/reference.md",
-      "sha256": "0644a39417d51f1222905567dca80a433661a2411e2d4dd1b94644bc1cda596d"
+      "sha256": "5e43f753b2189bc8256c04905c079016a31694dad2aa1ad841aceae3670dd6c6"
     },
     {
       "path": "harness-review/SKILL.md",
-      "sha256": "ec00e56acc221f34ab5b2717a560473670a897c8bf75039bae290a6d875c17df"
+      "sha256": "bb4f36751348697398d6b9de1601e5c1a3c9d8895b2533b834f930761334c7f0"
     },
     {
       "path": "harness-run/checklist.md",
@@ -183,7 +183,7 @@
     },
     {
       "path": "harness-run/SKILL.md",
-      "sha256": "9b3b608914a7bbf698c3a28a45e5d4cd6a8156bd49c9a780da5e1adbbde02408"
+      "sha256": "35947fa05b0f366585e4e6eaa7d5421685cdbf07f0bbd248173e66d191e65e5b"
     },
     {
       "path": "harness-submit/checklist.md",
@@ -195,7 +195,7 @@
     },
     {
       "path": "harness-submit/SKILL.md",
-      "sha256": "279bb2546f41d617fe4402caa5cad7db788643407ba47b5cfe0dae00b1c18e72"
+      "sha256": "5fe0ea4267aabdf6527aea9589f1a0f2d7d13726af355c127e2b5cfb198b12ea"
     },
     {
       "path": "harness-sync/reference.md",
@@ -203,7 +203,7 @@
     },
     {
       "path": "harness-sync/SKILL.md",
-      "sha256": "6dc61858ea0293876a79be8130de7c3f7699f1f8510a50fac6a6da01d62b4673"
+      "sha256": "afd9ca9af1b69fcf4a32564a1d70e975e73bedcd61d0f662175a8f53887d4fc1"
     },
     {
       "path": "harness-test/checklist.md",
@@ -227,7 +227,7 @@
     },
     {
       "path": "harness-test/SKILL.md",
-      "sha256": "a7c8d010c05c216c17ba353525ce06e3c8d39f5ec9182be29b4420f567fe36a7"
+      "sha256": "fe3dae58e7f9537f71d793d5390d5f73f1d5066682b4f79b2a5b6cc58ca6e247"
     },
     {
       "path": "protocols/archive-report-protocol.md",
@@ -291,19 +291,19 @@
     },
     {
       "path": "scripts/harness_gate.py",
-      "sha256": "f83e9d33816052553e2ae8e5514fae318c5b5bc48ba2aded67d88fc9f0b51a98"
+      "sha256": "c5762a90f0361496d1f6a64670ee4cc84dd5075924fec08c3846530393c0b2ff"
     },
     {
       "path": "scripts/harness_integration.py",
-      "sha256": "6b078d7d1d053e4c46bc320496fab3060d883b256d517a56f0b078eec2fa0ce0"
+      "sha256": "613440b92d14cef920647e61eb524eb8f539add5b7fd68e7a263fd541f99316a"
     },
     {
       "path": "scripts/harness_ledger.py",
-      "sha256": "5141168aa1c566327e421d6ab6de876dfe0cf6ae3e97d336fcce6dc7fc4bfb56"
+      "sha256": "60a6cdff5c3c81abf5606f7914c299828c4ed2b21d19e9acbb27b001a03fcaa5"
     },
     {
       "path": "scripts/harness_paths.py",
-      "sha256": "75560c0141172b335811014320001a299846e4fba45dd0589cba86da058ab01a"
+      "sha256": "c60d272e61aa98fc84a89c24db81c1ff8cbf2dac16b88fddbcd18fcc5d6199a5"
     },
     {
       "path": "scripts/harness_phase.py",
@@ -311,7 +311,7 @@
     },
     {
       "path": "scripts/harness_plan_finalize.py",
-      "sha256": "5534eb277e29e3473149a0f113ea107dc17b6cade742d7de920befb87e46fdfa"
+      "sha256": "6fd97c6d91d180fa0ce2b73ac16c13ee741ef8a78f8a78b0af6e061d2b9eb7da"
     },
     {
       "path": "scripts/harness_preflight.py",
@@ -319,11 +319,11 @@
     },
     {
       "path": "scripts/harness_profile.py",
-      "sha256": "7c02010be79352e552d028ac7a5884f273b832af304cb2336824d41a4371a800"
+      "sha256": "e242f79d36d7a38bdf3927cd2f65d1c7bb687a4119b07e41a59fec6989d5e253"
     },
     {
       "path": "scripts/harness_review.py",
-      "sha256": "78009e09b79867a13c66a8c71114b6cd04fe75c72054f5ec35d63c7be990bb04"
+      "sha256": "a741a63f62993d72889e78f540feb57a95e713b4d7a98fa61ff208b2ce914ca7"
     },
     {
       "path": "scripts/harness_runtime.py",