@michaelxwb/code-flow 0.6.5 → 0.8.1

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

@@ -1,178 +1,11 @@
 #!/usr/bin/env python3
-"""UserPromptSubmit hook for the Context-first three-branch router."""
-
-import json
-import os
-import re
+"""Path-frozen entry shim: implementation lives in codeflow.hooks.cf_user_prompt_hook."""
 import sys
 
-import cf_log
-from cf_checks import detect_correction
-from cf_core import (
-    _log,
-    ensure_utf8_io,
-    load_config,
-    normalize_path,
-    resolve_enforcement,
-    resolve_quality_loop,
-    resolve_session_id,
-    timing_log,
-)
-from cf_session_state import load_session_state, save_session_state
-from cf_spec_context import injection_version
-from cf_spec_router import RouterError, route_prompt
-
-
-_PATH_RE = re.compile(r'[@`]?([a-zA-Z0-9_.][a-zA-Z0-9_./\\\-]*\.[a-zA-Z]{1,6})(?![a-zA-Z0-9_])')
-_EXT_RE = re.compile(r'\.(py|js|ts|go|rs|java|rb|cs|cpp|c|h)$')
-
-_COMPRESS_INTERVAL = 25
-_REINJECT_INTERVAL = 25
-_REMINDER_TEXT = (
-    "⚠ 本会话已处理较多轮次，上下文较长；批量任务建议在任务间压缩上下文，或拆到新会话继续。"
-)
-_WARN_TEXT = "⚠ Spec Workflow 校验未通过（warn 模式）：{message} — 建议运行 cf-spec doctor 检查。"
-
-
-def extract_paths_from_prompt(prompt: str) -> list[str]:
-    """Extract explicit file paths without semantic keyword inference."""
-    paths = []
-    seen = set()
-    for match in _PATH_RE.finditer(prompt):
-        candidate = normalize_path(match.group(1).lstrip('@`'))
-        if candidate not in seen and ('/' in candidate or _EXT_RE.search(candidate)):
-            paths.append(candidate)
-            seen.add(candidate)
-    return paths
-
-
-def _payload(text: str, mode: str) -> dict[str, object]:
-    payload: dict[str, object] = {
-        "hookSpecificOutput": {"hookEventName": "UserPromptSubmit", "additionalContext": text}
-    }
-    if os.environ.get("CF_DEBUG") == "1":
-        payload["debug"] = {"mode": mode}
-    return payload
-
-
-def _record_correction(root: str, prompt: str, paths: list[str], sid: str) -> None:
-    config = load_config(root)
-    if not config or not resolve_quality_loop(config)["correction_capture"]:
-        return
-    correction = detect_correction(prompt)
-    if correction:
-        cf_log.append_event(root, "correction", {"phrase": correction["phrase"], "prompt_head": prompt[:200], "files": paths}, sid)
-
-
-def _session_reminder(root: str, sid: str) -> str:
-    """One-line context-compress nudge once per COMPRESS_INTERVAL prompts per session.
-
-    Gated by quality_loop.compress_reminder; disabled → zero IO. Never raises: a
-    corrupt state file degrades to no reminder rather than breaking the hook.
-    """
-    config = load_config(root)
-    if not config or not resolve_quality_loop(config)["compress_reminder"]:
-        return ""
-    state = load_session_state(root)
-    try:
-        if state.get("session_id") != sid:
-            state = {"session_id": sid, "prompt_count": 0, "next_remind_at": _COMPRESS_INTERVAL}
-        state["prompt_count"] = int(state.get("prompt_count", 0)) + 1
-        reminder = ""
-        if state["prompt_count"] >= int(state.get("next_remind_at", _COMPRESS_INTERVAL)):
-            reminder = _REMINDER_TEXT
-            state["next_remind_at"] = int(state["next_remind_at"]) + _COMPRESS_INTERVAL
-    except (ValueError, TypeError):
-        return ""
-    save_session_state(root, state)
-    return reminder
-
-
-def _route_with_enforcement(root: str, paths: list[str], sid: str, enforcement: str) -> tuple[object, object]:
-    """Route with enforcement-aware failure handling.
-
-    required — fail closed with the SPEC_WORKFLOW_BLOCKED message;
-    warn    — degrade to a short advisory message;
-    inject  — degrade silently.
-    Returns (result, error_payload); exactly one is not None.
-    """
-    try:
-        return route_prompt(root, paths, sid), None
-    except RouterError as exc:
-        if enforcement == "required":
-            message = f"SPEC_WORKFLOW_BLOCKED [{exc.code}]: {exc}. Run cf-spec doctor before continuing."
-            return None, _payload(message, "blocked")
-        if enforcement == "warn":
-            return None, _payload(_WARN_TEXT.format(message=str(exc)), "warn")
-        return None, None
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        raw = sys.stdin.read()
-        if not raw.strip():
-            return
-        data = json.loads(raw)
-        prompt = data.get("prompt", "")
-        if not isinstance(prompt, str) or not prompt.strip():
-            return
-        root = os.getcwd()
-        sid = resolve_session_id(data)
-        config = load_config(root)
-        enforcement = resolve_enforcement(config) if config else "required"
-        paths = extract_paths_from_prompt(prompt)
-        _record_correction(root, prompt, paths, sid)
-        result, error_payload = _route_with_enforcement(root, paths, sid, enforcement)
-        if error_payload is not None:
-            sys.stdout.write(json.dumps(error_payload, ensure_ascii=False))
-            return
-        if result is None:
-            return
-        reminder = ""
-        if config and resolve_quality_loop(config)["compress_reminder"]:
-            reminder = _session_reminder(root, sid)
-        text = result.text
-        if result.mode == "task" and result.context_sha256:
-            # Dedup: inject once per session/task/contract version, refreshing
-            # at the compress cadence so long sessions do not re-pay 12k chars
-            # on every prompt. The key covers task_id and the TASK contract
-            # digest (not just the Context hash) so switching TASKs on a
-            # shared Context always re-injects the new contract.
-            state = load_session_state(root)
-            count = int(state.get("prompt_count", 0))
-            dirty = False
-            if not (config and resolve_quality_loop(config)["compress_reminder"]):
-                # compress_reminder off → _session_reminder never bumps the
-                # counter; maintain the cadence here so the periodic refresh
-                # still fires after compaction.
-                count += 1
-                state["prompt_count"] = count
-                dirty = True
-            version = injection_version(root, sid, result.context_sha256)
-            injected = state.get("injected_version")
-            last_inject = int(state.get("last_inject_prompt", 0))
-            if injected == version and count - last_inject < _REINJECT_INTERVAL:
-                text = ""
-            else:
-                state["injected_version"] = version
-                state["last_inject_prompt"] = count
-                dirty = True
-            if dirty:
-                save_session_state(root, state)
-        if not text and not reminder:
-            return
-        if text:
-            cf_log.append_event(root, "inject", {"specs": list(result.specs), "mode": result.mode, "source": result.mode}, sid)
-        if text and reminder:
-            text = text.rstrip() + "\n\n" + reminder
-        elif reminder:
-            text = reminder
-        sys.stdout.write(json.dumps(_payload(text, result.mode if text else "reminder"), ensure_ascii=False))
-    except (json.JSONDecodeError, UnicodeError, OSError, ValueError) as exc:
-        _log(f"cf_user_prompt_hook error: {exc}")
-
+from codeflow.hooks import cf_user_prompt_hook as _impl
 
 if __name__ == "__main__":
