@christang/keel 5.1.2 → 5.2.1

package/scripts/validate_plugin.py

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.1.2"
-PROTOCOL_VERSION = "5.1.2"
+PACKAGE_VERSION = "5.2.1"
+PROTOCOL_VERSION = "5.2.1"
 LEGACY_MANAGED_START = "<!-- keel:start version=2.1 -->"
 OPENSPEC_SCHEMA_NAME = "keel-spec-driven"
 OPENSPEC_CONFIG_PATH = Path("openspec/config.yaml")
@@ -188,9 +188,9 @@ SKILL_DOC_REQUIREMENTS = [
             "one material decision at a time",
             "recommended answer",
             "Silence does not",
-            "references/web.md",
-            "references/hardware.md",
-            "references/hardware-dsl.md",
+            "keel/lenses/",
+            "Applies when",
+            "keel lenses add",
             "no separate alignment ledger",
         ],
     },
@@ -220,31 +220,34 @@ SKILL_DOC_REQUIREMENTS = [
         ],
     },
     {
-        # Structure only ("Material risk surface", "Durable placement"
-        # section headers); the expectation-alignment-skill scenario owns
-        # domain-keyword scoping across these three references, so the
-        # per-domain keywords are not duplicated here.
-        "name": "alignment web reference",
-        "path": "src/skills/keel-align-expectations/references/web.md",
+        # Structure only ("Applies when" self-describing header, "Material risk
+        # surface", "Execution and review checks"); the expectation-alignment-skill
+        # scenario owns domain-keyword scoping across these three lens templates,
+        # so the per-domain keywords are not duplicated here.
+        "name": "web lens template",
+        "path": "assets/lenses/web.md",
         "required": [
+            "Applies when",
             "Material risk surface",
-            "Durable placement",
+            "Execution and review checks",
         ],
     },
     {
-        "name": "alignment hardware reference",
-        "path": "src/skills/keel-align-expectations/references/hardware.md",
+        "name": "hardware lens template",
+        "path": "assets/lenses/hardware.md",
         "required": [
+            "Applies when",
             "Material risk surface",
-            "Durable placement",
+            "Execution and review checks",
         ],
     },
     {
-        "name": "alignment hardware-dsl reference",
-        "path": "src/skills/keel-align-expectations/references/hardware-dsl.md",
+        "name": "hardware-dsl lens template",
+        "path": "assets/lenses/hardware-dsl.md",
         "required": [
+            "Applies when",
             "Material risk surface",
-            "Durable placement",
+            "Execution and review checks",
         ],
     },
 ]
@@ -394,6 +397,7 @@ def validate_npm_package(errors: list[str]) -> None:
         "--doctor",
         "capabilities",
         "gate",
+        "lenses",
         "--profile",
         "--version",
         "--help",
@@ -640,6 +644,9 @@ def validate_openspec_schema(errors: list[str]) -> None:
             "provenance and license",
             "positive and negative trigger cases",
             "real-task evidence",
+            "one of pass, passed, complete, completed, ok, or done.",
+            "## Expectation Coverage",
+            "carry a durable owner",
         ):
             if required not in schema:
                 errors.append(f"OpenSpec schema.yaml missing required language: {required}")
@@ -655,12 +662,15 @@ def validate_openspec_schema(errors: list[str]) -> None:
             "Strategy:",
             "M1:",
             "Evidence:",
-            "Contract: pending task-start capsule and fingerprint",
+            "- Contract: pending",
             "Review:",
             "Status: pending",
+            "Status: one of pass, passed, complete, completed, ok, done",
             "Blocker: none",
             "Mode: diagnose-only",
             "Requires modifying files outside Touch.",
