@michaelxwb/code-flow 0.6.4 → 0.8.1

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

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

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Path-frozen entry shim: implementation lives in codeflow.cli.cf_audit."""
+import sys
+
+from codeflow.cli import cf_audit as _impl
+
+if __name__ == "__main__":
+    raise SystemExit(_impl.main())
+else:
+    sys.modules[__name__] = _impl

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Path-frozen entry shim: implementation lives in codeflow.hooks.cf_codex_hook."""
+import sys
+
+from codeflow.hooks import cf_codex_hook as _impl
+
+if __name__ == "__main__":
+    _impl.main()
+else:
+    sys.modules[__name__] = _impl

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Path-frozen entry shim: implementation lives in codeflow.cli.cf_design_lint."""
+import sys
+
+from codeflow.cli import cf_design_lint as _impl
+
+if __name__ == "__main__":
+    raise SystemExit(_impl.main())
+else:
+    sys.modules[__name__] = _impl

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Path-frozen entry shim: implementation lives in codeflow.cli.cf_evidence_import."""
+import sys
+
+from codeflow.cli import cf_evidence_import as _impl
+
+if __name__ == "__main__":
+    raise SystemExit(_impl.main())
+else:
+    sys.modules[__name__] = _impl

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

@@ -1,56 +1,10 @@
 #!/usr/bin/env python3
-"""cf_feedback: mark a check as false positive (FEAT-02 对话即反馈).
-
-The violation feedback text tells the user "误报可直接告诉我"; the agent then
-runs this CLI on the user's behalf — no new slash command, no config editing.
-
-Usage: python3 cf_feedback.py ignore <check-id>
-Exit codes: 0 = recorded / 1 = usage error / 2 = unknown check id.
-stdout: one JSON line {"check_id", "fp_count", "hit_count", "disabled"}.
-"""
-import json
-import os
+"""Path-frozen entry shim: implementation lives in codeflow.cli.cf_feedback."""
 import sys
 
-from cf_checks import load_check_state, load_spec_checks, record_false_positive
-from cf_core import build_effective_mapping, load_config, normalize_spec_entry
-from cf_log import append_event
-
-
-def known_check_ids(project_root: str) -> set:
-    """All check ids: declared in any configured spec, or already in state."""
-    ids = set(load_check_state(project_root).keys())
-    config = load_config(project_root)
-    mapping = build_effective_mapping(
-        project_root, (config or {}).get("path_mapping") or {}
-    )
-    specs_root = os.path.join(project_root, ".code-flow", "specs")
-    for domain_cfg in mapping.values():
-        for entry in (domain_cfg or {}).get("specs") or []:
-            rel = normalize_spec_entry(entry).get("path")
-            if not rel:
-                continue
-            checks, _ = load_spec_checks(os.path.join(specs_root, rel))
-            ids.update(check["id"] for check in checks)
-    return ids
-
-
-def main(argv: list) -> int:
-    if len(argv) != 2 or argv[0] != "ignore":
-        sys.stderr.write("usage: cf_feedback.py ignore <check-id>\n")
-        return 1
-    check_id = argv[1]
-    project_root = os.getcwd()
-    if check_id not in known_check_ids(project_root):
-        sys.stderr.write(f"unknown check id: {check_id}\n")
-        return 2
-    append_event(
-        project_root, "false_positive", {"check_id": check_id}, "cf-feedback"
-    )
-    result = record_false_positive(project_root, check_id)
-    sys.stdout.write(json.dumps(result, ensure_ascii=False) + "\n")
-    return 0
-
+from codeflow.cli import cf_feedback as _impl
 
 if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))
