cowork-flow 2.3.0 → 2.4.1

package/src/lib/language.js

@@ -0,0 +1,162 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+export const DEFAULT_LANGUAGE = 'zh-CN';
+export const SUPPORTED_LANGUAGES = Object.freeze(['zh-CN', 'en-US']);
+
+const LANGUAGE_ALIASES = new Map([
+  ['zh', 'zh-CN'],
+  ['zh-cn', 'zh-CN'],
+  ['zh_cn', 'zh-CN'],
+  ['en', 'en-US'],
+  ['en-us', 'en-US'],
+  ['en_us', 'en-US']
+]);
+
+// The config is a flat YAML document; a top-level `language:` scalar is the
+// only place the install-time choice is recorded. A `#` starts a comment only
+// outside quotes and only after whitespace, matching the Python reader.
+const LANGUAGE_KEY_RE = /^language\s*:\s*(.*)$/;
+
+function stripInlineComment(value) {
+  let quote = '';
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (escaped) {
+      escaped = false;
+    } else if (quote === '"' && char === '\\') {
+      escaped = true;
+    } else if (quote) {
+      if (char === quote) {
+        quote = '';
+      }
+    } else if (index === 0 && (char === '"' || char === "'")) {
+      quote = char;
+    } else if (char === '#' && (index === 0 || value[index - 1] === ' ' || value[index - 1] === '\t')) {
+      return value.slice(0, index).trimEnd();
+    }
+  }
+  return value;
+}
+
+function unquote(value) {
+  if (
+    value.length >= 2
+    && (value[0] === '"' || value[0] === "'")
+    && value[value.length - 1] === value[0]
+  ) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+export function normalizeLanguage(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  return LANGUAGE_ALIASES.get(String(value).trim().toLowerCase()) ?? null;
+}
+
+// Top-level `language:` lines only. Two keys, an empty value, a glued comment,
+// or trailing junk after a quoted value all mean the explicit setting cannot be
+// trusted; callers decide whether that is fatal (sync) or falls back (generation).
+export function readLanguageSetting(content) {
+  const entries = [];
+  for (const rawLine of String(content ?? '').split(/\r?\n/)) {
+    if (/^\s/.test(rawLine)) {
+      continue;
+    }
+    const match = LANGUAGE_KEY_RE.exec(rawLine);
+    if (match) {
+      entries.push(match[1]);
+    }
+  }
+  if (entries.length === 0) {
+    return { present: false, raw: null, duplicate: false };
+  }
+  if (entries.length > 1) {
+    return { present: true, raw: null, duplicate: true };
+  }
+  return {
+    present: true,
+    raw: unquote(stripInlineComment(entries[0].trim())).trim(),
+    duplicate: false
+  };
+}
+
+export function readLanguageValue(content) {
+  const setting = readLanguageSetting(content);
+  return setting.present ? setting.raw : null;
+}
+
+export function parseLanguage(content) {
+  return normalizeLanguage(readLanguageValue(content));
+}
+
+export async function readProjectLanguage(targetDir) {
+  const file = join(targetDir, '.cowork-flow', 'config.yaml');
+  let content;
+  try {
+    content = await readFile(file, 'utf8');
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return {
+        file,
+        present: false,
+        configured: false,
+        valid: true,
+        duplicate: false,
+        raw: null,
+        language: DEFAULT_LANGUAGE
+      };
+    }
+    throw error;
+  }
+
+  const setting = readLanguageSetting(content);
+  const language = setting.duplicate ? null : normalizeLanguage(setting.raw);
+  return {
+    file,
+    present: true,
+    configured: setting.present,
+    valid: !setting.present || language !== null,
+    duplicate: setting.duplicate,
+    raw: setting.raw,
+    language: language ?? DEFAULT_LANGUAGE
+  };
+}
+
+// Planning commands must not silently fall back on a typo: the caller is about
+// to distribute assets for a language the project explicitly asked for.
+export async function readProjectLanguageStrict(targetDir) {
+  const info = await readProjectLanguage(targetDir);
+  if (info.configured && !info.valid) {
+    const detail = info.duplicate
+      ? 'duplicate language keys'
+      : `unsupported language ${JSON.stringify(info.raw)}`;
+    throw new Error(
+      `${detail} in ${info.file}; expected ${SUPPORTED_LANGUAGES.join(' or ')}`
+    );
+  }
+  return info;
+}
+
+// Write the chosen language into the config content that is about to be
+// installed. The template already declares the key; the fallback keeps a
+// hand-edited template from losing the choice.
+export function withLanguage(content, language) {
+  const canonical = normalizeLanguage(language);
+  if (!canonical) {
+    throw new Error(`Unsupported language: ${language}`);
+  }
+  const setting = readLanguageSetting(content);
+  if (setting.duplicate) {
+    throw new Error('Cannot rewrite a config with duplicate language keys');
+  }
+  const line = `language: "${canonical}"`;
+  if (setting.present) {
+    return content.replace(/^language\s*:.*$/m, line);
+  }
+  return `${content.replace(/\s*$/, '')}\n\n${line}\n`;
+}

