@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/scripts/verify.py

@@ -1,673 +0,0 @@
-#!/usr/bin/env python3
-"""Consolidated verification script for audit-orchestrator.
-
-Runs all verification checks: lint, tests, type checks, and import validation.
-
-Usage:
-    uv run scripts/verify.py          # Run all checks
-    uv run scripts/verify.py --quick  # Quick check (+ LSP + Phase 117/118 storage gates + Phase 121 focused tests + optional DSN-gated state smoke)
-    uv run scripts/verify.py --tests  # Tests only
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import subprocess
-import sys
-import time
-from dataclasses import dataclass
-from pathlib import Path
-
-import yaml
-
-
-@dataclass
-class CheckResult:
-    """Result of a verification check."""
-
-    name: str
-    passed: bool
-    duration: float
-    output: str
-
-
-def run_command(cmd: list[str], cwd: Path | None = None) -> tuple[bool, str]:
-    """Run a command and return success status and output."""
-    try:
-        result = subprocess.run(
-            cmd,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            timeout=300,
-        )
-        output = result.stdout + result.stderr
-        return result.returncode == 0, output
-    except subprocess.TimeoutExpired:
-        return False, "Command timed out after 5 minutes"
-    except Exception as e:
-        return False, f"Error running command: {e}"
-
-
-def check_lint(project_root: Path, *, fix: bool = False) -> CheckResult:
-    """Run ruff linting (optionally with fixes)."""
-    start = time.monotonic()
-    cmd = ["uv", "run", "ruff", "check", "src/"]
-    if fix:
-        cmd.insert(4, "--fix")
-    passed, output = run_command(cmd, cwd=project_root)
-    duration = time.monotonic() - start
-    label = "Lint (ruff --fix)" if fix else "Lint (ruff)"
-    return CheckResult(label, passed, duration, output)
-
-
-def check_format(project_root: Path, *, fix: bool = False) -> CheckResult:
-    """Check ruff formatting (optionally apply formatting)."""
-    start = time.monotonic()
-    cmd = ["uv", "run", "ruff", "format", "src/"]
-    if not fix:
-        cmd.insert(4, "--check")
-    passed, output = run_command(cmd, cwd=project_root)
-    duration = time.monotonic() - start
-    label = "Format (ruff)" if fix else "Format (ruff --check)"
-    return CheckResult(label, passed, duration, output)
-
-
-def check_import(project_root: Path) -> CheckResult:
-    """Verify package imports correctly."""
-    start = time.monotonic()
-    passed, output = run_command(
-        [
-            "uv",
-            "run",
-            "python",
-            "-c",
-            "import vds_audit_orchestrator; print('OK:', vds_audit_orchestrator.__name__)",
-        ],
-        cwd=project_root,
-    )
-    duration = time.monotonic() - start
-    return CheckResult("Import check", passed, duration, output)
-
-
-def check_tests(project_root: Path, quick: bool = False) -> CheckResult:
-    """Run pytest test suite."""
-    start = time.monotonic()
-    cmd = ["uv", "run", "pytest", "tests/", "-q", "--tb=short"]
-    if quick:
-        cmd.extend(["-x", "--ignore=tests/integration"])
-    passed, output = run_command(cmd, cwd=project_root)
-    duration = time.monotonic() - start
-    return CheckResult("Tests (pytest)", passed, duration, output)
-
-
-def check_cli(project_root: Path) -> CheckResult:
-    """Verify CLI is functional."""
-    start = time.monotonic()
-    passed, output = run_command(
-        ["uv", "run", "vds-cli", "audit--help"],
-        cwd=project_root,
-    )
-    duration = time.monotonic() - start
-    return CheckResult("CLI check", passed, duration, output)
-
-
-def check_phase46(project_root: Path) -> CheckResult:
-    """Verify system-doc CLI surface and hierarchy-only regressions."""
-    start = time.monotonic()
-    commands = [
-        ["uv", "run", "vds-cli", "auditpublish-system-doc", "--help"],
-        [
-            "uv",
-            "run",
-            "python",
-            "scripts/verify_phase106_system_doc_hierarchy.py",
-        ],
-    ]
-    outputs: list[str] = []
-    for cmd in commands:
-        ok, output = run_command(cmd, cwd=project_root)
-        outputs.append(output)
-        if not ok:
-            duration = time.monotonic() - start
-            return CheckResult("Phase 46 checks", False, duration, "\n".join(outputs))
-    duration = time.monotonic() - start
-    return CheckResult("Phase 46 checks", True, duration, "\n".join(outputs))
-
-
-def check_phase47_docs(project_root: Path) -> CheckResult:
-    """Verify Phase 47 README command reference parity checks."""
-    start = time.monotonic()
-    passed, output = run_command(
-        ["uv", "run", "python", "scripts/verify_phase_43.py", "--docs-only"],
-        cwd=project_root,
-    )
-    duration = time.monotonic() - start
-    return CheckResult("Phase 47 docs parity", passed, duration, output)
-
-
-def check_phase47_state_bootstrap(project_root: Path) -> CheckResult:
-    """Verify Phase 47 state command contracts and fresh-volume runbook parity."""
-    start = time.monotonic()
-    failures: list[str] = []
-
-    required_state_commands = (
-        "validate",
-        "index-health",
-        "resolve-run-input",
-        "readiness",
-        "list-links",
-    )
-    ok, state_help = run_command(["uv", "run", "vds-cli", "auditstate", "--help"], cwd=project_root)
-    if not ok:
-        duration = time.monotonic() - start
-        return CheckResult("Phase 47 state/bootstrap", False, duration, state_help)
-
-    for command in required_state_commands:
-        if command not in state_help:
-            failures.append(f"state --help missing subcommand: {command}")
-
-    subcommand_contracts: tuple[tuple[str, tuple[str, ...]], ...] = (
-        ("validate", ("--state-dsn",)),
-        ("index-health", ("--state-dsn", "--bootstrap", "--index-type")),
-        ("resolve-run-input", ("--project", "--repo", "--state-dsn")),
-        ("readiness", ("--project", "--repo", "--state-dsn")),
-        ("list-links", ("--project", "--repo", "--state-dsn")),
-    )
-    for subcommand, expected_flags in subcommand_contracts:
-        ok, help_output = run_command(
-            ["uv", "run", "vds-cli", "auditstate", subcommand, "--help"],
-            cwd=project_root,
-        )
-        if not ok:
-            failures.append(f"state {subcommand} --help failed")
-            continue
-        for flag in expected_flags:
-            if flag not in help_output:
-                failures.append(f"state {subcommand} --help missing flag: {flag}")
-
-        for invalid_flag in ("--json", "--json-only"):
-            invalid_ok, invalid_output = run_command(
-                ["uv", "run", "vds-cli", "auditstate", subcommand, invalid_flag],
-                cwd=project_root,
-            )
-            if invalid_ok or f"No such option: {invalid_flag}" not in invalid_output:
-                failures.append(f"state {subcommand} unexpectedly accepted {invalid_flag} or error text changed")
-
-    deployment_path = project_root / "docs" / "DEPLOYMENT.md"
-    if not deployment_path.exists():
-        failures.append(f"missing deployment runbook: {deployment_path}")
-    else:
-        deployment_text = deployment_path.read_text(encoding="utf-8")
-        required_runbook_markers = (
-            "docker compose down -v",
-            "docker compose up -d audit-postgres",
-            'uv run vds-audit state init --state-dsn "$VDS_AUDIT_STATE_DSN"',
-            'uv run vds-audit state validate --state-dsn "$VDS_AUDIT_STATE_DSN"',
-            'uv run vds-audit state index-health --state-dsn "$VDS_AUDIT_STATE_DSN"',
-        )
-        for marker in required_runbook_markers:
-            if marker not in deployment_text:
-                failures.append(f"DEPLOYMENT.md missing fresh-volume marker: {marker}")
-
-        forbidden_per_command_json = (
-            "vds-audit state validate --json",
-            "vds-audit state validate --json-only",
-            "vds-audit state index-health --json",
-            "vds-audit state index-health --json-only",
-            "vds-audit state resolve-run-input --json",
-            "vds-audit state resolve-run-input --json-only",
-            "vds-audit state readiness --json",
-            "vds-audit state readiness --json-only",
-            "vds-audit state list-links --json",
-            "vds-audit state list-links --json-only",
-        )
-        for stale in forbidden_per_command_json:
-            if stale in deployment_text:
-                failures.append(f"DEPLOYMENT.md contains invalid per-command JSON flag usage: {stale}")
-
-    scripts_readme_path = project_root / "scripts" / "README.md"
-    if not scripts_readme_path.exists():
-        failures.append(f"missing scripts README: {scripts_readme_path}")
-    else:
-        scripts_readme_text = scripts_readme_path.read_text(encoding="utf-8")
-        required_scripts_markers = (
-            "Phase 47 fresh-volume closure checklist",
-            "docker compose down -v",
-            'uv run vds-audit state init --state-dsn "$VDS_AUDIT_STATE_DSN"',
-            "uv run scripts/verify.py --quick",
-            "uv run python scripts/verify_phase110_sharding.py",
-            "| `verify_phase110_sharding.py` | Focused Phase 110 gate:",
-        )
-        for marker in required_scripts_markers:
-            if marker not in scripts_readme_text:
-                failures.append(f"scripts/README.md missing Phase 47 marker: {marker}")
-
-        phase110_script_path = project_root / "scripts" / "verify_phase110_sharding.py"
-        if not phase110_script_path.exists():
-            failures.append(f"missing Phase 110 verifier script: {phase110_script_path}")
-
-    cli_reference_path = _resolve_agent_docs_reference(project_root, "reference", "cli-commands.md")
-    if not cli_reference_path.exists():
-        failures.append(f"missing CLI reference: {cli_reference_path}")
-    else:
-        cli_reference_text = cli_reference_path.read_text(encoding="utf-8")
-        required_cli_markers = (
-            "Phase 47 no-guessing rule",
-            "Phase 47 Migration Closure Gate (Fresh Volume)",
-            "Phase 47 parity rule: state subcommands do not accept per-command `--json`/`--json-only` flags",
-            "./scripts/worktree_uv.sh run --project audit_orchestrator scripts/verify.py --quick",
-        )
-        for marker in required_cli_markers:
-            if marker not in cli_reference_text:
-                failures.append(f"cli-commands.md missing Phase 47 marker: {marker}")
-
-    duration = time.monotonic() - start
-    if failures:
-        return CheckResult("Phase 47 state/bootstrap", False, duration, "\n".join(failures))
-    return CheckResult("Phase 47 state/bootstrap", True, duration, "state/bootstrap contract valid")
-
-
-def _lsp_unavailable_message(lsp_project: Path, output: str) -> str:
-    """Build actionable guidance when LSP command surface is unavailable."""
-    guidance = [
-        "LSP check failed because vds-lsp command surface is unavailable.",
-        f"Expected lsp_orchestrator project at: {lsp_project}",
-        "Suggested remediation:",
-        f"  1) uv sync --project {lsp_project}",
-        f"  2) uv run --project {lsp_project} vds-lsp health",
-        f"  3) uv run --project {lsp_project} vds-lsp type-check <repo>/src",
-        "",
-        "Command output:",
-        output.strip() or "<no output>",
-    ]
-    return "\n".join(guidance)
-
-
-def _resolve_agent_docs_reference(project_root: Path, *parts: str) -> Path:
-    """Resolve the WHO-owned agent docs path with a legacy fallback."""
-    canonical = project_root.parent / "docs" / "agents"
-    if canonical.exists():
-        return canonical.joinpath(*parts)
-    legacy = project_root.parent.parent / "insurance-document" / "agents"
-    return legacy.joinpath(*parts)
-
-
-def check_lsp(project_root: Path) -> CheckResult:
-    """Verify LSP orchestrator health and type-checking for audit_orchestrator src."""
-    start = time.monotonic()
-    lsp_project = project_root.parent / "lsp_orchestrator"
-    if not lsp_project.exists():
-        duration = time.monotonic() - start
-        message = _lsp_unavailable_message(
-            lsp_project,
-            "lsp_orchestrator directory not found.",
-        )
-        return CheckResult("LSP checks", False, duration, message)
-
-    src_path = project_root / "src"
-    commands: tuple[tuple[str, list[str]], ...] = (
-        (
-            "health",
-            ["uv", "run", "--project", str(lsp_project), "vds-cli", "lsp", "health"],
-        ),
-        (
-            "type-check",
-            [
-                "uv",
-                "run",
-                "--project",
-                str(lsp_project),
-                "vds-cli",
-                "lsp",
-                "type-check",
-                str(src_path),
-                "--mode",
-                "standard",
-            ],
-        ),
-    )
-    outputs: list[str] = []
-    unavailable_markers = (
-        "no such file or directory",
-        "command not found",
-        "no module named",
-        "entry point",
-        "failed to spawn",
-    )
-
-    for label, cmd in commands:
-        passed, output = run_command(cmd, cwd=project_root)
-        outputs.append(f"[{label}] {output.strip()}")
-        if not passed:
-            duration = time.monotonic() - start
-            lowered = output.lower()
-            if any(marker in lowered for marker in unavailable_markers):
-                message = _lsp_unavailable_message(lsp_project, output)
-                return CheckResult("LSP checks", False, duration, message)
-            return CheckResult("LSP checks", False, duration, "\n\n".join(outputs))
-
-    duration = time.monotonic() - start
-    return CheckResult("LSP checks", True, duration, "\n\n".join(outputs))
-
-
-def check_phase117_118_storage(project_root: Path) -> CheckResult:
-    """Verify Phase 117/118 real-Postgres storage gates and integration harness contract."""
-    start = time.monotonic()
-    outputs: list[str] = []
-
-    verifier_commands: tuple[tuple[str, list[str]], ...] = (
-        (
-            "phase117 verifier",
-            ["uv", "run", "python", "scripts/verify_phase117_cross_repo_evidence.py"],
-        ),
-        (
-            "phase118 verifier",
-            ["uv", "run", "python", "scripts/verify_phase118_knowledge_agent.py"],
-        ),
-    )
-    for label, cmd in verifier_commands:
-        passed, output = run_command(cmd, cwd=project_root)
-        outputs.append(f"[{label}] {output.strip()}")
-        if not passed:
-            duration = time.monotonic() - start
-            return CheckResult("Phase 117/118 storage gates", False, duration, "\n\n".join(outputs))
-
-    integration_cmd = [
-        "uv",
-        "run",
-        "pytest",
-        "tests/integration/test_phase117_118_storage.py",
-        "-q",
-    ]
-    integration_passed, integration_output = run_command(integration_cmd, cwd=project_root)
-    outputs.append(f"[phase117_118 integration] {integration_output.strip()}")
-    lowered_output = integration_output.lower()
-    skipped_for_optional_infra = (
-        "docker not available for testcontainers" in lowered_output
-        or "testcontainers optional dependency not installed" in lowered_output
-        or ("vds_audit_state_dsn" in lowered_output and "skipped" in lowered_output)
-    )
-    if not integration_passed and not skipped_for_optional_infra:
-        duration = time.monotonic() - start
-        return CheckResult("Phase 117/118 storage gates", False, duration, "\n\n".join(outputs))
-
-    duration = time.monotonic() - start
-    if skipped_for_optional_infra:
-        outputs.append(
-            "[phase117_118 integration note] Integration harness skipped cleanly because Docker, "
-            "testcontainers[postgres], or external VDS_AUDIT_STATE_DSN was unavailable."
-        )
-    return CheckResult("Phase 117/118 storage gates", True, duration, "\n\n".join(outputs))
-
-
-def check_phase121_short_circuit(project_root: Path) -> CheckResult:
-    """Verify Phase 121 short-circuit focused unit/integration coverage and validator script."""
-    start = time.monotonic()
-    outputs: list[str] = []
-
-    commands: tuple[tuple[str, list[str]], ...] = (
-        (
-            "phase121 unit tests",
-            [
-                "uv",
-                "run",
-                "pytest",
-                "tests/unit/test_workflow_short_circuit_phase121.py",
-                "-q",
-            ],
-        ),
-        (
-            "phase121 integration tests",
-            [
-                "uv",
-                "run",
-                "pytest",
-                "tests/integration/test_phase121_short_circuit.py",
-                "-q",
-            ],
-        ),
-    )
-
-    for label, cmd in commands:
-        passed, output = run_command(cmd, cwd=project_root)
-        outputs.append(f"[{label}] {output.strip()}")
-        if not passed:
-            duration = time.monotonic() - start
-            return CheckResult("Phase 121 short-circuit gates", False, duration, "\n\n".join(outputs))
-
-    validator_path = project_root / "scripts" / "verify_phase121_short_circuit.py"
-    if validator_path.exists():
-        outputs.append(
-            "[phase121 validator note] Dedicated CLI validator is present at scripts/verify_phase121_short_circuit.py"
-        )
-
-    duration = time.monotonic() - start
-    return CheckResult("Phase 121 short-circuit gates", True, duration, "\n\n".join(outputs))
-
-
-def check_state_cli_smoke(project_root: Path) -> CheckResult:
-    """Run optional real state smoke checks when VDS_AUDIT_STATE_DSN is configured."""
-    start = time.monotonic()
-    state_dsn = os.getenv("VDS_AUDIT_STATE_DSN", "").strip()
-    if not state_dsn:
-        duration = time.monotonic() - start
-        return CheckResult(
-            "State CLI smoke (dsn-gated)",
-            True,
-            duration,
-            "Skipped: set VDS_AUDIT_STATE_DSN to enable real state CLI smoke checks.",
-        )
-
-    commands: tuple[tuple[str, list[str]], ...] = (
-        (
-            "state validate",
-            ["uv", "run", "vds-cli", "auditstate", "validate", "--state-dsn", state_dsn],
-        ),
-        (
-            "state index-health",
-            ["uv", "run", "vds-cli", "auditstate", "index-health", "--state-dsn", state_dsn],
-        ),
-    )
-    outputs: list[str] = []
-    for label, cmd in commands:
-        passed, output = run_command(cmd, cwd=project_root)
-        outputs.append(f"[{label}] {output.strip()}")
-        if not passed:
-            duration = time.monotonic() - start
-            guidance = [
-                f"{label} failed.",
-                "Suggested remediation:",
-                "  1) Verify VDS_AUDIT_STATE_DSN points to a reachable Postgres instance.",
-                '  2) Initialize schema if needed: uv run vds-audit state init --state-dsn "$VDS_AUDIT_STATE_DSN"',
-                "  3) Re-run: uv run scripts/verify.py --quick",
-                "",
-                "Command output:",
-                output.strip() or "<no output>",
-            ]
-            return CheckResult("State CLI smoke (dsn-gated)", False, duration, "\n".join(guidance))
-
-    duration = time.monotonic() - start
-    return CheckResult("State CLI smoke (dsn-gated)", True, duration, "\n\n".join(outputs))
-
-
-def check_infra_contract(project_root: Path) -> CheckResult:
-    """P0: Verify Docker compose contract for shared infrastructure model."""
-    start = time.monotonic()
-    compose_path = project_root / "docker-compose.yml"
-    if not compose_path.exists():
-        duration = time.monotonic() - start
-        return CheckResult("Infra contract (compose)", False, duration, f"Missing file: {compose_path}")
-
-    try:
-        payload = yaml.safe_load(compose_path.read_text(encoding="utf-8")) or {}
-    except Exception as exc:
-        duration = time.monotonic() - start
-        return CheckResult("Infra contract (compose)", False, duration, f"Invalid YAML: {exc}")
-
-    services = payload.get("services", {})
-    orchestrator = services.get("audit-orchestrator", {})
-
-    failures: list[str] = []
-
-    # P0: Verify audit-orchestrator depends on shared postgres
-    depends_on = orchestrator.get("depends_on", {})
-    postgres_dep = depends_on.get("postgres", {})
-    if not isinstance(postgres_dep, dict):
-        # Try to find postgres dependency in any form
-        has_postgres_dep = any(
-            "postgres" in str(k).lower() or "postgres" in str(v).lower() for k, v in depends_on.items()
-        )
-        if not has_postgres_dep:
-            failures.append("P0: audit-orchestrator must depend on shared 'postgres' service")
-    elif postgres_dep.get("condition") != "service_healthy":
-        failures.append(
-            f"P0: audit-orchestrator depends_on postgres condition must be 'service_healthy', "
-            f"got: {postgres_dep.get('condition', 'none')}"
-        )
-
-    # Post-P8 v2.15.11+: Verify environment routes through PgBouncer stanza vds_audit.
-    # Schema pinning is no longer via URL `?options=` fragment — PgBouncer per-stanza
-    # connect_query handles search_path at backend startup; SQLAlchemy/psycopg
-    # connect-event listeners or _connect() helpers handle post-DISCARD-ALL re-pinning.
-    env = orchestrator.get("environment", {})
-    # Expected DSN pattern for v2.15.10+ topology (PgBouncer-routed, stanza alias as dbname)
-    expected_dsn_pattern = "vds-pgbouncer:6432/vds_audit"
-    actual_dsn = env.get("VDS_AUDIT_STATE_DSN", "")
-    if expected_dsn_pattern not in actual_dsn:
-        failures.append(
-            f"Post-P8 v2.15.11+: VDS_AUDIT_STATE_DSN must route through vds-pgbouncer:6432/vds_audit. "
-            f"Got: {actual_dsn[:80]}..."
-        )
-
-    for legacy_key in ("STATE_DSN", "LANGGRAPH_POSTGRES_DSN", "AUDIT_STATE_DSN"):
-        if legacy_key in env:
-            failures.append(f"P0: legacy DSN environment key must not be present: {legacy_key}")
-
-    # Verify restart policy
-    restart_policy = orchestrator.get("restart", "")
-    if restart_policy not in ("always", "on-failure", "unless-stopped"):
-        failures.append(
-            f"audit-orchestrator must have restart policy (always/on-failure/unless-stopped), "
-            f"got: {restart_policy or 'none'}"
-        )
-
-    # P0: Note - bootstrap SQL is now in shared infra init-schemas.sql
-    # The orchestrator's infrastructure/init-audit-state.sql may still exist for local dev
-    bootstrap_sql_path = project_root / "infrastructure" / "init-audit-state.sql"
-    if bootstrap_sql_path.exists():
-        bootstrap_sql = bootstrap_sql_path.read_text(encoding="utf-8")
-        required_fk_constraints = (
-            "CONSTRAINT fk_audit_state_corpus_documents_snapshot_id",
-            "CONSTRAINT fk_audit_state_corpus_documents_project_id",
-            "CONSTRAINT fk_audit_state_corpus_documents_repo_id",
-            "CONSTRAINT fk_audit_state_corpus_chunks_document_pk",
-            "CONSTRAINT fk_audit_state_corpus_embeddings_snapshot_id",
-            "CONSTRAINT fk_audit_state_corpus_embeddings_chunk_pk",
-        )
-        for constraint in required_fk_constraints:
-            if constraint not in bootstrap_sql:
-                failures.append(f"bootstrap DDL missing constraint contract: {constraint}")
-
-    duration = time.monotonic() - start
-    if failures:
-        return CheckResult("Infra contract (compose)", False, duration, "\n".join(failures))
-    return CheckResult("Infra contract (compose)", True, duration, "P0 compose contract valid")
-
-
-def print_result(result: CheckResult) -> None:
-    """Print a check result."""
-    status = "✅" if result.passed else "❌"
-    print(f"{status} {result.name}: {result.duration:.2f}s")
-    if not result.passed:
-        # Print first few lines of output on failure
-        lines = result.output.strip().split("\n")
-        for line in lines[-10:]:
-            print(f"   {line}")
-
-
-def main() -> int:
-    """Run verification checks."""
-    parser = argparse.ArgumentParser(description="Run verification checks")
-    parser.add_argument(
-        "--quick",
-        action="store_true",
-        help="Quick check (infra + lint + import + LSP + Phase 46/47 parity + Phase 117/118 + Phase 121 + optional state smoke)",
-    )
-    parser.add_argument("--tests", action="store_true", help="Tests only")
-    parser.add_argument("--infra", action="store_true", help="Infra contract checks only")
-    parser.add_argument("--all", action="store_true", help="Run all checks (default)")
-    parser.add_argument(
-        "--fix",
-        action="store_true",
-        help="Apply ruff autofixes + formatting (lint/format steps become write operations)",
-    )
-    args = parser.parse_args()
-
-    project_root = Path(__file__).parent.parent
-
-    print("=" * 60)
-    print("Audit Orchestrator Verification")
-    print("=" * 60)
-    print(f"Project: {project_root}")
-    print()
-
-    results: list[CheckResult] = []
-
-    if args.infra:
-        results.append(check_infra_contract(project_root))
-    elif args.tests:
-        # Tests only
-        results.append(check_tests(project_root))
-    elif args.quick:
-        # Quick checks
-        results.append(check_infra_contract(project_root))
-        results.append(check_lint(project_root, fix=args.fix))
-        results.append(check_import(project_root))
-        results.append(check_lsp(project_root))
-        results.append(check_phase46(project_root))
-        results.append(check_phase47_docs(project_root))
-        results.append(check_phase47_state_bootstrap(project_root))
-        results.append(check_phase117_118_storage(project_root))
-        results.append(check_phase121_short_circuit(project_root))
-        results.append(check_state_cli_smoke(project_root))
-    else:
-        # All checks
-        results.append(check_infra_contract(project_root))
-        results.append(check_lint(project_root, fix=args.fix))
-        results.append(check_format(project_root, fix=args.fix))
-        results.append(check_import(project_root))
-        results.append(check_lsp(project_root))
-        results.append(check_cli(project_root))
-        results.append(check_phase46(project_root))
-        results.append(check_phase47_docs(project_root))
-        results.append(check_phase47_state_bootstrap(project_root))
-        results.append(check_phase117_118_storage(project_root))
-        results.append(check_phase121_short_circuit(project_root))
-        results.append(check_state_cli_smoke(project_root))
-        results.append(check_tests(project_root))
-
-    print()
-    print("-" * 60)
-    print("Results:")
-    print("-" * 60)
-
-    for result in results:
-        print_result(result)
-
-    print()
-    total_duration = sum(r.duration for r in results)
-    passed_count = sum(1 for r in results if r.passed)
-    total_count = len(results)
-
-    if passed_count == total_count:
-        print(f"✅ All {total_count} checks passed in {total_duration:.2f}s")
-        return 0
-    else:
-        print(f"❌ {total_count - passed_count}/{total_count} checks failed")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())