@michaelxwb/code-flow 0.6.5 → 0.8.1

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

@@ -0,0 +1,98 @@
+"""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

@@ -0,0 +1,30 @@
+#!/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

@@ -0,0 +1,41 @@
+#!/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

@@ -0,0 +1,292 @@
+#!/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

@@ -0,0 +1,161 @@
+#!/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}")