@hunter-harness/workflow-harness 0.2.86 → 0.3.0

package/harness/bundles/general/cursor/scripts/harness_gate.py

@@ -155,14 +155,14 @@ GATE_WARNINGS_REL = Path("evidence") / "gate-warnings.ndjson"
 # Lifecycle order used to scope C9 scenario coverage by scenario ownerPhase.
 # A scenario owned by a later phase is deferred, not missing, at an earlier
 # phase close. Must stay a superset-ordering of hpf.VALID_OWNER_PHASES.
-SCENARIO_OWNER_PHASE_ORDER = ("plan", "run", "test", "review", "submit")
+SCENARIO_OWNER_PHASE_ORDER = ("plan", "execute", "review", "submit")
 
 # ---------------------------------------------------------------------------
 # 阶段能力表：每个阶段在 begin/close 里额外做什么，集中在这里声明。
 #
 # 这些开关以前是 cmd_begin / cmd_close 里散落的 `if args.phase == ...` —— 两个
-# 五百行的函数，想知道"test 阶段关门时到底跑哪几项"要通读全文。更要紧的是
-# run/test/review 的差异被摊平在控制流里，看不出它们其实共用同一套生命周期。
+# 五百行的函数，想知道"execute 阶段关门时到底跑哪几项"要通读全文。更要紧的是
+# execute/review 的差异被摊平在控制流里，看不出它们其实共用同一套生命周期。
 #
 # 键的含义：
 #   plan_handoff      begin 时校验 plan 已 finalize（只有进入实现的第一个阶段需要）