-    main()
-    timing_log("cf_user_prompt_hook")
+    _impl.main()
+    _impl.timing_log("cf_user_prompt_hook")
+else:
+    sys.modules[__name__] = _impl

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

@@ -1,81 +1,10 @@
-"""Programmatic validation entry with complete Git scope and argv execution."""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import os
-from pathlib import Path
-from typing import IO, Optional, Sequence
+#!/usr/bin/env python3
+"""Path-frozen entry shim: implementation lives in codeflow.cli.cf_validation."""
 import sys
 
-from cf_exec_base import execution_session
-from cf_spec_context import _git_changes, current_owned_paths, load_active_task
-
-
-def validation_scope(root: str, files: Sequence[str] = ()) -> tuple[str, ...]:
-    base = Path(root).resolve()
-    if files:
-        selected = []
-        for name in files:
-            path = (base / name).resolve()
-            if base not in path.parents:
-                raise ValueError(f"validation path outside project: {name}")
-            selected.append(path.relative_to(base).as_posix())
-        return tuple(sorted(set(selected)))
-    if (base / ".code-flow/.active-task.json").exists():
-        return current_owned_paths(str(base), load_active_task(str(base)))
-    return tuple(sorted(_git_changes(str(base))))
-
-
-def _validators(root: str) -> list[dict[str, object]]:
-    from cf_stop_hook import load_validators
-    if (Path(root) / ".code-flow/validation.yml").is_file():
-        return load_validators(root)
-    package = Path(root) / "package.json"
-    if not package.is_file():
-        return []
-    data = json.loads(package.read_text(encoding="utf-8"))
-    scripts = data.get("scripts", {}) if isinstance(data, dict) else {}
-    if not isinstance(scripts, dict):
-        raise ValueError("invalid package scripts")
-    return [{"name": name, "trigger": "*", "command": f"npm run {name}", "timeout": 60000}
-            for name in ("test", "lint") if isinstance(scripts.get(name), str)]
-
-
-def validate_files(root: str, files: Sequence[str] = (), budget: Optional[float] = None) -> dict[str, object]:
-    from cf_stop_hook import run_validators
-    selected = validation_scope(root, files)
-    validators = _validators(root)
-    if not selected:
-        return {"decision": "pass", "files": [], "reason": "no_changes"}
-    if not validators:
-        return {"decision": "block", "files": selected, "reason": "no_validators_configured"}
-    maximum = budget if budget is not None else sum(float(v.get("timeout", 30000)) / 1000 for v in validators)
-    if not math.isfinite(maximum) or maximum <= 0:
-        raise ValueError("validation budget must be finite and positive")
-    with execution_session():
-        failures, truncated = run_validators(root, validators, list(selected), "cf-validate", maximum, strict=True)
-    return {"decision": "block" if failures or truncated else "pass", "files": selected,
-            "failures": failures, "incomplete": truncated}
-
-
-def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--root", default=os.getcwd())
-    parser.add_argument("--files", nargs="*", default=[])
-    parser.add_argument("--budget", type=float)
-    parser.add_argument("--scope-only", action="store_true")
-    parser.add_argument("--json", action="store_true")
-    args = parser.parse_args(argv)
-    try:
-        result = {"files": validation_scope(args.root, args.files)} if args.scope_only else validate_files(args.root, args.files, args.budget)
-        stdout.write(json.dumps(result, ensure_ascii=False))
-        return 3 if result.get("decision") == "block" else 0
-    except (OSError, ValueError) as exc:
-        stdout.write(json.dumps({"decision": "block", "error": str(exc)}, ensure_ascii=False))
-        return 2
-
+from codeflow.cli import cf_validation as _impl
 
 if __name__ == "__main__":