+            "## Expectation Coverage",
+            "Discard reason:",
         ):
             if required not in tasks_template:
                 errors.append(
@@ -1540,7 +1550,7 @@ def validate_expectation_completion_gates_scenario() -> int:
         "- Acceptance check:",
         "- Scope check:",
         "- Findings:",
-        "discard rationale",
+        "Discard rationale:",
     ]
     handoff_skill_snippets = [
         "keel-handoff/v1",
@@ -1606,13 +1616,13 @@ def validate_authoring_continuity_scenario() -> int:
         "keel-align-expectations",
         "risk-triggered deep path",
         "hidden-knowledge risk",
-        "domain references",
+        "domain lenses",
         "Missing authority returns to OpenSpec authoring",
     ]
     schema_snippets = [
         "risk-triggered deep",
         "hidden-knowledge assumptions",
-        "domain reference",
+        "domain lens",
     ]
     design_template_snippets = [
         "Hidden Knowledge / Assumptions",
@@ -1621,7 +1631,7 @@ def validate_authoring_continuity_scenario() -> int:
     ]
     task_template_snippets = [
         "hidden-knowledge assumption",
-        "domain profile",
+        "domain lens",
     ]
 
     checks: list[tuple[str, Path, list[str]]] = [
@@ -1740,24 +1750,23 @@ def validate_authoring_continuity_scenario() -> int:
     return 0
 
 
-def validate_domain_profiles_scenario() -> int:
+def validate_domain_lenses_scenario() -> int:
     plugin_skills_root = ROOT / PLUGIN_ROOT / "skills"
-    for expected in (
-        "keel-align-expectations/SKILL.md",
-        "keel-align-expectations/references/web.md",
-        "keel-align-expectations/references/hardware.md",
-        "keel-align-expectations/references/hardware-dsl.md",
-    ):
-        if not (plugin_skills_root / expected).is_file():
+    if not (plugin_skills_root / "keel-align-expectations/SKILL.md").is_file():
+        report("domain-lenses scenario plugin misses the alignment skill")
+        return 1
+    lenses_root = ROOT / "assets/lenses"
+    for template in ("web.md", "hardware.md", "hardware-dsl.md"):
+        if not (lenses_root / template).is_file():
             report(
-                "domain-profiles scenario plugin misses the packaged alignment "
-                f"reference set: {expected}"
+                "domain-lenses scenario misses the shipped lens template: "
+                f"{template}"
             )
             return 1
     for legacy_skill in LEGACY_PROFILE_SKILLS:
         if (plugin_skills_root / legacy_skill).exists():
             report(
-                f"domain-profiles scenario plugin packages a legacy profile: {legacy_skill}"
+                f"domain-lenses scenario plugin packages a legacy profile: {legacy_skill}"
             )
             return 1
 
@@ -1767,20 +1776,20 @@ def validate_domain_profiles_scenario() -> int:
         repo.mkdir()
         install = run_keel(repo, "--install", "--target", "codex")
         if install.returncode != 0:
-            report("domain-profiles scenario default install failed:")
+            report("domain-lenses scenario default install failed:")
             report((install.stderr or install.stdout).strip())
             return 1
         if (repo / TARGET_SKILL_ROOTS["codex"]).exists():
             report(
-                "domain-profiles scenario thin install copied Keel skill trees; "
+                "domain-lenses scenario thin install copied Keel skill trees; "
                 "skills are plugin-owned in v4."
             )
             return 1
 
         rejected = run_keel(repo, "--install", "--target", "codex", "--profile", "web")
         rejected_text = (rejected.stderr or "") + (rejected.stdout or "")
-        if rejected.returncode == 0 or "bundled" not in rejected_text:
-            report("domain-profiles scenario still accepts --profile.")
+        if rejected.returncode == 0 or "keel/lenses" not in rejected_text:
+            report("domain-lenses scenario still accepts --profile.")
             report(rejected_text.strip())
             return 1
 
@@ -1792,7 +1801,7 @@ def validate_domain_profiles_scenario() -> int:
             or "Keel profiles" in doctor_text
         ):
             report(
-                "domain-profiles scenario doctor still reports profile state or "
+                "domain-lenses scenario doctor still reports profile state or "
                 "misses the native plugin surface."
             )
             report(doctor_text.strip())
@@ -1805,11 +1814,11 @@ def validate_domain_profiles_scenario() -> int:
             else ""
         )
         if uninstall.returncode != 0 or "keel:start" in agents_text:
-            report("domain-profiles scenario uninstall left the managed bootstrap.")
+            report("domain-lenses scenario uninstall left the managed bootstrap.")
             report((uninstall.stderr or uninstall.stdout).strip())
             return 1
 
-    report("domain-profiles scenario passed.")
+    report("domain-lenses scenario passed.")
     return 0
 
 
@@ -2387,6 +2396,42 @@ def validate_update_pack_install_scenario() -> int:
     return 0
 
 
