@michaelxwb/code-flow 0.6.5 → 1.0.0

package/src/core/code-flow/scripts/cf_acceptance_runner.py

@@ -1,192 +0,0 @@
-#!/usr/bin/env python3
-"""Execute manifest scenarios with deterministic ordering and evidence."""
-
-from __future__ import annotations
-
-import argparse
-import json
-from pathlib import Path
-import sys
-from typing import IO, Mapping, Optional, Sequence
-
-from cf_exec_base import execution_key, run_command, invalidate_executions
-from cf_acceptance_schema import load_manifest, validate_execution_baseline
-from cf_acceptance_evidence import persist_results
-
-
-def _run(
-    item: Mapping[str, object], root: Path, include_e2e: bool = False, deadline: Optional[float] = None,
-    only_e2e: bool = False,
-) -> dict[str, object]:
-    scenario_id = str(item.get("id", "unknown"))
-    kind = str(item.get("kind", "functional"))
-    if only_e2e and kind != "e2e":
-        return {"id": scenario_id, "kind": kind, "status": "not_included"}
-    if kind == "manual":
-        return {"id": scenario_id, "kind": kind, "status": "manual_pending"}
-    if kind == "e2e" and not include_e2e and not only_e2e:
-        return {"id": scenario_id, "kind": kind, "status": "e2e_deferred"}
-    command = item.get("command")
-    if not isinstance(command, list) or not command or not all(isinstance(value, str) for value in command):
-        return {"id": scenario_id, "kind": kind, "status": "not_configured"}
-    timeout = item.get("timeout", 60)
-    timeout_value = float(timeout) if isinstance(timeout, (int, float)) else 60.0
-    cwd = item.get("cwd", ".") if isinstance(item.get("cwd", "."), str) else "."
-    outcome = run_command(command, str(root / cwd), timeout_value, deadline)
-    if outcome["status"] == "deadline_exceeded":
-        return {"id": scenario_id, "kind": kind, "status": "incomplete", "error": "deadline_exceeded"}
-    if outcome["status"] == "timeout":
-        return {"id": scenario_id, "kind": kind, "status": "failed", "error": "timeout",
-                "output": str(outcome.get("stdout", ""))}
-    if outcome["status"] == "spawn_error":
-        return {"id": scenario_id, "kind": kind, "status": "failed", "error": str(outcome.get("stderr", ""))}
-    if outcome["returncode"] == 0:
-        return {"id": scenario_id, "kind": kind, "status": "passed", "exit_code": 0}
-    output = (str(outcome.get("stdout", "")) + str(outcome.get("stderr", ""))).strip()[-4000:]
-    return {"id": scenario_id, "kind": kind, "status": "failed", "exit_code": outcome["returncode"], "output": output}
-
-
-def _ordered(items: list[Mapping[str, object]]) -> list[Mapping[str, object]]:
-    by_id = {str(item.get("id")): item for item in items}
-    pending = set(by_id)
-    ordered: list[Mapping[str, object]] = []
-    while pending:
-        ready: list[str] = []
-        for item_id in by_id:
-            if item_id not in pending:
-                continue
-            deps = by_id[item_id].get("depends_on", [])
-            dep_ids = [str(dep) for dep in deps] if isinstance(deps, list) else []
-            unknown = [dep for dep in dep_ids if dep not in by_id]
-            if unknown:
-                raise ValueError(f"acceptance scenario dependency missing: {', '.join(unknown)}")
-            if all(dep not in pending for dep in dep_ids):
-                ready.append(item_id)
-        if not ready:
-            raise ValueError("acceptance scenario dependency cycle")
-        ordered.extend(by_id[item_id] for item_id in ready)
-        pending.difference_update(ready)
-    return ordered
-
-
-def _executable(items: list[Mapping[str, object]]) -> bool:
-    """Draft completeness vs execution gate: at least one scenario must be
-    executable — a functional scenario with a registered command, or a
-    manual / e2e scenario with its own confirmation/deferral path. Zero
-    executable scenarios must block execution acceptance, never pass it."""
-    for item in items:
-        command = item.get("command")
-        if isinstance(command, list) and command and all(isinstance(value, str) for value in command):
-            return True
-        if str(item.get("kind", "")) in ("manual", "e2e"):
-            return True
-    return False
-
-
-def _owned(items: list[Mapping[str, object]], owner: str) -> list[Mapping[str, object]]:
-    """Keep scenarios owned by the active TASK; ownerless legacy scenarios stay
-    included so old manifests keep working. Cross-TASK depends_on edges are
-    pruned: single-TASK ordering is enforced here, whole-demand ordering at
-    the final (archive/E2E) gate."""
-    if not owner:
-        return items
-    kept = [
-        item for item in items
-        if not isinstance(item.get("owner"), str) or not item.get("owner") or item.get("owner") == owner
-    ]
-    kept_ids = {str(item.get("id")) for item in kept}
-    pruned: list[Mapping[str, object]] = []
-    for item in kept:
-        if not isinstance(item, dict):
-            pruned.append(item)
-            continue
-        deps = item.get("depends_on")
-        if isinstance(deps, list):
-            item = {**item, "depends_on": [dep for dep in deps if str(dep) in kept_ids]}
-        pruned.append(item)
-    return pruned
-
-
-def _run_unique(
-    ordered: list[Mapping[str, object]], root: Path, include_e2e: bool, deadline: Optional[float] = None,
-    only_e2e: bool = False,
-) -> list[dict[str, object]]:
-    """Reuse identical execution semantics within a dependency-free batch."""
-    cache: dict[str, Mapping[str, object]] = {}
-    results: list[dict[str, object]] = []
-    for item in ordered:
-        scenario_id = str(item.get("id", "unknown"))
-        command = item.get("command")
-        key: Optional[str] = None
-        if isinstance(command, list) and command and all(isinstance(value, str) for value in command):
-            key = execution_key(command, str(root / str(item.get("cwd", "."))), float(item.get("timeout", 60)))
-            key += json.dumps([item.get("kind", "functional"), include_e2e, only_e2e])
-        if item.get("depends_on"):
-            cache.clear()
-            invalidate_executions()
-        if key is not None and key in cache:
-            shared = dict(cache[key])
-            shared["id"] = scenario_id
-            results.append(shared)
-            continue
-        result = _run(item, root, include_e2e, deadline, only_e2e)
-        if key is not None:
-            cache[key] = result
-        results.append(result)
-    return results
-
-
-def run_manifest(
-    manifest_file: str,
-    root: str,
-    write_evidence: bool = False,
-    include_e2e: bool = False,
-    owner: str = "",
-    deadline: Optional[float] = None,
-    only_e2e: bool = False,
-) -> dict[str, object]:
-    data = load_manifest(Path(manifest_file))
-    validate_execution_baseline(Path(manifest_file), data)
-    scenarios = data["scenarios"]
-    _ordered(scenarios)  # Validate the complete DAG before owner filtering.
-    items = _owned(scenarios, owner)
-    ordered = _ordered(items)
-    results = _run_unique(ordered, Path(root), include_e2e or only_e2e, deadline, only_e2e)
-    if write_evidence:
-        persist_results(Path(manifest_file), data, results)
-    if not _executable(items):
-        return {"decision": "block", "results": results, "error": "no_executable_scenarios"}
-    allowed = ("passed", "manual_pending", "e2e_deferred", "not_included")
-    decision = "pass" if all(item["status"] in allowed for item in results) else "block"
-    error = ""
-    if decision == "block":
-        pending = sorted({str(item["id"]) for item in results if item["status"] == "incomplete"})
-        failed = sorted({str(item["id"]) for item in results if item["status"] not in (*allowed, "incomplete")})
-        error = ",".join((["incomplete:" + ",".join(pending)] if pending else []) + (["failed:" + ",".join(failed)] if failed else [])) or "acceptance scenario failed"
-    outcome: dict[str, object] = {"decision": decision, "results": results}
-    if error:
-        outcome["error"] = error
-    return outcome
-
-
-def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--manifest", required=True)
-    parser.add_argument("--root", required=True)
-    parser.add_argument("--write-evidence", action="store_true")
-    parser.add_argument("--include-e2e", action="store_true", help="Execute E2E scenarios (deferred by default)")
-    parser.add_argument("--only-e2e", action="store_true", help="Execute only E2E scenarios; functional/manual are reported not_included")
-    parser.add_argument("--owner", default="", help="Only execute scenarios owned by this TASK (plus ownerless legacy ones)")
-    parser.add_argument("--deadline", type=float, default=0.0, help="Absolute monotonic deadline propagated from the entry gate (0 = unbounded)")
-    args = parser.parse_args(argv)
-    try:
-        result = run_manifest(args.manifest, args.root, args.write_evidence, args.include_e2e, args.owner, args.deadline or None, args.only_e2e)
-        stdout.write(json.dumps(result, ensure_ascii=False))
-        return 0 if result["decision"] == "pass" else 3
-    except (OSError, ValueError, json.JSONDecodeError) as exc:
-        stdout.write(json.dumps({"decision": "block", "error": str(exc)}, ensure_ascii=False))
-        return 2
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/src/core/code-flow/scripts/cf_acceptance_schema.py

