@blxzer/cursor-trellis 0.3.5 → 0.4.0

package/dist/templates/trellis/scripts/pool.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Review-pool CLI: validate / plan-check / link / unlink / show.
+
+Usage:
+    python pool.py validate [--root <repo>]
+    python pool.py plan-check [--root <repo>]
+    python pool.py link <item-id> <task-ref> [--root <repo>]
+    python pool.py unlink <item-id> <task-ref> [--root <repo>]
+    python pool.py show <item-id> [--root <repo>]
+
+Exit codes: any error-level finding (or a failed link/unlink/show) -> 1;
+warnings only -> 0.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from common.io import read_json
+from common.log import Colors, colored
+from common.paths import get_repo_root
+from common import pool_store
+
+
+def _print_issue(issue: pool_store.Issue) -> None:
+    color = Colors.RED if issue.is_error else Colors.YELLOW
+    level = "error" if issue.is_error else "warning"
+    location = f" ({issue.path})" if issue.path is not None else ""
+    print(colored(f"[{level}] {issue.code}: {issue.message}{location}", color))
+
+
+def _exit_for_issues(issues: list[pool_store.Issue]) -> int:
+    errors = [issue for issue in issues if issue.is_error]
+    warnings = [issue for issue in issues if not issue.is_error]
+    for issue in issues:
+        _print_issue(issue)
+    if not issues:
+        print(colored("OK", Colors.GREEN))
+    elif not errors:
+        print(colored(f"OK with {len(warnings)} warning(s)", Colors.GREEN))
+    else:
+        print(colored(f"{len(errors)} error(s), {len(warnings)} warning(s)", Colors.RED))
+    return 1 if errors else 0
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    issues = pool_store.validate_pool(args.root)
+    return _exit_for_issues(issues)
+
+
+def cmd_plan_check(args: argparse.Namespace) -> int:
+    issues = pool_store.check_plan(args.root)
+    return _exit_for_issues(issues)
+
+
+def cmd_link(args: argparse.Namespace) -> int:
+    result = pool_store.link_item_task(args.root, args.item_id, args.task_ref)
+    for issue in result.errors:
+        _print_issue(issue)
+    if not result.ok:
+        return 1
+    print(colored(f"linked {result.item_id} <-> {result.task_ref}", Colors.GREEN))
+    item = pool_store.load_item(args.root, result.item_id)
+    if item is not None:
+        print(f"  item.linked_tasks: {item.linked_tasks or '[]'}")
+    data = read_json(result.task_path / "task.json") if result.task_path else None
+    if data is not None:
+        print(f"  task.meta.pool_items: {pool_store.get_pool_items(data) or '[]'}")
+    return 0
+
+
+def cmd_unlink(args: argparse.Namespace) -> int:
+    result = pool_store.unlink_item_task(args.root, args.item_id, args.task_ref)
+    for issue in result.errors:
+        _print_issue(issue)
+    if not result.ok:
+        return 1
+    for issue in result.warnings:
+        _print_issue(issue)
+    print(colored(f"unlinked {result.item_id} <-> {result.task_ref}", Colors.GREEN))
+    return 0
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    item = pool_store.load_item(args.root, args.item_id)
+    if item is None:
+        print(
+            colored(
+                f"[error] item-not-found: pool item {args.item_id!r} not found",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 1
+    tasks_dir = args.root / ".cstl" / "tasks"
+    print(f"id: {item.id or '<missing>'}")
+    print(f"title: {item.title or '<missing>'}")
+    print(f"status: {item.status or '<missing>'}")
+    print(f"type: {item.type or '<missing>'}")
+    print(f"path: {item.path}")
+    if not item.linked_tasks:
+        print("linked_tasks: []")
+    for ref in item.linked_tasks:
+        task_dir = pool_store.find_task_dir(ref, tasks_dir)
+        if task_dir is None:
+            print(f"linked_tasks: {ref} (missing)")
+            continue
+        data = read_json(task_dir / "task.json") or {}
+        status = data.get("status", "?")
+        archived = "archive/" in task_dir.as_posix()
+        suffix = " (archived)" if archived else ""
+        print(f"linked_tasks: {ref} -> {task_dir.name} ({status}){suffix}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pool.py",
+        description="Review-pool maintenance CLI: validate, plan-check, link, unlink, show.",
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=None,
+        help="Repository root. Defaults to nearest parent containing .cstl/.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    def add_root(entry_parser: argparse.ArgumentParser) -> None:
+        # SUPPRESS so a missing subcommand --root never clobbers the global
+        # --root with None (argparse subparser defaults overwrite parent values).
+        entry_parser.add_argument(
+            "--root",
+            type=Path,
+            default=argparse.SUPPRESS,
+            help="Repository root (overrides the global --root).",
+        )
+
+    validate_parser = subparsers.add_parser(
+        "validate",
+        help="Validate pool entries (sections, frontmatter, links, consistency).",
+    )
+    add_root(validate_parser)
+    plan_parser = subparsers.add_parser(
+        "plan-check",
+        help="Check plan.md references against known pool item ids.",
+    )
+    add_root(plan_parser)
+    link_parser = subparsers.add_parser(
+        "link",
+        help="Link a pool item to a task on both sides (idempotent).",
+    )
+    add_root(link_parser)
+    link_parser.add_argument("item_id", help="Pool item id, e.g. P01")
+    link_parser.add_argument("task_ref", help="Task dir name or resolvable ref")
+    unlink_parser = subparsers.add_parser(
+        "unlink",
+        help="Remove the item<->task link on both sides (best-effort).",
+    )
+    add_root(unlink_parser)
+    unlink_parser.add_argument("item_id", help="Pool item id, e.g. P01")
+    unlink_parser.add_argument("task_ref", help="Task dir name or resolvable ref")
+    show_parser = subparsers.add_parser(
+        "show",
+        help="Print one pool item with linked task statuses.",
+    )
+    add_root(show_parser)
+    show_parser.add_argument("item_id", help="Pool item id, e.g. P01")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    root = getattr(args, "root", None)
+    args.root = root.resolve() if root is not None else get_repo_root()
+
+    handlers = {
+        "validate": cmd_validate,
+        "plan-check": cmd_plan_check,
+        "link": cmd_link,
+        "unlink": cmd_unlink,
+        "show": cmd_show,
+    }
+    return handlers[args.command](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/templates/trellis/scripts/retrieval_probe_matrix_template.json

@@ -85,11 +85,11 @@
     },
     {
       "id": "P-10",
-      "label": "Definition / reference via codegraph (LSP not in Agent tool table)",
+      "label": "Definition / reference — Prefer Grep+Read; codegraph when ambiguous",
       "nature": "local-mcp",
       "expected_byok": "pass",
-      "native": { "status": "pass", "evidence": "codegraph_search + node; def route_codebase_retrieval L791; GO_TO_DEFINITION none", "actual_tool": "codegraph_search", "probed_at": "2026-06-23" },
-      "byok":   { "status": "pass", "evidence": "codegraph_node at def route_codebase_retrieval; GO_TO_DEFINITION none", "actual_tool": "codegraph_node", "probed_at": "2026-06-23" }
+      "native": { "status": "pass", "evidence": "Grep def route_codebase_retrieval L805 codebase_retrieval_router.py; Read confirm; GO_TO_DEFINITION none; codegraph optional", "actual_tool": "Grep", "probed_at": "2026-08-05" },
+      "byok":   { "status": "pass", "evidence": "Grep+Read same as native; GO_TO_DEFINITION none", "actual_tool": "Grep", "probed_at": "2026-08-05" }
     },
     {
       "id": "P-08-SA",

package/dist/templates/trellis/scripts/spec_health_outcomes.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""S1 spec-health outcomes — read-only durable-learning distribution over archive verify.md.
+
+Maintainer observability only — NOT a blocking gate or KPI.
+See .cstl/spec/guides/durable-learning-decision-guide.md for outcome definitions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+_SCRIPT_DIR = Path(__file__).resolve().parent
+if str(_SCRIPT_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPT_DIR))
+
+from common.task_gates import NO_DURABLE_LEARNING_RE  # noqa: E402
+
+BUCKET_NAMES = ("no_only", "spec", "artifact", "ambiguous_multi", "legacy_none")
+
+MONTH_RE = re.compile(r"^(\d{4}-\d{2})$")
+
+
+def detect_signals(content: str) -> dict[str, bool]:
+    """Return which durable-learning signal families appear in verify.md text.
+
+    Uses the same substring probes as spec-health-signals.md S1 baseline (2026-08-06).
+    """
+    lower = content.lower()
+    return {
+        "no": bool(NO_DURABLE_LEARNING_RE.search(content)),
+        "spec": "spec update evidence" in lower,
+        "artifact": "learning artifact" in lower,
+    }
+
+
+def classify_bucket(content: str) -> str:
+    """Assign exactly one mutually-exclusive S1 outcome bucket."""
+    active = [name for name, present in detect_signals(content).items() if present]
+    if not active:
+        return "legacy_none"
+    if len(active) > 1:
+        return "ambiguous_multi"
+    return {"no": "no_only", "spec": "spec", "artifact": "artifact"}[active[0]]
+
+
+def extract_month(verify_path: Path, archive_root: Path) -> str | None:
+    """Derive YYYY-MM from archive folder layout (e.g. archive/2026-08/<task>/verify.md)."""
+    try:
+        rel = verify_path.relative_to(archive_root)
+    except ValueError:
+        return None
+    if rel.parts and MONTH_RE.match(rel.parts[0]):
+        return rel.parts[0]
+    return None
+
+
+def empty_counts() -> dict[str, int]:
+    return {name: 0 for name in BUCKET_NAMES}
+
+
+def scan_archive(root: Path) -> tuple[dict[str, int], dict[str, dict[str, int]], int]:
+    totals = empty_counts()
+    by_month: dict[str, dict[str, int]] = defaultdict(empty_counts)
+    total_files = 0
+
+    for verify_path in sorted(root.rglob("verify.md")):
+        if not verify_path.is_file():
+            continue
+        total_files += 1
+        try:
+            content = verify_path.read_text(encoding="utf-8")
+        except OSError:
+            content = ""
+        bucket = classify_bucket(content)
+        totals[bucket] += 1
+        month = extract_month(verify_path, root)
+        if month:
+            by_month[month][bucket] += 1
+
+    return totals, dict(sorted(by_month.items())), total_files
+
+
+def build_report(root: Path, *, by_month: bool) -> dict[str, Any]:
+    totals, monthly, total_files = scan_archive(root)
+    report: dict[str, Any] = {
+        "root": str(root),
+        "total": total_files,
+        "buckets": totals,
+        "note": "Maintainer observability only — not a blocking gate or KPI.",
+    }
+    if by_month:
+        report["by_month"] = monthly
+    return report
+
+
+def format_text_report(report: dict[str, Any]) -> str:
+    lines = [
+        f"Spec health S1 outcomes — {report['total']} verify.md files",
+        f"Root: {report['root']}",
+        "",
+    ]
+    total = int(report["total"])
+    for name in BUCKET_NAMES:
+        count = int(report["buckets"][name])
+        pct = (count / total * 100) if total else 0.0
+        lines.append(f"  {name}: {count} ({pct:.1f}%)")
+    lines.extend(["", str(report["note"])])
+    if report.get("by_month"):
+        lines.append("")
+        lines.append("By month:")
+        for month, counts in report["by_month"].items():
+            month_total = sum(int(v) for v in counts.values())
+            lines.append(f"  {month}: {month_total} files — {counts}")
+    return "\n".join(lines)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            "S1 spec-health: durable-learning outcome distribution in archive verify.md "
+            "(read-only; not a gate)."
+        ),
+    )
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=Path(".cstl/tasks/archive"),
+        help="Archive root to scan (default: .cstl/tasks/archive)",
+    )
+    parser.add_argument("--json", action="store_true", help="Emit JSON report on stdout")
+    parser.add_argument(
+        "--by-month",
+        action="store_true",
+        help="Include per YYYY-MM bucket counts (from archive folder names)",
+    )
+    args = parser.parse_args(argv)
+
+    root = args.root.resolve()
+    if not root.is_dir():
+        print(f"error: archive root not found: {root}", file=sys.stderr)
+        return 1
+
+    report = build_report(root, by_month=args.by_month)
+
+    if args.json:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    else:
+        print(format_text_report(report))
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/dist/templates/trellis/scripts/task.py

