@ikon85/agent-workflow-kit 0.42.1 → 0.44.0

package/scripts/test_skill_frontmatter_lint.py

@@ -1,234 +0,0 @@
-#!/usr/bin/env python3
-"""Skill-frontmatter parse-parity lint (#1603-Retro).
-
-Why: every other skill-lint reads `name`/`description` with a *regex* (e.g.
-stale_name_lint `re.compile(rf"name:\\s*{n}\\b")`), while the real consumer —
-Claude Code's skill loader — parses the frontmatter as **strict YAML**. A
-SKILL.md whose frontmatter does not parse therefore passes `ci:local` green but
-silently fails to load. That actually happened building the `impact-census`
-skill: the description carried an ASCII `"` instead of the German `"`, which
-terminated the YAML double-quoted scalar early — green CI, dead skill, caught
-only by an ad-hoc `yaml.safe_load`.
-
-This lint closes the parse-parity gap: it loads the frontmatter the same way the
-consumer does and asserts the keys the loader needs. Scope is the whole class
-(unparseable frontmatter — ASCII quotes, tabs, bad indentation, unbalanced
-colons), not just the one quote char; it adds NO speculative content rules.
-
-Checks, per SKILL.md in both trees (.claude/skills + .agents/skills):
-  1. the frontmatter block parses as YAML;
-  2. `name` is a non-empty string AND equals the skill directory name;
-  3. `description` is a non-empty string.
-
-Run: python3 scripts/test_skill_frontmatter_lint.py
-"""
-import re
-import json
-import unittest
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-SKILL_DIRS = [".claude/skills", ".agents/skills"]
-
-
-def skill_md_files() -> list[Path]:
-    """Every <tree>/<skill>/SKILL.md across both surface trees."""
-    out = []
-    for tree in SKILL_DIRS:
-        base = REPO_ROOT / tree
-        if not base.is_dir():
-            continue
-        for d in sorted(base.iterdir()):
-            md = d / "SKILL.md"
-            if d.is_dir() and md.is_file():
-                out.append(md)
-    return out
-
-
-def extract_frontmatter(text: str) -> str:
-    """Return the YAML block between the first two `---` fences.
-
-    Raises ValueError when the file has no leading frontmatter fence — the
-    loader requires it, so its absence is itself a failure.
-    """
-    if not text.startswith("---"):
-        raise ValueError("no leading `---` frontmatter fence")
-    parts = text.split("---", 2)
-    if len(parts) < 3:
-        raise ValueError("unterminated frontmatter (missing closing `---`)")
-    return parts[1]
-
-
-class FrontmatterError(ValueError):
-    pass
-
-
-def parse_scalar(value: str) -> str:
-    value = value.strip()
-    if value.startswith('"'):
-        try:
-            return json.loads(value)
-        except json.JSONDecodeError as exc:
-            raise FrontmatterError(str(exc)) from exc
-    if value.startswith("'"):
-        if len(value) < 2 or not value.endswith("'"):
-            raise FrontmatterError("unterminated single-quoted scalar")
-        return value[1:-1].replace("''", "'")
-    if ": " in value:
-        raise FrontmatterError("mapping values are not allowed in a plain scalar")
-    return value.split(" #", 1)[0].strip()
-
-
-def parse_frontmatter(block: str) -> dict:
-    """Parse the loader-relevant YAML subset without a third-party package."""
-    if "\t" in block:
-        raise FrontmatterError("tabs are not valid indentation")
-    data = {}
-    lines = block.splitlines()
-    i = 0
-    while i < len(lines):
-        line = lines[i]
-        i += 1
-        if not line.strip() or line.lstrip().startswith("#"):
-            continue
-        match = re.match(r'^((?:[A-Za-z][\w-]*)|(?:"[A-Za-z][\w-]*")):(?:[ ]*(.*))$', line)
-        if not match:
-            raise FrontmatterError(f"invalid top-level mapping line: {line!r}")
-        key, value = match.groups()
-        key = key.strip('"')
-        if value in (">", ">-", "|", "|-"):
-            chunks = []
-            while i < len(lines) and (not lines[i].strip() or lines[i].startswith("  ")):
-                chunks.append(lines[i].strip())
-                i += 1
-            data[key] = " ".join(filter(None, chunks))
-        else:
-            data[key] = parse_scalar(value)
-    return data
-
-
-def validate(md: Path) -> list[str]:
-    """Return human-readable problems for one SKILL.md (empty = clean)."""
-    try:
-        rel = md.relative_to(REPO_ROOT).as_posix()
-    except ValueError:
-        rel = md.as_posix()  # tmp paths in the validator's own unit tests
-    skill_name = md.parent.name
-    text = md.read_text(encoding="utf-8")
-    try:
-        block = extract_frontmatter(text)
-        data = parse_frontmatter(block)
-    except (ValueError, FrontmatterError) as exc:
-        # one-line message — YAML errors are multi-line, keep only the gist
-        return [f"{rel}: frontmatter does not parse — {str(exc).splitlines()[0]}"]
-    problems = []
-    if not isinstance(data, dict):
-        return [f"{rel}: frontmatter is not a YAML mapping"]
-    name = data.get("name")
-    if not isinstance(name, str) or not name.strip():
-        problems.append(f"{rel}: `name` missing or empty")
-    elif name != skill_name:
-        problems.append(f"{rel}: `name` is '{name}' but directory is '{skill_name}'")
-    desc = data.get("description")
-    if not isinstance(desc, str) or not desc.strip():
-        problems.append(f"{rel}: `description` missing or empty")
-    elif plain_desc_has_comment(block):
-        problems.append(
-            f"{rel}: plain-scalar `description` contains ' #' — YAML silently "
-            "truncates the rest as a comment (board-to-waves lost its anti-trigger "
-            "this way, PR #1914); quote it or fold with '>-'"
-        )
-    return problems
-
-
-DESC_LINE = re.compile(r"^description:[ \t]*(.*)$", re.M)
-
-
-def plain_desc_has_comment(block: str) -> bool:
-    """True when a PLAIN-style description scalar carries a ' #' — YAML reads
-    everything from the '#' on as a comment and silently shortens the value
-    (the file still parses, so the parse check above cannot catch it)."""
-    m = DESC_LINE.search(block)
-    if not m:
-        return False
-    first = m.group(1).strip()
-    if first[:1] in ('"', "'", ">", "|"):
-        return False  # quoted or block scalar — '#' is literal there
-    lines = [m.group(1)]
-    for ln in block[m.end():].splitlines():
-        # plain multi-line scalars continue on indented lines; stop at the
-        # next top-level key or a blank line
-        if ln.startswith((" ", "\t")) and ln.strip():
-            lines.append(ln)
-        else:
-            break
-    return any(" #" in ln for ln in lines)
-
-
-class FrontmatterParses(unittest.TestCase):
-    """Every SKILL.md frontmatter loads as the consumer (strict YAML) sees it."""
-
-    def test_all_skill_frontmatter_valid(self):
-        problems = [p for md in skill_md_files() for p in validate(md)]
-        self.assertEqual(
-            problems,
-            [],
-            "SKILL.md frontmatter that the loader would reject (regex lints miss "
-            "this — see #1603-Retro):\n" + "\n".join(problems),
-        )
-
-
-class ValidatorBehaves(unittest.TestCase):
-    """The validator itself catches the incident class (regression guard)."""
-
-    def _tmp_skill(self, body: str) -> Path:
-        import tempfile
-
-        d = Path(tempfile.mkdtemp()) / "demo"
-        d.mkdir()
-        md = d / "SKILL.md"
-        md.write_text(body, encoding="utf-8")
-        return md
-
-    def test_ascii_quote_in_description_is_flagged(self):
-        # the exact #1603 incident: an ASCII " closes the scalar early
-        md = self._tmp_skill('---\nname: demo\ndescription: "Use „x" then y, z"\n---\nbody\n')
-        self.assertTrue(any("does not parse" in p for p in validate(md)))
-
-    def test_plain_scalar_colon_followed_by_space_is_flagged(self):
-        md = self._tmp_skill(
-            "---\nname: demo\ndescription: This is invalid YAML: mapping-like text.\n---\nbody\n"
-        )
-        self.assertTrue(any("does not parse" in p for p in validate(md)))
-
-    def test_name_dir_mismatch_is_flagged(self):
-        md = self._tmp_skill("---\nname: wrong\ndescription: ok\n---\nbody\n")
-        self.assertTrue(any("but directory is 'demo'" in p for p in validate(md)))
-
-    def test_missing_description_is_flagged(self):
-        md = self._tmp_skill("---\nname: demo\n---\nbody\n")
-        self.assertTrue(any("`description` missing" in p for p in validate(md)))
-
-    def test_clean_frontmatter_passes(self):
-        md = self._tmp_skill('---\nname: demo\ndescription: "Use when foo: bar, baz."\n---\nbody\n')
-        self.assertEqual(validate(md), [])
-
-    def test_plain_desc_with_hash_comment_is_flagged(self):
-        # the PR-#1914 incident class: an unquoted ' #' turns the rest of a
-        # plain scalar into a YAML comment — parses fine, value silently short
-        md = self._tmp_skill(
-            "---\nname: demo\ndescription: Use for sweeps (e.g. #602); the anti-trigger after this vanishes.\n---\nbody\n"
-        )
-        self.assertTrue(any("silently" in p for p in validate(md)))
-
-    def test_quoted_and_folded_desc_with_hash_pass(self):
-        md = self._tmp_skill('---\nname: demo\ndescription: "Use for sweeps (e.g. #602); all kept."\n---\nbody\n')
-        self.assertEqual(validate(md), [])
-        md2 = self._tmp_skill(
-            "---\nname: demo\ndescription: >-\n  Use for sweeps\n  (e.g. #602); all kept.\n---\nbody\n"
-        )
-        self.assertEqual(validate(md2), [])
-
-
-if __name__ == "__main__":
-    unittest.main()

