@michaelxwb/code-flow 0.8.1 → 1.0.0

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

@@ -1,98 +0,0 @@
-"""OpenCode v2 native event RPC; no Claude/Codex hook wire translation."""
-import json
-import os
-import sys
-
-from codeflow.core import cf_log
-from codeflow.core.cf_core import ensure_utf8_io
-from codeflow.spec.cf_edit_service import after_edit, prepare_edits
-from codeflow.spec.cf_injection import injection_output
-from codeflow.core.cf_exec_base import execution_session
-from codeflow.core.cf_native_paths import project_root, validated_paths
-from codeflow.core.cf_patch import FileOperation, parse_patch
-from codeflow.core.cf_runtime_install import verify_install
-from codeflow.hooks.cf_stop_hook import build_stop_result
-from codeflow.hooks.cf_user_prompt_hook import build_prompt_context
-
-
-def edit_paths(root: str, directory: str, event: dict[str, object]) -> tuple[tuple[str, bool], ...]:
-    tool, inputs = event.get("tool"), event.get("input")
-    if not isinstance(inputs, dict):
-        raise ValueError("native tool input must be an object")
-    if tool in {"edit", "write"}:
-        path = inputs.get("path")
-        if not isinstance(path, str) or not path or "\x00" in path:
-            raise ValueError(f"{tool}.input.path must be a nonempty path")
-        operations = (FileOperation("update", path),)
-    elif tool == "patch":
-        command = inputs.get("patchText")
-        if not isinstance(command, str):
-            raise ValueError("patch.input.patchText must be a string")
-        operations = parse_patch(command)
-    else:
-        return ()
-    return validated_paths(root, directory, operations)
-
-
-def tool_result(root: str, directory: str, kind: str, event: dict[str, object], sid: str) -> dict[str, object]:
-    tool = event.get("tool")
-    if tool not in {"edit", "write", "patch"}:
-        return {"context": "", "blocked": False}
-    if kind == "tool.after" and event.get("status") != "completed":
-        cf_log.degrade(root, "opencode_tool", f"{tool}: edit not confirmed (status={event.get('status')})", sid)
-        return {"context": "", "blocked": False}
-    paths = edit_paths(root, directory, event)
-    if kind == "tool.before":
-        context, blocked = prepare_edits(root, tuple(path for path, _ in paths), sid, str(tool))
-        return {"context": context, "blocked": blocked}
-    text = []
-    blocked = False
-    for path, deleted in paths:
-        feedback = after_edit(root, path, sid, str(tool), deleted)
-        if feedback:
-            text.append(feedback)
-    context = "\n\n".join(dict.fromkeys(text))
-    return {"context": context, "blocked": blocked}
-
-
-def dispatch(data: dict[str, object]) -> dict[str, object]:
-    kind, directory, event = data.get("kind"), data.get("directory"), data.get("event")
-    if not isinstance(directory, str) or not os.path.isabs(directory) or not isinstance(event, dict):
-        raise ValueError("native event requires absolute session directory and an event object")
-    sid = event.get("sessionID")
-    if not isinstance(sid, str) or not sid:
-        raise ValueError("native event requires sessionID")
-    root = project_root(directory)
-    if not root:
-        return {"context": "", "blocked": False}
-    verify_install(root)
-    if kind == "session.prompt":
-        prompt = event.get("prompt")
-        if not isinstance(prompt, dict) or not isinstance(prompt.get("text"), str):
-            raise ValueError("native prompt.text must be a string")
-        text, mode = build_prompt_context(prompt["text"], sid, root)
-        return {"context": text, "blocked": mode == "blocked"}
-    if kind in {"tool.before", "tool.after"}:
-        return tool_result(root, directory, kind, event, sid)
-    if kind == "session.idle":
-        with execution_session():
-            result = build_stop_result(root, sid)
-        return {"context": result.get("reason", ""), "blocked": result.get("decision") == "block"}
-    raise ValueError(f"unknown native event kind: {kind}")
-
-
-def main() -> None:
-    ensure_utf8_io()
-    try:
-        data = json.loads(sys.stdin.read())
-        if not isinstance(data, dict):
-            raise ValueError("native RPC input must be an object")
-        with injection_output():
-            result = dispatch(data)
-            sys.stdout.write(json.dumps(result, ensure_ascii=False))
-            sys.stdout.flush()
-        return
-    except Exception as exc:
-        cf_log.warn(f"cf_opencode_event error: {exc}")
-        result = {"error": f"code-flow OpenCode runtime failed: {exc}. Run code-flow migrate --runtime --dry-run, then --apply."}
-    sys.stdout.write(json.dumps(result, ensure_ascii=False))

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