@@ -17,6 +17,8 @@ Usage:
     python task.py set-branch <dir> <branch>   # Set git branch
     python task.py set-base-branch <dir> <branch>  # Set PR target branch
     python task.py set-scope <dir> <scope>     # Set scope for PR title
+    python task.py set-deps <dir> <id...>      # Set task-level depends_on (soft checks)
+    python task.py set-depends-mode <dir> <warn|block|off>  # Dependency policy mode
     python task.py archive <task-dir> [--check] [--archive-integrated-children] # Check or archive completed task
     python task.py prepare-archive-evidence <task-dir> [--dry-run]  # Draft missing verify.md archive evidence
     python task.py prepare-learning-scaffold <task-dir> [--trigger <text>]  # Print spec-capture checklist (stdout only)
@@ -69,6 +71,7 @@ from common.task_gates import (
     write_gate_record,
 )
 from common.task_utils import resolve_task_dir, run_task_hooks
+from common.task_dependencies import read_depends_mode
 from common.tasks import (
     children_progress,
     format_child_task_display,
@@ -86,6 +89,9 @@ from common.task_store import (
     cmd_set_branch,
     cmd_set_base_branch,
     cmd_set_scope,
+    cmd_set_deps,
+    cmd_set_depends_mode,
+    append_depends_ignore_event,
     cmd_add_subtask,
     cmd_remove_subtask,
     cmd_prepare_child_worktree,
@@ -97,6 +103,7 @@ from common.task_store import (
     cmd_parent_status,
     cmd_publish_pack,
     cmd_review_child,
+    cmd_artifact_locale,
 )
 from common.task_context import (
     cmd_add_context,
@@ -240,6 +247,15 @@ def _print_guard_errors(items: list[str], stream=None) -> None:
         print(f"  - {item}", file=stream)
 
 
+def _print_dependency_warnings(guard) -> None:
+    """Print dependency warnings (Plan A soft checks; never affect PASS/FAIL)."""
+    for warning in guard.warnings:
+        print(
+            colored(f"[dependencies] WARN: {warning}", Colors.YELLOW),
+            file=sys.stderr,
+        )
+
+
 def cmd_start_execution(args: argparse.Namespace) -> int:
     """Start approved task execution after a non-mutating readiness check."""
     repo_root = get_repo_root()
@@ -258,6 +274,7 @@ def cmd_start_execution(args: argparse.Namespace) -> int:
             for hint in start_execution_repair_hints(guard.errors, task_dir):
                 print(f"  Hint: {hint}")
             return 1
+        _print_dependency_warnings(guard)
         print(colored("Start-execution check: PASS", Colors.GREEN))
         print(f"Contract fingerprint: {guard.contract_fingerprint}")
         baseline_fingerprint = guard.artifact_fingerprints.get(BASELINE_GATE)
@@ -293,13 +310,29 @@ def cmd_start_execution(args: argparse.Namespace) -> int:
         print("Run with --check for non-mutating preflight or --approved after explicit user approval.", file=sys.stderr)
         return 1
 
-    guard = validate_start_execution(task_dir, task_data, approved=True)
+    ignore_deps = bool(getattr(args, "ignore_deps", False))
+    guard = validate_start_execution(
+        task_dir,
+        task_data,
+        approved=True,
+        ignore_deps=ignore_deps,
+        enforce_deps_block=True,
+    )
     if not guard.ok:
         print(colored("Error: cannot start execution; readiness check failed.", Colors.RED), file=sys.stderr)
         _print_guard_errors(guard.errors, stream=sys.stderr)
         return 1
 
+    _print_dependency_warnings(guard)
+
     assert task_data is not None
+    if ignore_deps and guard.deps_blocking_summary:
+        append_depends_ignore_event(
+            task_data,
+            command="start-execution",
+            mode=read_depends_mode(task_data),
+            blocking_summary=guard.deps_blocking_summary,
+        )
     if guard.baseline_record:
         write_gate_record(task_data, "start-execution", BASELINE_GATE, guard.baseline_record)
     for gate, record in guard.auto_gate_records.items():
@@ -536,6 +569,7 @@ Usage:
   python task.py set-branch <dir> <branch>          Set git branch
   python task.py set-base-branch <dir> <branch>     Set PR target branch
   python task.py set-scope <dir> <scope>            Set scope for PR title
+  python task.py set-deps <dir> [dep ...]           Set depends_on (no deps clears to [])
   python task.py archive <task-dir> [--check]       Check or archive completed task
   python task.py add-subtask <parent> <child>       Link child task to parent
   python task.py remove-subtask <parent> <child>    Unlink child from parent
@@ -671,6 +705,11 @@ def main() -> int:
                                    help="Run non-mutating execution readiness check")
     p_start_execution.add_argument("--approved", action="store_true",
                                    help="Record explicit approval and start execution")
+    p_start_execution.add_argument(
+        "--ignore-deps",
+        action="store_true",
+        help="Override blocking dependencies (depends_mode=block) and record an audit event",
+    )
 
     # record-gate
     p_record_gate = subparsers.add_parser("record-gate", help="Record reviewer quality gate")
@@ -707,6 +746,43 @@ def main() -> int:
     p_scope.add_argument("dir", help="Task directory")
     p_scope.add_argument("scope", help="Scope name")
 
+    # set-deps
+    p_deps = subparsers.add_parser(
+        "set-deps",
+        help="Set task-level depends_on (declare only; soft checks in Plan A)",
+    )
+    p_deps.add_argument("dir", help="Task directory or name")
+    p_deps.add_argument(
+        "dep",
+        nargs="*",
+        help="Dependency task ids (bare id or pool:Pxx). No deps clears to [].",
+    )
+
+    # set-depends-mode
+    p_depends_mode = subparsers.add_parser(
+        "set-depends-mode",
+        help="Set meta.depends_mode (warn | block | off) for dependency policy",
+    )
+    p_depends_mode.add_argument("dir", help="Task directory or name")
+    p_depends_mode.add_argument(
+        "mode",
+        choices=["warn", "block", "off"],
+        help="warn = Plan A soft checks (default); block = hard gates at "
+        "start-execution --approved and set-child-state working; off = silent",
+    )
+
+    # artifact-locale
+    p_artifact_locale = subparsers.add_parser(
+        "artifact-locale",
+        help="Get or set human-reviewed artifact locale (zh | en)",
+    )
+    locale_sub = p_artifact_locale.add_subparsers(dest="artifact_locale_command")
+    p_locale_get = locale_sub.add_parser("get", help="Print resolved artifact locale")
+    p_locale_get.add_argument("--task", help="Task directory (includes task override)")
+    p_locale_set = locale_sub.add_parser("set", help="Set artifact locale")
+    p_locale_set.add_argument("locale", choices=["zh", "en"], help="Locale code")
+    p_locale_set.add_argument("--task", help="Task directory (task-level override)")
+
     # archive
     p_archive = subparsers.add_parser("archive", help="Archive task")
     p_archive.add_argument("name", help="Task directory or name")
@@ -782,6 +858,11 @@ def main() -> int:
     p_integrate_child.add_argument("--ref", help="Child git ref or reviewed diff reference")
     p_integrate_child.add_argument("--reason", help="Optional short reason")
     p_integrate_child.add_argument("--execute-merge", action="store_true", help="Execute git merge --no-ff --no-commit for an integrated Child")
+    p_integrate_child.add_argument(
+        "--no-publish-pack",
+        action="store_true",
+        help="Skip auto publish-pack after integrated (default: refresh child-prompts/ including evidence-only integrates)",
+    )
     p_integrate_child.add_argument("--check", action="store_true", help="Run non-mutating integration readiness check")
 
     # suggest-execution-strategy
@@ -921,6 +1002,8 @@ def main() -> int:
         "set-branch": cmd_set_branch,
         "set-base-branch": cmd_set_base_branch,
         "set-scope": cmd_set_scope,
+        "set-deps": cmd_set_deps,
+        "set-depends-mode": cmd_set_depends_mode,
         "archive": cmd_archive,
         "prepare-archive-evidence": cmd_prepare_archive_evidence,
         "prepare-learning-scaffold": cmd_prepare_learning_scaffold,
@@ -935,6 +1018,7 @@ def main() -> int:
         "parent-status": cmd_parent_status,
         "publish-pack": cmd_publish_pack,
         "review-child": cmd_review_child,
+        "artifact-locale": cmd_artifact_locale,
         "list": cmd_list,
         "list-archive": cmd_list_archive,
     }

package/dist/templates/trellis/scripts/verify_evidence_probe.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Verification evidence probe — repeatable false-green detection.
+
+Evaluates a fixture verify.md against closeout-profile evidence requirements
+by reusing task_gates.verify_evidence_status() (no duplicate rule set).
+
+Exit 0 when actual outcome matches --expect; exit 1 on mismatch or error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import io
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+_SCRIPTS = Path(__file__).resolve().parent
+if str(_SCRIPTS) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS))
+
+from common.task_gates import verify_evidence_status  # noqa: E402
+
+if sys.platform.startswith("win"):
+    for _stream_name in ("stdin", "stdout", "stderr"):
+        _stream = getattr(sys, _stream_name, None)
+        if _stream is None and _stream_name != "stdin":
+            continue
+        if _stream is None:
+            continue
+        if hasattr(_stream, "reconfigure"):
+            try:
+                _stream.reconfigure(encoding="utf-8", errors="replace")
+            except Exception:
+                pass
+        elif hasattr(_stream, "detach"):
+            try:
+                setattr(
+                    sys,
+                    _stream_name,
+                    io.TextIOWrapper(_stream.detach(), encoding="utf-8", errors="replace"),
+                )
+            except Exception:
+                pass
+
+PROFILE_REQUIRED_SIGNALS: dict[str, list[str]] = {
+    "lite": ["validation", "acceptance", "durable_learning"],
+    "full": [
+        "validation",
+        "acceptance",
+        "durable_learning",
+        "check_evidence",
+        "reviewed_change_set",
+    ],
+    "parent": [
+        "validation",
+        "acceptance",
+        "durable_learning",
+        "integration",
+    ],
+}
+
+
+def evaluate_fixture(fixture_path: Path, profile: str) -> tuple[bool, dict[str, bool], list[str]]:
+    """Return (passes, status_map, missing_signals) for a fixture verify.md."""
+    profile = profile.lower().strip()
+    if profile not in PROFILE_REQUIRED_SIGNALS:
+        raise ValueError(f"unknown profile: {profile}")
+
+    required = PROFILE_REQUIRED_SIGNALS[profile]
+    task_data: dict = {"children": ["probe-child"] if profile == "parent" else []}
+
+    with tempfile.TemporaryDirectory(prefix="cstl-verify-probe-") as tmp:
+        task_dir = Path(tmp)
+        shutil.copy2(fixture_path, task_dir / "verify.md")
+        status = verify_evidence_status(task_dir, task_data)
+
+    missing = [signal for signal in required if not status.get(signal)]
+    return len(missing) == 0, status, missing
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Probe verify.md fixture against closeout evidence requirements.",
+    )
+    parser.add_argument(
+        "--fixture",
+        required=True,
+        type=Path,
+        help="Path to fixture verify.md",
+    )
+    parser.add_argument(
+        "--profile",
+        required=True,
+        choices=sorted(PROFILE_REQUIRED_SIGNALS),
+        help="Closeout profile to evaluate against",
+    )
+    parser.add_argument(
+        "--expect",
+        required=True,
+        choices=("pass", "fail"),
+        help="Expected probe outcome",
+    )
+    args = parser.parse_args(argv)
+
+    fixture = args.fixture.resolve()
+    if not fixture.is_file():
+        print(f"verify-evidence-probe: fixture not found: {fixture}", file=sys.stderr)
+        return 2
+
+    try:
+        passes, status, missing = evaluate_fixture(fixture, args.profile)
+    except ValueError as exc:
+        print(f"verify-evidence-probe: {exc}", file=sys.stderr)
+        return 2
+
+    actual = "pass" if passes else "fail"
+    expected = args.expect.lower()
+
+    print(f"fixture: {fixture}")
+    print(f"profile: {args.profile}")
+    print(f"status: {status}")
+    if missing:
+        print(f"missing: {', '.join(missing)}")
+    print(f"actual: {actual}")
+    print(f"expect: {expected}")
+
+    if actual == expected:
+        print("result: OK")
+        return 0
+
+    print("result: MISMATCH", file=sys.stderr)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())