@ikon85/agent-workflow-kit 0.42.1 → 0.44.0

package/scripts/test_codex_adapter_sync_contract.py

@@ -1,169 +0,0 @@
-#!/usr/bin/env python3
-"""Regression contract for the Codex-only adapter audit skill."""
-
-import importlib.util
-import unittest
-from pathlib import Path
-
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-ADAPTER = REPO_ROOT / ".agents/skills/codex-adapter-sync/SKILL.md"
-AGENTS_README = REPO_ROOT / ".codex/agents/README.md"
-_FRONTMATTER_SPEC = importlib.util.spec_from_file_location(
-    "skill_frontmatter_lint", REPO_ROOT / "scripts/test_skill_frontmatter_lint.py")
-frontmatter = importlib.util.module_from_spec(_FRONTMATTER_SPEC)
-_FRONTMATTER_SPEC.loader.exec_module(frontmatter)
-
-
-def section(body: str, heading: str) -> str:
-    """Return one second-level Markdown section, excluding the next one."""
-    marker = f"## {heading}\n"
-    start = body.index(marker) + len(marker)
-    end = body.find("\n## ", start)
-    return body[start:] if end == -1 else body[start:end]
-
-
-class AdapterModesContract(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.body = ADAPTER.read_text(encoding="utf-8")
-
-    def test_audit_is_read_only_and_apply_is_worktree_gated(self):
-        audit = " ".join(section(self.body, "Audit mode (default)").split())
-        apply = " ".join(section(self.body, "Apply mode").split())
-
-        self.assertIn("current checkout", audit)
-        self.assertIn("read-only", audit)
-        self.assertIn("Do not create or switch branches or worktrees", audit)
-        self.assertIn("before the first edit", apply)
-        self.assertIn("Never apply adapter changes on `main`", apply)
-        self.assertNotIn("before inventory or edits", self.body)
-
-
-class AdapterRoutingContract(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.body = ADAPTER.read_text(encoding="utf-8")
-
-    def test_durable_routing_is_provider_neutral_and_resolved_at_dispatch(self):
-        routing = " ".join(section(self.body, "Routing intent").split())
-
-        self.assertIn("`routing-intent`", routing)
-        self.assertIn("`reasoning-intent`", routing)
-        self.assertIn("Evidence catalog", routing)
-        self.assertIn("Access graph", routing)
-        self.assertIn("Routing policy", routing)
-        self.assertIn("dispatch time", routing)
-        self.assertIn("explicit `inherit`", routing)
-        self.assertIn("Dispatch receipt", routing)
-        self.assertIn("`default`, `worker`, and `explorer`", routing)
-
-        self.assertNotRegex(self.body, r"(?<!model_)\breasoning_effort\b")
-        self.assertNotRegex(self.body, r"\bagent_type\b")
-
-
-class AdapterInventoryContract(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.body = ADAPTER.read_text(encoding="utf-8")
-
-    def test_nested_instructions_configs_and_hooks_are_inventoried(self):
-        inventory = section(self.body, "Inventory")
-
-        for surface in (
-            "`**/CLAUDE.md`",
-            "`**/AGENTS.md`",
-            "`**/AGENTS.override.md`",
-            "`**/.codex/config.toml`",
-            "`.claude/settings*.json`",
-            "`.claude/hooks/**`",
-            "`.codex/hooks.json`",
-            "inline `[hooks]`",
-        ):
-            self.assertIn(surface, inventory)
-        self.assertIn("trusted project layers", inventory)
-        self.assertIn("Codex-adapted", inventory)
-        self.assertIn("intentionally Claude-only", inventory)
-        self.assertNotIn("`frontend/CLAUDE.md`", self.body)
-        self.assertNotIn("`backend/CLAUDE.md`", self.body)
-
-
-class AdapterAgentContract(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.body = ADAPTER.read_text(encoding="utf-8")
-
-    def test_custom_agent_toml_uses_the_current_schema(self):
-        agents = " ".join(section(self.body, "Custom-agent validation").split())
-
-        self.assertIn(
-            "required `name`, `description`, and `developer_instructions`", agents)
-        self.assertIn("optional `model` and `model_reasoning_effort`", agents)
-        self.assertIn("Parse every `.codex/agents/*.toml`", agents)
-        self.assertIn("Reject a file", agents)
-
-    def test_codex_host_inventory_is_dated_and_does_not_invent_spawn_selectors(self):
-        inventory = " ".join(
-            AGENTS_README.read_text(encoding="utf-8").split()
-        )
-        for fragment in (
-            "2026-07-23",
-            "`task_name`",
-            "`message`",
-            "`fork_turns`",
-            "no per-spawn `model`",
-            "no per-spawn effort selector",
-            "`src/lib/routingAdapters/codex.mjs`",
-            "blocks differentiated AFK",
-            "Dispatch receipt v2",
-        ):
-            self.assertIn(fragment, inventory)
-
-
-class AdapterValidationContract(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.body = ADAPTER.read_text(encoding="utf-8")
-
-    def test_validation_covers_every_current_adapter_surface(self):
-        validation = " ".join(section(self.body, "Validation").split())
-
-        for proof in (
-            "`codex --strict-config --version`",
-            "skill-frontmatter guard",
-            "skill metadata and loading",
-            "custom-agent TOML",
-            "`git check-ignore",
-            "references, assets, scripts",
-            "mirror-parity guard",
-            "X of Y",
-        ):
-            self.assertIn(proof, validation)
-        for maintainer_only_path in (
-            "scripts/test_skill_frontmatter_lint.py",
-            "scripts/test_skill_portability_lint.py",
-        ):
-            self.assertNotIn(maintainer_only_path, self.body)
-
-    def test_description_cap_is_an_enforced_repository_safeguard(self):
-        validation = " ".join(section(self.body, "Validation").split())
-        self.assertIn("1024-character description cap", validation)
-        self.assertIn("repository safeguard", validation)
-        self.assertIn("not a Codex product limit", validation)
-
-        problems = []
-        for skill in (REPO_ROOT / ".agents/skills").glob("*/SKILL.md"):
-            data = frontmatter.parse_frontmatter(
-                frontmatter.extract_frontmatter(skill.read_text(encoding="utf-8")))
-            description = data.get("description")
-            if isinstance(description, str) and len(description) > 1024:
-                problems.append(f"{skill.relative_to(REPO_ROOT)}: {len(description)}")
-        self.assertEqual(
-            problems,
-            [],
-            "skill descriptions over 1024 characters:\n" + "\n".join(problems),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/scripts/test_dist_kit_smoke.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-"""dist-kit smoke — proves the BUILT kit's `validate-graph` imports + runs
-(Welle 52 / Slice 7 / #1936, PLAN Step 15).
-
-Why: `bundle.mjs`'s HELPER_FILES allowlist is the only thing that ships
-program_graph.py / program_graph_parse.py / program_graph_validate.py /
-node_kind.py / board_fields.py / program_sync.py into dist-kit/scripts/ — all
-six are imported UNCONDITIONALLY at board-sync.py's module top (not lazily
-inside a subcommand handler), so a forgotten entry does not fail at build time,
-it fails the FIRST time a consumer runs the shipped CLI (ImportError). This
-test catches that class of regression by actually invoking `validate-graph`
-against the built dist-kit/, not the scripts/ SSOT copy the rest of the suite
-imports.
-
-Fully offline: a throwaway consumer board profile (BOARD_SYNC_PROFILE env var)
-stands in for a project layer, and a fake `gh` shim on PATH answers the two
-read-only `gh` calls `validate-graph` makes (the PRD body + the empty
-sub-issues/children query) — no network, no real gh auth, no live board.
-
-Run: python3 scripts/test_dist_kit_smoke.py
-"""
-import json
-import os
-import shutil
-import stat
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parent.parent
-DIST = REPO / "dist-kit"
-
-# A minimal but structurally complete consumer profile (see board_config.py's
-# _REQUIRED_PATHS) — distinct ids from Testreporter's own, so a leak would be
-# obvious. `fields.phase` is included (with the same shape #1936 gives the
-# real Testreporter profile) so the fixture also exercises the Phase-aware
-# path in validate-graph, not just its defensive None-fallback.
-FIXTURE_PROFILE = {
-    "repo": "acme/widgets",
-    "project": {"number": 7, "owner": "acme", "nodeId": "PVT_FIXTURE"},
-    "fields": {
-        "status": {"id": "PVTSSF_FIXTURE", "options": {"Spec": "opt-spec"}},
-        "wave": "PVTF_FIXTURE_WAVE",
-        "cluster": "PVTF_FIXTURE_CLUSTER",
-        "specPath": "PVTF_FIXTURE_SPEC",
-        "planPath": "PVTF_FIXTURE_PLAN",
-        "phase": {"id": "PVTSSF_FIXTURE_PHASE",
-                  "options": {"P1": "opt-p1", "P2": "opt-p2", "P3": "opt-p3"}},
-    },
-    "labels": {"readyForAgent": "ready-for-agent", "typePrefix": "type:",
-               "clusterType": "type:cluster", "waveStub": "wave-stub"},
-    "branchPrefixes": ["feat", "fix"],
-    "prMarkers": {"partOf": "Part of", "retroMarker": "**Retro:**",
-                  "retroValues": ["ran", "skipped"]},
-    "headings": {"vorBau": "Clarify Before Build"},
-}
-
-# A minimal green Program-PRD body — one wave, two slices, full scope coverage,
-# no cycles/backward-refs/gate warnings — the same shape as test_program_graph.py's
-# GREEN_PRD fixture, duplicated here (not imported) so this smoke stays
-# self-contained and independent of the SSOT test module's import side effects.
-GREEN_PRD = (
-    "<!-- prd: program -->\n"
-    "**plan_revision:** r1\n\n"
-    "## Scope\n"
-    "- **S1:** Programm-Graph-Fundament\n"
-    "- **S2:** Execute-Ready-Erweiterung\n\n"
-    "## Wellenplan\n"
-    "<!-- wellenplan:start -->\n"
-    "| Welle | Name | Phase | Slices | Gate | covers |\n"
-    "|---|---|---|---|---|---|\n"
-    "| 1 | Fundament | P1 | 1a, 1b | — | S1,S2 |\n"
-    "<!-- wellenplan:end -->\n\n"
-    "## Phasen-Gates\n"
-    "- [ ] P1: Fundament steht\n\n"
-    "## Slices\n"
-    "#### 1a — Graph-Modul\n"
-    "<!-- wave: 1 -->\n"
-    "<!-- phase: P1 -->\n"
-    "<!-- area: scripts -->\n"
-    "<!-- gate: — -->\n"
-    "<!-- blocked_by: none -->\n\n"
-    "#### 1b — Execute-Ready\n"
-    "<!-- wave: 1 -->\n"
-    "<!-- phase: P1 -->\n"
-    "<!-- area: scripts -->\n"
-    "<!-- gate: — -->\n"
-    "<!-- blocked_by: 1a -->\n"
-)
-
-# A fake `gh` binary: answers the sub-issues/children GraphQL query (empty —
-# no published stubs yet) and the PRD-body `issue view` read from a file, so
-# `validate-graph` runs end to end without any real `gh` call.
-FAKE_GH = """#!/usr/bin/env python3
-import os, sys
-args = sys.argv[1:]
-if "subIssues" in " ".join(args):
-    sys.stdout.write('{"data":{"repository":{"issue":{"subIssues":{"nodes":[]}}}}}')
-else:
-    with open(os.environ["DIST_KIT_SMOKE_BODY"], encoding="utf-8") as fh:
-        sys.stdout.write(fh.read())
-"""
-
-
-def _build_dist_kit():
-    """Run the real build (subprocess — the maintainer's actual publish step).
-    Returns (CompletedProcess, skip_reason); skip_reason is set only when node
-    itself is unavailable in this environment (mirrors test_skill_publish_audit.py)."""
-    build = REPO / "scripts/build-kit.mjs"
-    try:
-        r = subprocess.run(["node", str(build)], cwd=REPO,
-                            capture_output=True, text=True, timeout=120)
-    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
-        return None, str(e)
-    return r, None
-
-
-class DistKitValidateGraphSmoke(unittest.TestCase):
-    """Builds dist-kit/ then runs `board-sync.py validate-graph` from the
-    SHIPPED location — proves the whole program_graph* / node_kind / board_fields
-    / program_sync import chain resolves in the actual publish artefact, and
-    that the command produces the correct counted report on a known fixture."""
-
-    def setUp(self):
-        r, skip_reason = _build_dist_kit()
-        if skip_reason:
-            self.skipTest(f"node/build unavailable: {skip_reason}")
-        self.assertEqual(r.returncode, 0, r.stderr)
-        self.board_sync_py = DIST / "scripts/board-sync.py"
-        self.assertTrue(self.board_sync_py.exists(), "dist-kit/scripts/board-sync.py missing")
-
-        self.tmp = Path(tempfile.mkdtemp())
-        self.addCleanup(shutil.rmtree, self.tmp, ignore_errors=True)
-
-        profile_md = ("<!-- board-sync:profile -->\n```json\n"
-                      + json.dumps(FIXTURE_PROFILE) + "\n```\n")
-        profile_path = self.tmp / "board-sync.md"
-        profile_path.write_text(profile_md, encoding="utf-8")
-
-        body_path = self.tmp / "prd-body.md"
-        body_path.write_text(GREEN_PRD, encoding="utf-8")
-
-        fake_gh_dir = self.tmp / "bin"
-        fake_gh_dir.mkdir()
-        gh_path = fake_gh_dir / "gh"
-        gh_path.write_text(FAKE_GH, encoding="utf-8")
-        gh_path.chmod(gh_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
-
-        self.env = {
-            **os.environ,
-            "PATH": f"{fake_gh_dir}{os.pathsep}{os.environ.get('PATH', '')}",
-            "BOARD_SYNC_PROFILE": str(profile_path),
-            "DIST_KIT_SMOKE_BODY": str(body_path),
-        }
-
-    def test_validate_graph_runs_against_the_built_kit(self):
-        result = subprocess.run(
-            [sys.executable, str(self.board_sync_py), "validate-graph", "--issue", "42"],
-            capture_output=True, text=True, timeout=30, env=self.env,
-        )
-        self.assertEqual(result.returncode, 0,
-                          f"stdout={result.stdout!r} stderr={result.stderr!r}")
-        self.assertIn("Scope-Abdeckung 2 von 2", result.stdout)
-        self.assertIn("Rollup-Kette ✓", result.stdout)
-        self.assertIn("zyklenfrei ✓", result.stdout)
-        self.assertIn("Kapazität ✓", result.stdout)
-        self.assertIn("Phasen-Optionen ✓", result.stdout)
-
-    def test_no_german_status_vocabulary_ships(self):
-        """kit#26 / #1947 acceptance, verbatim: a fresh consumer install must
-        grep clean for testreporter's German board-status names. The status
-        vocabulary lives ONLY in a board's own profile (fields.status.roles) —
-        shipped scripts, skills, and doc templates speak role language. This
-        greps the whole BUILT artefact, so any future spot the word-list
-        census or the command lint can't see (a bare status name carries no
-        German function word and no board-sync.py call) still fails here."""
-        import re
-        pat = re.compile(r"\bIn Arbeit\b|\bIdee\b")
-        hits = []
-        for path in sorted(DIST.rglob("*")):
-            if not path.is_file():
-                continue
-            try:
-                text = path.read_text(encoding="utf-8")
-            except (UnicodeDecodeError, PermissionError):
-                continue
-            for n, line in enumerate(text.splitlines(), 1):
-                if pat.search(line):
-                    hits.append(f"{path.relative_to(DIST)}:{n}: {line.strip()[:120]}")
-        self.assertEqual(hits, [],
-                         "German board-status vocabulary in the shipped kit — speak role "
-                         "language (fields.status.roles / --status-role) instead:\n"
-                         + "\n".join(hits))
-
-    def test_shipped_census_runs_for_a_foreign_greenfield_on_both_surfaces(self):
-        consumer = self.tmp / "census-consumer"
-        shutil.copytree(REPO / "test/fixtures/census-consumers/greenfield", consumer)
-        subprocess.run(["git", "init", "--quiet"], cwd=consumer, check=True)
-        subprocess.run(["git", "add", "."], cwd=consumer, check=True)
-        claude = (DIST / ".claude/skills/census-update/SKILL.md").read_text()
-        codex = (DIST / ".agents/skills/census-update/SKILL.md").read_text()
-        self.assertEqual(claude, codex)
-        module = (DIST / "scripts/census/index.mjs").as_uri()
-        runner = (
-            f'import {{ scanCensus }} from {json.dumps(module)};'
-            "const r=await scanCensus({repoRoot:process.argv[1],enabled:true});"
-            "console.log(JSON.stringify({state:r.state,count:r.denominator.length}));"
-        )
-        result = subprocess.run(
-            ["node", "--input-type=module", "--eval", runner, str(consumer)],
-            cwd=DIST, capture_output=True, text=True, timeout=30,
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertEqual(json.loads(result.stdout), {"state": "bootstrap", "count": 2})
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/scripts/test_drift_guard_diagnostics.py

@@ -1,295 +0,0 @@
-#!/usr/bin/env python3
-"""Diagnostics contract for the handoff drift guard.
-
-Three independent gaps, one guard:
-
-  * the issue anchor may only come from the handoff repository's OWN issues —
-    a link to a foreign repository's issue must never become the anchor;
-  * a census block must name the checkout it evaluated, and say so explicitly
-    when the session sits in a different worktree of the same repository;
-  * `--census-status` must report WHAT drifted, bounded, not only that the
-    topology fingerprint moved.
-"""
-import importlib.util
-import json
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-
-ROOT = Path(__file__).resolve().parents[1]
-HOOKS = ROOT / ".claude" / "hooks"
-sys.path.insert(0, str(HOOKS))
-SPEC = importlib.util.spec_from_file_location("drift_guard", HOOKS / "drift-guard.py")
-DRIFT_GUARD = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(DRIFT_GUARD)
-
-GIT_IDENTITY = [
-    "-c", "user.name=drift-guard-test",
-    "-c", "user.email=drift-guard@example.invalid",
-    "-c", "commit.gpgsign=false",
-]
-
-
-class DriftGuardDiagnosticsTest(unittest.TestCase):
-    def make_repo(self, remote=None):
-        temporary = tempfile.TemporaryDirectory(prefix="awk-drift-guard-")
-        root = Path(temporary.name)
-        self.addCleanup(temporary.cleanup)
-        (root / "src").mkdir()
-        (root / "package.json").write_text('{"name":"consumer"}\n', encoding="utf-8")
-        (root / "src" / "index.mjs").write_text("export const ready = true;\n", encoding="utf-8")
-        subprocess.run(["git", "init", "--quiet"], cwd=root, check=True)
-        subprocess.run(["git", "add", "."], cwd=root, check=True)
-        if remote:
-            subprocess.run(["git", "remote", "add", "origin", remote], cwd=root, check=True)
-        return root
-
-    def enable(self, root):
-        census = root / ".census"
-        census.mkdir(exist_ok=True)
-        (census / "profile.json").write_text(json.dumps({
-            "schemaVersion": 1,
-            "enabled": True,
-            "decisions": [],
-            "localScanners": [],
-            "overrides": [],
-        }) + "\n", encoding="utf-8")
-
-    def activate_current(self, root):
-        fresh = DRIFT_GUARD.scan_census_status(root)["fresh"]
-        (root / ".census" / "active.json").write_text(
-            json.dumps(fresh) + "\n", encoding="utf-8"
-        )
-
-    def write_payload(self, root, name, content):
-        handoff = root / ".handoff"
-        handoff.mkdir(exist_ok=True)
-        return {
-            "tool_name": "Write",
-            "tool_input": {"file_path": str(handoff / name), "content": content},
-        }
-
-    def census_status(self, root, *extra):
-        completed = subprocess.run(
-            [sys.executable, str(HOOKS / "drift-guard.py"), "--census-status", *extra],
-            cwd=root, capture_output=True, check=True, text=True,
-        )
-        return json.loads(completed.stdout)
-
-    # --- anchor extraction ------------------------------------------------
-
-    def test_foreign_repository_issue_link_never_becomes_the_anchor(self):
-        root = self.make_repo(remote="git@github.com:acme/consumer.git")
-        content = (
-            "Refresh landed as chore PR "
-            "[#2281](https://github.com/acme/consumer/pull/2281).\n"
-            "Reported upstream: "
-            "[kit#276](https://github.com/iKon85/agent-workflow-kit/issues/276)\n"
-        )
-
-        issue = DRIFT_GUARD.extract_issue(
-            self.write_payload(root, "2026-07-26-2279.md", content), content, root
-        )
-
-        self.assertEqual(issue, 2279)
-
-    def test_own_repository_content_anchor_still_wins_over_the_filename(self):
-        for remote in (
-            "git@github.com:acme/consumer.git",
-            "https://github.com/acme/consumer.git",
-            "ssh://git@github.com/acme/consumer",
-        ):
-            with self.subTest(remote=remote):
-                root = self.make_repo(remote=remote)
-                content = (
-                    "Anchor [#2280](https://github.com/acme/consumer/issues/2280) — "
-                    "upstream [#276](https://github.com/iKon85/agent-workflow-kit/issues/276)\n"
-                )
-
-                issue = DRIFT_GUARD.extract_issue(
-                    self.write_payload(root, "2026-07-26-2279.md", content), content, root
-                )
-
-                self.assertEqual(issue, 2280)
-
-    def test_without_a_parsable_remote_the_filename_anchor_is_preferred(self):
-        root = self.make_repo()
-        content = "Upstream [#276](https://github.com/iKon85/agent-workflow-kit/issues/276)\n"
-
-        issue = DRIFT_GUARD.extract_issue(
-            self.write_payload(root, "2026-07-26-2279.md", content), content, root
-        )
-
-        self.assertEqual(issue, 2279)
-
-    def test_without_remote_and_without_filename_anchor_the_content_anchor_remains(self):
-        root = self.make_repo()
-        content = "Anchor [#276](https://github.com/iKon85/agent-workflow-kit/issues/276)\n"
-
-        issue = DRIFT_GUARD.extract_issue(
-            self.write_payload(root, "session-notes.md", content), content, root
-        )
-
-        self.assertEqual(issue, 276)
-
-    def test_a_foreign_only_handoff_without_a_filename_anchor_fails_open(self):
-        root = self.make_repo(remote="git@github.com:acme/consumer.git")
-        content = "Upstream [#276](https://github.com/iKon85/agent-workflow-kit/issues/276)\n"
-        payload = self.write_payload(root, "session-notes.md", content)
-
-        self.assertIsNone(DRIFT_GUARD.extract_issue(payload, content, root))
-        with patch.object(DRIFT_GUARD, "run_check") as check:
-            self.assertEqual(DRIFT_GUARD.should_block(payload), (False, ""))
-        check.assert_not_called()
-
-    def test_block_message_names_the_own_anchor_not_the_foreign_issue(self):
-        root = self.make_repo(remote="git@github.com:acme/consumer.git")
-        content = (
-            "Refresh landed as chore PR "
-            "[#2281](https://github.com/acme/consumer/pull/2281).\n"
-            "Reported upstream: "
-            "[kit#276](https://github.com/iKon85/agent-workflow-kit/issues/276)\n"
-        )
-        payload = self.write_payload(root, "2026-07-26-2279.md", content)
-        checked = []
-
-        def check(issue, intent):
-            checked.append(issue)
-            return {"deny_recommended": True, "violations": [f"#{issue}: plan_revision missing"]}
-
-        with patch.object(DRIFT_GUARD, "run_check", side_effect=check):
-            blocked, message = DRIFT_GUARD.should_block(payload)
-
-        self.assertEqual(checked, [2279])
-        self.assertTrue(blocked)
-        self.assertIn("#2279", message)
-        self.assertNotIn("276", message)
-
-    # --- evaluated checkout -----------------------------------------------
-
-    def test_census_block_message_names_the_evaluated_checkout(self):
-        root = self.make_repo()
-        result = {"state": "refresh_required", "reasons": ["topology"], "overrides": []}
-
-        message = DRIFT_GUARD.build_census_block_message(2279, result, root, root)
-
-        self.assertIn(str(root), message)
-        self.assertIn("evaluated checkout", message)
-        self.assertIn("worktree", message)
-        self.assertIn("$census-update", message)
-
-    def test_a_sibling_worktree_working_directory_is_named_explicitly(self):
-        root = self.make_repo()
-        subprocess.run(["git", *GIT_IDENTITY, "commit", "--quiet", "-m", "init"],
-                       cwd=root, check=True)
-        sibling = root / "sibling-worktree"
-        subprocess.run(["git", "worktree", "add", "--quiet", str(sibling), "-b", "slice"],
-                       cwd=root, check=True)
-        result = {"state": "refresh_required", "reasons": ["topology"], "overrides": []}
-
-        from_sibling = DRIFT_GUARD.build_census_block_message(2279, result, root, sibling)
-        from_root = DRIFT_GUARD.build_census_block_message(2279, result, root, root)
-        from_elsewhere = DRIFT_GUARD.build_census_block_message(
-            2279, result, root, self.make_repo()
-        )
-
-        self.assertIn(str(sibling), from_sibling)
-        self.assertIn("different worktree", from_sibling)
-        self.assertNotIn("different worktree", from_root)
-        self.assertNotIn("different worktree", from_elsewhere)
-
-    def test_a_blocked_build_handoff_reports_the_checkout_it_evaluated(self):
-        root = self.make_repo()
-        payload = self.write_payload(
-            root, "2279.md", "Build [#2279](https://github.com/acme/consumer/issues/2279)\n"
-        )
-        refresh = {
-            "state": "refresh_required", "block_handoff": True,
-            "reasons": ["topology"], "overrides": [],
-        }
-
-        with patch.object(DRIFT_GUARD, "run_check", return_value={"deny_recommended": False}), \
-             patch.object(DRIFT_GUARD, "evaluate_census", return_value=refresh):
-            blocked, message = DRIFT_GUARD.should_block(payload)
-
-        self.assertTrue(blocked)
-        self.assertIn("evaluated checkout", message)
-        self.assertIn(str(root), message)
-
-    # --- drift delta -------------------------------------------------------
-
-    def test_census_status_reports_what_drifted(self):
-        root = self.make_repo()
-        self.enable(root)
-        self.activate_current(root)
-        (root / "src" / "added.mjs").write_text("export const added = true;\n", encoding="utf-8")
-        (root / "test").mkdir()
-        (root / "test" / "proof.test.mjs").write_text("// evidence\n", encoding="utf-8")
-        (root / "src" / "index.mjs").write_text("export const ready = false;\n", encoding="utf-8")
-        subprocess.run(["git", "add", "."], cwd=root, check=True)
-
-        status = self.census_status(root)
-
-        self.assertEqual(status["state"], "refresh_required")
-        self.assertIn("topology", status["reasons"])
-        delta = status["delta"]
-        self.assertIn("src/added.mjs", delta["denominator"]["added"])
-        self.assertIn("src/index.mjs", delta["denominator"]["changed"])
-        self.assertEqual(delta["denominator"]["removed"], [])
-        self.assertIn("test/proof.test.mjs", delta["evidence"]["added"])
-        self.assertEqual(delta["families"]["added"], [])
-
-    def test_a_new_surface_and_a_removed_file_are_named_in_the_delta(self):
-        root = self.make_repo()
-        self.enable(root)
-        self.activate_current(root)
-        (root / "packages" / "api" / "src").mkdir(parents=True)
-        (root / "packages" / "api" / "src" / "index.mjs").write_text(
-            "export const api = true;\n", encoding="utf-8"
-        )
-        (root / "src" / "index.mjs").unlink()
-        subprocess.run(["git", "add", "--all"], cwd=root, check=True)
-
-        status = self.census_status(root)
-        delta = status["delta"]
-
-        self.assertIn("packages/api/src/index.mjs", delta["denominator"]["added"])
-        self.assertIn("src/index.mjs", delta["denominator"]["removed"])
-        self.assertIn("surface:packages/api", delta["families"]["added"])
-        self.assertIn("surface:src", delta["families"]["removed"])
-
-    def test_a_large_delta_stays_bounded_and_verbose_reports_everything(self):
-        root = self.make_repo()
-        self.enable(root)
-        self.activate_current(root)
-        grown = DRIFT_GUARD.CENSUS_DELTA_LIMIT + 7
-        for index in range(grown):
-            (root / "src" / f"grown-{index:03d}.mjs").write_text(
-                f"export const grown{index} = true;\n", encoding="utf-8"
-            )
-        subprocess.run(["git", "add", "."], cwd=root, check=True)
-
-        capped = self.census_status(root)["delta"]["denominator"]["added"]
-        verbose = self.census_status(root, "--verbose")["delta"]["denominator"]["added"]
-
-        self.assertEqual(len(capped), DRIFT_GUARD.CENSUS_DELTA_LIMIT + 1)
-        self.assertEqual(capped[-1], "…and 7 more")
-        self.assertEqual(len(verbose), grown)
-        self.assertIn("src/grown-000.mjs", verbose)
-
-    def test_a_census_without_an_active_snapshot_reports_no_delta(self):
-        root = self.make_repo()
-        self.enable(root)
-
-        status = self.census_status(root)
-
-        self.assertEqual(status["state"], "bootstrap")
-        self.assertIsNone(status.get("delta"))
-
-
-if __name__ == "__main__":
-    unittest.main()