@michaelxwb/code-flow 0.6.0 → 0.6.2

package/src/adapters/opencode/commands/cf-task/plan.md

@@ -1,8 +1,3 @@
----
-description: 从设计文档拆解需求，生成结构化任务文件
----
-
-
 # cf-task:plan
 
 从设计文档或设计简报拆解需求，生成结构化任务文件。
@@ -13,6 +8,8 @@ description: 从设计文档拆解需求，生成结构化任务文件
 - `/cf-task:plan` — 交互式选择（从 `docs/` 目录列出候选）
 - `/cf-task:plan <设计文档路径> --explore` — 仅输出分析报告，不生成文件
 - `/cf-task:plan <设计文档路径> --quick` — 跳过缺口分析，直接拆解（保持原有行为）
+- `/cf-task:plan <设计文档路径> --draft` — 仅生成任务草案，必须经过 `--verify-plan` 后才能启动
+- `/cf-task:plan <任务文件> --verify-plan` — 执行完整 Acceptance Coverage 与 Spec Rule 门禁
 - `/cf-task:plan <.design.md 路径>` — 从 cf-task:align 产出的设计简报拆解（自动跳过缺口分析）
 
 ## 执行步骤
@@ -62,6 +59,17 @@ Read 设计文档后，**先扫描文档结构**，建立章节索引表：
 
 此索引用于后续步骤中精确记录每个子任务的来源章节。
 
+### 2.4.1. Draft / Verify Plan 模式
+
+`--draft` 只生成任务结构、依赖、Source 和初步验收映射，产物状态必须保持 `draft`，不得直接进入 `start`。用户确认拆分后执行 `--verify-plan`，完成全部场景覆盖、唯一 Rule owner、verifier、测试层级和真实边界校验；默认模式仍执行完整校验。
+
+`--verify-plan` 的执行命令为：
+
+```bash
+python3 .code-flow/scripts/cf_acceptance_manifest.py \
+  --verify-plan --task-dir <需求目录> --task-file <任务文件>
+```
+
 ### 2.5. Explore 模式（--explore）
 
 如果用户传入 `--explore`，在建立章节索引后，输出以下分析报告，**不生成任务文件**：
