@hunter-harness/workflow-harness 0.2.42 → 0.2.44

package/harness/bundles/java/claude-code/protocols/execution-session-protocol.md

@@ -0,0 +1,52 @@
+---
+description: 长时命令、验证调度、环境复用与 fixback 的可恢复执行协议。
+---
+
+# Execution Session Protocol
+
+## 受管运行会话
+
+可能超过交互窗口的命令必须通过 `harness_runtime.py run-start` 创建受管会话，而不是依赖调用方进程持续在线。会话状态位于：
+
+```text
+runtime/run-sessions/<session-id>/
+├── session.json
+├── stdout.log
+├── stderr.log
+└── worker.log
+```
+
+`session.json` 只持久化脱敏身份：命令哈希、环境哈希、产品身份、验证目标、阶段、资源锁、进程身份、心跳、进度、超时和原因码。原始环境变量和敏感 argv 不得写入回执。
+
+- `run-status` 可由新进程重连；心跳丢失超过 grace period 才标记 `INCOMPLETE`。
+- `run-log --cursor` 按字节游标增量读取 UTF-8 日志，返回下一游标。
+- `run-cancel` 只终止身份完全匹配的进程树；身份不确定时 fail closed。
+- launcher 尚未启动子进程时失败，状态为 `INCOMPLETE/LAUNCHER_FAILED`；子进程非零退出为 `FAIL/CHILD_EXIT_NONZERO`；超时为 `CANCELLED/TIMEOUT`。
+- `resourceLocks` 通过 `runtime/resource-locks/<lock-hash>.json` 原子独占；冲突会在启动测试进程前返回 `INCOMPLETE/RESOURCE_LOCK_BUSY`，终态写入前必须释放持有的锁。
+- Windows 使用 shell-free argv 和 kill-on-close Job Object；Job Object 绑定失败时必须终止已验证的子进程并返回 `PROCESS_TREE_ISOLATION_UNAVAILABLE`，不得降级为无隔离运行。
+
+## 验证调度
+
+`harness_verification.py plan` 对验证 DAG 做拓扑调度。每个目标声明 `dependsOn`、`resourceLocks`、identity 与复用策略。
+
+- 只有资源锁不相交的 ready 目标可进入同一 wave。
+- 未声明资源锁且预计大于等于 60 秒的目标自动使用 `harness:unclassified-heavy`，因此默认串行。
+- 冻结后的产品 identity 发生变化时返回 `FROZEN_IDENTITY_DRIFT`，禁止继续执行或复用。
+- 复用和跳过必须记录 `decision`、`reasonCode` 与人类可读 `explanation`；无证据不得返回 `REUSE`。
+
+## 环境会话
+
+环境租约支持两种模式：
+
+- `change-session`：同一 change、stack、内容指纹和通过的 canary 可复用。
+- `ephemeral`：每次 acquire 都创建新 session；替换既有 session 前必须提供匹配 stack/environment identity 的 provider reset 回执。
+
+租约获取通过注册锁原子串行化，跨 change 的 writable volume 永不共享。`change-session` 只有在内容指纹非空、environment hash、owner identity、expiry、mode、volume 和 canary 全部匹配时才可复用。内容指纹漂移标记 `STALE_CONTENT`；过期租约不可写。prepare/reuse 写入事实回执；reset/cleanup 只有在 provider operation evidence 为 `OK` 时才可如此命名。单纯释放租约只能记录 `release`，不得声称已清理外部环境。回执写入 change 的 `runtime/environment-receipts/`，文件名使用 stack hash，且不包含凭据明文。
+
+## Fixback 批次
+
+Review/Test 回灌通过 `harness_fixback.py` 形成批次。一个批次可包含多条相关问题，但每条问题必须保留可读取的 JSON RED/GREEN 证据。证据必须位于项目或 change state 内，包含 evidence id、状态和产品 identity，并在批次中固定 SHA-256；RED 必须为 `FAIL`，GREEN 必须为 `PASS/OK`。affected verification 与 review 回执必须绑定最终产品 identity，其 `passedGates` 合集覆盖风险扩展后的全部门禁。`freeze-readiness` 会重新校验证据摘要；开放问题、证据漂移或缺门禁均阻止 code freeze。
+
+## 效率摘要
+
+`harness_efficiency.py summary` 从运行会话、环境回执和失效回执生成事实型指标：墙钟区间并集、累计活动/资源等待、execution/launcher/verification 尝试、失败分类、环境 prepare/reuse/reset/cleanup、重复且没有新 result digest 的命令和人工 wrapper 数。reset/cleanup 只统计带有效 provider evidence 的回执。归档摘要自动包含该结构；指标不得归责个人，也不得在历史样本不足时虚构 ETA。