package/scripts/test_skill_gh_lint.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-"""Lint fixture (Welle 26 / #980): no bare board-writing `gh` in enforced skills.
-
-The board-sync mechanics now live behind `scripts/board-sync.py`. Skills that have
-been migrated to route through the helper must not inline bare board-mutating `gh`
-commands again — they drift from the SSOT and bypass the one-parent-check / preview
-header / field-ID encapsulation.
-
-Scope grows per slice: a skill joins ENFORCED_SKILLS once its slice routes it
-through the helper (1b: board-to-waves; to-issues lands in 1d/#982). The legacy
-two-line planning skill the helper was extracted from has since been removed
-(1f/#985).
-
-Only *runnable* lines inside ```bash/```sh fences are checked — prose mentions in
-backticks are fine. A line carrying the marker `board-sync-lint: ok` is exempt
-(for deliberate "don't do this" doc examples).
-
-Run: python3 scripts/test_skill_gh_lint.py
-"""
-import re
-import unittest
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-
-# Skills whose prose must route board writes through scripts/board-sync.py.
-# Grows per slice as each skill is migrated (1b: board-to-waves; 1c/#981: to-prd
-# routes creation through the helper; to-issues lands in 1d/#982; retro lands
-# in Welle 49 / Slice 9 / #1880).
-ENFORCED_SKILLS = ["board-to-waves", "to-prd", "to-issues", "retro"]
-
-# Both the Claude source and the Codex mirror must stay clean.
-SKILL_DIRS = [".claude/skills", ".agents/skills"]
-
-# Board-mutating gh commands that the helper now owns.
-FORBIDDEN = [
-    re.compile(r"\bgh\s+issue\s+create\b"),
-    re.compile(r"\bgh\s+project\s+item-add\b"),
-    re.compile(r"\bgh\s+project\s+item-edit\b"),
-    re.compile(r"\baddSubIssue\s*\(input"),
-    re.compile(r"\bremoveSubIssue\s*\(input"),
-    # workflow-state label edits the helper owns (R2#4): ready-for-agent / needs-info /
-    # type:cluster / wave-stub via gh issue edit --add-label/--remove-label. priority:* etc. stay fine.
-    re.compile(r"\bgh\s+issue\s+edit\b.*--(add|remove)-label\b.*"
-               r"\b(ready-for-agent|needs-info|type:cluster|wave-stub)\b"),
-]
-FENCE_OPEN = re.compile(r"^\s*```(bash|sh|shell)\b")
-FENCE_ANY = re.compile(r"^\s*```")
-EXEMPT = "board-sync-lint: ok"
-
-
-def find_offenders(text: str) -> list[tuple[int, str]]:
-    """Return (line_no, line) for forbidden gh inside bash/sh fences."""
-    offenders = []
-    in_shell = False
-    for n, line in enumerate(text.splitlines(), 1):
-        if not in_shell and FENCE_OPEN.match(line):
-            in_shell = True
-            continue
-        if in_shell and FENCE_ANY.match(line):
-            in_shell = False
-            continue
-        if in_shell and EXEMPT not in line:
-            if any(p.search(line) for p in FORBIDDEN):
-                offenders.append((n, line.strip()))
-    return offenders
-
-
-class SelfCheck(unittest.TestCase):
-    """The detector itself behaves."""
-
-    def test_flags_bare_create_in_bash_fence(self):
-        text = "```bash\ngh issue create --title X\n```"
-        self.assertEqual(len(find_offenders(text)), 1)
-
-    def test_flags_workflow_state_label_edit(self):
-        for lbl in ("ready-for-agent", "needs-info", "type:cluster", "wave-stub"):
-            text = f"```bash\ngh issue edit 982 --add-label {lbl}\n```"
-            self.assertEqual(len(find_offenders(text)), 1, lbl)
-
-    def test_flags_workflow_state_label_remove(self):
-        text = "```bash\ngh issue edit 982 --remove-label ready-for-agent\n```"
-        self.assertEqual(len(find_offenders(text)), 1)
-
-    def test_ignores_non_workflow_label_edit(self):
-        # priority:* is a normal label, not workflow-state — editing it is allowed
-        text = "```bash\ngh issue edit 982 --add-label priority:high\n```"
-        self.assertEqual(find_offenders(text), [])
-
-    def test_ignores_prose_mention(self):
-        text = "Der Helper kapselt `gh project item-edit` — nicht selbst aufrufen."
-        self.assertEqual(find_offenders(text), [])
-
-    def test_ignores_read_only_gh(self):
-        text = "```bash\ngh issue list --state open\ngh project item-list 1\n```"
-        self.assertEqual(find_offenders(text), [])
-
-    def test_exempt_marker(self):
-        text = "```bash\ngh issue create --title X  # board-sync-lint: ok (anti-example)\n```"
-        self.assertEqual(find_offenders(text), [])
-
-    def test_helper_call_is_clean(self):
-        text = "```bash\npython3 scripts/board-sync.py create --title X --body-file b.md\n```"
-        self.assertEqual(find_offenders(text), [])
-
-
-class EnforcedSkillsClean(unittest.TestCase):
-    def test_no_bare_board_gh_in_enforced_skills(self):
-        problems = []
-        for skill in ENFORCED_SKILLS:
-            for d in SKILL_DIRS:
-                path = REPO_ROOT / d / skill / "SKILL.md"
-                if not path.exists():
-                    continue
-                for ln, src in find_offenders(path.read_text(encoding="utf-8")):
-                    problems.append(f"{d}/{skill}/SKILL.md:{ln}: {src}")
-        self.assertEqual(
-            problems, [],
-            "Bare board-mutating gh in enforced skill prose — route through "
-            "scripts/board-sync.py:\n" + "\n".join(problems))
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

