@hunter-harness/workflow-harness 0.2.41 → 0.2.43

package/harness/bundles/general/claude-code/scripts/harness_verification.py

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

package/harness/bundles/general/codebuddy/.harness-build.json

@@ -2,5 +2,5 @@
   "schemaVersion": 1,
   "overlay": "none",
   "agent": "codebuddy",
-  "coreHash": "23e4a1b1c35dd556"
+  "coreHash": "49a193cd2335f90e"
 }

package/harness/bundles/general/codebuddy/contracts/build-profile-v3.schema.json

@@ -108,6 +108,10 @@
               "requiredCapabilities"
             ],
             "properties": {
+              "id": {
+                "type": "string",
+                "pattern": "^[A-Za-z][A-Za-z0-9_-]*$"
+              },
               "commandKey": {
                 "type": "string",
                 "pattern": "^[A-Za-z][A-Za-z0-9_-]*$"
@@ -124,7 +128,36 @@
                 "enum": [
                   "incremental",
                   "module-am",
-                  "module"
+                  "module",
+                  "full"
+                ]
+              },
+              "argvTemplate": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "minItems": 1
+              },
+              "inputs": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                }
+              },
+              "coverage": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "coverageLevel": {
+                "enum": [
+                  "incremental",
+                  "module",
+                  "module-am",
+                  "full"
                 ]
               },
               "candidate": {
@@ -137,6 +170,28 @@
                   "minLength": 1
                 },
                 "uniqueItems": true
+              },
+              "resourceLocks": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "uniqueItems": true
+              },
+              "estimatedDurationSeconds": {
+                "type": "number",
+                "minimum": 0
+              },
+              "requiresFrozenIdentity": {
+                "type": "boolean"
+              },
+              "reusePolicy": {
+                "enum": [
+                  "never",
+                  "identity-exact",
+                  "ledger-exact"
+                ]
               }
             }
           }

package/harness/bundles/general/codebuddy/harness-archive/SKILL.md

@@ -3,7 +3,7 @@ name: harness-archive
 description: 归档所有变更产出（计划/测试报告/审查/SQL/API文档）到
   .harness/archive/，含归档元数据和可视化最终总结。使用场景：归档、完成归档、收尾、打包产出物
 ---
-<!-- generated by harness_deploy.py; core=23e4a1b1c35dd556; overlay=none; agent=codebuddy; do not edit -->
+<!-- generated by harness_deploy.py; core=49a193cd2335f90e; overlay=none; agent=codebuddy; do not edit -->
 # harness-archive — 变更归档
 
 ## Purpose

package/harness/bundles/general/codebuddy/harness-archive/reference.md

@@ -47,6 +47,7 @@ powershell.exe -NoProfile -ExecutionPolicy Bypass -File "harness-skills/harness-
 - `durations`：totalMinutes + stages[{stage,skill,startedAt,endedAt,minutes,result}] —— 从 `logs/execution-log.md` 各 `[N] harness-<skill>` 小节的 `开始`/`结束`/`耗时` 解析；
 - `skillCalls`：每个 skill 的调用次数（含重入）+ 结果 —— 从 execution-log 统计；
 - `verification`：单元/API/覆盖展示，含 passRate —— 来自 `evidence/verification-ledger.json`；
+- `efficiency`：墙钟/活动/资源等待、验证尝试、失败分类、环境 prepare/reuse/reset/cleanup、重复命令与 wrapper 数 —— 由 `harness_efficiency.py` 从运行回执自动汇总；
 - `changedFiles`：path/summary/insertions/deletions —— 来自 `git diff --numstat <base>..<head>`；
 - `reviewSummary`：red/yellow + redFixed/redConfirmed/yellowFixed/yellowDeferred 修复进度；
 - `maintenanceNotes`：给后续维护者看的结论；

package/harness/bundles/general/codebuddy/harness-archive/templates/render-summary.mjs

