@hunter-harness/workflow-harness 0.2.42 → 0.2.43

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

@@ -6,10 +6,30 @@ from __future__ import annotations
 import argparse
 import fnmatch
 import json
+import time
 from pathlib import Path
 from typing import Any
 
 
+_COVERAGE_RANK = {"incremental": 0, "module": 1, "module-am": 2, "full": 3}
+
+
+def _normalize_targets(raw_targets: Any) -> list[dict[str, Any]]:
+    if isinstance(raw_targets, dict):
+        return [
+            {**dict(target), "id": str(target.get("id") or target_id)}
+            for target_id, target in raw_targets.items()
+            if isinstance(target_id, str) and isinstance(target, dict)
+        ]
+    if isinstance(raw_targets, list):
+        return [
+            dict(target)
+            for target in raw_targets
+            if isinstance(target, dict) and str(target.get("id") or "").strip()
+        ]
+    return []
+
+
 def select_verifications(payload: dict[str, Any]) -> dict[str, Any]:
     changed = sorted(
         {
@@ -18,9 +38,7 @@ def select_verifications(payload: dict[str, Any]) -> dict[str, Any]:
             if str(path).strip()
         }
     )
-    targets = [
-        target for target in payload.get("targets", []) if isinstance(target, dict)
-    ]
+    targets = _normalize_targets(payload.get("targets", []))
     selected_ids: set[str] = set()
     reasons: dict[str, list[str]] = {}
     for target in targets:
@@ -90,16 +108,398 @@ def select_verifications(payload: dict[str, Any]) -> dict[str, Any]:
     }
 
 
