@michaelxwb/code-flow 0.6.0 → 0.6.1

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

@@ -25,11 +25,13 @@ from cf_core import (
     ensure_utf8_io,
     load_config,
     normalize_path,
+    resolve_enforcement,
     resolve_quality_loop,
     resolve_session_id,
 )
 
 TOTAL_BUDGET_SECONDS = 30.0
+GATE_BUDGET_SECONDS = 25.0
 _BRACE_RE = re.compile(r"\{([^{}]+)\}")
 _TASK_SECTION_RE = re.compile(
     r"(?ms)^## (TASK-\d+):.*?(?=^## TASK-\d+:|\Z)"
@@ -246,6 +248,12 @@ def main() -> None:
             return  # 已因本 hook 续跑过一轮，避免循环
         project_root = os.getcwd()
         sid = resolve_session_id(data)
+        config = load_config(project_root)
+        if not config:
+            return
+        enforcement = resolve_enforcement(config)
+        if enforcement == "inject":
+            return  # 轻量模式：只注入不门禁，停止会话不受限
         marker = os.path.join(project_root, ".code-flow", ".active-task.json")
         has_active = os.path.exists(marker)
         files = []
@@ -253,19 +261,25 @@ def main() -> None:
             try:
                 active = load_active_task(project_root)
                 task_dir = os.path.join(project_root, active.task_dir)
-                done = run_done_gate(project_root, task_dir)
+                done = run_done_gate(project_root, task_dir, budget=GATE_BUDGET_SECONDS)
             except (OSError, ValueError) as exc:
-                payload = {"decision": "block", "reason": f"SPEC_WORKFLOW_BLOCKED: active task is invalid: {exc}"}
-                sys.stdout.write(json.dumps(payload, ensure_ascii=False))
-                return
-            if done.decision != "pass":
-                payload = {"decision": "block", "reason": "当前 TASK required Spec verifier/Evidence 未通过；修复或重新对齐后再 Done。"}
-                sys.stdout.write(json.dumps(payload, ensure_ascii=False))
-                return
-            files = list(done.files)
-        config = load_config(project_root)
-        if not config:
-            return
+                if enforcement == "required":
+                    payload = {"decision": "block", "reason": f"SPEC_WORKFLOW_BLOCKED: active task is invalid: {exc}"}
+                    sys.stdout.write(json.dumps(payload, ensure_ascii=False))
+                    return
+                cf_log.append_event(project_root, "stop_check", {"gate": "invalid_active_nonfatal", "error": str(exc)}, sid)
+                files = []
+            else:
+                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":
+                        payload = {"decision": "block", "reason": reason}
+                        sys.stdout.write(json.dumps(payload, ensure_ascii=False))
+                        return
+                    cf_log.append_event(project_root, "stop_check", {"gate": "blocked_nonfatal", "reason": reason}, sid)
+                files = list(done.files)
         if not resolve_quality_loop(config)["stop_check"]:
             return
         if not has_active:
@@ -280,6 +294,13 @@ def main() -> None:
         failures = acceptance_failures + failures
         if not failures:
             return  # 全过或无 validation.yml 且无验收缺口时静默
+        if enforcement == "warn":
+            cf_log.append_event(
+                project_root, "stop_check",
+                {"failures": [item["name"] for item in failures], "nonfatal": True},
+                sid,
+            )
+            return
         payload = {"decision": "block", "reason": _reason_text(failures, truncated)}
         sys.stdout.write(json.dumps(payload, ensure_ascii=False))
     except Exception as exc:

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

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""cf-sync: one-command canonical → deploy sync for dual-copy artifacts.
+
+Pairs (canonical source → deployed live copy), each with an explicit include
+prefix list — project-owned trees (specs/, tasks/) and deploy-only files
+(config.toml, CLAUDE.md, opencode.json) are never touched:
+
+  src/core/code-flow         → .code-flow        (scripts/, config.yml, .version, validation.yml, .gitignore)
+  src/adapters/claude        → .claude           (commands/, settings.local.json)
+  src/adapters/codex         → .codex            (hooks.json)
+  src/adapters/codex/skills  → .agents/skills    (everything)
+  src/adapters/costrict      → .costrict         (commands/, settings.local.json)
+  src/adapters/opencode      → .opencode         (commands/, plugins/)
+
+`check` (default) reports drift; `sync` copies canonical → deploy. Deploy-only
+files are never deleted (use --prune to remove files whose source side no
+longer contains them within the include prefixes).
+"""
+
+import argparse
+import filecmp
+import os
+from pathlib import Path
+import shutil
+import sys
+from typing import IO, Optional, Sequence
+
+
+PAIRS = (
+    ("src/core/code-flow", ".code-flow", ("scripts/", ".version", ".gitignore")),
+    ("src/adapters/claude", ".claude", ("commands/",)),
+    ("src/adapters/codex", ".codex", ("hooks.json",)),
+    ("src/adapters/codex/skills", ".agents/skills", ("*",)),
+    ("src/adapters/costrict", ".costrict", ("commands/",)),
+    ("src/adapters/opencode", ".opencode", ("commands/", "plugins/")),
+)
+
+_IGNORED_DIRS = {"__pycache__", ".git", "node_modules", "dist", "build"}
+
+
+def _included(relative: str, prefixes: Sequence[str]) -> bool:
+    return any(prefix == "*" or relative.startswith(prefix) for prefix in prefixes)
+
+
+def _walk(source: Path) -> list[str]:
+    files = []
+    for current, dirs, names in os.walk(source):
+        dirs[:] = sorted(item for item in dirs if item not in _IGNORED_DIRS)
+        base = Path(current)
+        for name in names:
+            files.append(str((base / name).relative_to(source)))
+    return sorted(files)
+
+
+def _relative(relative: str) -> str:
+    return relative.replace("\\", "/")
+
+
+def _pair_diffs(root: Path, source_rel: str, deploy_rel: str, prefixes: Sequence[str]) -> tuple[list[str], list[str], list[str]]:
+    """Return (differ, missing_in_deploy, deploy_only_within_prefixes)."""
+    source = root / source_rel
+    deploy = root / deploy_rel
+    differ: list[str] = []
+    missing: list[str] = []
+    for relative in _walk(source):
+        if not _included(_relative(relative), prefixes):
+            continue
+        source_file = source / relative
+        deploy_file = deploy / relative
+        if not deploy_file.exists():
+            missing.append(relative)
+        elif not filecmp.cmp(source_file, deploy_file, shallow=False):
+            differ.append(relative)
+    deploy_only: list[str] = []
+    if deploy.is_dir():
+        deploy_relative = set(_walk(deploy))
+        source_relative = {_relative(item) for item in _walk(source) if _included(_relative(item), prefixes)}
+        deploy_only = sorted(item for item in deploy_relative if item not in source_relative and _included(item, prefixes))
+    return differ, missing, deploy_only
+
+
+def _report(stdout: IO[str], root: Path, verbose: bool) -> int:
+    drift = 0
+    for source_rel, deploy_rel, prefixes in PAIRS:
+        differ, missing, deploy_only = _pair_diffs(root, source_rel, deploy_rel, prefixes)
+        status = "OK " if not (differ or missing) else "DRIFT"
+        stdout.write(f"{status} {source_rel} -> {deploy_rel}\n")
+        for relative in differ:
+            stdout.write(f"  diff  {deploy_rel}/{relative}\n")
+            drift += 1
+        for relative in missing:
+            stdout.write(f"  miss  {deploy_rel}/{relative}\n")
+            drift += 1
+        if verbose and deploy_only:
+            stdout.write(f"  only-in-deploy ({len(deploy_only)}):\n")
+            for relative in deploy_only[:10]:
+                stdout.write(f"    {deploy_rel}/{relative}\n")
+    return drift
+
+
+def _sync(root: Path, stdout: IO[str]) -> int:
+    copied = 0
+    for source_rel, deploy_rel, prefixes in PAIRS:
+        source = root / source_rel
+        deploy = root / deploy_rel
+        for relative in _walk(source):
+            if not _included(_relative(relative), prefixes):
+                continue
+            source_file = source / relative
+            deploy_file = deploy / relative
+            if deploy_file.exists() and filecmp.cmp(source_file, deploy_file, shallow=False):
+                continue
+            deploy_file.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source_file, deploy_file)
+            stdout.write(f"sync  {deploy_rel}/{relative}\n")
+            copied += 1
+    return copied
+
+
+def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    parser = argparse.ArgumentParser(prog="cf_sync.py")
+    parser.add_argument("action", choices=("check", "sync"), nargs="?", default="check")
+    parser.add_argument("--root", default=".")
+    parser.add_argument("--verbose", action="store_true")
+    args = parser.parse_args(argv)
+    root = Path(args.root).resolve()
+    if args.action == "check":
+        drift = _report(stdout, root, args.verbose)
+        if drift:
+            stdout.write(f"{drift} file(s) drifted; run `cf_sync.py sync` to deploy.\n")
+            return 1
+        stdout.write("all pairs in sync.\n")
+        return 0
+    copied = _sync(root, stdout)
+    stdout.write(f"{copied} file(s) deployed.\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -6,7 +6,8 @@ from __future__ import annotations
 from dataclasses import dataclass, replace
 import hashlib
 from pathlib import Path
-from typing import Mapping
+import time
+from typing import Mapping, Optional
 
 from cf_spec_context import (
     BindingInput,
@@ -19,11 +20,13 @@ from cf_spec_context import (
     load_active_task,
     load_context,
     pause_active_task,
+    resync_active_hash,
     save_context,
 )
 from cf_spec_gate import validate_stage
 from cf_spec_metadata import load_spec_metadata
 from cf_spec_resolver import resolve_candidates, SpecCandidate
+from cf_spec_session import context_sha256
 from cf_spec_verify import VerificationEvidence, VerificationScope, run_all_verifiers
 
 
@@ -40,6 +43,7 @@ class DoneResult:
     decision: str
     files: tuple[str, ...]
     evidence: tuple[Mapping[str, object], ...]
+    message: str = ""
 
 
 def _context_path(task_dir: str) -> str:
@@ -71,6 +75,9 @@ def evaluate_scope(root: str, task_dir: str) -> ScopeResult:
         for candidate in new
     )
     save_context(_context_path(task_dir), bind_specs(context, selections))
+    # The toolchain expanded the context itself; re-sync the marker so this
+    # automatic change does not surface as active_context_drift with no recovery.
+    resync_active_hash(root, task_dir, context_sha256(load_context(_context_path(task_dir))))
     required = tuple(candidate.spec_id for candidate in new if _required_candidate(candidate))
     if required:
         pause_active_task(root)
@@ -107,8 +114,20 @@ def _update_rule(rule: RuleBinding, evidence: Mapping[str, object]) -> RuleBindi
         return rule
     statuses = dict(rule.stage_status)
     current = statuses["code"]
+    if current.status in ("not_applicable", "waived"):
+        return rule
     status = "verified" if evidence.get("status") == "verified" else "unverified"
-    statuses["code"] = replace(current, status=status, evidence=(*current.evidence, evidence))
+    if evidence.get("error_code") == "skipped_in_cheap_gate":
+        signature = (evidence.get("verifier_ref"), evidence.get("result_sha256"), None)
+    else:
+        signature = (evidence.get("verifier_ref"), evidence.get("result_sha256"), evidence.get("diff_sha256"))
+    if any(
+        (item.get("verifier_ref"), item.get("result_sha256"), item.get("diff_sha256")) == signature
+        for item in current.evidence
+    ):
+        statuses["code"] = replace(current, status=status)
+    else:
+        statuses["code"] = replace(current, status=status, evidence=(*current.evidence, evidence))
     return replace(rule, stage_status=statuses)
 
 
@@ -125,18 +144,41 @@ def _apply_evidence(context: SpecContext, evidence: tuple[Mapping[str, object],
     return replace(context, bindings=tuple(bindings))
 
 
-def run_done_gate(root: str, task_dir: str) -> DoneResult:
+def _rule_manual_confirmation(rule: RuleBinding) -> Optional[Mapping[str, object]]:
+    status = rule.stage_status.get("code")
+    if status is None or status.decision is None or status.decision.kind != "manual_verification":
+        return None
+    decision = status.decision
+    return {
+        "reason": decision.reason,
+        "confirmed_by": decision.confirmed_by,
+        "confirmed_at": decision.confirmed_at,
+        "source": decision.source,
+    }
+
+
+def run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Optional[float] = None) -> DoneResult:
     scope_result = evaluate_scope(root, task_dir)
     if scope_result.decision == "pause":
-        return DoneResult("block", scope_result.files, ())
+        return DoneResult("block", scope_result.files, (), scope_result.message)
     context = load_context(_context_path(task_dir))
     diff_hash = _diff_hash(root, scope_result.files)
     all_evidence: list[Mapping[str, object]] = []
+    started = time.monotonic()
     for binding in context.bindings:
         metadata = load_spec_metadata(str(Path(root) / ".code-flow/specs" / binding.path))
-        result = run_all_verifiers(metadata, VerificationScope(root, scope_result.files, diff_hash))
+        confirmations: dict[str, Mapping[str, object]] = {}
+        for rule in binding.rules:
+            confirmation = _rule_manual_confirmation(rule)
+            if confirmation is not None:
+                confirmations[rule.ref] = confirmation
+        remaining = None if budget is None else budget - (time.monotonic() - started)
+        result = run_all_verifiers(
+            metadata, VerificationScope(root, scope_result.files, diff_hash), confirmations, cheap, remaining
+        )
         all_evidence.extend(_evidence_data(item) for item in result.evidence)
     updated = _apply_evidence(context, tuple(all_evidence))
-    save_context(_context_path(task_dir), updated)
-    gate = validate_stage(updated, "code")
+    if updated != context:
+        save_context(_context_path(task_dir), updated)
+    gate = validate_stage(updated, "code", diff_sha256=diff_hash)
     return DoneResult(gate.decision, scope_result.files, tuple(all_evidence))

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

@@ -8,13 +8,29 @@ import sys
 
 import cf_log
 from cf_checks import detect_correction
-from cf_core import _log, ensure_utf8_io, normalize_path, resolve_quality_loop, resolve_session_id, load_config
+from cf_core import (
+    _log,
+    ensure_utf8_io,
+    load_config,
+    normalize_path,
+    resolve_enforcement,
+    resolve_quality_loop,
+    resolve_session_id,
+)
+from cf_session_state import load_session_state, save_session_state
 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."""
@@ -46,6 +62,49 @@ def _record_correction(root: str, prompt: str, paths: list[str], sid: str) -> No
         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()
@@ -58,16 +117,53 @@ def main() -> None:
             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 = route_prompt(root, paths, sid)
-        if not result.text:
+        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
-        cf_log.append_event(root, "inject", {"specs": list(result.specs), "mode": result.mode, "source": result.mode}, sid)
-        sys.stdout.write(json.dumps(_payload(result.text, result.mode), ensure_ascii=False))
-    except RouterError as exc:
-        message = f"SPEC_WORKFLOW_BLOCKED [{exc.code}]: {exc}. Run cf-spec doctor before continuing."
-        sys.stdout.write(json.dumps(_payload(message, "blocked"), ensure_ascii=False))
+        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 the projection once per session/context, refreshing
+            # at the compress cadence so long sessions do not re-pay 12k chars
+            # on every prompt.
+            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
+            injected = state.get("injected_sha256")
+            last_inject = int(state.get("last_inject_prompt", 0))
+            if injected == result.context_sha256 and count - last_inject < _REINJECT_INTERVAL:
+                text = ""
+            else:
+                state["injected_sha256"] = result.context_sha256
+                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}")