+    sys.exit(_impl.main(sys.argv[1:]))
+else:
+    sys.modules[__name__] = _impl

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Path-frozen entry shim: implementation lives in codeflow.hooks.cf_opencode_event."""
+import sys
+
+from codeflow.hooks import cf_opencode_event as _impl
+
+if __name__ == "__main__":
+    _impl.main()
+else:
+    sys.modules[__name__] = _impl

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

@@ -1,196 +1,11 @@
 #!/usr/bin/env python3
-"""PostToolUse Hook: compliance feedback after Edit/Write (FEAT-01).
-
-Flow (spec-quality-loop.design.md §3.4):
-  edited file → matched domains → aggregate frontmatter checks of their
-  constraint specs → run against on-disk content → feedback via
-  additionalContext (advice only, never blocking) → violation events.
-
-Protocol invariants (RULE-01/02):
-  - always exit 0, stdout is JSON-only or empty (no-op);
-  - violations only warn — there is no error severity;
-  - same check+file reported once per session (RISK-05);
-  - any internal failure degrades silently (stderr + degrade event).
-
-Input (stdin): {"tool_name", "tool_input": {"file_path"}, "session_id"}
-Output: {"hookSpecificOutput": {"hookEventName": "PostToolUse",
-         "additionalContext": "..."}} or empty.
-"""
-import json
-import os
+"""Path-frozen entry shim: implementation lives in codeflow.hooks.cf_post_hook."""
 import sys
 
-import cf_log
-from cf_checks import (
-    load_check_state,
-    load_spec_checks,
-    record_hits,
-    run_checks,
-    save_check_state,
-)
-from cf_core import (
-    _log,
-    build_effective_mapping,
-    effective_project_root,
-    ensure_utf8_io,
-    is_code_file,
-    load_config,
-    match_domains,
-    normalize_path,
-    normalize_spec_entry,
-    resolve_enforcement,
-    resolve_quality_loop,
-    resolve_session_id,
-    timing_log,
-)
-
-FEEDBACK_HINT = '如认为误报，直接告诉我"这是误报"，我会标记忽略。'
-_REPORTED_KEY = "_reported"
-
-
-def _collect_checks(project_root: str, domains: list, mapping: dict) -> list:
-    """Aggregate checks of all constraint specs in matched domains.
-
-    Each check is annotated with its source spec path. Checks apply whenever
-    their own `files` glob matches — independent of injection tag gating.
-    """
-    specs_root = os.path.join(project_root, ".code-flow", "specs")
-    collected = []
-    seen_specs = set()
-    for domain in domains:
-        for entry in (mapping.get(domain) or {}).get("specs") or []:
-            cfg = normalize_spec_entry(entry)
-            rel = cfg.get("path")
-            if not rel or rel in seen_specs or not cfg.get("tags"):
-                continue
-            seen_specs.add(rel)
-            checks, _ = load_spec_checks(os.path.join(specs_root, rel))
-            for check in checks:
-                item = dict(check)
-                item["spec"] = rel
-                collected.append(item)
-    return collected
-
-
-def _session_reported(state: dict, sid: str) -> set:
-    session = state.get(_REPORTED_KEY) or {}
-    if session.get("sid") != sid:
-        return set()
-    return set(session.get("keys") or [])
-
-
-def _save_reported(project_root: str, state: dict, sid: str, keys: set) -> None:
-    state[_REPORTED_KEY] = {"sid": sid, "keys": sorted(keys)}
-    save_check_state(project_root, state)
-
-
-def _feedback_text(violations: list) -> str:
-    lines = ["## Spec 合规反馈 (auto-check)", ""]
-    for v in violations:
-        lines.append(f"⚠ {v['message']}（规则: {v['spec']}#{v['check_id']}）")
-        lines.append(f"  违规行 {v['line_no']}: {v['line']}")
-    lines.append("")
-    lines.append("请修正以上违规后再继续。" + FEEDBACK_HINT)
-    return "\n".join(lines)
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        raw = sys.stdin.read()
-        if not raw.strip():
-            return
-        data = json.loads(raw)
-        tool_name = data.get("tool_name", "")
-        file_path = (data.get("tool_input") or {}).get("file_path", "")
-        if tool_name not in {"Edit", "Write", "MultiEdit"}:
-            return
-        if not isinstance(file_path, str) or not file_path:
-            return
-
-        session_root = os.getcwd()
-        abs_path = file_path if os.path.isabs(file_path) else os.path.join(session_root, file_path)
-        # 并行子 agent 在 .code-flow/worktrees/... 内编辑时路由到该 worktree 的规格与状态
-        project_root = effective_project_root(session_root, abs_path)
-        config = load_config(project_root)
-        if not config:
-            return
-        if resolve_enforcement(config) == "inject":
-            return
-        quality_loop = resolve_quality_loop(config)
-        if not quality_loop["post_check"]:
-            return
-
-        rel_path = normalize_path(os.path.relpath(abs_path, project_root))
-        sid = resolve_session_id(data)
-        cf_log.append_event(project_root, "edit", {"file": rel_path, "tool": tool_name}, sid)
-        if not is_code_file(rel_path, config.get("quality_loop") or {}):
-            return
-        mapping = build_effective_mapping(
-            project_root, config.get("path_mapping") or {}
-        )
-        domains = match_domains(rel_path, mapping)
-        if not domains:
-            return
-
-        checks = _collect_checks(project_root, domains, mapping)
-        if not checks:
-            return
-
-        try:
-            with open(abs_path, "r", encoding="utf-8") as f:
-                content = f.read()
-        except Exception:
-            return
-
-        state = load_check_state(project_root)
-        violations, skipped = run_checks(checks, rel_path, content, state)
-        for item in skipped:
-            cf_log.degrade(
-                project_root, "post_check",
-                f"{item['check_id']}:{item['reason']}", sid,
-            )
-        if not violations:
-            return
-
-        spec_by_check = {c["id"]: c["spec"] for c in checks}
-        reported = _session_reported(state, sid)
-        fresh = []
-        for v in violations:
-            key = f"{v['check_id']}|{v['file']}"
-            if key in reported:
-                continue
-            v["spec"] = spec_by_check.get(v["check_id"], "")
-            fresh.append(v)
-            reported.add(key)
-        if not fresh:
-            return
-
-        # hit_count feeds the false-positive rate denominator (RULE-04)
-        record_hits(project_root, sorted({v["check_id"] for v in fresh}))
-        state = load_check_state(project_root)
-        _save_reported(project_root, state, sid, reported)
-
-        for v in fresh:
-            cf_log.append_event(
-                project_root, "violation",
-                {"check_id": v["check_id"], "spec": v["spec"],
-                 "file": v["file"], "severity": v["severity"]},
-                sid,
-            )
-
-        payload = {
-            "hookSpecificOutput": {
-                "hookEventName": "PostToolUse",
-                "additionalContext": _feedback_text(fresh),
-            }
-        }
-        sys.stdout.write(json.dumps(payload, ensure_ascii=False))
-    except Exception as exc:
-        _log(f"cf_post_hook error: {exc}")
-        return
-
+from codeflow.hooks import cf_post_hook as _impl
 
 if __name__ == "__main__":
-    main()
-    timing_log("cf_post_hook")
+    _impl.main()
+    _impl.timing_log("cf_post_hook")
+else:
+    sys.modules[__name__] = _impl

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

@@ -1,104 +1,11 @@
 #!/usr/bin/env python3
-"""PreToolUse hook: advisory Context/scope guidance on Edit/Write/MultiEdit.
-
-Hot-path policy: never deny the tool; inject context or guidance instead.
-Hard enforcement lives at the checkpoints (start / done / stop), not here.
-"""
-
-import json
-import os
-from pathlib import Path
+"""Path-frozen entry shim: implementation lives in codeflow.hooks.cf_pre_tool_hook."""
 import sys
 
-import cf_log
-from cf_core import (
-    _log,
-    effective_project_root,
-    ensure_utf8_io,
-    load_config,
-    normalize_path,
-    resolve_enforcement,
-    resolve_session_id,
-    timing_log,
-)
-from cf_session_state import load_session_state, save_session_state
-from cf_spec_context import injection_version, load_active_task, load_context
-from cf_spec_resolver import resolve_candidate_headers
-from cf_spec_router import RouterError, route_prompt
-
-_WARN_TEXT = "⚠ Spec Workflow 校验未通过（warn 模式）：{message} — 建议运行 cf-spec doctor 检查。"
-
-
-def _active_expansion(root: str, relative: str) -> tuple[str, ...]:
-    marker = Path(root) / ".code-flow/.active-task.json"
-    if not marker.exists():
-        return ()
-    active = load_active_task(root)
-    context = load_context(str(Path(root) / active.task_dir / "spec-context.yml"))
-    bound = {item.spec_id for item in context.bindings}
-    return tuple(
-        item.spec_id for item in resolve_candidate_headers(root, "code", (relative,))
-        if item.spec_id not in bound and item.enforcement == "required"
-        and getattr(item, "scope", "path") != "unmatched"
-    )
-
-
-def _inject(text: str) -> dict[str, object]:
-    return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "additionalContext": text}}
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        raw = sys.stdin.read()
-        if not raw.strip():
-            return
-        data = json.loads(raw)
-        tool_name = data.get("tool_name", "")
-        file_path = (data.get("tool_input") or {}).get("file_path", "")
-        if tool_name not in {"Edit", "Write", "MultiEdit"} or not isinstance(file_path, str) or not file_path:
-            return
-        session_root = os.getcwd()
-        absolute = file_path if os.path.isabs(file_path) else os.path.join(session_root, file_path)
-        # 并行子 agent 在 .code-flow/worktrees/... 内编辑时路由到该 worktree 的上下文
-        root = effective_project_root(session_root, absolute)
-        sid = resolve_session_id(data)
-        config = load_config(root)
-        enforcement = resolve_enforcement(config) if config else "required"
-        relative = normalize_path(os.path.relpath(absolute, root))
-        try:
-            expanded = _active_expansion(root, relative)
-            result = route_prompt(root, (relative,), sid)
-        except RouterError as exc:
-            if enforcement == "required":
-                sys.stdout.write(json.dumps(_inject(f"SPEC_WORKFLOW_BLOCKED [{exc.code}]: {exc}. Run cf-spec doctor before continuing."), ensure_ascii=False))
-            elif enforcement == "warn":
-                sys.stdout.write(json.dumps(_inject(_WARN_TEXT.format(message=str(exc))), ensure_ascii=False))
-            return
-        if expanded:
-            message = f"⚠ 该路径引入未绑定 required Spec：{', '.join(expanded)} — 建议先 refresh Context / Plan 再继续编辑。"
-            sys.stdout.write(json.dumps(_inject(message), ensure_ascii=False))
-            return
-        text = result.text
-        if result.mode == "task" and result.context_sha256:
-            # The projection is already in context from the prompt route unless
-            # the session/task/contract version changed; skip per-edit
-            # re-injection. Same version key as the prompt hook so a TASK
-            # switch re-injects here too.
-            state = load_session_state(root)
-            version = injection_version(root, sid, result.context_sha256)
-            if state.get("injected_version") == version:
-                text = ""
-            else:
-                state["injected_version"] = version
-                save_session_state(root, state)
-        if text:
-            sys.stdout.write(json.dumps(_inject(text), ensure_ascii=False))
-        cf_log.append_event(root, "edit_intent", {"file": relative, "tool": tool_name, "specs": list(result.specs)}, sid)
-    except (json.JSONDecodeError, OSError, ValueError) as exc:
-        _log(f"cf_pre_tool_hook error: {exc}")
-
+from codeflow.hooks import cf_pre_tool_hook as _impl
 
 if __name__ == "__main__":
-    main()
-    timing_log("cf_pre_tool_hook")
+    _impl.main()
+    _impl.timing_log("cf_pre_tool_hook")
+else:
+    sys.modules[__name__] = _impl

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+"""Path-frozen entry shim: implementation lives in codeflow.cli.cf_scenarios."""
+import sys
+
+from codeflow.cli import cf_scenarios as _impl
+
+if __name__ == "__main__":
+    raise SystemExit(_impl.main())
+else:
+    sys.modules[__name__] = _impl