+def _resource_locks(target: dict[str, Any]) -> list[str]:
+    locks = sorted(
+        {
+            str(item).strip()
+            for item in target.get("resourceLocks", [])
+            if str(item).strip()
+        }
+    )
+    estimated = float(
+        target.get("estimatedDurationSeconds")
+        or target.get("expectedDurationSeconds")
+        or 0
+    )
+    if estimated >= 60 and not locks:
+        locks.append("harness:unclassified-heavy")
+    return locks
+
+
+def _target_decision(
+    target: dict[str, Any],
+    *,
+    product_identity: str,
+    frozen_identity: str,
+    available_capabilities: set[str],
+    verification_ledger: list[dict[str, Any]],
+) -> tuple[str, list[str]]:
+    blockers: list[str] = []
+    if not product_identity:
+        return "BLOCKED", ["PRODUCT_IDENTITY_REQUIRED"]
+    required_capabilities = {
+        str(item).strip()
+        for item in target.get("requiredCapabilities", [])
+        if str(item).strip()
+    }
+    blockers.extend(
+        "CAPABILITY_MISSING:" + item
+        for item in sorted(required_capabilities - available_capabilities)
+    )
+    required_coverage = str(target.get("requiredCoverage") or "").strip()
+    coverage_level = str(
+        target.get("coverageLevel") or target.get("scope") or ""
+    ).strip()
+    if required_coverage:
+        if required_coverage not in _COVERAGE_RANK:
+            blockers.append("REQUIRED_COVERAGE_INVALID")
+        elif coverage_level not in _COVERAGE_RANK:
+            blockers.append("COVERAGE_DECLARATION_REQUIRED")
+        elif _COVERAGE_RANK[coverage_level] < _COVERAGE_RANK[required_coverage]:
+            blockers.append(
+                f"COVERAGE_INSUFFICIENT:{coverage_level}<{required_coverage}"
+            )
+    applicability = target.get("applicability")
+    if isinstance(applicability, dict) and applicability.get("applicable") is False:
+        return "SKIP", [
+            str(applicability.get("reasonCode") or "NOT_APPLICABLE")
+        ]
+    if (
+        target.get("requiresFrozenIdentity") is True
+        and not frozen_identity
+    ):
+        blockers.append("FROZEN_IDENTITY_REQUIRED")
+    if (
+        target.get("requiresFrozenIdentity") is True
+        and frozen_identity
+        and product_identity != frozen_identity
+    ):
+        blockers.append("FROZEN_IDENTITY_DRIFT")
+    if blockers:
+        return "BLOCKED", blockers
+    reuse = target.get("reuse")
+    if isinstance(reuse, dict) and reuse.get("eligible") is True:
+        if target.get("reusePolicy") == "never":
+            return "EXECUTE", ["REUSE_POLICY_NEVER"]
+        evidence_id = str(reuse.get("evidenceId") or "").strip()
+        evidence_product = str(reuse.get("productIdentity") or "").strip()
+        target_id = str(target.get("id") or "")
+        ledger_match = next(
+            (
+                item
+                for item in verification_ledger
+                if str(item.get("evidenceId") or "") == evidence_id
+                and str(item.get("targetId") or item.get("verification") or "")
+                == target_id
+                and str(item.get("productIdentity") or "") == product_identity
+                and item.get("status") == "OK"
+            ),
+            None,
+        )
+        if (
+            str(target.get("reusePolicy") or "") != "ledger-exact"
+            or not evidence_id
+            or evidence_product != product_identity
+            or ledger_match is None
+        ):
+            return "BLOCKED", ["REUSE_EVIDENCE_INVALID"]
+        return "REUSE", [str(reuse.get("reasonCode") or "REUSE_ELIGIBLE")]
+    return "EXECUTE", ["SELECTED_FOR_EXECUTION"]
+
+
+def schedule_verifications(payload: dict[str, Any]) -> dict[str, Any]:
+    """Build an explainable, lock-aware verification execution plan.
+
+    Dependencies define the earliest wave. Nodes in the same wave may run in
+    parallel only when their declared resource locks are disjoint. Long tasks
+    without a lock declaration receive one shared conservative lock.
+    """
+    targets = _normalize_targets(payload.get("targets", []))
+    if not targets:
+        return {
+            "ok": False,
+            "code": "VERIFICATION_TARGETS_REQUIRED",
+            "productIdentity": str(payload.get("productIdentity") or ""),
+            "frozenIdentity": str(payload.get("frozenIdentity") or ""),
+            "plan": [],
+            "waves": [],
+        }
+    targets.sort(key=lambda item: str(item["id"]))
+    by_id = {str(item["id"]): item for item in targets}
+    product_identity = str(payload.get("productIdentity") or "")
+    frozen_identity = str(payload.get("frozenIdentity") or "")
+    available_capabilities = {
+        str(item).strip()
+        for item in payload.get("availableCapabilities", [])
+        if str(item).strip()
+    }
+    verification_ledger = [
+        dict(item)
+        for item in payload.get("verificationLedger", [])
+        if isinstance(item, dict)
+    ]
+    decisions: dict[str, tuple[str, list[str]]] = {
+        target_id: _target_decision(
+            target,
+            product_identity=product_identity,
+            frozen_identity=frozen_identity,
+            available_capabilities=available_capabilities,
+            verification_ledger=verification_ledger,
+        )
+        for target_id, target in by_id.items()
+    }
+    waves: list[list[str]] = []
+    placed: dict[str, int | None] = {}
+    pending = set(by_id)
+
+    while pending:
+        progressed = False
+        for target_id in sorted(pending):
+            target = by_id[target_id]
+            dependencies = [str(item) for item in target.get("dependsOn", [])]
+            unknown = sorted(set(dependencies) - set(by_id))
+            if unknown:
+                decisions[target_id] = (
+                    "BLOCKED",
+                    ["DEPENDENCY_UNKNOWN:" + item for item in unknown],
+                )
+                placed[target_id] = None
+                pending.remove(target_id)
+                progressed = True
+                break
+            if any(item not in placed for item in dependencies):
+                continue
+            failed_dependencies = [
+                item
+                for item in dependencies
+                if decisions[item][0] in {"SKIP", "BLOCKED"}
+            ]
+            if failed_dependencies:
+                decisions[target_id] = (
+                    "BLOCKED",
+                    [
+                        "DEPENDENCY_BLOCKED:" + item
+                        for item in sorted(failed_dependencies)
+                    ],
+                )
+                placed[target_id] = None
+                pending.remove(target_id)
+                progressed = True
+                break
+            decision, _ = decisions[target_id]
+            if decision in {"SKIP", "BLOCKED"}:
+                placed[target_id] = None
+                pending.remove(target_id)
+                progressed = True
+                break
+            dependency_waves = [
+                placed[item]
+                for item in dependencies
+                if placed.get(item) is not None
+            ]
+            earliest = (
+                max(int(item) for item in dependency_waves) + 1
+                if dependency_waves
+                else 0
+            )
+            if decision == "REUSE":
+                placed[target_id] = max(0, earliest - 1)
+                pending.remove(target_id)
+                progressed = True
+                break
+            locks = set(_resource_locks(target))
+            wave = earliest
+            while True:
+                while wave >= len(waves):
+                    waves.append([])
+                occupied = {
+                    lock
+                    for item_id in waves[wave]
+                    for lock in _resource_locks(by_id[item_id])
+                }
+                if not locks & occupied:
+                    waves[wave].append(target_id)
+                    placed[target_id] = wave
+                    break
+                wave += 1
+            pending.remove(target_id)
+            progressed = True
+            break
+        if not progressed:
+            for target_id in sorted(pending):
+                decisions[target_id] = ("BLOCKED", ["DEPENDENCY_CYCLE"])
+                placed[target_id] = None
+            pending.clear()
+
+    plan: list[dict[str, Any]] = []
+    for target_id, target in by_id.items():
+        decision, reasons = decisions[target_id]
+        dependencies = [str(item) for item in target.get("dependsOn", [])]
+        reason_codes = [
+            *reasons,
+            *["depends-on:" + item for item in dependencies],
+        ]
+        plan.append(
+            {
+                **target,
+                "id": target_id,
+                "decision": decision,
+                "reasonCodes": reason_codes,
+                "resourceLocks": _resource_locks(target),
+                "wave": placed[target_id],
+            }
+        )
+    return {
+        "ok": all(item["decision"] != "BLOCKED" for item in plan),
+        "code": (
+            "VERIFICATION_PLAN_READY"
+            if all(item["decision"] != "BLOCKED" for item in plan)
+            else "VERIFICATION_PLAN_BLOCKED"
+        ),
+        "productIdentity": product_identity,
+        "frozenIdentity": frozen_identity,
+        "plan": plan,
+        "waves": [
+            {"wave": index, "targets": target_ids}
+            for index, target_ids in enumerate(waves)
+            if target_ids
+        ],
+    }
+
+
+def execute_verifications(payload: dict[str, Any]) -> dict[str, Any]:
+    """Execute a scheduled graph wave-by-wave through managed run sessions."""
+    import harness_runtime
+
+    scheduled = schedule_verifications(payload)
+    if not scheduled["ok"]:
+        return {**scheduled, "execution": []}
+    state_root = Path(str(payload.get("stateRoot") or "")).expanduser().resolve()
+    working_directory = Path(
+        str(payload.get("workingDirectory") or "")
+    ).expanduser().resolve()
+    if not str(payload.get("stateRoot") or "").strip():
+        return {
+            **scheduled,
+            "ok": False,
+            "code": "VERIFICATION_STATE_ROOT_REQUIRED",
+            "execution": [],
+        }
+    if not working_directory.is_dir():
+        return {
+            **scheduled,
+            "ok": False,
+            "code": "VERIFICATION_WORKDIR_INVALID",
+            "execution": [],
+        }
+    by_id = {str(item["id"]): item for item in scheduled["plan"]}
+    outcomes: dict[str, dict[str, Any]] = {
+        target_id: {
+            "targetId": target_id,
+            "status": "OK",
+            "reasonCode": "VERIFICATION_REUSED",
+        }
+        for target_id, target in by_id.items()
+        if target.get("decision") == "REUSE"
+    }
+    execution: list[dict[str, Any]] = list(outcomes.values())
+    for wave in scheduled["waves"]:
+        running: list[tuple[str, str]] = []
+        for target_id in wave["targets"]:
+            target = by_id[target_id]
+            failed_dependencies = [
+                dependency
+                for dependency in target.get("dependsOn", [])
+                if outcomes.get(str(dependency), {}).get("status") != "OK"
+            ]
+            if failed_dependencies:
+                outcome = {
+                    "targetId": target_id,
+                    "status": "BLOCKED",
+                    "reasonCode": "DEPENDENCY_EXECUTION_FAILED",
+                    "blockedBy": failed_dependencies,
+                }
+                outcomes[target_id] = outcome
+                execution.append(outcome)
+                continue
+            argv = target.get("argvTemplate")
+            if (
+                not isinstance(argv, list)
+                or not argv
+                or not all(isinstance(item, str) and item for item in argv)
+                or any("{" in item or "}" in item for item in argv)
+            ):
+                outcome = {
+                    "targetId": target_id,
+                    "status": "BLOCKED",
+                    "reasonCode": "VERIFICATION_ARGV_NOT_CONCRETE",
+                }
+                outcomes[target_id] = outcome
+                execution.append(outcome)
+                continue
+            receipt = harness_runtime.start_run_session(
+                state_root=state_root,
+                verification=target_id,
+                argv=argv,
+                working_directory=working_directory,
+                timeout_seconds=target.get("timeoutSeconds"),
+                expected_duration_seconds=target.get(
+                    "estimatedDurationSeconds"
+                ),
+                product_identity=scheduled["productIdentity"],
+                resource_locks=list(target["resourceLocks"]),
+            )
+            if receipt.get("status") in harness_runtime.RUN_TERMINAL_STATUSES:
+                outcome = {"targetId": target_id, **receipt}
+                outcomes[target_id] = outcome
+                execution.append(outcome)
+            else:
+                running.append((target_id, str(receipt["sessionId"])))
+        while running:
+            remaining: list[tuple[str, str]] = []
+            for target_id, session_id in running:
+                receipt = harness_runtime.run_session_status(state_root, session_id)
+                if receipt.get("status") in harness_runtime.RUN_TERMINAL_STATUSES:
+                    outcome = {"targetId": target_id, **receipt}
+                    outcomes[target_id] = outcome
+                    execution.append(outcome)
+                else:
+                    remaining.append((target_id, session_id))
+            running = remaining
+            if running:
+                time.sleep(0.05)
+    execution_ok = all(item.get("status") == "OK" for item in execution)
+    return {
+        **scheduled,
+        "ok": execution_ok,
+        "code": (
+            "VERIFICATION_EXECUTION_OK"
+            if execution_ok
+            else "VERIFICATION_EXECUTION_FAILED"
+        ),
+        "execution": execution,
+    }
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="harness_verification.py")
-    parser.add_argument("select", nargs="?")
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=("select", "plan", "execute"),
+        default="select",
+    )
     parser.add_argument("--input", required=True, type=Path)
     parser.add_argument("--out", type=Path)
     parser.add_argument("--json", action="store_true")
     args = parser.parse_args(argv)