@@ -303,6 +311,33 @@ TASK-002: <标题> [P1]
 python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage plan --artifact <任务文件> --json
 ```
 
+通过 Plan Gate 后，锁定验收基线：
+
+```bash
+python3 .code-flow/scripts/cf_acceptance_manifest.py \
+  --task-file <任务文件> \
+  --output <需求目录>/.acceptance-manifest.json
+```
+
+Manifest 锁定场景 ID、来源、测试层级、真实边界和责任 TASK。编码阶段不得静默修改这些字段；如发生范围变化，必须重新执行 plan 验证。
+
+验收类型按测试层级归类：
+- `unit/integration` → `functional`（Done Gate 自动执行）
+- `E2E` → `e2e`（延迟至所有任务完成后，需 `--include-e2e` 显式执行）
+- `manual` → `manual`（用户手动验证，永不自动执行）
+
+E2E 场景依赖外部环境（数据库、API、浏览器），在编码阶段默认跳过（状态 `e2e_deferred`），不阻断 Done Gate。所有子任务完成后，执行：
+
+```bash
+python3 .code-flow/scripts/cf_acceptance_runner.py \
+  --manifest <需求目录>/.acceptance-manifest.json \
+  --root . \
+  --include-e2e \
+  --write-evidence
+```
+
+不得为了提速降低 design 指定的 E2E 层级。
+
 只有 Context Plan 状态与任务结构校验都 `decision=pass` 才输出 Start 下一步；缺唯一 owner、`verifier_ref`、测试层级或真实边界时必须回到拆解修复。
 
 ### 6. 输出摘要

package/src/adapters/opencode/commands/cf-task/start.md

@@ -65,13 +65,12 @@ description: 激活子任务并开始编码
 
 在改状态或生产代码前，顺序固定且不得跳步：
 
-1. 调用 `cf_spec_context.py refresh --task-dir ...`，执行 Start Gate；stale/pending/conflict 或依赖未闭合均不得继续。
-2. 重新读取 refresh 后的 Context hash，再调用 `cf_spec_context.py active start`，传 task/context hash 和逐路径确认的 pre-existing ownership；已有/损坏 marker、未归属 diff 或 hash 不一致立即阻断。禁止先 start 再 refresh，避免 active marker 在编码前自行漂移。
-3. 调用 `cf_spec_session.py`，只根据当前 TASK 的 `Spec-Refs`、Source 与 Acceptance Contract 覆盖写入 `_session/task-<name>.md`。禁止重新 catalog 或猜测规则。
-4. 只有前三步全部成功，才用 Edit 更新子任务 Status 为 `in-progress`、追加 started log 并更新文件头日期。
-5. 在修改任何生产代码前，为每个 Acceptance-Ref 填写测试文件、包含场景 ID 的测试用例名和可单独执行的命令
-6. 先编写验收测试。E2E 测试必须经过契约声明的真实边界，不得用 mock 绕过 Store、Resolver、Builder、Renderer、Browser 等指定组件
-7. 新功能或缺陷修复先执行一次测试并记录 RED：失败命令、失败用例和与预期缺陷对应的失败原因。纯重构或已有行为补测无法 RED 时，记录原因，不得伪造失败
+1. 调用 `cf_spec_context.py start --task-dir ... --root ... --task ... --task-file ... --json`，由单个进程按 refresh → active start → session 顺序执行 Start Gate；stdin JSON 传入逐路径确认的 `owned_paths`。stale/pending/conflict、依赖未闭合、已有/损坏 marker、未归属 diff 或 hash 不一致立即阻断。禁止先 start 再 refresh，避免 active marker 在编码前自行漂移。
+2. 从命令返回值读取 refresh 后的 Context hash、active 状态和 session 输出路径；该命令只根据当前 TASK 的 `Spec-Refs`、Source 与 Acceptance Contract 覆盖写入 `.code-flow/specs/_session/task-<name>.md`，禁止重新 catalog 或猜测规则。
+3. 只有前两步全部成功，才用 Edit 更新子任务 Status 为 `in-progress`、追加 started log 并更新文件头日期。
+4. 在修改任何生产代码前，为每个 Acceptance-Ref 填写测试文件、包含场景 ID 的测试用例名和可单独执行的命令
+5. 先编写验收测试。E2E 测试必须经过契约声明的真实边界，不得用 mock 绕过 Store、Resolver、Builder、Renderer、Browser 等指定组件
+6. 新功能或缺陷修复先执行一次测试并记录 RED：失败命令、失败用例和与预期缺陷对应的失败原因。纯重构或已有行为补测无法 RED 时，记录原因，不得伪造失败
 
 RED 证据写入 `Acceptance Evidence`：
 

package/src/adapters/opencode/commands/cf-task/verify-e2e.md

@@ -0,0 +1,111 @@
+---
+description: Execute deferred E2E scenarios after all functional tests pass
+globs: []
+---
+
+# cf-task:verify-e2e
+
+执行需求目录下被延迟的 E2E 验收场景。
+
+## 使用场景
+
+E2E 测试依赖外部环境（数据库、API、浏览器等），在编码阶段默认跳过（状态 `e2e_deferred`）。当所有子任务的 functional 测试通过后，使用此命令统一执行 E2E 验收。
+
+## 调用方式
+
+```
+/cf-task:verify-e2e <需求目录>
+```
+
+## 执行步骤
+
+### 1. 检查前置条件
+
+确认需求目录下所有子任务状态为 `done` 或 `verified`：
+
+```bash
+rg "^Status:" <需求目录>/*.md
+```
+
+如有 `in-progress` 或 `blocked` 任务，提示用户先完成。
+
+### 2. 检查环境依赖
+
+读取 `.acceptance-manifest.json` 中的 E2E 场景，提取所需的外部依赖（从 `boundary` 字段推断）：
+
+- `HTTP API` → 提示确认 API 服务运行中
+- `Browser` → 提示确认浏览器驱动已安装
+- `Database` → 提示确认测试数据库可访问
+
+显示清单并询问：
+
+```
+E2E 场景需要以下环境：
+  - 本地 API 服务 (http://localhost:3000)
+  - PostgreSQL 测试数据库
+  - Chrome WebDriver
+
+环境已就绪？(y/N)
+```
+
+### 3. 执行 E2E 场景
+
+用户确认后，执行：
+
+```bash
+python3 .code-flow/scripts/cf_acceptance_runner.py \
+  --manifest <需求目录>/.acceptance-manifest.json \
+  --root . \
+  --include-e2e \
+  --write-evidence
+```
+
+### 4. 报告结果
+
+解析执行结果：
+
+```json
+{
+  "decision": "pass",
+  "results": [
+    {"id": "E-01", "kind": "e2e", "status": "passed"},
+    {"id": "E-02", "kind": "e2e", "status": "failed", "exit_code": 1}
+  ]
+}
+```
+
+- `decision=pass`：所有 E2E 场景通过，提示"E2E 验收完成"
+- `decision=block`：有失败场景，列出失败的场景 ID 和错误信息
+
+### 5. 更新任务状态
+
+所有 E2E 通过后，将需求目录下的任务状态更新为 `verified`（如果当前是 `done`）。
+
+## 失败处理
+
+E2E 失败时：
+
+1. 显示失败场景的完整命令和退出码
+2. 提示查看 `.acceptance-manifest.json` 中的 `evidence` 字段
+3. 不自动修改任务状态，等待用户修复后重新执行
+
+## 示例
+
+```
+/cf-task:verify-e2e .code-flow/tasks/2026-03-15/auth-module
+
+> 检查子任务状态... 所有任务已完成
+> 
+> E2E 场景需要以下环境：
+>   - 本地 API 服务 (http://localhost:3000)
+>   - PostgreSQL 测试数据库 (postgresql://localhost:5432/test)
+> 
+> 环境已就绪？(y/N) y
+> 
+> 执行 E2E 场景...
+>   ✓ E-01: 用户登录流程 (1.2s)
+>   ✓ E-02: 权限验证链路 (0.8s)
+> 
+> E2E 验收完成！2/2 场景通过
+> 已更新任务状态为 verified
+```

package/src/adapters/opencode/plugins/code-flow/index.js

@@ -21,13 +21,13 @@ function pythonPath(projectRoot, script) {
   return join(projectRoot, SCRIPT_DIR, script);
 }
 
-function callHook(projectRoot, script, input) {
+function callHook(projectRoot, script, input, timeout = 5000) {
   try {
     const proc = spawnSync("python3", [pythonPath(projectRoot, script)], {
       cwd: projectRoot,
       input: JSON.stringify(input),
       encoding: "utf-8",
-      timeout: 5000,
+      timeout,
       maxBuffer: 1024 * 1024,
     });
     if (proc.error || proc.status !== 0) {
@@ -65,7 +65,7 @@ export const CodeFlow = async (ctx) => {
         const sid =
           input.event?.properties?.sessionID ||
           input.event?.properties?.info?.id || "";
-        const result = callHook(projectRoot, "cf_stop_hook.py", { session_id: sid });
+        const result = callHook(projectRoot, "cf_stop_hook.py", { session_id: sid }, 35000);
         if (result?.reason) {
           // idle 无法阻断，校验失败排队到下一轮 system prompt
           const pending = sessionContext.get(sid);

package/src/core/code-flow/config.yml

@@ -2,7 +2,7 @@ version: 1
 
 spec_workflow:
     schema_version: 1
-    enforcement: required
+    enforcement: required  # required=全门禁 | warn=门禁仅记录不阻断 | inject=只注入不门禁
     drift_check: true
     scope_expansion_check: true
     metrics: true
@@ -29,6 +29,7 @@ quality_loop:
     # 注入时对 spec 内容做保守无损压缩（去行尾空白、折叠多空行、剥 HTML 注释、去重 bullet）
     # 缺省视为 true；仅显式 false 关闭
     compress: true
+    compress_reminder: true     # 会话过长每 N 轮提醒 /compact（per-session 计数，缺省 true）
     code_extensions:
         - ".py"
         - ".ts"

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

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Lock and validate plan Acceptance Coverage entries."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+import re
+import sys
+from typing import IO, Mapping, Optional, Sequence
+
+
+_ROW_RE = re.compile(r"^\|\s*([SEB]-\d+)\s*\|(.+?)\|$")
+
+
+def _kind(level: str) -> str:
+    """Map test level to execution kind.
+
+    - functional: auto-executed in Done Gate (unit, integration)
+    - e2e: deferred until explicit --verify-e2e (needs external dependencies)
+    - manual: user confirmation required, never auto-executed
+    """
+    normalized = level.strip().lower()
+    if normalized == "manual":
+        return "manual"
+    if normalized == "e2e":
+        return "e2e"  # Keep as separate kind, not functional
+    return "functional"
+
+
+def _manifest_hash(rows: list[dict[str, str]]) -> str:
+    immutable = [{key: item[key] for key in ("id", "source", "level", "kind", "boundary", "owner")} for item in rows]
+    payload = json.dumps(immutable, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def extract_manifest(task_file: str) -> dict[str, object]:
+    path = Path(task_file)
+    text = path.read_text(encoding="utf-8")
+    rows: list[dict[str, str]] = []
+    in_table = False
+    seen: set[str] = set()
+    for line in text.splitlines():
+        if line.startswith("## Acceptance Coverage"):
+            in_table = True
+            continue
+        if in_table and line.startswith("## "):
+            break
+        if not in_table:
+            continue
+        match = _ROW_RE.match(line)
+        if not match or set(match.group(2).replace("|", "").strip()) <= {"-", " "}:
+            continue
+        fields = [item.strip() for item in match.group(2).split("|")]
+        if len(fields) < 5 or match.group(1) in seen:
+            continue
+        seen.add(match.group(1))
+        rows.append({"id": match.group(1), "source": fields[0], "level": fields[1], "kind": _kind(fields[1]), "boundary": fields[2], "owner": fields[3], "status": fields[4]})
+    if not rows:
+        raise ValueError("Acceptance Coverage 缺失或为空")
+    return {"schema": 1, "task_file": str(path), "task_sha256": _manifest_hash(rows), "scenarios": rows}
+
+
+def write_manifest(task_file: str, output: str) -> dict[str, object]:
+    manifest = extract_manifest(task_file)
+    target = Path(output)
+    try:
+        manifest["task_file"] = str(Path(task_file).resolve().relative_to(target.parent.resolve()))
+    except ValueError:
+        manifest["task_file"] = str(Path(task_file).resolve())
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return manifest
+
+
+def validate_manifest(task_file: str, manifest_file: str) -> tuple[bool, str]:
+    try:
+        manifest = json.loads(Path(manifest_file).read_text(encoding="utf-8"))
+        expected = extract_manifest(task_file)
+    except (OSError, ValueError, json.JSONDecodeError) as exc:
+        return False, f"acceptance_manifest_invalid: {exc}"
+    if manifest.get("schema") != 1 or manifest.get("task_sha256") != expected["task_sha256"]:
+        return False, "acceptance_manifest_drift"
+    actual = {item.get("id") for item in manifest.get("scenarios", []) if isinstance(item, Mapping)}
+    required = {item["id"] for item in expected["scenarios"]}
+    if actual != required:
+        return False, "acceptance_manifest_scenarios_changed"
+    text = Path(task_file).read_text(encoding="utf-8")
+    for scenario in expected["scenarios"]:
+        owner = scenario["owner"]
+        section = re.search(rf"(?ms)^##\s+{re.escape(owner)}:.*?(?=^##\s+TASK-|\Z)", text)
+        refs = section.group(0).partition("Acceptance-Refs")[2] if section else ""
+        if scenario["id"] not in refs:
+            return False, "acceptance_manifest_owner_missing"
+    return True, ""
+
+
+def record_manual_evidence(manifest_file: str, scenario_id: str, confirmed_by: str, evidence: str) -> None:
+    if not confirmed_by or confirmed_by.lower().split(":", 1)[0] in {"agent", "assistant", "codex", "claude", "opencode", "costrict"}:
+        raise ValueError("manual evidence must be confirmed by a user")
+    path = Path(manifest_file)
+    data = json.loads(path.read_text(encoding="utf-8"))
+    scenarios = data.get("scenarios")
+    if not isinstance(scenarios, list):
+        raise ValueError("invalid manifest scenarios")
+    found = False
+    owner = ""
+    task_file = data.get("task_file")
+    for item in scenarios:
+        if isinstance(item, dict) and item.get("id") == scenario_id:
+            if item.get("kind") != "manual":
+                raise ValueError("scenario is not manual")
+            item["status"] = "verified"
+            item["evidence"] = {"confirmed_by": confirmed_by, "evidence": evidence}
+            found = True
+            owner = item.get("owner") if isinstance(item.get("owner"), str) else ""
+    if not found:
+        raise ValueError("scenario not found")
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    if isinstance(task_file, str) and task_file:
+        task_path = Path(task_file)
+        if not task_path.is_absolute():
+            task_path = path.parent / task_path
+        _sync_task_evidence(task_path, scenario_id, confirmed_by, evidence, owner)
+
+
+def _sync_task_evidence(task_file: Path, scenario_id: str, confirmed_by: str, evidence: str, owner: str = "") -> None:
+    text = task_file.read_text(encoding="utf-8")
+    if owner:
+        section_match = re.search(rf"(?ms)^##\s+{re.escape(owner)}:.*?(?=^##\s+TASK-|\Z)", text)
+    else:
+        section_match = re.search(r"(?ms)^##\s+TASK-\d+:.*?(?=^##\s+TASK-|\Z)", text)
+    if section_match is None:
+        return
+    section = section_match.group(0)
+    line = f"- {scenario_id}: verified — {evidence} (confirmed_by: {confirmed_by})"
+    contract_match = re.search(r"(?ms)^### Acceptance Contract\s*$\n(.*?)(?=^### |^## |\Z)", section)
+    if contract_match and scenario_id in contract_match.group(1) and "verified" not in contract_match.group(1).lower():
+        body = contract_match.group(1)
+        body = "\n".join((f"{item} — verified" if scenario_id in item else item) for item in body.splitlines())
+        section = section[:contract_match.start(1)] + body + section[contract_match.end(1):]
+    evidence_match = re.search(r"(?ms)^### Acceptance Evidence\s*$\n(.*?)(?=^### |^## |\Z)", section)
+    if evidence_match:
+        body = evidence_match.group(1)
+        replacement = body.rstrip() + "\n" + line + "\n"
+        section = section[:evidence_match.start(1)] + replacement + section[evidence_match.end(1):]
+    else:
+        section = section.rstrip() + "\n\n### Acceptance Evidence\n" + line + "\n"
+    task_file.write_text(text[:section_match.start()] + section + text[section_match.end():], encoding="utf-8")
+
+
+def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--task-file", required=True)
+    parser.add_argument("--output", default="")
+    parser.add_argument("--verify-plan", action="store_true")
+    parser.add_argument("--task-dir", default="")
+    parser.add_argument("--record-manual", action="store_true")
+    parser.add_argument("--scenario-id", default="")
+    parser.add_argument("--confirmed-by", default="")
+    parser.add_argument("--evidence", default="")
+    args = parser.parse_args(argv)
+    try:
+        if args.record_manual:
+            if not args.output or not args.scenario_id or not args.evidence:
+                raise ValueError("--record-manual requires --output, --scenario-id and --evidence")
+            record_manual_evidence(args.output, args.scenario_id, args.confirmed_by, args.evidence)
+            stdout.write(json.dumps({"ok": True, "scenario": args.scenario_id}, ensure_ascii=False))
+            return 0
+        if args.verify_plan:
+            if not args.task_dir:
+                raise ValueError("--verify-plan requires --task-dir")
+            from cf_spec_context import load_context
+            from cf_spec_gate import result_to_data, validate_plan_coverage, validate_stage
+
+            context = load_context(str(Path(args.task_dir) / "spec-context.yml"))
+            gate = validate_stage(context, "plan")
+            coverage = validate_plan_coverage(context, args.task_file)
+            result = {
+                "decision": "block" if gate.decision == "block" or coverage.decision == "block" else "pass",
+                "gate": result_to_data(gate),
+                "coverage": result_to_data(coverage),
+            }
+            stdout.write(json.dumps(result, ensure_ascii=False))
+            return 0 if result["decision"] == "pass" else 3
+        if not args.output:
+            raise ValueError("--output is required unless --verify-plan is used")
+        manifest = write_manifest(args.task_file, args.output)
+        stdout.write(json.dumps({"ok": True, "scenarios": len(manifest["scenarios"])}, ensure_ascii=False))
+        return 0
+    except (OSError, ValueError) as exc:
+        stdout.write(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False))
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""Execute manifest scenarios with deterministic ordering and evidence."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import sys
+from typing import IO, Mapping, Optional, Sequence
+
+
+def _run(item: Mapping[str, object], root: Path, include_e2e: bool = False) -> dict[str, object]:
+    scenario_id = str(item.get("id", "unknown"))
+    kind = str(item.get("kind", "functional"))
+    if kind == "manual":
+        return {"id": scenario_id, "kind": kind, "status": "manual_pending"}
+    if kind == "e2e" and not include_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 "."
+    try:
+        result = subprocess.run(command, cwd=str(root / cwd), capture_output=True, timeout=timeout_value, check=False)
+    except subprocess.TimeoutExpired:
+        return {"id": scenario_id, "kind": kind, "status": "failed", "error": "timeout"}
+    except OSError as exc:
+        return {"id": scenario_id, "kind": kind, "status": "failed", "error": str(exc)}
+    return {"id": scenario_id, "kind": kind, "status": "passed" if result.returncode == 0 else "failed", "exit_code": result.returncode}
+
+
+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 run_manifest(manifest_file: str, root: str, write_evidence: bool = False, include_e2e: bool = False) -> dict[str, object]:
+    data = json.loads(Path(manifest_file).read_text(encoding="utf-8"))
+    scenarios = data.get("scenarios", [])
+    if not isinstance(scenarios, list):
+        raise ValueError("invalid scenarios")
+    items = [item for item in scenarios if isinstance(item, Mapping)]
+    ordered = _ordered(items)
+    results = [_run(item, Path(root), include_e2e) for item in ordered]
+    configured = any(isinstance(item.get("command"), list) for item in items)
+    allowed = ("passed", "manual_pending", "e2e_deferred", "not_configured") if not configured else ("passed", "manual_pending", "e2e_deferred")
+    decision = "pass" if all(item["status"] in allowed for item in results) else "block"
+    if write_evidence:
+        for item, result in zip(ordered, results):
+            if isinstance(item, dict) and result["status"] == "passed":
+                item["status"] = "verified"
+                item["evidence"] = result
+        Path(manifest_file).write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        task_file = data.get("task_file")
+        if isinstance(task_file, str) and task_file:
+            from cf_acceptance_manifest import _sync_task_evidence
+
+            task_path = Path(task_file)
+            if not task_path.is_absolute():
+                task_path = Path(manifest_file).parent / task_path
+            for item, result in zip(ordered, results):
+                if result["status"] == "passed":
+                    owner = item.get("owner") if isinstance(item.get("owner"), str) else ""
+                    _sync_task_evidence(task_path, str(result["id"]), "runner", "automated command passed", owner)
+    return {"decision": decision, "results": results}
+
+
+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)")
+    args = parser.parse_args(argv)
+    try:
+        result = run_manifest(args.manifest, args.root, args.write_evidence, args.include_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
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -3,6 +3,7 @@ import fnmatch
 import os
 import re
 import sys
+import time
 
 # --- Config cache (fix #3: avoid re-parsing YAML on every hook call) ---
 
@@ -467,7 +468,8 @@ def resolve_quality_loop(config: dict) -> dict:
     """
     if not isinstance(config, dict):
         return {"enabled": False, "post_check": False,
-                "stop_check": False, "correction_capture": False}
+                "stop_check": False, "correction_capture": False,
+                "compress_reminder": False}
     cfg = config.get("quality_loop")
     cfg = cfg if isinstance(cfg, dict) else {}
     enabled = cfg.get("enabled") is True
@@ -480,9 +482,31 @@ def resolve_quality_loop(config: dict) -> dict:
         "post_check": _sub("post_check"),
         "stop_check": _sub("stop_check"),
         "correction_capture": _sub("correction_capture"),
+        "compress_reminder": _sub("compress_reminder"),
     }
 
 
+ENFORCEMENT_MODES = frozenset(("required", "warn", "inject"))
+
+
+def resolve_enforcement(config: dict) -> str:
+    """Project-wide Spec Workflow enforcement tier (light-mode ladder).
+
+    required — full fail-closed gates (default; upgraded projects keep it);
+    warn    — gates run but only log/report, never block the session;
+    inject  — routing/injection only; gates and blocks are disabled.
+    Missing or invalid values fail closed to "required".
+    """
+    if not isinstance(config, dict):
+        return "required"
+    workflow = config.get("spec_workflow")
+    workflow = workflow if isinstance(workflow, dict) else {}
+    value = workflow.get("enforcement")
+    if isinstance(value, str) and value in ENFORCEMENT_MODES:
+        return value
+    return "required"
+
+
 _FRONTMATTER_RE = re.compile(r"\A---[ \t]*\n(.*?)\n---[ \t]*\n?", re.DOTALL)
 
 
@@ -642,6 +666,25 @@ def _log(msg: str) -> None:
     print(msg, file=sys.stderr)
 
 
+_PROCESS_START = time.monotonic()
+
+
+def timing_log(name: str) -> None:
+    """Emit process-elapsed ms to stderr only when CF_DEBUG=1 (diagnostics).
+
+    Never touches stdout, so the hook JSON protocol is unaffected; a default
+    run pays one env lookup and no IO.
+    """
+    if os.environ.get("CF_DEBUG") == "1":
+        _log(f"{name}: {int((time.monotonic() - _PROCESS_START) * 1000)}ms")
+
+
+def phase_timing(name: str, started: float) -> None:
+    """Emit a named phase duration to stderr when CF_DEBUG=1."""
+    if os.environ.get("CF_DEBUG") == "1":
+        _log(f"cf_phase {name}: {int((time.monotonic() - started) * 1000)}ms")
+
+
 def ensure_utf8_io() -> None:
     """Force stdin/stdout/stderr to UTF-8 so Windows hooks don't mojibake.