chore: update project version to 0.8.3

Author: Akagi201

.rumdl.toml

@@ -25,6 +25,7 @@ exclude = [
     "dist",
     "build",
     "target",
+    "testdata",
 
     # Specific files or patterns
     "CHANGELOG.md",

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "pb-spec"
-version = "0.8.2"
+version = "0.8.3"
 description = "Plan-Build Spec (pb-spec): A CLI tool for managing AI coding assistant skills"
 readme = "README.md"
 license = "Apache-2.0"

src/pb_spec/validation/design.py

@@ -5,8 +5,8 @@
 import re
 from pathlib import Path
 
-HEADING_RE = re.compile(r"^#{2,6}\s+(.+?)\s*$")
-LEADING_NUMBER_RE = re.compile(r"^\d+(?:\.\d+)*\.\s+")
+HEADING_RE = re.compile(r"^(#{2,6})\s+(.+?)\s*$")
+LEADING_NUMBER_RE = re.compile(r"^\d+(?:\.\d+)*\.?\s+")
 PLACEHOLDER_RE = re.compile(r"^(?:TBD|\[To be written\]|\[[^\]]+\])$", re.IGNORECASE)
 
 FULL_MODE_REQUIRED_SECTIONS = (
@@ -32,57 +32,67 @@
 def validate_design_file(design_file: Path) -> list[str]:
     """Validate required design.md sections for full or lightweight mode."""
     sections = _parse_design_sections(design_file)
-    section_names = {name for name, _ in sections}
-    required_sections = _select_required_sections(section_names)
+    section_names = {name for name, _, _ in sections}
+    required_sections = _select_required_sections(section_names, sections)
 
     errors: list[str] = []
-    section_map = dict(sections)
+    section_map = {name: content for name, content, _ in sections}
     for section_name in required_sections:
         if section_name not in section_map:
             errors.append(f"Missing required design section in design.md: {section_name}")
             continue
 
-        if _is_placeholder_content(section_map[section_name]):
+        if _is_placeholder_content(section_map[section_name]) and not _has_subsections(
+            section_name, sections
+        ):
             errors.append(
                 f"Required design section is empty or placeholder in design.md: {section_name}"
             )
 
-    for section_name in _select_conditional_required_sections(section_names):
+    for section_name in _select_conditional_required_sections(section_names, sections):
         if section_name in required_sections:
             continue
         if section_name not in section_map:
             errors.append(f"Missing required design section in design.md: {section_name}")
             continue
 
-        if _is_placeholder_content(section_map[section_name]):
+        if _is_placeholder_content(section_map[section_name]) and not _has_subsections(
+            section_name, sections
+        ):
             errors.append(
                 f"Required design section is empty or placeholder in design.md: {section_name}"
             )
 
     return errors
 
 
-def _parse_design_sections(design_file: Path) -> list[tuple[str, str]]:
+def _parse_design_sections(design_file: Path) -> list[tuple[str, str, int]]:
+    """Parse design.md sections, returning (name, content, heading_level) tuples."""
     lines = design_file.read_text(encoding="utf-8").splitlines()
-    sections: list[tuple[str, str]] = []
+    sections: list[tuple[str, str, int]] = []
     current_heading: str | None = None
+    current_level: int = 0
     current_content: list[str] = []
 
     for line in lines:
         heading_match = HEADING_RE.match(line)
         if heading_match:
-            normalized_heading = _normalize_heading(heading_match.group(1))
+            level = len(heading_match.group(1))
+            normalized_heading = _normalize_heading(heading_match.group(2))
             if current_heading is not None:
-                sections.append((current_heading, "\n".join(current_content).strip()))
+                sections.append(
+                    (current_heading, "\n".join(current_content).strip(), current_level)
+                )
             current_heading = normalized_heading
+            current_level = level
             current_content = []
             continue
 
         if current_heading is not None:
             current_content.append(line)
 
     if current_heading is not None:
-        sections.append((current_heading, "\n".join(current_content).strip()))
+        sections.append((current_heading, "\n".join(current_content).strip(), current_level))
 
     return sections
 
@@ -100,15 +110,32 @@ def _normalize_heading(heading: str) -> str:
 )
 
 
-def _select_required_sections(section_names: set[str]) -> tuple[str, ...]:
-    if section_names & LIGHTWEIGHT_ONLY_SECTIONS:
+def _select_required_sections(
+    section_names: set[str], sections: list[tuple[str, str, int]] | None = None
+) -> tuple[str, ...]:
+    lightweight_names = section_names & LIGHTWEIGHT_ONLY_SECTIONS
+    if lightweight_names and sections:
+        for name, _, level in sections:
+            if name in lightweight_names and level == 2:
+                return LIGHTWEIGHT_MODE_REQUIRED_SECTIONS
+    elif lightweight_names:
         return LIGHTWEIGHT_MODE_REQUIRED_SECTIONS
     return FULL_MODE_REQUIRED_SECTIONS
 
 
-def _select_conditional_required_sections(section_names: set[str]) -> tuple[str, ...]:
+def _select_conditional_required_sections(
+    section_names: set[str], sections: list[tuple[str, str, int]] | None = None
+) -> tuple[str, ...]:
     conditional_sections: list[str] = []
-    is_lightweight = bool(section_names & LIGHTWEIGHT_ONLY_SECTIONS)
+    is_lightweight = False
+    lightweight_names = section_names & LIGHTWEIGHT_ONLY_SECTIONS
+    if lightweight_names and sections:
+        for name, _, level in sections:
+            if name in lightweight_names and level == 2:
+                is_lightweight = True
+                break
+    elif lightweight_names:
+        is_lightweight = True
 
     if "Existing Components to Reuse" not in section_names:
         conditional_sections.append("Existing Components to Reuse")
@@ -123,6 +150,24 @@ def _select_conditional_required_sections(section_names: set[str]) -> tuple[str,
     return tuple(conditional_sections)
 
 
+def _has_subsections(section_name: str, sections: list[tuple[str, str, int]]) -> bool:
+    """Check whether a section has child subsections at a deeper heading level."""
+    idx = None
+    parent_level = 0
+    for i, (name, _, level) in enumerate(sections):
+        if name == section_name:
+            idx = i
+            parent_level = level
+            break
+    if idx is None:
+        return False
+    for _, _, level in sections[idx + 1 :]:
+        if level > parent_level:
+            return True
+        break
+    return False
+
+
 def _is_placeholder_content(content: str) -> bool:
     stripped_content = content.strip()
     if not stripped_content:

src/pb_spec/validation/tasks.py

@@ -168,10 +168,13 @@ def validate_task_file(
                     "Scenario Coverage must name a concrete scenario for "
                     f"{task_block.task_id} when Loop Type is BDD+TDD"
                 )
-            elif scenario_inventory is not None and scenario_coverage not in scenario_inventory:
-                errors.append(
-                    f"Scenario reference not found for {task_block.task_id}: {scenario_coverage}"
-                )
+            elif scenario_inventory is not None:
+                scenario_names = _extract_scenario_names(scenario_coverage)
+                for scenario_name in scenario_names:
+                    if scenario_name not in scenario_inventory:
+                        errors.append(
+                            f"Scenario reference not found for {task_block.task_id}: {scenario_name}"
+                        )
 
     return errors
 
@@ -182,7 +185,7 @@ def find_referenced_scenarios(task_blocks: list[TaskBlock]) -> set[str]:
     for block in task_blocks:
         coverage = block.fields.get("Scenario Coverage")
         if coverage is not None and not _is_not_applicable_value(coverage):
-            referenced.add(coverage)
+            referenced.update(_extract_scenario_names(coverage))
     return referenced
 
 
@@ -204,20 +207,20 @@ def _build_task_block(task_id: str, name: str, body_lines: list[str]) -> TaskBlo
     for line in body_lines:
         quote_field_match = QUOTE_FIELD_RE.match(line)
         if quote_field_match:
-            fields[quote_field_match.group(1)] = quote_field_match.group(2)
+            fields[quote_field_match.group(1)] = _strip_backticks(quote_field_match.group(2))
             continue
 
         field_match = FIELD_RE.match(line)
         if field_match:
-            fields[field_match.group(1)] = field_match.group(2)
+            fields[field_match.group(1)] = _strip_backticks(field_match.group(2))
             continue
 
         if CHECKBOX_RE.match(line):
             evidence_checkbox_lines.append(line)
             checkbox_label_match = CHECKBOX_LABEL_RE.match(line)
             if checkbox_label_match:
                 checkbox_fields[_normalize_checkbox_field_name(checkbox_label_match.group(1))] = (
-                    checkbox_label_match.group(2)
+                    _strip_backticks(checkbox_label_match.group(2))
                 )
             if line.startswith("- [ ] **Step") or line.startswith("- [x] **Step"):
                 checkbox_lines.append(line)
@@ -242,6 +245,47 @@ def _is_bare_not_applicable_value(value: str) -> bool:
     return value.strip() == "N/A"
 
 
+def _extract_scenario_names(coverage: str) -> list[str]:
+    """Extract all scenario names from a coverage value.
+
+    Handles formats:
+    - 'Scenario Name'
+    - 'feature_file.feature / Scenario Name'
+    - 'feature_file.feature / all scenarios' (returns empty list)
+    - '`feature / s1`, `feature / s2`' (multiple backtick-wrapped refs)
+    """
+    if "`, `" in coverage:
+        parts = coverage.split("`, `")
+        names = []
+        for part in parts:
+            name = _parse_single_scenario_ref(part.strip("`").strip())
+            if name is not None:
+                names.append(name)
+        return names
+    name = _parse_single_scenario_ref(coverage)
+    return [name] if name is not None else []
+
+
+def _parse_single_scenario_ref(value: str) -> str | None:
+    """Parse a single 'feature / scenario' or plain scenario reference."""
+    stripped = value.strip().strip("`")
+    if " / " in stripped:
+        _feature, scenario = stripped.split(" / ", 1)
+        scenario = scenario.strip()
+        if scenario.lower() == "all scenarios":
+            return None
+        return scenario
+    return stripped if stripped else None
+
+
+def _strip_backticks(value: str) -> str:
+    """Strip surrounding single backticks from a field value."""
+    stripped = value.strip()
+    if len(stripped) >= 2 and stripped.startswith("`") and stripped.endswith("`"):
+        return stripped[1:-1]
+    return stripped
+
+
 def _normalize_checkbox_field_name(name: str) -> str:
     normalized_name = name.strip()
     if normalized_name.startswith("Runtime Verification"):