cowork-flow 2.3.0 → 2.4.1

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

@@ -17,23 +17,31 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
+from services.decision_anchor_schema import (
+    ACCEPTANCE,
+    ACCEPTANCE_RE,
+    GOAL,
+    HEADING_RE,
+    REJECTED,
+    SCOPE,
+    VERIFICATION,
+    canonical_section,
+    is_spec_check_line,
+)
+
 GOAL_TRUNCATE = 300
 VERIFY_COMMAND_TRUNCATE = 120
 VERIFY_COMMAND_MAX = 10
 SCOPE_BOUNDARY_TRUNCATE = 160
-ANCHOR_SECTIONS = ("目标", "验收标准", "被拒方案", "验证命令", "范围边界")
-ACCEPTANCE_RE = re.compile(
-    r"^\s*-\s*(?:\[([ xX])\]?\s*)?(AC-[A-Za-z0-9-]+)\s*[:：]\s*(.+?)\s*$"
-)
 REJECTED_RE = re.compile(r"^\s*-\s*\*\*(.+?)\*\*")
-_HEADING_RE = re.compile(r"^##\s*(.+?)\s*$")
 
 
 def parse_decision_anchor(text: str) -> dict[str, Any]:
     """Extract goal / acceptance criteria / rejected option names / declared
     verification commands / scope boundary from a decision-anchor.md body.
-    Section format is frozen by spec/contracts/decision-anchor.md; parsing is
-    line-level and degrades to empty values when sections are missing."""
+    Section headings may be the Chinese set or the English aliases (see
+    spec/contracts/decision-anchor.md); parsing is line-level and degrades to
+    empty values when sections are missing."""
     goal_lines: list[str] = []
     acceptance: list[dict[str, str]] = []
     rejected: list[str] = []
@@ -41,15 +49,14 @@ def parse_decision_anchor(text: str) -> dict[str, Any]:
     scope_boundary = ""
     section: str | None = None
     for raw in text.splitlines():
-        heading = _HEADING_RE.match(raw.strip())
+        heading = HEADING_RE.match(raw.strip())
         if heading:
-            name = heading.group(1)
-            section = name if name in ANCHOR_SECTIONS else None
+            section = canonical_section(heading.group(1))
             continue
-        if section == "目标":
+        if section == GOAL:
             if raw.strip():
                 goal_lines.append(raw.strip())
-        elif section == "验收标准":
+        elif section == ACCEPTANCE:
             match = ACCEPTANCE_RE.match(raw)
             if match:
                 acceptance.append(
@@ -59,17 +66,22 @@ def parse_decision_anchor(text: str) -> dict[str, Any]:
                         "checked": match.group(1) in ("x", "X"),
                     }
                 )
-        elif section == "被拒方案":
+        elif section == REJECTED:
             match = REJECTED_RE.match(raw)
             if match:
                 rejected.append(match.group(1).strip())
-        elif section == "验证命令":
+        elif section == VERIFICATION:
             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 == "范围边界":
+        elif section == SCOPE:
             if raw.strip() and not scope_boundary:
                 scope_boundary = raw.strip()[:SCOPE_BOUNDARY_TRUNCATE]
     return {

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 (
@@ -32,7 +33,22 @@ from services.context_paths import (
     normalize_context_path,
     prepare_context_entry,
 )
-from services.plan_binding import normalize_plan_file, plan_file_blockers
+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.task_gate_profiles import (
     GATE_PROFILE_STRICT,
     acceptance_row_blockers,
@@ -330,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")
@@ -337,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)
 
@@ -360,13 +392,53 @@ class TaskContextService:
 
     @staticmethod
     def _decision_anchor_section_blockers(anchor_text: str) -> list[str]:
-        blockers: list[str] = []
-        for section in ("## 目标", "## 验收标准"):
-            if section not in anchor_text:
-                blockers.append(
-                    f"decision-anchor.md missing required section: {section}"
-                )
-        return blockers
+        present = present_sections(anchor_text)
+        return [
+            "decision-anchor.md missing required section: "
+            + " (or ".join(f"## {heading}" for heading in section_headings(section))
+            + ")"
+            for section in REQUIRED_SECTIONS
+            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:

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

@@ -6,7 +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.task_tree import TaskTreeError, TaskTreeService
 from services import task_graph
 from infra.paths import (
@@ -19,6 +28,20 @@ from services.task_gate_profiles import GATE_PROFILE_STRICT
 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: ... -->",
+    ("en-US", GOAL): "<!-- One sentence describing the observable outcome. -->",
+    ("en-US", ACCEPTANCE): "<!-- At least one, e.g. - [ ] AC-001: ... -->",
+}
+
+
 class TaskCreationError(RuntimeError):
     """Raised when task creation cannot be completed."""
 
@@ -66,6 +89,25 @@ class TaskCreationResult:
     linked_parent: str | None
     missing_parent: str | None
     generated_anchor: bool
+    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),
+        _ANCHOR_PLACEHOLDERS[("zh-CN", section)],
+    )
 
 
 def ensure_tasks_dir(repo_root: Path) -> Path:
@@ -122,9 +164,10 @@ class TaskCreationService:
             created_files.append(task_dir / FILE_TASK_JSON)
 
             linked_parent, missing_parent = self._link_parent(request, task_dir)
-            generated_anchor = self._generate_anchor(
+            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")
@@ -136,6 +179,7 @@ class TaskCreationService:
             linked_parent=linked_parent,
             missing_parent=missing_parent,
             generated_anchor=generated_anchor,
+            generated_anchor_from_plan=generated_anchor_from_plan,
         )
 
     def _task_data(
@@ -316,41 +360,56 @@ class TaskCreationService:
             "plan file must live under .cowork-flow/plans",
         )
 
-    @staticmethod
     def _generate_anchor(
+        self,
         task_dir: Path,
         plan_path: Path | None,
-    ) -> bool:
-        if plan_path is None:
-            return False
-        if not plan_path.is_file():
-            return False
+        dev_type: str | None = None,
+    ) -> tuple[bool, bool]:
+        """Create a language-specific anchor scaffold.
 