@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-"""Claude-style PostToolUse protocol entry; edit rules live in cf_edit_service."""
-import json
-import os
-import sys
-
-from codeflow.core.cf_core import ensure_utf8_io, resolve_session_id, timing_log
-from codeflow.core.cf_log import warn
-from codeflow.spec.cf_edit_service import after_edit
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        if sys.stdin.isatty():
-            warn("cf_post_hook.py: missing stdin event")
-            return
-        raw = sys.stdin.read()
-        if not raw.strip():
-            return
-        data = json.loads(raw)
-        tool = data.get("tool_name", "")
-        path = (data.get("tool_input") or {}).get("file_path", "")
-        if tool not in {"Edit", "Write", "MultiEdit"} or not isinstance(path, str) or not path:
-            return
-        text = after_edit(os.getcwd(), path, resolve_session_id(data), tool)
-        if text:
-            sys.stdout.write(json.dumps({"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": text}}, ensure_ascii=False))
-    except Exception as exc:
-        warn(f"cf_post_hook.py error: {exc}")

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

@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-"""Claude-style PreToolUse protocol entry; edit rules live in cf_edit_service."""
-import json
-import os
-import sys
-
-from codeflow.core.cf_core import ensure_utf8_io, resolve_session_id, timing_log
-from codeflow.core.cf_log import warn
-from codeflow.spec.cf_edit_service import prepare_edit
-from codeflow.spec.cf_injection import injection_output, pre_tool_payload
-from codeflow.core.cf_native_paths import project_root
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        if sys.stdin.isatty():
-            warn("cf_pre_tool_hook.py: missing stdin event")
-            return
-        raw = sys.stdin.read()
-        if not raw.strip():
-            return
-        data = json.loads(raw)
-        tool = data.get("tool_name", "")
-        path = (data.get("tool_input") or {}).get("file_path", "")
-        if tool not in {"Edit", "Write", "MultiEdit"} or not isinstance(path, str) or not path:
-            return
-        directory = os.getcwd()
-        root = project_root(directory)
-        if not root:
-            return
-        absolute = path if os.path.isabs(path) else os.path.join(directory, path)
-        with injection_output():
-            text, blocked = prepare_edit(root, absolute, resolve_session_id(data), tool)
-            if text:
-                sys.stdout.write(json.dumps(pre_tool_payload(text, blocked), ensure_ascii=False))
-                sys.stdout.flush()
-    except Exception as exc:
-        warn(f"cf_pre_tool_hook.py error: {exc}")
-        text = f"SPEC_WORKFLOW_BLOCKED [pre_tool_error]: {exc}"
-        sys.stdout.write(json.dumps(pre_tool_payload(text, True), ensure_ascii=False))

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

