@mc-and-his-agents/loom-installer 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mc-and-his-agents/loom-installer",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Node installer for Loom plugin and single-skill installation surfaces.",
   "type": "module",
   "bin": {

package/payload/manifest.json

@@ -2,9 +2,9 @@
   "schema_version": "loom-installer-payload/v1",
   "loom_version": "0.4.0",
   "source_repository": "https://github.com/MC-and-his-Agents/Loom",
-  "source_commit": "4f6a4074d02557304018e9f063425f974d6a08cf",
+  "source_commit": "b07d54d4963a674da0ff2397f4ad244cb3028584",
   "source_ref": "main",
-  "built_at": "2026-04-25T11:49:46+08:00",
+  "built_at": "2026-04-25T12:04:56+08:00",
   "runtime": {
     "python_minimum": "3.10",
     "python_recommended": "3.11+"
@@ -628,13 +628,13 @@
     },
     {
       "path": "plugin/loom/skills/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "plugin/loom/skills/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "plugin/loom/skills/shared/scripts/loom_init.py",
@@ -1213,13 +1213,13 @@
     },
     {
       "path": "skills/loom-adopt/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-adopt/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-adopt/.loom-runtime/shared/scripts/loom_init.py",
@@ -1828,13 +1828,13 @@
     },
     {
       "path": "skills/loom-handoff/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-handoff/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-handoff/.loom-runtime/shared/scripts/loom_init.py",
@@ -2443,13 +2443,13 @@
     },
     {
       "path": "skills/loom-init/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-init/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-init/.loom-runtime/shared/scripts/loom_init.py",
@@ -3063,13 +3063,13 @@
     },
     {
       "path": "skills/loom-merge-ready/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-merge-ready/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-merge-ready/.loom-runtime/shared/scripts/loom_init.py",
@@ -3678,13 +3678,13 @@
     },
     {
       "path": "skills/loom-pre-review/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-pre-review/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-pre-review/.loom-runtime/shared/scripts/loom_init.py",
@@ -4293,13 +4293,13 @@
     },
     {
       "path": "skills/loom-resume/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-resume/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-resume/.loom-runtime/shared/scripts/loom_init.py",
@@ -4908,13 +4908,13 @@
     },
     {
       "path": "skills/loom-retire/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-retire/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-retire/.loom-runtime/shared/scripts/loom_init.py",
@@ -5523,13 +5523,13 @@
     },
     {
       "path": "skills/loom-review/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-review/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-review/.loom-runtime/shared/scripts/loom_init.py",
@@ -6138,13 +6138,13 @@
     },
     {
       "path": "skills/loom-spec-review/.loom-runtime/shared/scripts/loom_check.py",
-      "bytes": 253737,
-      "sha256": "9ada27e8f88d01940e7f70112301f1c6c78ffa362f5159abba2a44ae445266ac"
+      "bytes": 260856,
+      "sha256": "9f9b145158d659764c853f7234dfb7308c96e78031f43741e431905b91a6b7fc"
     },
     {
       "path": "skills/loom-spec-review/.loom-runtime/shared/scripts/loom_flow.py",
-      "bytes": 259768,
-      "sha256": "f11062993fe565160cdc2910e981e9a601d0fcafcbe16dd0072d63acf39d67b0"
+      "bytes": 262117,
+      "sha256": "ec49996bbebb9a59fee0f906d301c2c66e13e17ec548ef762f2b0e33e9abbe32"
     },
     {
       "path": "skills/loom-spec-review/.loom-runtime/shared/scripts/loom_init.py",

package/payload/plugin/loom/skills/shared/scripts/loom_check.py

@@ -92,7 +92,9 @@ CORE_DOCS = (
     "docs/methodology/templates/pull-request.md",
     "docs/evidence/extraction-ledger.md",
     "docs/evidence/landing-map.md",
+    "docs/evidence/validations/validation-closeout-reconciliation-blocking-gate.md",
     "docs/evidence/validations/validation-loom-core-runtime-parity.md",
+    "docs/evidence/validations/validation-shadow-parity-blocking-gate.md",
     "docs/evidence/validations/validation-syvert-strong-governance-parity.md",
     "docs/adoption/rationale.md",
     "docs/adoption/routing-and-checkpoints.md",
@@ -968,10 +970,17 @@ def require_shadow_parity_payload(
         return
     if payload.get("command") != "shadow-parity":
         failures.append(Failure(category, f"{context} must report `command: shadow-parity`"))
-    if payload.get("result") not in {"pass", "warn"}:
-        failures.append(Failure(category, f"{context} result must be `pass` or `warn`"))
-    if payload.get("fallback_to") is not None:
-        failures.append(Failure(category, f"{context} fallback_to must remain `null`"))
+    mode = payload.get("mode", "validation-only")
+    if mode not in {"validation-only", "blocking"}:
+        failures.append(Failure(category, f"{context} mode must be `validation-only` or `blocking`"))
+    if payload.get("blocking") != (mode == "blocking"):
+        failures.append(Failure(category, f"{context} blocking flag must match mode"))
+    allowed_results = {"pass", "block"} if mode == "blocking" else {"pass", "warn"}
+    if payload.get("result") not in allowed_results:
+        failures.append(Failure(category, f"{context} result must stay within the stable mode-specific contract"))
+    expected_fallbacks = {"manual-reconciliation"} if payload.get("result") == "block" else {None}
+    if payload.get("fallback_to") not in expected_fallbacks:
+        failures.append(Failure(category, f"{context} fallback_to must match the shadow parity enforcement mode"))
     if not isinstance(payload.get("summary"), str) or not payload.get("summary"):
         failures.append(Failure(category, f"{context} must include non-empty `summary`"))
     if not isinstance(payload.get("missing_inputs"), list):
@@ -1007,6 +1016,14 @@ def require_shadow_parity_payload(
             failures.append(Failure(category, f"{context} reports[{index}] must declare a known surface"))
         if report.get("result") not in {"match", "mismatch", "unreadable"}:
             failures.append(Failure(category, f"{context} reports[{index}] result must stay within the stable contract"))
+        if report.get("classification") not in {None, "drift", "gate_failure"}:
+            failures.append(Failure(category, f"{context} reports[{index}] classification must stay within the stable contract"))
+        if not isinstance(report.get("blocking"), bool):
+            failures.append(Failure(category, f"{context} reports[{index}] must include boolean `blocking`"))
+        if not isinstance(report.get("recommended_action"), str) or not report.get("recommended_action"):
+            failures.append(Failure(category, f"{context} reports[{index}] must include non-empty `recommended_action`"))
+        if mode == "blocking" and report.get("result") != "match" and report.get("blocking") is not True:
+            failures.append(Failure(category, f"{context} reports[{index}] must block non-matching reports in blocking mode"))
         if not isinstance(report.get("summary"), str) or not report.get("summary"):
             failures.append(Failure(category, f"{context} reports[{index}] must include non-empty `summary`"))
         if not isinstance(report.get("missing_inputs"), list):
@@ -1118,10 +1135,14 @@ def require_reconciliation_payload(
         if not isinstance(finding, dict):
             failures.append(Failure(category, f"{context} reconciliation findings must be JSON objects"))
             continue
-        if finding.get("kind") not in {"absorbed_but_open", "parent_drift", "project_drift"}:
+        if finding.get("category") not in {"drift", "gate_failure"}:
+            failures.append(Failure(category, f"{context} reconciliation finding category must stay within the stable taxonomy"))
+        if finding.get("kind") not in {"merged_but_open", "absorbed_but_open", "parent_drift", "project_drift", "host_signal_drift"}:
             failures.append(Failure(category, f"{context} reconciliation finding kind must stay within the stable contract"))
         if finding.get("severity") not in {"warn", "fix-needed", "block"}:
             failures.append(Failure(category, f"{context} reconciliation finding severity must stay within the stable contract"))
+        if finding.get("fallback_to") not in {"reconciliation-sync", "manual-reconciliation", None}:
+            failures.append(Failure(category, f"{context} reconciliation finding fallback_to must stay within the stable contract"))
         if not isinstance(finding.get("subject"), str) or not finding.get("subject"):
             failures.append(Failure(category, f"{context} reconciliation findings must include non-empty `subject`"))
         if not isinstance(finding.get("evidence"), dict):
@@ -4692,18 +4713,20 @@ def check_daily_execution_cli(root: Path) -> list[Failure]:
                 "summary": "warn",
                 "missing_inputs": [],
                 "fallback_to": "manual-reconciliation",
-                "findings": [
-                    {
-                        "kind": "project_drift",
-                        "severity": "warn",
-                        "subject": "project 5",
-                        "evidence": {},
-                        "recommended_action": "review warning",
-                    }
-                ],
+                    "findings": [
+                        {
+                            "category": "drift",
+                            "kind": "project_drift",
+                            "severity": "warn",
+                            "subject": "project 5",
+                            "evidence": {},
+                            "recommended_action": "review warning",
+                            "fallback_to": "reconciliation-sync",
+                        }
+                    ],
+                },
             },
-        },
-    )
+        )
     if warn_payload_failures:
         failures.append(
             Failure(
@@ -4712,6 +4735,50 @@ def check_daily_execution_cli(root: Path) -> list[Failure]:
             )
         )
 
+    valid_reconciliation_samples = [
+        ("merged_but_open", "fix-needed", "reconciliation-sync"),
+        ("absorbed_but_open", "fix-needed", "reconciliation-sync"),
+        ("parent_drift", "block", "manual-reconciliation"),
+        ("host_signal_drift", "block", "manual-reconciliation"),
+    ]
+    for kind, reconciliation_result_value, fallback_to in valid_reconciliation_samples:
+        sample_failures = []
+        require_closeout_reconciliation_contract(
+            sample_failures,
+            category="daily-execution-cli",
+            context=f"`closeout-{kind}`",
+            payload={
+                "result": "block",
+                "fallback_to": fallback_to,
+                "reconciliation": {
+                    "command": "reconciliation",
+                    "operation": "audit",
+                    "result": reconciliation_result_value,
+                    "summary": kind,
+                    "missing_inputs": [] if kind != "host_signal_drift" else ["github control plane"],
+                    "fallback_to": "manual-reconciliation",
+                    "findings": [
+                        {
+                            "category": "drift",
+                            "kind": kind,
+                            "severity": reconciliation_result_value,
+                            "subject": "closeout sample",
+                            "evidence": {},
+                            "recommended_action": "reconcile closeout sample",
+                            "fallback_to": fallback_to,
+                        }
+                    ],
+                },
+            },
+        )
+        if sample_failures:
+            failures.append(
+                Failure(
+                    "daily-execution-cli",
+                    f"`closeout-{kind}` synthetic payload must satisfy closeout reconciliation validation",
+                )
+            )
+
     return failures
 
 
@@ -5250,6 +5317,23 @@ def check_repo_interop_contracts(root: Path) -> list[Failure]:
             if parity_payload.get("result") != "pass":
                 failures.append(Failure("repo-interop", "`shadow-parity` must pass when all declared surfaces match"))
 
+        blocking_match_payload, error = load_command_json(
+            root,
+            ["python3", "tools/loom_flow.py", "shadow-parity", "--target", str(present_target), "--blocking"],
+        )
+        if error:
+            failures.append(Failure("repo-interop", f"`shadow-parity --blocking` match sample failed: {error}"))
+        else:
+            require_shadow_parity_payload(
+                failures,
+                category="repo-interop",
+                context="`shadow-parity --blocking` match sample",
+                payload=blocking_match_payload,
+                expected_reports=4,
+            )
+            if blocking_match_payload.get("result") != "pass":
+                failures.append(Failure("repo-interop", "`shadow-parity --blocking` must pass when all declared surfaces match"))
+
         mismatch_target = base / "mismatch"
         shutil.copytree(present_target, mismatch_target)
         write_json(mismatch_target / ".loom/shadow/review-repo.json", {"decision": "block"})
@@ -5271,6 +5355,62 @@ def check_repo_interop_contracts(root: Path) -> list[Failure]:
             if not isinstance(reports, list) or not reports or reports[0].get("result") != "mismatch":
                 failures.append(Failure("repo-interop", "`shadow-parity` mismatch sample must report `mismatch`"))
 
+        blocking_mismatch_payload, error = load_command_json(
+            root,
+            [
+                "python3",
+                "tools/loom_flow.py",
+                "shadow-parity",
+                "--target",
+                str(mismatch_target),
+                "--surface",
+                "review",
+                "--mode",
+                "blocking",
+            ],
+        )
+        if error:
+            failures.append(Failure("repo-interop", f"`shadow-parity --mode blocking` mismatch sample failed: {error}"))
+        else:
+            require_shadow_parity_payload(
+                failures,
+                category="repo-interop",
+                context="`shadow-parity --mode blocking` mismatch sample",
+                payload=blocking_mismatch_payload,
+                expected_reports=1,
+            )
+            if blocking_mismatch_payload.get("result") != "block":
+                failures.append(Failure("repo-interop", "`shadow-parity --mode blocking` must block mismatches"))
+
+        unreadable_target = base / "unreadable"
+        shutil.copytree(present_target, unreadable_target)
+        (unreadable_target / ".loom/shadow/closeout-repo.json").unlink()
+        blocking_unreadable_payload, error = load_command_json(
+            root,
+            [
+                "python3",
+                "tools/loom_flow.py",
+                "shadow-parity",
+                "--target",
+                str(unreadable_target),
+                "--surface",
+                "closeout",
+                "--blocking",
+            ],
+        )
+        if error:
+            failures.append(Failure("repo-interop", f"`shadow-parity --blocking` unreadable sample failed: {error}"))
+        else:
+            require_shadow_parity_payload(
+                failures,
+                category="repo-interop",
+                context="`shadow-parity --blocking` unreadable sample",
+                payload=blocking_unreadable_payload,
+                expected_reports=1,
+            )
+            if blocking_unreadable_payload.get("result") != "block":
+                failures.append(Failure("repo-interop", "`shadow-parity --blocking` must block unreadable surfaces"))
+
     return failures
 
 

package/payload/plugin/loom/skills/shared/scripts/loom_flow.py

@@ -276,6 +276,17 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
         default=".loom/bootstrap/init-result.json",
         help="Init-result path relative to the target root",
     )
