@hunter-harness/workflow-harness 0.2.11 → 0.2.12

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

@@ -266,6 +266,8 @@ def capture_current_state(
         segment_files=files,
     )
     changed: list[str] = []
+    baseline_created = previous is None
+    unresolved: list[str] = []
     if previous:
         old_segments = previous.get("segments") or {}
         for name, segment in fresh["segments"].items():
@@ -275,7 +277,12 @@ def capture_current_state(
             else:
                 changed.append(name)
     else:
-        changed = list(fresh["segments"])
+        # A first observation establishes the baseline; it is not evidence
+        # that every segment changed during the current phase.
+        unresolved = sorted(fresh["segments"])
+    fresh["baselineCreated"] = baseline_created
+    fresh["changedSegments"] = sorted(changed)
+    fresh["unresolvedSegments"] = unresolved
     write_snapshot(change_dir, fresh)
     return fresh, changed
 
@@ -312,7 +319,13 @@ def main(argv: list[str] | None = None) -> int:
         "ok": True,
         "path": str(snapshot_path(change_dir)),
         "changedSegments": changed,
-        "reusedSegments": sorted(set(snapshot["segments"]) - set(changed)),
+        "reusedSegments": sorted(
+            set(snapshot["segments"])
+            - set(changed)
+            - set(snapshot.get("unresolvedSegments") or [])
+        ),
+        "baselineCreated": bool(snapshot.get("baselineCreated")),
+        "unresolvedSegments": list(snapshot.get("unresolvedSegments") or []),
         "git": snapshot["git"],
     }
     if args.json:

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