-    raise SystemExit(main())
+    raise SystemExit(_impl.main())
+else:
+    sys.modules[__name__] = _impl

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

@@ -0,0 +1,347 @@
+"""Append execution history without erasing the user's acceptance contract."""
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Mapping, Optional, Sequence
+from uuid import uuid4
+
+from codeflow.evidence.cf_evidence_store import EvidenceStore, discover_project_root, git_commit
+from codeflow.acceptance.cf_acceptance_schema import check_outcome, load_manifest, recorded_check_hash, scenario_check_ids
+
+STATES = frozenset(("planned", "pending", "tbd", "verified", "unverified", "stale", "failed", "incomplete", "not_configured", "e2e_deferred", "env_blocked", "manual_pending", "accepted_risk"))
+_COVERAGE_STATES = STATES | {"designed"}
+_EVIDENCE_STATUS = {
+    "passed": "passed",
+    "failed": "failed",
+    "incomplete": "incomplete",
+    "not_configured": "not_configured",
+    "e2e_deferred": "deferred",
+    "env_blocked": "env_blocked",
+    "accepted_risk": "accepted_risk",
+}
+
+
+def scenario_line(line: str, scenario_id: str) -> bool:
+    return bool(re.match(rf"^\s*(?:\|\s*|[-*]\s+){re.escape(scenario_id)}(?=\s*[:|])", line))
+
+
+def line_status(line: str, scenario_id: str) -> str:
+    if not scenario_line(line, scenario_id):
+        return ""
+    if line.lstrip().startswith("|"):
+        cells = [cell.strip().lower() for cell in line.strip().strip("|").split("|")]
+        return next((cell for cell in reversed(cells) if cell in _COVERAGE_STATES), "")
+    match = re.match(r"^\s*[-*]\s+[^:]+:\s*([a-z0-9_]+)\b", line, re.I)
+    return match.group(1).lower() if match and match.group(1).lower() in _COVERAGE_STATES else ""
+
+
+def _status_index(header: str) -> int:
+    cells = [cell.strip().lower() for cell in header.strip().strip("|").split("|")]
+    for index, cell in enumerate(cells):
+        if cell in ("状态", "status"):
+            return index + 1
+    return -1
+
+
+def _status_line(line: str, scenario_id: str, status: str, status_index: int = -1) -> str:
+    if not scenario_line(line, scenario_id):
+        return line
+    if line.lstrip().startswith("|"):
+        cells = line.split("|")
+        if 0 < status_index < len(cells) - 1:
+            cells[status_index] = f" {status} "
+            return "|".join(cells)
+        for index in range(len(cells) - 1, 0, -1):
+            if cells[index].strip().lower() in _COVERAGE_STATES:
+                cells[index] = f" {status} "
+                return "|".join(cells)
+        return line.rstrip().rstrip("|") + f"| {status} |"
+    prefix = r"(^\s*[-*]\s+[^:]+:\s*)"
+    if line_status(line, scenario_id):
+        return re.sub(prefix + r"(?:" + "|".join(sorted(_COVERAGE_STATES)) + r")\b", rf"\g<1>{status}", line, count=1, flags=re.I)
+    return re.sub(prefix, rf"\g<1>{status} — ", line, count=1)
+
+
+def _patch_section(section: str, scenario_id: str, status: str, record: str) -> str:
+    contract = re.search(r"(?ms)^### Acceptance Contract[^\n]*\n(.*?)(?=^### |^## |\Z)", section)
+    if contract:
+        lines = contract.group(1).splitlines()
+        header = next((line for line in lines if line.lstrip().startswith("|")
+                       and ("状态" in line or "status" in line.lower())), "")
+        index = _status_index(header)
+        body = "\n".join(_status_line(line, scenario_id, status, index) for line in lines) + "\n"
+        section = section[:contract.start(1)] + body + section[contract.end(1):]
+    evidence = re.search(r"(?ms)^### Acceptance Evidence[^\n]*\n(.*?)(?=^### |^## |\Z)", section)
+    if evidence:
+        body = evidence.group(1)
+        if record not in body.splitlines():
+            body = body.rstrip() + "\n" + record + "\n\n"
+        section = section[:evidence.start(1)] + body + section[evidence.end(1):]
+    else:
+        section = section.rstrip() + "\n\n### Acceptance Evidence\n" + record + "\n"
+    return section
+
+
+def sync_task_evidence(task: Path, scenario_id: str, confirmed_by: str, evidence: str, owner: str = "", status: str = "verified") -> str:
+    """Sync one scenario's status into the task file; returns what was written.
+
+    - owner + TASK section → contract/evidence + coverage
+    - ownerless legacy scenario → coverage only (a scenario with neither owner
+      nor coverage has no truthful place to attribute evidence; first-TASK
+      attribution corrupted unrelated contracts, so it is skipped)
+    """
+    text = task.read_text(encoding="utf-8")
+    record = f"- {scenario_id}: {status} — {evidence} (confirmed_by: {confirmed_by})"
+    if owner:
+        task_pattern = re.escape(owner)
+        match = re.search(rf"(?ms)^##\s+{task_pattern}:.*?(?=^## |\Z)", text)
+        if match is None:
+            raise ValueError(f"acceptance owner missing: {owner}")
+        section = _patch_section(match.group(0), scenario_id, status, record)
+        text = text[:match.start()] + section + text[match.end():]
+    coverage = re.search(r"(?ms)^## Acceptance Coverage[^\n]*\n(.*?)(?=^## |\Z)", text)
+    if coverage:
+        lines = coverage.group(1).splitlines()
+        header = next((line for line in lines if line.lstrip().startswith("|")
+                       and ("状态" in line or "status" in line.lower())), "")
+        index = _status_index(header)
+        body = "\n".join(_status_line(line, scenario_id, status, index) for line in lines) + "\n"
+        text = text[:coverage.start(1)] + body + text[coverage.end(1):]
+    elif not owner:
+        return "skipped_no_owner"
+    from codeflow.core.cf_fs import atomic_write_text
+    atomic_write_text(task, text)
+    return "synced"
+
+
+def _run_record(row: Mapping[str, object], result: Mapping[str, object], run_id: str,
+                executed_at: str, fingerprint: str, commit: str,
+                check_config: Optional[Mapping[str, object]] = None) -> dict[str, object]:
+    source = check_config if isinstance(check_config, Mapping) else row
+    command = source.get("command")
+    if not isinstance(command, list):
+        command = []
+    timeout = source.get("timeout", 60)
+    cwd = source.get("cwd", ".")
+    state = str(result.get("status"))
+    exit_code = result.get("exit_code")
+    return {
+        "run_id": run_id,
+        "check_id": str(row.get("check") or row.get("id")),
+        "scenario_id": str(row.get("id")),
+        "command": command,
+        "cwd": cwd if isinstance(cwd, str) else ".",
+        "timeout": timeout if isinstance(timeout, (int, float)) else 60,
+        "input_hash": fingerprint if isinstance(fingerprint, str) else "",
+        "exit_code": exit_code if isinstance(exit_code, int) else (0 if state == "passed" else 1),
+        "status": _EVIDENCE_STATUS[state],
+        "executed_at": executed_at,
+        "source": str(result.get("source") or "local"),
+        "environment_hash": str(result.get("environment_hash") or ""),
+        "commit": commit,
+        "run_url": str(result.get("run_url") or ""),
+    }
+
+
+def _outcome_mapping(result: Mapping[str, object], field: str) -> Mapping[str, object]:
+    value = result.get(field)
+    return value if isinstance(value, Mapping) else {}
+
+
+def _store_evidence_runs(path: Path, rows: Mapping[str, Mapping[str, object]],
+                         results: Sequence[Mapping[str, object]], run_id: str,
+                         executed_at: str, fingerprint: str) -> dict[str, int]:
+    from codeflow.evidence.cf_evidence_store import requirement_key
+    project = discover_project_root(path.parent)
+    store = EvidenceStore(project, requirement_key(path.parent))
+    commit = git_commit(project)
+    created = duplicates = 0
+    for result in results:
+        state = str(result.get("status"))
+        if state not in _EVIDENCE_STATUS:
+            continue
+        if result.get("cache_reused") is True and result.get("checkpoint_reused") is not True:
+            continue
+        row = rows.get(str(result.get("id")))
+        if row is None:
+            continue
+        result_fingerprint = str(result.get("input_hash") or fingerprint)
+        raw_ids = result.get("check_ids")
+        check_ids = [str(value) for value in raw_ids] if isinstance(raw_ids, list) else []
+        check_id = str(row.get("check") or row.get("id"))
+        if not check_ids:
+            check_ids = [check_id]
+        check_hashes = _outcome_mapping(result, "check_hashes")
+        check_reused = _outcome_mapping(result, "check_reused")
+        check_checkpoint = _outcome_mapping(result, "checkpoint_reused_checks")
+        configs = _outcome_mapping(result, "check_configs")
+        for item_id in check_ids:
+            checkpointed = check_checkpoint.get(item_id, result.get("checkpoint_reused"))
+            item_hash = str(check_hashes.get(item_id) or result_fingerprint)
+            if check_reused.get(item_id) is True:
+                if checkpointed is not True:
+                    continue
+                if any(
+                    run.get("input_hash") == item_hash
+                    and run.get("status") in ("passed", "verified")
+                    for run in store.list_runs(item_id)
+                ):
+                    continue
+            config = configs.get(item_id)
+            record = _run_record(
+                row, check_outcome(result, item_id), run_id, executed_at, item_hash, commit,
+                config if isinstance(config, Mapping) else None,
+            )
+            record["check_id"] = item_id
+            outcome = store.write_run(item_id, record)
+            created += outcome["status"] == "created"
+            duplicates += outcome["status"] == "duplicate"
+    return {"created": created, "duplicates": duplicates}
+
+
+def _restore_checkpoint(row: dict[str, object], result: Mapping[str, object], run_key: str,
+                        executed_at: str, fingerprint: str) -> Optional[tuple[dict[str, object], str]]:
+    if result["status"] != "passed" or row.get("status") == "verified":
+        return None
+    row["revision"] = int(row.get("revision", 0)) + 1
+    record: dict[str, object] = {
+        "id": result["id"],
+        "kind": str(result.get("kind", "functional")),
+        "status": "passed",
+        "exit_code": 0,
+        "cache_reused": True,
+        "checkpoint_reused": True,
+        "revision": row["revision"],
+        "run_id": run_key,
+        "executed_at": executed_at,
+        "command": row.get("command"),
+        "cwd": row.get("cwd", "."),
+        "timeout": row.get("timeout", 60),
+    }
+    if fingerprint:
+        record["fingerprint"] = fingerprint
+    for key in ("check_ids", "check_hashes", "check_results", "check_reused", "checkpoint_reused_checks", "check_configs", "input_hash", "risk"):
+        if key in result:
+            record[key] = result[key]
+    row["status"] = "verified"
+    row.pop("stale_checks", None)
+    row.pop("stale_reason", None)
+    return record, "verified"
+
+
+def _record_result(row: dict[str, object], result: Mapping[str, object], run_key: str,
+                   executed_at: str, fingerprint: str) -> Optional[tuple[dict[str, object], str]]:
+    """Apply one result to a manifest row; None means keep the row unchanged."""
+    state = str(result["status"])
+    if result.get("cache_reused") is True:
+        return _restore_checkpoint(row, result, run_key, executed_at, fingerprint)
+    # A deferral placeholder (e2e skipped in a non-E2E run) must never
+    # downgrade a verified terminal scenario: verify-e2e runs first, then
+    # later Done/finish passes would otherwise silently un-verify it.
+    if state == "e2e_deferred" and row.get("status") == "verified":
+        return None
+    # An unavailable environment is not new product evidence: keep a prior
+    # verified conclusion, but never promote an unverified row.
+    if state == "env_blocked" and row.get("status") == "verified":
+        return None
+    row["revision"] = int(row.get("revision", 0)) + 1
+    status = "verified" if state == "passed" else state
+    row["status"] = status
+    row.pop("stale_checks", None)
+    row.pop("stale_reason", None)
+    record = {**result, "revision": row["revision"], "run_id": run_key, "executed_at": executed_at}
+    # Identity for cross-run reuse checks: command/cwd/timeout + content
+    # fingerprint of the worktree the command actually ran against.
+    record["command"] = row.get("command")
+    record["cwd"] = row.get("cwd", ".")
+    record["timeout"] = row.get("timeout", 60)
+    if fingerprint and status == "verified":
+        record["fingerprint"] = fingerprint
+    return record, status
+
+
+def stale_scenario_checks(row: Mapping[str, object], hashes: Mapping[str, Mapping[str, object]],
+                          fingerprint: str) -> list[str]:
+    """Compare every declared check; a missing or unavailable hash is stale."""
+    if row.get("status") not in ("verified", "accepted_risk", "stale"):
+        return []
+    if row.get("kind") == "manual" or row.get("exec") in ("manual", "aspirational"):
+        return []
+    check_ids = scenario_check_ids(row)
+    evidence = row.get("evidence")
+    evidence = evidence if isinstance(evidence, Mapping) else {}
+    if not check_ids:
+        return [] if fingerprint and evidence.get("fingerprint") == fingerprint else [str(row["id"])]
+    stale = []
+    for check_id in check_ids:
+        expected = hashes.get(check_id, {}).get("input_hash")
+        actual = recorded_check_hash(row, check_id)
+        if not expected or expected != actual:
+            stale.append(check_id)
+    return stale
+
+
+def invalidate_manifest_evidence(root: Path, manifest: Path,
+                                 fingerprint: str) -> list[dict[str, object]]:
+    """Mark outdated conclusions without changing historical execution evidence."""
+    from codeflow.acceptance.cf_check_inputs import check_input_hashes
+    from codeflow.core.cf_fs import atomic_write_text
+    data = load_manifest(manifest)
+    checks = {str(check["id"]): check for check in data.get("checks", [])}
+    hashes = check_input_hashes(str(root), checks, fingerprint)
+    changed: list[dict[str, object]] = []
+    for row in data["scenarios"]:
+        stale = stale_scenario_checks(row, hashes, fingerprint)
+        if not stale:
+            continue
+        row.update(status="stale", stale_checks=stale)
+        changed.append({"scenario_id": row["id"], "checks": stale})
+    if not changed:
+        return []
+    atomic_write_text(manifest, json.dumps(data, ensure_ascii=False, indent=2) + "\n")
+    task_name = data.get("task_file")
+    if isinstance(task_name, str) and task_name:
+        task = (manifest.parent / task_name).resolve()
+        rows = {row["id"]: row for row in data["scenarios"]}
+        for item in changed:
+            row = rows[item["scenario_id"]]
+            sync_task_evidence(task, str(row["id"]), "runtime",
+                               "input changed: " + ", ".join(item["checks"]),
+                               str(row.get("owner", "")), "stale")
+    return changed
+
+
+def persist_results(path: Path, data: dict[str, object], results: Sequence[Mapping[str, object]],
+                    fingerprint: str = "", run_id: str = "") -> None:
+    rows = {row["id"]: row for row in data["scenarios"]}
+    run_key, executed_at = run_id or uuid4().hex, datetime.now(timezone.utc).isoformat()
+    updates = []
+    for result in results:
+        state = str(result["status"])
+        if state in ("not_included", "manual_pending"):
+            continue
+        row = rows[result["id"]]
+        result_fingerprint = str(result.get("input_hash") or fingerprint)
+        applied = _record_result(row, result, run_key, executed_at, result_fingerprint)
+        if applied is None:
+            continue
+        record, status = applied
+        row["evidence"] = record
+        if result.get("cache_reused") is not True:
+            runs = row.setdefault("runs", [])
+            runs.append(record)
+            if len(runs) > 50:
+                del runs[:-50]
+        updates.append((row, record, status))
+    from codeflow.core.cf_fs import atomic_write_text
+    atomic_write_text(path, json.dumps(data, ensure_ascii=False, indent=2) + "\n")
+    _store_evidence_runs(path, rows, results, run_key, executed_at, fingerprint)
+    task_name = data.get("task_file")
+    if isinstance(task_name, str) and task_name:
+        task = Path(task_name) if Path(task_name).is_absolute() else path.parent / task_name
+        for row, record, status in updates:
+            detail = f"automated command {record['status']}; run_id={run_key}"
+            sync_task_evidence(task, str(row["id"]), "runner", detail, str(row.get("owner", "")), status)