-        try:
-            plan_text = plan_path.read_text(encoding="utf-8")
-        except (OSError, UnicodeDecodeError) as error:
-            raise TaskCreationError(
-                "TASK-CREATE-PLAN-001",
-                plan_path,
-                "plan cannot be read as UTF-8",
-            ) from error
+        A bound plan's goal line (or legacy table row) fills the goal section;
+        otherwise the scaffold 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
 
-        goal = next(
-            (
-                line.split(":", 1)[1].strip()
-                for line in plan_text.splitlines()
-                if line.startswith("**Goal:**")
-                or line.startswith("**目标:**")
-            ),
-            None,
+        goal: str | None = None
+        if plan_path is not None and plan_path.is_file():
+            try:
+                plan_text = plan_path.read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError) as error:
+                raise TaskCreationError(
+                    "TASK-CREATE-PLAN-001",
+                    plan_path,
+                    "plan cannot be read as UTF-8",
+                ) from error
+            goal = _extract_plan_goal(plan_text)
+
+        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. -->"
         )
-        anchor_file = task_dir / "decision-anchor.md"
-        if not goal or anchor_file.exists():
-            return False
+        verification_body = spec_check_placeholder(language, dev_type)
         try:
             anchor_file.write_text(
-                f"## 目标\n\n{goal}\n\n## 验收标准\n"
-                "<!-- 至少一条，例如：- [ ] AC-001: ... -->\n",
+                f"## {goal_heading}\n\n{goal_body}\n\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:
@@ -363,7 +422,7 @@ class TaskCreationService:
                 anchor_file,
                 "decision anchor could not be written",
             ) from error
-        return True
+        return True, goal is not None
 
 
 def _validate_dev_type(dev_type: str | None, path: Path) -> None:

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

@@ -4,7 +4,7 @@ A task created today carries `meta.gateProfile = "strict"`; a task without the
 marker keeps the historical gate (legacy), so nothing that already exists is
 retroactively re-gated.
 
-The strict gate exists because the old one only checked that the `## 验收标准`
+The strict gate exists because the old one only checked that the acceptance
 heading was present. An anchor with an empty acceptance section passed, the
 acceptance/evidence gates then found no AC rows to check, and the whole chain
 silently did nothing.
@@ -12,20 +12,17 @@ silently did nothing.
 
 from __future__ import annotations
 
-import re
-
-from services.fact_view import ACCEPTANCE_RE
+from services.decision_anchor_schema import (
+    ACCEPTANCE_RE,
+    LIST_ITEM_RE,
+    acceptance_section_lines,
+)
 
 GATE_PROFILE_STRICT = "strict"
 GATE_PROFILE_LEGACY = "legacy"
 
 LIGHT_TASK_TYPE = "tiny"
 
-ACCEPTANCE_HEADING = "验收标准"
-
-_HEADING_RE = re.compile(r"^##\s*(.+?)\s*$")
-_LIST_ITEM_RE = re.compile(r"^\s*[-*]\s")
-
 
 def resolve_gate_profile(task_data: dict) -> str:
     """The gate a task is held to; an unmarked task is legacy."""
@@ -72,20 +69,6 @@ def is_light_task(task_data: dict) -> bool:
     return declares_light_profile(task_data)
 
 
-def acceptance_section_lines(anchor_text: str) -> list[str]:
-    """Raw lines under `## 验收标准`, up to the next heading."""
-    lines: list[str] = []
-    inside = False
-    for raw in anchor_text.splitlines():
-        heading = _HEADING_RE.match(raw.strip())
-        if heading:
-            inside = heading.group(1) == ACCEPTANCE_HEADING
-            continue
-        if inside:
-            lines.append(raw)
-    return lines
-
-
 def acceptance_row_blockers(anchor_text: str) -> list[str]:
     """Why the acceptance section cannot start a strict task.
 
@@ -101,7 +84,7 @@ def acceptance_row_blockers(anchor_text: str) -> list[str]:
         if match:
             ids.append(match.group(2))
             continue
-        if _LIST_ITEM_RE.match(raw):
+        if LIST_ITEM_RE.match(raw):
             malformed.append(raw.strip()[:80])
     blockers: list[str] = []
     if not ids: