@michaelxwb/code-flow 0.6.1 → 0.6.3

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

@@ -8,12 +8,17 @@ import fnmatch
 from pathlib import Path
 from typing import Mapping, Optional, Sequence
 
-import yaml
+from cf_spec_metadata import (
+    ALLOWED_STAGES,
+    SpecHeader,
+    SpecMetadata,
+    SpecRule,
+    load_spec_header,
+    load_spec_metadata,
+)
 
-from cf_spec_metadata import ALLOWED_STAGES, SpecMetadata, SpecRule, load_spec_metadata
 
-
-SCOPE_PRIORITY = {"global": 1, "path": 2, "task": 3}
+SCOPE_PRIORITY = {"unmatched": 0, "global": 1, "path": 2, "task": 3}
 _config_cache: dict[str, tuple[int, int, Mapping[str, object]]] = {}
 _metadata_cache: dict[str, tuple[int, int, SpecMetadata]] = {}
 
@@ -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")
@@ -158,7 +174,12 @@ def _candidate_scope(relative: str, patterns: Sequence[str], paths: Sequence[str
     if relative.startswith("_session/"):
         return "task", ()
     matched = tuple(path for path in paths if any(fnmatch.fnmatch(path, pattern) for pattern in patterns))
-    return ("path", matched) if matched else ("global", ())
+    if matched:
+        return "path", matched
+    # A domain without patterns is truly global. A domain WITH patterns that
+    # match nothing is irrelevant to these paths ("unmatched") — discovery
+    # keeps it, but injection and scope expansion must not consume it.
+    return ("global", ()) if not patterns else ("unmatched", ())
 
 
 def _candidate_for(
@@ -180,6 +201,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 +244,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 +256,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,20 +139,31 @@ 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:
         raise RouterError("invalid_spec_metadata", str(exc)) from exc
     specs = []
     for candidate in candidates:
+        if candidate.scope == "unmatched":
+            continue
         target = Path(root) / ".code-flow/specs" / candidate.path
         try:
             raw = target.read_text(encoding="utf-8")
@@ -78,7 +171,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 +239,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_session.py

@@ -36,7 +36,8 @@ def _task_section(text: str, task_id: str) -> str:
 
 
 def _refs(section: str) -> tuple[str, ...]:
-    match = re.search(r"(?m)^- \*\*Spec-Refs\*\*:\s*(.+)$", section)
+    # [ \t]* 而非 \s*：空 Spec-Refs 不得跨行吞掉下一字段（Acceptance-Refs 等）
+    match = re.search(r"(?m)^- \*\*Spec-Refs\*\*:[ \t]*(.*)$", section)
     if match is None:
         raise ValueError("spec_refs_missing")
     return tuple(item.strip() for item in match.group(1).split(",") if item.strip())
@@ -83,7 +84,7 @@ def project_task_session(
         if len(header + "".join(lines) + candidate + footer) > max_chars:
             break
         lines.append(candidate)
-    truncated = len(lines) < len(refs)
+    truncated = len(lines) < len(refs) or len(header + "".join(lines) + footer) > max_chars
     if truncated:
         footer = "\n> 投影超过预算；完整 Context 保留在需求目录，请拆分 TASK。\n" + footer
     text = (header + "".join(lines) + footer)[:max_chars]

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

@@ -11,11 +11,22 @@ 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
+from cf_exec_base import execution_session, run_command
+
+
+_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)
@@ -44,6 +55,107 @@ 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 {},
+        "artifact_content": _artifact_fingerprint(verifier, scope),
+    }
+    return hashlib.sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True, default=str).encode()).hexdigest()
+
+
+def _artifact_fingerprint(verifier: SpecVerifier, scope: VerificationScope) -> Optional[str]:
+    if verifier.type != "document":
+        return None
+    relative = verifier.config.get("artifact")
+    if not isinstance(relative, str):
+        return "invalid"
+    try:
+        return hashlib.sha256((Path(scope.root) / relative).read_bytes()).hexdigest()
+    except OSError as exc:
+        return f"unreadable:{exc}"
+
+
+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
@@ -168,30 +280,22 @@ def _command(config: Mapping[str, object], scope: VerificationScope, timeout_cap
     cwd = _config_string(config, "cwd") or "."
     timeout_value = config.get("timeout", 30)
     timeout = float(timeout_value) if isinstance(timeout_value, (int, float)) else 30.0
-    if timeout_cap is not None:
-        timeout = min(timeout, timeout_cap)
     allowed_value = config.get("allowed_exit_codes", [0])
     allowed = tuple(item for item in allowed_value if isinstance(item, int)) if isinstance(allowed_value, list) else (0,)
-    try:
-        completed = subprocess.run(
-            argv,
-            cwd=str(Path(scope.root) / cwd),
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-            check=False,
-        )
-    except subprocess.TimeoutExpired:
+    deadline = None if timeout_cap is None else time.monotonic() + timeout_cap
+    completed = run_command(argv, str(Path(scope.root) / cwd), timeout, deadline)
+    if completed["status"] in ("timeout", "deadline_exceeded"):
         return _Outcome(False, "verifier_timeout", None, {"timeout": timeout, "argv": argv})
-    except OSError as exc:
-        return _Outcome(False, "command_unavailable", None, {"argv": argv, "error": str(exc)})
+    if completed["status"] == "spawn_error":
+        return _Outcome(False, "command_unavailable", None, {"argv": argv, "error": completed["stderr"]})
     details = {
         "argv": argv,
-        "exit_code": completed.returncode,
-        "stdout_sha256": _hash_bytes(completed.stdout.encode()),
-        "stderr_sha256": _hash_bytes(completed.stderr.encode()),
+        "exit_code": completed["returncode"],
+        "stdout_sha256": _hash_bytes(str(completed["stdout"]).encode()),
+        "stderr_sha256": _hash_bytes(str(completed["stderr"]).encode()),
+        "output": (str(completed["stdout"]) + str(completed["stderr"]))[-4000:],
     }
-    passed = completed.returncode in allowed
+    passed = completed["returncode"] in allowed
     return _Outcome(passed, None if passed else "command_failed", None, details)
 
 
@@ -281,7 +385,16 @@ def _budget_evidence(metadata: SpecMetadata, rule: SpecRule, scope: Verification
     )
 
 
-def run_all_verifiers(
+def _missing_evidence(metadata: SpecMetadata, rule: SpecRule, scope: VerificationScope) -> VerificationEvidence:
+    details = {"rule": rule.ref}
+    return VerificationEvidence(
+        f"{metadata.id}#{rule.ref}", datetime.now(timezone.utc).isoformat(),
+        "unverified", rule.text_sha256, None, scope.diff_sha256,
+        _result_hash("unverified", "verifier_missing", details), "verifier_missing", details,
+    )
+
+
+def _run_all_verifiers(
     metadata: SpecMetadata,
     scope: VerificationScope,
     confirmations: Optional[Mapping[str, Mapping[str, object]]] = None,
@@ -290,7 +403,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,34 +413,40 @@ 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(
-                    f"{metadata.id}#{rule.ref}",
-                    datetime.now(timezone.utc).isoformat(),
-                    "unverified",
-                    rule.text_sha256,
-                    None,
-                    scope.diff_sha256,
-                    _result_hash("unverified", "verifier_missing", details),
-                    "verifier_missing",
-                    details,
-                )
-            )
+            evidence_by_ref[rule.ref] = _missing_evidence(metadata, rule, scope)
             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))
 
 
+def run_all_verifiers(metadata: SpecMetadata, scope: VerificationScope,
+                      confirmations: Optional[Mapping[str, Mapping[str, object]]] = None,
+                      skip_command: bool = False, timeout_budget: Optional[float] = None) -> VerificationResult:
+    with execution_session():
+        return _run_all_verifiers(metadata, scope, confirmations, skip_command, timeout_budget)
+
+
 def evidence_is_fresh(
     evidence: VerificationEvidence,
     rule_text_sha256: str,