cowork-flow 2.4.0 → 2.4.2

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

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Template-driven plan skeleton generation."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+from pathlib import Path
+
+from infra.paths import DIR_WORKFLOW
+
+
+PLAN_TEMPLATE_PATH = f"{DIR_WORKFLOW}/templates/plan-template.md"
+PLAN_DIRECTORY = f"{DIR_WORKFLOW}/plans"
+SLUG_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
+H1_RE = re.compile(r"^#(?!#)\s+(.+?)\s*$")
+
+
+class PlanScaffoldError(RuntimeError):
+    """Raised when a plan skeleton cannot be generated."""
+
+    def __init__(self, code: str, path: Path, detail: str) -> None:
+        self.code = code
+        self.path = path
+        self.detail = detail
+        super().__init__(f"{code}: {detail}: {path}")
+
+
+class PlanScaffoldService:
+    """Create a plan file from the installed, localized plan template."""
+
+    def __init__(self, repo_root: Path) -> None:
+        self.repo_root = Path(repo_root)
+
+    def create(
+        self,
+        title: str,
+        slug: str,
+        *,
+        force: bool = False,
+        date_prefix: str | None = None,
+    ) -> Path:
+        normalized_title = title.strip()
+        normalized_slug = slug.strip()
+        if not normalized_title:
+            raise PlanScaffoldError(
+                "PLAN-NEW-TITLE-001",
+                self.repo_root,
+                "plan title is required",
+            )
+        if not SLUG_RE.match(normalized_slug):
+            raise PlanScaffoldError(
+                "PLAN-NEW-SLUG-001",
+                self.repo_root,
+                "plan slug must contain lowercase ASCII letters, digits, and hyphens",
+            )
+
+        template = self.repo_root / PLAN_TEMPLATE_PATH
+        if not template.is_file():
+            raise PlanScaffoldError(
+                "PLAN-NEW-TEMPLATE-001",
+                template,
+                "installed plan template is missing; run `cwf project sync .`",
+            )
+
+        plans_dir = self.repo_root / PLAN_DIRECTORY
+        day = date_prefix or datetime.now().strftime("%Y-%m-%d")
+        if not re.fullmatch(r"\d{4}-\d{2}-\d{2}", day):
+            raise PlanScaffoldError(
+                "PLAN-NEW-DATE-001",
+                plans_dir,
+                "plan date must use YYYY-MM-DD",
+            )
+        plan_path = plans_dir / f"{day}-{normalized_slug}.md"
+        if plan_path.exists() and not force:
+            raise PlanScaffoldError(
+                "PLAN-NEW-EXISTS-001",
+                plan_path,
+                "plan already exists; pass --force to overwrite",
+            )
+
+        try:
+            text = template.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as error:
+            raise PlanScaffoldError(
+                "PLAN-NEW-TEMPLATE-002",
+                template,
+                "installed plan template cannot be read as UTF-8",
+            ) from error
+
+        rendered = self._render_title(text, normalized_title, template)
+        try:
+            plans_dir.mkdir(parents=True, exist_ok=True)
+            with plan_path.open("w", encoding="utf-8", newline="\n") as handle:
+                handle.write(rendered)
+        except OSError as error:
+            raise PlanScaffoldError(
+                "PLAN-NEW-WRITE-001",
+                plan_path,
+                "plan file could not be written",
+            ) from error
+        return plan_path
+
+    @staticmethod
+    def _render_title(text: str, title: str, template: Path) -> str:
+        lines = text.splitlines()
+        for index, line in enumerate(lines):
+            match = H1_RE.match(line.strip())
+            if match is None:
+                continue
+            heading = match.group(1)
+            if "<功能>" in heading:
+                if title.endswith("实施计划"):
+                    lines[index] = f"# {title}"
+                else:
+                    lines[index] = f"# {heading.replace('<功能>', title)}"
+                return "\n".join(lines) + "\n"
+            if "<Feature>" in heading:
+                if title.endswith("Implementation Plan"):
+                    lines[index] = f"# {title}"
+                else:
+                    lines[index] = f"# {heading.replace('<Feature>', title)}"
+                return "\n".join(lines) + "\n"
+            raise PlanScaffoldError(
+                "PLAN-NEW-TITLE-002",
+                template,
+                "plan template title is missing the <功能>/<Feature> placeholder",
+            )
+        raise PlanScaffoldError(
+            "PLAN-NEW-TITLE-003",
+            template,
+            "plan template has no top-level title",
+        )

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

@@ -0,0 +1,222 @@
+#!/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*$")
+
+GOAL_LINE_RE = re.compile(r"^\*\*(?:Goal|目标):\*\*\s*(.+?)\s*$")
+GOAL_BOLD_COLON_RE = re.compile(r"^\*\*(?:Goal|目标)\*\*:\s*(.+?)\s*$")
+GOAL_TABLE_RE = re.compile(
+    r"^\|\s*\*\*(?:Goal|目标)\*\*\s*\|\s*(.+?)\s*\|\s*$"
+)
+PLAN_AC_RE = re.compile(
+    r"^\s*-\s*(?:\[[ xX]\]\s*)?(AC-\d{3})\s*[:：]\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_goal(text: str) -> str | None:
+    """First machine-readable plan goal line, then the legacy table row."""
+    for raw in structural_lines(text):
+        line = raw.strip()
+        for pattern in (GOAL_LINE_RE, GOAL_BOLD_COLON_RE, GOAL_TABLE_RE):
+            match = pattern.match(line)
+            if match:
+                return match.group(1).strip()
+    return None
+
+
+def plan_acceptance_criteria(
+    text: str,
+    language: str,
+) -> list[dict[str, str]]:
+    """Acceptance rows declared by the plan, in document order."""
+    resolved = _language(language)
+    heading = PLAN_SECTION_HEADINGS[resolved][1]
+    rows: list[dict[str, str]] = []
+    for raw in _section_lines(structural_lines(text), heading):
+        match = PLAN_AC_RE.match(raw)
+        if match:
+            rows.append({"id": match.group(1), "text": match.group(2).strip()})
+    return rows
+
+
+def section_body(text: str, heading: str) -> list[str]:
+    """Raw lines under one `##` heading, excluding fenced code."""
+    return _section_lines(structural_lines(text), heading)
+
+
+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,21 @@ 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
+from services.plan_binding import (
+    normalize_plan_file,
+    plan_file_blockers,
+    plan_template_blockers,
+)
+from services.plan_readiness import plan_ready_snapshot_blockers
 from services.task_gate_profiles import (
     GATE_PROFILE_STRICT,
     acceptance_row_blockers,
@@ -335,6 +347,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 +357,38 @@ 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 and not light:
+            meta = task_data.get("meta")
+            meta = meta if isinstance(meta, dict) else {}
+            blockers.extend(
+                plan_ready_snapshot_blockers(
+                    self.repo_root,
+                    task_dir,
+                    task_data,
+                    required=meta.get("planReadyRequired") is True,
+                )
+            )
+        if strict:
             blockers.extend(dev_type_blocker(task_data))
         return tuple(blockers)
 
@@ -374,6 +413,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

@@ -6,14 +6,16 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-import re
 
 from infra.config import get_language
 from services.decision_anchor_schema import (
     ACCEPTANCE,
     GOAL,
+    VERIFICATION,
     heading_for,
+    spec_check_placeholder,
 )
+from services.plan_schema import plan_acceptance_criteria, plan_goal
 from services.task_tree import TaskTreeError, TaskTreeService
 from services import task_graph
 from infra.paths import (
@@ -22,16 +24,10 @@ from infra.paths import (
     get_tasks_dir,
 )
 from services.plan_binding import PlanBindingError, bind_plan_file
-from services.task_gate_profiles import GATE_PROFILE_STRICT
+from services.task_gate_profiles import GATE_PROFILE_STRICT, LIGHT_TASK_TYPE
 from services.task_repository import TaskRepository, TaskRepositoryError
 
 
-_GOAL_LINE_RE = re.compile(r"^\*\*(?:Goal|目标):\*\*\s*(.+?)\s*$")
-_GOAL_BOLD_COLON_RE = re.compile(r"^\*\*(?:Goal|目标)\*\*:\s*(.+?)\s*$")
-_GOAL_TABLE_RE = re.compile(
-    r"^\|\s*\*\*(?:Goal|目标)\*\*\s*\|\s*(.+?)\s*\|\s*$"
-)
-
 _ANCHOR_PLACEHOLDERS = {
     ("zh-CN", GOAL): "<!-- 用一句话描述可观察的目标。 -->",
     ("zh-CN", ACCEPTANCE): "<!-- 至少一条，例如：- [ ] AC-001: ... -->",
@@ -90,17 +86,6 @@ class TaskCreationResult:
     generated_anchor_from_plan: bool
 
 
-def _extract_plan_goal(plan_text: str) -> str | None:
-    """First machine-readable goal line, then the legacy table row."""
-    for raw in plan_text.splitlines():
-        line = raw.strip()
-        for pattern in (_GOAL_LINE_RE, _GOAL_BOLD_COLON_RE, _GOAL_TABLE_RE):
-            match = pattern.match(line)
-            if match:
-                return match.group(1).strip()
-    return None
-
-
 def _anchor_placeholder(section: str, language: str) -> str:
     return _ANCHOR_PLACEHOLDERS.get(
         (language, section),
@@ -108,6 +93,12 @@ def _anchor_placeholder(section: str, language: str) -> str:
     )
 
 
+def _render_acceptance(rows: list[dict[str, str]]) -> str:
+    return "\n".join(
+        f"- [ ] {row['id']}: {row['text']}" for row in rows
+    )
+
+
 def ensure_tasks_dir(repo_root: Path) -> Path:
     """Ensure active and archived task directories exist."""
     tasks_dir = get_tasks_dir(repo_root)
@@ -165,6 +156,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")
@@ -189,6 +181,10 @@ class TaskCreationService:
         created_at = request.created_at or datetime.now().strftime("%Y-%m-%d")
         meta = dict(plan_metadata) if isinstance(plan_metadata, dict) else {}
         meta.setdefault("gateProfile", GATE_PROFILE_STRICT)
+        if meta.get("gateProfile") == GATE_PROFILE_STRICT and (
+            request.task_type != LIGHT_TASK_TYPE
+        ):
+            meta["planReadyRequired"] = True
         # The light profile is declarable at creation only: this is the sole
         # write of the field, and no lifecycle command changes it later.
         if request.task_type:
@@ -361,18 +357,21 @@ class TaskCreationService:
         self,
         task_dir: Path,
         plan_path: Path | None,
+        dev_type: str | None = None,
     ) -> tuple[bool, bool]:
         """Create a language-specific anchor scaffold.
 
-        A bound plan's goal line (or legacy table row) fills the goal section;
-        otherwise the scaffold carries a localized placeholder. An anchor that
+        A bound plan's goal and AC rows fill the corresponding sections;
+        otherwise each section carries a localized placeholder. An anchor that
         already exists is never overwritten.
         """
         anchor_file = task_dir / "decision-anchor.md"
         if anchor_file.exists():
             return False, False
 
+        language = get_language(self.repo_root)
         goal: str | None = None
+        acceptance_rows: list[dict[str, str]] = []
         if plan_path is not None and plan_path.is_file():
             try:
                 plan_text = plan_path.read_text(encoding="utf-8")
@@ -382,17 +381,34 @@ class TaskCreationService:
                     plan_path,
                     "plan cannot be read as UTF-8",
                 ) from error
-            goal = _extract_plan_goal(plan_text)
+            goal = plan_goal(plan_text)
+            acceptance_rows = plan_acceptance_criteria(plan_text, language)
 
-        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)
+        acceptance_body = (
+            _render_acceptance(acceptance_rows)
+            if acceptance_rows
+            else _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