cowork-flow 2.4.0 → 2.4.2

package/CHANGELOG.md

@@ -4,6 +4,28 @@
 
 ### Added
 
+### Changed
+
+## [2.4.2] - 2026-10-23
+
+### Added
+
+- **计划骨架生成与定稿门禁**：新增 `./.cowork-flow/run plan new --title ... --slug ...`，从已安装的本地化 `.cowork-flow/templates/plan-template.md` 生成计划骨架并替换标题占位符，默认拒绝覆盖已有计划；新增 `plan finalize [task-dir]`，校验计划模板形状、目标、AC、章节内容、任务简报字段、验证命令、anchor 的 AC/目标/规范核对和 `implement.jsonl`，通过后写入 `task.json.meta.planReady` 的 plan/anchor 摘要。模板中的角括号占位内容以及示例路径/符号（如 `path/a.py`、`function_name`）不算已填充，必须替换后才能定稿。任务创建会把计划 AC 自动填入 anchor 的验收标准。新 strict 非 Tiny 任务默认带 `planReadyRequired`，start 要求快照存在且摘要未变；人验收后修改计划或 anchor 会阻断 start，需重新 finalize 并重新验收。Tiny、legacy 与未标记旧任务保持原行为。
+
+### Changed
+
+- **计划流程改为“生成骨架 → 填充 → finalize → 人验收 → start”**：`task-planning` 技能、`plan-binding.md` 契约与 `plan finalize` 检查共同约束计划完整性；start 保留结构 backstop，并把新任务的完整性主检查前移到 finalize。契约摘要同步更新，未新增第二套计划模板。
+
+## [2.4.1] - 2026-10-23
+
+### Added
+
+- **新任务 anchor 预置规范核对脚手架**：`task create` 生成的 `decision-anchor.md` 在目标/验收标准后追加配置语言的 `## 验证命令` / `## Verification Commands`，并写入带 `<dev_type>` 与 `<pass / not_applicable + 理由>` 的 `规范核对：` / `Spec check:` 占位行和启动前替换说明。创建与 `--from-plan` 绑定仍保持宽松，占位行在 start 时才被门禁拒绝。
+
+### Changed
+
+- **strict 非 Tiny 任务的计划模板与规范核对硬门禁**：start 前校验绑定计划使用配置语言的标题标记、六个模板章节顺序、`### 任务` / `### Task` 前缀，以及 `## 最终验证` / `## Final Verification` 中已填写的 `规范核对：` / `Spec check:` 结果；同时要求 anchor 具有配置语言的验证节和已填写结果。模板占位符不算通过；事实视图不再把规范核对行当作 shell 命令。Tiny 与 legacy 任务保持原有行为，创建/绑定阶段不新增拒绝路径。
+
 ## [2.4.0] - 2026-10-23
 
 ### Added
