test: disable rare-language grammar repros with documented grammar/limitation notes

Maintainer-approved: skip (return -1, not counted) the repros that fail due to
tree-sitter grammar defects or niche-language coverage gaps rather than cbm
extraction bugs, each with an in-code explanation and the original assertions
preserved (unreachable) for re-enable:

- verilog: grammar mis-parses the SystemVerilog task call as a data_declaration
  (fails identically as systemverilog).
- nim: extract-clean fails on standard Nim (indentation-sensitive grammar parse).
- meson: newer func...endfunc user-function syntax not modelled by the grammar.
- cobol / emacslisp: calls target external/undefined programs/symbols (no in-tree
  target node).
- bitbake / puppet / typst / llvm_ir / nasm / nix: niche-DSL/assembly/markup
  call or enclosing-func modelling gaps.

Mainstream-language reds (cpp, cs, java, kt, php, py, go) and the systemic
invariants remain enabled and red.

Signed-off-by: Martin Vogel <martin.vogel.tech@gmail.com>

tests/repro/repro_grammar_build.c

@@ -546,6 +546,14 @@ TEST(repro_grammar_build_cmake) {
  * Expected GREEN: dims 1-6. Robustness should pass.
  */
 TEST(repro_grammar_build_meson) {
+    /* DISABLED — GRAMMAR ISSUE (maintainer-approved, 2026-06-28): the newer Meson
+     * `cbm_flags = func (target) ... endfunc` user-function syntax is not parsed
+     * as a function_expression by tree-sitter-meson (extract_func_def is never
+     * called for it; the configured meson func node type is dead for this form),
+     * so no Function def is extracted. A grammar/feature-coverage limitation, not
+     * a cbm bug. Original assertions below are preserved (unreachable). */
+    printf("%sSKIP%s grammar issue (meson func...endfunc unsupported)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "project('cbm', 'c',\n"
         "    version: '0.8.1',\n"
@@ -954,6 +962,13 @@ TEST(repro_grammar_build_sshconfig) {
  * Robustness should pass.
  */
 TEST(repro_grammar_build_bitbake) {
+    /* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): BitBake (Yocto
+     * recipe DSL) produces no in-body CALLS edge for the fixture's task/function
+     * body — a callee/extraction gap in a niche build DSL. Deferred for now; not a
+     * mainstream-language bug. Original assertions below are preserved
+     * (unreachable) for re-enable. */
+    printf("%sSKIP%s rare language (BitBake call extraction)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "DESCRIPTION = \"CBM MCP server component\"\n"
         "HOMEPAGE    = \"https://github.com/DeusData/codebase-memory-mcp\"\n"
@@ -1012,6 +1027,13 @@ TEST(repro_grammar_build_bitbake) {
  * Robustness should pass.
  */
 TEST(repro_grammar_build_puppet) {
+    /* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): Puppet (config
+     * management DSL) sources its in-body call to the Module (enclosing-func gap
+     * for Puppet's define/function node), and the grammar's call/func modelling is
+     * niche. Deferred for now; not a mainstream-language bug. Original assertions
+     * below are preserved (unreachable) for re-enable. */
+    printf("%sSKIP%s rare language (Puppet enclosing-func)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "class cbm (\n"
         "  String $version  = '0.8.1',\n"

tests/repro/repro_grammar_markup.c

@@ -523,6 +523,14 @@ TEST(repro_grammar_markup_rst) {
  * Dim 8 expected GREEN: no dangling CALLS endpoints.
  */
 TEST(repro_grammar_markup_typst) {
+    /* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): Typst (markup).
+     * The `#greet("world")` is a genuinely top-level (module-level) application
+     * that production CORRECTLY sources to the Module, but pipeline_battery counts
+     * any non-Function-sourced edge as drift (the nix-pattern). A simple in-
+     * function wrap conflicts with markup_callable_battery, which needs that very
+     * call. Murky markup/fixture interaction in a niche language; deferred. */
+    printf("%sSKIP%s rare language (Typst top-level-call sourcing)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "#let title = \"Codebase Memory\"\n"
         "#let greet(name) = [Hello, #name!]\n"

tests/repro/repro_grammar_shells.c

@@ -634,6 +634,13 @@ TEST(repro_grammar_shells_fennel) {
  *   may yield no name -> 0 edges).
  */
 TEST(repro_grammar_shells_nix) {
+    /* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): Nix. An in-body
+     * call sources to the Module — an enclosing-func gap for this grammar's
+     * function node in the callable-sourcing check (func_kinds_for_lang / scope).
+     * Niche language; deferred for now. Original assertions below are preserved
+     * (unreachable) for re-enable. */
+    printf("%sSKIP%s rare language (Nix enclosing-func)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "let\n"
         "  addOne = x: x + 1;\n"
@@ -751,6 +758,13 @@ TEST(repro_grammar_shells_teal) {
  *   walk cannot reach a function_header ancestor -> Module-sourced.
  */
 TEST(repro_grammar_shells_llvm_ir) {
+    /* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): LLVM IR
+     * (assembly-level). No in-body CALLS edge is produced for the `call`
+     * instruction — a callee/extraction gap in a niche IR. Deferred for now; not a
+     * mainstream-language bug. Original assertions below are preserved
+     * (unreachable) for re-enable. */
+    printf("%sSKIP%s rare language (LLVM-IR call extraction)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "define i32 @inner(i32 %x) {\n"
         "entry:\n"
@@ -785,6 +799,13 @@ TEST(repro_grammar_shells_llvm_ir) {
  *   the enclosing-func walk cannot attribute the call -> Module-sourced.
  */
 TEST(repro_grammar_shells_nasm) {
+    /* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): NASM assembly.
+     * No in-body CALLS edge is produced for the `call` instruction — a callee/
+     * extraction gap in a niche assembly grammar. Deferred for now; not a
+     * mainstream-language bug. Original assertions below are preserved
+     * (unreachable) for re-enable. */
+    printf("%sSKIP%s rare language (NASM call extraction)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "section .text\n"
         "\n"

tests/repro/repro_grammar_systems.c

@@ -257,6 +257,14 @@ TEST(repro_grammar_systems_zig) {
  * call to "add".
  */
 TEST(repro_grammar_systems_nim) {
+    /* DISABLED — GRAMMAR ISSUE (maintainer-approved, 2026-06-28): extraction of
+     * standard Nim (`proc add(a, b: int): int = ...`) fails extract-clean (NULL
+     * result or has_error set) — tree-sitter-nim mis-parses the indentation-
+     * sensitive layout (Nim was a deferred/problematic grammar in the sweep). A
+     * grammar/parser defect, not a cbm extraction bug. Original assertions below
+     * are preserved (unreachable) for re-enable when the grammar is fixed. */
+    printf("%sSKIP%s grammar issue (tree-sitter-nim parse failure)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
     static const char src[] =
         "import std/strutils\n"
         "\n"

tests/repro/repro_invariant_enclosing_parity.c

@@ -328,13 +328,42 @@ static const parity_case_t case_cobol = {
 TEST(repro_enclosing_parity_fortran)    { return run_parity_case(&case_fortran); }
 TEST(repro_enclosing_parity_scss)       { return run_parity_case(&case_scss); }
 TEST(repro_enclosing_parity_sql)        { return run_parity_case(&case_sql); }
-TEST(repro_enclosing_parity_verilog)    { return run_parity_case(&case_verilog); }
+/* DISABLED — GRAMMAR ISSUE (maintainer-approved, 2026-06-28): tree-sitter-verilog
+ * mis-parses the SystemVerilog task call `do_log(n);` as a data_declaration
+ * (variable decl: type `do_log`, instance `(n)`), not a subroutine call, so no
+ * CALLS edge ever forms. Verified to fail identically under CBM_LANG_SYSTEMVERILOG
+ * (function_subroutine_call). This is a tree-sitter grammar defect, not a cbm
+ * extraction bug; re-enable when the grammar is fixed/replaced. */
+TEST(repro_enclosing_parity_verilog) {
+    (void)&case_verilog;
+    printf("%sSKIP%s grammar issue (tree-sitter-verilog mis-parses task call)\n", tf_dim(),
+           tf_reset());
+    return -1; /* skip — not counted as pass or fail */
+}
 TEST(repro_enclosing_parity_julia)      { return run_parity_case(&case_julia); }
 TEST(repro_enclosing_parity_nix)        { return run_parity_case(&case_nix); }
 TEST(repro_enclosing_parity_commonlisp) { return run_parity_case(&case_commonlisp); }
-TEST(repro_enclosing_parity_emacslisp)  { return run_parity_case(&case_emacslisp); }
+/* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): the Emacs Lisp
+ * `(defmacro run (n) (helper n))` body calls `helper`, which is an external/
+ * undefined symbol (not defined in-file), so there is no in-tree target node and
+ * no CALLS edge. Resolving cross-file/builtin Elisp symbols is out of scope for
+ * now; re-enable if/when Elisp gets in-file or builtin call-target resolution. */
+TEST(repro_enclosing_parity_emacslisp) {
+    (void)&case_emacslisp;
+    printf("%sSKIP%s rare language (external/undefined callee)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
+}
 TEST(repro_enclosing_parity_dart)       { return run_parity_case(&case_dart); }
-TEST(repro_enclosing_parity_cobol)      { return run_parity_case(&case_cobol); }
+/* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): COBOL
+ * `CALL 'HELPER'` invokes an EXTERNAL program named by a string literal; HELPER
+ * is not defined in this translation unit, so there is no in-tree target node and
+ * no CALLS edge. Modelling external COBOL program targets is out of scope for now;
+ * re-enable when external-program call targets are synthesized. */
+TEST(repro_enclosing_parity_cobol) {
+    (void)&case_cobol;
+    printf("%sSKIP%s rare language (external program callee)\n", tf_dim(), tf_reset());
+    return -1; /* skip — not counted as pass or fail */
+}
 
 /* ── Suite ──────────────────────────────────────────────────────────────── */