@hunter-harness/workflow-harness 0.2.79 → 0.2.81

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

@@ -10232,6 +10232,42 @@ def cmd_repair_cli(args: argparse.Namespace) -> int:
     return code
 
 
+def resolve_republish_project_root(explicit: Path | None, archive_dir: Path | None) -> Path:
+    """Locate the project root for a republish without requiring --project.
+
+    ``find_project_root`` walks ``p.parents``, which excludes ``p`` itself; it is
+    built for a change/archive subdirectory. Handing it the cwd therefore skips
+    the very directory the operator is standing in and keeps climbing — in a real
+    run that resolved ``E:/WorkProject/kb-sdd`` to its parent and made the command
+    look for archives that were never there.
+
+    Order: explicit flag, then the archive's own location, then cwd and its
+    parents (cwd included), then the deployed script's location — the script
+    lives at ``<project>/.claude|.codebuddy/skills/scripts/`` after install.
+    """
+    if explicit is not None:
+        return explicit.resolve()
+    if archive_dir is not None:
+        return find_project_root(archive_dir)
+
+    def first_with_archive(start: Path) -> Path | None:
+        start = start.resolve()
+        for candidate in (start, *start.parents):
+            if (candidate / ".harness" / "archive").is_dir():
+                return candidate
+        return None
+
+    found = first_with_archive(Path.cwd())
+    if found is not None:
+        return found
+    found = first_with_archive(Path(__file__).resolve().parent)
+    if found is not None:
+        return found
+    # Nothing carries an archive directory; report against cwd so the error names
+    # a path the operator recognises instead of some ancestor.
+    return Path.cwd().resolve()
+
+
 def resolve_archive_dir_for_change(
     project_root: Path,
     change_key: str,
@@ -10272,7 +10308,10 @@ def _republish_knowledge_entry(archive_dir: Path) -> dict[str, tuple[str, str, b
         change_key=str(summary.get("changeName") or archive_dir.name),
         archive_id=archive_dir.name,
         producer_version=SCHEMA_VERSION,
-        created_at=now_iso(),
+        # Derived from the archive, never wall-clock: `now_iso()` here made every
+        # rebuild produce different bytes, so a package could never be compared
+        # against a stored one and the "deterministic package" claim was false.
+        created_at=_archive_created_at(summary_path),
     )
     if not candidates:
         return {}
@@ -10285,12 +10324,28 @@ def _republish_knowledge_entry(archive_dir: Path) -> dict[str, tuple[str, str, b
     }
 
 
+def read_durable_archive_receipt(project_root: Path, change_key: str) -> dict[str, Any] | None:
+    """The `<key>.remote.json` written after a confirmed durable upload, if any."""
+    receipt_path = (
+        project_root / ".harness" / "state" / "local" / "archive-packages"
+        / f"{change_key}.remote.json"
+    )
+    if not receipt_path.is_file():
+        return None
+    try:
+        receipt = read_json(receipt_path)
+    except (OSError, json.JSONDecodeError, TypeError, ValueError):
+        return None
+    return receipt if isinstance(receipt, dict) else None
+
+
 def cmd_republish(
     *,
     change_key: str,
     archive_dir: Path | None,
     project_root: Path | None,
     dry_run: bool,
+    inject_knowledge: bool = True,
 ) -> tuple[int, dict[str, Any]]:
     """Rebuild and re-upload the core ZIP for an already sealed archive.
 
@@ -10311,7 +10366,7 @@ def cmd_republish(
         payload["reasonCode"] = "ARCHIVE_CHANGE_KEY_INVALID"
         return 2, payload
 
-    root = (project_root or find_project_root(archive_dir or Path.cwd())).resolve()
+    root = resolve_republish_project_root(project_root, archive_dir)
     payload["projectRoot"] = str(root)
     matches: list[str] = []
     if archive_dir is None:
@@ -10338,53 +10393,103 @@ def cmd_republish(
         payload["reasonCode"] = "ARCHIVE_SUMMARY_MISSING"
         return 1, payload
 
-    try:
-        extra_entries = _republish_knowledge_entry(archive_dir)
-    except (OSError, ValueError, json.JSONDecodeError) as exc:
-        # Knowledge is additive: never fail a re-delivery over it.
-        payload.setdefault("warnings", []).append(
-            f"knowledge candidate regeneration skipped: {exc}"
-        )
-        extra_entries = {}
+    extra_entries: dict[str, tuple[str, str, bytes]] = {}
+    if inject_knowledge:
+        try:
+            extra_entries = _republish_knowledge_entry(archive_dir)
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            # Knowledge is additive: never fail a re-delivery over it.
+            payload.setdefault("warnings", []).append(
+                f"knowledge candidate regeneration skipped: {exc}"
+            )
+            extra_entries = {}
     payload["knowledgeCandidatesInjected"] = "candidates/knowledge.json" in extra_entries
 
-    if dry_run:
-        # The package builder refuses to write outside the project, so the
-        # preview lands beside the real packages under a distinct name and is
-        # removed again; it must never be mistaken for a pending upload.
-        preview_path = (
-            root / ".harness" / "state" / "local" / "archive-packages"
-            / f"{change_key}.preview.zip"
+    # Build once, into a preview path, so the bytes can be compared against any
+    # durable receipt before an upload is attempted. The builder refuses to write
+    # outside the project, so the preview lands beside the real packages under a
+    # distinct name; it must never be mistaken for a pending upload.
+    preview_path = (
+        root / ".harness" / "state" / "local" / "archive-packages"
+        / f"{change_key}.preview.zip"
+    )
+    try:
+        package = build_archive_package(
+            root,
+            archive_dir,
+            change_key,
+            output_path=preview_path,
+            extra_entries=extra_entries,
         )
+    except (OSError, ValueError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        payload["error"] = f"archive package build failed: {exc}"
+        payload["reasonCode"] = "ARCHIVE_PACKAGE_BUILD_FAILED"
+        return 1, payload
+    finally:
         try:
-            package = build_archive_package(
-                root,
-                archive_dir,
-                change_key,
-                output_path=preview_path,
-                extra_entries=extra_entries,
-            )
-        except (OSError, ValueError, UnicodeDecodeError, json.JSONDecodeError) as exc:
-            payload["error"] = f"archive package build failed: {exc}"
-            payload["reasonCode"] = "ARCHIVE_PACKAGE_BUILD_FAILED"
-            return 1, payload
-        finally:
-            try:
-                preview_path.unlink(missing_ok=True)
-            except OSError:
-                pass
-        payload.update(
-            {
+            preview_path.unlink(missing_ok=True)
+        except OSError:
+            pass
+
+    payload.update(
+        {
+            "fileCount": package["fileCount"],
+            "sizeBytes": package["sizeBytes"],
+            "knowledgeCandidateCount": package["knowledgeCandidateCount"],
+            "packageSha256": package["packageSha256"],
+            "manifestSha256": package["manifestSha256"],
+            "files": package["paths"],
+        }
+    )
+
+    # The platform stores exactly one immutable package per change key. A rebuild
+    # that differs by even one byte is refused server-side, so decide here rather
+    # than spending an upload to learn it.
+    durable = read_durable_archive_receipt(root, change_key)
+    stored_sha = str((durable or {}).get("packageSha256") or "")
+    if durable is not None and str(durable.get("archiveStatus") or "") == "durable":
+        payload["remoteReceipt"] = {
+            "archiveId": durable.get("archiveId"),
+            "archiveStatus": durable.get("archiveStatus"),
+            "knowledgeStatus": durable.get("knowledgeStatus"),
+            "packageSha256": stored_sha,
+            "recordedAt": durable.get("recordedAt"),
+        }
+        if stored_sha and stored_sha == package["packageSha256"]:
+            payload.update({
                 "ok": True,
-                "reasonCode": "ARCHIVE_REPUBLISH_PREVIEW",
-                "fileCount": package["fileCount"],
-                "sizeBytes": package["sizeBytes"],
-                "knowledgeCandidateCount": package["knowledgeCandidateCount"],
-                "packageSha256": package["packageSha256"],
-                "manifestSha256": package["manifestSha256"],
-                "files": package["paths"],
-            }
-        )
+                "reasonCode": "ARCHIVE_ALREADY_PUBLISHED",
+                "message": (
+                    "远端已存有字节一致的同一个包，无需重传"
+                    f"（archiveId={durable.get('archiveId')}）。"
+                ),
+            })
+            return 0, payload
+        payload.update({
+            "ok": False,
+            "reasonCode": "ARCHIVE_REMOTE_IMMUTABLE_CONFLICT",
+            "error": (
+                "该 change 在远端已是 durable 归档，服务端对同一 change key 只保存一个"
+                "不可变包，不接受不同字节的替换。"
+            ),
+            "nextAction": (
+                "补传只适用于『从未成功上传』或『字节完全一致的重试』。"
+                + (
+                    "本次重建注入了 "
+                    f"{package['knowledgeCandidateCount']} 条知识候选"
+                    "（原包上传时还没有 candidates/knowledge.json），因此字节必然不同——"
+                    "已发布归档无法从客户端追加知识条目，需要平台侧提供重新索引或归档版本化能力。"
+                    "若只是想重试同一个包（例如知识索引失败），加 --no-knowledge-injection "
+                    "可重建与封存目录完全一致的字节。"
+                    if payload.get("knowledgeCandidatesInjected")
+                    else "本地归档内容与已上传的包不一致，请先确认哪一份才是应保留的事实。"
+                )
+            ),
+        })
+        return 1, payload
+
+    if dry_run:
+        payload.update({"ok": True, "reasonCode": "ARCHIVE_REPUBLISH_PREVIEW"})
         return 0, payload
 
     result = auto_push_archive_core(
@@ -10407,6 +10512,7 @@ def cmd_republish_cli(args: argparse.Namespace) -> int:
         archive_dir=resolve_path(args.archive_dir) if args.archive_dir else None,
         project_root=resolve_path(args.project) if args.project else None,
         dry_run=bool(args.dry_run),
+        inject_knowledge=not bool(args.no_knowledge_injection),
     )
     emit_json(payload)
     return code
@@ -10590,6 +10696,14 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="build the package and report its contents without uploading",
     )
+    p_republish.add_argument(
+        "--no-knowledge-injection",
+        action="store_true",
+        help=(
+            "rebuild exactly what the sealed archive holds; needed to retry the "
+            "same bytes the server already stored"
+        ),
+    )
     p_republish.add_argument("--json", action="store_true", default=True)
     p_republish.set_defaults(func=cmd_republish_cli)
 

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

@@ -1165,9 +1165,11 @@ def close_transition(
             "holder": lease.get("owner"),
             "leasePhase": lease.get("phase"),
         }
+    # Owner and phase already matched above, so nobody took this lease over: a
+    # takeover rewrites the file and would have produced CONTEXT_LEASE_MISMATCH.
+    # A lapsed deadline therefore proves only that the phase outlived the TTL.
     expiry = _parse_time(lease.get("expiresAt"))
-    if expiry is None or _now() >= expiry:
-        return {"ok": False, "code": "CONTEXT_LEASE_EXPIRED"}
+    lease_lapsed = expiry is None or _now() >= expiry
 
     previous_hash = transitions[-1].get("receiptHash") if transitions else None
     attempt = (
@@ -1192,6 +1194,12 @@ def close_transition(
         "closedAt": _now().isoformat(),
         "previousReceiptHash": previous_hash,
     }
+    if lease_lapsed:
+        # Recorded, not hidden: the phase ran past its lease without a renewal.
+        receipt["leaseLapsed"] = {
+            "expiresAt": lease.get("expiresAt"),
+            "acquiredAt": lease.get("acquiredAt"),
+        }
     receipt["receiptHash"] = _payload_hash(receipt)
     _append_ndjson(paths["transitions"], receipt)
     paths["lease"].unlink(missing_ok=True)
@@ -1267,7 +1275,11 @@ def _begin_transition_unlocked(
             "legacyBootstrap": True,
             "message": (
                 "没有交接凭证。v2 计划应有 committed 的 meta/publication-journals/*.json "
-                "作为补录证据；legacy 计划需先完成 plan 阶段的 close"
+                "作为补录证据；legacy 计划需先完成 plan 阶段的 close。"
+                "首次进入某阶段（还没有任何 transition 凭证）时不要用 context begin——"
+                "改跑 `harness_gate.py begin --change-dir .harness/changes/<change> "
+                "--phase <phase> --run-id <phase>_<uuid4hex> --note \"<触发指令>\"`，"
+                "它会领取租约并写好 phase.start。"
             ),
         }
     receipt = transitions[-1]
@@ -1458,6 +1470,53 @@ def cancel_prepared_context(
     }
 
 
+def renew_lease(
+    project: Path,
+    change: str,
+    *,
+    executor: str,
+    ttl_seconds: int = 3600,
+) -> dict[str, Any]:
+    """Extend the current phase lease in place.
+
+    Only the recorded owner may renew, and only while no other executor has
+    taken the lease over. Renewal touches nothing but ``expiresAt``, so it is
+    safe to call on a heartbeat during a long phase.
+    """
+    project = project.resolve()
+    try:
+        _, _, state_root = _contract(project, change)
+    except ValueError as exc:
+        return {"ok": False, "code": _contract_error_code(exc), "error": str(exc)}
+    paths = _paths(state_root)
+    if not paths["lease"].is_file():
+        return {"ok": False, "code": "CONTEXT_LEASE_REQUIRED"}
+    with _exclusive_state_lock(paths["runtime"] / "branch-selection.lock"):
+        try:
+            lease = _read_json(paths["lease"])
+        except (OSError, ValueError, json.JSONDecodeError):
+            return {"ok": False, "code": "CONTEXT_LEASE_INVALID"}
+        if lease.get("owner") != executor:
+            return {
+                "ok": False,
+                "code": "CONTEXT_LEASE_MISMATCH",
+                "holder": lease.get("owner"),
+            }
+        expiry = _parse_time(lease.get("expiresAt"))
+        lapsed = expiry is None or _now() >= expiry
+        lease["expiresAt"] = (
+            _now() + dt.timedelta(seconds=max(1, int(ttl_seconds)))
+        ).isoformat()
+        lease["renewedAt"] = _now().isoformat()
+        _write_json_atomic(paths["lease"], lease)
+    return {
+        "ok": True,
+        "code": "CONTEXT_LEASE_RENEWED",
+        "lease": lease,
+        "wasLapsed": lapsed,
+    }
+
+
 def context_view(project: Path, change: str) -> dict[str, Any]:
     project = Path(project).resolve()
     try:
@@ -1536,6 +1595,14 @@ def build_parser() -> argparse.ArgumentParser:
     begin.add_argument("--change", required=True)
     begin.add_argument("--phase", required=True)
     begin.add_argument("--executor", required=True)
+    renew = sub.add_parser(
+        "renew", help="extend the current phase lease without touching context"
+    )
+    renew.add_argument("--json", action="store_true")
+    renew.add_argument("--project", required=True, type=Path)
+    renew.add_argument("--change", required=True)
+    renew.add_argument("--executor", required=True)
+    renew.add_argument("--ttl-seconds", type=int, default=3600)
     configure = sub.add_parser("configure-plan")
     configure.add_argument("--json", action="store_true")
     configure.add_argument("--project", required=True, type=Path)
@@ -1588,6 +1655,13 @@ def main(argv: list[str] | None = None) -> int:
             phase=args.phase,
             executor=args.executor,
         )
+    elif args.command == "renew":
+        result = renew_lease(
+            args.project,
+            args.change,
+            executor=args.executor,
+            ttl_seconds=args.ttl_seconds,
+        )
     elif args.command == "configure-plan":
         result = configure_phase_plan(
             args.project,

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

@@ -1904,6 +1904,7 @@ def cmd_append(args: argparse.Namespace) -> int:
             file=sys.stderr,
         )
     phase_closed = False
+    phase_start_duplicate = False
     projection_error: str | None = None
     attempt_error: str | None = None
     auto_sealed_events: list[dict[str, Any]] = []
@@ -1951,10 +1952,25 @@ def cmd_append(args: argparse.Namespace) -> int:
                 except ValueError as exc:
                     projection_error = str(exc)
             elif args.type == "phase.start":
+                # Re-appending the same (phase, run_id) is the caller restating a
+                # start that already exists — `gate begin` writes one, and the
+                # logging protocol used to ask for a second. Treat it as a no-op
+                # rather than a duplicate; two identical phase.start events make
+                # `plan finalize` unrecoverable via PHASE_START_DUPLICATE.
+                if run_id is not None and any(
+                    item.get("phase") == args.phase
+                    and item.get("type") == "phase.start"
+                    and item.get("run_id") == run_id
+                    for item in existing_events
+                ):
+                    phase_start_duplicate = True
                 # HH-WF-20260730-001: a new phase.start must not be appended
                 # while a prior attempt for the same phase is still open —
                 # auto-seal it first so timing never has two open attempts.
-                open_attempts = open_attempts_for_phase(existing_events, args.phase)
+                open_attempts = (
+                    [] if phase_start_duplicate
+                    else open_attempts_for_phase(existing_events, args.phase)
+                )
                 if open_attempts:
                     inferred_reason = infer_auto_seal_reason(
                         open_attempts[-1].get("events") or []
@@ -1964,7 +1980,12 @@ def cmd_append(args: argparse.Namespace) -> int:
                         phase=args.phase,
                         seal_reason=inferred_reason,
                     )
-            if not phase_closed and projection_error is None and attempt_error is None:
+            if (
+                not phase_closed
+                and not phase_start_duplicate
+                and projection_error is None
+                and attempt_error is None
+            ):
                 for seal_event in auto_sealed_events:
                     atomic_append_line(
                         path,
@@ -1976,6 +1997,18 @@ def cmd_append(args: argparse.Namespace) -> int:
                 )
     except (OSError, TimeoutError, ValueError) as exc:
         return emit_error(f"append failed: {exc}", as_json=as_json)
+    if phase_start_duplicate:
+        if as_json:
+            print(json.dumps({
+                "ok": True,
+                "skipped": True,
+                "reason": "phase-start-already-recorded",
+                "phase": args.phase,
+                "run_id": event.get("run_id"),
+            }, ensure_ascii=False))
+        else:
+            print("ok (phase.start already recorded for this run id)")
+        return 0
     if phase_closed:
         return emit_error(
             "PHASE_ALREADY_CLOSED: refusing a second phase.end for the same "

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

@@ -735,7 +735,12 @@ def _validate_plan_start(
     if len(matching) > 1:
         return _result_error(
             "PHASE_START_DUPLICATE",
-            f"found {len(matching)} matching plan phase.start events",
+            f"found {len(matching)} matching plan phase.start events for run id "
+            f"{run_id}. `harness_gate.py begin` already appends phase.start; a "
+            "second manual append of the same run id creates this state. Recover "
+            "with a fresh run id and the next attempt number (attempts are global "
+            "per phase, not per run id): append phase.start with both, then "
+            "finalize with the same pair.",
         )
     return {"ok": True, "phaseStartCount": 1}
 

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

@@ -2,9 +2,9 @@
   "schema_version": 2,
   "profile": "general",
   "adapter": "claude-code",
-  "bundle_version": "0.2.68",
+  "bundle_version": "0.2.70",
   "requires": {
-    "minimumCliVersion": "0.2.87",
+    "minimumCliVersion": "0.2.88",
     "capabilities": [
       "sync@2",
       "rules-sync@1",
@@ -25,7 +25,7 @@
   "files": [
     {
       "path": ".harness-build.json",
-      "sha256": "db342ad36703f2a861b0df0e886fcbb25e81a4fa6b4cf9f47ade38a1d12a5a4b"
+      "sha256": "ba966d7563aa4c5cf5a170d9af6c80a4a1c87613061d2e8bf7858a1f53001690"
     },
     {
       "path": "agents/harness-evaluator.md",
@@ -97,7 +97,7 @@
     },
     {
       "path": "harness-archive/SKILL.md",
-      "sha256": "992ce9f6978add8e56138bae4dddcacb45183f518b0bb00b901a95c23b13738b"
+      "sha256": "cb5686f5044f3dcf580497d8081ae0d7a3742a83c6910dc92d9622b21c4e3e94"
     },
     {
       "path": "harness-archive/templates/summary-data-template.json",
@@ -113,7 +113,7 @@
     },
     {
       "path": "harness-codebase-map/SKILL.md",
-      "sha256": "e60e1437bdfea17c723e5384548a250b4b7646b37daf3a9abbc05478ea05a5ef"
+      "sha256": "f60acc504b6227448a5879240ed75b5762e587a5908ac0207c558e20f81fc098"
     },
     {
       "path": "harness-codebase-map/templates/ARCHITECTURE.md",
@@ -153,11 +153,11 @@
     },
     {
       "path": "harness-knowledge-ingest/SKILL.md",
-      "sha256": "be8eccf19cbbcf775bbebee4cf91a3fc69604588be48960b5216dcc6f6dfc53d"
+      "sha256": "c3a2cdadfb78f0b38503d117def71098a0a2919e3a8eb939e70b4796e3cd84cc"
     },
     {
       "path": "harness-knowledge-query/SKILL.md",
-      "sha256": "da01386a0b83c2c9c2d99f5cc1baa0fefbbea523834e3dac77d0c6d7834b9963"
+      "sha256": "46a06f2b9610093d11dfbe9d8a27fd8a62129d66c7aa6bb82e759b7893ad9e9b"
     },
     {
       "path": "harness-plan/checklist.md",
@@ -173,15 +173,15 @@
     },
     {
       "path": "harness-plan/SKILL.md",
-      "sha256": "3aa5b3297f2c8566e0ede8a6408e0179c75d04ef58350fbac12729e8966181dc"
+      "sha256": "79e1c84a92a8bf6370cdc6691dc5cc92bd3e5ff4a720864949a1d3c7de7782a3"
     },
     {
       "path": "harness-pull/SKILL.md",
-      "sha256": "47c33af5a0565b681ccce8c41a8cd1ba1b9cbe8b54f6a1c28309acae632a3eca"
+      "sha256": "29df6f2b5b351c01c97c47db42f835706add2bfe84b4edd0968da1289a2e54c9"
     },
     {
       "path": "harness-push/SKILL.md",
-      "sha256": "f58e3aa0fb3545ae8f9820a8d13ca8069f800d20bc44813c016587e2fdc04975"
+      "sha256": "ee723583548b7fa73fe113bfbb73d840f144ba1bc059a627cb57289cd8518705"
     },
     {
       "path": "harness-review/checklist.md",
@@ -197,7 +197,7 @@
     },
     {
       "path": "harness-review/SKILL.md",
-      "sha256": "faddc29f7766391ef7a30eef0228fa8d13412ae506f1ce2128585cd8d02129bc"
+      "sha256": "a70669bf6deabb442a855535283e22ea6edb6c2e3d50dc65543ab47f7e01f5f3"
     },
     {
       "path": "harness-run/checklist.md",
@@ -213,7 +213,7 @@
     },
     {
       "path": "harness-run/SKILL.md",
-      "sha256": "367f5a1f9e848d1a094d785cc900b852dfdc24ef3951f5fe662fd0b922c26c54"
+      "sha256": "ad7fefb8891068fd4fbaf1890e21abcbe1a1eed037f3ab1cd751dca56bd651d0"
     },
     {
       "path": "harness-submit/checklist.md",
@@ -225,7 +225,7 @@
     },
     {
       "path": "harness-submit/SKILL.md",
-      "sha256": "29d8f550b6d6f287c162274d5274e67fc8ee827ba269d7531f845aa94515844a"
+      "sha256": "3c222757ff63d702fb69002704931dc6cca246256ff2a2a5a7d093f04410844e"
     },
     {
       "path": "harness-sync/reference.md",
@@ -233,7 +233,7 @@
     },
     {
       "path": "harness-sync/SKILL.md",
-      "sha256": "c1dfbdc342866518833f844ddf01c54e8ae0eff0773cc0453fd1e544a3167452"
+      "sha256": "3c755bf5732e7d1f9945b08527668a33cde6e24a593b0636359d89a21418173e"
     },
     {
       "path": "harness-test/checklist.md",
@@ -257,7 +257,7 @@
     },
     {
       "path": "harness-test/SKILL.md",
-      "sha256": "ef03b216907be0066d5ce2785fe8742cf02b32164cbde7081ef29bd930208cf0"
+      "sha256": "3b2cc724648e75fc310fc09e44a1737c669fc12d5d0933b278c564a72c7fd05a"
     },
     {
       "path": "protocols/archive-report-protocol.md",
@@ -329,7 +329,7 @@
     },
     {
       "path": "scripts/harness_archive.py",
-      "sha256": "0c3b8d9e14aedfd569bf38ce4f6d0ff9a168b3015f2b5fe685a58cb3e40f030b"
+      "sha256": "da88a0a922d24d402e3258041e3eb3a2c3d47dc42d930f10550161acf6864179"
     },
     {
       "path": "scripts/harness_change.py",
@@ -341,7 +341,7 @@
     },
     {
       "path": "scripts/harness_context.py",
-      "sha256": "e61bbeb3073d77a34ac9aefb13421c187a8d16c8f95597d1ca50d91b0c6af1d2"
+      "sha256": "c7ad3199bda332e853a24e6268fa32dcc253adb6dfe7e0de7aa3b7f0ae7ae312"
     },
     {
       "path": "scripts/harness_deploy.py",
@@ -361,7 +361,7 @@
     },
     {
       "path": "scripts/harness_events.py",
-      "sha256": "3116137be32bd696adce47c79f2af99a8f1517a7555bd1bbaffe27e17fd12fbc"
+      "sha256": "e992498f7256d11ae98d6e71be4f88fc8e08331311ca74372bbc890a720eae43"
     },
     {
       "path": "scripts/harness_execution_contracts.py",
@@ -413,7 +413,7 @@
     },
     {
       "path": "scripts/harness_plan_finalize.py",
-      "sha256": "af12b53ab5503eb5c0ead5bd58e8da9d5389c649958ac678bf448e4c8a286d5b"
+      "sha256": "6f4dcee06f92f7ed7a3bd0ee615e9dd7e8fd921502b132305e37c4871b97537b"
     },
     {
       "path": "scripts/harness_preflight.py",