@michaelxwb/code-flow 0.8.1 → 1.0.0

package/src/core/code-flow/scripts/codeflow/acceptance/cf_check_registration.py

@@ -1,326 +0,0 @@
-"""Validate test registration against a bounded, real collection command."""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-import re
-import shlex
-import time
-from typing import Mapping, Sequence
-
-from codeflow.acceptance.cf_acceptance_schema import scenario_check_ids, validate_checks
-from codeflow.core.cf_exec_base import run_command
-
-
-REGISTRATION_FIELDS = ("suite", "test_ids", "markers", "collect", "level", "environment_revision", "evidence_ttl_seconds")
-
-
-class CollectionError(ValueError):
-    def __init__(self, code: str, details: Mapping[str, object]) -> None:
-        super().__init__(code)
-        self.code = code
-        self.details = dict(details)
-
-
-def _pytest_markers(argv: Sequence[str]) -> list[str]:
-    positions = [index for index, value in enumerate(argv[:-1]) if value == "-m" and argv[index + 1] != "pytest"]
-    expression = argv[positions[-1] + 1] if positions else ""
-    markers = [value.strip() for value in expression.split(" and ")] if expression else []
-    if any(not re.fullmatch(r"[a-zA-Z_][a-zA-Z0-9_]*", value) for value in markers):
-        raise ValueError("check_collection_marker_expression_invalid")
-    return markers
-
-
-def _pytest_collection(output: str, argv: Sequence[str]) -> list[dict[str, object]]:
-    markers = _pytest_markers(argv)
-    return [{"id": line.strip(), "markers": markers,
-             "capabilities": ["browser"] if "browser" in markers else []}
-            for line in output.splitlines() if re.fullmatch(r"[^\s]+\.py::[^\s]+", line.strip())]
-
-
-def _objects(value: object) -> list[Mapping[str, object]]:
-    if not isinstance(value, list) or not all(isinstance(item, Mapping) for item in value):
-        raise ValueError("check_collection_invalid_playwright_structure")
-    return value
-
-
-def _browser_projects(config: Mapping[str, object]) -> set[str]:
-    projects: set[str] = set()
-    for project in _objects(config.get("projects", [])):
-        metadata = project.get("metadata", {})
-        capabilities = metadata.get("capabilities", []) if isinstance(metadata, Mapping) else None
-        if not isinstance(capabilities, list) or not all(isinstance(value, str) for value in capabilities):
-            raise ValueError("check_collection_invalid_project_capabilities")
-        if "browser" in capabilities:
-            projects.add(str(project.get("name", "")).lower())
-    return projects | {"chromium", "firefox", "webkit", "browser"}
-
-
-def _playwright_spec(spec: Mapping[str, object], suite: Mapping[str, object], report_root: Path,
-                     root: str, projects: set[str]) -> list[dict[str, object]]:
-    file = spec.get("file", suite.get("file", ""))
-    tags = spec.get("tags", [])
-    if not isinstance(file, str) or not isinstance(tags, list) or not all(isinstance(value, str) for value in tags):
-        raise ValueError("check_collection_invalid_playwright_spec")
-    if type(spec.get("line")) is not int:
-        raise ValueError("check_collection_invalid_playwright_location")
-    file = (report_root / file).resolve().relative_to(Path(root).resolve()).as_posix()
-    tests: list[dict[str, object]] = []
-    for case in _objects(spec.get("tests", [])):
-        project = case.get("projectName", "")
-        if not isinstance(project, str):
-            raise ValueError("check_collection_invalid_playwright_project")
-        tests.append({"id": f"{file}:{spec['line']}@{project}", "markers": [tag.lstrip("@") for tag in tags],
-                      "capabilities": ["browser"] if project.lower() in projects else []})
-    return tests
-
-
-def _playwright_collection(data: Mapping[str, object], root: str) -> list[dict[str, object]]:
-    tests: list[dict[str, object]] = []
-    config = data.get("config", {})
-    if not isinstance(config, Mapping) or not isinstance(config.get("rootDir", root), str):
-        raise ValueError("check_collection_invalid_playwright_config")
-    report_root = Path(str(config.get("rootDir", root)))
-    projects = _browser_projects(config)
-    pending = list(_objects(data.get("suites", [])))
-    while pending:
-        suite = pending.pop()
-        if not isinstance(suite, Mapping):
-            raise ValueError("check_collection_invalid_playwright_suite")
-        pending.extend(_objects(suite.get("suites", [])))
-        for spec in _objects(suite.get("specs", [])):
-            tests.extend(_playwright_spec(spec, suite, report_root, root, projects))
-    return tests
-
-
-def _parse_collection(output: str, config: Mapping[str, object], root: str) -> list[Mapping[str, object]]:
-    fmt = config.get("format", "json")
-    if fmt == "pytest":
-        return _pytest_collection(output, config["argv"])
-    try:
-        data = json.loads(output)
-    except json.JSONDecodeError as exc:
-        raise ValueError("check_collection_invalid_json") from exc
-    if not isinstance(data, Mapping):
-        raise ValueError("check_collection_invalid_tests")
-    tests = _playwright_collection(data, root) if fmt == "playwright" else data.get("tests")
-    if fmt not in ("json", "pytest", "playwright") or not isinstance(tests, list):
-        raise ValueError("check_collection_invalid_format")
-    for test in tests:
-        if not isinstance(test, Mapping) or not isinstance(test.get("id"), str):
-            raise ValueError("check_collection_invalid_tests")
-        for field in ("capabilities", "markers"):
-            values = test.get(field, [])
-            if not isinstance(values, list) or not all(isinstance(value, str) for value in values):
-                raise ValueError("check_collection_invalid_tests")
-    return tests
-
-
-def _finding(code: str, scenario: str, check: str, message: str) -> dict[str, str]:
-    return {"code": code, "scenario": scenario, "check_id": check, "message": message}
-
-
-def _execution_argv(root: str, check: Mapping[str, object]) -> list[str]:
-    command = check.get("command")
-    if not isinstance(command, list) or not all(isinstance(value, str) for value in command):
-        return []
-    expanded = list(command)
-    for _ in range(4):
-        if not expanded or Path(expanded[0]).name not in ("npm", "pnpm", "yarn"):
-            return expanded
-        offset = 2 if len(expanded) > 1 and expanded[1] == "run" else 1
-        if len(expanded) <= offset:
-            return []
-        package = Path(root) / str(check.get("cwd", ".")) / "package.json"
-        data = json.loads(package.read_text(encoding="utf-8"))
-        script = data.get("scripts", {}).get(expanded[offset])
-        if not isinstance(script, str):
-            return []
-        lexer = shlex.shlex(script, posix=True, punctuation_chars=True)
-        lexer.whitespace_split = True
-        tokens = list(lexer)
-        if any(value in ("&&", "||", ";", "|", ">", ">>", "&") for value in tokens):
-            raise ValueError("check_execution_script_requires_direct_command")
-        expanded = tokens + [value for value in expanded[offset + 1:] if value != "--"]
-    return []
-
-
-def _execution_matches(root: str, check: Mapping[str, object], selected: Sequence[Mapping[str, object]]) -> bool:
-    from codeflow.acceptance.cf_check_inputs import match_path
-    argv = _execution_argv(root, check)
-    if not argv or not selected or any(value in argv for value in ("-k", "-g", "--grep", "--grep-invert")):
-        return False
-    pytest = any(Path(value).name in ("pytest", "py.test") for value in argv)
-    markers = _pytest_markers(argv) if pytest else []
-    if markers and any(not set(markers) <= set(item.get("markers", [])) for item in selected):
-        return False
-    selectors: list[str] = []
-    for value in argv:
-        normalized = value.replace("\\", "/").removeprefix("./")
-        if normalized.startswith(str(Path(root).resolve()) + "/"):
-            normalized = normalized[len(str(Path(root).resolve())) + 1:]
-        if re.fullmatch(r"[\w./*?:-]+\.(?:py|[cm]?[jt]sx?)(?::[\w:\[\].-]+)?", normalized):
-            selectors.append(normalized)
-    if selectors:
-        return all(any(match_path(str(item["id"]).split("@", 1)[0], selector)
-                       or match_path(str(item["id"]).split("@", 1)[0].split(":", 1)[0], selector)
-                       for selector in selectors) for item in selected)
-    if pytest:
-        return bool(markers)
-    return any(Path(value).name in ("playwright", "cypress") for value in argv)
-
-
-def _collected(root: str, check: Mapping[str, object], deadline: float | None = None) -> dict[str, Mapping[str, object]]:
-    config = check.get("collect")
-    if not isinstance(config, Mapping):
-        raise ValueError("check_collection_missing")
-    argv = config.get("argv")
-    if not isinstance(argv, list) or not argv or not all(isinstance(item, str) for item in argv):
-        raise ValueError("check_collection_invalid")
-    timeout = config.get("timeout", 10)
-    if isinstance(timeout, bool) or not isinstance(timeout, (float, int)) or not 0 < timeout <= 60:
-        raise ValueError("check_collection_timeout_invalid")
-    directory = (Path(root) / str(check.get("cwd", "."))).resolve()
-    if directory != Path(root).resolve() and Path(root).resolve() not in directory.parents:
-        raise ValueError("check_collection_outside_project")
-    result = run_command(argv, str(directory), float(timeout), deadline)
-    if result.get("status") != "ok" or result.get("returncode") != 0:
-        raise CollectionError("check_collection_failed", {"command": argv, "cwd": str(directory),
-            "exit_code": result.get("returncode"), "status": result.get("status"),
-            "output": (str(result.get("stdout", "")) + str(result.get("stderr", "")))[-4000:]})
-    output = str(result.get("stdout", ""))
-    if len(output.encode()) > 2_000_000:
-        raise ValueError("check_collection_too_large")
-    tests = _parse_collection(output, config, root)
-    if len({item["id"] for item in tests}) != len(tests):
-        raise ValueError("check_collection_duplicate_test")
-    return {str(item["id"]): item for item in tests}
-
-
-def _requirements(row: Mapping[str, object]) -> tuple[bool, set[str]]:
-    browser = str(row.get("level", row.get("kind", ""))).lower() == "e2e"
-    markers: set[str] = set()
-    if row.get("smoke"):
-        markers.add("smoke")
-    if row.get("level") == "capacity" or "capacity" in row.get("tags", []):
-        markers.add("capacity")
-    return browser, markers
-
-
-def registration_required(row: Mapping[str, object]) -> bool:
-    """Return whether a scenario needs collection-backed registration."""
-    browser, markers = _requirements(row)
-    return bool(browser or markers)
-
-
-def _collection_config(root: str, check: Mapping[str, object], markers: set[str]) -> dict[str, object]:
-    argv = _execution_argv(root, check)
-    if any(Path(value).name in ("pytest", "py.test") for value in argv):
-        if "-k" in argv:
-            raise ValueError("check_execution_selection_mismatch: use concrete pytest node IDs")
-        selected_markers = set(_pytest_markers(argv)) | markers
-        argv = [value for value in argv if not re.fullmatch(r"-q+|--quiet", value)]
-        argv += ["--collect-only", "--verbosity=-1"]
-        if selected_markers:
-            argv += ["-m", " and ".join(sorted(selected_markers))]
-        return {"argv": argv, "format": "pytest", "timeout": 10}
-    if any(Path(value).name == "playwright" for value in argv):
-        return {"argv": argv + ["--list", "--reporter=json"], "format": "playwright", "timeout": 10}
-    raise ValueError("check_collection_inference_unsupported: supply --registration-file")
-
-
-def register_check(root: str, check: dict[str, object], rows: Sequence[Mapping[str, object]],
-                   deadline: float) -> list[dict[str, str]]:
-    """Collect, populate and validate one check against all of its scenarios."""
-    validate_checks([check])
-    effective_rows = [{**row, "level": check.get("level", row.get("level"))} for row in rows]
-    requirements = [_requirements(row) for row in effective_rows]
-    browser = any(item[0] for item in requirements)
-    markers = set().union(*(item[1] for item in requirements))
-    if "collect" not in check:
-        check["collect"] = _collection_config(root, check, markers | ({"browser"} if browser else set()))
-    collected = _collected(root, check, deadline)
-    if not collected:
-        raise ValueError("check_collection_empty")
-    check.setdefault("test_ids", sorted(collected))
-    selected = [collected[value] for value in check["test_ids"] if value in collected]
-    actual_markers = set.intersection(*(set(item.get("markers", [])) for item in selected)) if selected else set()
-    check.setdefault("markers", sorted(actual_markers))
-    if browser and selected and all("browser" in item.get("capabilities", []) for item in selected):
-        check.setdefault("suite", "browser")
-    validate_checks([check])
-    return [issue for row in effective_rows for issue in _registration_issues(root, row, check, collected)]
-
-
-def _registration_issues(root: str, row: Mapping[str, object], check: Mapping[str, object],
-                          collected: Mapping[str, Mapping[str, object]]) -> list[dict[str, str]]:
-    scenario, check_id = str(row.get("id", "")), str(check.get("id", ""))
-    browser, markers = _requirements(row)
-    errors: list[dict[str, str]] = []
-    test_ids = check.get("test_ids", [])
-    if not isinstance(test_ids, list) or not test_ids or not all(isinstance(value, str) for value in test_ids):
-        return [_finding("check_test_ids_missing", scenario, check_id, "check 必须登记具体测试 ID")]
-    selected = [collected[value] for value in test_ids if value in collected]
-    if len(selected) != len(test_ids):
-        errors.append(_finding("check_test_not_collected", scenario, check_id, "登记的测试 ID 未全部被真实收集"))
-    try:
-        matches = _execution_matches(root, check, selected)
-    except (OSError, ValueError) as exc:
-        errors.append(_finding("check_execution_config_invalid", scenario, check_id, str(exc)))
-        matches = False
-    if not matches:
-        errors.append(_finding("check_execution_selection_mismatch", scenario, check_id,
-                               "实际执行命令必须选择登记用例；不可验证的 grep/-k 过滤请改用具体测试 ID"))
-    if browser and (check.get("suite") != "browser" or any("browser" not in item.get("capabilities", []) for item in selected)):
-        errors.append(_finding("e2e_check_not_browser", scenario, check_id, "E2E check 必须属于 browser 套件并收集到浏览器能力用例"))
-    if check.get("level") and check.get("level") != "e2e" and any(
-        "browser" in item.get("capabilities", []) for item in selected
-    ):
-        errors.append(_finding("check_level_browser_mismatch", scenario, check_id, "浏览器用例必须声明 e2e 层级"))
-    for marker in sorted(markers):
-        if marker not in check.get("markers", []) or any(marker not in item.get("markers", []) for item in selected):
-            code = "capacity_check_not_marked" if marker == "capacity" else "smoke_check_not_registered"
-            errors.append(_finding(code, scenario, check_id, f"check 与真实收集用例必须包含 {marker} 标记"))
-    return errors
-
-
-def validate_registration(root: str, scenarios: Sequence[Mapping[str, object]],
-                           checks: Sequence[Mapping[str, object]]) -> dict[str, object]:
-    by_id = {str(check["id"]): check for check in checks}
-    cache: dict[str, dict[str, Mapping[str, object]] | Exception] = {}
-    errors: list[dict[str, object]] = []
-    deadline = time.monotonic() + 60
-    runnable_smoke = runnable_browser = 0
-    for row in scenarios:
-        browser, markers = _requirements(row)
-        ids = scenario_check_ids(row)
-        has_browser_check = any(by_id.get(check_id, {}).get("level") == "e2e" for check_id in ids)
-        if not browser and not markers and not has_browser_check:
-            continue
-        row_errors: list[dict[str, object]] = []
-        if not ids:
-            row_errors.append(_finding("scenario_check_missing", str(row["id"]), "", "需要可执行 check 绑定"))
-        for check_id in ids:
-            check = by_id.get(check_id)
-            if check is None:
-                row_errors.append(_finding("unknown_check", str(row["id"]), check_id, "引用的 check 不存在"))
-                continue
-            effective = {**row, "level": check.get("level", row.get("level"))}
-            if not registration_required(effective):
-                continue
-            if check_id not in cache:
-                try:
-                    cache[check_id] = _collected(root, check, deadline)
-                except (OSError, ValueError) as exc:
-                    cache[check_id] = exc
-            collected = cache[check_id]
-            if isinstance(collected, Exception):
-                detail = collected.details if isinstance(collected, CollectionError) else {}
-                row_errors.append({**_finding(str(collected), str(row["id"]), check_id, "无法验证测试收集与套件登记"), **detail})
-            else:
-                row_errors.extend(_registration_issues(root, effective, check, collected))
-        errors.extend(row_errors)
-        runnable_smoke += int(bool(row.get("smoke")) and not row_errors)
-        runnable_browser += int(browser and not row_errors)
-    return {"ok": not errors, "errors": errors, "runnable_smoke_count": runnable_smoke,
-            "runnable_browser_count": runnable_browser, "collected_checks": len(cache)}

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

@@ -1,333 +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
-from typing import Mapping
-from concurrent.futures import ThreadPoolExecutor
-from concurrent.futures import TimeoutError as FutureTimeout
-
-from codeflow.core import cf_log
-from codeflow.core.cf_core import normalize_path
-from codeflow.core.cf_markdown import frontmatter_block
-
-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 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:
-        cf_log.warn(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_block(content)
-    if match is None or "checks:" not in match:
-        return [], []
-    try:
-        import yaml
-        meta = yaml.safe_load(match) 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:
-        cf_log.warn(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