@michaelxwb/code-flow 0.6.1 → 0.6.2

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

@@ -10,9 +10,11 @@ import json
 from pathlib import Path
 import re
 import sys
+import time
 from typing import IO, Mapping, Optional, Sequence
 
 from cf_spec_context import Decision, RuleBinding, RuleStageStatus, SpecBinding, SpecContext, load_context
+from cf_core import phase_timing
 
 
 @dataclass(frozen=True)
@@ -212,13 +214,21 @@ def _parser() -> argparse.ArgumentParser:
 
 
 def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    started = time.monotonic()
     try:
         args = _parser().parse_args(argv)
+        phase_started = time.monotonic()
         context = load_context(str(Path(args.task_dir) / "spec-context.yml"))
+        phase_timing("gate.load_context", phase_started)
+        phase_started = time.monotonic()
         result = validate_stage(context, args.stage, task_id=args.task)
+        phase_timing("gate.validate_stage", phase_started)
         if args.stage == "plan" and args.artifact:
+            phase_started = time.monotonic()
             result = _merge_results(result, validate_plan_coverage(context, args.artifact))
+            phase_timing("gate.validate_plan", phase_started)
         stdout.write(json.dumps(result_to_data(result), ensure_ascii=False))
+        phase_timing("gate.total", started)
         return 0 if result.decision == "pass" else 3
     except Exception as exc:
         sys.stderr.write(f"cf_spec_gate error: {exc}\n")

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

@@ -10,7 +10,6 @@ from pathlib import Path
 import re
 from typing import Mapping, Optional
 
-import yaml
 
 
 ALLOWED_STAGES = frozenset(("prd", "design", "plan", "code", "review"))
@@ -20,6 +19,8 @@ _ID_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
 _RULE_ID_RE = re.compile(r"^RULE-[a-z0-9]+(?:-[a-z0-9]+)*-\d{3}$")
 _EXPLICIT_RULE_RE = re.compile(r"^\[(RULE-[a-z0-9-]+-\d{3})\]\s+(.+)$")
 _FRONTMATTER_RE = re.compile(r"\A---[ \t]*\r?\n(.*?)\r?\n---[ \t]*(?:\r?\n|$)", re.DOTALL)
+_FRONTMATTER_OPEN_RE = re.compile(br"---[ \t]*\r?\n")
+_FRONTMATTER_CLOSE_RE = re.compile(br"---[ \t]*(?:\r?\n)?")
 _SECTION_RE = re.compile(r"^##\s+(Rules|Anti-Patterns|Patterns|Examples)\s*$")
 _H2_RE = re.compile(r"^##\s+")
 _BULLET_RE = re.compile(r"^\s*-\s+(.+\S|\S)\s*$")
@@ -63,6 +64,13 @@ class SpecRule:
     line: int
 
 
+@dataclass(frozen=True)
+class SpecHeader:
+    id: str
+    stages: tuple[str, ...]
+    enforcement: str
+
+
 @dataclass(frozen=True)
 class SpecMetadata:
     id: str
