@hunter-harness/workflow-harness 0.2.85 → 0.2.86

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

@@ -28,6 +28,7 @@ if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
 import harness_paths  # noqa: E402
+import harness_plan_finalize as hpf  # noqa: E402
 import harness_profile  # noqa: E402
 
 
@@ -1629,6 +1630,24 @@ def _scenario_receipt_error(code: str, message: str) -> dict[str, Any]:
     return {"ok": False, "code": code, "error": message}
 
 
+def resolve_scenario_manifest(manifest: Any) -> dict[str, Any]:
+    """把 v2 artifact 包装体解成 legacy 形状；legacy 输入原样返回。
+
+    解包规则住在 harness_plan_finalize（它定义了 legacy manifest 的 schema），
+    门禁与本模块共用同一份，两边不会各推一套。
+
+    此前这里只判包装体、一律 fail-closed；更早的时候连判都不判——cmd_record
+    的版本探测初值是 0，包装体探测不出 schemaVersion 就停在 0，
+    `manifest_schema >= 2` 判假，--scenario-receipt-file 的强制要求被静默跳过。
+
+    返回 ``{"ok": True, "manifest": ...}`` 或 ``{"ok": False, "code": ...}``。
+    """
+    unpacked = hpf.unpack_v2_scenario_manifest(manifest)
+    if unpacked is None:
+        return {"ok": True, "manifest": manifest}
+    return unpacked
+
+
 def _resolve_receipt_path(
     raw: str, change_dir: Path
 ) -> tuple[Path | None, list[Path]]:
@@ -1694,6 +1713,12 @@ def validate_scenario_execution_receipt(
         )
     except (OSError, json.JSONDecodeError) as exc:
         return _scenario_receipt_error("SCENARIO_MANIFEST_INVALID", str(exc))
+    resolved = resolve_scenario_manifest(manifest)
+    if not resolved["ok"]:
+        return _scenario_receipt_error(
+            str(resolved["code"]), str(resolved.get("message") or "")
+        )
+    manifest = resolved["manifest"]
     if not isinstance(manifest, dict) or not isinstance(manifest.get("scenarios"), list):
         return _scenario_receipt_error(
             "SCENARIO_MANIFEST_INVALID",
@@ -2827,6 +2852,15 @@ def cmd_record(args: argparse.Namespace) -> int:
                             as_json=as_json,
                             error_code="SCENARIO_MANIFEST_INVALID",
                         )
+                    resolved_probe = resolve_scenario_manifest(manifest_probe)
+                    if not resolved_probe["ok"]:
+                        return emit_error(
+                            str(resolved_probe.get("message") or ""),
+                            as_json=as_json,
+                            error_code=str(resolved_probe["code"]),
+                            extra={"artifactType": "scenario_manifest"},
+                        )
+                    manifest_probe = resolved_probe["manifest"]
                     raw_schema = (
                         manifest_probe.get("schemaVersion")
                         if isinstance(manifest_probe, dict)
@@ -3064,6 +3098,15 @@ def cmd_scenario_receipt_template(args: argparse.Namespace) -> int:
             as_json=as_json,
             error_code="SCENARIO_MANIFEST_INVALID",
         )