@@ -1,292 +0,0 @@
-#!/usr/bin/env python3
-"""Stop Hook: run validation.yml checks on session-edited files (FEAT-03).
-
-Flow: session edit events (cf_log) → match validator triggers → run commands
-serially under a total budget → failures surface as {"decision": "block",
-"reason": ...} so the agent fixes them before the session truly ends.
-
-Protocol notes (deviation from the injection-hook contract, recorded in
-TASK-010): the Stop event's feedback channel is decision/reason — there is no
-additionalContext for Stop. `stop_hook_active` is respected so an already
-continued session is never re-blocked (no loops). All-pass → silent exit 0.
-"""
-import json
-import os
-import re
-import sys
-import time
-
-from codeflow.core import cf_log
-from codeflow.core.cf_exec_base import execution_session
-from codeflow.cli.cf_spec_context import load_active_task
-from codeflow.task.cf_task_runtime import run_done_gate
-from codeflow.core.cf_stop_guard import StopAlreadyRunning, stop_guard
-from codeflow.acceptance.cf_acceptance_evidence import line_status, scenario_line
-from codeflow.task.cf_task_doc import TaskDocumentError, parse_task_document
-from codeflow.core.cf_validators import PARSE_ERROR, VALID, load_validators, run_validators
-from codeflow.acceptance.cf_acceptance_manifest_core import coverage_execution
-from codeflow.core.cf_core import (
-    ensure_utf8_io,
-    load_config,
-    normalize_path,
-    resolve_enforcement,
-    resolve_quality_loop,
-    resolve_session_id,
-    timing_log,
-)
-
-TOTAL_BUDGET_SECONDS = 30.0
-GATE_BUDGET_SECONDS = 25.0
-_SCENARIO_RE = re.compile(r"\b[SEB]-\d+\b")
-_UNVERIFIED_RE = re.compile(r"\b(?:planned|pending|tbd)\b", re.IGNORECASE)
-
-
-def session_edited_files(project_root: str, sid: str) -> list:
-    files = []
-    seen = set()
-    for event in cf_log.read_events(project_root, days=2, events=("edit",)):
-        if event.get("sid") != sid:
-            continue
-        rel = (event.get("data") or {}).get("file")
-        if rel and rel not in seen:
-            seen.add(rel)
-            files.append(rel)
-    return files
-
-
-def _root_scoped_files(project_root: str, files: list) -> list:
-    """Drop worktree-internal / outside-root paths.
-
-    Parallel subagents edit another working copy (.code-flow/worktrees/<run>/<TASK>/);
-    those paths must not trigger this root's validators.
-    """
-    root = os.path.realpath(project_root)
-    scoped = []
-    for rel in files:
-        path = normalize_path(rel)
-        if path.startswith(".code-flow/worktrees/"):
-            continue
-        absolute = os.path.realpath(os.path.join(root, path))
-        if absolute == root or absolute.startswith(root + os.sep):
-            scoped.append(rel)
-    return scoped
-
-
-def _is_active_task_file(rel_path: str) -> bool:
-    path = normalize_path(rel_path)
-    if not path.startswith(".code-flow/tasks/") or "/archived/" in path:
-        return False
-    return path.endswith(".md") and not path.endswith((".design.md", ".prd.md", ".scenarios.md"))
-
-
-def _subsection(section: str, heading: str) -> str:
-    match = re.search(
-        rf"(?ms)^### {re.escape(heading)}\s*$\n(.*?)(?=^### |^## |\Z)",
-        section,
-    )
-    return match.group(1) if match else ""
-
-
-def _acceptance_gap(task_id: str, section: str, coverage: str) -> str:
-
-    status = re.search(r"(?m)^- \*\*Status\*\*: ([^\n]+)", section)
-    # done = implementation finished; verified = E2E/final acceptance closed.
-    # Both enter the same contract checks; anything else is still in flight.
-    if not status or status.group(1).strip() not in ("done", "verified"):
-        return ""
-    refs_match = re.search(r"(?m)^- \*\*Acceptance-Refs\*\*: ([^\n]+)", section)
-    if not refs_match:
-        return f"{task_id} 缺少 Acceptance-Refs"
-    refs = refs_match.group(1).strip()
-    if refs.upper().startswith("N/A"):
-        return ""
-    scenarios = sorted(set(_SCENARIO_RE.findall(refs)))
-    if not scenarios:
-        return f"{task_id} Acceptance-Refs 未引用 S/E/B 场景"
-    contract = _subsection(section, "Acceptance Contract")
-    evidence = _subsection(section, "Acceptance Evidence")
-    if not contract or not evidence:
-        return f"{task_id} 缺少 Acceptance Contract 或 Acceptance Evidence"
-    for scenario in scenarios:
-        task_status = status.group(1).strip()
-        row_kind, row_exec = coverage_execution(coverage, scenario)
-        if task_status == "done" and (row_kind == "e2e" or row_exec == "deferred"):
-            allowed = {"verified", "e2e_deferred"}
-        elif task_status == "done" and row_kind == "manual":
-            # manual 人工验收延后到需求级 verify-e2e 由用户一次性确认（confirm-manual 写回 verified）
-            allowed = {"verified", "planned", "pending", "manual_pending"}
-        else:
-            allowed = {"verified"}
-        states = []
-        for body in (contract, evidence, coverage):
-            found = [line_status(line, scenario) for line in body.splitlines() if scenario_line(line, scenario)]
-            states.append(found[-1] if found else "")
-        if not all(state in allowed for state in states):
-            return f"{task_id} 的 {scenario} 状态未闭环（planned/pending/TBD/failed 或缺少 verified；仅实现阶段 E2E/显式 deferred 可 e2e_deferred、manual 可 manual_pending）"
-    return ""
-
-
-def task_acceptance_failures(project_root: str, files: list) -> list:
-    """Check new-format task files; legacy tasks without coverage are ignored."""
-    failures = []
-    for rel_path in files:
-        if not _is_active_task_file(rel_path):
-            continue
-        path = os.path.join(project_root, normalize_path(rel_path))
-        try:
-            with open(path, "r", encoding="utf-8") as f:
-                text = f.read()
-        except FileNotFoundError:
-            # Session logs retain paths after a task has moved or been deleted.
-            continue
-        except OSError as exc:
-            cf_log.warn(f"cf_stop_hook task read failed: {exc}")
-            continue
-        if "## Acceptance Coverage" not in text:
-            continue
-        coverage = text.split("## Acceptance Coverage", 1)[1]
-        boundary = coverage.find("\n## ")
-        if boundary != -1:
-            coverage = coverage[:boundary]
-        try:
-            document = parse_task_document(text, source=rel_path)
-        except TaskDocumentError as exc:
-            if exc.code == "task_document_empty":
-                continue
-            failures.append({
-                "name": "任务段落解析",
-                "on_fail": "修复任务文件中重复或损坏的 TASK 段落后再结束",
-                "detail": str(exc),
-            })
-            continue
-        for task in document.tasks:
-            detail = _acceptance_gap(task.id, task.body, coverage)
-            if detail:
-                failures.append({
-                    "name": "任务验收契约",
-                    "on_fail": "补齐设计场景的测试映射与执行证据后再完成任务",
-                    "detail": detail,
-                })
-    return failures
-
-
-def _reason_text(failures: list, truncated: bool) -> str:
-    lines = ["收尾校验未通过（cf-stop）："]
-    for item in failures:
-        tag = "（未执行）" if item.get("incomplete") else ""
-        lines.append(f"✗ {item['name']}{tag}：{item['on_fail']}")
-        if item["detail"]:
-            lines.append(f"  输出片段: {item['detail'][:200]}")
-    if truncated:
-        lines.append("（总预算 30s 已用尽，以上为已完成部分）")
-    lines.append("请修复后再结束。")
-    return "\n".join(lines)
-
-
-def _active_stop_scope(root: str, sid: str, enforcement: str, deadline: float) -> tuple[list[str], dict[str, str]]:
-    try:
-        active = load_active_task(root)
-        remaining = deadline - time.monotonic()
-        done = run_done_gate(root, os.path.join(root, active.task_dir), cheap=True,
-                             budget=min(GATE_BUDGET_SECONDS, max(remaining, 0.01)))
-    except (OSError, ValueError) as exc:
-        if enforcement == "required":
-            return [], {"decision": "block", "reason": f"SPEC_WORKFLOW_BLOCKED: active task is invalid: {exc}"}
-        cf_log.append_event(root, "stop_check", {"gate": "invalid_active_nonfatal", "error": str(exc)}, sid)
-        return [], {}
-    if done.decision != "pass":
-        reason = done.message or "当前 TASK required Spec verifier/Evidence 未通过；修复或重新对齐后再 Done。"
-        if any(item.get("error_code") == "verifier_budget_exhausted" for item in done.evidence):
-            reason += "（验证预算不足，部分 verifier 未运行，请拆分 TASK 或减少验证命令）"
-        if enforcement == "required":
-            return [], {"decision": "block", "reason": reason}
-        cf_log.append_event(root, "stop_check", {"gate": "blocked_nonfatal", "reason": reason}, sid)
-    return list(done.files), {}
-
-
-def _stop_feedback(root: str, sid: str, files: list[str], enforcement: str, deadline: float) -> dict[str, str]:
-    if not files:
-        return {}
-    failures = task_acceptance_failures(root, files)
-    truncated = False
-    config = load_validators(root)
-    if config.state == PARSE_ERROR:
-        failures.append({
-            "name": "validation.yml",
-            "on_fail": "修复 .code-flow/validation.yml 的 YAML/结构错误后再结束",
-            "detail": f"invalid_validation_config: {config.error}",
-        })
-    elif config.state == VALID:
-        filtered = config.without_heavy()
-        if filtered.validators:
-            outcome = run_validators(root, filtered, files, sid, deadline=deadline)
-            failures.extend(outcome.failures)
-            truncated = outcome.truncated
-    if not failures:
-        return {}
-    if enforcement == "warn":
-        cf_log.append_event(root, "stop_check", {"failures": [item["name"] for item in failures], "nonfatal": True}, sid)
-        return {}
-    return {"decision": "block", "reason": _reason_text(failures, truncated)}
-
-
-def build_stop_result(project_root: str, sid: str) -> dict[str, str]:
-    enforcement = "required"
-    try:
-        config = load_config(project_root)
-        if not config:
-            return {}
-        enforcement = resolve_enforcement(config)
-        if enforcement == "inject":
-            return {}
-        active = os.path.exists(os.path.join(project_root, ".code-flow/.active-task.json"))
-        enabled = resolve_quality_loop(config)["stop_check"]
-        if not active and not enabled:
-            return {}
-        with stop_guard(project_root, sid):
-            return _guarded_stop_result(project_root, sid, enforcement, active, enabled)
-    except StopAlreadyRunning as exc:
-        return {"decision": "block", "reason": str(exc)}
-    except Exception as exc:
-        cf_log.warn(f"cf_stop_hook error: {exc}")
-        return {"decision": "block", "reason": f"SPEC_WORKFLOW_BLOCKED: {exc}"} if enforcement == "required" else {}
-
-
-def _guarded_stop_result(root: str, sid: str, enforcement: str, active: bool, enabled: bool) -> dict[str, str]:
-    deadline = time.monotonic() + TOTAL_BUDGET_SECONDS
-    files, payload = _active_stop_scope(root, sid, enforcement, deadline) if active else ([], {})
-    if not payload and enabled:
-        if not active:
-            files = _root_scoped_files(root, session_edited_files(root, sid))
-        payload = _stop_feedback(root, sid, files, enforcement, deadline)
-    return payload
-
-
-def process_stop(data: dict[str, object], project_root: str) -> None:
-    try:
-        if data.get("stop_hook_active"):
-            return
-        payload = build_stop_result(project_root, resolve_session_id(data))
-        if payload:
-            sys.stdout.write(json.dumps(payload, ensure_ascii=False))
-    except Exception as exc:
-        cf_log.warn(f"cf_stop_hook error: {exc}")
-        sys.stdout.write(json.dumps({"decision": "block", "reason": f"SPEC_WORKFLOW_BLOCKED: {exc}"}, ensure_ascii=False))
-
-
-def _main() -> None:
-    try:
-        ensure_utf8_io()
-        if sys.stdin.isatty():
-            cf_log.warn("cf_stop_hook.py: missing stdin event")
-            return
-        raw = sys.stdin.read()
-        if raw.strip():
-            process_stop(json.loads(raw), os.getcwd())
-    except (json.JSONDecodeError, OSError, ValueError) as exc:
-        cf_log.warn(f"cf_stop_hook.py bad_stdin_json: {exc}")
-
-
-def main() -> None:
-    with execution_session():
-        _main()

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