+    shadow.add_argument(
+        "--mode",
+        choices=("validation-only", "blocking"),
+        default="validation-only",
+        help="Shadow parity enforcement mode; defaults to validation-only.",
+    )
+    shadow.add_argument(
+        "--blocking",
+        action="store_true",
+        help="Shortcut for --mode blocking. This is explicit opt-in and never the default.",
+    )
 
     runtime_parity = subparsers.add_parser(
         "runtime-parity",
@@ -543,8 +554,11 @@ def shadow_parity_report(
     empty_report = {
         "surface": surface,
         "result": "unreadable",
+        "classification": "gate_failure",
+        "blocking": False,
         "summary": "shadow parity could not be evaluated for this surface.",
         "missing_inputs": [],
+        "recommended_action": "restore the declared Loom and repo-native shadow parity locators before treating this surface as authoritative.",
         "host_adapters": [],
         "repo_native_carriers": [],
         "loom_surface": {
@@ -633,8 +647,11 @@ def shadow_parity_report(
         return {
             "surface": surface,
             "result": "match",
+            "classification": None,
+            "blocking": False,
             "summary": "Loom and repo-native surfaces report the same normalized result.",
             "missing_inputs": [],
+            "recommended_action": "no shadow parity action required.",
             "host_adapters": relevant_host_adapters,
             "repo_native_carriers": relevant_repo_native_carriers,
             "loom_surface": loom_surface,
@@ -643,8 +660,11 @@ def shadow_parity_report(
     return {
         "surface": surface,
         "result": "mismatch",
+        "classification": "drift",
+        "blocking": False,
         "summary": "Loom and repo-native surfaces disagree on the normalized result.",
         "missing_inputs": [],
+        "recommended_action": "resolve the parity mismatch or explicitly choose the authoritative surface outside repo interop before enabling blocking consumption.",
         "host_adapters": relevant_host_adapters,
         "repo_native_carriers": relevant_repo_native_carriers,
         "loom_surface": loom_surface,
@@ -3748,13 +3768,19 @@ def make_reconciliation_finding(
     subject: str,
     evidence: dict[str, Any],
     recommended_action: str,
+    category: str = "drift",
+    fallback_to: str | None = None,
 ) -> dict[str, Any]:
+    if fallback_to is None:
+        fallback_to = "manual-reconciliation" if severity == "block" else "reconciliation-sync"
     return {
+        "category": category,
         "kind": kind,
         "severity": severity,
         "subject": subject,
         "evidence": evidence,
         "recommended_action": recommended_action,
+        "fallback_to": fallback_to,
     }
 
 
@@ -3824,13 +3850,13 @@ def reconciliation_audit_payload(
                     merge_commit_sha = oid
                     merge_commit_in_main = contains_merged_commit(target_root, merge_commit_sha)
 
-    absorbed_issue = False
+    merged_issue_open = False
     if issue_payload is not None and pr_payload is not None:
         if issue_payload.get("state") == "OPEN" and pr_payload.get("state") == "MERGED" and merge_commit_sha and merge_commit_in_main:
-            absorbed_issue = True
+            merged_issue_open = True
             findings.append(
                 make_reconciliation_finding(
-                    kind="absorbed_but_open",
+                    kind="merged_but_open",
                     severity="fix-needed",
                     subject=f"issue #{issue_number}",
                     evidence={
@@ -3840,7 +3866,7 @@ def reconciliation_audit_payload(
                         "merge_commit": merge_commit_sha,
                         "merge_commit_in_main": merge_commit_in_main,
                     },
-                    recommended_action="close the absorbed issue or run reconciliation sync after reviewing the evidence.",
+                    recommended_action="close the merged issue or run reconciliation sync after reviewing the evidence.",
                 )
             )
 
@@ -3866,7 +3892,7 @@ def reconciliation_audit_payload(
                 if child_state == "CLOSED":
                     resolved_children.append(child)
                     continue
-                if child_number == issue_number and absorbed_issue:
+                if child_number == issue_number and merged_issue_open:
                     resolved_children.append(child)
                     continue
                 unresolved_children.append(child)
@@ -3929,7 +3955,7 @@ def reconciliation_audit_payload(
             }
 
             if issue_number is not None:
-                expected_done = issue_payload is not None and (issue_payload.get("state") == "CLOSED" or absorbed_issue)
+                expected_done = issue_payload is not None and (issue_payload.get("state") == "CLOSED" or merged_issue_open)
                 if issue_item is None:
                     project_drift_details.append(
                         {
@@ -3994,12 +4020,23 @@ def reconciliation_audit_payload(
         )
 
     if missing_inputs:
+        findings.append(
+            make_reconciliation_finding(
+                kind="host_signal_drift",
+                severity="block",
+                subject="github control plane",
+                evidence={"missing_inputs": missing_inputs},
+                recommended_action="restore readable GitHub issue, PR, project, or repository signals before closeout.",
+                category="drift",
+                fallback_to="manual-reconciliation",
+            )
+        )
         result = "block"
         summary = "reconciliation audit could not complete because required GitHub inputs were missing."
     else:
         result = reconciliation_result(findings)
         summary = (
-            "reconciliation audit found no absorbed-but-open, parent-drift, or project-drift findings."
+            "reconciliation audit found no merged-but-open, absorbed-but-open, parent-drift, host-signal-drift, or project-drift findings."
             if result == "pass"
             else "reconciliation audit found GitHub drift that must be reviewed before closeout."
         )
@@ -4037,7 +4074,7 @@ def reconciliation_sync_plan(audit_payload: dict[str, Any]) -> tuple[list[dict[s
         evidence = finding.get("evidence")
         if severity != "fix-needed":
             continue
-        if kind == "absorbed_but_open":
+        if kind in {"merged_but_open", "absorbed_but_open"}:
             plan.append(
                 {
                     "kind": kind,
@@ -6105,6 +6142,7 @@ def handle_shadow_parity(args: argparse.Namespace) -> int:
     governance_surface = build_governance_surface(target_root)
     repo_interop = governance_surface.get("repo_interop")
     requested_surfaces = SHADOW_PARITY_SURFACES if args.surface == "all" else (args.surface,)
+    mode = "blocking" if args.blocking else args.mode
     reports = [
         shadow_parity_report(
             repo_interop,
@@ -6114,9 +6152,18 @@ def handle_shadow_parity(args: argparse.Namespace) -> int:
         for surface in requested_surfaces
     ]
 
-    result = "pass" if reports and all(report["result"] == "match" for report in reports) else "warn"
+    all_match = bool(reports) and all(report["result"] == "match" for report in reports)
+    blocking_reports = [report for report in reports if report.get("result") != "match"]
+    if mode == "blocking":
+        result = "pass" if all_match else "block"
+        for report in blocking_reports:
+            report["blocking"] = True
+    else:
+        result = "pass" if all_match else "warn"
     if result == "pass":
         summary = "shadow parity matches across all requested surfaces."
+    elif mode == "blocking":
+        summary = "shadow parity blocking mode found mismatch or unreadable surfaces."
     else:
         summaries = {report["result"] for report in reports}
         if "mismatch" in summaries:
@@ -6133,10 +6180,12 @@ def handle_shadow_parity(args: argparse.Namespace) -> int:
     return emit(
         {
             "command": "shadow-parity",
+            "mode": mode,
+            "blocking": mode == "blocking",
             "result": result,
             "summary": summary,
             "missing_inputs": missing_inputs,
-            "fallback_to": None,
+            "fallback_to": "manual-reconciliation" if result == "block" else None,
             "runtime_state": runtime_state,
             "governance_surface": governance_surface,
             "reports": reports,