+def validate_update_default_registry_scenario() -> int:
+    with tempfile.TemporaryDirectory(prefix="keel-update-default-") as raw_tmp:
+        tmp = Path(raw_tmp)
+        update = run_keel(tmp, "--update", "--dry-run")
+        if update.returncode != 0:
+            report("update-default-registry scenario keel --update --dry-run failed:")
+            report((update.stderr or update.stdout).strip())
+            return 1
+
+        pack_plan = (
+            "would run npm pack" in update.stdout
+            or "would run npm.cmd pack" in update.stdout
+        )
+        if not pack_plan:
+            report("update-default-registry scenario did not report a pack plan.")
+            report(update.stdout.strip())
+            return 1
+        if "@christang/keel" not in update.stdout:
+            report(
+                "update-default-registry scenario default source is not the "
+                "published registry package @christang/keel."
+            )
+            report(update.stdout.strip())
+            return 1
+        if "github:" in update.stdout:
+            report(
+                "update-default-registry scenario default source is a git-type "
+                "spec; self-update must default to the registry package."
+            )
+            report(update.stdout.strip())
+            return 1
+
+    report("update-default-registry scenario passed.")
+    return 0
+
+
 def run_keel_hook(repo: Path, event: dict) -> subprocess.CompletedProcess[str]:
     env = dict(os.environ)
     env["KEEL_CLI"] = str(ROOT / "bin/keel.js")
@@ -2633,7 +2678,7 @@ def validate_cli_scenario() -> int:
         if (
             update.returncode != 0
             or not pack_plan
-            or "github:TanglmChris/keel" not in update.stdout
+            or "@christang/keel" not in update.stdout
             or not install_plan
         ):
             report("cli scenario keel --update did not report global CLI update plan.")
@@ -4508,11 +4553,23 @@ def validate_core_gates_scenario() -> int:
             "1.1",
             "--json",
         )
+        handoff_payload = json.loads(handoff_owner.stdout)
+        finding_owner_message = " ".join(
+            problem.get("message", "")
+            for problem in handoff_payload.get("problems", [])
+            if problem.get("code") == "finding-owner"
+        )
         if (
             handoff_owner.returncode != 3
-            or json.loads(handoff_owner.stdout).get("status") != "fail"
+            or handoff_payload.get("status") != "fail"
+            or "Discard reason" not in finding_owner_message
+            or "keel/archive" not in finding_owner_message
+            or "openspec/changes" not in finding_owner_message
         ):
-            report("core-gates scenario accepted HANDOFF as finding owner.")
+            report(
+                "core-gates scenario accepted HANDOFF as finding owner or the "
+                "finding-owner error did not enumerate the accepted forms."
+            )
             report((handoff_owner.stderr or handoff_owner.stdout).strip())
             return 1
 
@@ -4543,6 +4600,54 @@ def validate_core_gates_scenario() -> int:
             report((owned_finding.stderr or owned_finding.stdout).strip())
             return 1
 