@@ -1,161 +0,0 @@
-#!/usr/bin/env python3
-"""UserPromptSubmit hook for the Context-first three-branch router."""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import sys
-from pathlib import Path
-
-from codeflow.core import cf_log
-from codeflow.acceptance.cf_checks import detect_correction
-from codeflow.core.cf_core import (
-    ConfigError,
-    ensure_utf8_io,
-    load_config,
-    normalize_path,
-    resolve_quality_loop,
-    resolve_session_id,
-    timing_log,
-)
-from codeflow.core.cf_session_state import load_session_state, save_session_state
-from codeflow.spec.cf_injection import injection_output, injection_text
-from codeflow.spec.cf_spec_router import RouterError, RouteResult, route_prompt
-
-
-_PATH_RE = re.compile(r'`([^`\n]+)`|@?((?:[a-zA-Z]:[\\/]|/)?[a-zA-Z0-9_.][a-zA-Z0-9_./\\\-]*\.[a-zA-Z]{1,8})(?![a-zA-Z0-9_])')
-_EXT_RE = re.compile(r'\.(py|js|jsx|ts|tsx|vue|svelte|go|rs|java|rb|cs|cpp|c|h)$')
-_URL_RE = re.compile(r'\b[a-zA-Z][a-zA-Z0-9+.-]*://[^\s`<>]+')
-_HARNESS_RE = re.compile(
-    r"<(?P<tag>task-notification|output-file)\b[^>]*>.*?</(?P=tag)>",
-    re.IGNORECASE | re.DOTALL,
-)
-
-_COMPRESS_INTERVAL = 25
-_REMINDER_TEXT = (
-    "⚠ 本会话已处理较多轮次，上下文较长；批量任务建议在任务间压缩上下文，或拆到新会话继续。"
-)
-
-
-def extract_paths_from_prompt(prompt: str, root: str | None = None) -> list[str]:
-    """Extract explicit file paths without semantic keyword inference.
-
-    Paths outside the project are ignored: harness metadata (for example the
-    `<output-file>` in a background-agent notification) and pasted logs often
-    contain absolute paths that are not routable project files. Only in-project
-    paths participate in spec routing.
-    """
-    paths = []
-    seen = set()
-    text = _HARNESS_RE.sub("", prompt)
-    for match in _PATH_RE.finditer(_URL_RE.sub("", text)):
-        candidate = normalize_path((match.group(1) or match.group(2)).lstrip('@'))
-        if '/' not in candidate and not _EXT_RE.search(candidate):
-            continue
-        if root is not None:
-            try:
-                target = Path(candidate) if Path(candidate).is_absolute() else Path(root) / candidate
-                candidate = target.resolve().relative_to(Path(root).resolve()).as_posix()
-            except ValueError:
-                continue
-        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 mode == "blocked":
-        payload.update(decision="block", reason=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
-        next_at = int(state.get("next_remind_at", _COMPRESS_INTERVAL))
-        reminder = ""
-        if state["prompt_count"] >= next_at:
-            reminder = _REMINDER_TEXT
-            state["next_remind_at"] = next_at + _COMPRESS_INTERVAL
-    except (ValueError, TypeError, KeyError):
-        return ""
-    save_session_state(root, state)
-    return reminder
-
-
-def build_prompt_context(prompt: str, sid: str, root: str) -> tuple[str, str]:
-    try:
-        return _build_prompt_context(prompt, sid, root)
-    except (ConfigError, RouterError, OSError, UnicodeError, ValueError, TypeError) as exc:
-        return f"SPEC_WORKFLOW_BLOCKED [{getattr(exc, 'code', 'invalid_prompt_context')}]: {exc}. Run cf-spec doctor before continuing.", "blocked"
-
-
-def _build_prompt_context(prompt: str, sid: str, root: str) -> tuple[str, str]:
-    if not prompt.strip():
-        return "", ""
-    config = load_config(root)
-    active = (Path(root) / ".code-flow/.active-task.json").exists()
-    paths = extract_paths_from_prompt(prompt, None if active else root)
-    _record_correction(root, prompt, paths, sid)
-    result = route_prompt(root, paths, sid)
-    reminder = _session_reminder(root, sid) if config and resolve_quality_loop(config)["compress_reminder"] else ""
-    text = injection_text(root, sid, result, prompt=True)
-    if text and result.mode == "catalog":
-        cf_log.append_event(root, "inject", {"specs": list(result.specs), "mode": result.mode, "source": result.mode}, sid)
-    mode = result.mode if text else "reminder"
-    return "\n\n".join(part.rstrip() for part in (text, reminder) if part), mode
-
-
-def process_prompt(data: dict[str, object], root: str) -> None:
-    try:
-        prompt = data.get("prompt", "")
-        if not isinstance(prompt, str) or not prompt.strip():
-            return
-        with injection_output():
-            text, mode = build_prompt_context(prompt, resolve_session_id(data), root)
-            if text:
-                sys.stdout.write(json.dumps(_payload(text, mode), ensure_ascii=False))
-                sys.stdout.flush()
-    except (json.JSONDecodeError, UnicodeError, OSError, ValueError) as exc:
-        cf_log.warn(f"cf_user_prompt_hook error: {exc}")
-
-
-def main() -> None:
-    try:
-        ensure_utf8_io()
-        if sys.stdin.isatty():
-            cf_log.warn("cf_user_prompt_hook.py: missing stdin event")
-            return
-        raw = sys.stdin.read()
-        if raw.strip():
-            process_prompt(json.loads(raw), os.getcwd())
-    except (json.JSONDecodeError, OSError, ValueError) as exc:
-        cf_log.warn(f"cf_user_prompt_hook.py bad_stdin_json: {exc}")