+    resolved = resolve_scenario_manifest(manifest)
+    if not resolved["ok"]:
+        return emit_error(
+            str(resolved.get("message") or ""),
+            as_json=as_json,
+            error_code=str(resolved["code"]),
+            extra={"artifactType": "scenario_manifest"},
+        )
+    manifest = resolved["manifest"]
     scenarios = manifest.get("scenarios") if isinstance(manifest, dict) else None
     if not isinstance(scenarios, list):
         return emit_error(

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

@@ -34,6 +34,66 @@ if hasattr(sys.stderr, "reconfigure"):
 LIFECYCLE_STATUSES = {"draft", "active", "superseded", "archived", "cancelled"}
 CHANGE_CONTEXT_REL = Path("meta") / "change-context.json"
 
+# 工作流阶段的唯一权威清单。这里是叶子模块（不 import 任何 harness_*），所以
+# harness_context 与 harness_phase 都能引它而不成环。
+#
+# 此前这份清单在两个模块各写一遍，靠约定保持同步——直到 harness_phase 少了一个
+# merge，worktree 变更走到 merge 阶段就在 target_required_dag 里直接 raise
+# "unsupported reconcile target phase"。同一份事实不该有两个副本。
+WORKFLOW_PHASES = (
+    "plan",
+    "run",
+    "test",
+    "review",
+    "package",
+    "apidoc",
+    "submit",
+    "merge",
+    "archive",
+)
+
+# 出现在阶段位置、但不是工作流阶段的名字。它们是真实存在的：
+# workflow-policy.json 的 skills.*.phase 用 sync/codebase-map/knowledge-query 标注
+# 技能归属，harness_gate.GATE_RELEASE_PHASES 含 release/deploy。把它们与"拼错的
+# 阶段名"区分开，调用方才能既不误判也不硬崩。
+KNOWN_NON_WORKFLOW_PHASES = frozenset({
+    "release",
+    "deploy",
+    "sync",
+    "codebase-map",
+    "knowledge-query",
+    "knowledge-ingest",
+    "push",
+    "pull",
+})
+
+# 旧阶段名 → 现阶段名。阶段合并/改名时在这里登记，读时映射即可让历史
+# gate-policy.json 与 plannedPhases 继续可读，不必迁移已落盘的 change。
+# 目前为空：还没有发生过阶段改名。
+LEGACY_PHASE_ALIASES: dict[str, str] = {}
+
+
+def resolve_phase_name(phase: Any) -> str | None:
+    """把可能是旧名的阶段解析成当前的工作流阶段名；不是工作流阶段则返回 None。"""
+    name = str(phase or "").strip()
+    if name in WORKFLOW_PHASES:
+        return name
+    mapped = LEGACY_PHASE_ALIASES.get(name)
+    return mapped if mapped in WORKFLOW_PHASES else None
+
+
+def classify_phase_name(phase: Any) -> str:
+    """三态判定：``workflow`` | ``non_workflow`` | ``unknown``。
+
+    调用方需要区分这三者：``workflow`` 照常处理；``non_workflow`` 是别的子系统
+    的标注，跳过而不是报错；只有 ``unknown`` 才是真的有问题，值得让人看见。
+    """
+    if resolve_phase_name(phase) is not None:
+        return "workflow"
+    if str(phase or "").strip() in KNOWN_NON_WORKFLOW_PHASES:
+        return "non_workflow"
+    return "unknown"
+
 
 def _git_text(cwd: Path, *args: str) -> str | None:
     proc = subprocess.run(

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

@@ -33,7 +33,9 @@ import harness_paths as hpaths  # noqa: E402
 
 SCHEMA_VERSION = 1
 CI_METRICS_SCHEMA_VERSION = 1
-PHASE_ORDER = ("plan", "run", "test", "review", "package", "apidoc", "submit", "archive")
+# 唯一权威清单在 harness_paths，harness_context 引的是同一个对象。此前这里另有
+# 一份拷贝，少了 merge，worktree 变更走到 merge 就在 target_required_dag 里硬 raise。
+PHASE_ORDER = hpaths.WORKFLOW_PHASES
 VALIDATION_PHASES = {
     "compile": "run",
     "unitTest": "run",
@@ -700,8 +702,18 @@ def target_required_dag(policy: dict[str, Any], target_phase: str) -> dict[str,
     stage nodes for the target itself are deliberately excluded because their
     ``phase.end`` is the result of close, not evidence required before close.
     """
-    if target_phase not in PHASE_ORDER:
-        raise ValueError(f"unsupported reconcile target phase: {target_phase}")
+    # 未知阶段名先过读时映射：阶段改名后，历史 change 的 gate-policy.json 与
+    # plannedPhases 里仍然是旧名，靠 LEGACY_PHASE_ALIASES 继续可读，不必迁移已落盘
+    # 的 change（本仓库没有 change 级 schema 迁移机制，硬 raise 等于让在途变更报废）。
+    resolved_target = hpaths.resolve_phase_name(target_phase)
+    if resolved_target is None:
+        raise ValueError(
+            f"unsupported reconcile target phase: {target_phase}; "
+            f"已知阶段 {', '.join(PHASE_ORDER)}。"
+            "若这是改名前的旧阶段，在 harness_paths.LEGACY_PHASE_ALIASES 登记映射；"
+            "若这份 gate-policy.json 本身过期，重跑 harness_gate.py classify 重建"
+        )
+    target_phase = resolved_target
     dag = policy.get("requiredGateDag")
     if not isinstance(dag, dict) or not isinstance(dag.get("nodes"), list):
         raise ValueError("gate policy missing requiredGateDag; run harness_gate.py classify")
@@ -718,9 +730,15 @@ def target_required_dag(policy: dict[str, Any], target_phase: str) -> dict[str,
             if node_kind == "validation"
             else node_name
         )
-        node_phase = str(node.get("phase") or inferred_phase or "")
-        if node_phase not in PHASE_ORDER:
-            raise ValueError(f"requiredGateDag node has unsupported phase: {node_id}")
+        raw_phase = str(node.get("phase") or inferred_phase or "")
+        node_phase = hpaths.resolve_phase_name(raw_phase)
+        if node_phase is None:
+            raise ValueError(
+                f"requiredGateDag node has unsupported phase: {node_id} (phase={raw_phase!r})；"
+                "旧阶段名在 harness_paths.LEGACY_PHASE_ALIASES 登记映射，"
+                "或重跑 harness_gate.py classify 重建这份 gate-policy.json"
+            )
+        node["phase"] = node_phase
         node_rank = PHASE_ORDER.index(node_phase)
         is_validation = node.get("kind") == "validation" or node_id.startswith(
             "validation:"

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

@@ -261,6 +261,127 @@ def scenario_manifest_schema_version(scenarios: list[dict[str, Any]]) -> int:
     return 1
 
 
+# v2 场景键 → 门禁与 ledger 消费的 legacy 键。可执行三元是可选的：缺了只是把
+# manifest 降到 schemaVersion 1（绑不上结构化执行收据），不算缺口。
+_V2_SCENARIO_FIELD_MAP = (
+    ("scenario_id", "id"),
+    ("priority", "priority"),
+    ("required_evidence_kind", "requiredEvidenceKind"),
+    ("owner_phase", "ownerPhase"),
+)
+_V2_SCENARIO_OPTIONAL_FIELD_MAP = (
+    ("executable_test_id", "executableTestId"),
+    ("test_file", "testFile"),
+    ("test_title", "testTitle"),
+)
+V2_MANIFEST_UNSUPPORTED = "SCENARIO_MANIFEST_V2_UNSUPPORTED"
+
+
+def is_v2_scenario_manifest(manifest: Any) -> bool:
+    """v2 plan finalize 派生的 scenario_manifest artifact 包装体。
+
+    它没有顶层 schemaVersion，场景字段全在 content.scenarios 下且改了名。
+    """
+    return (
+        isinstance(manifest, dict)
+        and manifest.get("artifact_type") == "scenario_manifest"
+    )
+
+
+def unpack_v2_scenario_manifest(manifest: Any) -> dict[str, Any] | None:
+    """v2 artifact 包装体 → 消费端的 legacy 形状；字段不齐时 fail-closed。
+
+    返回 None 表示"这不是 v2 包装体"，调用方按 legacy 原样处理。否则返回
+    ``{"ok": True, "manifest": {...}}``（已是 legacy 形状，后续判定逻辑对
+    v2 与 legacy 完全一致）或 ``{"ok": False, "code": V2_MANIFEST_UNSUPPORTED}``。
+
+    这个函数住在 finalizer 里，是因为 legacy manifest 的 schema 本来就由本模块
+    定义（``scenario_manifest_schema_version`` / ``PRIORITY_EVIDENCE_KIND``）。
+    门禁与 ledger 都 import 它，两边不会各推一套解包规则。
+
+    为什么必须逐场景校验、不能取键的并集：并集只要有**一条**场景带了
+    priority 就算"present"，其余缺 priority 的场景会静默落进非必需集，
+    ``required_ids`` 随之缩水——那正是把证据门禁悄悄关掉的老路子。
+    """
+    if not is_v2_scenario_manifest(manifest):
+        return None
+    content = manifest.get("content")
+    raw = content.get("scenarios") if isinstance(content, dict) else None
+    if not isinstance(raw, list):
+        return {
+            "ok": False,
+            "code": V2_MANIFEST_UNSUPPORTED,
+            "message": "v2 scenario-manifest 的 content.scenarios 必须是数组",
+            "missingFields": [legacy for _, legacy in _V2_SCENARIO_FIELD_MAP],
+            "artifactType": "scenario_manifest",
+        }
+    scenarios: list[dict[str, Any]] = []
+    missing: set[str] = set()
+    for item in raw:
+        if not isinstance(item, dict):
+            missing.update(legacy for _, legacy in _V2_SCENARIO_FIELD_MAP)
+            continue
+        mapped: dict[str, Any] = {}
+        for source, legacy in _V2_SCENARIO_FIELD_MAP:
+            value = item.get(source)
+            if not str(value or "").strip():
+                missing.add(legacy)
+                continue
+            mapped[legacy] = value
+        for source, legacy in _V2_SCENARIO_OPTIONAL_FIELD_MAP:
+            value = item.get(source)
+            if str(value or "").strip():
+                mapped[legacy] = value
+        scenarios.append(mapped)
+    if missing:
+        return {
+            "ok": False,
+            "code": V2_MANIFEST_UNSUPPORTED,
+            "message": (
+                "meta/scenario-manifest.json 是 v2 plan artifact 包装体，"
+                "部分场景缺少消费端需要的字段；请在规划阶段补齐后重新发布，"
+                "不要手改派生产物"
+            ),
+            "missingFields": sorted(missing),
+            "artifactType": "scenario_manifest",
+        }
+    return {
+        "ok": True,
+        "manifest": {
+            # 与 legacy 同一条规则判版本，不另立一套。
+            "schemaVersion": scenario_manifest_schema_version(scenarios),
+            "scenarios": scenarios,
+        },
+    }
+
+
+def unpack_v2_implementation_checkpoints(document: Any) -> dict[str, Any] | None:
+    """v2 的 implementation_checkpoints artifact 包装体 → 门禁消费的形状。
+
+    返回 None 表示"这不是 v2 包装体"，调用方按原样处理。
+
+    v2 的 content 是 ``{tasks, foundation_gate}``，而 ``checkpoint_status`` 找的是
+    ``checkpoints: [{id, status}]``——找不到就返回 "missing"，``foundation_gate_blocks``
+    随即放行。也就是说 foundation-gate 对**所有 v2 计划**是静默关闭的。信息本身是够
+    的（``foundation_gate`` 就是那个状态），只是形状不同，所以这里解包而不是改文件名
+    ——与 scenario-manifest 同一模式。
+    """
+    if (
+        not isinstance(document, dict)
+        or document.get("artifact_type") != "implementation_checkpoints"
+    ):
+        return None
+    content = document.get("content")
+    content = content if isinstance(content, dict) else {}
+    status = str(content.get("foundation_gate") or "").strip() or "pending"
+    tasks = content.get("tasks")
+    return {
+        "schemaVersion": 1,
+        "checkpoints": [{"id": "foundation-gate", "status": status, "blocking": True}],
+        "tasks": tasks if isinstance(tasks, list) else [],
+    }
+
+
 def parse_plan_tasks(plan_path: Path) -> list[dict[str, str]]:
     """C8: parse plan.md task table rows, extracting optional ownerPhase/implementationDoneWhen/verificationPhase columns.
 
@@ -877,7 +998,9 @@ def _verify_plan_v2(change_dir: Path) -> dict[str, Any] | None:
         f"plans/{change_dir.name}-plan.md",
         f"plans/{change_dir.name}-implementation-detail.md",
         f"plans/{change_dir.name}-test-scenarios.md",
-        "meta/gate-policy.json",
+        # v2 发布的是派生视图 meta/plan-profile.json，不是 Python classify 写的
+        # meta/gate-policy.json——后者是 run/test 门禁的权威输入，不能被发布覆盖。
+        "meta/plan-profile.json",
         "meta/worktree.json",
     }
     missing_required = sorted(required - set(ownership_paths))

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

@@ -194,14 +194,30 @@ def _load_findings(change_dir: Path) -> dict[str, Any] | None:
 
 
 def validate_dispositions(
-    doc: Any, known_ids: set[str]
+    doc: Any, known_ids: set[str], findings_run_id: str | None = None
 ) -> list[str]:
+    """校验处置文档。``findings_run_id`` 给出时，还要求两份 sidecar 同属一轮。
+
+    runId 以前完全不校验——``write_dispositions`` 直接透传 ``doc.get("runId")``，
+    写 ``None`` 都能落盘，整条 sidecar 的强制力全压在 gate 关门时的一行断言上。
+    而这条断言防的是 fixback 循环里的跨轮重放：sidecar 是 per-change 单文件、不带
+    runId 后缀，第二轮 review 关门时磁盘上躺着第一轮那份（finding 全已 FIXED）。
+    在写入端就挡住，比等到关门再拒绝早一整轮。
+    """
     problems: list[str] = []
     if not isinstance(doc, dict):
         return ["dispositions document must be an object"]
+    run_id = doc.get("runId")
+    if not isinstance(run_id, str) or not run_id.strip():
+        problems.append("runId is required")
+    elif findings_run_id is not None and run_id != findings_run_id:
+        problems.append(
+            f"runId {run_id} does not match review findings runId {findings_run_id}"
+        )
     dispositions = doc.get("dispositions")
     if not isinstance(dispositions, list):
-        return ["dispositions must be a list"]
+        problems.append("dispositions must be a list")
+        return problems
     for index, item in enumerate(dispositions):
         if not isinstance(item, dict):
             problems.append(f"dispositions[{index}] must be an object")
@@ -226,12 +242,17 @@ def write_dispositions(change_dir: Path, doc: dict[str, Any]) -> dict[str, Any]:
         f.get("id") for f in (findings_doc or {}).get("findings", [])
         if isinstance(f, dict)
     }
-    problems = validate_dispositions(doc, known_ids)
+    findings_run_id = (findings_doc or {}).get("runId")
+    problems = validate_dispositions(
+        doc,
+        known_ids,
+        findings_run_id if isinstance(findings_run_id, str) else None,
+    )
     if problems:
         return {"ok": False, "code": "DISPOSITIONS_INVALID", "problems": problems}
     payload = {
         "schemaVersion": 1,
-        "runId": doc.get("runId"),
+        "runId": doc["runId"],
         "dispositions": doc["dispositions"],
     }
     out = dispositions_path(change_dir)

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

@@ -4,7 +4,7 @@
   "adapter": "claude-code",
   "bundle_version": "0.2.73",
   "requires": {
-    "minimumCliVersion": "0.2.91",
+    "minimumCliVersion": "0.2.92",
     "capabilities": [
       "sync@2",
       "rules-sync@1",
@@ -25,7 +25,7 @@
   "files": [
     {
       "path": ".harness-build.json",
-      "sha256": "61081cabc198cc4cc6e70e67627c57b5cd56179e2e5df96c2c00826ec04ae837"
+      "sha256": "3dd6ddcc89f89ab3e51d7b2d1f7415d79ad897c72d29676ed59178b4d5636233"
     },
     {
       "path": "agents/harness-evaluator.md",
@@ -97,7 +97,7 @@
     },
     {
       "path": "harness-archive/SKILL.md",
-      "sha256": "ff76b7128a867a872ef91889b879efd6216331c48e2947c2b3fe83fc131f387e"
+      "sha256": "4ffdd943d3659f3bee25d5d8949b930f8e1eed45069dbf8fae5c5a593eeceef8"
     },
     {
       "path": "harness-archive/templates/summary-data-template.json",
@@ -113,7 +113,7 @@
     },
     {
       "path": "harness-codebase-map/SKILL.md",
-      "sha256": "03027ba66bfc73f0e8d762766a0163c109466f544e537afda89eb9023118d6fe"
+      "sha256": "77ea556fce28dd30d5463318c066c1e35d48eb1cd9c0285f4097de7d094f2b29"
     },
     {
       "path": "harness-codebase-map/templates/ARCHITECTURE.md",
@@ -153,35 +153,35 @@
     },
     {
       "path": "harness-knowledge-ingest/SKILL.md",
-      "sha256": "edef9ca1b46dd7068499c067f63ed229d07db3aa36de16e373968581419d37e8"
+      "sha256": "67e4f63587f6b2c17820c6c5f9625f702de8b902de1cb38ccbcd2ecf362d44df"
     },
     {
       "path": "harness-knowledge-query/SKILL.md",
-      "sha256": "c734278aa9128e232e63f43070c18e13ff03c779ed19c876b58a29903ca04b67"
+      "sha256": "25f165ad7227a348320c6956850584d83bc9bd6267126f32c7f8e2f866a6b885"
     },
     {
       "path": "harness-plan/checklist.md",
-      "sha256": "31c66e6e08595d6d97e5f57fcd6d99ced5b721b82c122fbb26bb8fba34c23d90"
+      "sha256": "42eefa0a350a15efab18d9fe03adb019f17eadf0b6c9d797fb80ad05842a22aa"
     },
     {
       "path": "harness-plan/protocols.md",
-      "sha256": "9bff7f88fc236adbc1c01db2fcbeb39248399e98f6a172080c8592ee27e742c5"
+      "sha256": "ee15618cbe4005ec1efd5ae91b0105920b929a9eedba8dffd29183efadf52485"
     },
     {
       "path": "harness-plan/reference.md",
-      "sha256": "197f5b764d1054ef401f61f95055b468ab2a0c66ad482efc50a014ab7ea89711"
+      "sha256": "a10e417269d4993699a4a1d53ffd4f0c8296231a0c5e468630da3d10809a1d93"
     },
     {
       "path": "harness-plan/SKILL.md",
-      "sha256": "0ae55ffb8ae2f8129f1cf6f7bf04364ecdef17ca23cc457208cd774cac6a4b45"
+      "sha256": "11d0cf7d378e23d95f561c445cd71f5f4a04bce921955e2e6056d67b3a60f564"
     },
     {
       "path": "harness-pull/SKILL.md",
-      "sha256": "cb671d8f8e219528a6aee26846a7b2ed766ed7b3acb8ed3eabba44a81c235272"
+      "sha256": "b4c52d0a2479557a9e45c18513c6cb4cbe06e0ef4c0681a7bdcaacad1d403aab"
     },
     {
       "path": "harness-push/SKILL.md",
-      "sha256": "e9c409d6c3858d91197f884e037bdad060f9c12de6c4f1f6d9494ad76b0ce5f1"
+      "sha256": "534bf14d352626ca5d9cd3eb8c8b0873cb45235e142abe8183f7f8292f291091"
     },
     {
       "path": "harness-review/checklist.md",
@@ -197,7 +197,7 @@
     },
     {
       "path": "harness-review/SKILL.md",
-      "sha256": "f85d811af75f23464a78ab84ba0a2e89db3da48f68959fd4af662c4b6500c59b"
+      "sha256": "339f54dd65a69d2e16eea8a99bd6e44056f6f84f4f4b7fb07ee4943e5273fc83"
     },
     {
       "path": "harness-run/checklist.md",
@@ -213,7 +213,7 @@
     },
     {
       "path": "harness-run/SKILL.md",
-      "sha256": "cb2955e609670a5d5c5767928264e9c3df1cbad75b227e630f75aa8e42cfdefe"
+      "sha256": "3347cd844c41dbf3161375358ee73c1f4d3a804cd8427e58d5ef044c1892141c"
     },
     {
       "path": "harness-submit/checklist.md",
@@ -225,7 +225,7 @@
     },
     {
       "path": "harness-submit/SKILL.md",
-      "sha256": "77097c018a1512cf2e824dee3699e1af882543b5c57ced629ef0601c3f954782"
+      "sha256": "e232d9529f4e1c77e757606c3498fd20c44d60a2c81e3478b716fefc9a66c291"
     },
     {
       "path": "harness-sync/reference.md",
@@ -233,7 +233,7 @@
     },
     {
       "path": "harness-sync/SKILL.md",
-      "sha256": "87f42bc67bc3f63a56e8e96790b12aa7e45bfd62d33872a69127a0ce0ecc9f81"
+      "sha256": "81eca1aa726fce88aeeffa513be0b050edc7102a2215fb6c7cd5c601ea048653"
     },
     {
       "path": "harness-test/checklist.md",
@@ -257,7 +257,7 @@
     },
     {
       "path": "harness-test/SKILL.md",
-      "sha256": "1df46245e947f31768b51068567f72aefa37759bfcb32488cfab25c5fff701f5"
+      "sha256": "1045385d042fb625bca663068cd2505e73539437e5a7e5e86e4081562df3b630"
     },
     {
       "path": "protocols/archive-report-protocol.md",
@@ -333,7 +333,7 @@
     },
     {
       "path": "scripts/harness_change.py",
-      "sha256": "f4e2d4ab9ee13e93cf200555b6b116342ad044dcdd5dfa25fa7e7ca435dd1882"
+      "sha256": "9d35cfb6184028ee03c7d574a6d24b33f8cc437ba5c3dae9a0487d50566bda1f"
     },
     {
       "path": "scripts/harness_check_gate.py",
@@ -341,7 +341,7 @@
     },
     {
       "path": "scripts/harness_context.py",
-      "sha256": "c7ad3199bda332e853a24e6268fa32dcc253adb6dfe7e0de7aa3b7f0ae7ae312"
+      "sha256": "23572ea0c3455812a5998448e4c90afe9ea7d3a37f15c893c718007ad3c5c886"
     },
     {
       "path": "scripts/harness_deploy.py",
@@ -369,11 +369,11 @@
     },
     {
       "path": "scripts/harness_fixback.py",
-      "sha256": "56a961a8654dd78d31b5e6f875fd15651419266ea9cab7b81fe0106f2d8a2420"
+      "sha256": "dda0d6d836fe4aaaf7ba4cbf888f921c9e1800a0d4f17ee8f7e0e3ac19dd4cbc"
     },
     {
       "path": "scripts/harness_gate.py",
-      "sha256": "aa8527c794ac974e2c2a6d55f72021c67e80f56e919b670f02c268d6048f5908"
+      "sha256": "447a7339b87cbf134a570a0119b697766f1ee3e703dce497e5f3763ad016cb68"
     },
     {
       "path": "scripts/harness_headless.py",
@@ -389,7 +389,7 @@
     },
     {
       "path": "scripts/harness_ledger.py",
-      "sha256": "476832333a63089fe312d9fb288b9e8a51d081a44b30548e1dac9a2b8298e0fb"
+      "sha256": "52caa7106480074f1e2ee0122fa6f194cf852805bfd562073ad2fc79ba666514"
     },
     {
       "path": "scripts/harness_migration_head.py",
@@ -401,11 +401,11 @@
     },
     {
       "path": "scripts/harness_paths.py",
-      "sha256": "4042a0ee0521a3ff26448d63415eaf63dd45161d71d8c54a2b72665a1263e02b"
+      "sha256": "bdd20fce04754664f33ceb838a5fa49ddcbf6e507a7017850cacc345b5564a77"
     },
     {
       "path": "scripts/harness_phase.py",
-      "sha256": "b1e53c1f7becf198195cb9a4bcba835767aed82420450e1842cc07d89febf532"
+      "sha256": "7dc52174d1dc1b3ce8d3c4ebb3f61dd5e1058a77b36d44007ed04db949eaa392"
     },
     {
       "path": "scripts/harness_plan_aggregate.py",
@@ -413,7 +413,7 @@
     },
     {
       "path": "scripts/harness_plan_finalize.py",
-      "sha256": "6f4dcee06f92f7ed7a3bd0ee615e9dd7e8fd921502b132305e37c4871b97537b"
+      "sha256": "0cb683d26bb9af86cfe4a9c019d1fc20447fa90eb12fb31377bd1d7e4740c4d3"
     },
     {
       "path": "scripts/harness_preflight.py",
@@ -437,7 +437,7 @@
     },
     {
       "path": "scripts/harness_review.py",
-      "sha256": "3e14be966ffc0f2e0261f471390d1ed308f2272e1df7e0cb30d7c9ba5e33f858"
+      "sha256": "c3c591323846bee24afc13ba0ab4eb275233eff84f57c1bb5d155a453bd127db"
     },
     {
       "path": "scripts/harness_runtime.py",