+        write_text(completion_tasks, completion_task("passed", "done"))
+        done_status = run_keel(
+            completion_repo,
+            "gate",
+            "task-complete",
+            "--change",
+            "demo",
+            "--task",
+            "1.1",
+            "--json",
+        )
+        if (
+            done_status.returncode != 0
+            or json.loads(done_status.stdout).get("status") != "pass"
+        ):
+            report("core-gates scenario rejected an accepted `done` Review Status.")
+            report((done_status.stderr or done_status.stdout).strip())
+            return 1
+
+        write_text(completion_tasks, completion_task("passed", "reviewed"))
+        bad_status = run_keel(
+            completion_repo,
+            "gate",
+            "task-complete",
+            "--change",
+            "demo",
+            "--task",
+            "1.1",
+            "--json",
+        )
+        bad_status_payload = json.loads(bad_status.stdout)
+        bad_status_message = " ".join(
+            problem.get("message", "")
+            for problem in bad_status_payload.get("problems", [])
+        )
+        if (
+            bad_status.returncode != 4
+            or bad_status_payload.get("status") != "needs-review"
+            or "Status" not in bad_status_message
+            or "done" not in bad_status_message
+        ):
+            report(
+                "core-gates scenario semantic-review did not name Status and list "
+                "accepted tokens including done."
+            )
+            report((bad_status.stderr or bad_status.stdout).strip())
+            return 1
+
         write_text(completion_tasks, completion_task("passed", "pass"))
         write_text(completion_repo / "src/outside.js", "outside\n")
         subprocess.run(
@@ -5115,6 +5220,107 @@ def validate_core_gates_scenario() -> int:
     return 0
 
 
+def validate_scope_rename_attribution_scenario() -> int:
+    rename_task = (
+        "# Tasks\n\n"
+        "- [ ] 1.1 Complete behavior\n"
+        "  - Owner: keel-agent\n"
+        "  - Mode: implementation\n"
+        "  - Covers:\n"
+        "    - E1: public behavior\n"
+        "  - Read:\n"
+        "    - README.md\n"
+        "  - Touch:\n"
+        "    - src/renamed-from.js\n"
+        "    - src/renamed-to.js\n"
+        "    - openspec/changes/demo/tasks.md\n"
+        "  - Commands:\n"
+        "    - M1: node test.js\n"
+        "  - Acceptance:\n"
+        "    - Public behavior passes.\n"
+        "  - Autonomy boundary:\n"
+        "    - Default: hard-stop\n"
+        "    - Pre-authorized fallback: none\n"
+        "  - Coupling: none\n"
+        "  - Candidate Boundary:\n"
+        "    - One complete candidate reaches M1.\n"
+        "  - Stop Rules:\n"
+        "    - Stop on final assertion failure.\n"
+        "  - Evidence:\n"
+        "    - M1: passed\n"
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: public behavior reviewed\n"
+        "      - Scope check: Touch reviewed semantically\n"
+        "      - Findings: none\n"
+        "    - Blocker: none\n"
+        "  - Stop if:\n"
+        "    - Requires files outside Touch.\n"
+        "  - Report:\n"
+        "    - Summary\n"
+    )
+    with tempfile.TemporaryDirectory(prefix="keel-scope-rename-") as raw_tmp:
+        repo = Path(raw_tmp)
+        write_text(repo / "openspec/changes/demo/tasks.md", rename_task)
+        write_text(repo / "src/renamed-from.js", "module.exports = 1;\n")
+        write_text(repo / "README.md", "readme\n")
+        for args in (
+            ["init", "--quiet"],
+            ["config", "user.email", "keel@example.invalid"],
+            ["config", "user.name", "Keel Fixture"],
+            ["add", "."],
+            ["commit", "--quiet", "-m", "baseline"],
+        ):
+            result = subprocess.run(
+                ["git", *args], cwd=repo, capture_output=True, text=True
+            )
+            if result.returncode != 0:
+                report("scope-rename scenario git setup failed:")
+                report((result.stderr or result.stdout).strip())
+                return 1
+        # A staged rename whose old and new paths are both in Touch must not be a
+        # false outside-Touch failure (git reports it as one `old -> new` entry).
+        moved = subprocess.run(
+            ["git", "mv", "src/renamed-from.js", "src/renamed-to.js"],
+            cwd=repo,
+            capture_output=True,
+            text=True,
+        )
+        if moved.returncode != 0:
+            report("scope-rename scenario git mv failed:")
+            report((moved.stderr or moved.stdout).strip())
+            return 1
+        completed = run_keel(
+            repo,
+            "gate",
+            "task-complete",
+            "--change",
+            "demo",
+            "--task",
+            "1.1",
+            "--base",
+            "HEAD",
+            "--json",
+        )
+        payload = json.loads(completed.stdout or "{}")
+        outside = " ".join(
+            problem.get("message", "") for problem in payload.get("problems", [])
+        )
+        if (
+            completed.returncode != 0
+            or payload.get("status") != "pass"
+            or "outside" in outside.lower()
+        ):
+            report(
+                "scope-rename scenario reported a false outside-touch failure for a "
+                "git mv rename whose old and new paths are both in Touch."
+            )
+            report((completed.stderr or completed.stdout).strip())
+            return 1
+    report("scope-rename scenario passed.")
+    return 0
+
+
 def validate_target_capability_adapters_scenario() -> int:
     capability_keys = (
         "continuity.start",
@@ -5397,27 +5603,24 @@ def validate_expectation_alignment_skill_scenario() -> int:
             )
             return 1
 
-    # Structure and behavior: domain references exist, are routed from the
-    # skill, and stay scoped to their own domain (cross-file keyword pairs).
+    # Structure and behavior: the skill routes to user-authored keel/lenses/,
+    # the shipped lens templates exist, and each template stays scoped to its
+    # own domain (cross-file keyword pairs).
+    if "keel/lenses/" not in skill:
+        report("expectation-alignment-skill does not route to keel/lenses/")
+        return 1
     for domain in ("web", "hardware", "hardware-dsl"):
-        reference_path = (
-            ROOT / "src/skills/keel-align-expectations/references" / f"{domain}.md"
-        )
-        if not reference_path.is_file():
-            report(f"expectation-alignment-skill reference is missing: {domain}.md")
-            return 1
-        if f"references/{domain}.md" not in skill:
-            report(f"expectation-alignment-skill does not route to references/{domain}.md")
-            return 1
-    web_reference = (
-        ROOT / "src/skills/keel-align-expectations/references/web.md"
-    ).read_text(encoding="utf-8")
-    hardware_reference = (
-        ROOT / "src/skills/keel-align-expectations/references/hardware.md"
-    ).read_text(encoding="utf-8")
-    dsl_reference = (
-        ROOT / "src/skills/keel-align-expectations/references/hardware-dsl.md"
-    ).read_text(encoding="utf-8")
+        template_path = ROOT / "assets/lenses" / f"{domain}.md"
+        if not template_path.is_file():
+            report(f"expectation-alignment-skill lens template is missing: {domain}.md")
+            return 1
+    web_reference = (ROOT / "assets/lenses/web.md").read_text(encoding="utf-8")
+    hardware_reference = (ROOT / "assets/lenses/hardware.md").read_text(
+        encoding="utf-8"
+    )
+    dsl_reference = (ROOT / "assets/lenses/hardware-dsl.md").read_text(
+        encoding="utf-8"
+    )
     for content, expected, unexpected in (
         (web_reference, "accessibility", "valid-ready"),
         (hardware_reference, "valid-ready", "browser"),
@@ -5425,7 +5628,7 @@ def validate_expectation_alignment_skill_scenario() -> int:
     ):
         if expected not in content or unexpected in content:
             report(
-                "expectation-alignment-skill domain references are not scoped to "
+                "expectation-alignment-skill lens templates are not scoped to "
                 "their own domain."
             )
             return 1
@@ -5563,11 +5766,10 @@ def validate_native_plugin_manifests_scenario() -> int:
                 f"source: {skill_name}"
             )
             return 1