@@ -201,6 +201,10 @@ const releaseHtml = recordOnly ? "" : `
 const remoteCost = record(measurements.remoteCost);
 const remoteCostTotals = record(remoteCost.totals);
 const storage = record(measurements.artifactStorage);
+const efficiency = record(data.efficiency);
+const efficiencyTiming = record(efficiency.timing);
+const environmentActions = record(efficiency.environment);
+const failureClasses = record(efficiency.failureClasses);
 const projection = record(data.projection);
 const durability = record(data.archiveDurability);
 const durabilityStatus = durability.status || "ARCHIVED_LOCAL_ONLY";
@@ -264,6 +268,10 @@ ${scenarioCoverageHtml}
   <div class="fact"><span>未归因 <code title="agentOrToolUnattributedMs">agentOrToolUnattributed</code></span><strong>${esc(duration(timing.agentOrToolUnattributedMs))}</strong></div>
   <div class="fact"><span>远端 runner 成本</span><strong>${measurement(remoteCostTotals.runnerMinutes ?? remoteCost.runnerMinutes, " 分钟")}</strong></div>
   <div class="fact"><span>新增制品字节</span><strong>${measurement(storage.bytesAdded, " bytes")}</strong></div>
+  <div class="fact"><span>验证尝试 / 资源等待</span><strong>${esc(efficiency.verificationAttempts ?? 0)} / ${esc(duration(efficiencyTiming.resourceWaitMs))}</strong></div>
+  <div class="fact"><span>环境准备 / 复用 / 重置 / 清理</span><strong>${esc(environmentActions.prepare ?? 0)} / ${esc(environmentActions.reuse ?? 0)} / ${esc(environmentActions.reset ?? 0)} / ${esc(environmentActions.cleanup ?? 0)}</strong></div>
+  <div class="fact"><span>启动器 / 环境 / 测试 / 外部失败</span><strong>${esc(failureClasses.launcher ?? 0)} / ${esc(failureClasses.environment ?? 0)} / ${esc(failureClasses.test ?? 0)} / ${esc(failureClasses.external ?? 0)}</strong></div>
+  <div class="fact"><span>无新证据的重复命令</span><strong>${esc(efficiency.repeatedCommandsWithoutNewEvidence ?? 0)}</strong></div>
   <div class="fact"><span>守恒差值 <code>conservationDeltaMs</code></span><strong>${esc(timing.conservationDeltaMs ?? "N/A")}</strong></div>
 </div></details>
 <details><summary>阶段状态</summary><div class="table-wrap"><table><thead><tr><th>阶段</th><th>结果</th></tr></thead><tbody>${stageHtml}</tbody></table></div></details>

package/harness/bundles/general/codebuddy/harness-archive/templates/summary-data-template.json

@@ -125,6 +125,34 @@
       "duplicateRunCount": 0
     }
   },
+  "efficiency": {
+    "schemaVersion": 1,
+    "timing": {
+      "wallClockMs": 0,
+      "activeTimeMs": 0,
+      "resourceWaitMs": 0
+    },
+    "verificationAttempts": 0,
+    "statusCounts": {},
+    "failureClasses": {
+      "launcher": 0,
+      "environment": 0,
+      "test": 0,
+      "external": 0,
+      "unknown": 0
+    },
+    "invalidationReasons": {},
+    "environment": {
+      "prepare": 0,
+      "reuse": 0,
+      "reset": 0,
+      "cleanup": 0
+    },
+    "productIdentityCount": 0,
+    "repeatedCommandsWithoutNewEvidence": 0,
+    "manualWrapperCount": 0,
+    "notes": []
+  },
   "reviewSummary": {
     "status": "ADVISORY",
     "red": 0,

package/harness/bundles/general/codebuddy/harness-codebase-map/SKILL.md

@@ -3,7 +3,7 @@ name: harness-codebase-map
 description: 分析现有代码库并生成 .harness/codebase/map/
   下的结构化代码库地图。用于陌生项目理解、重大改造前梳理、harness-sync 提示 map 过期后的人工刷新。
 ---
-<!-- generated by harness_deploy.py; core=23e4a1b1c35dd556; overlay=none; agent=codebuddy; do not edit -->
+<!-- generated by harness_deploy.py; core=49a193cd2335f90e; overlay=none; agent=codebuddy; do not edit -->
 # harness-codebase-map — 代码库地图
 
 ## Purpose