@@ -1,83 +0,0 @@
-"""Validated acceptance records shared by execution and lifecycle gates."""
-from __future__ import annotations
-
-import json
-import math
-from pathlib import Path
-from typing import Mapping
-
-
-def verified_evidence(row: Mapping[str, object]) -> bool:
-    evidence = row.get("evidence")
-    if row.get("status") != "verified" or not isinstance(evidence, dict):
-        return False
-    if row.get("kind") != "manual":
-        return evidence.get("status") == "passed" and evidence.get("exit_code") == 0
-    author, detail = evidence.get("confirmed_by"), evidence.get("evidence")
-    agents = {"agent", "assistant", "codex", "claude", "opencode", "costrict"}
-    return (isinstance(author, str) and bool(author.strip())
-            and author.strip().lower().split(":", 1)[0] not in agents
-            and isinstance(detail, str) and bool(detail.strip()))
-
-
-def validate_scenarios(value: object) -> list[dict[str, object]]:
-    if not isinstance(value, list):
-        raise ValueError("invalid manifest scenarios: expected list")
-    seen: set[str] = set()
-    for item in value:
-        if not isinstance(item, dict):
-            raise ValueError("invalid scenario: expected object")
-        scenario_id = item.get("id")
-        if not isinstance(scenario_id, str) or not scenario_id.strip():
-            raise ValueError("scenario id missing")
-        if scenario_id in seen:
-            raise ValueError(f"duplicate scenario id: {scenario_id}")
-        seen.add(scenario_id)
-        for field in ("kind", "owner", "cwd"):
-            if field in item and not isinstance(item[field], str):
-                raise ValueError(f"invalid scenario {scenario_id}:{field}")
-        command = item.get("command")
-        if command is not None and (not isinstance(command, list) or not all(isinstance(x, str) for x in command)):
-            raise ValueError(f"invalid scenario {scenario_id}:command")
-        timeout = item.get("timeout", 60)
-        if isinstance(timeout, bool) or not isinstance(timeout, (int, float)) or not math.isfinite(timeout) or timeout <= 0:
-            raise ValueError(f"invalid scenario {scenario_id}:timeout")
-        deps = item.get("depends_on", [])
-        if not isinstance(deps, list) or not all(isinstance(x, str) for x in deps):
-            raise ValueError(f"invalid scenario {scenario_id}:depends_on")
-        if "runs" in item and not isinstance(item["runs"], list):
-            raise ValueError(f"invalid scenario {scenario_id}:runs")
-        revision = item.get("revision", 0)
-        if isinstance(revision, bool) or not isinstance(revision, int) or revision < 0:
-            raise ValueError(f"invalid scenario {scenario_id}:revision")
-    for item in value:
-        unknown = set(item.get("depends_on", [])) - seen
-        if unknown:
-            raise ValueError(f"acceptance scenario dependency missing: {', '.join(sorted(unknown))}")
-    return value
-
-
-def load_manifest(path: Path) -> dict[str, object]:
-    data = json.loads(path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
-        raise ValueError("invalid acceptance manifest: expected object")
-    validate_scenarios(data.get("scenarios"))
-    if "task_file" in data and not isinstance(data["task_file"], str):
-        raise ValueError("invalid acceptance manifest: task_file")
-    return data
-
-
-def validate_execution_baseline(path: Path, data: Mapping[str, object]) -> None:
-    """Legacy standalone manifests remain usable; locked plans must match."""
-    task_name = data.get("task_file")
-    if not isinstance(task_name, str) or not task_name:
-        return
-    task = Path(task_name)
-    task = task if task.is_absolute() else path.parent / task
-    if not task.is_file():
-        raise ValueError(f"acceptance task file missing: {task}")
-    if "## Acceptance Coverage" in task.read_text(encoding="utf-8"):
-        from cf_acceptance_manifest import validate_manifest
-        valid, reason = validate_manifest(str(task), str(path))
-        if not valid:
-            raise ValueError(reason)

package/src/core/code-flow/scripts/cf_checks.py

@@ -1,336 +0,0 @@
-#!/usr/bin/env python3
-"""Spec frontmatter checks: parse, cache and execute (quality loop FEAT-01).
-
-Contract (spec-quality-loop.design.md §2.3.2 / §3.4 / §3.5):
-- Checks live in spec frontmatter `checks:` so rule text and machine check
-  stay in the same file (ADR: frontmatter over checks.yml).
-- Invalid entries are skipped and surfaced as parse errors (E-01) — they must
-  never break parsing of sibling checks or spec injection.
-- Execution guards: per-check timeout (E-02), oversized content skipped
-  (B-01), disabled checks filtered (RULE-04 state), matched lines per check
-  capped so feedback stays small (RISK-05).
-- yaml import is lazy: specs without `checks:` never pay for it on the
-  PostToolUse hot path (NFR-PERF-01).
-"""
-import fnmatch
-import os
-import re
-import sys
-from typing import Mapping
-from concurrent.futures import ThreadPoolExecutor
-from concurrent.futures import TimeoutError as FutureTimeout
-
-from cf_core import _FRONTMATTER_RE, normalize_path
-
-CHECK_TIMEOUT_SECONDS = 2.0
-MAX_CONTENT_BYTES = 256 * 1024
-MESSAGE_MAX_LEN = 200
-MAX_LINES_PER_CHECK = 3
-
-_ID_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
-IMPLEMENTED_TYPES = ("regex",)
-RESERVED_TYPES = ("ast", "cmd")  # interface reserved, implementation deferred
-_SEVERITIES = ("warn", "info")  # no "error": feedback only, never blocking
-
-_checks_cache: dict = {}
-
-STATE_NAME = ".check-state.json"
-FP_DISABLE_COUNT = 3
-FP_DISABLE_RATE = 0.10
-
-
-def _log(msg: str) -> None:
-    sys.stderr.write(f"[cf-checks] {msg}\n")
-
-
-def state_path(project_root: str) -> str:
-    return os.path.join(project_root, ".code-flow", STATE_NAME)
-
-
-def load_check_state(project_root: str) -> dict:
-    """Read check-state; corrupt/missing files rebuild as empty (tolerant)."""
-    import json
-    try:
-        with open(state_path(project_root), "r", encoding="utf-8") as f:
-            data = json.load(f)
-        return data if isinstance(data, dict) else {}
-    except Exception:
-        return {}
-
-
-def save_check_state(project_root: str, state: dict) -> bool:
-    import json
-    try:
-        path = state_path(project_root)
-        os.makedirs(os.path.dirname(path), exist_ok=True)
-        with open(path, "w", encoding="utf-8") as f:
-            json.dump(state, f, ensure_ascii=False)
-        return True
-    except Exception as exc:
-        _log(f"save_check_state failed: {exc}")
-        return False
-
-
-def record_hits(project_root: str, check_ids: list) -> dict:
-    """Increment hit_count for triggered checks (误报率分母). Returns state."""
-    state = load_check_state(project_root)
-    for cid in check_ids:
-        entry = state.setdefault(cid, {})
-        entry["hit_count"] = int(entry.get("hit_count", 0)) + 1
-    save_check_state(project_root, state)
-    return state
-
-
-def record_false_positive(project_root: str, check_id: str) -> dict:
-    """Mark one false positive; auto-disable past RULE-04 thresholds.
-
-    Returns {"check_id", "fp_count", "hit_count", "disabled"}.
-    """
-    state = load_check_state(project_root)
-    entry = state.setdefault(check_id, {})
-    entry["fp_count"] = int(entry.get("fp_count", 0)) + 1
-    fp = entry["fp_count"]
-    hits = int(entry.get("hit_count", 0))
-    if not entry.get("disabled") and (
-        fp >= FP_DISABLE_COUNT or (hits > 0 and fp / hits > FP_DISABLE_RATE)
-    ):
-        entry["disabled"] = True
-        entry["disabled_reason"] = (
-            f"auto: fp_count={fp}" if fp >= FP_DISABLE_COUNT
-            else f"auto: fp_rate={fp}/{hits}"
-        )
-    save_check_state(project_root, state)
-    return {
-        "check_id": check_id,
-        "fp_count": fp,
-        "hit_count": hits,
-        "disabled": bool(entry.get("disabled")),
-    }
-
-
-def _validate_entry(entry: object, index: int, seen_ids: set) -> tuple:
-    """Validate one raw checks entry → (check_dict | None, error | None)."""
-    if not isinstance(entry, dict):
-        return None, f"checks[{index}]: 不是对象，已跳过"
-    cid = entry.get("id")
-    if not isinstance(cid, str) or not _ID_RE.match(cid):
-        return None, f"checks[{index}]: id 缺失或非 kebab-case，已跳过"
-    if cid in seen_ids:
-        return None, f"checks[{index}]: id '{cid}' 重复，已跳过"
-    ctype = entry.get("type")
-    if ctype in RESERVED_TYPES:
-        return None, f"{cid}: type '{ctype}' 暂未实现（接口预留），已跳过"
-    if ctype not in IMPLEMENTED_TYPES:
-        return None, f"{cid}: 未知 type '{ctype}'，已跳过"
-    pattern = entry.get("pattern")
-    if not isinstance(pattern, str) or not pattern:
-        return None, f"{cid}: pattern 缺失，已跳过"
-    try:
-        compiled = re.compile(pattern)
-    except re.error as exc:
-        return None, f"{cid}: pattern 非法正则（{exc}），已跳过"
-
-    message = entry.get("message")
-    if not isinstance(message, str) or not message.strip():
-        return None, f"{cid}: message 缺失，已跳过"
-    error = None
-    if len(message) > MESSAGE_MAX_LEN:
-        error = f"{cid}: message 超过 {MESSAGE_MAX_LEN} 字符，运行时截断"
-        message = message[:MESSAGE_MAX_LEN]
-
-    severity = entry.get("severity", "warn")
-    if severity not in _SEVERITIES:
-        error = error or f"{cid}: severity '{severity}' 非法，按 warn 处理"
-        severity = "warn"
-
-    # default "*": fnmatch's "*" crosses "/" so it matches any depth;
-    # "**/*" under fnmatch would demand at least one directory level and
-    # silently skip repo-root files (same pitfall fixed in config patterns)
-    files = entry.get("files")
-    if not isinstance(files, str) or not files:
-        files = "*"
-
-    return {
-        "id": cid,
-        "type": ctype,
-        "pattern": pattern,
-        "regex": compiled,
-        "files": files,
-        "message": message,
-        "severity": severity,
-    }, error
-
-
-def parse_spec_checks(content: str) -> tuple:
-    """Parse frontmatter checks → (checks, errors). Both lists, never raises."""
-    if not isinstance(content, str):
-        return [], []
-    match = _FRONTMATTER_RE.match(content)
-    if not match or "checks:" not in match.group(1):
-        return [], []
-    try:
-        import yaml
-        meta = yaml.safe_load(match.group(1)) or {}
-    except Exception as exc:
-        return [], [f"frontmatter YAML 解析失败: {exc}"]
-    raw = meta.get("checks")
-    if raw is None:
-        return [], []
-    if not isinstance(raw, list):
-        return [], ["checks 必须是列表"]
-    checks: list = []
-    errors: list = []
-    seen_ids: set = set()
-    for index, entry in enumerate(raw):
-        check, error = _validate_entry(entry, index, seen_ids)
-        if error:
-            errors.append(error)
-        if check:
-            checks.append(check)
-            seen_ids.add(check["id"])
-    return checks, errors
-
-
-def load_spec_checks(spec_abs_path: str) -> tuple:
-    """Parse a spec file's checks with mtime cache → (checks, errors)."""
-    try:
-        mtime = os.path.getmtime(spec_abs_path)
-    except OSError:
-        return [], []
-    cached = _checks_cache.get(spec_abs_path)
-    if cached and cached["mtime"] == mtime:
-        return cached["checks"], cached["errors"]
-    try:
-        with open(spec_abs_path, "r", encoding="utf-8") as f:
-            checks, errors = parse_spec_checks(f.read())
-    except Exception as exc:
-        _log(f"load_spec_checks failed {spec_abs_path}: {exc}")
-        return [], []
-    _checks_cache[spec_abs_path] = {
-        "mtime": mtime, "checks": checks, "errors": errors,
-    }
-    return checks, errors
-
-
-# 纠正句式（FEAT-04 信号①）：保守收录、宁漏勿误（E-06）。
-# 否定排除：不要紧/不要紧张、对不对、不对外/不对称。
-_CORRECTION_PATTERNS = [
-    r"不要(?!紧)",
-    r"(?<!对)不对(?![外称])",
-    r"不是这样",
-    r"我说过",
-    r"改回[去来]",
-    r"别再?用",
-    r"写错了",
-    r"\bdon'?t\s+use\b",
-    r"\bthat'?s\s+wrong\b",
-    r"\bI\s+said\b",
-    r"\brevert\s+(that|this|it)\b",
-    r"\bstop\s+using\b",
-]
-_CORRECTION_RE = re.compile("|".join(_CORRECTION_PATTERNS), re.IGNORECASE)
-
-
-def detect_correction(prompt: str) -> dict:
-    """Detect a correction phrase in a user prompt → {"phrase", "span"} | None.
-
-    Single combined regex, first hit wins; the wordlist is deliberately
-    conservative — a missed correction only delays learning, a false hit
-    pollutes the candidate stream.
-    """
-    if not isinstance(prompt, str) or not prompt:
-        return None
-    match = _CORRECTION_RE.search(prompt)
-    if not match:
-        return None
-    return {"phrase": match.group(0), "span": [match.start(), match.end()]}
-
-
-def _match_lines(regex, content: str) -> list:
-    hits = []
-    for line_no, line in enumerate(content.splitlines(), 1):
-        if regex.search(line):
-            hits.append((line_no, line.strip()))
-            if len(hits) >= MAX_LINES_PER_CHECK:
-                break
-    return hits
-
-
-def run_checks(
-    checks: list,
-    rel_path: str,
-    content: str,
-    state: dict = None,
-    timeout: float = CHECK_TIMEOUT_SECONDS,
-) -> tuple:
-    """Execute checks against one file's content → (violations, skipped).
-
-    violations: [{check_id, file, line_no, line, message, severity}]
-    skipped:    [{check_id, reason}] — timeout / oversize, caller records
-                degrade events (E-02 / B-01).
-    Disabled checks (state[check_id]["disabled"]) are silently filtered.
-    """
-    violations: list = []
-    skipped: list = []
-    if not checks or not isinstance(content, str):
-        return violations, skipped
-    if len(content.encode("utf-8", errors="ignore")) > MAX_CONTENT_BYTES:
-        return violations, [{"check_id": "*", "reason": "content_too_large"}]
-
-    rel_path = normalize_path(rel_path)
-    state = state or {}
-    with ThreadPoolExecutor(max_workers=1) as pool:
-        for check in checks:
-            if state.get(check["id"], {}).get("disabled"):
-                continue
-            if not fnmatch.fnmatch(rel_path, check["files"]):
-                continue
-            future = pool.submit(_match_lines, check["regex"], content)
-            try:
-                hits = future.result(timeout=timeout)
-            except FutureTimeout:
-                skipped.append({"check_id": check["id"], "reason": "timeout"})
-                future.cancel()
-                continue
-            except Exception as exc:
-                skipped.append({"check_id": check["id"], "reason": f"error:{exc}"})
-                continue
-            for line_no, line in hits:
-                violations.append({
-                    "check_id": check["id"],
-                    "file": rel_path,
-                    "line_no": line_no,
-                    "line": line[:160],
-                    "message": check["message"],
-                    "severity": check["severity"],
-                })
-    return violations, skipped
-
-
-def run_regex_verifier(
-    pattern: str,
-    files: str,
-    contents: Mapping[str, str],
-    timeout: float = CHECK_TIMEOUT_SECONDS,
-) -> tuple[list[dict[str, object]], list[dict[str, object]]]:
-    """Execute one verifier regex over explicit file contents."""
-    try:
-        compiled = re.compile(pattern)
-    except re.error as exc:
-        return [], [{"check_id": "verifier", "reason": f"invalid_regex:{exc}"}]
-    check = {
-        "id": "verifier",
-        "type": "regex",
-        "pattern": pattern,
-        "regex": compiled,
-        "files": files,
-        "message": "Rule verifier matched forbidden content",
-        "severity": "warn",
-    }
-    violations: list[dict[str, object]] = []
-    skipped: list[dict[str, object]] = []
-    for relative, content in contents.items():
-        file_violations, file_skipped = run_checks([check], relative, content, timeout=timeout)
-        violations.extend(file_violations)
-        skipped.extend(file_skipped)
-    return violations, skipped