-    for reference in ("web.md", "hardware.md", "hardware-dsl.md"):
-        if not (
-            skills_root / "keel-align-expectations/references" / reference
-        ).is_file():
-            report(f"native-plugin-manifests plugin misses reference: {reference}")
+    lenses_root = ROOT / "assets/lenses"
+    for template in ("web.md", "hardware.md", "hardware-dsl.md"):
+        if not (lenses_root / template).is_file():
+            report(f"native-plugin-manifests misses lens template: {template}")
             return 1
 
     codex_market_path = ROOT / ".agents/plugins/marketplace.json"
@@ -6180,7 +6382,7 @@ def validate_compact_task_authoring_scenario() -> int:
         "- Strategy: <strategy>",
         "- M1:",
         "- Evidence:",
-        "- Contract: pending task-start capsule and fingerprint",
+        "- Contract: pending",
         "- Review:",
         "- Blocker: none",
         "- Mode: diagnose-only",
@@ -9299,42 +9501,51 @@ def validate_domain_execution_references_scenario() -> int:
         "keel-debug-failure",
         "keel-review-checklist",
     )
-    references = ("web.md", "hardware.md", "hardware-dsl.md")
+    templates = ("web.md", "hardware.md", "hardware-dsl.md")
     roots = (ROOT / "src/skills", ROOT / PLUGIN_ROOT / "skills")
 
     for root in roots:
         for skill in consuming_skills:
             text = (root / skill / "SKILL.md").read_text(encoding="utf-8")
             for needle in (
-                "keel-align-expectations",
+                "keel/lenses/",
                 "Execution and review checks",
-                "only the matching",
-                "no domain signal",
+                "load only that one",
+                "no lens matches",
             ):
                 if needle not in text:
                     report(
                         f"domain-execution-references: {root.name}/{skill} lacks "
-                        f"the on-demand consult step ({needle!r})."
+                        f"the on-demand lens consult step ({needle!r})."
                     )
                     return 1
-        for reference in references:
-            ref_path = (
-                root / "keel-align-expectations" / "references" / reference
+
+    lenses_root = ROOT / "assets/lenses"
+    for template in templates:
+        ref_path = lenses_root / template
+        if not ref_path.is_file():
+            report(f"domain-execution-references: lens template is missing: {template}")
+            return 1
+        text = ref_path.read_text(encoding="utf-8")
+        if "## Execution and review checks" not in text:
+            report(
+                f"domain-execution-references: {template} lacks the "
+                "execution and review section."
             )
-            text = ref_path.read_text(encoding="utf-8")
-            if "## Execution and review checks" not in text:
-                report(
-                    f"domain-execution-references: {reference} lacks the "
-                    "execution and review section."
-                )
-                return 1
-            size = ref_path.stat().st_size
-            if size > 3072:
-                report(
-                    f"domain-execution-references: {reference} exceeds the 3072-"
-                    f"byte budget ({size} bytes); move depth to dedicated skills."
-                )
-                return 1
+            return 1
+        if "Applies when" not in text:
+            report(
+                f"domain-execution-references: {template} lacks the "
+                "self-describing 'Applies when' header."
+            )
+            return 1
+        size = ref_path.stat().st_size
+        if size > 3072:
+            report(
+                f"domain-execution-references: {template} exceeds the 3072-"
+                f"byte budget ({size} bytes); move depth to dedicated skills."
+            )
+            return 1
 
     for skill in consuming_skills:
         src_text = (roots[0] / skill / "SKILL.md").read_bytes()
@@ -9345,19 +9556,6 @@ def validate_domain_execution_references_scenario() -> int:
                 "from the canonical source."
             )
             return 1