-    result = select_verifications(
-        json.loads(args.input.read_text(encoding="utf-8-sig"))
-    )
+    payload = json.loads(args.input.read_text(encoding="utf-8-sig"))
+    if args.command == "execute":
+        result = execute_verifications(payload)
+    elif args.command == "plan":
+        result = schedule_verifications(payload)
+    else:
+        result = select_verifications(payload)
     if args.out:
         args.out.parent.mkdir(parents=True, exist_ok=True)
         args.out.write_text(
@@ -107,7 +507,7 @@ def main(argv: list[str] | None = None) -> int:
             encoding="utf-8",
         )
     print(json.dumps(result, ensure_ascii=False, indent=2))
-    return 0
+    return 0 if result.get("ok") else 1
 
 
 if __name__ == "__main__":

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

@@ -2,9 +2,9 @@
   "schema_version": 2,
   "profile": "general",
   "adapter": "claude-code",
-  "bundle_version": "0.2.31",
+  "bundle_version": "0.2.32",
   "requires": {
-    "minimumCliVersion": "0.2.44",
+    "minimumCliVersion": "0.2.45",
     "capabilities": [
       "sync@2",
       "rules-sync@1",
@@ -12,6 +12,7 @@
       "knowledge-sync@3",
       "build-profile@3",
       "verification-graph@1",
+      "execution-session@1",
       "external-convergence@1",
       "codegraph-status@2",
       "doctor-capability@1",
@@ -22,7 +23,7 @@
   "files": [
     {
       "path": ".harness-build.json",
-      "sha256": "87389b46fe1cd171ac419b2bea1d86c859642768deaf77e58b6ee31d082c8f5c"
+      "sha256": "2bc63b2a999812dad07176ee1b887caac1053046cc1150ba7e504e1f04a13963"
     },
     {
       "path": "agents/harness-evaluator.md",
@@ -42,7 +43,7 @@
     },
     {
       "path": "contracts/build-profile-v3.schema.json",
-      "sha256": "4bce197283c749a79a12bdefa85dbb6506656478806c629270594d52ecc6c14c"
+      "sha256": "12be5f258673f18d271aec962b333c6a25be1af19726c1565a568a4f085aadd7"
     },
     {
       "path": "contracts/ci-metrics.schema.json",
@@ -66,7 +67,7 @@
     },
     {
       "path": "harness-archive/reference.md",
-      "sha256": "9a76b0d880e3951ca2d24e56573a4144fdfe3d7abb4a8a44dda4a19d4dce4ec1"
+      "sha256": "7564286fae2b73a9a646819b408d0dcd3ed757fdc833d19e8a130861f92ffb03"
     },
     {
       "path": "harness-archive/scripts/gen-manifest.ps1",
@@ -74,15 +75,15 @@
     },
     {
       "path": "harness-archive/SKILL.md",
-      "sha256": "251ceb2210428ca34db6d3a76d55acfa7f53a7e7953f8b57c9a0fa13d11f2aaf"
+      "sha256": "087bccc2059780f405111656bf3a6a586e0e83af2408a5ccdc0110b0d69741de"
     },
     {
       "path": "harness-archive/templates/render-summary.mjs",
-      "sha256": "a4d1a98de2cf6a6ab74ddba33b6529459f7f5b009f31c5a7021f6abe2c0afef0"
+      "sha256": "970585dcd1c590a6fc985289954b60c41b2cf012df7ea2dd790260e452e404c9"
     },
     {
       "path": "harness-archive/templates/summary-data-template.json",
-      "sha256": "4cc275012d59f22fae14b41c81b076b9865c3f0027addcea5e746dd303101dd7"
+      "sha256": "6d2a1ef5b02287150f14f530902e78382fcf0111beeff4eb63bcf1a88f26b05c"
     },
     {
       "path": "harness-codebase-map/checklist.md",
@@ -94,7 +95,7 @@
     },
     {
       "path": "harness-codebase-map/SKILL.md",
-      "sha256": "e80b9578f785db234ca0ce0ffad2326b7221f0871930a6c61c3defd70213f6f9"
+      "sha256": "6c358466447cb65726f5208b324dc3585cd99e60449b2d6594f434ac2bc1b3be"
     },
     {
       "path": "harness-codebase-map/templates/ARCHITECTURE.md",
@@ -158,11 +159,11 @@
     },
     {
       "path": "harness-knowledge-ingest/SKILL.md",
-      "sha256": "948dea77f853df34786f8465a907170154255528503573b3b87aa27a57ef6235"
+      "sha256": "71f060cac1fbb20de5546cb9c701b19b0c94bc7c88a96c89e8a63e8346da1fb1"
     },
     {
       "path": "harness-knowledge-query/SKILL.md",
-      "sha256": "bd6235efef89893cf35cc1e01e93112355f368c33722b69f4e72abc48d900ef0"
+      "sha256": "da4b65dfc7a599a8f74b4c1dec021d3ce22da82e14d7f6df79f915dc0394f7ce"
     },
     {
       "path": "harness-plan/checklist.md",
@@ -178,7 +179,7 @@
     },
     {
       "path": "harness-plan/SKILL.md",
-      "sha256": "e5c1e00b76d02aa9ba5c765d84cb496f5304677d282385d3f7323240a4a64dc0"
+      "sha256": "c977aa7851fb32e9d82bf0c147cb209fee43010437ec3feabb3138dfbeba70d1"
     },
     {
       "path": "harness-review/checklist.md",
@@ -194,7 +195,7 @@
     },
     {
       "path": "harness-review/SKILL.md",
-      "sha256": "5934dea44bebc26411edc3b1f5f127f032dea2e97f8f4f38a9d2d472a280bee3"
+      "sha256": "a496c7ed5914a4c14b3b2b05adb2a45d49f3bc816435c83979fd8660f7476467"
     },
     {
       "path": "harness-run/checklist.md",
@@ -206,11 +207,11 @@
     },
     {
       "path": "harness-run/reference.md",
-      "sha256": "6b25813eb7d4ae78772e2f85fda4875698633538e562e8a18d31c773d1689a8a"
+      "sha256": "b6887480549e86434d9cfce0003ffe698e81e8ed0b63512e303278f21267748b"
     },
     {
       "path": "harness-run/SKILL.md",
-      "sha256": "324297b618540c072fd7d6cabc6d424679e49bc6884c9340737a750a5887e00d"
+      "sha256": "5547c82ac3cbce6467db81d50e745b876b15cd944bcb89cc7433348eab2f004c"
     },
     {
       "path": "harness-submit/checklist.md",
@@ -222,7 +223,7 @@
     },
     {
       "path": "harness-submit/SKILL.md",
-      "sha256": "c36b6af82ff4b6249e6312df63462c548e7e13ed1215e9a59624d76178e5c5f1"
+      "sha256": "b6dbf2271dcb5aa3c549c0e9f8a22941c0ce18164ce6e4efbec1f5c1b3fbae7e"
     },
     {
       "path": "harness-sync/reference.md",
@@ -230,7 +231,7 @@
     },
     {
       "path": "harness-sync/SKILL.md",
-      "sha256": "27c56c5cca98a91b99c3f8e16f9b78a61d257be9aa8be21c8c4b5a7282b26dc9"
+      "sha256": "b59e3a519c106f992160920f7f546152bbb1039432358eb7472288dffb4ff270"
     },
     {
       "path": "harness-test/checklist.md",
@@ -254,7 +255,7 @@
     },
     {
       "path": "harness-test/SKILL.md",
-      "sha256": "0986a30598cf5e4723cb6fa307b4ed8c2192f55f2cdc3cc5a5133c5382eb390f"
+      "sha256": "f81237ccd069f9daa77ad2302d97b33e3fc4bcf24e8bc04ade22d31a2202f101"
     },
     {
       "path": "protocols/archive-report-protocol.md",
@@ -268,6 +269,10 @@
       "path": "protocols/evidence-based-reporting-protocol.md",
       "sha256": "f78ea87823c0935a3033175b393582319da433cf4226e1705070b20d53890ba2"
     },
+    {
+      "path": "protocols/execution-session-protocol.md",
+      "sha256": "d0ac7ab78cb0bac155e5ca92186168c31779cdd0da1fabbbb2c493dd132f02c2"
+    },
     {
       "path": "protocols/external-platform-protocol.md",
       "sha256": "6893e3b6a5615ee3eda567952797f91f4d2fcec59c1f8fd947e472a4c1f6ed71"
@@ -302,7 +307,7 @@
     },
     {
       "path": "protocols/state-layout-protocol.md",
-      "sha256": "8f20ae2dac0244f39b7dad162bf58f3a502b23dea968dc97d7f2b4d82f4a4cba"
+      "sha256": "517bfa32a9446a898e753344ac652e16cf282fe19abc59490e90926f35ee1e81"
     },
     {
       "path": "protocols/submit-protocol.md",
@@ -310,7 +315,7 @@
     },
     {
       "path": "protocols/verification-graph-protocol.md",
-      "sha256": "f34b3dbcfb09ce0f3cbf56a22bda1b25afef305b6f57b90138ba7b366511f402"
+      "sha256": "8f1b140c4e51b1f3b437971b6d3154c2aeaf8dad404512f7bc2fbad5f640f0ca"
     },
     {
       "path": "README.md",
@@ -322,7 +327,7 @@
     },
     {
       "path": "scripts/harness_archive.py",
-      "sha256": "428273edc77d4c8ee5f7488abd7e0dbc8c6f82b3d8267d02e9e144fe06bb53e4"
+      "sha256": "4ffdd0b5a61a60ee263d32d61b67da7c5ba4101968d0de7510894044c4f4b407"
     },
     {
       "path": "scripts/harness_change.py",
@@ -340,14 +345,22 @@
       "path": "scripts/harness_deploy.py",
       "sha256": "fb4290c2dd5c28a09c378da5ee7be491bdefe0410f277ec5dd2af1952cfddbca"
     },
+    {
+      "path": "scripts/harness_efficiency.py",
+      "sha256": "36b2ecbe75a453b35cf6085bbc5e61c04f82e627f9f4f243d29837fad6568c9d"
+    },
     {
       "path": "scripts/harness_environment.py",
-      "sha256": "beeef14f7b5f6a14e15ba518236c2cee40c63e4a61d057d046edab3a48e629a2"
+      "sha256": "35ffcf5d76c7165f1aee7ed2953b1b86c943e9c751827b81c126e99a58fdd641"
     },
     {
       "path": "scripts/harness_events.py",
       "sha256": "0d4db19d71d5945837c255192f7c915af447f98e2ac66bf60e25b93f1613b391"
     },
+    {
+      "path": "scripts/harness_fixback.py",
+      "sha256": "723c48a0034648f8a96967749baacbfdde59774cec2a66b1b26a34ea5f7f2b0f"
+    },
     {
       "path": "scripts/harness_gate.py",
       "sha256": "404ad6fdf0f5508a22e12086a05f728df41074bbc2c8072f577d500a797c91c5"
@@ -386,7 +399,7 @@
     },
     {
       "path": "scripts/harness_profile.py",
-      "sha256": "cad15c1143a3fe42aa76e45ccf821dc212c2df281cbea21d0dcfde44f4ca26c7"
+      "sha256": "0d6ec71588058e6ca7442ea7148169d1bf2f9db83a756ec29be1aa4b4281413a"
     },
     {
       "path": "scripts/harness_report_model.py",
@@ -402,11 +415,11 @@
     },
     {
       "path": "scripts/harness_runtime.py",
-      "sha256": "0cc27b7622922fa1c998973979d4970c5c993efe42545fa64dd0e64993030fce"
+      "sha256": "a50cfc9dd5f157251a7ecb8287384319663ec44408bceb0d58e3507c9f8fe340"
     },
     {
       "path": "scripts/harness_service.py",
-      "sha256": "56862b94d43314ad6515c37ad2945d256672cde66db3da1cbfbde8aebf94847c"
+      "sha256": "d3dd9bf79d4b89fe1b40b3564e2831b89008dfc781034875d72c034216079d24"
     },
     {
       "path": "scripts/harness_state.py",
@@ -426,11 +439,11 @@
     },
     {
       "path": "scripts/harness_test_runner.py",
-      "sha256": "119a884794c0a417e6ffd128dfa601ac17ed5630b3db6b923d357875d3739c7e"
+      "sha256": "562b6bf2ab69b2c85c77ae300f25c6fdfbfb19d35791aea0c92350a99034af2e"
     },
     {
       "path": "scripts/harness_verification.py",
-      "sha256": "a54a257d6c068f4e15f0174a841845cab61af02c4abc35503f99d7fdd206c4f7"
+      "sha256": "038f1f19b2ff10c65f6f66f48df63334a1834342107237c8bca1aeefea87515d"
     },
     {
       "path": "scripts/harness_workflow_policy.py",