@@ -174,11 +174,10 @@ SCENARIO_OWNER_PHASE_ORDER = ("plan", "run", "test", "review", "submit")
 #   projection_drift  close 时 projection receipt 变化即硬失败（外发边界）
 PHASE_GATE_RULES: dict[str, frozenset[str]] = {
     "plan": frozenset(),
-    "run": frozenset({
+    "execute": frozenset({
         "plan_handoff", "test_guard", "scenario_coverage",
         "ledger_blocking", "head_may_advance",
     }),
-    "test": frozenset({"test_guard", "scenario_coverage", "ledger_blocking"}),
     "review": frozenset({"review_outputs"}),
     "package": frozenset({"ledger_blocking"}),
     "apidoc": frozenset(),
@@ -481,8 +480,20 @@ def _phase_capsule_path(change_dir: Path, phase: str, run_id: str) -> Path:
 def load_phase_capsule(
     change_dir: Path, phase: str, run_id: str
 ) -> dict[str, Any] | None:
-    path = _phase_capsule_path(change_dir, phase, run_id)
-    if not path.is_file():
+    # 在途 change 的 capsule 可能按旧名（run/test）写入：先归一入参，canonical
+    # 查不到时对所有解析为该 canonical 的旧名各查一次。新写一律 canonical。
+    phase = hp.resolve_phase_name(phase) or phase
+    candidates = [phase] + [
+        legacy for legacy, canonical in hp.LEGACY_PHASE_ALIASES.items()
+        if canonical == phase
+    ]
+    path: Path | None = None
+    for name in candidates:
+        candidate = _phase_capsule_path(change_dir, name, run_id)
+        if candidate.is_file():
+            path = candidate
+            break
+    if path is None:
         return None
     try:
         data = _read_json(path)
@@ -719,7 +730,16 @@ def validate_ledger_for_phase_close(
     individual validation status to be FAIL/NOT_RUN, so a failing phase can
     close honestly without polluting evidence or blocking lease release.
     """
-    required = policy.get("requiredValidations", {}).get(phase, [])
+    resolved_phase = hp.resolve_phase_name(phase) or phase
+    # requiredValidations 的键可能还是合并前的旧名（在途 change 的旧契约），
+    # 入参也可能是旧名（手工 --phase run）——两侧都归一后再匹配；旧契约的
+    # run/test 两个键都映射到 execute，取并集。
+    required: list[str] = []
+    for key, value in (policy.get("requiredValidations") or {}).items():
+        if (hp.resolve_phase_name(key) or str(key)) == resolved_phase:
+            for item in value or []:
+                if item not in required:
+                    required.append(item)
     if not required:
         return {"ok": True, "code": "LEDGER_NOT_REQUIRED", "phase": phase}
 
@@ -913,11 +933,17 @@ def validate_ledger_for_phase_close(
 def effective_workflow_policy(
     workflow: dict[str, Any], change_dir: Path
 ) -> dict[str, Any]:
-    """Overlay a classified change's per-phase gate requirements."""
-    path = change_dir / "meta" / "gate-policy.json"
-    if not path.is_file():
+    """Overlay a classified change's per-phase gate requirements.
+
+    权威切换（2026-08）：经 ``harness_paths.load_change_gate_policy`` 读取——
+    v2 发布快照（meta/plan-profile.json）优先，classify 工作副本回退。
+    返回值保持与历史一致的纯净 workflow 形状；source/drift 由需要记录的
+    调用方另行调用 ``load_change_gate_policy`` 获取（见 gate begin 路径）。
+    """
+    loaded = hp.load_change_gate_policy(change_dir)
+    document = loaded.get("policy")
+    if document is None:
         return workflow
-    document = json.loads(path.read_text(encoding="utf-8"))
     if not isinstance(document, dict) or document.get("schemaVersion") != 1:
         raise ValueError("gate-policy.json must be a schemaVersion 1 object")
     by_phase = document.get("requiredValidationsByPhase")
@@ -1334,7 +1360,7 @@ def _apply_required_gate_contract(
         if stage_name == "package":
             dependencies = [
                 f"validation:{item}" for item in required
-                if validation_phases.get(item) in {"run", "test"}
+                if hp.resolve_phase_name(validation_phases.get(item)) == "execute"
             ]
         elif stage_name == "apidoc" and "apiTest" in required_set:
             dependencies = ["validation:apiTest"]
@@ -1364,7 +1390,7 @@ def classify_risk(
     workflow: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     # 无风险信号时的起步档。曾经是 full，于是每个普通变更都默认背上
-    # plan→run→test→review→submit→archive 六阶段和 apiTest；风险信号推断只在
+    # plan→execute→review→submit→archive 五阶段和 apiTest；风险信号推断只在
     # --stage post-run 下跑，而生产流程没有任何地方调用它，起步值实际就是终值。
     # standard 保留 compile/unitTest/unitTestFull 的证据闭环，只去掉默认的
     # review 阶段与 apiTest。下面的单调升级逻辑不变，有信号照样升到 full。
@@ -1803,7 +1829,7 @@ def append_phase_event(
             trigger=("fixback" if fixback or "fixback" in note.lower() else None),
             from_phase=(
                 "review"
-                if phase == "run" and (fixback or "fixback" in note.lower())
+                if phase == "execute" and (fixback or "fixback" in note.lower())
                 else None
             ),
             result_status=None,
@@ -1940,7 +1966,7 @@ def validate_context_for_gate_begin(
     if not isinstance(current, dict):
         return {"ok": True, "code": "CONTEXT_LEGACY_COMPATIBLE"}
     current_phase = str(current.get("phase") or view.get("currentPhase") or "")
-    if current_phase != phase:
+    if hp.resolve_phase_name(current_phase) != phase:
         return {
             "ok": False,
             "code": "CONTEXT_HANDOFF_REQUIRED",
@@ -1954,11 +1980,11 @@ def validate_context_for_gate_begin(
         begin_items = begins if isinstance(begins, list) else []
         acknowledged = any(
             isinstance(item, dict)
-            and item.get("phase") == phase
+            and hp.resolve_phase_name(item.get("phase")) == phase
             and item.get("receiptHash") == receipt_hash
             for item in begin_items
         )
-        if latest.get("toPhase") != phase or not acknowledged:
+        if hp.resolve_phase_name(latest.get("toPhase")) != phase or not acknowledged:
             return {
                 "ok": False,
                 "code": "CONTEXT_BEGIN_REQUIRED",
@@ -1970,7 +1996,7 @@ def validate_context_for_gate_begin(
 
 def _phase_event_exists(change_dir: Path, phase: str, type_: str, run_id: str) -> bool:
     return any(
-        event.get("phase") == phase
+        hp.resolve_phase_name(event.get("phase")) == phase
         and event.get("type") == type_
         and event.get("run_id") == run_id
         for event in he.load_events(he.events_path(change_dir))
@@ -1983,7 +2009,10 @@ def _latest_phase_end(
     run_id: str | None = None,
 ) -> dict[str, Any] | None:
     for event in reversed(he.load_events(he.events_path(change_dir))):
-        if event.get("phase") != phase or event.get("type") != "phase.end":
+        if (
+            hp.resolve_phase_name(event.get("phase")) != phase
+            or event.get("type") != "phase.end"
+        ):
             continue
         if run_id and event.get("run_id") != run_id:
             continue
@@ -2001,7 +2030,7 @@ def _latest_open_run_id(change_dir: Path, phase: str) -> str | None:
     started: list[str] = []
     ended: set[str] = set()
     for event in he.load_events(he.events_path(change_dir)):
-        if event.get("phase") != phase:
+        if hp.resolve_phase_name(event.get("phase")) != phase:
             continue
         run_id = str(event.get("run_id") or "")
         if not run_id:
@@ -2047,12 +2076,15 @@ def _close_context_handoff(
     to_phase = getattr(args, "to_phase", None)
     if not to_phase:
         return None
+    # 写边界归一：旧名（--to-phase test）落 canonical；未知名交给
+    # close_transition 的 PHASE_UNKNOWN 报错，不在此吞掉。
+    to_phase = hp.resolve_phase_name(to_phase) or str(to_phase)
     try:
         return hctx.close_transition(
             project,
             change_id,
             from_phase=args.phase,
-            to_phase=str(to_phase),
+            to_phase=to_phase,
             executor=getattr(args, "executor", None),
             artifacts=list(getattr(args, "artifact", None) or []),
             status=status,
@@ -2081,6 +2113,10 @@ def _scenario_owner_phase_rank(owner_phase: str | None) -> int | None:
     if not owner_phase:
         return None
     normalized = str(owner_phase).strip().lower()
+    # 旧 manifest 的 ownerPhase=run/test 经别名表归一到 execute 后再定秩。
+    resolved = hp.resolve_phase_name(normalized)
+    if resolved is not None:
+        normalized = resolved
     if normalized not in hpf.VALID_OWNER_PHASES:
         return None
     try:
@@ -2514,8 +2550,32 @@ def validate_review_outputs_for_close(
     }
 
 
+def _normalize_gate_phase(args: argparse.Namespace, as_json: bool) -> int | None:
+    """cmd_begin/cmd_close 入口归一：旧名（run/test）映射到现阶段名。
+
+    归一后 args.phase 全链路只流动 canonical 名；未知名报错并列出合法名与别名。
+    """
+    resolved = hp.resolve_phase_name(getattr(args, "phase", None))
+    if resolved is not None:
+        args.phase = resolved
+        return None
+    return emit_error(
+        "PHASE_UNKNOWN",
+        f"未知阶段名 {getattr(args, 'phase', None)!r}；合法阶段 "
+        f"{list(hp.WORKFLOW_PHASES)}，旧名别名 {hp.LEGACY_PHASE_ALIASES}。",
+        as_json=as_json,
+        extra={
+            "allowedPhases": list(hp.WORKFLOW_PHASES),
+            "legacyAliases": dict(hp.LEGACY_PHASE_ALIASES),
+        },
+    )
+
+
 def cmd_begin(args: argparse.Namespace) -> int:
     as_json = bool(args.json)
+    normalized = _normalize_gate_phase(args, as_json)
+    if normalized is not None:
+        return normalized
     project = hc.resolve_main_project_root()
     resolved = hc.resolve_change(project, args.change)
     if not resolved.get("ok"):
@@ -2646,7 +2706,9 @@ def cmd_begin(args: argparse.Namespace) -> int:
     current_lease = hc.inspect_lease(project, resolved["changeId"])
     run_id = explicit_run_id or (
         str(current_lease.get("runId"))
-        if isinstance(current_lease, dict) and current_lease.get("phase") == args.phase
+        if isinstance(current_lease, dict) and (
+            hp.resolve_phase_name(current_lease.get("phase")) == args.phase
+        )
         else "run-" + uuid.uuid4().hex
     )
     try:
@@ -2870,6 +2932,9 @@ def cmd_begin(args: argparse.Namespace) -> int:
 
 def cmd_close(args: argparse.Namespace) -> int:
     as_json = bool(args.json)
+    normalized = _normalize_gate_phase(args, as_json)
+    if normalized is not None:
+        return normalized
     project = hc.resolve_main_project_root()
     resolved = hc.resolve_change(project, args.change)
     if not resolved.get("ok"):
@@ -2940,7 +3005,7 @@ def cmd_close(args: argparse.Namespace) -> int:
         if (
             expired_run_id
             and expired_run_id == expected_run_id
-            and str(expired_lease.get("phase") or "") == args.phase
+            and hp.resolve_phase_name(expired_lease.get("phase")) == args.phase
         ):
             reacquired = hc.claim_lease(
                 project,
@@ -3042,7 +3107,9 @@ def cmd_close(args: argparse.Namespace) -> int:
             },
         )
     run_id = explicit_run_id or str(current_lease.get("runId") or "")
-    if str(current_lease.get("runId")) != run_id or str(current_lease.get("phase")) != args.phase:
+    if str(current_lease.get("runId")) != run_id or (
+        hp.resolve_phase_name(current_lease.get("phase")) != args.phase
+    ):
         return emit_error(
             "LEASE_OWNER_MISMATCH",
             "active lease does not match close phase/run-id",

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

@@ -202,14 +202,16 @@ def frozen_ownership_check(change_dir: Path) -> dict[str, Any]:
     if not capsule_root.is_dir():
         return {"ok": True, "code": "OWNERSHIP_FREEZE_NOT_APPLICABLE"}
     capsules: list[dict[str, Any]] = []
-    for path in capsule_root.glob("run-*.json"):
+    # capsule 文件名是 <phase>-<hash>.json；execute 合并（run/test→execute）后
+    # 新旧两批名字都可能躺在在途 change 里，按内容归一判定而不是按文件名。
+    for path in capsule_root.glob("*.json"):
         try:
             item = json.loads(path.read_text(encoding="utf-8-sig"))
         except (OSError, json.JSONDecodeError):
             continue
         if (
             isinstance(item, dict)
-            and item.get("phase") == "run"
+            and harness_paths.resolve_phase_name(item.get("phase")) == "execute"
             and not item.get("closedAt")
             and _nonempty_str(item.get("ownershipHash"))
         ):

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

@@ -42,8 +42,7 @@ CHANGE_CONTEXT_REL = Path("meta") / "change-context.json"
 # "unsupported reconcile target phase"。同一份事实不该有两个副本。
 WORKFLOW_PHASES = (
     "plan",
-    "run",
-    "test",
+    "execute",
     "review",
     "package",
     "apidoc",
@@ -68,9 +67,11 @@ KNOWN_NON_WORKFLOW_PHASES = frozenset({
 })
 
 # 旧阶段名 → 现阶段名。阶段合并/改名时在这里登记，读时映射即可让历史
-# gate-policy.json 与 plannedPhases 继续可读，不必迁移已落盘的 change。
-# 目前为空：还没有发生过阶段改名。
-LEGACY_PHASE_ALIASES: dict[str, str] = {}
+# gate-policy.json、plannedPhases 与已落盘 transitions 继续可读，不必迁移
+# 已落盘的 change。注意：映射只能用在哈希校验之后的业务比较层——对已哈希
+# 的 receipt 先映射再重算会断 _payload_hash 链。
+# 2026-08 run+test 合并为 execute（方案 c，review 保留独立阶段）。
+LEGACY_PHASE_ALIASES: dict[str, str] = {"run": "execute", "test": "execute"}
 
 
 def resolve_phase_name(phase: Any) -> str | None:
@@ -230,6 +231,120 @@ def load_change_contract(contract_dir: Path) -> dict[str, Any]:
     return data
 
 
+def _unpack_v2_gate_policy(wrapper: Any) -> dict[str, Any] | None:
+    """meta/plan-profile.json（v2 包装体）→ Python schemaVersion:1 形状。
+
+    门禁权威所需的四个字段（mode/planned_phases/required_gate_dag/
+    required_validations_by_phase）缺一即视为不完整快照（0.2.92-era 的发布
+    没有门禁 overlay），调用方回退工作副本。返回 None 表示不可用作权威。
+    """
+    if not isinstance(wrapper, dict):
+        return None
+    if wrapper.get("artifact_type") != "gate_policy":
+        return None
+    content = wrapper.get("content")
+    if not isinstance(content, dict):
+        return None
+    planned = content.get("planned_phases")
+    dag = content.get("required_gate_dag")
+    by_phase = content.get("required_validations_by_phase")
+    if (
+        not isinstance(content.get("mode"), str)
+        or not (isinstance(planned, list) and all(isinstance(p, str) for p in planned))
+        or not isinstance(dag, dict)
+        or not isinstance(by_phase, dict)
+    ):
+        return None
+    policy: dict[str, Any] = {
+        "schemaVersion": 1,
+        "tier": content.get("tier"),
+        "source": content.get("source"),
+        "plannedPhases": list(planned),
+        "requiredValidations": list(content.get("required_validations") or []),
+        "requiredValidationsByPhase": dict(by_phase),
+        "requiredGateDag": dict(dag),
+    }
+    return policy
+
+
+def load_change_gate_policy(change_dir: Path) -> dict[str, Any]:
+    """v2-first 的每 change 门禁策略加载（权威切换 2026-08）。
+
+    meta/plan-profile.json（v2 发布快照，门禁字段已哈希绑定）优先于
+    meta/gate-policy.json（classify 在 0.5 写的工作副本）。v2 快照不完整
+    或缺失 → 回退工作副本。两者并存且 plannedPhases（canonical 归一去重
+    后）不一致 → drift 报告，策略以 v2 为准（已审批定稿 > 工作副本；
+    发布后改写工作副本本身就是异常）。
+
+    返回 ``{"policy": <schemaVersion:1 dict 或 None>, "source":
+    "v2-plan-profile" | "gate-policy-json" | None, "drift": dict | None,
+    "working_error": bool}``——``working_error`` 区分"工作副本不存在"与
+    "存在但不可读"（`_phase_plan` 的 legacy:policy-unreadable 语义靠它）。
+    """
+    change_dir = Path(change_dir)
+    v2_policy: dict[str, Any] | None = None
+    v2_path = change_dir / "meta" / "plan-profile.json"
+    if v2_path.is_file():
+        try:
+            v2_policy = _unpack_v2_gate_policy(
+                json.loads(v2_path.read_text(encoding="utf-8-sig"))
+            )
+        except (OSError, ValueError, json.JSONDecodeError):
+            v2_policy = None
+
+    working: dict[str, Any] | None = None
+    working_error = False
+    working_path = change_dir / "meta" / "gate-policy.json"
+    if working_path.is_file():
+        try:
+            candidate = json.loads(working_path.read_text(encoding="utf-8-sig"))
+            # 工作副本保持与历史一致的宽松接受：任何 dict 都交给下游各自的
+            # 形状校验（effective_workflow_policy 查 schemaVersion，reconcile
+            # 查 requiredGateDag），加载器不提前收紧。
+            if isinstance(candidate, dict):
+                working = candidate
+            else:
+                working_error = True
+        except (OSError, ValueError, json.JSONDecodeError):
+            working_error = True
+
+    drift: dict[str, Any] | None = None
+    if v2_policy is not None and working is not None:
+        canonical = lambda names: sorted(
+            {name for raw in (names or []) if (name := resolve_phase_name(raw))}
+        )
+        v2_phases = canonical(v2_policy.get("plannedPhases"))
+        working_phases = canonical(working.get("plannedPhases"))
+        if v2_phases != working_phases:
+            drift = {
+                "kind": "plannedPhases",
+                "v2": v2_phases,
+                "gate_policy_json": working_phases,
+                "resolution": "v2-plan-profile wins (approved publication snapshot)",
+            }
+
+    if v2_policy is not None:
+        return {
+            "policy": v2_policy,
+            "source": "v2-plan-profile",
+            "drift": drift,
+            "working_error": working_error,
+        }
+    if working is not None:
+        return {
+            "policy": working,
+            "source": "gate-policy-json",
+            "drift": None,
+            "working_error": False,
+        }
+    return {
+        "policy": None,
+        "source": None,
+        "drift": None,
+        "working_error": working_error,
+    }
+
+
 def contract_layout_kind(contract: dict[str, Any]) -> str:
     """``split-v1`` when the contract declares a separate runtime root."""
     ownership = contract.get("stateOwnership")

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

@@ -37,12 +37,12 @@ CI_METRICS_SCHEMA_VERSION = 1
 # 一份拷贝，少了 merge，worktree 变更走到 merge 就在 target_required_dag 里硬 raise。
 PHASE_ORDER = hpaths.WORKFLOW_PHASES
 VALIDATION_PHASES = {
-    "compile": "run",
-    "unitTest": "run",
-    "unitTestFull": "test",
-    "apiTest": "test",
-    "browserTest": "test",
-    "dbCompatibility": "test",
+    "compile": "execute",
+    "unitTest": "execute",
+    "unitTestFull": "execute",
+    "apiTest": "execute",
+    "browserTest": "execute",
+    "dbCompatibility": "execute",
     "package": "package",
 }
 FINAL_SEQUENCE_RECEIPTS_REL = (
@@ -76,10 +76,11 @@ def _write_json(path: Path, value: Any) -> None:
 
 
 def _final_sequence_contract(change_dir: Path) -> dict[str, Any] | None:
-    policy_path = change_dir / "meta" / "gate-policy.json"
-    if not policy_path.is_file():
+    # 权威切换（2026-08）：v2 发布快照优先，classify 工作副本回退。
+    loaded = hpaths.load_change_gate_policy(change_dir)
+    policy = loaded.get("policy")
+    if policy is None:
         return None
-    policy = _read_json(policy_path)
     declared = policy.get("finalSequence")
     if isinstance(declared, dict) and isinstance(declared.get("nodeIds"), list):
         return declared
@@ -786,6 +787,13 @@ def select_phase_capsule(
             "message": f"invalid phase selector: {phase}",
             "remediation": "pass the phase name emitted by harness_gate.py begin",
         }
+    # 在途 change 的 capsule 可能按旧名（run/test）写入：归一后按 canonical
+    # 优先、旧名兜底查找。新写一律 canonical。
+    phase = hpaths.resolve_phase_name(phase) or phase
+    phase_names = [phase] + [
+        legacy for legacy, canonical in hpaths.LEGACY_PHASE_ALIASES.items()
+        if canonical == phase
+    ]
     state_dir = hpaths.resolve_state_dir_for_contract(change_dir, project_root)
     capsule_dir = state_dir / "runtime" / "phase-context"
     candidates = (
@@ -793,7 +801,7 @@ def select_phase_capsule(
             path
             for path in capsule_dir.iterdir()
             if path.is_file()
-            and path.name.startswith(f"{phase}-")
+            and any(path.name.startswith(f"{name}-") for name in phase_names)
             and path.suffix == ".json"
         ]
         if capsule_dir.is_dir()
@@ -813,14 +821,20 @@ def select_phase_capsule(
             "message": f"{len(candidates)} capsule(s) exist for phase {phase}",
             "remediation": f"rerun reconcile with --phase {phase} --run-id <run-id>",
         }
-    key = hashlib.sha256(f"{phase}\0{run_id}".encode("utf-8")).hexdigest()[:20]
-    path = capsule_dir / f"{phase}-{key}.json"
-    if not path.is_file():
+    path: Path | None = None
+    for name in phase_names:
+        key = hashlib.sha256(f"{name}\0{run_id}".encode("utf-8")).hexdigest()[:20]
+        candidate = capsule_dir / f"{name}-{key}.json"
+        if candidate.is_file():
+            path = candidate
+            break
+    if path is None:
+        key = hashlib.sha256(f"{phase}\0{run_id}".encode("utf-8")).hexdigest()[:20]
         return {
             "ok": False,
             "code": "PHASE_CAPSULE_NOT_FOUND",
             "message": f"no capsule for phase {phase} and run-id {run_id}",
-            "expectedPath": str(path),
+            "expectedPath": str(capsule_dir / f"{phase}-{key}.json"),
             "remediation": f"begin/resume the phase or verify --phase {phase} --run-id {run_id}",
         }
     try:
@@ -833,7 +847,10 @@ def select_phase_capsule(
             "path": str(path),
             "remediation": f"repair or resume the capsule for --phase {phase} --run-id {run_id}",
         }
-    if capsule.get("phase") != phase or capsule.get("runId") != run_id:
+    if (
+        hpaths.resolve_phase_name(capsule.get("phase")) != phase
+        or capsule.get("runId") != run_id
+    ):
         return {
             "ok": False,
             "code": "PHASE_CAPSULE_IDENTITY_MISMATCH",
@@ -1368,7 +1385,14 @@ def reconcile(
 ) -> dict[str, Any]:
     change_dir = change_dir.resolve()
     project_root = project_root.resolve()
-    policy = _read_json(change_dir / "meta" / "gate-policy.json")
+    # 权威切换（2026-08）：v2 发布快照优先，classify 工作副本回退。
+    loaded = hpaths.load_change_gate_policy(change_dir)
+    policy = loaded.get("policy")
+    if policy is None:
+        raise ValueError(
+            "gate policy missing; run harness_gate.py classify "
+            "or publish via plan finalize"
+        )
     dag = (
         target_required_dag(policy, target_phase)
         if target_phase is not None
@@ -1633,7 +1657,7 @@ def build_parser() -> argparse.ArgumentParser:
     reconcile_parser.add_argument("--json", action="store_true")
     reconcile_parser.add_argument("--output")
     reconcile_parser.add_argument("--close", action="store_true")
-    reconcile_parser.add_argument("--phase", default="run")
+    reconcile_parser.add_argument("--phase", default="execute")
     reconcile_parser.add_argument("--run-id")
     reconcile_parser.set_defaults(func=_cmd_reconcile)