-    for reference in references:
-        src_ref = (
-            roots[0] / "keel-align-expectations" / "references" / reference
-        ).read_bytes()
-        shipped_ref = (
-            roots[1] / "keel-align-expectations" / "references" / reference
-        ).read_bytes()
-        if src_ref != shipped_ref:
-            report(
-                f"domain-execution-references: shipped {reference} copy diverges "
-                "from the canonical source."
-            )
-            return 1
 
     readme = (ROOT / "README.zh-CN.md").read_text(encoding="utf-8")
     if "Execution and review checks" not in readme:
@@ -9377,6 +9575,129 @@ def validate_domain_execution_references_scenario() -> int:
     return 0
 
 
+def validate_domain_lens_scaffold_scenario() -> int:
+    shipped = {"web", "hardware", "hardware-dsl"}
+    lenses_root = ROOT / "assets/lenses"
+    for name in shipped:
+        if not (lenses_root / f"{name}.md").is_file():
+            report(f"domain-lens-scaffold: shipped template is missing: {name}")
+            return 1
+
+    with tempfile.TemporaryDirectory(prefix="keel-lenses-") as raw_tmp:
+        repo = Path(raw_tmp) / "repo"
+        repo.mkdir()
+
+        listing = run_keel(repo, "lenses", "list")
+        if listing.returncode != 0:
+            report("domain-lens-scaffold: keel lenses list failed.")
+            report((listing.stderr or listing.stdout).strip())
+            return 1
+        for name in shipped:
+            if name not in listing.stdout:
+                report(
+                    f"domain-lens-scaffold: keel lenses list omitted the "
+                    f"{name} template."
+                )
+                report(listing.stdout.strip())
+                return 1
+        if "keel/lenses/" not in listing.stdout:
+            report(
+                "domain-lens-scaffold: keel lenses list did not name the "
+                "keel/lenses/ install location."
+            )
+            return 1
+
+        add = run_keel(repo, "lenses", "add", "web")
+        installed = repo / "keel/lenses/web.md"
+        if add.returncode != 0 or not installed.is_file():
+            report("domain-lens-scaffold: keel lenses add web did not scaffold.")
+            report((add.stderr or add.stdout).strip())
+            return 1
+        if "Applies when:" not in installed.read_text(encoding="utf-8"):
+            report(
+                "domain-lens-scaffold: scaffolded lens lost its 'Applies when:' "
+                "header."
+            )
+            return 1
+
+        clobber = run_keel(repo, "lenses", "add", "web")
+        if clobber.returncode == 0:
+            report(
+                "domain-lens-scaffold: a second keel lenses add web must refuse "
+                "without --force."
+            )
+            return 1
+
+        forced = run_keel(repo, "lenses", "add", "web", "--force")
+        if forced.returncode != 0:
+            report("domain-lens-scaffold: keel lenses add web --force failed.")
+            report((forced.stderr or forced.stdout).strip())
+            return 1
+
+        after_add = run_keel(repo, "lenses", "list")
+        if "web (installed)" not in after_add.stdout:
+            report(
+                "domain-lens-scaffold: keel lenses list did not mark web as "
+                "installed after add."
+            )
+            report(after_add.stdout.strip())
+            return 1
+
+    report("domain-lens-scaffold scenario passed.")
+    return 0
+
+
+def validate_domain_lens_doctor_scenario() -> int:
+    with tempfile.TemporaryDirectory(
+        prefix="keel-lens-doctor-", ignore_cleanup_errors=True
+    ) as raw_tmp:
+        repo = Path(raw_tmp) / "repo"
+        repo.mkdir()
+
+        doctor = run_keel(repo, "--doctor")
+        out = doctor.stdout
+        if "Domain lens surface:" not in out:
+            report("domain-lens-doctor: --doctor lacks the Domain lens surface section.")
+            report((doctor.stderr or out).strip())
+            return 1
+        for name in ("web", "hardware", "hardware-dsl"):
+            if name not in out:
+                report(f"domain-lens-doctor: --doctor did not report the {name} template.")
+                report(out.strip())
+                return 1
+        if "lens templates: ok" not in out:
+            report("domain-lens-doctor: --doctor did not report the shipped templates as ok.")
+            report(out.strip())
+            return 1
+
+        legacy = repo / ".claude/skills/keel-profile-web/SKILL.md"
+        legacy.parent.mkdir(parents=True)
+        legacy.write_text("legacy profile bytes\n", encoding="utf-8")
+        before = legacy.read_bytes()
+
+        doctor2 = run_keel(repo, "--doctor")
+        out2 = doctor2.stdout
+        if "legacy profiles: migrate" not in out2 or "keel-profile-web" not in out2:
+            report(
+                "domain-lens-doctor: --doctor did not warn about the legacy "
+                "keel-profile-web skill."
+            )
+            report(out2.strip())
+            return 1
+        if "not active state" not in out2:
+            report(
+                "domain-lens-doctor: the legacy warning must state it is not "
+                "active state."
+            )
+            return 1
+        if legacy.read_bytes() != before:
+            report("domain-lens-doctor: --doctor modified the legacy skill bytes.")
+            return 1
+
+    report("domain-lens-doctor scenario passed.")
+    return 0
+
+
 def validate_precompact_probe_scenario() -> int:
     hooks_config = json.loads(
         (ROOT / PLUGIN_ROOT / "hooks/hooks.json").read_text(encoding="utf-8")
@@ -9719,9 +10040,54 @@ def validate_validation_runner_scenario() -> int:
 
 # The one ordered scenario registry: --scenario dispatch, the --all runner,
 # and registration assertions all read this list and nothing else.
+def validate_doctor_openspec_honesty_scenario() -> int:
+    cli = (ROOT / "bin/keel.js").read_text(encoding="utf-8")
+    if "is not on PATH" not in cli:
+        report(
+            "doctor-openspec-honesty scenario: bin/keel.js is missing the "
+            "openspec PATH-reachability warning branch."
+        )
+        return 1
+    with tempfile.TemporaryDirectory(prefix="keel-doctor-openspec-") as raw:
+        root = Path(raw)
+        repo = root / "repo"
+        repo.mkdir()
+        stub_dir = root / "stub"
+        stub_dir.mkdir()
+        if os.name == "nt":
+            (stub_dir / "openspec.cmd").write_text(
+                "@echo off\necho 1.6.0\n", encoding="utf-8"
+            )
+        else:
+            stub = stub_dir / "openspec"
+            stub.write_text("#!/bin/sh\necho 1.6.0\n", encoding="utf-8")
+            stub.chmod(0o755)
+        env = dict(os.environ)
+        env["PATH"] = str(stub_dir) + os.pathsep + env.get("PATH", "")
+        on_path = run_keel(repo, "--doctor", env=env)
+        openspec_line = next(
+            (
+                line
+                for line in on_path.stdout.splitlines()
+                if line.startswith("openspec:")
+            ),
+            "",
+        )
+        if not openspec_line.startswith("openspec: ok"):
+            report(
+                "doctor-openspec-honesty scenario: doctor did not report `ok` "
+                "when a bare openspec is on PATH."
+            )
+            report(on_path.stdout.strip())
+            return 1
+    report("doctor-openspec-honesty scenario passed.")
+    return 0
+
+
 SCENARIOS: tuple = (
     ("stateless-continuity", validate_stateless_continuity_scenario),
     ("core-gates", validate_core_gates_scenario),
+    ("scope-rename-attribution", validate_scope_rename_attribution_scenario),
     ("target-capability-adapters", validate_target_capability_adapters_scenario),
     ("native-runtime-projection", validate_native_runtime_projection_scenario),
     ("target-surface", validate_target_surface_scenario),
@@ -9729,13 +10095,15 @@ SCENARIOS: tuple = (
     ("expectation-slice-gates", validate_expectation_slice_gates_scenario),
     ("expectation-completion-gates", validate_expectation_completion_gates_scenario),
     ("authoring-continuity", validate_authoring_continuity_scenario),
-    ("domain-profiles", validate_domain_profiles_scenario),
+    ("domain-lenses", validate_domain_lenses_scenario),
     ("skill-portability-policy", validate_skill_portability_policy_scenario),
     ("version-alignment", validate_version_alignment_scenario),
     ("openspec-surface-overlay", validate_openspec_surface_overlay_scenario),
     ("uninstall", validate_uninstall_scenario),
     ("cli", validate_cli_scenario),
+    ("doctor-openspec-honesty", validate_doctor_openspec_honesty_scenario),
     ("update-pack-install", validate_update_pack_install_scenario),
+    ("update-default-registry", validate_update_default_registry_scenario),
     ("task-contract-core", validate_task_contract_core_scenario),
     ("task-capsule", validate_task_capsule_scenario),
     ("task-verification-strategies", validate_task_verification_strategies_scenario),
@@ -9768,6 +10136,8 @@ SCENARIOS: tuple = (
     ("plugin-compaction-continuity", validate_plugin_compaction_continuity_scenario),
     ("precompact-probe", validate_precompact_probe_scenario),
     ("domain-execution-references", validate_domain_execution_references_scenario),
+    ("domain-lens-scaffold", validate_domain_lens_scaffold_scenario),
+    ("domain-lens-doctor", validate_domain_lens_doctor_scenario),
     ("plan-funnel-guidance", validate_plan_funnel_guidance_scenario),
     ("native-tasks-view", validate_native_tasks_view_scenario),
     ("validation-runner", validate_validation_runner_scenario),
@@ -9800,6 +10170,83 @@ def run_scenario_processes(names: list, jobs: int) -> list:
     return [(name, *results[name]) for name in names]
 
 
+def validate_review_status_single_source(errors: list[str]) -> None:
+    contract = (ROOT / "src/core/task-contract.js").read_text(encoding="utf-8")
+    if "ACCEPTED_REVIEW_STATUSES" not in contract:
+        errors.append(
+            "src/core/task-contract.js must define the shared "
+            "ACCEPTED_REVIEW_STATUSES constant."
+        )
+    if '"done"' not in contract:
+        errors.append(
+            "ACCEPTED_REVIEW_STATUSES must include the `done` Review Status."
+        )
+    literal = "pass|passed|complete|completed|ok"
+    for relative in ("src/core/gates.js", "src/core/context.js"):
+        content = (ROOT / relative).read_text(encoding="utf-8")
+        if "ACCEPTED_REVIEW_STATUSES" not in content:
+            errors.append(
+                f"{relative} must consume the shared ACCEPTED_REVIEW_STATUSES "
+                "constant rather than an inline Review Status vocabulary."
+            )
+        if literal in content:
+            errors.append(
+                f"{relative} still hard-codes the Review Status vocabulary "
+                f"`{literal}`; consume the shared constant instead."
+            )
+
+
+def validate_install_honesty(errors: list[str]) -> None:
+    installer = (ROOT / "scripts/install_to_repo.py").read_text(encoding="utf-8")
+    if "def skill_actions" in installer or "dist_asset(target_name, \"skills\")" in installer:
+        errors.append(
+            "install_to_repo.py must not carry the dead keel-* skill_actions "
+            "path; keel-* skills are plugin-delivered."
+        )
+    cli = (ROOT / "bin/keel.js").read_text(encoding="utf-8")
+    if "delivered by the installed Keel plugin" not in cli:
+        errors.append(
+            "keel --help/--doctor must state that keel-* skills are delivered "
+            "by the installed Keel plugin, not installed by the CLI."
+        )
+    if ".claude/skills/keel-*." in cli:
+        errors.append(
+            "keel --help must not claim the CLI installs skills under "
+            ".claude/skills/keel-*."
+        )
+
+
+def validate_openspec_invocable(errors: list[str]) -> None:
+    cli = (ROOT / "bin/keel.js").read_text(encoding="utf-8")
+    if 'options.action === "openspec"' not in cli:
+        errors.append("bin/keel.js must implement the `keel openspec` passthrough.")
+    if cli.count("Invoke OpenSpec through") < 2:
+        errors.append(
+            "the apply and archive overlays must direct agents to `keel openspec` "
+            "in place of a bare openspec command."
+        )
+
+
+def validate_archive_overlay_hygiene(errors: list[str]) -> None:
+    cli = (ROOT / "bin/keel.js").read_text(encoding="utf-8")
+    if "--skip-specs" not in cli:
+        errors.append(
+            "the archive overlay must direct archive to pass --skip-specs "
+            "after /opsx:sync has promoted the delta."
+        )
+    if "drop the change's guard manifest" not in cli:
+        errors.append(
+            "the archive overlay must remind the agent to run keel guard clear "
+            "after archiving."
+        )
+    gates = (ROOT / "src/core/gates.js").read_text(encoding="utf-8")
+    if "clearGuard" in gates:
+        errors.append(
+            "gates must stay read-only: gate code must not clear the guard "
+            "manifest (guard clear is explicit via keel guard clear)."
+        )
+
+
 def run_baseline() -> int:
     errors: list[str] = []
     validate_manifest(errors)
@@ -9808,6 +10255,10 @@ def run_baseline() -> int:
     validate_resident_blocks(errors)
     validate_templates(errors)
     validate_openspec_schema(errors)
+    validate_review_status_single_source(errors)
+    validate_install_honesty(errors)
+    validate_openspec_invocable(errors)
+    validate_archive_overlay_hygiene(errors)
     validate_skill_docs(errors)
     validate_skill_portability(ROOT, errors)
     validate_scripts_use_stdlib(errors)