cowork-flow 2.4.0 → 2.4.1

package/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 ### Added
 
+### Changed
+
+## [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 +435,8 @@
 
 此版本未保留本地条目正文，详情见 [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.1...HEAD
+[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.1",
   "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.1",
   "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.1",
   "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.1",
   "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.1",
   "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.1",
   "description": "AI 协作工作流引擎：任务生命周期、子代理调度、门禁与状态注入。将 cowork-flow 的完整工作流带入 ZCode。",
   "author": {
     "name": "fishlikewater",

package/template/.cowork-flow/.version

@@ -1 +1 @@
-2.4.0
+2.4.1

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)
+    ]

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

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Plan template language and structure checks for strict task start.
+
+The checks are intentionally structural: a plan must use the configured
+language's title marker, the six template sections, task-heading prefixes and a
+filled spec-check line. Prose, step status, acceptance text and evidence
+matching stay out of scope.
+"""
+
+from __future__ import annotations
+
+import re
+
+from services.decision_anchor_schema import (
+    DEFAULT_LANGUAGE,
+    is_spec_check_result_line,
+    spec_check_example,
+    spec_check_label,
+    structural_lines,
+)
+
+PLAN_TITLE_MARKERS: dict[str, str] = {
+    "zh-CN": "实施计划",
+    "en-US": "Implementation Plan",
+}
+
+PLAN_SECTION_HEADINGS: dict[str, tuple[str, ...]] = {
+    "zh-CN": (
+        "目标",
+        "验收标准",
+        "全局约束",
+        "文件边界",
+        "任务",
+        "最终验证",
+    ),
+    "en-US": (
+        "Goal",
+        "Acceptance Criteria",
+        "Global Constraints",
+        "File Boundaries",
+        "Tasks",
+        "Final Verification",
+    ),
+}
+
+PLAN_TASK_PREFIXES: dict[str, str] = {
+    "zh-CN": "任务",
+    "en-US": "Task",
+}
+
+H1_RE = re.compile(r"^#(?!#)\s+(.+?)\s*$")
+H2_RE = re.compile(r"^##(?!#)\s+(.+?)\s*$")
+H3_RE = re.compile(r"^###\s+(.+?)\s*$")
+
+
+def _language(language: str) -> str:
+    return language if language in PLAN_SECTION_HEADINGS else DEFAULT_LANGUAGE
+
+
+def _headings(lines: list[str]) -> tuple[list[str], list[str], list[str]]:
+    h1: list[str] = []
+    h2: list[str] = []
+    h3: list[str] = []
+    for raw in lines:
+        line = raw.strip()
+        match = H3_RE.match(line)
+        if match:
+            h3.append(match.group(1))
+            continue
+        match = H2_RE.match(line)
+        if match:
+            h2.append(match.group(1))
+            continue
+        match = H1_RE.match(line)
+        if match:
+            h1.append(match.group(1))
+    return h1, h2, h3
+
+
+def _section_lines(lines: list[str], heading: str) -> list[str]:
+    body: list[str] = []
+    inside = False
+    for raw in lines:
+        line = raw.strip()
+        match = H2_RE.match(line)
+        if match:
+            inside = match.group(1) == heading
+            continue
+        if inside:
+            body.append(raw)
+    return body
+
+
+def _task_prefix_blocker(heading: str, language: str, prefix: str) -> str | None:
+    lowered = heading.lower()
+    if not (heading.startswith("任务") or lowered.startswith("task")):
+        return None
+    if heading.startswith(prefix):
+        return None
+    return (
+        f"plan task heading '### {heading}' must use the {language} prefix "
+        f"'### {prefix} N：'"
+        if language == "zh-CN"
+        else f"plan task heading '### {heading}' must use the {language} prefix "
+        f"'### {prefix} N:'"
+    )
+
+
+def plan_template_blockers(
+    text: str,
+    language: str,
+    *,
+    dev_type: str | None = None,
+) -> list[str]:
+    """Why a plan does not match the configured-language template shape."""
+    if not text.strip():
+        return ["plan is empty"]
+    resolved = _language(language)
+    expected = PLAN_SECTION_HEADINGS[resolved]
+    other = "en-US" if resolved == "zh-CN" else "zh-CN"
+    other_headings = set(PLAN_SECTION_HEADINGS[other])
+    lines = structural_lines(text)
+    h1, h2, h3 = _headings(lines)
+    blockers: list[str] = []
+
+    marker = PLAN_TITLE_MARKERS[resolved]
+    if not h1:
+        blockers.append(
+            f"plan is missing a top-level title; expected: # <功能> {marker}"
+        )
+    elif marker not in h1[0]:
+        blockers.append(
+            f"plan title must contain '{marker}' for {resolved}; "
+            f"expected: # <功能> {marker}"
+        )
+
+    wrong_language = [heading for heading in h2 if heading in other_headings]
+    if wrong_language:
+        blockers.append(
+            f"plan uses {other} plan headings in a {resolved} project: "
+            + ", ".join(f"## {heading}" for heading in wrong_language)
+            + "; expected: "
+            + ", ".join(f"## {heading}" for heading in expected)
+        )
+    else:
+        missing = [heading for heading in expected if heading not in h2]
+        if missing:
+            blockers.append(
+                f"plan is missing required {resolved} template heading(s): "
+                + ", ".join(f"## {heading}" for heading in missing)
+            )
+        else:
+            positions = [h2.index(heading) for heading in expected]
+            if positions != sorted(positions):
+                blockers.append(
+                    f"plan template headings are out of order; expected: "
+                    + " -> ".join(f"## {heading}" for heading in expected)
+                )
+
+    prefix = PLAN_TASK_PREFIXES[resolved]
+    for heading in h3:
+        blocker = _task_prefix_blocker(heading, resolved, prefix)
+        if blocker is not None:
+            blockers.append(blocker)
+            break
+
+    final_heading = expected[-1]
+    if final_heading in h2:
+        body = _section_lines(lines, final_heading)
+        if not any(
+            spec_check_label(resolved) in line
+            and is_spec_check_result_line(line, resolved)
+            for line in body
+        ):
+            blockers.append(
+                f"plan `## {final_heading}` is missing a filled spec-check "
+                f"result; expected a line starting with '{spec_check_label(resolved)}' "
+                f"and containing 'pass' or 'not_applicable', e.g. "
+                f"{spec_check_example(resolved, dev_type)}"
+            )
+
+    return blockers

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

@@ -7,6 +7,7 @@ import json
 from dataclasses import dataclass
 from pathlib import Path
 
+from infra.config import get_language
 from infra.files import read_text_utf8
 from infra.paths import FILE_TASK_JSON
 from services.context_discovery import (
@@ -34,10 +35,20 @@ from services.context_paths import (
 )
 from services.decision_anchor_schema import (
     REQUIRED_SECTIONS,
+    VERIFICATION,
+    heading_for,
+    headings,
+    is_spec_check_result_line,
     present_sections,
     section_headings,
+    spec_check_example,
+    verification_section_lines,
+)
+from services.plan_binding import (
+    normalize_plan_file,
+    plan_file_blockers,
+    plan_template_blockers,
 )
-from services.plan_binding import normalize_plan_file, plan_file_blockers
 from services.task_gate_profiles import (
     GATE_PROFILE_STRICT,
     acceptance_row_blockers,
@@ -335,6 +346,9 @@ class TaskContextService:
         task_dir = Path(task_dir)
         blockers: list[str] = []
         task_data = self._task_data(task_dir)
+        strict = resolve_gate_profile(task_data) == GATE_PROFILE_STRICT
+        light = self._is_tiny_task(task_data)
+        language = get_language(self.repo_root)
         if not (task_dir / FILE_TASK_JSON).is_file():
             blockers.append("task.json is missing")
         anchor_text = read_text_utf8(task_dir / "decision-anchor.md")
@@ -342,14 +356,27 @@ class TaskContextService:
             blockers.append("decision-anchor.md is missing or empty")
         else:
             blockers.extend(self._decision_anchor_section_blockers(anchor_text))
-            if resolve_gate_profile(task_data) == GATE_PROFILE_STRICT:
+            if strict:
                 blockers.extend(acceptance_row_blockers(anchor_text))
+                if not light:
+                    blockers.extend(
+                        self._anchor_spec_check_blockers(
+                            anchor_text,
+                            language,
+                            task_data.get("dev_type"),
+                        )
+                    )
         for context_file in ("implement.jsonl",):
             if not read_text_utf8(task_dir / context_file):
                 blockers.append(f"{context_file} is missing or empty")
-        if (task_dir / FILE_TASK_JSON).is_file() and not self._is_tiny_task(task_data):
-            blockers.extend(self._plan_file_blockers(task_data))
-        if resolve_gate_profile(task_data) == GATE_PROFILE_STRICT:
+        if (task_dir / FILE_TASK_JSON).is_file() and not light:
+            plan_blockers = self._plan_file_blockers(task_data)
+            blockers.extend(plan_blockers)
+            if strict and not plan_blockers:
+                blockers.extend(
+                    plan_template_blockers(self.repo_root, task_data, language)
+                )
+        if strict:
             blockers.extend(dev_type_blocker(task_data))
         return tuple(blockers)
 
@@ -374,6 +401,45 @@ class TaskContextService:
             if section not in present
         ]
 
+    @staticmethod
+    def _anchor_spec_check_blockers(
+        anchor_text: str,
+        language: str,
+        dev_type: str | None,
+    ) -> list[str]:
+        expected = heading_for(VERIFICATION, language)
+        actual = headings(anchor_text)
+        normalized_dev_type = (
+            dev_type.strip()
+            if isinstance(dev_type, str) and dev_type.strip()
+            else None
+        )
+        example = spec_check_example(language, normalized_dev_type)
+        if expected not in actual:
+            other = heading_for(
+                VERIFICATION,
+                "en-US" if language == "zh-CN" else "zh-CN",
+            )
+            if other in actual:
+                return [
+                    f"decision-anchor.md uses `## {other}`; a strict {language} "
+                    f"task requires `## {expected}` with a filled spec-check "
+                    f"result, e.g. {example}"
+                ]
+            return [
+                f"decision-anchor.md is missing `## {expected}` with a filled "
+                f"spec-check result, e.g. {example}"
+            ]
+        if not any(
+            is_spec_check_result_line(line, language)
+            for line in verification_section_lines(anchor_text)
+        ):
+            return [
+                f"decision-anchor.md `## {expected}` is missing a filled "
+                f"spec-check result, e.g. {example}"
+            ]
+        return []
+
     @staticmethod
     def _is_tiny_task(task_data: dict) -> bool:
         """Field-level reading only: the plan-file waiver also covers

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

@@ -12,7 +12,9 @@ from infra.config import get_language
 from services.decision_anchor_schema import (
     ACCEPTANCE,
     GOAL,
+    VERIFICATION,
     heading_for,
+    spec_check_placeholder,
 )
 from services.task_tree import TaskTreeError, TaskTreeService
 from services import task_graph
@@ -165,6 +167,7 @@ class TaskCreationService:
             generated_anchor, generated_anchor_from_plan = self._generate_anchor(
                 task_dir,
                 bound_plan_path,
+                request.dev_type,
             )
             if generated_anchor:
                 created_files.append(task_dir / "decision-anchor.md")
@@ -361,6 +364,7 @@ class TaskCreationService:
         self,
         task_dir: Path,
         plan_path: Path | None,
+        dev_type: str | None = None,
     ) -> tuple[bool, bool]:
         """Create a language-specific anchor scaffold.
 
@@ -387,12 +391,25 @@ class TaskCreationService:
         language = get_language(self.repo_root)
         goal_heading = heading_for(GOAL, language)
         acceptance_heading = heading_for(ACCEPTANCE, language)
+        verification_heading = heading_for(VERIFICATION, language)
         goal_body = goal or _anchor_placeholder(GOAL, language)
         acceptance_body = _anchor_placeholder(ACCEPTANCE, language)
+        verification_comment = (
+            "<!-- strict 任务启动前：把 <dev_type> 和 "
+            "<pass / not_applicable + 理由> 替换为实际核对结果；"
+            "保留模板占位符会被启动门禁阻断。 -->"
+            if language == "zh-CN"
+            else "<!-- Before a strict task starts: replace <dev_type> and "
+            "<pass / not_applicable + reason> with the actual result; "
+            "the start gate rejects the template placeholder. -->"
+        )
+        verification_body = spec_check_placeholder(language, dev_type)
         try:
             anchor_file.write_text(
                 f"## {goal_heading}\n\n{goal_body}\n\n"
-                f"## {acceptance_heading}\n\n{acceptance_body}\n",
+                f"## {acceptance_heading}\n\n{acceptance_body}\n\n"
+                f"## {verification_heading}\n\n{verification_comment}\n"
+                f"{verification_body}\n",
                 encoding="utf-8",
             )
         except OSError as error:

package/template/.cowork-flow/spec/contracts/decision-anchor.md

@@ -49,7 +49,7 @@ and the right column the `en-US` output.
 | `## 被拒方案` / `## Rejected Options` | optional | required for brainstorming tasks, so a rejected option is not reconsidered during execution |
 | `## 关键假设` / `## Key Assumptions` | optional | filled in for complex tasks to surface implicit constraints; not read by the runtime parser |
 | `## 范围边界` / `## Scope Boundary` | optional | prevents scope creep |
-| `## 验证命令` / `## Verification Commands` | optional | filled in for complex tasks, as the basis for automated verification; when the changed files are covered by `.cowork-flow/spec/backend/` or `frontend/` rules, it must also carry the spec/gate check for the task's `dev_type` (deciding command, or clause-by-clause `pass` / `not_applicable` with reason) |
+| `## 验证命令` / `## Verification Commands` | required for strict non-Tiny; optional for legacy/Tiny | filled in for complex tasks, as the basis for automated verification; a strict non-Tiny task also needs the configured-language section and a filled spec/gate check for the task's `dev_type` (deciding command, or clause-by-clause `pass` / `not_applicable` with reason) |
 
 ### Machine-readable line formats (for injection)
 
@@ -59,11 +59,13 @@ fact view (`services/fact_view.parse_decision_anchor`). Line-format conventions:
 - `## 验证命令`: one command per line (an optional `- ` prefix), truncated to 120
   characters, at most 10 lines; the implementing agent runs them itself
   (self-declared, self-checked) and the reviewer verifies the execution evidence.
-  When the changed files are covered by `.cowork-flow/spec/<dev_type>/` rules, the
-  section must also carry the spec/gate check for the task's `dev_type`: a deciding
-  command, or a `规范核对:` line reviewed clause by clause (`pass` /
-  `not_applicable` + reason). This is a strong review reminder, not a `spec-check`
-  hard gate.
+  A strict non-Tiny task must also carry a `规范核对：` line in the configured
+  language's section, with the actual `pass` / `not_applicable` result and a
+  reason. The template placeholder (`<pass / not_applicable + 理由>`) does not
+  satisfy the start gate. This line is a hard start gate for strict non-Tiny
+  tasks, while its content remains self-declared and is reviewed by the check
+  agent. The fact view recognizes the line and does not return it as a shell
+  command.
 - `## 范围边界`: only the first non-empty line is taken, truncated to 160
   characters.
 
@@ -98,6 +100,13 @@ After merging (5 files): `decision-anchor.md` + `implement.jsonl` + `check.jsonl
   `## Acceptance Criteria`, no duplicate AC ids, no non-AC list rows in that
   section, and a declared `dev_type` (otherwise `task specs` dev-type dispatch
   silently comes back shorter).
+- A strict non-Tiny task also requires the configured-language
+  `## 验证命令` / `## Verification Commands` section with a filled
+  `规范核对：` / `Spec check:` line. A missing section, the other-language
+  heading, or the template placeholder blocks start. Tiny tasks and legacy tasks
+  are exempt. The bound plan's `## 最终验证` / `## Final Verification` section
+  carries the same filled check; plan structure and language are covered by
+  `plan-binding.md`.
 - An acceptance row's checkbox state (`- [ ]` / `- [x]`) and the evidence records
   (the task directory's `evidence.jsonl`) are the fact source of the completion
   gate: completion is blocked when an unchecked AC exists (`LIFECYCLE-AC-001`), a

package/template/.cowork-flow/spec/contracts/plan-binding.md

@@ -51,9 +51,29 @@ into `in_progress`:
 - `decision-anchor.md` contains `## Goal`/`## 目标` and
   `## Acceptance Criteria`/`## 验收标准`.
 - `implement.jsonl` passes the existing context validation.
-
-A Tiny task may have no planFile, but must still satisfy the existing anchor and
-implement-scope requirements.
+- For a strict non-Tiny task, the plan title contains the configured-language
+  marker (`实施计划` / `Implementation Plan`).
+- The plan contains the six configured-language `##` template headings in
+  template order: `目标` / `验收标准` / `全局约束` / `文件边界` / `任务` /
+  `最终验证`, or their `en-US` equivalents. Extra custom sections are allowed;
+  fenced code is ignored; a known template heading from the other language is
+  rejected.
+- Any `### 任务` / `### Task` task heading uses the configured-language prefix.
+- `## 最终验证` / `## Final Verification` contains a line starting with
+  `规范核对：` / `Spec check:` and carrying an actual `pass` or
+  `not_applicable` result. The template placeholder (`<pass / not_applicable +
+  理由>` / `<pass / not_applicable + reason>`) does not satisfy the gate.
+- The strict non-Tiny anchor carries the configured-language `## 验证命令` /
+  `## Verification Commands` section with the same filled spec-check result;
+  see `decision-anchor.md`.
+
+Creation and `--from-plan` binding stay permissive: a planning task may create
+and bind a plan before its structure is final. These checks run only at the
+planning → `in_progress` start gate.
+
+A Tiny task may have no planFile and is exempt from the plan-shape and anchor
+spec-check gates. A legacy task (no `meta.gateProfile: "strict"`) keeps the
+historical checks; this contract does not retro-fit either profile.
 
 ## Implementation recovery
 
@@ -79,6 +99,8 @@ The recovery output lists paths only and never expands the plan prose.
 - No Markdown AST or DSL.
 - No comparing AC text against plan task prose.
 - No matching verification commands against evidence records.
+- No semantic validation of the spec-check result or reason; the structural
+  check only requires an actual `pass` / `not_applicable` token.
 - No plan-approval data model.
 
 These capabilities are considered only after warning noise and real payoff have been

package/template/.cowork-flow/spec/runtime/contract-registry.json

@@ -108,6 +108,7 @@
       "digest": [
         "Plan binding records repo-relative task.json.meta.planFile.",
         "Task start blocks clear missing plan facts for non-Tiny tasks.",
+        "Strict non-Tiny start requires the configured-language plan template shape and a filled spec-check line.",
         "V1 does not parse plan steps, AC text, or verification evidence."
       ],
       "readWhen": [

package/template/.cowork-flow/templates/plan-template.md

@@ -71,7 +71,7 @@ Tiny 任务可保留简化 brief，但仍须写明精确文件边界、完成条
 <command>
 ```
 
-当改动文件受 `.cowork-flow/spec/<dev_type>/` 规则覆盖时，在这里加入决定命令或规范门禁核对行（`pass` / `not_applicable` 并附理由）；这是强复核提醒，不是硬门禁。
+当改动文件受 `.cowork-flow/spec/<dev_type>/` 规则覆盖时，在这里加入决定命令或规范门禁核对行（`pass` / `not_applicable` 并附理由）。strict 非 Tiny 任务启动前必须把 `<pass / not_applicable + 理由>` 替换为实际核对结果；保留模板占位符会被 start 门禁阻断。
 
 **完成条件**
 - <2-4 条可检查条件>

package/template/locales/en-US/.cowork-flow/spec/contracts/decision-anchor.md

@@ -49,7 +49,7 @@ and the left column the `zh-CN` output.
 | `## Rejected Options` / `## 被拒方案` | optional | required for brainstorming tasks, so a rejected option is not reconsidered during execution |
 | `## Key Assumptions` / `## 关键假设` | optional | filled in for complex tasks to surface implicit constraints; not read by the runtime parser |
 | `## Scope Boundary` / `## 范围边界` | optional | prevents scope creep |
-| `## Verification Commands` / `## 验证命令` | optional | filled in for complex tasks, as the basis for automated verification; when the changed files are covered by `.cowork-flow/spec/backend/` or `frontend/` rules, it must also carry the spec/gate check for the task's `dev_type` (deciding command, or clause-by-clause `pass` / `not_applicable` with reason) |
+| `## Verification Commands` / `## 验证命令` | required for strict non-Tiny; optional for legacy/Tiny | filled in for complex tasks, as the basis for automated verification; a strict non-Tiny task also needs the configured-language section and a filled spec/gate check for the task's `dev_type` (deciding command, or clause-by-clause `pass` / `not_applicable` with reason) |
 
 ### Machine-readable line formats (for injection)
 
@@ -60,11 +60,13 @@ Line-format conventions:
 - `## Verification Commands`: one command per line (an optional `- ` prefix),
   truncated to 120 characters, at most 10 lines; the implementing agent runs them
   itself (self-declared, self-checked) and the reviewer verifies the execution
-  evidence. When the changed files are covered by `.cowork-flow/spec/<dev_type>/`
-  rules, the section must also carry the spec/gate check for the task's
-  `dev_type`: a deciding command, or a `Spec check:` line reviewed clause by
-  clause (`pass` / `not_applicable` + reason). This is a strong review reminder,
-  not a `spec-check` hard gate.
+  evidence. A strict non-Tiny task must also carry a `Spec check:` line in the
+  configured language's section, with the actual `pass` / `not_applicable` result
+  and a reason. The template placeholder (`<pass / not_applicable + reason>`) does
+  not satisfy the start gate. This line is a hard start gate for strict non-Tiny
+  tasks, while its content remains self-declared and is reviewed by the check
+  agent. The fact view recognizes the line and does not return it as a shell
+  command.
 - `## Scope Boundary`: only the first non-empty line is taken, truncated to 160
   characters.
 
@@ -99,6 +101,13 @@ After merging (5 files): `decision-anchor.md` + `implement.jsonl` + `check.jsonl
   `## 验收标准`, no duplicate AC ids, no non-AC list rows in that section, and a
   declared `dev_type` (otherwise `task specs` dev-type dispatch silently comes
   back shorter).
+- A strict non-Tiny task also requires the configured-language
+  `## Verification Commands` / `## 验证命令` section with a filled
+  `Spec check:` / `规范核对：` line. A missing section, the other-language
+  heading, or the template placeholder blocks start. Tiny tasks and legacy tasks
+  are exempt. The bound plan's `## Final Verification` / `## 最终验证` section
+  carries the same filled check; plan structure and language are covered by
+  `plan-binding.md`.
 - An acceptance row's checkbox state (`- [ ]` / `- [x]`) and the evidence records
   (the task directory's `evidence.jsonl`) are the fact source of the completion
   gate: completion is blocked when an unchecked AC exists (`LIFECYCLE-AC-001`), a

package/template/locales/en-US/.cowork-flow/templates/plan-template.md

@@ -71,7 +71,7 @@ Tiny plans may keep a shorter brief, but must still name exact file boundaries,
 <command>
 ```
 
-When changed files are covered by `.cowork-flow/spec/<dev_type>/` rules, add the deciding command or a spec/gate check line (`pass` / `not_applicable` with reason) here; it is a strong review reminder, not a hard gate.
+When changed files are covered by `.cowork-flow/spec/<dev_type>/` rules, add the deciding command or a spec/gate check line (`pass` / `not_applicable` with reason) here. Before a strict non-Tiny task starts, replace `<pass / not_applicable + reason>` with the actual result; the start gate rejects the template placeholder.
 
 **Completion Conditions**
 - <2-4 checkable conditions>

package/template/skills/task-planning/SKILL.md

@@ -49,7 +49,7 @@ Fill the template in order: header table and goal first, then acceptance criteri
 - Every Normal or High-risk task fills every required field in the template's task brief: Purpose, Code Fact Sources, File Boundaries, Key Symbols, Implementation Notes, Test Proof, Verification Command, Completion Conditions, Prohibited Drift, and Deviation Conditions.
 - For Tiny tasks, keep the brief short but still name exact file boundaries, completion conditions, and verification commands.
 - For behavior changes, include a failing test before implementation when behavior can be tested.
-- For implementation tasks whose changed files are covered by `.cowork-flow/spec/` requirements, name the covered spec files in the plan and add the clause check to the task's `Verification Command` and the plan's `Final Verification`: run the deciding command when one exists, otherwise check clause by clause and record `pass` / `not_applicable` with reason. This is a strong review reminder, not a separate hard gate.
+- For implementation tasks whose changed files are covered by `.cowork-flow/spec/` requirements, name the covered spec files in the plan and add the clause check to the task's `Verification Command` and the plan's `Final Verification`: run the deciding command when one exists, otherwise check clause by clause and record `pass` / `not_applicable` with reason. For strict non-Tiny tasks this is a hard start gate: the bound plan and the task anchor must use the configured-language verification heading and carry a filled spec-check result. The template placeholder `<pass / not_applicable + reason>` blocks start; replace it before starting. The content remains self-declared and is reviewed by the check agent.
 - Do not add shallow tests just to satisfy process. Avoid tests that only assert existence, mirror implementation details, count mock calls without behavior, or snapshot empty structure.
 - For complex problems, test depth first: business invariants, cross-layer contracts, state transitions, error boundaries, and real regression paths before narrow unit cases.
 - Map behavior-changing tests to stable `decision-anchor.md` acceptance IDs when useful; do not create `tdd.jsonl` or write TDD evidence records into `check.jsonl`.
@@ -81,7 +81,7 @@ A plan can be marked approved only when all conditions hold:
 - Every task in the plan has clear acceptance criteria.
 - Every task has implementation steps and verification commands.
 - Task dependencies are explicit, including whether work is serial or parallelizable.
-- The plan uses the installed `.cowork-flow/templates/plan-template.md` shape and the configured output language.
+- The plan uses the installed `.cowork-flow/templates/plan-template.md` shape and the configured output language. For strict non-Tiny tasks, the runtime blocks start when the plan or anchor lacks the configured-language verification section or a filled spec-check result.
 
 `implement.jsonl` is the current task's context index — the files in scope and
 the spec pointers it needs — not the task list. The plan owns the task list.
@@ -118,5 +118,5 @@ Before handoff:
 3. Confirm every Normal or High-risk task fills every required brief field in the template.
 4. Check names, paths, command syntax, and expected outputs.
 5. Confirm the plan says to stop and report back when code facts conflict with the plan, a plan-external file becomes necessary, or a test fails for an unplanned reason.
-6. Confirm Final Verification carries the applicable `.cowork-flow/spec/<dev_type>/` clause check, or states why no spec file applies.
+6. Confirm Final Verification carries the applicable `.cowork-flow/spec/<dev_type>/` clause check with an actual `pass` / `not_applicable` result, or states why no spec file applies. For strict non-Tiny tasks the runtime blocks start when this line is missing or still the template placeholder.
 7. Confirm the plan is written in the configured language and keeps the machine-readable goal line and `AC-NNN` identifiers unchanged.