package/template/.cowork-flow/.version

@@ -1 +1 @@
-2.3.0
+2.4.1

package/template/.cowork-flow/config.yaml

@@ -3,6 +3,14 @@
 #
 # All values have sensible defaults. Only override what you need.
 
+#-------------------------------------------------------------------------------
+# Language
+#-------------------------------------------------------------------------------
+
+# Output language for generated task and plan artifacts: zh-CN or en-US.
+# This file is never overwritten by project sync, including sync --force.
+language: "zh-CN"
+
 #-------------------------------------------------------------------------------
 # Codex Runtime
 #-------------------------------------------------------------------------------

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

@@ -133,10 +133,12 @@ def _print_create_result(result) -> None:
             file=sys.stderr,
         )
     if result.generated_anchor:
-        print(
-            f"  {colored('[OK]', Colors.GREEN)} "
+        message = (
             "Generated decision-anchor.md from plan"
+            if result.generated_anchor_from_plan
+            else "Created decision-anchor.md scaffold"
         )
+        print(f"  {colored('[OK]', Colors.GREEN)} {message}")
 
     print(
         colored(f"Created task: {dir_name}", Colors.GREEN),
@@ -150,7 +152,7 @@ def _print_next_steps() -> None:
     print("", file=sys.stderr)
     print(colored("Next steps:", Colors.BLUE), file=sys.stderr)
     print(
-        "  1. Create decision-anchor.md with requirements",
+        "  1. Fill in decision-anchor.md (a scaffold is created)",
         file=sys.stderr,
     )
     print(

package/template/.cowork-flow/scripts/adapters/host/host_manifest.py

@@ -31,11 +31,14 @@ CAPABILITY_STATUS_VALUES = (
     "experimental",
     "unsupported",
 )
-MANIFEST_KEYS = frozenset(("schemaVersion", "capabilityValues", "capabilityMatrix", "platforms", "excludedPrefixes", "syncPolicy"))
+MANIFEST_KEYS = frozenset(("schemaVersion", "capabilityValues", "capabilityMatrix", "platforms", "excludedPrefixes", "localization", "syncPolicy"))
 PLATFORM_KEYS = frozenset(("id", "displayName", "aliases", "detectAny", "assetPrefixes", "assetFiles", "skillReadRoot", "skillDiscovery", "adapterPath", "capabilities", "commandTargets", "payload"))
 SKILL_DISCOVERY_KEYS = frozenset(("scope", "path", "gates", "evidence"))
 SKILL_DISCOVERY_SCOPES = frozenset(("project",))
-SYNC_POLICY_KEYS = frozenset(("protectedFiles", "protectedPrefixes", "safeFiles", "safePrefixes", "managedBlockFiles", "obsoleteFiles"))
+SYNC_POLICY_KEYS = frozenset(("protectedFiles", "forceProtectedFiles", "protectedPrefixes", "safeFiles", "safePrefixes", "managedBlockFiles", "obsoleteFiles"))
+LOCALIZATION_KEYS = frozenset(("default", "supported", "assets"))
+DEFAULT_LANGUAGE = "zh-CN"
+SUPPORTED_LANGUAGES = ("zh-CN", "en-US")
 COMMAND_TARGET_KEYS = frozenset(("config", "format", "target"))
 COMMAND_TARGET_FORMATS = frozenset(("json", "toml", "yaml"))
 CAPABILITY_DECLARATION_KEYS = frozenset(("status", "fallback"))
@@ -108,6 +111,7 @@ class HostPlatform:
 @dataclass(frozen=True)
 class SyncPolicy:
     protected_files: tuple[str, ...]
+    force_protected_files: tuple[str, ...]
     protected_prefixes: tuple[str, ...]
     safe_files: tuple[str, ...]
     safe_prefixes: tuple[str, ...]
@@ -115,6 +119,19 @@ class SyncPolicy:
     obsolete_files: tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class Localization:
+    """Language-specific asset overrides.
+
+    The base template always carries the default language. A non-default
+    language may override a declared asset from `locales/<language>/`.
+    """
+
+    default: str
+    supported: tuple[str, ...]
+    assets: dict[str, tuple[str, ...]]
+
+
 @dataclass(frozen=True)
 class HostManifest:
     schema_version: int
@@ -123,6 +140,7 @@ class HostManifest:
     capability_matrix: dict[str, dict[str, CapabilityDeclaration]]
     platforms: tuple[HostPlatform, ...]
     excluded_prefixes: tuple[str, ...]
+    localization: Localization
     sync_policy: SyncPolicy
 
     @property
@@ -195,6 +213,19 @@ def validate_host_assets(
     if not (root / SCHEMA_PATH).is_file():
         errors.append(f"missing host asset schema: {root / SCHEMA_PATH}")
 
+    # Locale sources live in the package template. An installed project keeps
+    # only the resolved canonical path, so absence of `locales/` is normal and
+    # must not turn into a host-asset error.
+    if (root / "locales").is_dir():
+        for language, assets in manifest.localization.assets.items():
+            for asset in assets:
+                if not (root / asset).is_file():
+                    errors.append(f"missing localized base asset: {asset}")
+                if not (root / "locales" / language / asset).is_file():
+                    errors.append(
+                        f"missing localized asset: locales/{language}/{asset}"
+                    )
+
     selected_platforms: list[HostPlatform] = []
     selected_ids = (
         manifest.platform_ids
@@ -388,8 +419,13 @@ def _build_manifest(raw: dict[str, Any]) -> HostManifest:
         capability_matrix=capability_matrix,
         platforms=platforms,
         excluded_prefixes=_string_tuple(raw.get("excludedPrefixes"), "excludedPrefixes"),
+        localization=_build_localization(raw.get("localization")),
         sync_policy=SyncPolicy(
             protected_files=_string_tuple(sync_raw.get("protectedFiles"), "syncPolicy.protectedFiles"),
+            force_protected_files=_string_tuple(
+                sync_raw.get("forceProtectedFiles", []),
+                "syncPolicy.forceProtectedFiles",
+            ),
             protected_prefixes=_string_tuple(sync_raw.get("protectedPrefixes"), "syncPolicy.protectedPrefixes"),
             safe_files=_string_tuple(sync_raw.get("safeFiles"), "syncPolicy.safeFiles"),
             safe_prefixes=_string_tuple(sync_raw.get("safePrefixes"), "syncPolicy.safePrefixes"),
@@ -398,6 +434,39 @@ def _build_manifest(raw: dict[str, Any]) -> HostManifest:
         ),
     )
 
+
+def _build_localization(raw: object) -> Localization:
+    if raw is None:
+        return Localization(
+            default=DEFAULT_LANGUAGE,
+            supported=SUPPORTED_LANGUAGES,
+            assets={},
+        )
+    if not isinstance(raw, dict):
+        raise HostManifestError("localization must be an object")
+    _reject_unknown_fields(raw, LOCALIZATION_KEYS, "localization")
+    default = raw.get("default")
+    if not isinstance(default, str) or not default.strip():
+        raise HostManifestError("localization.default must be a non-empty string")
+    supported = _string_tuple(raw.get("supported"), "localization.supported")
+    if default not in supported:
+        raise HostManifestError("localization.default must be listed in localization.supported")
+    assets_raw = raw.get("assets")
+    if not isinstance(assets_raw, dict):
+        raise HostManifestError("localization.assets must be an object")
+    assets: dict[str, tuple[str, ...]] = {}
+    for language, paths in assets_raw.items():
+        if language not in supported:
+            raise HostManifestError(
+                f"localization.assets language is not supported: {language}"
+            )
+        if language == default:
+            raise HostManifestError(
+                "localization.assets must not override the default language"
+            )
+        assets[language] = _string_tuple(paths, f"localization.assets.{language}")
+    return Localization(default=default, supported=supported, assets=assets)
+
 def _build_capability_matrix(
     raw: object,
     allowed: tuple[str, ...],

package/template/.cowork-flow/scripts/infra/config.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import re
 from pathlib import Path
 
 from infra.paths import DIR_WORKFLOW, get_repo_root
@@ -18,9 +19,24 @@ DEFAULT_PARTY_MODE_V2_MAX_DRIFT_WARNINGS = 2
 DEFAULT_PARTY_MODE_V2_FRESH_CONTEXT_PER_ROUND = True
 DEFAULT_PARTY_MODE_V2_REQUIRE_CURRENT_ROUND_ONLY = True
 
+DEFAULT_LANGUAGE = "zh-CN"
+SUPPORTED_LANGUAGES = ("zh-CN", "en-US")
+LANGUAGE_ALIASES = {
+    "zh": "zh-CN",
+    "zh-cn": "zh-CN",
+    "zh_cn": "zh-CN",
+    "en": "en-US",
+    "en-us": "en-US",
+    "en_us": "en-US",
+}
+
 CONFIG_FILE = "config.yaml"
 
 
+class UnsupportedLanguageError(ValueError):
+    """The config declares a language the runtime does not support."""
+
+
 def _unquote(value: str) -> str:
     if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
         return value[1:-1]
@@ -117,6 +133,75 @@ def _load_config(repo_root: Path | None = None) -> dict:
         return {}
 
 
+def normalize_language(value: object) -> str | None:
+    """Canonical language for a supported value, otherwise None."""
+    if not isinstance(value, str):
+        return None
+    return LANGUAGE_ALIASES.get(value.strip().lower())
+
+
+_LANGUAGE_KEY_RE = re.compile(r"^language\s*:\s*(.*)$")
+
+
+def _read_language_setting(
+    repo_root: Path | None = None,
+) -> tuple[str | None, bool, bool]:
+    """The explicit top-level language scalar.
+
+    Returns `(raw, present, duplicate)`. Only top-level `language:` lines count.
+    Two keys, an empty value, a glued comment, or trailing junk are left for
+    `normalize_language` to reject, matching the Node reader.
+    """
+    config_file = _get_config_path(repo_root)
+    try:
+        content = config_file.read_text(encoding="utf-8")
+    except (OSError, IOError):
+        return None, False, False
+
+    entries: list[str] = []
+    for raw_line in content.splitlines():
+        if raw_line.startswith((" ", "\t")):
+            continue
+        match = _LANGUAGE_KEY_RE.match(raw_line)
+        if match:
+            entries.append(match.group(1))
+    if not entries:
+        return None, False, False
+    if len(entries) > 1:
+        return None, True, True
+    raw = _unquote(_strip_comment(entries[0].strip())).strip()
+    return raw, True, False
+
+
+def get_language(
+    repo_root: Path | None = None,
+    *,
+    strict: bool = False,
+) -> str:
+    """Task/plan artifact language from the project config.
+
+    A missing file or key yields the default. An explicit unsupported value or
+    duplicate `language` keys raises when strict is set; runtime generation uses
+    the non-strict form so a config typo cannot block task creation.
+    """
+    raw, present, duplicate = _read_language_setting(repo_root)
+    if not present:
+        return DEFAULT_LANGUAGE
+    canonical = None if duplicate else normalize_language(raw)
+    if canonical is not None:
+        return canonical
+    if strict:
+        detail = (
+            "duplicate language keys"
+            if duplicate
+            else f"unsupported language {raw!r}"
+        )
+        raise UnsupportedLanguageError(
+            detail + "; expected one of: " + ", ".join(SUPPORTED_LANGUAGES)
+        )
+    return DEFAULT_LANGUAGE
+
+
 
 def get_hooks(event: str, repo_root: Path | None = None) -> list[str]:
     """Hook commands declared for one lifecycle event; empty when none."""

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

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Shared decision-anchor heading schema.
+
+The runtime recognizes two heading sets for the same sections: the historical
+Chinese set and the English aliases introduced for English-language task
+artifacts. Recognition is language-independent so existing tasks and mixed
+language projects keep working; the configured project language only decides
+which set a newly generated anchor uses.
+"""
+
+from __future__ import annotations
+
+import re
+
+GOAL = "goal"
+ACCEPTANCE = "acceptance"
+REJECTED = "rejected"
+ASSUMPTIONS = "assumptions"
+SCOPE = "scope"
+VERIFICATION = "verification"
+
+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: "目标",
+        ACCEPTANCE: "验收标准",
+        REJECTED: "被拒方案",
+        ASSUMPTIONS: "关键假设",
+        SCOPE: "范围边界",
+        VERIFICATION: "验证命令",
+    },
+    "en-US": {
+        GOAL: "Goal",
+        ACCEPTANCE: "Acceptance Criteria",
+        REJECTED: "Rejected Options",
+        ASSUMPTIONS: "Key Assumptions",
+        SCOPE: "Scope Boundary",
+        VERIFICATION: "Verification Commands",
+    },
+}
+
+SECTION_ALIASES: dict[str, str] = {
+    heading: section
+    for headings in LANGUAGE_HEADINGS.values()
+    for section, heading in headings.items()
+}
+
+HEADING_RE = re.compile(r"^##\s*(.+?)\s*$")
+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:
+    """Canonical section key for a recognized heading, or None."""
+    return SECTION_ALIASES.get(heading)
+
+
+def headings_for(language: str) -> dict[str, str]:
+    """Heading set for a language, falling back to the default language."""
+    return LANGUAGE_HEADINGS.get(language, LANGUAGE_HEADINGS[DEFAULT_LANGUAGE])
+
+
+def heading_for(section: str, language: str) -> str:
+    """One heading in the requested language, falling back to the default."""
+    return headings_for(language)[section]
+
+
+def section_headings(section: str) -> tuple[str, ...]:
+    """Every recognized heading for one section, default language first."""
+    return tuple(
+        LANGUAGE_HEADINGS[language][section] for language in LANGUAGE_HEADINGS
+    )
+
+
+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()
+    for raw in text.splitlines():
+        heading = HEADING_RE.match(raw.strip())
+        if not heading:
+            continue
+        section = canonical_section(heading.group(1))
+        if section is not None:
+            present.add(section)
+    return present
+
+
+def acceptance_section_lines(text: str) -> list[str]:
+    """Raw lines under the acceptance heading, up to the next heading."""
+    return section_lines(text, ACCEPTANCE)