package/harness/bundles/java/claude-code/protocols/state-layout-protocol.md

@@ -60,7 +60,14 @@ description: harness .harness 状态目录分层协议。用于减少根目录
 ├── sqls/
 ├── scripts/
 ├── runtime/
-│   └── service-session.json
+│   ├── service-session.json
+│   ├── run-sessions/<session-id>/
+│   │   ├── session.json
+│   │   ├── stdout.log
+│   │   └── stderr.log
+│   ├── environment-receipts/
+│   ├── invalidations/
+│   └── fixback/batches/
 └── backups/
     └── uncommitted-tests/
 ```
@@ -73,6 +80,10 @@ description: harness .harness 状态目录分层协议。用于减少根目录
 
 `build-profile.json` 的 `serviceStart.inputFiles`（glob 列表，相对 project 展开）是 `moduleInputsHash` 的来源。`harness_service.py ensure` 取 CLI `--files` ∪ `serviceStart.inputFiles` 计算依赖闭包；**空输入被拒绝**（exit 非 0），**不得生成可复用的空指纹**。通用项目 detect 无法猜 module 源，`inputFiles` 默认空数组，须人工配置。
 
+过期的 service session 只有在进程身份明确不匹配时才允许由 `retire-stale` 移入
+`runtime/retired-service-sessions/`；该动作保留原始回执且不终止进程。受管命令、
+环境会话和 fixback 的完整合同见 `execution-session-protocol.md`。
+
 ## knowledge maintenance-outbox（§8）
 
 归档 close 不再同步执行知识维护；它写一个 pending outbox 项即返回：
@@ -179,3 +190,15 @@ Harness skill 读取的项目级配置（不提交 git）。缺失时使用下
 | `knowledge.manualReview` | boolean | `false` | `true` 时 knowledge-ingest promote 等高价值操作需人工确认；`false` 时按 skill 默认策略 |
 
 读取顺序：`.harness/config/harness.json` → 缺失则默认值。plan 阶段 5 设计审批包须读取 `defaultWorktree` 作为 worktree 选项的推荐值。
+
+## 可恢复文件事务
+
+schema v3 事务在本地 `transactions/<transaction-id>/` 保存 journal、before snapshot、staged payload、after manifest 和小型 status 投影。journal 固定 project identity、执行器版本、目标 Bundle identity、ownership manifest hash、plan hash 与 snapshot digest。
+
+未完成事务同时镜像到用户级恢复根：
+
+```text
+${HUNTER_HARNESS_RECOVERY_ROOT:-~/.hunter-harness/recovery}/<project-path-hash>/transactions/<transaction-id>/
+```
+
+因此项目内 `.harness` 局部丢失后，`status` 仍可只读发现恢复项。`resume` 仅在 plan/snapshot/staged digest 与已完成操作的当前文件状态全部匹配时继续 pending operations；任一不匹配均 fail closed。`rollback` 在写回 before snapshot 前重新校验 snapshot digest。事务提交或回滚成功后删除用户级镜像；本地 committed 事务仍按保留策略提供显式回滚。

package/harness/bundles/java/claude-code/protocols/verification-graph-protocol.md

@@ -11,6 +11,9 @@ Build Profile v3 用 `verificationGraph` 取代账本内的固定验证目标清
 - `requiredCoverage`：`incremental/module-am/module`；
 - `candidate`：是否为发布候选门禁；
 - `requiredCapabilities`：执行环境必须具备的能力。
+- `resourceLocks`：目标独占或共享的数据库、端口、浏览器、容器等资源身份；
+- `estimatedDurationSeconds`：供默认串行策略和进度显示使用，不作为虚构 ETA 的依据；
+- `reusePolicy`：允许复用时必须匹配的产品、环境、命令与覆盖身份。
 
 `candidateTarget` 必须引用已声明目标。未知目标、未知依赖、循环依赖、命令缺失都 fail closed。
 
@@ -22,5 +25,8 @@ Build Profile v3 用 `verificationGraph` 取代账本内的固定验证目标清
 4. 未进入闭包的目标是 `omitted`，与“执行失败”或“因能力阻断”分开报告。
 5. 账本记录目标定义的规范化 identity；依赖、覆盖度或能力声明变化后，旧证据必须失效。
 6. 候选目标即使自身命令可运行，也必须等待所有依赖和能力满足。
+7. ready 目标按 `resourceLocks` 分 wave；锁相交的目标不得并行。预计 ≥60 秒且未声明锁的目标默认归入 `harness:unclassified-heavy` 串行队列。
+8. code freeze 后产品 identity 漂移必须返回 `FROZEN_IDENTITY_DRIFT`；禁止在旧候选上补跑后声称覆盖新候选。
+9. 每个 `RUN / REUSE / SKIP / BLOCKED` 决策都必须带稳定 `reasonCode` 和解释；`REUSE` 还必须绑定现有证据 identity。
 
 JSON 合同见 `contracts/build-profile-v3.schema.json`；通用选择器为 `@hunter-harness/core` 的 `selectVerificationTargets`。

package/harness/bundles/java/claude-code/scripts/harness_archive.py

@@ -70,12 +70,14 @@ if str(SCRIPTS_DIR) not in sys.path:
     sys.path.insert(0, str(SCRIPTS_DIR))
 
 import harness_events as he  # noqa: E402
+import harness_efficiency as heff  # noqa: E402
 import harness_gate as hgate  # noqa: E402
 import harness_ledger as hl  # noqa: E402
 import harness_paths as hp  # noqa: E402
 import harness_phase as hphase  # noqa: E402
 import harness_report_model as hrm  # noqa: E402
 import harness_review as hr  # noqa: E402
+import harness_runtime as hruntime  # noqa: E402
 
 
 # ---------------------------------------------------------------------------
@@ -1956,6 +1958,131 @@ def check_archive_exact_byte_policy(project_root: Path) -> dict[str, Any]:
     }
 
 
+def validate_sensitive_evidence_publication_gate(
+    change_dir: Path,
+    *,
+    copy_root: Path | None = None,
+    require_receipt: bool = False,
+) -> dict[str, Any]:
+    """Fail closed before freeze/copy when plaintext evidence is unresolved.
+
+    The receipt is deliberately self-excluded from the tree digest.  It may
+    therefore bind the exact publishable bytes without creating a recursive
+    digest.  Private quarantine paths are evidence metadata only and must be
+    outside both the project/copy roots.
+    """
+    change_dir = change_dir.expanduser().resolve()
+    copy_root = (copy_root or change_dir).expanduser().resolve()
+    receipt_path = hruntime.sensitive_evidence_receipt_path(change_dir)
+    candidates = hruntime.sensitive_evidence_candidates(change_dir)
+    if candidates:
+        return {
+            "ok": False,
+            "reasonCode": "SENSITIVE_EVIDENCE_UNQUARANTINED",
+            "receiptPath": str(receipt_path),
+            "unresolvedFailures": candidates,
+            "nextAction": "Quarantine the original bytes before archive publication.",
+        }
+    if not receipt_path.is_file():
+        if require_receipt:
+            return {
+                "ok": False,
+                "reasonCode": "SECRET_SCAN_RECEIPT_MISSING",
+                "receiptPath": str(receipt_path),
+                "unresolvedFailures": [],
+            }
+        return {
+            "ok": True,
+            "reasonCode": "SECRET_SCAN_NOT_APPLICABLE",
+            "receiptPath": str(receipt_path),
+            "receiptRequired": False,
+            "unresolvedFailures": [],
+        }
+    try:
+        receipt = read_json(receipt_path)
+    except (OSError, json.JSONDecodeError, TypeError) as exc:
+        return {
+            "ok": False,
+            "reasonCode": "SECRET_SCAN_RECEIPT_INVALID",
+            "receiptPath": str(receipt_path),
+            "error": str(exc),
+        }
+    if not isinstance(receipt, dict):
+        return {
+            "ok": False,
+            "reasonCode": "SECRET_SCAN_RECEIPT_INVALID",
+            "receiptPath": str(receipt_path),
+            "error": "receipt must be an object",
+        }
+    issues: list[dict[str, Any]] = []
+    if receipt.get("schemaVersion") != 1:
+        issues.append({"code": "SECRET_SCAN_SCHEMA_INVALID"})
+    if receipt.get("rulesVersion") != hruntime.SECRET_SCAN_RULES_VERSION:
+        issues.append({"code": "SECRET_SCAN_RULES_MISMATCH"})
+    if receipt.get("changeId") != change_dir.name:
+        issues.append({"code": "SECRET_SCAN_CHANGE_ID_MISMATCH"})
+    if str(receipt.get("status") or "").upper() not in {"OK", "QUARANTINED"}:
+        issues.append({"code": "SENSITIVE_EVIDENCE_QUARANTINE_FAILED"})
+    unresolved = receipt.get("unresolvedFailures")
+    if isinstance(unresolved, list) and unresolved:
+        issues.append({"code": "SENSITIVE_EVIDENCE_QUARANTINE_FAILED", "count": len(unresolved)})
+    elif unresolved not in (None, []):
+        issues.append({"code": "SECRET_SCAN_UNRESOLVED_INVALID"})
+    try:
+        actual_digest = hruntime.publishable_tree_digest(change_dir)
+    except OSError as exc:
+        actual_digest = None
+        issues.append({"code": "SECRET_SCAN_TREE_UNREADABLE", "error": str(exc)})
+    if actual_digest is not None and receipt.get("publishableTreeDigest") != actual_digest:
+        issues.append({
+            "code": "SECRET_SCAN_TREE_DIGEST_MISMATCH",
+            "expected": receipt.get("publishableTreeDigest"),
+            "actual": actual_digest,
+        })
+    if receipt.get("publicationExcluded") is not True:
+        issues.append({"code": "SECRET_SCAN_PUBLICATION_NOT_EXCLUDED"})
+    project_root = find_project_root(change_dir)
+    for entry in receipt.get("entries") or []:
+        if not isinstance(entry, dict):
+            issues.append({"code": "SECRET_SCAN_ENTRY_INVALID"})
+            continue
+        private_raw = entry.get("privatePath")
+        if not isinstance(private_raw, str) or not private_raw.strip():
+            issues.append({"code": "SECRET_SCAN_PRIVATE_PATH_MISSING"})
+            continue
+        private_path = Path(private_raw).expanduser().resolve()
+        if (
+            _path_is_within(private_path, copy_root)
+            or _path_is_within(private_path, project_root)
+            or _path_is_within(private_path, change_dir)
+        ):
+            issues.append({
+                "code": "SECRET_SCAN_PRIVATE_PATH_IN_COPY_ROOT",
+                "privatePath": str(private_path),
+            })
+        if not private_path.is_file():
+            issues.append({
+                "code": "SECRET_SCAN_PRIVATE_PATH_MISSING",
+                "privatePath": str(private_path),
+            })
+        source_raw = entry.get("sourcePath")
+        if isinstance(source_raw, str) and source_raw.strip():
+            source_path = (change_dir / source_raw).resolve()
+            if _path_is_within(source_path, change_dir) and source_path.exists():
+                issues.append({
+                    "code": "SENSITIVE_EVIDENCE_SOURCE_REMAINS",
+                    "sourcePath": source_raw,
+                })
+    return {
+        "ok": not issues,
+        "reasonCode": "SECRET_SCAN_GATE_SATISFIED" if not issues else "SECRET_SCAN_GATE_BLOCKED",
+        "receiptPath": str(receipt_path),
+        "receipt": receipt,
+        "issues": issues,
+        "treeDigest": actual_digest,
+    }
+
+
 # ---------------------------------------------------------------------------
 # status
 # ---------------------------------------------------------------------------
@@ -2000,6 +2127,22 @@ def check_status(
             }
         )
 
+    sensitive_gate = validate_sensitive_evidence_publication_gate(
+        change_dir,
+        copy_root=change_dir,
+        require_receipt=False,
+    )
+    checks["sensitive_evidence_publication"] = sensitive_gate
+    if not sensitive_gate.get("ok"):
+        blockers.append({
+            "code": str(sensitive_gate.get("reasonCode") or "SECRET_SCAN_GATE_BLOCKED"),
+            "message": str(
+                sensitive_gate.get("nextAction")
+                or sensitive_gate.get("error")
+                or "sensitive evidence publication gate failed"
+            ),
+        })
+
     # --- H-4 formal-layer minimum set ---
     plans_dir = change_dir / "plans"
     plan_files = (
@@ -2245,6 +2388,14 @@ def check_status(
     except Exception as exc:  # noqa: BLE001 — preflight must not crash status
         preflight = {"ok": False, "items": [], "blocking": [], "error": str(exc)}
     checks["artifact_preflight"] = preflight
+    if preflight.get("ok") is not True and not preflight.get("blocking"):
+        blockers.append({
+            "code": "artifact-preflight-invalid",
+            "message": str(
+                preflight.get("error")
+                or "artifact event projection or preflight validation failed"
+            ),
+        })
     for item in preflight.get("blocking") or []:
         blockers.append({
             "code": "artifact-path-blocking",
@@ -3890,12 +4041,15 @@ def collect_summary_data(
             "retention",
             "archiveDurability",
             "remoteCost",
+            "efficiency",
             "projection",
         ):
             if key in existing:
                 data[key] = _deepcopy_json(existing[key])
     if not for_replay or not isinstance(data.get("remoteCost"), dict):
         data["remoteCost"] = remote_cost
+    if not for_replay or not isinstance(data.get("efficiency"), dict):
+        data["efficiency"] = heff.collect_efficiency_summary(change_dir)
 
     event_summary = he.build_summary(change_dir, events) if events else {
         "ok": True,
@@ -6461,12 +6615,9 @@ def artifact_preflight(change_dir: Path) -> dict[str, Any]:
         return {"ok": True, "items": [], "blocking": []}
     change_id = change_dir.name
     project_root = find_project_root(change_dir)
-    for line in events_p.read_text(encoding="utf-8").splitlines():
-        try:
-            event = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        if not isinstance(event, dict) or event.get("type") != "artifact":
+    events = he.apply_event_corrections(he.load_events(events_p))
+    for event in events:
+        if event.get("type") != "artifact":
             continue
         path = str(event.get("path") or "").strip()
         kind = str(event.get("kind") or "").strip()
@@ -6653,9 +6804,19 @@ def evaluate_artifact_budget(change_dir: Path) -> dict[str, Any]:
     except (OSError, ValueError, json.JSONDecodeError) as exc:
         return {
             "ok": False,
-            "code": "ARTIFACT_POLICY_INVALID",
+            "code": "ARTIFACT_PREFLIGHT_INVALID",
             "message": str(exc),
         }
+    if preflight.get("ok") is not True:
+        return {
+            "ok": False,
+            "code": "ARTIFACT_PREFLIGHT_INVALID",
+            "message": str(
+                preflight.get("error")
+                or "artifact event projection or preflight validation failed"
+            ),
+            "preflightBlocking": preflight.get("blocking") or [],
+        }
     excluded_parts = {
         "node_modules",
         ".venv",
@@ -6693,7 +6854,7 @@ def evaluate_artifact_budget(change_dir: Path) -> dict[str, Any]:
     oversized = [
         item for item in entries if int(item["bytes"]) > max_file
     ]
-    ok = total <= max_total and not oversized and bool(preflight.get("ok"))
+    ok = total <= max_total and not oversized
     return {
         "ok": ok,
         "code": (
@@ -6722,6 +6883,13 @@ def materialize_repository_artifacts(change_dir: Path) -> dict[str, Any]:
     change_dir = change_dir.resolve()
     project_root = find_project_root(change_dir)
     preflight = artifact_preflight(change_dir)
+    if preflight.get("ok") is not True:
+        raise ValueError(
+            str(
+                preflight.get("error")
+                or "artifact event projection or preflight validation failed"
+            )
+        )
     copied: list[str] = []
     objects: list[dict[str, Any]] = []
     bytes_added = 0
@@ -7295,6 +7463,32 @@ def cmd_finalize(
         payload["error"] = f"archive target already exists: {archive_dir}"
         return 1, payload
 
+    source_sensitive_gate = validate_sensitive_evidence_publication_gate(
+        original_change_dir,
+        copy_root=original_change_dir,
+        require_receipt=False,
+    )
+    payload["steps"]["sensitive_evidence_source_gate"] = source_sensitive_gate
+    if not source_sensitive_gate.get("ok"):
+        payload["error"] = str(
+            source_sensitive_gate.get("nextAction")
+            or source_sensitive_gate.get("error")
+            or "sensitive evidence publication gate failed"
+        )
+        payload["issues"] = [
+            {
+                "code": str(
+                    source_sensitive_gate.get("reasonCode")
+                    or "SECRET_SCAN_GATE_BLOCKED"
+                ),
+                "severity": "error",
+                "message": payload["error"],
+            }
+        ]
+        payload["original_preserved"] = original_change_dir.is_dir()
+        payload["finalStatus"] = "FAIL"
+        return 1, payload
+
     exact_byte = check_archive_exact_byte_policy(project_root)
     payload["steps"]["archive_exact_byte"] = exact_byte
     if not exact_byte["ok"]:
@@ -7303,7 +7497,13 @@ def cmd_finalize(
     artifact_budget = evaluate_artifact_budget(original_change_dir)
     payload["steps"]["artifact_budget"] = artifact_budget
     if not artifact_budget.get("ok"):
-        payload["error"] = "artifact budget exceeded before staging"
+        if artifact_budget.get("code") == "ARTIFACT_PREFLIGHT_INVALID":
+            payload["error"] = str(
+                artifact_budget.get("message")
+                or "artifact validation failed before staging"
+            )
+        else:
+            payload["error"] = "artifact budget exceeded before staging"
         payload["issues"] = [
             {
                 "code": str(
@@ -7376,6 +7576,38 @@ def cmd_finalize(
     work_dir = operation_temp_dir
     before_manifest: dict[str, Any] | None = None
 
+    # A source tree without sensitive evidence still receives a digest-bound
+    # receipt in the isolated staging tree.  This keeps legacy archives
+    # compatible while making every published archive auditable.
+    try:
+        staged_receipt = hruntime.sensitive_evidence_receipt_path(work_dir)
+        if not staged_receipt.is_file():
+            hruntime.ensure_sensitive_evidence_scan_receipt(work_dir)
+        staged_sensitive_gate = validate_sensitive_evidence_publication_gate(
+            work_dir,
+            copy_root=work_dir,
+            require_receipt=True,
+        )
+        payload["steps"]["sensitive_evidence_publication"] = staged_sensitive_gate
+        if not staged_sensitive_gate.get("ok"):
+            payload["error"] = "sensitive evidence publication gate failed before freeze"
+            payload["issues"] = [
+                {
+                    "code": str(
+                        staged_sensitive_gate.get("reasonCode")
+                        or "SECRET_SCAN_GATE_BLOCKED"
+                    ),
+                    "severity": "error",
+                    "message": payload["error"],
+                }
+            ]
+            _restore_finalize_failure()
+            return 1, payload
+    except (OSError, ValueError, json.JSONDecodeError) as exc:
+        payload["error"] = f"sensitive evidence publication gate failed: {exc}"
+        _restore_finalize_failure()
+        return 1, payload
+
     if split_state_dir is not None and split_state_dir.is_dir():
         _merge_runtime_state(split_state_dir, work_dir)
         payload["steps"]["split_state_merge"] = {
@@ -7474,19 +7706,36 @@ def cmd_finalize(
         "blockingCount": len(preflight.get("blocking") or []),
         "itemsCount": len(preflight.get("items") or []),
     }
-    if preflight.get("blocking"):
-        payload["error"] = (
-            f"artifact preflight blocking: "
-            f"{len(preflight['blocking'])} path(s) cannot be archived"
-        )
-        payload["issues"] = [
-            {
-                "code": "ARTIFACT_PATH_BLOCKING",
-                "severity": "error",
-                "message": f"{item.get('path', '')}: {item.get('reason', 'blocking')}",
-            }
-            for item in preflight["blocking"]
-        ]
+    if preflight.get("ok") is not True:
+        blocking_paths = preflight.get("blocking") or []
+        if blocking_paths:
+            payload["error"] = (
+                f"artifact preflight blocking: "
+                f"{len(blocking_paths)} path(s) cannot be archived"
+            )
+            payload["issues"] = [
+                {
+                    "code": "ARTIFACT_PATH_BLOCKING",
+                    "severity": "error",
+                    "message": f"{item.get('path', '')}: {item.get('reason', 'blocking')}",
+                }
+                for item in blocking_paths
+            ]
+        else:
+            payload["error"] = (
+                "artifact preflight invalid: "
+                + str(
+                    preflight.get("error")
+                    or "artifact event projection or preflight validation failed"
+                )
+            )
+            payload["issues"] = [
+                {
+                    "code": "ARTIFACT_PREFLIGHT_INVALID",
+                    "severity": "error",
+                    "message": payload["error"],
+                }
+            ]
         _restore_finalize_failure()
         payload["warnings"] = warnings
         payload["ok"] = False