@@ -116,6 +124,11 @@ def _split_frontmatter(content: str, path: str) -> tuple[Mapping[str, object], s
     if not match:
         raise SpecMetadataError(path, "frontmatter", 1, "缺失或未闭合 YAML frontmatter")
     raw = match.group(1)
+    return _parse_frontmatter(raw, path), raw, content[match.end():]
+
+
+def _parse_frontmatter(raw: str, path: str) -> Mapping[str, object]:
+    import yaml
     try:
         loaded = yaml.safe_load(raw) or {}
     except yaml.YAMLError as exc:
@@ -126,7 +139,7 @@ def _split_frontmatter(content: str, path: str) -> tuple[Mapping[str, object], s
         raise SpecMetadataError(path, "frontmatter", 2, "顶层必须是 mapping")
     if not all(isinstance(key, str) for key in loaded):
         raise SpecMetadataError(path, "frontmatter", 2, "所有顶层 key 必须是字符串")
-    return loaded, raw, content[match.end():]
+    return loaded
 
 
 def _required_string(meta: Mapping[str, object], key: str, path: str, raw: str) -> str:
@@ -149,6 +162,46 @@ def _validate_stages(meta: Mapping[str, object], path: str, raw: str) -> tuple[s
     return stages
 
 
+def _spec_header(meta: Mapping[str, object], raw: str, path: str) -> SpecHeader:
+    spec_id = _required_string(meta, "id", path, raw)
+    if not _ID_RE.fullmatch(spec_id):
+        raise SpecMetadataError(path, "id", _field_line(raw, "id"), "必须是 kebab-case")
+    stages = _validate_stages(meta, path, raw)
+    enforcement = _required_string(meta, "enforcement", path, raw)
+    if enforcement not in ALLOWED_ENFORCEMENT:
+        line = _field_line(raw, "enforcement")
+        raise SpecMetadataError(path, "enforcement", line, f"必须是 {sorted(ALLOWED_ENFORCEMENT)}")
+    return SpecHeader(spec_id, stages, enforcement)
+
+
+def _read_frontmatter(path: str) -> str:
+    lines: list[bytes] = []
+    try:
+        with Path(path).open("rb") as source:
+            if not _FRONTMATTER_OPEN_RE.fullmatch(source.readline()):
+                raise SpecMetadataError(path, "frontmatter", 1, "缺失或未闭合 YAML frontmatter")
+            for line in source:
+                if _FRONTMATTER_CLOSE_RE.fullmatch(line):
+                    break
+                lines.append(line)
+            else:
+                raise SpecMetadataError(path, "frontmatter", 1, "缺失或未闭合 YAML frontmatter")
+    except OSError as exc:
+        raise SpecMetadataError(path, "file", 1, f"读取失败: {exc}") from exc
+    raw = b"".join(lines)
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        line = raw[:exc.start].count(b"\n") + 2
+        raise SpecMetadataError(path, "encoding", line, f"必须是 UTF-8: {exc}") from exc
+
+
+def load_spec_header(path: str) -> SpecHeader:
+    """Load only routing fields, stopping at the frontmatter delimiter."""
+    raw = _read_frontmatter(path)
+    return _spec_header(_parse_frontmatter(raw, path), raw, path)
+
+
 def _validate_checks(meta: Mapping[str, object], path: str, raw: str) -> tuple[Mapping[str, object], ...]:
     value = meta.get("checks", [])
     if not isinstance(value, list) or not all(isinstance(item, dict) for item in value):
@@ -265,15 +318,8 @@ def _validate_links(
 
 def parse_spec_metadata(content: str, path: str = "<memory>", raw_bytes: Optional[bytes] = None) -> SpecMetadata:
     meta, raw_frontmatter, body = _split_frontmatter(content, path)
-    spec_id = _required_string(meta, "id", path, raw_frontmatter)
-    if not _ID_RE.fullmatch(spec_id):
-        raise SpecMetadataError(path, "id", _field_line(raw_frontmatter, "id"), "必须是 kebab-case")
+    header = _spec_header(meta, raw_frontmatter, path)
     description = _required_string(meta, "description", path, raw_frontmatter)
-    stages = _validate_stages(meta, path, raw_frontmatter)
-    enforcement = _required_string(meta, "enforcement", path, raw_frontmatter)
-    if enforcement not in ALLOWED_ENFORCEMENT:
-        line = _field_line(raw_frontmatter, "enforcement")
-        raise SpecMetadataError(path, "enforcement", line, f"必须是 {sorted(ALLOWED_ENFORCEMENT)}")
     owner = meta.get("owner")
     if owner is not None and (not isinstance(owner, str) or not owner.strip()):
         raise SpecMetadataError(path, "owner", _field_line(raw_frontmatter, "owner"), "必须是非空字符串")
@@ -289,7 +335,10 @@ def parse_spec_metadata(content: str, path: str = "<memory>", raw_bytes: Optiona
         metadata_sha256=_sha256(_canonical_json(meta, path, "frontmatter", 1)),
         rules_sha256=_sha256(_canonical_json(required_rules, path, "rules", 1)),
     )
-    return SpecMetadata(spec_id, description, stages, enforcement, owner, checks, verifiers, rules, hashes, path)
+    return SpecMetadata(
+        header.id, description, header.stages, header.enforcement,
+        owner, checks, verifiers, rules, hashes, path,
+    )
 
 
 def load_spec_metadata(path: str) -> SpecMetadata:

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

@@ -8,9 +8,14 @@ import fnmatch
 from pathlib import Path
 from typing import Mapping, Optional, Sequence
 
-import yaml
-
-from cf_spec_metadata import ALLOWED_STAGES, SpecMetadata, SpecRule, load_spec_metadata
+from cf_spec_metadata import (
+    ALLOWED_STAGES,
+    SpecHeader,
+    SpecMetadata,
+    SpecRule,
+    load_spec_header,
+    load_spec_metadata,
+)
 
 
 SCOPE_PRIORITY = {"global": 1, "path": 2, "task": 3}
@@ -44,6 +49,16 @@ class SpecCandidate:
         return sum(rule.enforcement == "required" for rule in self.metadata.rules)
 
 
+@dataclass(frozen=True)
+class SpecCandidateHeader:
+    spec_id: str
+    path: str
+    scope: str
+    priority: int
+    matched_paths: tuple[str, ...]
+    enforcement: str
+
+
 @dataclass(frozen=True)
 class ResolvedRule:
     ref: str
@@ -93,6 +108,7 @@ def _fingerprint(path: Path, field: str) -> tuple[int, int]:
 
 
 def _load_config(root: str) -> Mapping[str, object]:
+    import yaml
     path = Path(root) / ".code-flow" / "config.yml"
     if not path.is_file():
         raise SpecResolutionError(str(path), "config", "缺失 config.yml")
@@ -180,6 +196,36 @@ def _candidate_for(
     return SpecCandidate(metadata.id, relative, scope, SCOPE_PRIORITY[scope], matched, metadata)
 
 
+def _candidate_header_for(
+    path: Path,
+    spec_root: Path,
+    mapping: Mapping[str, object],
+    config_path: str,
+    stage: str,
+    paths: Sequence[str],
+) -> Optional[SpecCandidateHeader]:
+    relative = path.relative_to(spec_root).as_posix()
+    header: SpecHeader = load_spec_header(str(path))
+    if stage not in header.stages:
+        return None
+    domain = relative.split("/", 1)[0]
+    config = _domain_config(mapping, domain, config_path)
+    patterns = _patterns(config, f"path_mapping.{domain}.patterns", config_path)
+    scope, matched = _candidate_scope(relative, patterns, paths)
+    return SpecCandidateHeader(
+        header.id, relative, scope, SCOPE_PRIORITY[scope], matched, header.enforcement
+    )
+
+
+def _spec_paths(spec_root: Path, excluded: set[str]) -> tuple[Path, ...]:
+    result: list[Path] = []
+    for path in sorted(spec_root.rglob("*.md")):
+        relative = path.relative_to(spec_root).as_posix()
+        if path.name != "_map.md" and not relative.startswith("_session/") and relative not in excluded:
+            result.append(path)
+    return tuple(result)
+
+
 def resolve_candidates(root: str, stage: str, paths: Sequence[str]) -> tuple[SpecCandidate, ...]:
     if stage not in ALLOWED_STAGES:
         raise SpecResolutionError(root, "stage", f"不支持 stage: {stage!r}")
@@ -193,10 +239,7 @@ def resolve_candidates(root: str, stage: str, paths: Sequence[str]) -> tuple[Spe
         raise SpecResolutionError(str(spec_root), "specs", "缺失 specs 目录")
     candidates: list[SpecCandidate] = []
     ids: dict[str, str] = {}
-    for path in sorted(spec_root.rglob("*.md")):
-        relative = path.relative_to(spec_root).as_posix()
-        if path.name == "_map.md" or relative.startswith("_session/") or relative in excluded:
-            continue
+    for path in _spec_paths(spec_root, excluded):
         candidate = _candidate_for(path, spec_root, mapping, config_path, stage, normalized_paths)
         if candidate is None:
             continue
@@ -208,6 +251,34 @@ def resolve_candidates(root: str, stage: str, paths: Sequence[str]) -> tuple[Spe
     return tuple(sorted(candidates, key=lambda item: (-item.priority, item.path)))
 
 
+def resolve_candidate_headers(
+    root: str, stage: str, paths: Sequence[str]
+) -> tuple[SpecCandidateHeader, ...]:
+    """Resolve candidates from routing frontmatter without parsing bodies or hashes."""
+    if stage not in ALLOWED_STAGES:
+        raise SpecResolutionError(root, "stage", f"不支持 stage: {stage!r}")
+    normalized_paths = tuple(path.replace("\\", "/") for path in paths)
+    config = _load_config(root)
+    config_path = str(Path(root) / ".code-flow" / "config.yml")
+    mapping = _path_mapping(config, config_path)
+    excluded = _non_injectable(mapping, config_path)
+    spec_root = Path(root) / ".code-flow" / "specs"
+    if not spec_root.is_dir():
+        raise SpecResolutionError(str(spec_root), "specs", "缺失 specs 目录")
+    candidates: list[SpecCandidateHeader] = []
+    ids: dict[str, str] = {}
+    for path in _spec_paths(spec_root, excluded):
+        candidate = _candidate_header_for(path, spec_root, mapping, config_path, stage, normalized_paths)
+        if candidate is None:
+            continue
+        if candidate.spec_id in ids:
+            detail = f"重复 id {candidate.spec_id}: {ids[candidate.spec_id]}, {candidate.path}"
+            raise SpecResolutionError(str(spec_root), "spec_id", detail)
+        ids[candidate.spec_id] = candidate.path
+        candidates.append(candidate)
+    return tuple(sorted(candidates, key=lambda item: (-item.priority, item.path)))
+
+
 def _effective_enforcement(candidate: SpecCandidate, rule: SpecRule) -> str:
     if candidate.metadata.enforcement == "advisory" and rule.enforcement == "required":
         return "advisory"

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

@@ -8,14 +8,25 @@ import json
 import os
 from pathlib import Path
 import tempfile
-from typing import Mapping, Sequence
-
-from cf_core import assemble_context, build_effective_mapping, build_spec_catalog, load_config, parse_spec_frontmatter
+from typing import Mapping, Optional, Sequence
+
+from cf_core import (
+    assemble_context,
+    build_effective_mapping,
+    build_spec_catalog,
+    compress_content,
+    load_config,
+    parse_spec_frontmatter,
+    resolve_compress,
+)
 from cf_spec_context import ContextError, load_active_task, load_context
 from cf_spec_resolver import resolve_candidates
 from cf_spec_session import context_sha256, project_task_session
 
 
+_PROJECTION_CACHE_PATH = ".code-flow/.task-projection-state.json"
+
+
 @dataclass(frozen=True)
 class RouteResult:
     mode: str
@@ -44,6 +55,77 @@ def _task_file(task_dir: Path, task_id: str) -> Path:
     return matches[0]
 
 
+def _projection_cache_path(root: str) -> Path:
+    return Path(root) / _PROJECTION_CACHE_PATH
+
+
+def _load_projection_cache(root: str) -> Mapping[str, object]:
+    try:
+        value = json.loads(_projection_cache_path(root).read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def _cached_projection(
+    root: str, task_dir: Path, task_id: str, current_hash: str
+) -> Optional[tuple[str, bool]]:
+    cache = _load_projection_cache(root)
+    if (
+        cache.get("version") != 1
+        or cache.get("task_id") != task_id
+        or cache.get("context_sha256") != current_hash
+        or not isinstance(cache.get("task_file"), str)
+        or not isinstance(cache.get("text"), str)
+        or not isinstance(cache.get("truncated"), bool)
+    ):
+        return None
+    task_file = Path(str(cache["task_file"]))
+    if task_file.parent != task_dir or not task_file.is_file():
+        return None
+    try:
+        directory_mtime = task_dir.stat().st_mtime_ns
+        task_mtime = task_file.stat().st_mtime_ns
+    except OSError:
+        return None
+    if cache.get("task_dir_mtime_ns") != directory_mtime or cache.get("task_mtime_ns") != task_mtime:
+        return None
+    return str(cache["text"]), bool(cache["truncated"])
+
+
+def _save_projection_cache(
+    root: str,
+    task_dir: Path,
+    task_file: Path,
+    task_id: str,
+    current_hash: str,
+    text: str,
+    truncated: bool,
+) -> None:
+    try:
+        payload = {
+            "version": 1,
+            "task_id": task_id,
+            "context_sha256": current_hash,
+            "task_file": str(task_file),
+            "task_dir_mtime_ns": task_dir.stat().st_mtime_ns,
+            "task_mtime_ns": task_file.stat().st_mtime_ns,
+            "text": text,
+            "truncated": truncated,
+        }
+        path = _projection_cache_path(root)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+        temporary.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+        os.replace(temporary, path)
+    except (OSError, TypeError, UnicodeError):
+        if "temporary" in locals() and temporary.exists():
+            try:
+                temporary.unlink()
+            except OSError:
+                pass
+
+
 def _active_route(root: str) -> RouteResult:
     try:
         active = load_active_task(root)
@@ -57,14 +139,23 @@ def _active_route(root: str) -> RouteResult:
             "active_context_drift",
             "active marker Context hash does not match; run `cf-spec doctor` (resync) to re-sync the marker before continuing",
         )
-    projection = project_task_session(context, str(_task_file(task_dir, active.task_id)), active.task_id)
-    if projection.truncated:
+    cached = _cached_projection(root, task_dir, active.task_id, current_hash)
+    if cached is None:
+        task_file = _task_file(task_dir, active.task_id)
+        projection = project_task_session(context, str(task_file), active.task_id)
+        _save_projection_cache(
+            root, task_dir, task_file, active.task_id, current_hash, projection.text, projection.truncated
+        )
+        text, truncated = projection.text, projection.truncated
+    else:
+        text, truncated = cached
+    if truncated:
         raise RouterError("task_projection_truncated", "split the TASK before coding")
     refs = tuple(binding.spec_id for binding in context.bindings)
-    return RouteResult("task", projection.text, refs, current_hash)
+    return RouteResult("task", text, refs, current_hash)
 
 
-def _read_candidates(root: str, paths: Sequence[str]) -> RouteResult:
+def _read_candidates(root: str, paths: Sequence[str], compress: bool = True) -> RouteResult:
     try:
         candidates = resolve_candidates(root, "code", tuple(paths))
     except ValueError as exc:
@@ -78,7 +169,8 @@ def _read_candidates(root: str, paths: Sequence[str]) -> RouteResult:
             raise RouterError("spec_read_failed", f"{candidate.path}: {exc}") from exc
         unused_frontmatter, content = parse_spec_frontmatter(raw)
         del unused_frontmatter
-        specs.append({"path": candidate.path, "content": content.strip(), "tier": 1})
+        final_content = compress_content(content.strip()) if compress else content.strip()
+        specs.append({"path": candidate.path, "content": final_content, "tier": 1})
     text = assemble_context(specs, "## Active Specs (path-mapped)") if specs else ""
     return RouteResult("path", text, tuple(item.path for item in candidates))
 
@@ -145,5 +237,6 @@ def route_prompt(root: str, paths: Sequence[str], session_id: str) -> RouteResul
     if not config:
         return RouteResult("none", "", ())
     if paths:
-        return _read_candidates(root, paths)
+        quality = config.get("quality_loop")
+        return _read_candidates(root, paths, resolve_compress(quality if isinstance(quality, dict) else {}))
     return _catalog_route(root, session_id, config)

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

@@ -11,13 +11,23 @@ import hashlib
 import json
 from pathlib import Path
 import subprocess
+from threading import Lock
 import time
+from concurrent.futures import ThreadPoolExecutor
 from typing import Mapping, Optional, Sequence
 
 from cf_checks import run_regex_verifier
 from cf_spec_metadata import SpecMetadata, SpecRule, SpecVerifier
 
 
+_RESULT_CACHE: dict[str, dict[str, object]] = {}
+_RESULT_CACHE_ROOT: Optional[str] = None
+_RESULT_CACHE_DIRTY = False
+_RESULT_CACHE_LOCK = Lock()
+_MAX_RESULT_CACHE_ENTRIES = 2048
+_PURE_VERIFIER_TYPES = frozenset(("document", "regex", "ast"))
+
+
 @dataclass(frozen=True)
 class VerificationScope:
     root: str
@@ -44,6 +54,94 @@ class VerificationResult:
     passed: bool
 
 
+def _cache_file(root: str) -> Path:
+    return Path(root) / ".code-flow" / ".verifier-cache.json"
+
+
+def _cache_key(metadata: SpecMetadata, rule: SpecRule, verifier: SpecVerifier, scope: VerificationScope, confirmation: Optional[Mapping[str, object]]) -> str:
+    payload = {
+        "spec": metadata.hashes.file_sha256,
+        "rule": rule.text_sha256,
+        "verifier": {"type": verifier.type, "config": verifier.config},
+        "files": scope.files,
+        "diff": scope.diff_sha256,
+        "confirmation": confirmation or {},
+    }
+    return hashlib.sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True, default=str).encode()).hexdigest()
+
+
+def _load_result_cache(root: str) -> None:
+    global _RESULT_CACHE_ROOT, _RESULT_CACHE, _RESULT_CACHE_DIRTY
+    if _RESULT_CACHE_ROOT == root:
+        return
+    _RESULT_CACHE_ROOT = root
+    _RESULT_CACHE = {}
+    _RESULT_CACHE_DIRTY = False
+    path = _cache_file(root)
+    try:
+        loaded = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(loaded, dict):
+            _RESULT_CACHE.update({str(key): value for key, value in loaded.items() if isinstance(value, dict)})
+    except (OSError, ValueError):
+        pass
+
+
+def _cached_evidence(key: str) -> Optional[VerificationEvidence]:
+    item = _RESULT_CACHE.get(key)
+    if not isinstance(item, dict) or item.get("status") != "verified":
+        return None
+    try:
+        return VerificationEvidence(**item)
+    except (TypeError, ValueError):
+        return None
+
+
+def _save_result_cache(key: str, evidence: VerificationEvidence) -> None:
+    global _RESULT_CACHE_DIRTY
+    with _RESULT_CACHE_LOCK:
+        _RESULT_CACHE[key] = evidence.__dict__
+        _RESULT_CACHE_DIRTY = True
+        while len(_RESULT_CACHE) > _MAX_RESULT_CACHE_ENTRIES:
+            _RESULT_CACHE.pop(next(iter(_RESULT_CACHE)))
+
+
+def _flush_result_cache(root: str) -> None:
+    global _RESULT_CACHE_DIRTY
+    with _RESULT_CACHE_LOCK:
+        if not _RESULT_CACHE_DIRTY:
+            return
+        path = _cache_file(root)
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            temporary = path.with_suffix(".json.tmp")
+            temporary.write_text(
+                json.dumps(_RESULT_CACHE, ensure_ascii=False, sort_keys=True, default=str), encoding="utf-8"
+            )
+            temporary.replace(path)
+            _RESULT_CACHE_DIRTY = False
+        except OSError:
+            pass
+
+
+def _cached_or_run(
+    metadata: SpecMetadata,
+    rule: SpecRule,
+    verifier: SpecVerifier,
+    scope: VerificationScope,
+    confirmation: Optional[Mapping[str, object]],
+) -> VerificationEvidence:
+    cacheable = verifier.type in _PURE_VERIFIER_TYPES
+    key = _cache_key(metadata, rule, verifier, scope, confirmation) if cacheable else ""
+    if cacheable:
+        cached = _cached_evidence(key)
+        if cached is not None:
+            return cached
+    current = _evidence(metadata, rule, verifier, scope, confirmation)
+    if cacheable and current.status == "verified":
+        _save_result_cache(key, current)
+    return current
+
+
 @dataclass(frozen=True)
 class _Outcome:
     passed: bool
@@ -290,7 +388,9 @@ def run_all_verifiers(
 ) -> VerificationResult:
     verifier_by_rule = {item.rule: item for item in metadata.verifiers}
     confirmation_by_rule = confirmations or {}
-    evidence: list[VerificationEvidence] = []
+    _load_result_cache(scope.root)
+    evidence_by_ref: dict[str, VerificationEvidence] = {}
+    parallel: list[tuple[SpecRule, SpecVerifier, Optional[Mapping[str, object]]]] = []
     started = time.monotonic()
     for rule in metadata.rules:
         if rule.enforcement != "required":
@@ -298,13 +398,12 @@ def run_all_verifiers(
         if timeout_budget is not None:
             remaining = timeout_budget - (time.monotonic() - started)
             if remaining <= 0:
-                evidence.append(_budget_evidence(metadata, rule, scope, timeout_budget))
+                evidence_by_ref[rule.ref] = _budget_evidence(metadata, rule, scope, timeout_budget)
                 continue
         verifier = verifier_by_rule.get(rule.ref)
         if verifier is None:
             details = {"rule": rule.ref}
-            evidence.append(
-                VerificationEvidence(
+            evidence_by_ref[rule.ref] = VerificationEvidence(
                     f"{metadata.id}#{rule.ref}",
                     datetime.now(timezone.utc).isoformat(),
                     "unverified",
@@ -315,14 +414,25 @@ def run_all_verifiers(
                     "verifier_missing",
                     details,
                 )
-            )
             continue
         if skip_command and verifier.type in ("command", "test"):
-            evidence.append(_skipped_evidence(metadata, rule, scope))
+            evidence_by_ref[rule.ref] = _skipped_evidence(metadata, rule, scope)
+            continue
+        confirmation = confirmation_by_rule.get(rule.ref)
+        if timeout_budget is None and verifier.type in ("document", "regex", "ast"):
+            parallel.append((rule, verifier, confirmation))
             continue
         cap = None if timeout_budget is None else max(0.1, timeout_budget - (time.monotonic() - started))
-        evidence.append(_evidence(metadata, rule, verifier, scope, confirmation_by_rule.get(rule.ref), cap))
-    result = tuple(evidence)
+        evidence_by_ref[rule.ref] = _cached_or_run(metadata, rule, verifier, scope, confirmation) if cap is None else _evidence(metadata, rule, verifier, scope, confirmation, cap)
+    if parallel:
+        with ThreadPoolExecutor(max_workers=min(8, len(parallel))) as pool:
+            futures = {
+                rule.ref: pool.submit(_cached_or_run, metadata, rule, verifier, scope, confirmation)
+                for rule, verifier, confirmation in parallel
+            }
+            evidence_by_ref.update({ref: future.result() for ref, future in futures.items()})
+    result = tuple(evidence_by_ref[rule.ref] for rule in metadata.rules if rule.ref in evidence_by_ref)
+    _flush_result_cache(scope.root)
     return VerificationResult(result, bool(result) and all(item.status == "verified" for item in result))
 
 

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

@@ -28,6 +28,7 @@ from cf_core import (
     resolve_enforcement,
     resolve_quality_loop,
     resolve_session_id,
+    timing_log,
 )
 
 TOTAL_BUDGET_SECONDS = 30.0
@@ -310,3 +311,4 @@ def main() -> None:
 
 if __name__ == "__main__":
     main()
+    timing_log("cf_stop_hook")