package/scripts/test_skill_language_census.py

@@ -1,254 +0,0 @@
-#!/usr/bin/env python3
-"""Language census lint (Welle 50 / Slice 6 / #1897).
-
-Mechanical proof that "the published skill prose is English" is COUNTED,
-not remembered (HR23 "Vollständigkeit ist gezählt, nicht erinnert" — the same
-principle behind `impact-census`, applied here to language instead of
-blast-radius).
-
-Denominator (Y): every skill with `publish: true` in the manifest
-(`.claude/skills/skill-manifest.json`) — the same SSOT the other skill lints
-use (see `test_skill_selfcontainment_lint.py`). Each skill's SKILL.md is read
-from whichever surface actually hosts it — `.claude/skills` if `"claude"` is
-in its `surfaces`, else `.agents/skills` (the sole surface for a Codex-only
-adapter such as `codex-adapter-sync`).
-
-Heuristic: a wordlist of common German function words, scanned whole-word
-case-insensitive against the BODY only (frontmatter — the first `---`...`---`
-block — is skipped; a skill's `description:` may legitimately quote German
-trigger phrases the user actually types, e.g. board-to-waves).
-
-False-positive guard: two short words in the list collide with real English
-tokens — `mit` collides with the "MIT" license acronym (always uppercase in
-this repo), and `die` collides with the English verb ("logs die"). Both are
-treated as WEAK signals: a line is only flagged if it carries a STRONG hit
-(a German word with no plausible English reading) or *multiple* WEAK hits
-(a coincidence of two independent English collisions on one line is not
-realistic). A single stray `mit`/`die` hit alone is not a violation.
-
-Allowlist (each entry is why it's exempt, not prose to translate):
-
-1. **Bilingual PRD example blocks** (`to-prd`) — the template deliberately
-   pairs a `lang="de"` user-story example with a `lang="en"` one so a spec
-   author can pick their spec's language; lines inside a
-   `<user-story-example lang="de">...</user-story-example>` block are
-   exempt.
-2. **Cross-skill contract literals** kept German on purpose because another
-   skill or the board-sync tooling consumes the exact string:
-   - `## Vor Bau zu klären` — the `headings.vorBau` profile VALUE
-     (`docs/agents/board-sync.md`); `to-issues`/`grill-with-docs(-codex)`/
-     `wrapup` all reference this literal heading text.
-   - (removed #1947: `In Arbeit`/`Triaged` were exempt as board Status option
-     values — shipped skills now speak role language + `--status-role`, the
-     vocabulary lives only in the profile's `fields.status.roles`, so the
-     exemption is dead and stays removed.)
-   - `Welle <N>` — the wave-anchor issue-title format `board-sync.py` parses.
-   - `Trigger` / `Check` / `Korrektur` — the `## Self-Critique-Check` block
-     format (`Trigger / Check / Korrektur`) that `setup-workflow`'s seed and
-     `spec-self-critique` both parse verbatim; matched via a dedicated
-     'Trigger/Check/Korrektur' regex, not the generic wordlist (none of
-     those three words are in the wordlist itself).
-   A line carrying ONLY these literals (no other wordlist hit) is exempt.
-3. **`skill-surface-lint`'s `CLAUDE_ONLY_MARKER`** — `test_skill_surface_refs.py`
-   greps prose for a literal marker string to suppress a Claude-only-skill
-   cross-surface reference. It shipped as the German phrase "nur Claude Code"
-   (Welle 26) and is now the English phrase "Claude Code only" (translated
-   alongside `ask-matt`, the only skill that carries it, in this slice) — so
-   this allowlist class exists for documentation/audit completeness but has
-   no live match after the translation.
-
-If the heuristic (after the allowlist) still flags a real hit in a
-publish:true body, that is a residual finding: translate it, or — if it's a
-genuine additional intentional literal — add it to `LINE_ALLOWLIST_LITERALS`
-with a one-line reason.
-
-Run: python3 -m unittest scripts.test_skill_language_census
-     (or, from scripts/: python3 test_skill_language_census.py)
-"""
-import json
-import re
-import unittest
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-MANIFEST = REPO_ROOT / ".claude/skills/skill-manifest.json"
-
-# STRONG: German function words with no realistic English reading.
-STRONG_WORDS = [
-    "der", "das", "und", "nicht", "wird", "werden", "muss", "kein", "oder",
-    "für", "über", "eine", "einen", "auch", "nur", "schon",
-]
-# WEAK: collide with real English tokens (MIT license acronym; "die" the verb).
-WEAK_WORDS = ["mit", "die"]
-
-STRONG_PAT = re.compile(r"\b(" + "|".join(STRONG_WORDS) + r")\b", re.IGNORECASE)
-WEAK_PAT = re.compile(r"\b(" + "|".join(WEAK_WORDS) + r")\b", re.IGNORECASE)
-
-# Cross-skill contract literals: a line whose ONLY wordlist hit(s) come from
-# inside one of these exact literals is exempt (§2 in the module docstring).
-CONTRACT_LITERALS = [
-    "## Vor Bau zu klären",
-]
-WAVE_TITLE = re.compile(r"\bWelle\s+\d+\b")
-
-BILINGUAL_BLOCK_START = re.compile(r'<user-story-example\s+lang="de"\s*>')
-BILINGUAL_BLOCK_END = re.compile(r"</user-story-example>")
-
-LINE_EXEMPT_MARKER = "language-census: ok"
-
-
-def load_manifest() -> dict:
-    return json.loads(MANIFEST.read_text(encoding="utf-8"))
-
-
-def publish_true_skills() -> dict:
-    """name -> SKILL.md path, resolved to whichever surface hosts the skill."""
-    manifest = load_manifest()["skills"]
-    out = {}
-    for name, entry in manifest.items():
-        if not entry.get("publish"):
-            continue
-        surfaces = entry.get("surfaces", [])
-        tree = ".claude/skills" if "claude" in surfaces else ".agents/skills"
-        out[name] = REPO_ROOT / tree / name / "SKILL.md"
-    return out
-
-
-def strip_frontmatter(text: str) -> str:
-    """Drop the leading `---`...`---` frontmatter block; description: may
-    legitimately quote German trigger phrases (board-to-waves)."""
-    if not text.startswith("---"):
-        return text
-    parts = text.split("---", 2)
-    return parts[2] if len(parts) >= 3 else text
-
-
-def _strip_contract_literals(line: str) -> str:
-    """Remove known cross-skill contract literals from a line before wordlist
-    matching, so a line consisting only of a literal (e.g. a heading
-    `## Vor Bau zu klären`) doesn't trip the census."""
-    stripped = line
-    for literal in CONTRACT_LITERALS:
-        stripped = stripped.replace(literal, "")
-    stripped = WAVE_TITLE.sub("", stripped)
-    return stripped
-
-
-def _line_hits(line: str) -> bool:
-    """True if this line carries a real (non-allowlisted) German-prose hit."""
-    if LINE_EXEMPT_MARKER in line:
-        return False
-    scan = _strip_contract_literals(line)
-    strong = STRONG_PAT.search(scan) is not None
-    weak_count = len(WEAK_PAT.findall(scan))
-    return strong or weak_count >= 2
-
-
-def find_violations(name: str, path: Path) -> list:
-    """Return [(lineno, line)] of real German-prose hits in a skill body."""
-    if not path.is_file():
-        return [(0, f"MISSING FILE: {path}")]
-    text = path.read_text(encoding="utf-8")
-    body = strip_frontmatter(text)
-
-    violations = []
-    in_bilingual_de_block = False
-    for i, line in enumerate(body.splitlines(), start=1):
-        if BILINGUAL_BLOCK_START.search(line):
-            in_bilingual_de_block = True
-        if in_bilingual_de_block:
-            if BILINGUAL_BLOCK_END.search(line):
-                in_bilingual_de_block = False
-            continue  # allowlist §1: deliberate bilingual example block
-        if _line_hits(line):
-            violations.append((i, line.strip()))
-    return violations
-
-
-class LanguageCensus(unittest.TestCase):
-    def test_all_publish_true_skills_are_english(self):
-        skills = publish_true_skills()
-        self.assertGreater(len(skills), 0, "no publish:true skills found — manifest read failed?")
-
-        all_violations = {}
-        for name, path in sorted(skills.items()):
-            v = find_violations(name, path)
-            if v:
-                all_violations[name] = v
-
-        total = len(skills)
-        clean = total - len(all_violations)
-        msg_lines = [f"Census: {clean} of {total} publish:true skills English."]
-        for name, v in all_violations.items():
-            msg_lines.append(f"\n{name}:")
-            for lineno, line in v[:10]:
-                msg_lines.append(f"  {lineno}: {line[:160]}")
-        self.assertEqual(
-            all_violations, {},
-            "\n".join(msg_lines) +
-            "\n\nTranslate the residual German prose, or — if it's a genuine "
-            "intentional literal — add it to the allowlist (CONTRACT_LITERALS / "
-            "a bilingual-block marker) with a one-line reason, or mark the "
-            "single line with `language-census: ok`.",
-        )
-
-
-class HeuristicFixtures(unittest.TestCase):
-    """The heuristic + allowlist mechanics, exercised in isolation."""
-
-    def test_strong_word_is_flagged(self):
-        self.assertTrue(_line_hits("Diese Änderung ist querschnittig und betrifft alles."))
-
-    def test_single_weak_word_alone_is_not_flagged(self):
-        # "MIT" license acronym collides with weak-word "mit"
-        self.assertFalse(_line_hits("Adopted from Matt Pocock's skill (MIT license)."))
-        # English verb "die" collides with weak-word "die"
-        self.assertFalse(_line_hits("Untagged logs survive; tagged logs die."))
-
-    def test_two_weak_words_together_are_flagged(self):
-        self.assertTrue(_line_hits("mit der Kampagne verglichen"))
-
-    def test_contract_literal_heading_alone_is_not_flagged(self):
-        self.assertFalse(_line_hits("## Vor Bau zu klären"))
-
-    def test_status_option_names_are_no_longer_exempt(self):
-        # #1947: `In Arbeit` lost its contract-literal exemption — shipped
-        # skills speak role language, so German option names in prose are a
-        # finding again ("Arbeit" itself is not in the wordlist; the article
-        # trips it, exactly like any other German prose).
-        self.assertTrue(_line_hits("verschiebe das Item auf `In Arbeit`"))
-        # An option name that carries no wordlist token stays invisible to the
-        # heuristic — the census is a German-prose net, not a name detector.
-        self.assertFalse(_line_hits("status `Triaged`"))
-
-    def test_wave_title_alone_is_not_flagged(self):
-        self.assertFalse(_line_hits("title **without** a `Welle 42` prefix"))
-
-    def test_contract_literal_plus_real_prose_is_still_flagged(self):
-        self.assertTrue(_line_hits("## Vor Bau zu klären und weitere Fragen für den Nutzer"))
-
-    def test_inline_exempt_marker_suppresses_the_line(self):
-        self.assertFalse(_line_hits("Dies ist deutsch und bleibt es.  <!-- language-census: ok -->"))
-
-    def test_frontmatter_is_stripped(self):
-        text = (
-            "---\n"
-            "name: x\n"
-            'description: Use when "lass uns das Board durchgehen".\n'
-            "---\n\n"
-            "Body is English only.\n"
-        )
-        body = strip_frontmatter(text)
-        self.assertNotIn("lass uns das Board durchgehen", body)
-
-    def test_bilingual_example_block_is_exempt(self):
-        path = REPO_ROOT / ".claude/skills/to-prd/SKILL.md"
-        if not path.is_file():
-            self.skipTest("to-prd SKILL.md not present")
-        violations = find_violations("to-prd", path)
-        flagged_lines = "\n".join(line for _, line in violations)
-        self.assertNotIn("Als QA-Lead", flagged_lines)
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)