devlyn-cli 3.2.1 → 3.3.0

package/config/skills/_shared/spec-verify-check.py

@@ -244,38 +244,6 @@ RISK_PROBE_INTEGRITY_FIX_HINT = (
     ".devlyn/risk-probes.jsonl or .devlyn/probes/."
 )
 INLINE_JSON_OBJECT_RE = re.compile(r'`?\{\s*"[^"\n]+"\s*:', re.IGNORECASE)
-BACKTICKED_TEXT_RE = re.compile(r"`[^`\n]+`")
-OBSERVABLE_COMMAND_MARKERS = ("command", "observable", "expose")
-RESERVED_BACKTICK_TERMS = {"solo-headroom hypothesis", "solo_claude", "miss"}
-SOLO_CEILING_CONTROL_RE = re.compile(
-    r'\bS[2-6]\b|S2-S6|solo-saturated|rejected controls?|solo ceiling',
-    re.IGNORECASE,
-)
-SOLO_CEILING_DIFFERENCE_RE = re.compile(
-    r'\bdiffer(?:s|ent|ence)?\b|\bunlike\b|\bbecause\b|\bpreserve\b|\bheadroom\b',
-    re.IGNORECASE,
-)
-COMMAND_PREFIXES = {
-    "bash",
-    "bun",
-    "cargo",
-    "git",
-    "go",
-    "jest",
-    "make",
-    "node",
-    "npm",
-    "pnpm",
-    "printf",
-    "pytest",
-    "python",
-    "python3",
-    "ruff",
-    "sh",
-    "uv",
-    "vitest",
-    "yarn",
-}
 LOCAL_URL_HOSTS = {
     'localhost',
     '127.0.0.1',
@@ -442,135 +410,6 @@ def validate_present_spec_complexity(text: str) -> str | None:
     return f"frontmatter complexity must be one of: {values}"
 
 
-def backticked_observable_miss_commands(text: str) -> list[str]:
-    commands: list[str] = []
-    for line in text.splitlines():
-        lower = line.lower()
-        if "miss" not in lower or not any(marker in lower for marker in OBSERVABLE_COMMAND_MARKERS):
-            continue
-        for match in BACKTICKED_TEXT_RE.finditer(line):
-            value = match.group(0).strip("`")
-            if is_command_like_backtick(value):
-                commands.append(value)
-    return commands
-
-
-def is_command_like_backtick(value: str) -> bool:
-    stripped = value.strip()
-    lower = stripped.lower()
-    if not stripped or lower in RESERVED_BACKTICK_TERMS:
-        return False
-    first = lower.split(maxsplit=1)[0]
-    return (
-        first in COMMAND_PREFIXES
-        or any(marker in stripped for marker in ("/", "$", "=", "|", "&&", ";"))
-        or stripped.endswith((".js", ".py", ".sh"))
-    )
-
-
-def has_backticked_observable_miss_command(text: str) -> bool:
-    return bool(backticked_observable_miss_commands(text))
-
-
-def validate_present_solo_headroom_hypothesis(text: str) -> str | None:
-    lower = text.lower()
-    if "solo-headroom hypothesis" not in lower and not ("solo_claude" in lower and "miss" in lower):
-        return None
-    if (
-        "solo-headroom hypothesis" in lower
-        and "solo_claude" in lower
-        and "miss" in lower
-        and has_backticked_observable_miss_command(text)
-    ):
-        return None
-    return (
-        "solo-headroom hypothesis must include `solo-headroom hypothesis`, "
-        "`solo_claude`, `miss`, and a backticked command/observable line "
-        "that exposes the miss"
-    )
-
-
-def validate_present_solo_ceiling_avoidance(text: str) -> str | None:
-    lower = text.lower()
-    if "solo ceiling avoidance" not in lower:
-        return None
-    if (
-        "solo_claude" in lower
-        and SOLO_CEILING_CONTROL_RE.search(text)
-        and SOLO_CEILING_DIFFERENCE_RE.search(text)
-    ):
-        return None
-    return (
-        "solo ceiling avoidance must include `solo ceiling avoidance`, "
-        "`solo_claude`, and a concrete difference from rejected or "
-        "solo-saturated controls such as `S2`-`S6`"
-    )
-
-
-def validate_solo_headroom_commands_against_expected(
-    spec_text: str,
-    commands: object,
-    expected_label: str,
-) -> str | None:
-    lower = spec_text.lower()
-    if "solo-headroom hypothesis" not in lower and not ("solo_claude" in lower and "miss" in lower):
-        return None
-    expected_cmds = {
-        command.get("cmd")
-        for command in commands
-        if isinstance(command, dict) and isinstance(command.get("cmd"), str)
-    } if isinstance(commands, list) else set()
-    hypothesis_cmds = backticked_observable_miss_commands(spec_text)
-    if any(command in expected_cmds for command in hypothesis_cmds):
-        return None
-    return (
-        "solo-headroom hypothesis observable command must match "
-        f"{expected_label} verification_commands[].cmd"
-    )
-
-
-def command_contains_expected(actual: str, expected: str) -> bool:
-    normalized_actual = " ".join(actual.split())
-    normalized_expected = " ".join(expected.split())
-    if not normalized_expected:
-        return False
-    pattern = re.compile(
-        rf"(?<![A-Za-z0-9_.:/=-]){re.escape(normalized_expected)}(?![A-Za-z0-9_.:/=-])"
-    )
-    return bool(pattern.search(normalized_actual))
-
-
-def validate_risk_probes_cover_solo_headroom_hypothesis(
-    probes: list[dict],
-    verification_text: str,
-) -> str | None:
-    hypothesis_cmds = backticked_observable_miss_commands(verification_text)
-    if not hypothesis_cmds:
-        return None
-    if not probes:
-        return None
-    derived_from = probes[0].get("derived_from")
-    if not (
-        isinstance(derived_from, str)
-        and "solo-headroom hypothesis" in derived_from.lower()
-        and any(command_contains_expected(derived_from, hypothesis_cmd) for hypothesis_cmd in hypothesis_cmds)
-    ):
-        return (
-            "risk-probes[0].derived_from must reference the solo-headroom "
-            "hypothesis bullet and observable command"
-        )
-    cmd = probes[0].get("cmd")
-    if isinstance(cmd, str) and any(
-        command_contains_expected(cmd, hypothesis_cmd)
-        for hypothesis_cmd in hypothesis_cmds
-    ):
-        return None
-    return (
-        "risk-probes[0].cmd must contain a "
-        "solo-headroom hypothesis observable command"
-    )
-
-
 def external_url_hosts(text: str) -> list[str]:
     hosts: list[str] = []
     for match in EXTERNAL_URL_RE.finditer(text or ''):
@@ -868,24 +707,7 @@ def validate_expected_against_sibling_spec(spec_path: Path, data: object) -> str
         return None
     if not spec_path.is_file():
         return None
-    try:
-        spec_text = spec_path.read_text(encoding="utf-8")
-    except OSError:
-        return None
-    solo_headroom_err = validate_present_solo_headroom_hypothesis(spec_text)
-    if solo_headroom_err:
-        return solo_headroom_err
-    solo_ceiling_err = validate_present_solo_ceiling_avoidance(spec_text)
-    if solo_ceiling_err:
-        return solo_ceiling_err
     commands = data.get("verification_commands", [])
-    solo_headroom_command_err = validate_solo_headroom_commands_against_expected(
-        spec_text,
-        commands,
-        "spec.expected.json",
-    )
-    if solo_headroom_command_err:
-        return solo_headroom_command_err
     pure_design = data.get("pure_design") is True
     if commands:
         if pure_design:
@@ -1099,12 +921,6 @@ def load_risk_probes(
         if missing:
             formatted = "; ".join(f"{r['tag']} (derived_from={r['derived_from']!r})" for r in missing)
             return ([], f"risk-probes.jsonl missing required probe(s): {formatted}")
-    solo_headroom_probe_err = validate_risk_probes_cover_solo_headroom_hypothesis(
-        probes,
-        verification_text,
-    )
-    if solo_headroom_probe_err:
-        return ([], solo_headroom_probe_err)
     return (probes, None)
 
 
@@ -1907,14 +1723,6 @@ def run_check_mode(md_path: Path) -> int:
     if frontmatter_err:
         print(f"[spec-verify --check] {md_path}: {frontmatter_err}", file=sys.stderr)
         return 2
-    solo_headroom_err = validate_present_solo_headroom_hypothesis(text)
-    if solo_headroom_err:
-        print(f"[spec-verify --check] {md_path}: {solo_headroom_err}", file=sys.stderr)
-        return 2
-    solo_ceiling_err = validate_present_solo_ceiling_avoidance(text)
-    if solo_ceiling_err:
-        print(f"[spec-verify --check] {md_path}: {solo_ceiling_err}", file=sys.stderr)
-        return 2
     expected_path = md_path.with_name("spec.expected.json")
     if expected_path.is_file():
         data, err = load_expected_contract(expected_path)
@@ -1949,14 +1757,6 @@ def run_check_mode(md_path: Path) -> int:
     if err:
         print(f"[spec-verify --check] {md_path}: shape error: {err}", file=sys.stderr)
         return 2
-    solo_headroom_command_err = validate_solo_headroom_commands_against_expected(
-        text,
-        data.get("verification_commands", []),
-        "`## Verification` JSON carrier",
-    )
-    if solo_headroom_command_err:
-        print(f"[spec-verify --check] {md_path}: {solo_headroom_command_err}", file=sys.stderr)
-        return 2
     return 0
 
 
@@ -2615,169 +2415,6 @@ def run_self_test() -> int:
             print(bad_complexity_check.stderr, file=sys.stderr)
             return 1
 
-        weak_solo_headroom = work / "weak-solo-headroom.md"
-        weak_solo_headroom.write_text(
-            "# Weak\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling.\n"
-            "- Observable command: `node check.js` exposes behavior.\n",
-            encoding="utf-8",
-        )
-        weak_solo_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(weak_solo_headroom)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if weak_solo_check.returncode == 0:
-            print("weak solo-headroom hypothesis was accepted by --check", file=sys.stderr)
-            return 1
-        if "backticked command/observable line that exposes the miss" not in weak_solo_check.stderr:
-            print("--check did not report weak solo-headroom hypothesis", file=sys.stderr)
-            print(weak_solo_check.stderr, file=sys.stderr)
-            return 1
-
-        weak_descriptive_backtick = work / "weak-descriptive-backtick.md"
-        weak_descriptive_backtick.write_text(
-            "# Weak descriptive backtick\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss behavior where observable `priority rollback` exposes the miss.\n",
-            encoding="utf-8",
-        )
-        weak_descriptive_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(weak_descriptive_backtick)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if weak_descriptive_check.returncode == 0:
-            print("descriptive backtick solo-headroom hypothesis was accepted by --check", file=sys.stderr)
-            return 1
-
-        strong_solo_headroom = work / "strong-solo-headroom.md"
-        strong_solo_headroom.write_text(
-            "# Strong\n\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling exposed by `node check.js`.\n",
-            encoding="utf-8",
-        )
-        strong_solo_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(strong_solo_headroom)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if strong_solo_check.returncode != 0:
-            print("actionable solo-headroom hypothesis was rejected by --check", file=sys.stderr)
-            print(strong_solo_check.stderr, file=sys.stderr)
-            return 1
-
-        docs_style_solo_headroom = work / "docs-style-solo-headroom.md"
-        docs_style_solo_headroom.write_text(
-            "# Docs style\n\n## Verification\n\n"
-            "- Solo-headroom hypothesis: the spec must literally contain `solo_claude`, `miss`, and an observable command; "
-            "`node check.js` exposes the miss.\n",
-            encoding="utf-8",
-        )
-        docs_style_solo_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(docs_style_solo_headroom)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if docs_style_solo_check.returncode != 0:
-            print("docs-style solo-headroom hypothesis was rejected by --check", file=sys.stderr)
-            print(docs_style_solo_check.stderr, file=sys.stderr)
-            return 1
-
-        weak_solo_ceiling = work / "weak-solo-ceiling.md"
-        weak_solo_ceiling.write_text(
-            "# Weak ceiling\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo ceiling avoidance: this is not like the previous ones.\n",
-            encoding="utf-8",
-        )
-        weak_solo_ceiling_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(weak_solo_ceiling)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if weak_solo_ceiling_check.returncode == 0:
-            print("weak solo ceiling avoidance was accepted by --check", file=sys.stderr)
-            return 1
-        if "concrete difference from rejected or solo-saturated controls" not in weak_solo_ceiling_check.stderr:
-            print("--check did not report weak solo ceiling avoidance", file=sys.stderr)
-            print(weak_solo_ceiling_check.stderr, file=sys.stderr)
-            return 1
-
-        strong_solo_ceiling = work / "strong-solo-ceiling.md"
-        strong_solo_ceiling.write_text(
-            "# Strong ceiling\n\n## Verification\n\n"
-            "- solo ceiling avoidance: unlike solo-saturated `S2`-`S6`, this uses a cross-run "
-            "state leak because solo_claude headroom should be preserved.\n",
-            encoding="utf-8",
-        )
-        strong_solo_ceiling_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(strong_solo_ceiling)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if strong_solo_ceiling_check.returncode != 0:
-            print("actionable solo ceiling avoidance was rejected by --check", file=sys.stderr)
-            print(strong_solo_ceiling_check.stderr, file=sys.stderr)
-            return 1
-
-        inline_mismatched_solo = work / "inline-mismatched-solo.md"
-        inline_mismatched_solo.write_text(
-            "# Inline mismatch\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling; "
-            "`node check.js` exposes the miss.\n\n"
-            "```json\n"
-            + json.dumps({"verification_commands": [{"cmd": "printf ok"}]})
-            + "\n```\n",
-            encoding="utf-8",
-        )
-        inline_mismatched_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(inline_mismatched_solo)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if inline_mismatched_check.returncode == 0:
-            print("mismatched inline solo-headroom command was accepted by --check", file=sys.stderr)
-            return 1
-        if "observable command must match `## Verification` JSON carrier" not in inline_mismatched_check.stderr:
-            print("--check did not report mismatched inline solo-headroom command", file=sys.stderr)
-            print(inline_mismatched_check.stderr, file=sys.stderr)
-            return 1
-
-        inline_matched_solo = work / "inline-matched-solo.md"
-        inline_matched_solo.write_text(
-            "# Inline match\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling; "
-            "`printf ok` exposes the miss.\n\n"
-            "```json\n"
-            + json.dumps({"verification_commands": [{"cmd": "printf ok"}]})
-            + "\n```\n",
-            encoding="utf-8",
-        )
-        inline_matched_check = subprocess.run(
-            [sys.executable, script_path, "--check", str(inline_matched_solo)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if inline_matched_check.returncode != 0:
-            print("matched inline solo-headroom command was rejected by --check", file=sys.stderr)
-            print(inline_matched_check.stderr, file=sys.stderr)
-            return 1
-
         (devlyn / "risk-probes.jsonl").write_text(json.dumps({
             "id": "P2",
             "derived_from": "probe must pass visible marker.",
@@ -3019,180 +2656,6 @@ def run_self_test() -> int:
             print("error_contract with unrelated derived_from was accepted", file=sys.stderr)
             return 1
 
-        spec_md.write_text(
-            "# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling; "
-            "`printf ok` exposes the miss.\n"
-            "- probe must pass visible marker.\n",
-            encoding="utf-8",
-        )
-        (devlyn / "risk-probes.jsonl").write_text(json.dumps({
-            "id": "P4",
-            "derived_from": "solo-headroom hypothesis: solo_claude should miss duplicate handling; `printf ok` exposes the miss.",
-            "cmd": "printf unrelated",
-            "exit_code": 0,
-            "stdout_contains": ["unrelated"],
-            "stdout_not_contains": [],
-            "tags": ["shape_contract"],
-            "tag_evidence": {
-                "shape_contract": [
-                    "uses_visible_input_key_names",
-                    "asserts_visible_output_key_names",
-                    "asserts_no_unexpected_output_keys",
-                ],
-            },
-        }) + "\n", encoding="utf-8")
-        bad_solo_headroom_probe = subprocess.run(
-            [sys.executable, script_path, "--validate-risk-probes"],
-            cwd=work,
-            env=env,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if bad_solo_headroom_probe.returncode == 0:
-            print("risk probe missing solo-headroom command coverage was accepted", file=sys.stderr)
-            return 1
-        if "risk-probes[0].cmd must contain a solo-headroom hypothesis observable command" not in bad_solo_headroom_probe.stderr:
-            print("solo-headroom risk-probe coverage failure had the wrong error", file=sys.stderr)
-            print(bad_solo_headroom_probe.stderr, file=sys.stderr)
-            return 1
-
-        (devlyn / "risk-probes.jsonl").write_text(json.dumps({
-            "id": "P4a",
-            "derived_from": "probe must pass visible marker.",
-            "cmd": "bash -lc 'printf ok'",
-            "exit_code": 0,
-            "stdout_contains": ["ok"],
-            "stdout_not_contains": [],
-            "tags": ["shape_contract"],
-            "tag_evidence": {
-                "shape_contract": [
-                    "uses_visible_input_key_names",
-                    "asserts_visible_output_key_names",
-                    "asserts_no_unexpected_output_keys",
-                ],
-            },
-        }) + "\n", encoding="utf-8")
-        bad_solo_headroom_derived_from = subprocess.run(
-            [sys.executable, script_path, "--validate-risk-probes"],
-            cwd=work,
-            env=env,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if bad_solo_headroom_derived_from.returncode == 0:
-            print("risk probe with unrelated solo-headroom derived_from was accepted", file=sys.stderr)
-            return 1
-        if "risk-probes[0].derived_from must reference the solo-headroom hypothesis bullet" not in bad_solo_headroom_derived_from.stderr:
-            print("solo-headroom risk-probe derived_from failure had the wrong error", file=sys.stderr)
-            print(bad_solo_headroom_derived_from.stderr, file=sys.stderr)
-            return 1
-
-        (devlyn / "risk-probes.jsonl").write_text(
-            json.dumps({
-                "id": "P5a",
-                "derived_from": "solo-headroom hypothesis: solo_claude should miss duplicate handling; `printf ok` exposes the miss.",
-                "cmd": "printf first-unrelated",
-                "exit_code": 0,
-                "stdout_contains": ["first-unrelated"],
-                "stdout_not_contains": [],
-                "tags": ["shape_contract"],
-                "tag_evidence": {
-                    "shape_contract": [
-                        "uses_visible_input_key_names",
-                        "asserts_visible_output_key_names",
-                        "asserts_no_unexpected_output_keys",
-                    ],
-                },
-            }) + "\n" + json.dumps({
-                "id": "P5b",
-                "derived_from": "probe must pass visible marker.",
-                "cmd": "bash -lc 'printf ok'",
-                "exit_code": 0,
-                "stdout_contains": ["ok"],
-                "stdout_not_contains": [],
-                "tags": ["shape_contract"],
-                "tag_evidence": {
-                    "shape_contract": [
-                        "uses_visible_input_key_names",
-                        "asserts_visible_output_key_names",
-                        "asserts_no_unexpected_output_keys",
-                    ],
-                },
-            }) + "\n",
-            encoding="utf-8",
-        )
-        late_solo_headroom_probe = subprocess.run(
-            [sys.executable, script_path, "--validate-risk-probes"],
-            cwd=work,
-            env=env,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if late_solo_headroom_probe.returncode == 0:
-            print("solo-headroom command in a later risk probe was accepted", file=sys.stderr)
-            return 1
-
-        (devlyn / "risk-probes.jsonl").write_text(json.dumps({
-            "id": "P5c",
-            "derived_from": "solo-headroom hypothesis: solo_claude should miss duplicate handling; `printf ok` exposes the miss.",
-            "cmd": "printf ok2",
-            "exit_code": 0,
-            "stdout_contains": ["ok2"],
-            "stdout_not_contains": [],
-            "tags": ["shape_contract"],
-            "tag_evidence": {
-                "shape_contract": [
-                    "uses_visible_input_key_names",
-                    "asserts_visible_output_key_names",
-                    "asserts_no_unexpected_output_keys",
-                ],
-            },
-        }) + "\n", encoding="utf-8")
-        prefix_solo_headroom_probe = subprocess.run(
-            [sys.executable, script_path, "--validate-risk-probes"],
-            cwd=work,
-            env=env,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if prefix_solo_headroom_probe.returncode == 0:
-            print("solo-headroom command prefix match was accepted", file=sys.stderr)
-            return 1
-
-        (devlyn / "risk-probes.jsonl").write_text(json.dumps({
-            "id": "P5",
-            "derived_from": "solo-headroom hypothesis: solo_claude should miss duplicate handling; `printf ok` exposes the miss.",
-            "cmd": "bash -lc 'printf ok'",
-            "exit_code": 0,
-            "stdout_contains": ["ok"],
-            "stdout_not_contains": [],
-            "tags": ["shape_contract"],
-            "tag_evidence": {
-                "shape_contract": [
-                    "uses_visible_input_key_names",
-                    "asserts_visible_output_key_names",
-                    "asserts_no_unexpected_output_keys",
-                ],
-            },
-        }) + "\n", encoding="utf-8")
-        good_solo_headroom_probe = subprocess.run(
-            [sys.executable, script_path, "--validate-risk-probes"],
-            cwd=work,
-            env=env,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if good_solo_headroom_probe.returncode != 0:
-            print("risk probe covering solo-headroom command was rejected", file=sys.stderr)
-            print(good_solo_headroom_probe.stderr, file=sys.stderr)
-            return 1
-
         expected_json = work / "spec.expected.json"
         expected_json.write_text(json.dumps({
             "verification_commands": [
@@ -3209,122 +2672,6 @@ def run_self_test() -> int:
             "forbidden_files": [],
             "max_deps_added": 0,
         }) + "\n", encoding="utf-8")
-        spec_md.write_text(
-            "# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling.\n"
-            "- Observable command: `node check.js` exposes behavior.\n",
-            encoding="utf-8",
-        )
-        weak_sibling_solo = subprocess.run(
-            [sys.executable, script_path, "--check-expected", str(expected_json)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if weak_sibling_solo.returncode == 0:
-            print("weak sibling solo-headroom hypothesis was accepted by --check-expected", file=sys.stderr)
-            return 1
-        if "backticked command/observable line that exposes the miss" not in weak_sibling_solo.stderr:
-            print("--check-expected did not report weak sibling solo-headroom hypothesis", file=sys.stderr)
-            print(weak_sibling_solo.stderr, file=sys.stderr)
-            return 1
-
-        spec_md.write_text(
-            "# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling; "
-            "`node check.js` exposes the miss.\n",
-            encoding="utf-8",
-        )
-        mismatched_sibling_solo = subprocess.run(
-            [sys.executable, script_path, "--check-expected", str(expected_json)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if mismatched_sibling_solo.returncode == 0:
-            print("mismatched sibling solo-headroom command was accepted by --check-expected", file=sys.stderr)
-            return 1
-        if "observable command must match spec.expected.json" not in mismatched_sibling_solo.stderr:
-            print("--check-expected did not report mismatched sibling solo-headroom command", file=sys.stderr)
-            print(mismatched_sibling_solo.stderr, file=sys.stderr)
-            return 1
-
-        spec_md.write_text(
-            "# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo-headroom hypothesis: solo_claude should miss duplicate handling; "
-            "`printf ok` exposes the miss.\n",
-            encoding="utf-8",
-        )
-        matched_sibling_solo = subprocess.run(
-            [sys.executable, script_path, "--check-expected", str(expected_json)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if matched_sibling_solo.returncode != 0:
-            print("matched sibling solo-headroom command was rejected by --check-expected", file=sys.stderr)
-            print(matched_sibling_solo.stderr, file=sys.stderr)
-            return 1
-
-        spec_md.write_text(
-            "# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- Solo-headroom hypothesis: the spec must literally contain `solo_claude`, `miss`, and an observable command; "
-            "`printf ok` exposes the miss.\n",
-            encoding="utf-8",
-        )
-        docs_style_sibling_solo = subprocess.run(
-            [sys.executable, script_path, "--check-expected", str(expected_json)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if docs_style_sibling_solo.returncode != 0:
-            print("docs-style sibling solo-headroom command was rejected by --check-expected", file=sys.stderr)
-            print(docs_style_sibling_solo.stderr, file=sys.stderr)
-            return 1
-
-        spec_md.write_text(
-            "# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo ceiling avoidance: this differs from controls but omits the required baseline.\n",
-            encoding="utf-8",
-        )
-        weak_sibling_solo_ceiling = subprocess.run(
-            [sys.executable, script_path, "--check-expected", str(expected_json)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if weak_sibling_solo_ceiling.returncode == 0:
-            print("weak sibling solo ceiling avoidance was accepted by --check-expected", file=sys.stderr)
-            return 1
-        if "concrete difference from rejected or solo-saturated controls" not in weak_sibling_solo_ceiling.stderr:
-            print("--check-expected did not report weak sibling solo ceiling avoidance", file=sys.stderr)
-            print(weak_sibling_solo_ceiling.stderr, file=sys.stderr)
-            return 1
-
-        spec_md.write_text(
-            "# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n"
-            "- solo ceiling avoidance: unlike solo-saturated `S2`-`S6`, this includes a "
-            "multi-run temporal dependency because solo_claude headroom should remain.\n",
-            encoding="utf-8",
-        )
-        strong_sibling_solo_ceiling = subprocess.run(
-            [sys.executable, script_path, "--check-expected", str(expected_json)],
-            cwd=work,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-        )
-        if strong_sibling_solo_ceiling.returncode != 0:
-            print("actionable sibling solo ceiling avoidance was rejected by --check-expected", file=sys.stderr)
-            print(strong_sibling_solo_ceiling.stderr, file=sys.stderr)
-            return 1
-
         spec_md.write_text("# Spec\n\n<!-- devlyn:verification -->\n## Verification\n\n- probe must pass visible marker.\n", encoding="utf-8")
         expected_good = subprocess.run(
             [sys.executable, script_path, "--check-expected", str(expected_json)],