@hunter-harness/workflow-harness 0.2.17 → 0.2.19

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

@@ -109,6 +109,10 @@ class CleanupResidualError(IntegrationError):
         )
 
 
+class AbandonRefusedError(IntegrationError):
+    code = "ABANDON_REFUSED"
+
+
 class JournalConflictError(IntegrationError):
     code = "JOURNAL_CONFLICT"
 
@@ -740,6 +744,8 @@ class IntegrationTransaction:
                 str(intg_root),
                 self.temp_branch,
             )
+            # H-5: LF-stable hashing in the integration worktree.
+            self.runner.run(intg_root, "config", "core.autocrlf", "false")
 
         return self._run_step("prepare", action)
 
@@ -1195,6 +1201,148 @@ class IntegrationTransaction:
         harness_change.integration_lock_release(self.project_root, run_id=self.run_id)
         return journal
 
+    # ------------------------------------------------------------ abandon
+
+    def _remote_contains_merge(self, journal: dict[str, Any]) -> bool:
+        merge_commit = str(journal.get("mergeCommit") or "")
+        if not merge_commit:
+            return False
+        remote_line = self.runner.text(
+            self.project_root, "ls-remote", "origin", self.target_branch
+        )
+        observed_remote = (
+            remote_line.split()[0] if remote_line and remote_line.split() else ""
+        )
+        return bool(observed_remote and observed_remote == merge_commit)
+
+    def _force_remove_integration_root(
+        self, journal: dict[str, Any], intg_root: Path
+    ) -> dict[str, Any]:
+        """Best-effort remove of the integration worktree for abandon only."""
+        allowed = Path(str(journal.get("allowedCleanupRoot") or "")).resolve()
+        resolved = harness_paths.assert_path_within(intg_root, self.temp_root)
+        if not allowed or resolved != allowed:
+            raise CleanupRefusedError(
+                f"refusing to abandon non-transaction path: {resolved}"
+            )
+        self.runner.run(
+            self.project_root,
+            "worktree",
+            "remove",
+            "--force",
+            str(resolved),
+            check=False,
+        )
+        residual: list[str] = []
+        if resolved.exists():
+            for name in HEAVY_WORKTREE_ROOTS:
+                heavy = resolved / name
+                if heavy.exists():
+                    harness_paths.assert_path_within(heavy, resolved)
+                    try:
+                        if heavy.is_dir() and not heavy.is_symlink():
+                            shutil.rmtree(heavy)
+                        else:
+                            heavy.unlink()
+                    except OSError:
+                        residual.append(name)
+            if resolved.exists():
+                try:
+                    shutil.rmtree(resolved)
+                except OSError:
+                    residual.append(str(resolved))
+        listed = self.runner.text(self.project_root, "worktree", "list", "--porcelain")
+        still_registered = str(resolved) in {
+            str(Path(line.removeprefix("worktree ")).resolve())
+            for line in (listed or "").splitlines()
+            if line.startswith("worktree ")
+        }
+        ok = not still_registered and not residual and not resolved.exists()
+        return {
+            "ok": ok,
+            "code": "CLEANUP_COMPLETE" if ok else "CLEANUP_RESIDUAL",
+            "target": str(resolved),
+            "worktreeRegistered": still_registered,
+            "diskPathPresent": resolved.exists(),
+            "residualPaths": residual,
+        }
+
+    def abandon(self) -> dict[str, Any]:
+        """Official recovery for a failed integration transaction (H-6).
+
+        Allowed only when push is not DONE and the remote does not already
+        contain ``mergeCommit``. Removes the integration worktree, temp branch,
+        protection refs, and integration lock. Never deletes the feature
+        worktree or feature branch.
+        """
+        try:
+            journal = self._load()
+        except FileNotFoundError as exc:
+            raise AbandonRefusedError(
+                f"no journal for transaction {self.transaction_id}"
+            ) from exc
+
+        push_status = str(self._step(journal, "push").get("status") or "")
+        push_intent = journal.get("pushIntent") or {}
+        push_confirmed = (
+            push_status == "DONE"
+            or (
+                isinstance(push_intent, dict)
+                and push_intent.get("status") == "REMOTE_CONFIRMED"
+            )
+            or bool(journal.get("pushedHead"))
+            or bool(journal.get("mergeFinalHash"))
+        )
+        remote_has_merge = self._remote_contains_merge(journal)
+        if push_confirmed or remote_has_merge:
+            raise AbandonRefusedError(
+                "refuse abandon: push succeeded or remote already contains "
+                "the merge commit; use cleanup instead"
+            )
+
+        intg_root = Path(str(journal.get("integrationRoot") or ""))
+        cleanup_result: dict[str, Any] = {
+            "ok": True,
+            "code": "ALREADY_ABSENT",
+            "target": str(intg_root) if intg_root else "",
+            "worktreeRegistered": False,
+            "diskPathPresent": False,
+            "residualPaths": [],
+        }
+        prepare_done = self._step(journal, "prepare").get("status") == "DONE"
+        if prepare_done and str(journal.get("integrationRoot") or "").strip():
+            try:
+                cleanup_result = self.cleanup_target(intg_root)
+            except CleanupRefusedError:
+                cleanup_result = self._force_remove_integration_root(journal, intg_root)
+
+        self.runner.run(
+            self.project_root, "branch", "-D", self.temp_branch, check=False
+        )
+        refs = journal.get("protectionRefs") or {}
+        if isinstance(refs, dict):
+            for ref in (refs.get("base"), refs.get("head")):
+                if ref:
+                    self.runner.run(
+                        self.project_root, "update-ref", "-d", str(ref), check=False
+                    )
+
+        harness_change.integration_lock_release(self.project_root, run_id=self.run_id)
+
+        journal = self._load()
+        journal["abandonedAt"] = now_iso()
+        journal["abandonResult"] = cleanup_result
+        self._save(journal)
+
+        return {
+            "ok": True,
+            "code": "ABANDON_COMPLETE",
+            "transactionId": self.transaction_id,
+            "cleanup": cleanup_result,
+            "featureBranchRetained": True,
+            "featureWorktreeRetained": True,
+        }
+
     # ------------------------------------------------------------ recover
 
     def recover(
@@ -1282,6 +1430,10 @@ def cmd_cleanup(args: argparse.Namespace) -> int:
     return _emit(_txn_from_args(args).cleanup())
 
 
+def cmd_abandon(args: argparse.Namespace) -> int:
+    return _emit(_txn_from_args(args).abandon())
+
+
 def cmd_recover(args: argparse.Namespace) -> int:
     return _emit(_txn_from_args(args).recover())
 
@@ -1333,6 +1485,7 @@ def build_parser() -> argparse.ArgumentParser:
     add("merge", cmd_merge)
     add("push", cmd_push)
     add("cleanup", cmd_cleanup)
+    add("abandon", cmd_abandon)
     add("recover", cmd_recover)
     add("status", cmd_status)
 

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

@@ -131,8 +131,19 @@ def emit_compact_or_verbose(
     emit_json(out, as_json=as_json)
 
 
-def emit_error(message: str, *, as_json: bool, code: int = 1) -> int:
-    payload = {"ok": False, "error": message}
+def emit_error(
+    message: str,
+    *,
+    as_json: bool,
+    code: int = 1,
+    error_code: str | None = None,
+    extra: dict[str, Any] | None = None,
+) -> int:
+    payload: dict[str, Any] = {"ok": False, "error": message}
+    if error_code:
+        payload["code"] = error_code
+    if extra:
+        payload.update(extra)
     if as_json:
         sys.stderr.write(json.dumps(payload, ensure_ascii=False) + "\n")
     else:
@@ -1520,6 +1531,8 @@ def cmd_record(args: argparse.Namespace) -> int:
                 return emit_error(
                     "ledger identity incomplete: " + ", ".join(missing),
                     as_json=as_json,
+                    error_code="LEDGER_IDENTITY_INVALID",
+                    extra={"missing": missing},
                 )
         write_ledger(out_path, ledger)
     except (OSError, ValueError, FileNotFoundError, json.JSONDecodeError) as exc:

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

@@ -20,7 +20,7 @@ import re
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any
+from typing import Any, Sequence
 
 SCRIPTS_DIR = Path(__file__).resolve().parent
 if str(SCRIPTS_DIR) not in sys.path:
@@ -289,6 +289,175 @@ def assert_path_within(
     return resolved
 
 
+class CleanupTopologyError(ValueError):
+    """Raised when cleanup would delete or traverse into state/archive roots."""
+
+    code = "CLEANUP_TOPOLOGY_REFUSED"
+
+
+# Skip descending into these when scanning for junction/symlink escapes.
+# Matches integration HEAVY_WORKTREE_ROOTS plus .git (topology scan only).
+CLEANUP_WALK_SKIP_DIRS = frozenset(
+    {
+        "node_modules",
+        ".venv",
+        "venv",
+        "build",
+        "dist",
+        "target",
+        ".cache",
+        "__pycache__",
+        ".git",
+    }
+)
+
+
+def assert_cleanup_safe(
+    cleanup_root: Path,
+    state_roots: Sequence[Path] | None = None,
+    archive_roots: Sequence[Path] | None = None,
+) -> Path:
+    """Refuse cleanup when state/archive roots resolve inside the cleanup tree.
+
+    Also refuses when a junction/symlink under ``cleanup_root`` resolves into a
+    protected state/archive root (Windows junction / symlink escape).
+    """
+    cleanup = Path(cleanup_root).resolve()
+    protected: list[Path] = []
+    for raw in [*(state_roots or ()), *(archive_roots or ())]:
+        try:
+            protected.append(Path(raw).resolve())
+        except OSError as exc:
+            raise CleanupTopologyError(
+                f"CLEANUP_TOPOLOGY_REFUSED: cannot resolve protected path {raw}: {exc}"
+            ) from exc
+
+    for prot in protected:
+        if prot == cleanup or prot.is_relative_to(cleanup):
+            raise CleanupTopologyError(
+                "CLEANUP_TOPOLOGY_REFUSED: protected path "
+                f"{prot} is inside cleanup root {cleanup}"
+            )
+
+    if cleanup.is_dir():
+        for dirpath, dirnames, filenames in os.walk(cleanup, followlinks=False):
+            # Inspect this level (including heavy names) for link escapes, then
+            # prune descent so we do not walk install/cache trees.
+            entries = [*dirnames, *filenames]
+            dirnames[:] = [d for d in dirnames if d not in CLEANUP_WALK_SKIP_DIRS]
+            for name in entries:
+                child = Path(dirpath) / name
+                try:
+                    is_link = child.is_symlink()
+                except OSError:
+                    continue
+                # Junctions often report as directories; resolve and compare.
+                try:
+                    resolved_child = child.resolve()
+                except OSError:
+                    continue
+                escaped = not (
+                    resolved_child == cleanup or resolved_child.is_relative_to(cleanup)
+                )
+                if not (is_link or escaped):
+                    continue
+                for prot in protected:
+                    if (
+                        resolved_child == prot
+                        or resolved_child.is_relative_to(prot)
+                        or prot.is_relative_to(resolved_child)
+                    ):
+                        raise CleanupTopologyError(
+                            "CLEANUP_TOPOLOGY_REFUSED: cleanup path "
+                            f"{child} resolves to protected {resolved_child}"
+                        )
+    return cleanup
+
+
+_FORMAL_SNAPSHOT_DIRS = ("plans", "spec", "evidence", "reports", "meta")
+_FORMAL_SNAPSHOT_FILES = ("events.ndjson",)
+
+
+def snapshot_change_formal_layer(
+    project_root: Path,
+    change_id: str,
+    *,
+    change_dir: Path | None = None,
+) -> dict[str, Any]:
+    """Copy change formal layer into ``.harness/cache/change-snapshots/<change>/``.
+
+    Destination is always under the main project / common harness root — never
+    under a feature worktree path alone.
+    """
+    import shutil
+
+    project = resolve_main_project_root(Path(project_root))
+    src = Path(change_dir).resolve() if change_dir is not None else (
+        project / ".harness" / "changes" / change_id
+    ).resolve()
+    if not src.is_dir():
+        raise FileNotFoundError(f"change dir not found for snapshot: {src}")
+
+    dest = (project / ".harness" / "cache" / "change-snapshots" / change_id).resolve()
+    # Hard guard: never write the snapshot inside the source tree itself.
+    if dest == src or dest.is_relative_to(src):
+        raise ValueError(
+            f"snapshot destination must not be inside change dir: {dest}"
+        )
+    dest.mkdir(parents=True, exist_ok=True)
+
+    copied: list[str] = []
+    for name in _FORMAL_SNAPSHOT_DIRS:
+        source_dir = src / name
+        if not source_dir.is_dir():
+            continue
+        target_dir = dest / name
+        shutil.copytree(source_dir, target_dir, dirs_exist_ok=True)
+        copied.append(name + "/")
+    for name in _FORMAL_SNAPSHOT_FILES:
+        source_file = src / name
+        if not source_file.is_file():
+            continue
+        shutil.copy2(source_file, dest / name)
+        copied.append(name)
+
+    file_hashes: dict[str, str] = {}
+    for path in sorted(dest.rglob("*")):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(dest).as_posix()
+        if rel == "manifest.json":
+            continue
+        digest = hashlib.sha256(path.read_bytes()).hexdigest()
+        file_hashes[rel] = "sha256:" + digest
+
+    manifest = {
+        "schemaVersion": 1,
+        "changeId": change_id,
+        "source": str(src),
+        "destination": str(dest),
+        "projectRoot": str(project),
+        "copied": copied,
+        "files": file_hashes,
+        "fileCount": len(file_hashes),
+    }
+    manifest_path = dest / "manifest.json"
+    manifest_path.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+        newline="\n",
+    )
+    return {
+        "ok": True,
+        "code": "CHANGE_SNAPSHOT_WRITTEN",
+        "changeId": change_id,
+        "destination": str(dest),
+        "fileCount": len(file_hashes),
+        "copied": copied,
+        "manifestPath": str(manifest_path),
+    }
+
+
 def cmd_resolve_layout(args: argparse.Namespace) -> int:
     layout = resolve_change_layout(Path.cwd(), args.change)
     sys.stdout.write(json.dumps(layout, ensure_ascii=False, indent=2) + "\n")

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

@@ -48,6 +48,7 @@ PROFILE_REL = Path(".harness") / "config" / "build-profile.json"
 DEFAULT_EXCLUDED_ROOTS: tuple[str, ...] = (
     ".git",
     ".harness",
+    ".worktrees",
     ".claude/worktrees",
     ".codex/worktrees",
     ".cursor/worktrees",

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

@@ -23,10 +23,10 @@ if hasattr(sys.stderr, "reconfigure"):
 SCHEMA_VERSION = 1
 _CHANGE_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
 _ADAPTERS = {
-    "claude-code": (".claude/worktrees", "claude/"),
-    "codex": (".codex/worktrees", "codex/"),
-    "cursor": (".cursor/worktrees", "cursor/"),
-    "codebuddy": (".codebuddy/worktrees", "codebuddy/"),
+    "claude-code": (".worktrees", "harness/"),
+    "codex": (".worktrees", "harness/"),
+    "cursor": (".worktrees", "harness/"),
+    "codebuddy": (".worktrees", "harness/"),
 }
 
 

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

@@ -164,6 +164,7 @@ def get_service_start(profile: dict[str, Any]) -> dict[str, Any]:
 # runtime resolve 把具体 overlay/profile 注入到 session，不写回持久 profile
 # （spec §3.1 持久 profile 只保存模板；§3.4 修复输入端陈旧 profile）。
 STALE_WORKTREE_MARKERS: tuple[str, ...] = (
+    ".worktrees/",
     ".claude/worktrees/",
     ".cursor/worktrees/",
     ".codeium/worktrees/",

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

@@ -7,7 +7,7 @@
   "files": [
     {
       "path": ".harness-build.json",
-      "sha256": "f8d05b3cde1a30f216ab0d3ba26ec45796f533686a003c4c656a36aed077634b"
+      "sha256": "a7fd6e4e51c881e477be82f244cc3ab7ee32936d272b04bb0adc89b7b40d3e81"
     },
     {
       "path": "agents/harness-evaluator.md",
@@ -35,7 +35,7 @@
     },
     {
       "path": "harness-archive/checklist.md",
-      "sha256": "0329561202acf39646f08c861a2859ffe68164df05b95526af86c5b1842d2009"
+      "sha256": "c996b57c4f90a9a5285e59c7391e0628e9627974f030b2629bb477c36ad77aa5"
     },
     {
       "path": "harness-archive/reference.md",
@@ -47,7 +47,7 @@
     },
     {
       "path": "harness-archive/SKILL.md",
-      "sha256": "1081a1913e62f86ada5b5b43eed866e0de0aca1e9900883aa9c3a328168e0128"
+      "sha256": "de28ac18baac77b3ab0881ead2a5aa2caae5cfccd5405104ec5f7b47331cc8c0"
     },
     {
       "path": "harness-archive/templates/render-summary.mjs",
@@ -67,7 +67,7 @@
     },
     {
       "path": "harness-codebase-map/SKILL.md",
-      "sha256": "ebfa5cc6ca087dddf001c7e951cfe40c9a47dd1ab15e69b696564bc9d35c4dd2"
+      "sha256": "81fd2ec9fee4da20d650e6dc48ab4ab741f12245c281d853f7a00936c7eb9e0b"
     },
     {
       "path": "harness-codebase-map/templates/ARCHITECTURE.md",
@@ -131,11 +131,11 @@
     },
     {
       "path": "harness-knowledge-ingest/SKILL.md",
-      "sha256": "fb0e10981ec43a63fe89365edf12c4d65058050d593e612cbca05116f721a76f"
+      "sha256": "ab3a09a404d69852376aaba528abbe44b831aca48f9763783af71fb0efcacf9b"
     },
     {
       "path": "harness-knowledge-query/SKILL.md",
-      "sha256": "4825b36103b11eb1b2759167638af9234d6612b16ea2024c87f0c4dadf740e46"
+      "sha256": "7e9fb5f54f07bf2b2394e14be136fe771835c082e40fe7f61206fc11a22bae4e"
     },
     {
       "path": "harness-plan/checklist.md",
@@ -147,15 +147,15 @@
     },
     {
       "path": "harness-plan/reference.md",
-      "sha256": "5f3ee154ad79f4b5906efffbd09f14d26ca629540002fb06e35208c21bd5efa4"
+      "sha256": "1d252ecff35031bdc32692f52ee8d736d9d8570d5d8ab351ebaf81e85ffc56ea"
     },
     {
       "path": "harness-plan/SKILL.md",
-      "sha256": "83d1a6c96be57ea556d0c08c665ad62ccd7813bb9f7e5fed0354ab8f4cd3756c"
+      "sha256": "34df4f0e7e0fa656800b0546e3a724c86c95c96ebf990f145a93154a88dda70e"
     },
     {
       "path": "harness-review/checklist.md",
-      "sha256": "9bb5fcbd3cd407464c2f7c9b3feb5949410aa094b0fac95b39337ed30e3e885b"
+      "sha256": "5827ab101fd8d83c7f4616cb538b2dad0d5174e8f70e79d0af54871fb4d8a80f"
     },
     {
       "path": "harness-review/protocols.md",
@@ -167,11 +167,11 @@
     },
     {
       "path": "harness-review/SKILL.md",
-      "sha256": "536fc0c4200bd8701991b2446d929c1fb3db6b06838227860eea81a8ea734cd1"
+      "sha256": "ce103208e022e238bdd0b6e501c4faf9194b95ed2d736c52816b004eda4812b0"
     },
     {
       "path": "harness-run/checklist.md",
-      "sha256": "9b7578d1697772c6c545d1a65c0d232b7f0848185aa4b47ee254ee7b3fbbcb81"
+      "sha256": "8f8be29c43b2a37885d0ef729ca4a1cb748869d65de0498b0e38f3e1cc7f317a"
     },
     {
       "path": "harness-run/protocols.md",
@@ -179,15 +179,15 @@
     },
     {
       "path": "harness-run/reference.md",
-      "sha256": "0c47bca05013669fb1f1a6d6d232aa7771657a5b9727f666811bc2d9e640850c"
+      "sha256": "00d13333bc9e398842155bc4f9e59792be3666b15b471e093c8f50fe8aa0abf6"
     },
     {
       "path": "harness-run/SKILL.md",
-      "sha256": "89cfccb7a8bae365a56614bf4e6b21749e83abb894f3af18ee6430fe23cafeff"
+      "sha256": "ee22d79c40fbf24d2ab7eba24448c7e89274bb2a81c7d6875fcc526cfd03e771"
     },
     {
       "path": "harness-submit/checklist.md",
-      "sha256": "9748c5cb4fb33919490d2cc7757b35fd191090ed02af6eacce8aa97e19666328"
+      "sha256": "54230792cd9716c663ba3e7f569846910f67d0f0955bf38bafb653062111357c"
     },
     {
       "path": "harness-submit/reference.md",
@@ -195,7 +195,7 @@
     },
     {
       "path": "harness-submit/SKILL.md",
-      "sha256": "d0ff4a5569685e018fef7bdc02a17d9a5889b269505dd0b0d31dbe66d75301f9"
+      "sha256": "3d32ae7ee46dbad5fac6f1363f67e16c6fd9ec0cbdddff926a8ce37b95349c82"
     },
     {
       "path": "harness-sync/reference.md",
@@ -203,7 +203,7 @@
     },
     {
       "path": "harness-sync/SKILL.md",
-      "sha256": "1544c88eb25a2902df8e0789e2b7f4bb0ba6b5da8baf01293d745f42e3c514d3"
+      "sha256": "02f0b36925dc6e7da64a5674b15e2395c40c4eb91d17ae169c4d557882156dff"
     },
     {
       "path": "harness-test/checklist.md",
@@ -227,7 +227,7 @@
     },
     {
       "path": "harness-test/SKILL.md",
-      "sha256": "cc698eebaa77cb448ef9aba98e8b0e0c43ee7530557e2df9d33645539bbc7b37"
+      "sha256": "f4a9e2b2d3724d3df2bc0a98784c8dd0cd56c99cd726ecba9669e3d10639694e"
     },
     {
       "path": "protocols/archive-report-protocol.md",
@@ -247,7 +247,7 @@
     },
     {
       "path": "protocols/report-pipeline-protocol.md",
-      "sha256": "1a54a6a1540e9da41cf3466eee8a3810eb2b3ae732ab87f295d1832d135da6fb"
+      "sha256": "46ade8806083f2b83b41099976555291f01c44990977fc7eb968007dee5a653d"
     },
     {
       "path": "protocols/sensitive-info-protocol.md",
@@ -271,7 +271,7 @@
     },
     {
       "path": "scripts/harness_archive.py",
-      "sha256": "3e4802a07b2f798243bdcfe4733830b59ea4a387a751189e23017a4dc2ebc80b"
+      "sha256": "739671addbac6096860342910dd046178db04d130b34df129667ddd3523449cb"
     },
     {
       "path": "scripts/harness_change.py",
@@ -287,7 +287,7 @@
     },
     {
       "path": "scripts/harness_events.py",
-      "sha256": "a44614a8bb497820619feaf2531569942a7a61de2dfe4d3f0646aece23636f62"
+      "sha256": "dcc4c1e4c2967ec7a07c103890f45f2903fc2784adebe3d6c5ae8e92037efd4f"
     },
     {
       "path": "scripts/harness_gate.py",
@@ -295,15 +295,15 @@
     },
     {
       "path": "scripts/harness_integration.py",
-      "sha256": "777c8d0bd07b026645d5c6938da64699c123ab13870f04963fa0b09a900b095d"
+      "sha256": "ab963ef60b554118858124a6a8ed3af09bdc0bf78a873251825aee225ad77ad4"
     },
     {
       "path": "scripts/harness_ledger.py",
-      "sha256": "60a6cdff5c3c81abf5606f7914c299828c4ed2b21d19e9acbb27b001a03fcaa5"
+      "sha256": "6d6b5fd9626178d5c10d0fd878f5a31c137b8b292e6a65838f6f06e0991e7576"
     },
     {
       "path": "scripts/harness_paths.py",
-      "sha256": "c60d272e61aa98fc84a89c24db81c1ff8cbf2dac16b88fddbcd18fcc5d6199a5"
+      "sha256": "4042a0ee0521a3ff26448d63415eaf63dd45161d71d8c54a2b72665a1263e02b"
     },
     {
       "path": "scripts/harness_phase.py",
@@ -319,7 +319,7 @@
     },
     {
       "path": "scripts/harness_profile.py",
-      "sha256": "e242f79d36d7a38bdf3927cd2f65d1c7bb687a4119b07e41a59fec6989d5e253"
+      "sha256": "366575a5d201da2730f1c28acbbf4a4ef76dbdacb38d222a555671c93a06b8e0"
     },
     {
       "path": "scripts/harness_review.py",
@@ -327,11 +327,11 @@
     },
     {
       "path": "scripts/harness_runtime.py",
-      "sha256": "8959e8702bf703380dc2de92bf33aef3f9520d66ffd790c2295ce6cae1c28cab"
+      "sha256": "0cc27b7622922fa1c998973979d4970c5c993efe42545fa64dd0e64993030fce"
     },
     {
       "path": "scripts/harness_service.py",
-      "sha256": "17c26b40ed3e7d110b74ef61e627fa0ad1bc84718a1721a066e6d72ee0e37649"
+      "sha256": "af0eb7c93d5f856c5ed5a977e3f9a12dc0ced5baca571f7023f6b04ece46baf6"
     },
     {
       "path": "scripts/harness_state.py",