@@ -564,6 +564,159 @@ def record(
     return _result(True, action, "RECORDED", [rel for _, rel in validated], manifestPath=str(manifest_path))
 
 
+def rehome(
+    from_project: Path | str,
+    to_project: Path | str,
+    change_dir: Path | str,
+    expected_head: str,
+) -> dict[str, Any]:
+    """Atomically hand test ownership from a merged feature worktree to target."""
+    action = "rehome"
+    from_root = Path(from_project).resolve()
+    to_root = Path(to_project).resolve()
+    if not from_root.is_dir() or not to_root.is_dir():
+        return _result(False, action, "PROJECT_ROOT_MISSING", [])
+    if harness_paths.repository_identity(from_root) != harness_paths.repository_identity(to_root):
+        return _result(False, action, "REPOSITORY_MISMATCH", [])
+    to_head_result = _git(to_root, "rev-parse", "--verify", "HEAD")
+    to_head = to_head_result.stdout.strip() if to_head_result.returncode == 0 else ""
+    if not expected_head or to_head != expected_head:
+        return _result(
+            False, action, "EXPECTED_HEAD_MISMATCH", [],
+            expectedHead=expected_head, actualHead=to_head,
+        )
+    from_head_result = _git(from_root, "rev-parse", "--verify", "HEAD")
+    from_head = from_head_result.stdout.strip() if from_head_result.returncode == 0 else ""
+    from_tree_result = _git(from_root, "rev-parse", "HEAD^{tree}")
+    to_tree_result = _git(to_root, "rev-parse", f"{expected_head}^{{tree}}")
+    from_tree = from_tree_result.stdout.strip() if from_tree_result.returncode == 0 else ""
+    to_tree = to_tree_result.stdout.strip() if to_tree_result.returncode == 0 else ""
+    if not from_tree or from_tree != to_tree:
+        return _result(
+            False, action, "TREE_MISMATCH", [],
+            fromHead=from_head, toHead=to_head, fromTree=from_tree, toTree=to_tree,
+        )
+
+    change_root = _change_dir(from_root, change_dir)
+    if change_root is None:
+        return _result(False, action, "CHANGE_DIR_OUTSIDE_PROJECT", [])
+    manifest_path = _manifest_path(change_root)
+    if manifest_path is None:
+        return _result(False, action, "MANIFEST_PATH_OUTSIDE_PROJECT", [])
+    lock_path = manifest_path.with_name(manifest_path.name + ".lock")
+    try:
+        with _exclusive_lock(lock_path, wait_seconds=5.0):
+            try:
+                manifest = _read_json(manifest_path)
+            except FileNotFoundError:
+                return _result(False, action, "MANIFEST_MISSING", [])
+            except (OSError, json.JSONDecodeError) as exc:
+                return _result(False, action, "MANIFEST_INVALID", [], error=str(exc))
+            is_v2 = isinstance(manifest, dict) and manifest.get("schemaVersion") == 2
+            entries = manifest.get("files") if isinstance(manifest, dict) else None
+            if not isinstance(entries, list):
+                return _result(False, action, "MANIFEST_INVALID", [])
+            if not is_v2 and (
+                manifest.get("schemaVersion") != SCHEMA_VERSION
+                or manifest.get("mode") != MODE
+                or manifest.get("projectRoot") != str(from_root)
+            ):
+                return _result(False, action, "MANIFEST_PROJECT_MISMATCH", [])
+            if is_v2:
+                error, validated = _validate_existing_manifest_v2(
+                    from_root, manifest, require_files=False
+                )
+                if error:
+                    return _result(False, action, error, [])
+            else:
+                validated: dict[str, dict[str, Any]] = {}
+                for item in entries:
+                    if not _entry_shape_valid(item):
+                        return _result(False, action, "MANIFEST_INVALID", [])
+                    rel = item["path"]
+                    source, normalized, error = _validate_file(from_root, rel)
+                    if error or normalized != rel or source is None:
+                        return _result(False, action, error or "MANIFEST_INVALID", [rel])
+                    if item["sha256"] != _sha256(source):
+                        return _result(False, action, "HASH_DRIFT", [rel])
+                    validated[rel] = dict(item)
+
+            updated = json.loads(json.dumps(manifest))
+            updated_entries: list[dict[str, Any]] = []
+            for rel, item in sorted(validated.items()):
+                target, normalized, error = _validate_file(to_root, rel)
+                if error or normalized != rel or target is None:
+                    return _result(False, action, "TARGET_CONTENT_MISMATCH", [rel])
+                replacement = dict(item)
+                if is_v2:
+                    digest = logical_file_hash(to_root, rel)
+                    source_digest = item.get("logicalHash") or item.get("binaryHash")
+                    if digest != source_digest:
+                        return _result(False, action, "TARGET_CONTENT_MISMATCH", [rel])
+                    replacement["logicalHash"] = digest
+                    replacement["binaryHash"] = (
+                        None if digest.startswith("gitblob:") else digest
+                    )
+                    replacement["ignored"] = _is_ignored(to_root, rel)
+                else:
+                    digest = _sha256(target)
+                    if digest != item["sha256"]:
+                        return _result(False, action, "TARGET_CONTENT_MISMATCH", [rel])
+                    replacement["sha256"] = digest
+                    replacement["ignored"] = _is_ignored(to_root, rel)
+                    replacement["trackedBefore"] = (
+                        _git(to_root, "ls-files", "--error-unmatch", "--", rel).returncode == 0
+                    )
+                updated_entries.append(replacement)
+
+            before_hash = _sha256(manifest_path)
+            handoff_at = time.strftime("%Y-%m-%dT%H:%M:%S")
+            handoff_id = "handoff-" + hashlib.sha256(
+                f"{from_root}\0{to_root}\0{from_head}\0{to_head}".encode("utf-8")
+            ).hexdigest()[:20]
+            handoffs = updated.get("handoffs")
+            if handoffs is None:
+                handoffs = []
+            if not isinstance(handoffs, list):
+                return _result(False, action, "MANIFEST_INVALID", [])
+            handoff = {
+                "id": handoff_id,
+                "fromRoot": str(from_root),
+                "toRoot": str(to_root),
+                "fromHead": from_head,
+                "toHead": to_head,
+                "expectedHead": expected_head,
+                "treeHash": to_tree,
+                "at": handoff_at,
+                "manifestHashBefore": before_hash,
+            }
+            if not any(isinstance(item, dict) and item.get("id") == handoff_id for item in handoffs):
+                handoffs.append(handoff)
+            updated["files"] = updated_entries
+            updated["projectRoot"] = str(to_root)
+            updated["head"] = to_head
+            updated["handoffs"] = handoffs
+            _write_json(manifest_path, updated)
+            after_hash = _sha256(manifest_path)
+    except LockUnavailable:
+        return _result(False, action, "MANIFEST_LOCKED", [])
+    return _result(
+        True,
+        action,
+        "REHOMED",
+        sorted(validated),
+        fromRoot=str(from_root),
+        toRoot=str(to_root),
+        fromHead=from_head,
+        toHead=to_head,
+        treeHash=to_tree,
+        handoffId=handoff_id,
+        manifestHashBefore=before_hash,
+        manifestHashAfter=after_hash,
+        manifestPath=str(manifest_path),
+    )
+
+
 def _stage_locked(
     project_root: Path, change_root: Path, manifest_path: Path, index_path: Path
 ) -> dict[str, Any]:
@@ -709,6 +862,31 @@ def begin(project: Path | str, change_dir: Path | str) -> dict[str, Any]:
     if not _manifest_target_inside(change_root, snapshot_path):
         return _result(False, action, "SNAPSHOT_PATH_OUTSIDE_PROJECT", [])
 
+    if snapshot_path.is_file():
+        try:
+            snapshot = _read_json(snapshot_path)
+        except (OSError, json.JSONDecodeError) as exc:
+            return _result(False, action, "SNAPSHOT_INVALID", [], error=str(exc))
+        entries = snapshot.get("files") if isinstance(snapshot, dict) else None
+        if (
+            not isinstance(snapshot, dict)
+            or snapshot.get("schemaVersion") != SCHEMA_VERSION
+            or snapshot.get("mode") != MODE
+            or snapshot.get("projectRoot") != str(project_root)
+            or not isinstance(entries, list)
+            or any(not isinstance(item, dict) or not isinstance(item.get("path"), str)
+                   for item in entries)
+        ):
+            return _result(False, action, "SNAPSHOT_INVALID", [])
+        return _result(
+            True,
+            action,
+            "SNAPSHOT_REUSED",
+            [item["path"] for item in entries],
+            snapshotPath=str(snapshot_path),
+            fileCount=len(entries),
+        )
+
     files = _enumerate_allowed_test_files(project_root)
     snapshot = {
         "schemaVersion": SCHEMA_VERSION,
@@ -867,6 +1045,12 @@ def main(argv: list[str] | None = None) -> int:
     close_parser.add_argument("--project", required=True)
     close_parser.add_argument("--change-dir", required=True)
     close_parser.add_argument("--json", action="store_true")
+    rehome_parser = sub.add_parser("rehome")
+    rehome_parser.add_argument("--from", dest="from_project", required=True)
+    rehome_parser.add_argument("--to", dest="to_project", required=True)
+    rehome_parser.add_argument("--change-dir", required=True)
+    rehome_parser.add_argument("--expected-head", required=True)
+    rehome_parser.add_argument("--json", action="store_true")
     mark_parser = sub.add_parser("mark")
     mark_parser.add_argument("--project", required=True)
     mark_parser.add_argument("--change-dir", required=True)
@@ -883,6 +1067,10 @@ def main(argv: list[str] | None = None) -> int:
     elif args.action == "mark":
         files = [item.strip() for item in args.files.split(",") if item.strip()]
         result = mark(args.project, args.change_dir, files)
+    elif args.action == "rehome":
+        result = rehome(
+            args.from_project, args.to_project, args.change_dir, args.expected_head
+        )
     else:
         result = stage(args.project, args.change_dir)
     print(json.dumps(result, ensure_ascii=False, indent=2 if args.json else None))

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

@@ -19,6 +19,8 @@ TOP_LEVEL_KEYS = frozenset(
         "skills",
         "requiredArtifacts",
         "requiredValidations",
+        "validationPhases",
+        "capabilityGates",
         "conditionalStages",
         "interactionWhitelist",
         "checkpointRules",
@@ -48,6 +50,9 @@ SKILL_KEYS = frozenset(
 )
 
 CONDITIONAL_STAGE_KEYS = frozenset({"tiers", "signals"})
+CAPABILITY_GATE_KEYS = frozenset(
+    {"signals", "requiredStages", "requiredValidations"}
+)
 CHECKPOINT_RULE_KEYS = frozenset(
     {
         "afterTasks",
@@ -121,6 +126,20 @@ def validate_policy(data: Any) -> dict[str, Any]:
         for phase, items in section_data.items():
             _require_type(items, list, f"{section}.{phase}")
 
+    validation_phases = data["validationPhases"]
+    _require_type(validation_phases, dict, "validationPhases")
+    for verification, phase in validation_phases.items():
+        _require_type(phase, str, f"validationPhases.{verification}")
+
+    capability_gates = data["capabilityGates"]
+    _require_type(capability_gates, dict, "capabilityGates")
+    for capability, gate in capability_gates.items():
+        path = f"capabilityGates.{capability}"
+        _require_type(gate, dict, path)
+        _reject_unknown(gate, CAPABILITY_GATE_KEYS, path)
+        for key in CAPABILITY_GATE_KEYS:
+            _require_type(gate[key], list, f"{path}.{key}")
+
     conditional = data["conditionalStages"]
     _require_type(conditional, dict, "conditionalStages")
     for stage_name, stage in conditional.items():

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

@@ -2,12 +2,12 @@
   "schema_version": 2,
   "profile": "general",
   "adapter": "claude-code",
-  "bundle_version": "0.2.11",
+  "bundle_version": "0.2.12",
   "generator": "harness_deploy.py",
   "files": [
     {
       "path": ".harness-build.json",
-      "sha256": "40d31470c7bcb1767951cf358f5e16e2e021757382cb07a4148d42b699671867"
+      "sha256": "b1e7fdc6c66ac7aed5ff8a8e381ff36d28d49955394e145cbfb2f0f8132b26ed"
     },
     {
       "path": "agents/harness-evaluator.md",
@@ -25,9 +25,13 @@
       "path": "CONTEXT.md",
       "sha256": "19c75b493f6f760d0e607a88bd355acdd232fcb66660887ef94d10425f39507b"
     },
+    {
+      "path": "contracts/ci-metrics.schema.json",
+      "sha256": "63e05a5ee620069dac7f63ab5780a07900114534c201e3f449b1bd8de9365757"
+    },
     {
       "path": "contracts/workflow-policy.json",
-      "sha256": "e642d840fa90aa5943cb80bee6538e0aa11577fcaab0c4e534641ebfae8d8f00"
+      "sha256": "3f39160c6905338a527170c0f15d83715ad56ac9fb449f4f568a6714ccdd3c9a"
     },
     {
       "path": "harness-archive/checklist.md",
@@ -43,7 +47,7 @@
     },
     {
       "path": "harness-archive/SKILL.md",
-      "sha256": "13d1957acf85bf3c933474a28410be0601d64f5235821c37325021bbe208b1a5"
+      "sha256": "85db6ae3e7c040e489a0fc8fd3c1d16785a57b4aea0e146f07a783808d90ee34"
     },
     {
       "path": "harness-archive/templates/render-summary.mjs",
@@ -63,7 +67,7 @@
     },
     {
       "path": "harness-codebase-map/SKILL.md",
-      "sha256": "09f36dc649a1f9d3011fddd04e22e58e537210e7ae52415a2759bd5665633b7f"
+      "sha256": "7936882e87ddb799fd9023b3289285cf777219a13e9b6675c57f61c48611a554"
     },
     {
       "path": "harness-codebase-map/templates/ARCHITECTURE.md",
@@ -127,15 +131,15 @@
     },
     {
       "path": "harness-knowledge-ingest/SKILL.md",
-      "sha256": "d25d7f2661de42398dbd8b0fdc02664bfe1a00f9db0c5f9e53026f98c080de9b"
+      "sha256": "7ad661113a23a9d18bc68e54dd9e425bbb6a4be240e84aaeba299cfe70c43114"
     },
     {
       "path": "harness-knowledge-query/SKILL.md",
-      "sha256": "f3350f4904db95e9c01125b169fcbd344b902a151599e0a60d30f228df63649a"
+      "sha256": "d1501e58969944afb8184659d15608e7679a59fcc793d0cab21475b72e08fbce"
     },
     {
       "path": "harness-plan/checklist.md",
-      "sha256": "efd49a7430aae916d2cd6da82f812c0fdc9777eaabe8212a92904d5dcfa38534"
+      "sha256": "897649058dea86440bcbf4fcb7f2323a6c361318da48737ca69b282f7a9b1870"
     },
     {
       "path": "harness-plan/protocols.md",
@@ -143,11 +147,11 @@
     },
     {
       "path": "harness-plan/reference.md",
-      "sha256": "93b1a26397cb411ca64700f3022ca92d199f85f5fc221b745bcc10a9c2ba9970"
+      "sha256": "5f3ee154ad79f4b5906efffbd09f14d26ca629540002fb06e35208c21bd5efa4"
     },
     {
       "path": "harness-plan/SKILL.md",
-      "sha256": "a521f4093cf364006f33b6e59196308c055ff9ee24f28cab04407e2315560426"
+      "sha256": "b9e45a9128cb936baef0af42555e87758f6c66926a071c84ea4fdeb65d85e52d"
     },
     {
       "path": "harness-review/checklist.md",
@@ -163,11 +167,11 @@
     },
     {
       "path": "harness-review/SKILL.md",
-      "sha256": "b0968731379ef9cd344f6daf4c80edc3d446dc52c518cbe46b09cd302e0325df"
+      "sha256": "f7be0a500962ba4393cd438bf9d59250eede7b10beb433cdfcf30b496d8b009f"
     },
     {
       "path": "harness-run/checklist.md",
-      "sha256": "4a829a9a1521402d508f2b76ba16246f8d5b860cc5eeaa40faa96cbc874992c2"
+      "sha256": "091bde8a02224f8da1078c7022bb431c2ea696779efef5a8b9129b2e51522505"
     },
     {
       "path": "harness-run/protocols.md",
@@ -175,11 +179,11 @@
     },
     {
       "path": "harness-run/reference.md",
-      "sha256": "9c0b34303310de06ab56ab0c38b35134dcd4b0d3bde10c9275313ff2962010f3"
+      "sha256": "2be487368210d50b22062cefcf6e9b4ef4ff2eb148531e0c85b180f41f2e8b33"
     },
     {
       "path": "harness-run/SKILL.md",
-      "sha256": "d05d156aff4a852cd84de3e0c228a7a11ff132d1fcedc939e54688908204ca42"
+      "sha256": "0ffe532fe94448923b178cfcd04f5f448b6a259ae800bcf6523382b51a1a9ffa"
     },
     {
       "path": "harness-submit/checklist.md",
@@ -191,7 +195,7 @@
     },
     {
       "path": "harness-submit/SKILL.md",
-      "sha256": "4fe6f295e5df8e52ef6808777e203f5999b575e80acc8c7744c31b111e537821"
+      "sha256": "87ea4e3d91eba4b6a75609ea521f36e96fd29502479a0f9f5a1d9ecd3eaa2a85"
     },
     {
       "path": "harness-sync/reference.md",
@@ -199,7 +203,7 @@
     },
     {
       "path": "harness-sync/SKILL.md",
-      "sha256": "c72e07daa1eb3c59a0a8da2b1e60b2b5097537f38c1c6f314b9f8b18b0ec42f1"
+      "sha256": "7c708fd321c79242c85799b223517ba812c0d43972933d74e8012940d84c1535"
     },
     {
       "path": "harness-test/checklist.md",
@@ -223,7 +227,7 @@
     },
     {
       "path": "harness-test/SKILL.md",
-      "sha256": "1e7be5f528b51b8124d3e3ef27e03e2d7965ab266370be91b34d3113775443ec"
+      "sha256": "8463f54ca8a41b89a09e92cae35c8f1c125371c26564e6545354286d415016c8"
     },
     {
       "path": "protocols/archive-report-protocol.md",
@@ -267,7 +271,7 @@
     },
     {
       "path": "scripts/harness_archive.py",
-      "sha256": "52f3a7aef19cc84d4820f90d0fa320e7e963e7b7710f607954cd67608c67be55"
+      "sha256": "b0c29fd8505de3ece4efa7415424c68564116a17f0ba9e3d2718f3ee0cdec0f2"
     },
     {
       "path": "scripts/harness_change.py",
@@ -283,43 +287,55 @@
     },
     {
       "path": "scripts/harness_events.py",
-      "sha256": "700ce2741ec80144c8880cdb85c8026dc9c7aec9bcbdee1c1d3ccb77aed58648"
+      "sha256": "287436f60ce4aded0869233f9148112d612b74e61d79d1d4be358f802751c736"
     },
     {
       "path": "scripts/harness_gate.py",
-      "sha256": "5fdb48040a396403dc9584561316d6181b9b70c5234407d662093bad739cc3bc"
+      "sha256": "76c7a4e82d89ef121b47bcb3b3e7f180b9f421a9406bfb9d1de9cfbb9d27bfba"
     },
     {
       "path": "scripts/harness_integration.py",
-      "sha256": "a5e616ed1ba04b390d431132f6eeedef8789b87bee1e1512667e696f6a970471"
+      "sha256": "8c4d143affe1fc37ea028cc9d85581774ddecc4849f298094f1d4d831f3929f7"
     },
     {
       "path": "scripts/harness_ledger.py",
-      "sha256": "79815b4a1fb6f5c43d63dcb64a4a9cde26ccd7f6206c86ba3d0c795854668ee5"
+      "sha256": "28e87fbdbac579f87e7c374bce59c60e689c61d2ac1298b4fdd868562e2abbac"
     },
     {
       "path": "scripts/harness_paths.py",
       "sha256": "75560c0141172b335811014320001a299846e4fba45dd0589cba86da058ab01a"
     },
+    {
+      "path": "scripts/harness_phase.py",
+      "sha256": "5f16f9b03dc01a08f3dbc0bb0a416856833836f4c3fcb2c4c0799a876079c43d"
+    },
+    {
+      "path": "scripts/harness_plan_finalize.py",
+      "sha256": "8557e392b34711811a7fa220a2c388c60fec79e916fbd61b42f3e6e6dc50b22c"
+    },
     {
       "path": "scripts/harness_preflight.py",
       "sha256": "245f70d6c1f9979f2921e14e5d7a6078bd5126ae6c5d8c0bcd6cfd9c4fd8e135"
     },
     {
       "path": "scripts/harness_profile.py",
-      "sha256": "52c9fb0d7c22823f06a8fd49bc1b648b0bda974f0851e8a12b0959be7c1c4183"
+      "sha256": "7c02010be79352e552d028ac7a5884f273b832af304cb2336824d41a4371a800"
     },
     {
       "path": "scripts/harness_review.py",
       "sha256": "78009e09b79867a13c66a8c71114b6cd04fe75c72054f5ec35d63c7be990bb04"
     },
+    {
+      "path": "scripts/harness_runtime.py",
+      "sha256": "8959e8702bf703380dc2de92bf33aef3f9520d66ffd790c2295ce6cae1c28cab"
+    },
     {
       "path": "scripts/harness_service.py",
       "sha256": "17c26b40ed3e7d110b74ef61e627fa0ad1bc84718a1721a066e6d72ee0e37649"
     },
     {
       "path": "scripts/harness_state.py",
-      "sha256": "27073a1d7b1ea6d54a75bf6e679eb250a3507c95311101b60a1c4d32e00f909e"
+      "sha256": "5a35c8ceb1d1cbb1e52347f150139029dd78e57ed47b6d9f2a69066ce33b6084"
     },
     {
       "path": "scripts/harness_sync.py",
@@ -327,11 +343,11 @@
     },
     {
       "path": "scripts/harness_test_guard.py",
-      "sha256": "76713c4af83486b513979f40ba8055fefd0ff10b487d31de9d7f9d9a4ee2dce0"
+      "sha256": "1817c2b0ceeb14a98149e704decd4e6cbcaf16121f95320ef61cd36805abe03d"
     },
     {
       "path": "scripts/harness_workflow_policy.py",
-      "sha256": "3e754da7041ebec852c3f0be8736cec423d7a0ee98424164bfe4a06fc4d8ca4f"
+      "sha256": "a01530d0992cd589129b847c15f1d038cb54992387f694748c09fa182a2de240"
     }
   ]
 }