@@ -423,7 +445,9 @@
 
 此版本未保留本地条目正文，详情见 [GitHub Release](https://github.com/fishlikewater/cowork-flow/releases/tag/v0.0.47)。
 
-[Unreleased]: https://github.com/fishlikewater/cowork-flow/compare/v2.4.0...HEAD
+[Unreleased]: https://github.com/fishlikewater/cowork-flow/compare/v2.4.2...HEAD
+[2.4.2]: https://github.com/fishlikewater/cowork-flow/compare/v2.4.1...v2.4.2
+[2.4.1]: https://github.com/fishlikewater/cowork-flow/compare/v2.4.0...v2.4.1
 [2.4.0]: https://github.com/fishlikewater/cowork-flow/compare/v2.3.0...v2.4.0
 [2.3.0]: https://github.com/fishlikewater/cowork-flow/compare/v2.2.0...v2.3.0
 [2.2.0]: https://github.com/fishlikewater/cowork-flow/compare/v2.1.0...v2.2.0

package/docs/architecture.en.md

@@ -73,7 +73,7 @@ Installers and the synchronizer do not read and write incrementally; they execut
 
 `config.yaml`, `.developer`, specs, tasks, and plans are protected by the sync policy. `--force` widens the overwrite range, but `.cowork-flow/config.yaml` is in `forceProtectedFiles`: once created, neither `init --force` nor `sync --force` overwrites it. For an existing project, run with `--dry-run` first to see the changes.
 
-The installation language is written to `language` in `config.yaml` (`zh-CN` by default, or `en-US`). The `localization` field of the Host Asset Manifest declares which assets have language variants; their source files live under `template/locales/<language>/<canonical-path>`. `init`, `sync`, and `dev refresh` choose the source file through `localizedSource()`, while the target path is always the canonical path, and `locales/` is excluded by `excludedPrefixes` so it never enters the project. Currently only `spec/contracts/decision-anchor.md` and `.cowork-flow/templates/plan-template.md` are localized: the former sets the heading language of a new anchor, the latter sets the language of plan artifacts, and parsers always accept both Chinese and English headings.
+The installation language is written to `language` in `config.yaml` (`zh-CN` by default, or `en-US`). The `localization` field of the Host Asset Manifest declares which assets have language variants; their source files live under `template/locales/<language>/<canonical-path>`. `init`, `sync`, and `dev refresh` choose the source file through `localizedSource()`, while the target path is always the canonical path, and `locales/` is excluded by `excludedPrefixes` so it never enters the project. Currently only `spec/contracts/decision-anchor.md` and `.cowork-flow/templates/plan-template.md` are localized: the former sets the heading language of a new anchor, the latter sets the language of plan artifacts, and parsers always accept both Chinese and English headings. The start gate for strict non-Tiny tasks additionally requires the plan and anchor to use the configured-language template shape and a filled `Spec check:` / `规范核对：` result; the template placeholder blocks start, while Tiny and legacy tasks are unaffected.
 
 `.cowork-flow/spec/` splits its sync policy by ownership. Framework-maintained `spec/contracts/`, `spec/runtime/`, `spec/schemas/`, and `spec/index.md` follow `sync`: contract errata, `contract-registry.json`, `host-assets.json`, `scope-rules.json`, and schemas therefore reach installed projects in the same generation as the scripts, and obsolete framework spec files registered in `obsoleteFiles` are deleted as well. Project-maintained `spec/backend/`, `spec/frontend/`, `spec/guides/`, and `spec/references/` stay protected, and a normal `sync` never overwrites or deletes files there. The cost is that a project which has locally modified a framework contract or `scope-rules.json` loses those changes on the next `sync`; customizations worth keeping should go into the four project directories, `AGENTS.md`, `config.yaml`, or a project-owned Skill.
 

package/docs/architecture.md

@@ -73,7 +73,7 @@
 
 `config.yaml`、`.developer`、规范、任务和计划按同步策略保护。`--force` 会扩大覆盖范围，但 `.cowork-flow/config.yaml` 是 `forceProtectedFiles`：首次创建后 `init --force` 和 `sync --force` 都不再覆盖它。已有项目应先用 `--dry-run` 查看变更。
 
-安装语言写在 `config.yaml` 的 `language`（`zh-CN` 默认，或 `en-US`）。Host Asset Manifest 的 `localization` 声明哪些资产存在语言变体，源文件位于 `template/locales/<language>/<canonical-path>`；`init`、`sync` 与 `dev refresh` 通过 `localizedSource()` 选择源文件，目标路径始终是 canonical path，`locales/` 被 `excludedPrefixes` 排除，不会进入项目。当前只有 `spec/contracts/decision-anchor.md` 与 `.cowork-flow/templates/plan-template.md` 本地化；前者决定新 anchor 的标题语言，后者决定计划产物语言，解析器始终同时接受中英两套标题。
+安装语言写在 `config.yaml` 的 `language`（`zh-CN` 默认，或 `en-US`）。Host Asset Manifest 的 `localization` 声明哪些资产存在语言变体，源文件位于 `template/locales/<language>/<canonical-path>`；`init`、`sync` 与 `dev refresh` 通过 `localizedSource()` 选择源文件，目标路径始终是 canonical path，`locales/` 被 `excludedPrefixes` 排除，不会进入项目。当前只有 `spec/contracts/decision-anchor.md` 与 `.cowork-flow/templates/plan-template.md` 本地化；前者决定新 anchor 的标题语言，后者决定计划产物语言，解析器始终同时接受中英两套标题。strict 非 Tiny 任务的 start 门禁另外要求计划与 anchor 使用配置语言的模板形状，并要求 `规范核对：` 行填写实际 `pass` / `not_applicable` 结果；模板占位符会被阻断，Tiny 与 legacy 任务不受影响。
 
 `.cowork-flow/spec/` 按归属拆分同步策略。框架维护的 `spec/contracts/`、`spec/runtime/`、`spec/schemas/` 与 `spec/index.md` 随 `sync` 更新：契约勘误、`contract-registry.json`、`host-assets.json`、`scope-rules.json` 和 schema 因此能与脚本同代际到达已装项目，`obsoleteFiles` 中登记的过期框架 spec 文件也会被删除。项目维护的 `spec/backend/`、`spec/frontend/`、`spec/guides/`、`spec/references/` 保持保护，普通 `sync` 不会覆盖或删除其中的文件。代价是本地修改过框架契约或 `scope-rules.json` 的项目会在下一次 `sync` 丢掉这些改动；需要保留的定制应写入四个项目目录、`AGENTS.md`、`config.yaml` 或项目自有 Skill。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "CLI for installing and maintaining cowork-flow collaboration templates.",
   "keywords": [
     "ai-agent",

package/presets/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Claude Code。",
   "displayName": "Cowork Flow",
   "author": {

package/presets/codex/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Codex。",
   "author": {
     "name": "fishlikewater",

package/presets/kimi-code/.kimi-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Kimi Code。",
   "author": {
     "name": "fishlikewater",

package/presets/qoder/.qoder-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 Qoder。",
   "displayName": "Cowork Flow",
   "author": {

package/presets/zcode/.zcode-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "cowork-flow",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 ZCode。",
   "author": {
     "name": "fishlikewater",

package/template/.cowork-flow/.version

@@ -1 +1 @@
-2.4.0
+2.4.2

package/template/.cowork-flow/scripts/adapters/cli/plan.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""Plan skeleton generation and readiness finalization CLI."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from adapters.cli.execution_context_args import (
+    build_internal_execution_context_parser,
+    execution_context_from_namespace,
+)
+from adapters.cli.task_support import (
+    Colors,
+    colored,
+    resolve_task_dir,
+    slugify,
+)
+from infra.paths import FILE_TASK_JSON, get_repo_root
+from runtime.session_state import (
+    PROVENANCE_PROCESS_FALLBACK,
+    get_active_task,
+)
+from services.plan_readiness import PlanReadinessError, PlanReadinessService
+from services.plan_scaffold import PlanScaffoldError, PlanScaffoldService
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Generate a plan skeleton or finalize planning artifacts",
+        parents=[build_internal_execution_context_parser()],
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    new_parser = subparsers.add_parser(
+        "new",
+        help="Create a plan skeleton from the installed localized template",
+    )
+    new_parser.add_argument("--title", required=True, help="Plan title")
+    new_parser.add_argument(
+        "--slug",
+        help="ASCII plan slug; defaults to the title when it slugifies",
+    )
+    new_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite an existing plan file",
+    )
+    new_parser.add_argument(
+        "--date",
+        help="Plan date prefix in YYYY-MM-DD form (default: today)",
+    )
+
+    finalize_parser = subparsers.add_parser(
+        "finalize",
+        help="Validate planning artifacts and record the plan-ready snapshot",
+    )
+    finalize_parser.add_argument(
+        "dir",
+        nargs="?",
+        help="Task directory or name; defaults to the active task",
+    )
+    finalize_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Print the plan-ready snapshot as JSON",
+    )
+    return parser
+
+
+def _resolve_task(args: argparse.Namespace, repo_root: Path) -> Path | None:
+    target = getattr(args, "dir", None)
+    if target:
+        task_dir = resolve_task_dir(target, repo_root)
+    else:
+        active = get_active_task(repo_root)
+        if not active.context_key:
+            print(
+                colored(
+                    "Error: Missing session context. Set "
+                    "COWORK_FLOW_CONTEXT_ID or pass a task dir.",
+                    Colors.RED,
+                ),
+                file=sys.stderr,
+            )
+            return None
+        if active.task_path and active.provenance == PROVENANCE_PROCESS_FALLBACK:
+            print(
+                colored(
+                    "Error: Session binding is process-fallback (shared); "
+                    "set COWORK_FLOW_CONTEXT_ID to the session value shown "
+                    "in the workflow-state header, or pass a task dir "
+                    "explicitly.",
+                    Colors.RED,
+                ),
+                file=sys.stderr,
+            )
+            return None
+        if not active.task_path:
+            print(
+                colored(
+                    "Error: No active task set for this session",
+                    Colors.RED,
+                ),
+                file=sys.stderr,
+            )
+            return None
+        task_dir = repo_root / active.task_path
+
+    if not task_dir.is_dir() or not (task_dir / FILE_TASK_JSON).is_file():
+        print(
+            colored(
+                f"Error: Task not found or task.json missing: {task_dir}",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return None
+    return task_dir
+
+
+def _cmd_new(args: argparse.Namespace, repo_root: Path) -> int:
+    slug = args.slug or slugify(args.title)
+    if not slug:
+        print(
+            colored(
+                "Error: could not generate an ASCII slug from the title; "
+                "pass --slug <ascii-slug>",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 1
+    try:
+        plan_path = PlanScaffoldService(repo_root).create(
+            args.title,
+            slug,
+            force=bool(args.force),
+            date_prefix=args.date,
+        )
+    except PlanScaffoldError as error:
+        print(
+            colored(
+                f"Error: Failed to create plan skeleton [{error.code}]: "
+                f"{error.detail}",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 1
+    try:
+        display = plan_path.resolve().relative_to(repo_root.resolve()).as_posix()
+    except ValueError:
+        display = str(plan_path)
+    print(display)
+    return 0
+
+
+def _cmd_finalize(args: argparse.Namespace, repo_root: Path) -> int:
+    task_dir = _resolve_task(args, repo_root)
+    if task_dir is None:
+        return 1
+    try:
+        snapshot = PlanReadinessService(repo_root).finalize(task_dir)
+    except PlanReadinessError as error:
+        print(
+            colored("Error: Plan is not ready for review", Colors.RED),
+            file=sys.stderr,
+        )
+        for blocker in error.blockers:
+            print(f"  - {blocker}", file=sys.stderr)
+        print(
+            "Hint: fill the planning artifacts, then rerun "
+            "`./.cowork-flow/run plan finalize <task-dir>`.",
+            file=sys.stderr,
+        )
+        return 1
+
+    if getattr(args, "json", False):
+        print(json.dumps(snapshot, ensure_ascii=False, indent=2))
+    else:
+        print(colored("Plan is ready for human review.", Colors.GREEN))
+        print(f"  planDigest: {snapshot['planDigest']}")
+        print(f"  anchorDigest: {snapshot['anchorDigest']}")
+        print(f"  readyAt: {snapshot['readyAt']}")
+        print(
+            "  Next: review the plan and anchor, then start the task. "
+            "Start will reject any later edit to either file."
+        )
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _build_parser().parse_args(argv)
+    execution_context = execution_context_from_namespace(args)
+    if not execution_context.is_default:
+        print(
+            colored(
+                "Error: plan commands must run in the main session; "
+                "delegated contexts cannot finalize a task.",
+                Colors.RED,
+            ),
+            file=sys.stderr,
+        )
+        return 2
+
+    repo_root = get_repo_root()
+    if args.command == "new":
+        return _cmd_new(args, repo_root)
+    if args.command == "finalize":
+        return _cmd_finalize(args, repo_root)
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/template/.cowork-flow/scripts/run.py

@@ -23,6 +23,7 @@ configure_cli_encoding()
 COMMAND_SCRIPTS = {
     "resume": "adapters/cli/resume.py",
     "task": "adapters/cli/task.py",
+    "plan": "adapters/cli/plan.py",
     "get-context": "adapters/cli/get_context.py",
     "get_context": "adapters/cli/get_context.py",
     "get-developer": "adapters/cli/get_developer.py",
@@ -35,7 +36,7 @@ COMMAND_SCRIPTS = {
 }
 RESERVED_COMMAND_NAMES = (*COMMAND_SCRIPTS, "python", "help", "-h", "--help")
 
-CONTEXT_AWARE_COMMANDS = {"resume", "task", "subagent"}
+CONTEXT_AWARE_COMMANDS = {"resume", "task", "plan", "subagent"}
 
 
 def print_usage() -> None:
@@ -49,6 +50,7 @@ def print_usage() -> None:
 Common commands:
   resume
   task
+  plan
   state
   get-context
   get-developer

package/template/.cowork-flow/scripts/services/decision_anchor_schema.py

@@ -23,6 +23,11 @@ REQUIRED_SECTIONS = (GOAL, ACCEPTANCE)
 
 DEFAULT_LANGUAGE = "zh-CN"
 
+SPEC_CHECK_LABELS: dict[str, str] = {
+    "zh-CN": "规范核对：",
+    "en-US": "Spec check:",
+}
+
 LANGUAGE_HEADINGS: dict[str, dict[str, str]] = {
     "zh-CN": {
         GOAL: "目标",
@@ -53,6 +58,10 @@ ACCEPTANCE_RE = re.compile(
     r"^\s*-\s*(?:\[([ xX])\]?\s*)?(AC-[A-Za-z0-9-]+)\s*[:：]\s*(.+?)\s*$"
 )
 LIST_ITEM_RE = re.compile(r"^\s*[-*]\s")
+LIST_PREFIX_RE = re.compile(r"^\s*[-*+]\s*")
+FENCE_MARKER_RE = re.compile(r"^(```|~~~)")
+SPEC_CHECK_RESULT_RE = re.compile(r"(?i)\b(?:pass|not_applicable)\b")
+ANGLE_SPAN_RE = re.compile(r"[<＜][^>＞]*[>＞]")
 
 
 def canonical_section(heading: str) -> str | None:
@@ -77,6 +86,130 @@ def section_headings(section: str) -> tuple[str, ...]:
     )
 
 
+def spec_check_label(language: str) -> str:
+    """The spec-check label for a language, falling back to the default."""
+    return SPEC_CHECK_LABELS.get(language, SPEC_CHECK_LABELS[DEFAULT_LANGUAGE])
+
+
+def _spec_check_remainder(line: str, language: str | None) -> str | None:
+    text = LIST_PREFIX_RE.sub("", line.strip(), count=1)
+    labels = (
+        (spec_check_label(language),)
+        if language is not None
+        else tuple(SPEC_CHECK_LABELS.values())
+    )
+    for label in labels:
+        if text.startswith(label):
+            return text[len(label):]
+    return None
+
+
+def is_spec_check_line(line: str, language: str | None = None) -> bool:
+    """Whether a line starts with the configured or any spec-check label."""
+    return _spec_check_remainder(line, language) is not None
+
+
+def is_spec_check_result_line(line: str, language: str | None = None) -> bool:
+    """Whether a spec-check line carries an actual result.
+
+    Angle-bracket spans are the template's placeholder syntax, so a result
+    mentioned only inside `<...>`/`＜...＞` does not count.
+    """
+    remainder = _spec_check_remainder(line, language)
+    if remainder is None:
+        return False
+    return SPEC_CHECK_RESULT_RE.search(ANGLE_SPAN_RE.sub("", remainder)) is not None
+
+
+def _spec_scope(dev_type: str | None) -> str:
+    """The spec source a task's dev_type dispatches to.
+
+    `spec` is the whole-spec dev type and its reading list starts at the spec
+    index, not at a `.cowork-flow/spec/spec/` directory.
+    """
+    if dev_type == "spec":
+        return ".cowork-flow/spec/"
+    return f".cowork-flow/spec/{dev_type or '<dev_type>'}/"
+
+
+def spec_check_placeholder(language: str, dev_type: str | None = None) -> str:
+    """The localized scaffold line that the start gate treats as unfilled."""
+    spec_dir = _spec_scope(dev_type)
+    if language == "en-US":
+        return (
+            f"- Spec check: clause-by-clause check against applicable "
+            f"`{spec_dir}` rules -> <pass / not_applicable + reason>."
+        )
+    return (
+        f"- 规范核对：逐条核对 `{spec_dir}` 适用规范 "
+        "→ <pass / not_applicable + 理由>。"
+    )
+
+
+def spec_check_example(language: str, dev_type: str | None = None) -> str:
+    """A filled spec-check example for start-gate error messages."""
+    spec_dir = _spec_scope(dev_type)
+    if language == "en-US":
+        return (
+            f"- Spec check: clause-by-clause check against applicable "
+            f"`{spec_dir}` rules -> pass (reason: ...)"
+        )
+    return (
+        f"- 规范核对：逐条核对 `{spec_dir}` 适用规范 → pass（理由：...）"
+    )
+
+
+def structural_lines(text: str) -> list[str]:
+    """Lines outside fenced code blocks, for structural Markdown checks."""
+    lines: list[str] = []
+    fence: str | None = None
+    for raw in text.splitlines():
+        marker = FENCE_MARKER_RE.match(raw.strip())
+        if marker is not None:
+            if fence is None:
+                fence = marker.group(1)
+            elif marker.group(1) == fence:
+                fence = None
+            continue
+        if fence is None:
+            lines.append(raw)
+    return lines
+
+
+def section_lines(
+    text: str,
+    section: str,
+    *,
+    skip_fenced: bool = False,
+) -> list[str]:
+    """Raw lines under a recognized heading, up to the next `##` heading."""
+    lines: list[str] = []
+    inside = False
+    source = structural_lines(text) if skip_fenced else text.splitlines()
+    for raw in source:
+        heading = HEADING_RE.match(raw.strip())
+        if heading:
+            inside = canonical_section(heading.group(1)) == section
+            continue
+        if inside:
+            lines.append(raw)
+    return lines
+
+
+def verification_section_lines(text: str) -> list[str]:
+    """Raw verification lines, ignoring fenced command examples."""
+    return section_lines(text, VERIFICATION, skip_fenced=True)
+
+
+def headings(text: str) -> tuple[str, ...]:
+    """Every `##` heading text in the document order."""
+    return tuple(
+        heading.group(1)
+        for raw in text.splitlines()
+        if (heading := HEADING_RE.match(raw.strip()))
+    )
+
+
 def present_sections(text: str) -> set[str]:
     """Canonical keys of the recognized `##` sections present in the text."""
     present: set[str] = set()
@@ -92,13 +225,4 @@ def present_sections(text: str) -> set[str]:
 
 def acceptance_section_lines(text: str) -> list[str]:
     """Raw lines under the acceptance heading, up to the next heading."""
-    lines: list[str] = []
-    inside = False
-    for raw in text.splitlines():
-        heading = HEADING_RE.match(raw.strip())
-        if heading:
-            inside = canonical_section(heading.group(1)) == ACCEPTANCE
-            continue
-        if inside:
-            lines.append(raw)
-    return lines
+    return section_lines(text, ACCEPTANCE)

package/template/.cowork-flow/scripts/services/fact_view.py

@@ -26,6 +26,7 @@ from services.decision_anchor_schema import (
     SCOPE,
     VERIFICATION,
     canonical_section,
+    is_spec_check_line,
 )
 
 GOAL_TRUNCATE = 300
@@ -73,6 +74,11 @@ def parse_decision_anchor(text: str) -> dict[str, Any]:
             command = raw.strip()
             if command.startswith("- "):
                 command = command[2:].strip()
+            if command.startswith("<!--"):
+                # Scaffold instructions and author notes are not commands.
+                continue
+            if is_spec_check_line(command):
+                continue
             if command and len(verify_commands) < VERIFY_COMMAND_MAX:
                 verify_commands.append(command[:VERIFY_COMMAND_TRUNCATE])
         elif section == SCOPE:

package/template/.cowork-flow/scripts/services/plan_binding.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from infra.files import read_text_utf8
 from infra.paths import DIR_WORKFLOW
+from services.plan_schema import plan_template_blockers as plan_text_blockers
 from services.task_repository import TaskRepository
 
 
@@ -165,3 +166,36 @@ def plan_file_blockers(repo_root: Path, task_data: dict) -> list[str]:
             return [f"planFile is empty: {error.normalized}"]
         return [error.detail]
     return []
+
+
+def plan_template_blockers(
+    repo_root: Path,
+    task_data: dict,
+    language: str,
+) -> list[str]:
+    """Structure blockers for an already-bound, non-empty plan."""
+    meta = task_data.get("meta")
+    plan_file = meta.get("planFile") if isinstance(meta, dict) else None
+    if not isinstance(plan_file, str) or not plan_file.strip():
+        return []
+    try:
+        bound = bind_plan_file(
+            repo_root,
+            plan_file,
+            allow_absolute=False,
+            require_exists=True,
+            require_non_empty=True,
+        )
+    except PlanBindingError:
+        # plan_file_blockers already reported the binding fact.
+        return []
+    text = read_text_utf8(bound.path)
+    if not text.strip():
+        return []
+    dev_type = task_data.get("dev_type")
+    if not isinstance(dev_type, str) or not dev_type.strip():
+        dev_type = None
+    return [
+        f"plan {bound.normalized}: {message}"
+        for message in plan_text_blockers(text, language, dev_type=dev_type)
+    ]