Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
fix(graph): quality round after the v0.11.0 probe — deterministic resolution, findability, coverage, names
Martin Vogel1a3425536be9
diff --git a/internal/cbm/cbm.c b/internal/cbm/cbm.cindex 2f475229a..8b319adda 100644--- a/internal/cbm/cbm.c+++ b/internal/cbm/cbm.c@@ -125,7 +125,79 @@ void cbm_reset_profile(void) {} \} while (0)+/* A definition name never spans lines. Config extractors hand over a node's+ * whole text — a YAML block key, a Makefile recipe (`endif\n\n$(obj)/x.h`), a+ * ktest .conf directive — and the line break rode into the graph (2026-09-16+ * probe: 8,301 Field nodes on elastic/elasticsearch, 91 kernel nodes). Cut at+ * the first line break and drop trailing blanks; the qualified name carries+ * the same text as its last segment and is cut the same way. */+static const char *cbm_first_line(CBMArena *a, const char *text) {+ if (!text) {+ return text;+ }+ const char *nl = strpbrk(text, "\r\n");+ if (!nl) {+ return text;+ }+ size_t n = (size_t)(nl - text);+ while (n > 0 && (text[n - 1] == ' ' || text[n - 1] == '\t')) {+ n--;+ }+ char *cut = (char *)cbm_arena_alloc(a, n + 1);+ if (!cut) {+ return text;+ }+ memcpy(cut, text, n);+ cut[n] = '\0';+ return cut;+}++/* JS/TS files: a definition named by a literal token is the walker naming a+ * function or variable from an object key or a numeric pattern element —+ * `{}` (1,534 incoming CALLS on microsoft/TypeScript's test baselines), `1`+ * (38 nodes), a quoted string. An identifier starts with a letter, `_`, `$`,+ * `#` (private members) or a non-ASCII byte; anything else is not a name. */+static bool cbm_js_family_path(const char *path) {+ if (!path) {+ return false;+ }+ const char *dot = strrchr(path, '.');+ if (!dot) {+ return false;+ }+ static const char *const exts[] = {".js", ".mjs", ".cjs", ".jsx", ".ts",+ ".mts", ".cts", ".tsx", ".ets", NULL};+ for (int i = 0; exts[i]; i++) {+ if (strcmp(dot, exts[i]) == 0) {+ return true;+ }+ }+ return false;+}++static bool cbm_js_name_is_junk(const char *name) {+ if (!name || !name[0]) {+ return false; /* empty names are handled by the callers' own rules */+ }+ unsigned char c = (unsigned char)name[0];+ bool identifier_start = (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_' ||+ c == '$' || c == '#' || c >= 0x80;+ /* Member names JS spells without an identifier start are still names:+ * computed keys (`[Symbol.iterator]`), string-literal keys (`"my-key"`,+ * `'x'`) and escaped identifiers (`А`). Measured on the TypeScript+ * corpus: 1,531 `[…]` members, 97 quoted members, 154 escaped+ * identifiers — all real definitions. What remains ({…} patterns, numeric+ * literals, parenthesised types, `...rest`) is a token, not a name. */+ bool member_key_start = c == '[' || c == '"' || c == '\'' || c == '\\';+ return !identifier_start && !member_key_start;+}+void cbm_defs_push(CBMDefArray *arr, CBMArena *a, CBMDefinition def) {+ def.name = cbm_first_line(a, def.name);+ def.qualified_name = cbm_first_line(a, def.qualified_name);+ if (cbm_js_family_path(def.file_path) && cbm_js_name_is_junk(def.name)) {+ return;+ }GROW_ARRAY(arr, a);arr->items[arr->count++] = def;}@@ -1358,14 +1430,88 @@ static void cbm_mark_pp_error_rows(TSNode n, uint8_t *rows, uint32_t row_count,/* Recovery subtraction (#963): tree-sitter error recovery plus the* ERROR-descending def walker often still extract constructs INSIDE a failed* region (verified: a function in an #ifdef-split ERROR region and even a- * `def broken(:` both came back as defs). A region whose every line is- * covered by definitions that START inside it is definitely recovered — its- * constructs ARE in the graph — so flagging it would be a false miss.- * Container defs (Module/Package) are ignored: a file-spanning Module node is- * not evidence the region's constructs survived. Conservative: partially- * covered regions stay flagged. */-static bool cbm_region_is_recovered(uint32_t rs, uint32_t re, const CBMDefArray *defs) {- enum { MAX_COVER_DEFS = 256 };+ * `def broken(:` both came back as defs). The lines a definition that STARTS+ * inside the region covers are therefore in the graph, and only the lines no+ * definition covers can honestly be called missed. Container defs+ * (Module/Package) are ignored: a file-spanning Module node is not evidence+ * the region's constructs survived.+ *+ * This used to be all-or-nothing — a region stayed flagged whole unless every+ * line was covered. On torvalds/linux (2026-09-16 probe) one ERROR node that+ * swallowed the second half of kernel/sched/core.c (lines 5522–11284) survived+ * because of the comment and macro lines between its 286 extracted functions,+ * and the coverage report told a reader 68 % of the scheduler was unindexed.+ * Now the uncovered gaps are reported instead, and a gap holding only blank,+ * comment or preprocessor lines is not a miss at all. */+static uint32_t *cbm_line_offsets(const char *src, int src_len, uint32_t *out_lines) {+ uint32_t lines = 1;+ for (int i = 0; i < src_len; i++) {+ if (src[i] == '\n') {+ lines++;+ }+ }+ uint32_t *offs = (uint32_t *)malloc((size_t)(lines + 1) * sizeof(uint32_t));+ if (!offs) {+ *out_lines = 0;+ return NULL;+ }+ uint32_t n = 0;+ offs[n++] = 0;+ for (int i = 0; i < src_len && n < lines; i++) {+ if (src[i] == '\n') {+ offs[n++] = (uint32_t)i + 1;+ }+ }+ offs[n] = (uint32_t)src_len;+ *out_lines = n;+ return offs;+}++/* A 1-based line that holds nothing a reader would call missed code: blank,+ * a comment line, or a preprocessor directive (the import pass owns #include;+ * #if/#endif carry no construct of their own). */+static bool cbm_line_is_inert(const char *src, const uint32_t *offs, uint32_t nlines,+ uint32_t line) {+ if (!src || !offs || line == 0 || line > nlines) {+ return true;+ }+ const char *p = src + offs[line - 1];+ const char *end = src + offs[line];+ while (p < end && (*p == ' ' || *p == '\t' || *p == '\r')) {+ p++;+ }+ if (p >= end || *p == '\n') {+ return true;+ }+ if (p[0] == '/' && p + 1 < end && (p[1] == '/' || p[1] == '*')) {+ return true;+ }+ return p[0] == '*' || p[0] == '#';+}++static void cbm_regions_emit_gap(cbm_error_regions_t *out, uint32_t gs, uint32_t ge,+ const char *src, const uint32_t *offs, uint32_t nlines) {+ bool live = false;+ for (uint32_t l = gs; l <= ge && !live; l++) {+ live = !cbm_line_is_inert(src, offs, nlines, l);+ }+ if (!live) {+ return;+ }+ if (out->count < CBM_MAX_ERROR_REGIONS) {+ out->starts[out->count] = gs;+ out->ends[out->count] = ge;+ out->count++;+ } else {+ out->dropped++;+ }+}++/* Replace [rs, re] by the sub-ranges no in-region definition covers. */+static void cbm_region_uncovered_gaps(uint32_t rs, uint32_t re, const CBMDefArray *defs,+ const char *src, const uint32_t *offs, uint32_t nlines,+ cbm_error_regions_t *out) {+ enum { MAX_COVER_DEFS = 1024 };uint32_t starts[MAX_COVER_DEFS];uint32_t ends[MAX_COVER_DEFS];int n = 0;@@ -1377,14 +1523,25 @@ static bool cbm_region_is_recovered(uint32_t rs, uint32_t re, const CBMDefArrayif (d->start_line < rs || d->start_line > re) {continue; /* recovery evidence must originate inside the region */}+ /* A one-line definition salvaged from inside an error region is the+ * walker's guess at broken text (`def x(:` comes back as a def, a+ * mis-parsed `static _Thread_local int x` as a Variable named `int`,+ * and Python's synthetic builtins all sit on line 1); only a construct+ * whose body spans lines proves it was understood. Conservative: real+ * one-line variables and macros inside a failed region keep their line+ * flagged. */+ if (d->end_line <= d->start_line) {+ continue;+ }starts[n] = d->start_line;- ends[n] = d->end_line < d->start_line ? d->start_line : d->end_line;+ ends[n] = d->end_line;n++;}if (n == 0) {- return false;+ cbm_regions_emit_gap(out, rs, re, src, offs, nlines);+ return;}- /* Insertion-sort by start, then sweep for gaps in [rs, re]. */+ /* Insertion-sort by start, then sweep and emit the gaps in [rs, re]. */for (int i = 1; i < n; i++) {uint32_t s = starts[i];uint32_t e = ends[i];@@ -1397,16 +1554,18 @@ static bool cbm_region_is_recovered(uint32_t rs, uint32_t re, const CBMDefArraystarts[j + 1] = s;ends[j + 1] = e;}- uint32_t covered_to = rs - 1;+ uint32_t cursor = rs;for (int i = 0; i < n; i++) {- if (starts[i] > covered_to + 1) {- return false; /* uncovered gap */+ if (starts[i] > cursor) {+ cbm_regions_emit_gap(out, cursor, starts[i] - 1, src, offs, nlines);}- if (ends[i] > covered_to) {- covered_to = ends[i];+ if (ends[i] + 1 > cursor) {+ cursor = ends[i] + 1;}}- return covered_to >= re;+ if (cursor <= re) {+ cbm_regions_emit_gap(out, cursor, re, src, offs, nlines);+ }}/* #961: true when 1-based `line` of `src` contains `name` (used to verify a@@ -1598,16 +1757,19 @@ static bool cbm_remap_preprocessed_def(CBMDefinition *def, const CBMPreprocessedreturn true;}-static void cbm_subtract_recovered_regions(cbm_error_regions_t *regs, const CBMDefArray *defs) {- int kept = 0;+static void cbm_subtract_recovered_regions(cbm_error_regions_t *regs, const CBMDefArray *defs,+ const char *src, int src_len) {+ if (regs->count <= 0) {+ return;+ }+ uint32_t nlines = 0;+ uint32_t *offs = cbm_line_offsets(src, src_len, &nlines);+ cbm_error_regions_t out = {{0}, {0}, 0, regs->dropped};for (int i = 0; i < regs->count; i++) {- if (!cbm_region_is_recovered(regs->starts[i], regs->ends[i], defs)) {- regs->starts[kept] = regs->starts[i];- regs->ends[kept] = regs->ends[i];- kept++;- }+ cbm_region_uncovered_gaps(regs->starts[i], regs->ends[i], defs, src, offs, nlines, &out);}- regs->count = kept;+ free(offs);+ *regs = out;}/* #1071: a function-like macro invocation whose argument is a type token@@ -2019,6 +2181,10 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, CTSTree *tree = ts_parser_parse_with_options(parser, NULL, ts_input, opts);uint64_t t1 = now_ns();+ uint64_t parse_cpu_ns = cbm_thread_cpu_time_ns() - cpu_start_ns;+#ifdef CBM_ENABLE_TEST_SEAMS+ t1 += tl_parse_wall_seam_offset_ns; /* the stall seam inflates every wall reading */+#endifif (!tree) {result->has_error = true;@@ -2669,7 +2835,7 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C* splitting a brace inside a recovered function looks unrecovered:* the refinement keeps only the discarded branch, the function starts* above it, and the evidence falls outside the range. */- cbm_subtract_recovered_regions(®s, &result->defs);+ cbm_subtract_recovered_regions(®s, &result->defs, source, source_len);/* Phase 2: cut what is left down to the lines the preprocessed parse* could not explain. */if (pp_line_map) {diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.hindex a7907289a..a00192a18 100644--- a/internal/cbm/cbm.h+++ b/internal/cbm/cbm.h@@ -269,26 +269,31 @@ typedef struct {* calls at 251 MB with most of that empty slots. Readers index it exactly* as before; only `sizeof` changed. */CBMCallArg *args;- int arg_count; // number of captured arguments (<= CBM_MAX_CALL_ARGS)- int loop_depth; // enclosing loop nesting at the call site- int branch_depth; // enclosing branch nesting at the call site- int start_line; // 1-based source line of the call (for def range-match)- uint32_t site_start_byte; // exact AST occurrence span; end > start when present- uint32_t site_end_byte; // exclusive byte offset in the source file- CBMSourceOrigin source_origin; // raw source or C-family preprocessed buffer- bool is_method; // method/member call with an UNRESOLVED receiver. Perl:- // arrow/method call ($obj->m). TS/JS/TSX: member call- // x.foo() whose receiver is not this/super. Python:- // x.foo() where x is not self/cls/super() and is not- // rooted in an imported name. Read by the weak-member- // guard and by the pxc synthetic-carrier dedup key in- // pass_lsp_cross.c. Default false.- bool requires_lsp_resolution; // synthetic semantic candidate (for example an implicit- // C++ operator). Never fall back to textual resolution.- bool callee_is_locally_bound; // bare call foo() whose callee identifier is bound as a- // parameter of an enclosing function, so it cannot be the- // module-level foo. Python only today. Read by the- // weak-local-binding guard. Default false.+ int arg_count; // number of captured arguments (<= CBM_MAX_CALL_ARGS)+ int loop_depth; // enclosing loop nesting at the call site+ int branch_depth; // enclosing branch nesting at the call site+ int start_line; // 1-based source line of the call (for def range-match)+ uint32_t site_start_byte; // exact AST occurrence span; end > start when present+ uint32_t site_end_byte; // exclusive byte offset in the source file+ CBMSourceOrigin source_origin; // raw source or C-family preprocessed buffer+ bool is_method; // method/member call with an UNRESOLVED receiver. Perl:+ // arrow/method call ($obj->m). TS/JS/TSX: member call+ // x.foo() whose receiver is not this/super. Python:+ // x.foo() where x is not self/cls/super() and is not+ // rooted in an imported name. Read by the weak-member+ // guard and by the pxc synthetic-carrier dedup key in+ // pass_lsp_cross.c. Default false.+ bool requires_lsp_resolution; // synthetic semantic candidate (for example an implicit+ // C++ operator). Never fall back to textual resolution.+ bool callee_is_locally_bound; // bare call foo() whose callee identifier is bound as a+ // parameter of an enclosing function, so it cannot be the+ // module-level foo. Python only today. Read by the+ // weak-local-binding guard. Default false.+ bool receiver_is_self_attribute; // Python member call whose receiver is an attribute+ // chain rooted at self/cls but not self/cls itself+ // (self.compiler.apply_converters()). An object the+ // class owns, not a parameter: read by the weak-member+ // guard's unique-name exemption. Default false.} CBMCall;typedef struct {diff --git a/internal/cbm/extract_calls.c b/internal/cbm/extract_calls.cindex 728059c71..83820fdc6 100644--- a/internal/cbm/extract_calls.c+++ b/internal/cbm/extract_calls.c@@ -2068,6 +2068,14 @@ static void extract_call_args(CBMExtractCtx *ctx, TSNode args, CBMCall *call) {for (uint32_t ai = 0; ai < argc && call->arg_count < CBM_MAX_CALL_ARGS; ai++) {TSNode arg_node = ts_node_named_child(args, ai);const char *ak = ts_node_type(arg_node);+ /* tree-sitter lists a comment inside the argument list as a named+ * child (Java block_comment/line_comment, C-family comment). It is+ * not an argument: taken as one, a leading block comment became+ * args[0] and the Route pass read its text as a URL. */+ if (strcmp(ak, "comment") == 0 || strcmp(ak, "line_comment") == 0 ||+ strcmp(ak, "block_comment") == 0) {+ continue;+ }if (!call->args) {call->args = cbm_arena_calloc(ctx->arena, CBM_MAX_CALL_ARGS * sizeof(CBMCallArg));if (!call->args) {@@ -2965,6 +2973,28 @@ static char *resolve_objectscript_instance_call(CBMArena *a, TSNode node, const* statically-known type here, so the call must not bind by short name alone.* Note `self.client.send()` is NOT exempt: the receiver is `self.client`, an* attribute of unknown type, not `self` itself. */+/* True when a Python attribute-call receiver is an attribute chain ROOTED at+ * self/cls but is not self/cls itself: `self.compiler.apply_converters()` has+ * receiver `self.compiler`, an object the class owns. The weak-member guard's+ * unique-name exemption keys on this shape (see cbm_weak_member_unique_name_+ * exempt): a bare parameter (`accelerator.backward()`) carries no ownership+ * evidence and stays suppressed. Direct `self.m()` is already exempt via+ * python_receiver_is_exempt and is deliberately NOT flagged here. */+static bool python_receiver_rooted_at_self(CBMExtractCtx *ctx, TSNode receiver) {+ if (ts_node_is_null(receiver) || strcmp(ts_node_type(receiver), "attribute") != 0) {+ return false;+ }+ TSNode root = receiver;+ while (!ts_node_is_null(root) && strcmp(ts_node_type(root), "attribute") == 0) {+ root = ts_node_child_by_field_name(root, TS_FIELD("object"));+ }+ if (ts_node_is_null(root) || strcmp(ts_node_type(root), "identifier") != 0) {+ return false;+ }+ char *name = cbm_node_text(ctx->arena, root, ctx->source);+ return name && (strcmp(name, "self") == 0 || strcmp(name, "cls") == 0);+}+static bool python_receiver_is_exempt(CBMExtractCtx *ctx, TSNode receiver) {if (ts_node_is_null(receiver)) {return false;@@ -3695,6 +3725,7 @@ CBMInvocationDescriptor handle_calls(CBMExtractCtx *ctx, TSNode node, const CBMLif (!ts_node_is_null(fn) && strcmp(ts_node_type(fn), "attribute") == 0) {TSNode obj = ts_node_child_by_field_name(fn, TS_FIELD("object"));call.is_method = !python_receiver_is_exempt(ctx, obj);+ call.receiver_is_self_attribute = python_receiver_rooted_at_self(ctx, obj);} else if (!ts_node_is_null(fn) && strcmp(ts_node_type(fn), "identifier") == 0) {call.callee_is_locally_bound = python_callee_is_bound_parameter(ctx, state, fn);}diff --git a/internal/cbm/service_patterns.c b/internal/cbm/service_patterns.cindex e3740f5aa..0dd404877 100644--- a/internal/cbm/service_patterns.c+++ b/internal/cbm/service_patterns.c@@ -714,6 +714,25 @@ static const char *strip_string_delimiters(const char *literal, char *buf, size_return buf;}+/* A comment opens with the slash a route opens with, and an argument list+ * that starts with one handed three Java block comments to the Route pass as+ * URLs (elasticsearch, 2026-09-16). The wildcard route (slash-star alone) is a+ * path, so the block-comment shape needs its closing star-slash; a route+ * literal never holds a line break. */+bool cbm_service_pattern_is_comment_text(const char *text) {+ if (!text || text[0] != '/') {+ return false;+ }+ if (strchr(text, '\n') != NULL || strchr(text, '\r') != NULL) {+ return true;+ }+ size_t n = strlen(text);+ if (text[1] == '*' && n >= 4 && text[n - 2] == '*' && text[n - 1] == '/') {+ return true;+ }+ return text[1] == '/' && (text[2] == ' ' || text[2] == '\t');+}+bool cbm_service_pattern_is_http_route_literal(const char *literal, const char *callee_name) {char path_buf[1024];const char *path = strip_string_delimiters(literal, path_buf, sizeof(path_buf));@@ -729,6 +748,9 @@ bool cbm_service_pattern_is_http_route_literal(const char *literal, const char *if (path[0] != '/') {return false;}+ if (cbm_service_pattern_is_comment_text(path)) {+ return false;+ }if (callee_is_delimiter_or_filesystem_builder(callee_name)) {return false;}diff --git a/internal/cbm/service_patterns.h b/internal/cbm/service_patterns.hindex 4642a08de..d9a93c251 100644--- a/internal/cbm/service_patterns.h+++ b/internal/cbm/service_patterns.h@@ -48,6 +48,12 @@ bool cbm_service_pattern_is_global_fetch(const char *callee_name);* Rejects filesystem paths and non-HTTP string consumers. */bool cbm_service_pattern_is_http_route_literal(const char *literal, const char *callee_name);+/* True when text that reached a path slot is a source comment rather than a+ * path: a block comment (slash-star … star-slash), a line comment (slash-slash+ * followed by a space), or any text with a line break. The wildcard route+ * (slash-star alone) is a path. */+bool cbm_service_pattern_is_comment_text(const char *text);+/* Per-worker TLS cache for cbm_service_pattern_match results. The* pattern matcher runs once per resolved CALL edge in emit_service_* edge — that's 6 pattern lists × ~30 patterns × strstr per call ≈diff --git a/src/cli/cli.c b/src/cli/cli.cindex 8645fbe56..b59a894a6 100644--- a/src/cli/cli.c+++ b/src/cli/cli.c@@ -13752,6 +13752,32 @@ static void cli_add_typed(yyjson_mut_doc *out, yyjson_mut_val *obj, const char *arr = yyjson_mut_arr(out);yyjson_mut_obj_add(obj, yyjson_mut_strcpy(out, key), arr);}+ /* The help prints `--paths <array>`, and a caller who writes the+ * array literally — `--paths '["lib","t"]'` — used to get ONE element+ * holding that literal text (2026-09-16 probe: check_index_coverage+ * reported the fake path `["lib","t"]`). A value that parses as a JSON+ * array contributes its elements; anything else is one element. */+ if (have_value && value && value[0] == '[') {+ yyjson_doc *lit = yyjson_read(value, strlen(value), 0);+ yyjson_val *lit_root = lit ? yyjson_doc_get_root(lit) : NULL;+ if (lit_root && yyjson_is_arr(lit_root)) {+ size_t idx;+ size_t max;+ yyjson_val *elem;+ yyjson_arr_foreach(lit_root, idx, max, elem) {+ if (yyjson_is_str(elem)) {+ yyjson_mut_arr_add_strcpy(out, arr, yyjson_get_str(elem));+ } else {+ yyjson_mut_arr_add_val(arr, yyjson_val_mut_copy(out, elem));+ }+ }+ yyjson_doc_free(lit);+ return;+ }+ if (lit) {+ yyjson_doc_free(lit);+ }+ }yyjson_mut_arr_add_strcpy(out, arr, have_value ? value : "");return;}diff --git a/src/cypher/cypher.c b/src/cypher/cypher.cindex 73592a4b8..dd2544fd0 100644--- a/src/cypher/cypher.c+++ b/src/cypher/cypher.c@@ -5014,8 +5014,104 @@ static void execute_return_clause(cbm_query_t *q, cbm_return_clause_t *ret, bindlimit_is_engine_budget);}+/* ── Planner: seed a single-hop pattern from its selective end ──────────────+ *+ * The executor scans pattern node 0 and expands from there. Written as+ * `MATCH (a)-[:CALLS]->(b) WHERE b.name = '_printk'`, that scans every node+ * in the store before the filter on `b` can discard any — on an 8.5 M node+ * kernel graph the query hit the execution-time limit while the anchored+ * spelling `MATCH (b:Function {name:'_printk'})<-[:CALLS]-(a)` answered in+ * seconds (2026-09-16 probe). A reader should not have to know which end to+ * write first: when the far node carries an equality on name/qualified_name,+ * an inline property, or a label and the near node carries less, the pattern+ * is walked from the far end with the relationship direction inverted. The+ * result set is identical; only the enumeration order changes. Restricted to+ * one single-relationship pattern with an explicit RETURN, and never to an+ * OPTIONAL MATCH, whose anchor is part of its meaning. */+static int cypher_cond_selectivity(const cbm_condition_t *c, const char *var) {+ if (!c || !c->variable || !var || strcmp(c->variable, var) != 0 || c->negated) {+ return 0;+ }+ if (!c->op || strcmp(c->op, "=") != 0 || !c->property) {+ return 0;+ }+ return (strcmp(c->property, "name") == 0 || strcmp(c->property, "qualified_name") == 0) ? 3 : 2;+}++static int cypher_expr_selectivity(const cbm_expr_t *e, const char *var) {+ if (!e) {+ return 0;+ }+ if (e->type == EXPR_CONDITION) {+ return cypher_cond_selectivity(&e->cond, var);+ }+ if (e->type == EXPR_AND) {+ int l = cypher_expr_selectivity(e->left, var);+ int r = cypher_expr_selectivity(e->right, var);+ return l > r ? l : r;+ }+ return 0; /* OR / NOT / XOR: no single equality to seed from */+}++static int cypher_node_selectivity(const cbm_node_pattern_t *n, const cbm_where_clause_t *w) {+ int s = 0;+ for (int i = 0; i < n->prop_count; i++) {+ const char *k = n->props[i].key;+ int v = (k && (strcmp(k, "name") == 0 || strcmp(k, "qualified_name") == 0)) ? 3 : 2;+ if (v > s) {+ s = v;+ }+ }+ if (w && n->variable) {+ int v = 0;+ if (w->root) {+ v = cypher_expr_selectivity(w->root, n->variable);+ } else if (!w->op || strcmp(w->op, "AND") == 0) {+ for (int i = 0; i < w->count; i++) {+ int c = cypher_cond_selectivity(&w->conditions[i], n->variable);+ if (c > v) {+ v = c;+ }+ }+ }+ if (v > s) {+ s = v;+ }+ }+ if (s == 0 && n->label) {+ s = 1;+ }+ return s;+}++static void cypher_plan_seed_from_selective_end(cbm_query_t *q) {+ if (!q || q->pattern_count != 1 || !q->ret || (q->pattern_optional && q->pattern_optional[0])) {+ return;+ }+ cbm_pattern_t *p = &q->patterns[0];+ if (p->rel_count != 1 || p->node_count != 2) {+ return;+ }+ if (cypher_node_selectivity(&p->nodes[1], q->where) <=+ cypher_node_selectivity(&p->nodes[0], q->where)) {+ return;+ }+ cbm_node_pattern_t tmp = p->nodes[0];+ p->nodes[0] = p->nodes[1];+ p->nodes[1] = tmp;+ cbm_rel_pattern_t *r = &p->rels[0];+ if (r->direction && strcmp(r->direction, "outbound") == 0) {+ free((void *)r->direction);+ r->direction = heap_strdup("inbound");+ } else if (r->direction && strcmp(r->direction, "inbound") == 0) {+ free((void *)r->direction);+ r->direction = heap_strdup("outbound");+ }+}+static int execute_single(cbm_store_t *store, cbm_query_t *q, const char *project, int max_rows,result_builder_t *rb) {+ cypher_plan_seed_from_selective_end(q);cbm_pattern_t *pat0 = &q->patterns[0];/* Step 1: Scan initial nodes */diff --git a/src/foundation/str_util.c b/src/foundation/str_util.cindex c8aec01af..9f65c079a 100644--- a/src/foundation/str_util.c+++ b/src/foundation/str_util.c@@ -310,6 +310,33 @@ bool cbm_validate_project_name(const char *name) {return true;}+int cbm_utf8_trim_partial(char *buf) {+ if (!buf) {+ return 0;+ }+ int pos = (int)strlen(buf);+ if (pos == 0) {+ return 0;+ }+ /* Walk back over continuation bytes to the lead byte; drop the sequence+ * when fewer continuation bytes follow it than its lead byte announces. */+ int back = pos - 1;+ int cont = 0;+ while (back >= 0 && ((unsigned char)buf[back] & 0xC0) == 0x80) {+ back--;+ cont++;+ }+ if (back >= 0) {+ unsigned char lead = (unsigned char)buf[back];+ int need = lead >= 0xF0 ? 3 : lead >= 0xE0 ? 2 : lead >= 0xC0 ? 1 : 0;+ if (need > cont) {+ pos = back;+ buf[pos] = '\0';+ }+ }+ return pos;+}+int cbm_json_escape(char *buf, int bufsize, const char *src) {if (!buf || bufsize <= 0) {return 0;@@ -319,7 +346,8 @@ int cbm_json_escape(char *buf, int bufsize, const char *src) {return 0;}int pos = 0;- for (int i = 0; src[i] && pos < bufsize - JSON_NUL_RESERVE; i++) {+ int i = 0;+ for (; src[i] && pos < bufsize - JSON_NUL_RESERVE; i++) {unsigned char c = (unsigned char)src[i];if (c == '"' || c == '\\') {if (pos + JSON_ESC_LEN > bufsize - JSON_NUL_RESERVE) {@@ -356,5 +384,11 @@ int cbm_json_escape(char *buf, int bufsize, const char *src) {}}buf[pos] = '\0';+ /* A truncated output must never end inside a multibyte UTF-8 sequence: a+ * callee cut mid-character persisted bytes SQLite cannot decode as text+ * (2026-09-16 probe: nine CALLS rows across rust, java and typescript). */+ if (src[i] != '\0') {+ pos = cbm_utf8_trim_partial(buf);+ }return pos;}diff --git a/src/foundation/str_util.h b/src/foundation/str_util.hindex e0ff46057..afaeb6ba0 100644--- a/src/foundation/str_util.h+++ b/src/foundation/str_util.h@@ -91,9 +91,16 @@ bool cbm_validate_project_name(const char *name);} \} while (0)+/* Drop a trailing INCOMPLETE UTF-8 sequence from a NUL-terminated buffer in+ * place (a lead byte whose continuation bytes were cut off). Returns the new+ * length. Complete sequences and ASCII are left untouched. Use after any+ * byte-count truncation of text that will be stored or serialised. */+int cbm_utf8_trim_partial(char *buf);+/* Escape a string for safe embedding in JSON: escapes " \ and control chars.* Writes into buf (including NUL). Returns number of chars written (excl NUL).- * If buf is too small, output is truncated but always NUL-terminated. */+ * If buf is too small, output is truncated but always NUL-terminated, and it+ * never ends inside a multibyte UTF-8 sequence. */int cbm_json_escape(char *buf, int bufsize, const char *src);#endif /* CBM_STR_UTIL_H */diff --git a/src/mcp/mcp.c b/src/mcp/mcp.cindex 7bfca8d7a..ca88bdb52 100644--- a/src/mcp/mcp.c+++ b/src/mcp/mcp.c@@ -3762,6 +3762,8 @@ enum {BM25_BIND_OFFSET = 4,BM25_BIND_INNER = 5,BM25_BIND_FILE = 6,+ BM25_BIND_LABEL = 7,+ BM25_BIND_EXACT = 8,BM25_SQL_AUTO_LEN = -1,/* Inner FTS5 candidate cap. SQLite can early-terminate a plain FTS5 query* (no JOIN/WHERE on outer table) of the form:@@ -4019,8 +4021,8 @@ static char *bm25_render(const bm25_output_row_t *rows, int returned, int total,* Returns NULL if FTS5 is unavailable or the query produced no usable tokens,* in which case the caller falls back to the regex-based search path. */static char *bm25_search(cbm_store_t *store, const char *project, const char *query,- const char *file_pattern, int limit, int offset, bool tree_format,- size_t max_output_bytes) {+ const char *file_pattern, const char *label, int limit, int offset,+ bool tree_format, size_t max_output_bytes) {sqlite3 *db = cbm_store_get_db(store);if (!db) {return NULL;@@ -4046,9 +4048,18 @@ static char *bm25_search(cbm_store_t *store, const char *project, const char *qu* because no outer predicate blocks it. We fetch BM25_INNER_LIMIT top candidates* from the FTS5 index, then join/filter/boost only those rows. bm25() returns a* NEGATIVE score (lower = more relevant). */+ /* Exact-name tier (2026-09-16 probe): a definition whose NAME is the query+ * outranks every partial hit. BM25 term frequency otherwise rewards a long+ * test-method name that repeats the token — `table references table with+ * same name` — over the `Table` class itself, and the label tiers below+ * then push the class's own methods above it (Method 10 > Class 5). The+ * definition the reader asked for by name comes first; case-insensitive+ * exact spelling comes next; everything else keeps its BM25 order. */const char *sql ="SELECT n.id, n.label, n.name, n.qualified_name, n.file_path, n.start_line, n.end_line, "" (fts.base_rank "+ " - CASE WHEN n.name = ?8 THEN 30.0 "+ " WHEN lower(n.name) = lower(?8) THEN 20.0 ELSE 0.0 END "" - CASE WHEN n.label IN ('Function','Method') THEN 10.0 "" WHEN n.label = 'Route' THEN 8.0 "" WHEN n.label IN (" CBM_SQL_TYPE_LIKE_LABELS ") THEN 5.0 "@@ -4070,6 +4081,10 @@ static char *bm25_search(cbm_store_t *store, const char *project, const char *qu* must be changed together or results desynchronise from counts. */" AND n.label NOT IN ('File','Folder','Variable','Project') "" AND (?6 IS NULL OR n.file_path LIKE ?6) "+ /* The caller's label filter applies in query mode exactly as it does+ * in the structural mode (2026-09-16 probe: `label=Class` was ignored+ * here and five Methods came back). MIRRORED in the count query. */+ " AND (?7 IS NULL OR n.label = ?7) "/* rank ties are common (boosted floats) — the id tie-break makes* offset pages contractually stable across calls. */"ORDER BY rank, n.id "@@ -4090,6 +4105,12 @@ static char *bm25_search(cbm_store_t *store, const char *project, const char *qu} else {sqlite3_bind_null(stmt, BM25_BIND_FILE);}+ if (label && label[0]) {+ sqlite3_bind_text(stmt, BM25_BIND_LABEL, label, BM25_SQL_AUTO_LEN, MCP_SQLITE_TRANSIENT);+ } else {+ sqlite3_bind_null(stmt, BM25_BIND_LABEL);+ }+ sqlite3_bind_text(stmt, BM25_BIND_EXACT, query, BM25_SQL_AUTO_LEN, MCP_SQLITE_TRANSIENT);/* Count hits within the same inner-limit window — capped at BM25_INNER_LIMIT.* Uses the identical subquery structure so the FTS5 early-exit applies here too. */@@ -4107,6 +4128,7 @@ static char *bm25_search(cbm_store_t *store, const char *project, const char *qu* not describe the rows returned. */" AND n.label NOT IN ('File','Folder','Variable','Project')"" AND (?6 IS NULL OR n.file_path LIKE ?6)"+ " AND (?7 IS NULL OR n.label = ?7)"")";sqlite3_stmt *cs = NULL;if (sqlite3_prepare_v2(db, count_sql, BM25_SQL_AUTO_LEN, &cs, NULL) == SQLITE_OK) {@@ -4121,6 +4143,12 @@ static char *bm25_search(cbm_store_t *store, const char *project, const char *qu} else {sqlite3_bind_null(cs, BM25_BIND_FILE);}+ if (label && label[0]) {+ sqlite3_bind_text(cs, BM25_BIND_LABEL, label, BM25_SQL_AUTO_LEN,+ MCP_SQLITE_TRANSIENT);+ } else {+ sqlite3_bind_null(cs, BM25_BIND_LABEL);+ }if (sqlite3_step(cs) == SQLITE_ROW) {total = sqlite3_column_int(cs, 0);}@@ -4153,10 +4181,10 @@ static char *bm25_search(cbm_store_t *store, const char *project, const char *quint row_count = 0;while (rows && row_count < row_cap && sqlite3_step(stmt) == SQLITE_ROW) {const char *qn = (const char *)sqlite3_column_text(stmt, BM25_COL_QN);- const char *label = (const char *)sqlite3_column_text(stmt, BM25_COL_LABEL);+ const char *row_label = (const char *)sqlite3_column_text(stmt, BM25_COL_LABEL);const char *file = (const char *)sqlite3_column_text(stmt, BM25_COL_FILE);rows[row_count].qualified_name = heap_strdup(qn ? qn : "");- rows[row_count].label = heap_strdup(label ? label : "");+ rows[row_count].label = heap_strdup(row_label ? row_label : "");rows[row_count].file_path = heap_strdup(file ? file : "");rows[row_count].start_line = sqlite3_column_int(stmt, BM25_COL_START);rows[row_count].end_line = sqlite3_column_int(stmt, BM25_COL_END);@@ -5089,9 +5117,11 @@ static char *handle_search_graph(cbm_mcp_server_t *srv, const char *args) {}if (query && query[0]) {char *q_file_pattern = cbm_mcp_get_string_arg(args, "file_pattern");- char *bm25_json = bm25_search(store, project, query, q_file_pattern, limit, offset,+ char *q_label = cbm_mcp_get_string_arg(args, "label");+ char *bm25_json = bm25_search(store, project, query, q_file_pattern, q_label, limit, offset,!json_format, max_output_bytes);free(q_file_pattern);+ free(q_label);if (bm25_json) {free(query);free(project);diff --git a/src/pipeline/pass_calls.c b/src/pipeline/pass_calls.cindex c9744dda2..84958954c 100644--- a/src/pipeline/pass_calls.c+++ b/src/pipeline/pass_calls.c@@ -626,15 +626,29 @@ static int resolve_single_call(cbm_pipeline_ctx_t *ctx, CBMCall *call,* reintroduce the #592/#606 false-edge class for .ets files. */bool suppress_weak_member = lang == CBM_LANG_PYTHON || lang == CBM_LANG_JAVASCRIPT ||lang == CBM_LANG_TYPESCRIPT || lang == CBM_LANG_TSX ||- lang == CBM_LANG_ARKTS;+ lang == CBM_LANG_ARKTS ||+ /* Files whose calls are embedded JS/TS (<script>+ * bodies): the calls carry the JS receiver flag+ * but the FILE language gated them out, so+ * generated Dokka pages bound localStorage.getItem+ * to a docs bundle (2026-09-16 probe: 4,207 junk+ * edges on JetBrains/Exposed). */+ lang == CBM_LANG_HTML || lang == CBM_LANG_VUE ||+ lang == CBM_LANG_SVELTE || lang == CBM_LANG_ASTRO;/* Bare-call local-binding suppression. A member call has a receiver the* guard above can reason about; a bare `run()` has none, so that guard* cannot see this class at all. Python-only today because the extraction* flag is set only for Python — this gate MUST match pass_parallel.c's* exactly, for the same divergence reason noted above. */bool suppress_weak_local_binding = lang == CBM_LANG_PYTHON;+ /* The member guard's one exemption (Python, self/cls-rooted receiver,+ * unique_name, not a builtin type's method) — see+ * cbm_weak_member_unique_name_exempt. MUST match pass_parallel.c exactly. */bool drop_plain_call =- cbm_suppress_weak_member_match(suppress_weak_member, call->is_method, res.strategy) ||+ (cbm_suppress_weak_member_match(suppress_weak_member, call->is_method, res.strategy) &&+ !cbm_weak_member_unique_name_exempt(lang == CBM_LANG_PYTHON,+ call->receiver_is_self_attribute, call->callee_name,+ res.strategy)) ||cbm_suppress_weak_local_binding_call(suppress_weak_local_binding,call->callee_is_locally_bound, res.strategy);diff --git a/src/pipeline/pass_parallel.c b/src/pipeline/pass_parallel.cindex dbf459814..e85ad015f 100644--- a/src/pipeline/pass_parallel.c+++ b/src/pipeline/pass_parallel.c@@ -1874,6 +1874,10 @@ typedef struct {static void sanitize_expr(char *expr_buf, const char *expr) {if (expr) {snprintf(expr_buf, 128, "%.*s", 120, expr);+ /* The 120-byte cut can land inside a multibyte character; a torn+ * sequence persisted as invalid UTF-8 in edge properties (2026-09-16+ * probe: rust, java, typescript stores). */+ cbm_utf8_trim_partial(expr_buf);for (char *p = expr_buf; *p; p++) {if (*p == '"') {*p = '\'';@@ -1960,10 +1964,18 @@ static bool is_path_keyword(const char *keyword) {return false;}+/* A route path is one line that opens with a slash. A block or line comment+ * opens with a slash too, and an argument list that starts with one used to+ * hand the comment text to the Route pass (three Java block comments became+ * Route nodes on elasticsearch, 2026-09-16). */+static bool is_route_path_shaped(const char *val) {+ return val && val[0] == '/' && !cbm_service_pattern_is_comment_text(val);+}+static const char *find_route_path_in_args(const CBMCall *call, const char **out_handler) {*out_handler = NULL;/* 1. First string arg starting with / */- if (call->first_string_arg && call->first_string_arg[0] == '/') {+ if (is_route_path_shaped(call->first_string_arg)) {*out_handler = call->second_arg_name;return call->first_string_arg;}@@ -1972,7 +1984,7 @@ static const char *find_route_path_in_args(const CBMCall *call, const char **outfor (int ai = 0; ai < call->arg_count && !found; ai++) {const CBMCallArg *ca = &call->args[ai];const char *val = ca->value ? ca->value : ca->expr;- if (!val || val[0] != '/') {+ if (!is_route_path_shaped(val)) {continue;}if ((ca->keyword && is_path_keyword(ca->keyword)) || (!ca->keyword && ca->index == 0)) {@@ -2931,12 +2943,19 @@ static void resolve_file_calls(resolve_ctx_t *rc, resolve_worker_state_t *ws, CB* note there. ArkTS belongs to the JS/TS family (#1842). */bool suppress_weak_member = lang == CBM_LANG_PYTHON || lang == CBM_LANG_JAVASCRIPT ||lang == CBM_LANG_TYPESCRIPT || lang == CBM_LANG_TSX ||- lang == CBM_LANG_ARKTS;+ lang == CBM_LANG_ARKTS ||+ /* embedded-script hosts — see pass_calls.c */+ lang == CBM_LANG_HTML || lang == CBM_LANG_VUE ||+ lang == CBM_LANG_SVELTE || lang == CBM_LANG_ASTRO;/* Bare-call local-binding suppression — see the note in pass_calls.c.* This gate MUST stay identical to the one there. */bool suppress_weak_local_binding = lang == CBM_LANG_PYTHON;+ /* The member guard's one exemption — MUST match pass_calls.c exactly. */bool drop_plain_call =- cbm_suppress_weak_member_match(suppress_weak_member, call->is_method, res.strategy) ||+ (cbm_suppress_weak_member_match(suppress_weak_member, call->is_method, res.strategy) &&+ !cbm_weak_member_unique_name_exempt(lang == CBM_LANG_PYTHON,+ call->receiver_is_self_attribute,+ call->callee_name, res.strategy)) ||cbm_suppress_weak_local_binding_call(suppress_weak_local_binding,call->callee_is_locally_bound, res.strategy);diff --git a/src/pipeline/pass_pkgmap.c b/src/pipeline/pass_pkgmap.cindex 4715a9275..bc534c583 100644--- a/src/pipeline/pass_pkgmap.c+++ b/src/pipeline/pass_pkgmap.c@@ -1599,6 +1599,49 @@ static bool is_c_family_source(const char *source_rel) {return false;}+/* Directory depth of a repo-relative path: how many directories sit above it. */+static int include_path_depth(const char *path) {+ int depth = 0;+ for (const char *p = path; *p; p++) {+ if (*p == '/' || *p == '\\') {+ depth++;+ }+ }+ return depth;+}++/* Total order among nodes whose file path ends with the include path. The+ * by-name hits arrive in node-registration order, which under parallel+ * extraction is the workers' merge order and differs run to run; taking the+ * first hit made `#include <linux/device.h>` target include/linux/device.h in+ * one index of the kernel and tools/virtio/linux/device.h in the next (5,821+ * IMPORTS edges moved, and every CALLS edge resolved through those files'+ * import maps moved with them). The include names a file, so a File node+ * outranks a symbol declared in it; among files the least nested path wins+ * (include/ over tools/virtio/), then the smaller path, then the smaller QN+ * — a function of the candidate set alone (O9). */+static bool include_target_outranks(const cbm_gbuf_node_t *cand, const cbm_gbuf_node_t *best) {+ if (!best) {+ return true;+ }+ bool cand_file = strcmp(cand->label, "File") == 0;+ bool best_file = strcmp(best->label, "File") == 0;+ if (cand_file != best_file) {+ return cand_file;+ }+ int cd = include_path_depth(cand->file_path);+ int bd = include_path_depth(best->file_path);+ if (cd != bd) {+ return cd < bd;+ }+ int by_path = strcmp(cand->file_path, best->file_path);+ if (by_path != 0) {+ return by_path < 0;+ }+ return cand->qualified_name && best->qualified_name &&+ strcmp(cand->qualified_name, best->qualified_name) < 0;+}+static const cbm_gbuf_node_t *resolve_exact_file_node(const cbm_pipeline_ctx_t *ctx,const char *file_path,const char *source_file_qn) {@@ -1651,18 +1694,12 @@ static const cbm_gbuf_node_t *resolve_exact_file_node(const cbm_pipeline_ctx_t *strcmp(cand->qualified_name, source_file_qn) == 0) {continue;}- if (strcmp(cand->label, "File") == 0) {- return cand;- }- if (!best) {+ if (include_target_outranks(cand, best)) {best = cand;}}- if (best) {- return best;- }}- return NULL;+ return best;}static const cbm_gbuf_node_t *resolve_header_include(const cbm_pipeline_ctx_t *ctx,diff --git a/src/pipeline/pipeline.h b/src/pipeline/pipeline.hindex 733e7ea8a..e5a672cb0 100644--- a/src/pipeline/pipeline.h+++ b/src/pipeline/pipeline.h@@ -294,6 +294,20 @@ bool cbm_perl_suppress_generic_match(bool is_perl, bool is_method, const char *c* Pure; unit-tested in test_registry.c. */bool cbm_suppress_weak_member_match(bool enabled, bool is_method, const char *strategy);+/* True if `name` is a method of a Python builtin type (str/bytes/list/dict/set/+ * file) or a builtin function seen as an attribute call. A language fact, kept+ * as a sorted table like the Perl builtins. */+bool cbm_python_is_builtin_member(const char *name);++/* The member guard's exemption: a Python member call whose receiver is an+ * attribute chain rooted at self/cls (an object the class owns), whose callee has+ * exactly one project definition (strategy unique_name) and is not a builtin+ * type's own method keeps its edge. Combine at the call sites as+ * `suppress && !exempt`; both pass_calls.c and pass_parallel.c must do the same.+ * Pure; unit-tested in test_registry.c. */+bool cbm_weak_member_unique_name_exempt(bool is_python, bool receiver_is_self_attribute,+ const char *callee_name, const char *strategy);+/* Bare-call counterpart of the guard above. True when a resolved BARE call edge* binds a callee that is shadowed by an enclosing parameter, and the match came* from a weak short-name strategy — so the edge is fabricated by constructiondiff --git a/src/pipeline/registry.c b/src/pipeline/registry.cindex f052f80c4..c99c72d8d 100644--- a/src/pipeline/registry.c+++ b/src/pipeline/registry.c@@ -229,6 +229,37 @@ static int candidate_score(const char *candidate_qn, const char *module_qn, intreturn score;}+/* Number of '.'-separated segments in a QN: how deeply the definition is+ * nested (file depth + enclosing types). */+static int qn_depth(const char *qn) {+ int depth = 1;+ for (const char *p = qn; *p; p++) {+ if (*p == '.') {+ depth++;+ }+ }+ return depth;+}++/* Total order among candidates that tie on candidate_score. The registry's+ * by-name bucket is in registration order, which follows the file list; a+ * tie broken by bucket position made the resolved target a function of+ * that order (kernel: 632 CALLS edges differed between two indexes of the+ * same tree, `dev_name` flipping between twenty same-named struct fields+ * and unresolved, `sg_set_buf` between include/linux and tools/virtio).+ * The rule: the least nested definition wins (a top-level function over a+ * same-named member two types deep, include/linux over tools/virtio/linux),+ * then the lexicographically smaller QN — a pure function of the candidate+ * set, never of the order it was built in (O9). */+static bool candidate_outranks_on_tie(const char *candidate, const char *best) {+ int cd = qn_depth(candidate);+ int bd = qn_depth(best);+ if (cd != bd) {+ return cd < bd;+ }+ return strcmp(candidate, best) < 0;+}+/* Pick candidate with highest composite score (test-deprioritization + namespace* proximity). `is_test_flags` is the candidates' cached test verdicts, or NULL* when the caller has none (a filtered subset carries its own copy). */@@ -239,7 +270,8 @@ static const char *best_by_import_distance(const char **candidates, const uint8_for (int i = 0; i < count; i++) {int score =candidate_score(candidates[i], module_qn, is_test_flags ? (int)is_test_flags[i] : -1);- if (score > best_score) {+ if (score > best_score ||+ (score == best_score && best && candidate_outranks_on_tie(candidates[i], best))) {best_score = score;best = candidates[i];}@@ -559,6 +591,84 @@ bool cbm_suppress_weak_member_match(bool enabled, bool is_method, const char *streturn weak_short_name_strategy(strategy);}+/* ── Python builtin-type members ─────────────────────────────────────────+ * Methods of Python's builtin types (str, bytes, list, dict, set, file objects)+ * plus the builtin functions that appear as attribute calls. Like PERL_BUILTINS+ * this is a fact about the LANGUAGE, not about corpus fashion: a member call+ * whose name is a builtin's own method — `parts.extend(...)`, `line.strip()`,+ * `d.items()` — is that builtin's method whenever the receiver is untyped, so a+ * project symbol that merely shares the spelling must not bind. MUST stay+ * sorted ASCII-ascending for bsearch. */+static const char *const PYTHON_BUILTIN_MEMBERS[] = {+ "add", "append", "capitalize",+ "casefold", "center", "clear",+ "close", "copy", "count",+ "decode", "difference", "discard",+ "encode", "endswith", "expandtabs",+ "extend", "fileno", "find",+ "flush", "format", "get",+ "index", "insert", "intersection",+ "isalnum", "isalpha", "isdecimal",+ "isdigit", "isidentifier", "islower",+ "isnumeric", "isprintable", "isspace",+ "istitle", "isupper", "issubset",+ "issuperset", "items", "join",+ "keys", "ljust", "lower",+ "lstrip", "partition", "pop",+ "popitem", "print", "read",+ "readable", "readline", "readlines",+ "remove", "replace", "reverse",+ "rfind", "rindex", "rjust",+ "rpartition", "rsplit", "rstrip",+ "seek", "setdefault", "sort",+ "split", "splitlines", "startswith",+ "strip", "swapcase", "symmetric_difference",+ "tell", "title", "truncate",+ "union", "update", "upper",+ "values", "writable", "write",+ "writelines", "zfill",+};++static int python_builtin_member_cmp(const void *key, const void *elem) {+ return strcmp((const char *)key, *(const char *const *)elem);+}++bool cbm_python_is_builtin_member(const char *name) {+ if (!name || !name[0]) {+ return false;+ }+ return bsearch(name, PYTHON_BUILTIN_MEMBERS,+ sizeof(PYTHON_BUILTIN_MEMBERS) / sizeof(PYTHON_BUILTIN_MEMBERS[0]),+ sizeof(PYTHON_BUILTIN_MEMBERS[0]), python_builtin_member_cmp) != NULL;+}++/* The member guard's one exemption. A Python member call whose receiver could+ * not be typed still carries real evidence when three facts line up: the callee+ * name has exactly ONE definition in the whole project (strategy unique_name),+ * the receiver is an attribute chain rooted at self/cls — an object the class+ * owns, not a parameter handed in — and the name is not a builtin type's own+ * method. `self.compiler.apply_converters()` names the only apply_converters in+ * django and nothing else it could mean exists. Measured on django/django+ * (v0.10.8 → v0.11.0 A/B, 2026-09-16): the unconditional guard dropped 800 such+ * self-rooted edges, every sampled one a real call in the source. A bare+ * parameter receiver (`accelerator.backward()`, #1276's own case) carries no+ * ownership evidence and stays suppressed, as does every builtin-member name+ * (`self.parts.extend()`). Python only: the JS/TS family keeps the TS-LSP trade+ * recorded in the resolution probe. Pure; unit-tested in test_registry.c. */+bool cbm_weak_member_unique_name_exempt(bool is_python, bool receiver_is_self_attribute,+ const char *callee_name, const char *strategy) {+ if (!is_python || !receiver_is_self_attribute) {+ return false;+ }+ if (!strategy || strcmp(strategy, "unique_name") != 0) {+ return false;+ }+ if (!callee_name || !callee_name[0]) {+ return false;+ }+ return !cbm_python_is_builtin_member(simple_name(callee_name));+}+/* Bare-call counterpart of the member guard above. A Python call `foo()` whose* callee identifier is bound as a parameter of an enclosing scope cannot be the* module-level `foo`: the parameter shadows it for the whole body. Binding such@@ -611,13 +721,30 @@ static const char *path_basename(const char *path) {return slash ? slash + 1 : path;}+/* Build and configuration languages have no cross-language call semantics: a+ * Makefile's `$(eval ...)` or a CMake `function(...)` names nothing in a C+ * file, so a bare-name bind into another language is always a collision+ * (2026-09-16 probe: kernel Makefile targets bound to `sk_psock.eval`). */+static bool build_config_language(CBMLanguage lang) {+ return lang == CBM_LANG_MAKEFILE || lang == CBM_LANG_CMAKE || lang == CBM_LANG_YAML ||+ lang == CBM_LANG_TOML || lang == CBM_LANG_JSON || lang == CBM_LANG_INI ||+ lang == CBM_LANG_DOCKERFILE;+}+bool cbm_suppress_cross_language_suffix_match(CBMLanguage caller_lang, const char *target_file_path,const char *strategy) {/* Two same-named symbols in different languages: suffix_match picks one* winner by import-distance and attaches every bare-name call to it* (#725, Bash/Python main, JS/Python commit). unique_name is the- * candidates==1 case (#1572) and is not this guard. */- if (!strategy || strcmp(strategy, "suffix_match") != 0) {+ * candidates==1 case (#1572) and is not this guard — except for a build+ * or configuration caller, where even a unique match into another+ * language is a collision by construction. */+ if (!strategy) {+ return false;+ }+ bool config_caller = build_config_language(caller_lang);+ if (strcmp(strategy, "suffix_match") != 0 &&+ !(config_caller && strcmp(strategy, "unique_name") == 0)) {return false;}if (caller_lang == CBM_LANG_COUNT || !target_file_path || !target_file_path[0]) {@@ -1088,27 +1215,37 @@ static bool receiver_chain_admits(const char *callee_name, const char *candidatereturn true;}- /* The candidate's parent segment: the one before its final name. */+ /* The candidate's ancestry: every segment before its final name. */const char *cand_last = strrchr(candidate_qn, '.');if (!cand_last || cand_last == candidate_qn) {- return true; /* top-level candidate — no parent to look for */+ return true; /* top-level candidate — no ancestry to look for */}- const char *parent = cand_last;- while (parent > candidate_qn && parent[-1] != '.') {- parent--;- }- size_t parent_len = (size_t)(cand_last - parent);/* Walk the chain — every segment before the final callee name. A trailing- * "()" is dropped so JSONEncoder().encode reads as JSONEncoder. */+ * "()" is dropped so JSONEncoder().encode reads as JSONEncoder. A chain+ * segment admits the candidate when it names ANY segment of the candidate's+ * ancestry, not only the immediate parent: Settings.builder().putList binds+ * settings.Settings.Builder.putList because Settings owns Builder, and+ * RequestOptions.DEFAULT.toBuilder().setWarningsHandler binds+ * RequestOptions.Builder.setWarningsHandler the same way. Measured on+ * elastic/elasticsearch: the parent-only rule refused 9,473 unique-name+ * calls, most of them exactly these factory chains into a nested Builder.+ * A foreign root still finds nothing in the ancestry — Base64.getEncoder+ * does not admit DocOffsetsCodec.getEncoder, URLSession.shared.data does+ * not admit PickedFile.data — so the #1893 refusals hold. */for (const char *seg = dotted; seg < last_dot;) {const char *end = strchr(seg, '.');size_t len = (size_t)(end - seg);if (len >= 2 && seg[len - 2] == '(' && seg[len - 1] == ')') {len -= 2; /* an empty "()" — JSONEncoder().encode names JSONEncoder */}- if (len == parent_len && strncmp(seg, parent, parent_len) == 0) {- return true;+ for (const char *anc = candidate_qn; anc < cand_last;) {+ const char *anc_end = strchr(anc, '.');+ size_t anc_len = (size_t)(anc_end - anc);+ if (anc_len == len && len > 0 && strncmp(seg, anc, len) == 0) {+ return true;+ }+ anc = anc_end + SKIP_ONE;}seg = end + SKIP_ONE;}diff --git a/tests/test_cli.c b/tests/test_cli.cindex 06ebb3841..211ec6355 100644--- a/tests/test_cli.c+++ b/tests/test_cli.c@@ -1837,8 +1837,7 @@ static bool cli_scope_fixture_start(cli_scope_fixture_t *fixture, const char *tareturn fixture->client != NULL;}-static bool cli_scope_host_serving_within(const cli_scope_fixture_t *fixture,- uint32_t timeout_ms) {+static bool cli_scope_host_serving_within(const cli_scope_fixture_t *fixture, uint32_t timeout_ms) {cbm_daemon_runtime_status_t status = {0};return fixture->endpoint &&cbm_daemon_runtime_request_status(fixture->endpoint, &fixture->identity, timeout_ms,@@ -1994,8 +1993,8 @@ TEST(cli_install_into_host_namespace_still_drains_host_cohort) {: -1;/* Negative probe: see CLI_SCOPE_HOST_DRAINED_PROBE_MS. The drain itself is* asserted positively below via host_exit == CLI_SCOPE_HOST_DRAINED. */- bool host_serving = ready && cli_scope_host_serving_within(&fixture,- CLI_SCOPE_HOST_DRAINED_PROBE_MS);+ bool host_serving =+ ready && cli_scope_host_serving_within(&fixture, CLI_SCOPE_HOST_DRAINED_PROBE_MS);const char *events = read_test_file(activation_log);bool drained_in_log = events && strstr(events, "cohort drained") != NULL &&strstr(events, "\"daemon_active_clients\":1") != NULL;@@ -9384,8 +9383,8 @@ TEST(cli_codex_respects_codex_home) {snprintf(expected_config, sizeof(expected_config), "%s/config.toml", codex_home);yyjson_doc *plan_doc = json ? yyjson_read(json, strlen(json), 0) : NULL;yyjson_val *plan_root = plan_doc ? yyjson_doc_get_root(plan_doc) : NULL;- bool plans_config = test_json_string_array_contains(plan_root, "config_files_planned",- expected_config);+ bool plans_config =+ test_json_string_array_contains(plan_root, "config_files_planned", expected_config);bool plans_instructions = test_json_string_array_contains(plan_root, "instruction_files_planned", expected_instructions);bool plans_cleanup = json && strstr(json, "remove_managed_block_if_present") != NULL;@@ -9441,8 +9440,8 @@ TEST(cli_codex_install_uses_global_activation_pointer_issue1689) {struct stat state;int fresh_rc = cbm_install_agent_configs(tmpdir, binary_path, false, false);char *fresh_agents = read_test_file_alloc(agents_path);- bool fresh_pointer_installed = fresh_rc == 0 && fresh_agents &&- strcmp(fresh_agents, test_codex_activation_block) == 0;+ bool fresh_pointer_installed =+ fresh_rc == 0 && fresh_agents && strcmp(fresh_agents, test_codex_activation_block) == 0;char *config = read_test_file_alloc(config_path);bool other_surfaces_installed =fresh_rc == 0 && config && strstr(config, "[mcp_servers.codebase-memory-mcp]") &&@@ -9463,8 +9462,7 @@ TEST(cli_codex_install_uses_global_activation_pointer_issue1689) {bool unowned_preserved =user_pointer_written > 0 && (size_t)user_pointer_written < sizeof(expected_user_pointer) &&dry_rc == 0 && unowned_rc == 0 && after_dry && after_unowned &&- strcmp(after_dry, user_only) == 0 &&- strcmp(after_unowned, expected_user_pointer) == 0;+ strcmp(after_dry, user_only) == 0 && strcmp(after_unowned, expected_user_pointer) == 0;free(after_dry);free(after_unowned);@@ -9509,11 +9507,10 @@ TEST(cli_codex_install_uses_global_activation_pointer_issue1689) {int malformed_rc = cbm_install_agent_configs(tmpdir, binary_path, false, false);char *after_malformed = read_test_file_alloc(agents_path);config = read_test_file_alloc(config_path);- bool malformed_preserved = malformed_rc != 0 && after_malformed &&- strcmp(after_malformed, malformed) == 0 && config &&- strstr(config, "[mcp_servers.codebase-memory-mcp]") &&- strstr(config, "SessionStart") && stat(skill_path, &state) == 0 &&- stat(profile_path, &state) == 0;+ bool malformed_preserved =+ malformed_rc != 0 && after_malformed && strcmp(after_malformed, malformed) == 0 && config &&+ strstr(config, "[mcp_servers.codebase-memory-mcp]") && strstr(config, "SessionStart") &&+ stat(skill_path, &state) == 0 && stat(profile_path, &state) == 0;free(config);free(after_malformed);@@ -9521,8 +9518,8 @@ TEST(cli_codex_install_uses_global_activation_pointer_issue1689) {char *uninstall_argv[] = {"uninstall", "--yes"};int uninstall_rc = cli_test_cmd_uninstall(2, uninstall_argv);char *after_uninstall = read_test_file_alloc(agents_path);- bool uninstall_preserved_foreign = uninstall_rc == 0 && after_uninstall &&- strcmp(after_uninstall, user_only) == 0;+ bool uninstall_preserved_foreign =+ uninstall_rc == 0 && after_uninstall && strcmp(after_uninstall, user_only) == 0;free(after_uninstall);restore_test_env("HOME", saved_home);@@ -11803,8 +11800,7 @@ TEST(cli_codex_migrates_to_single_hook_representation) {restore_test_env("PATH", saved_path);restore_test_env("CODEX_HOME", saved_codex);test_rmdir_r(tmpdir);- if (!lifecycle_ok || !migrated || !independent_cleanup ||- !pointer_only_on_preflight_failure)+ if (!lifecycle_ok || !migrated || !independent_cleanup || !pointer_only_on_preflight_failure)FAIL("Codex lifecycle preflight must be idempotent, preserve the activation pointer ""contract, and independently clean owned side files");PASS();@@ -11844,8 +11840,7 @@ TEST(cli_codex_pointer_migration_precedes_hook_preflight_issue1689) {test_rmdir_r(tmpdir);FAIL("failed to build expected Codex pointer migration");}- if (write_test_file(config_path, ambiguous) != 0 ||- write_test_file(agents_path, legacy) != 0) {+ if (write_test_file(config_path, ambiguous) != 0 || write_test_file(agents_path, legacy) != 0) {test_rmdir_r(tmpdir);FAIL("failed to write Codex cleanup preflight fixture");}@@ -11868,14 +11863,13 @@ TEST(cli_codex_pointer_migration_precedes_hook_preflight_issue1689) {strcmp(config_after_plan, ambiguous) == 0 &&strcmp(agents_after_plan, legacy) == 0;- int install_rc =- cbm_install_agent_configs(tmpdir, "/opt/codebase-memory-mcp", false, false);+ int install_rc = cbm_install_agent_configs(tmpdir, "/opt/codebase-memory-mcp", false, false);char *config_after_install = read_test_file_alloc(config_path);char *agents_after_install = read_test_file_alloc(agents_path);struct stat state;- bool preflight_failed_closed =- install_rc != 0 && config_after_install && strcmp(config_after_install, ambiguous) == 0 &&- stat(skill_path, &state) != 0 && stat(profile_path, &state) != 0;+ bool preflight_failed_closed = install_rc != 0 && config_after_install &&+ strcmp(config_after_install, ambiguous) == 0 &&+ stat(skill_path, &state) != 0 && stat(profile_path, &state) != 0;bool pointer_migrated =agents_after_install && strcmp(agents_after_install, legacy_migrated) == 0;@@ -15206,6 +15200,34 @@ TEST(cli_build_args_json_bare_boolean_issue680) {PASS();}+/* An array-typed flag given a JSON array literal — the shape the help's+ * `<array>` invites — contributes the literal's elements, not one element+ * holding the literal text (2026-09-16 probe: check_index_coverage reported+ * the fake path `["lib","t"]`). Repeated plain values still accumulate. */+TEST(cli_build_args_json_array_flag_accepts_json_literal) {+ char *err = NULL;+ char *argv[] = {"--project", "p", "--paths", "[\"lib\",\"t\"]"};+ char *json = cbm_cli_build_args_json("check_index_coverage", 4, argv, &err);+ ASSERT_NOT_NULL(json);+ ASSERT_NULL(err);+ ASSERT(strstr(json, "\"paths\":[\"lib\",\"t\"]") != NULL);+ free(json);++ char *argv2[] = {"--project", "p", "--paths", "lib", "--paths", "t"};+ json = cbm_cli_build_args_json("check_index_coverage", 6, argv2, &err);+ ASSERT_NOT_NULL(json);+ ASSERT(strstr(json, "\"paths\":[\"lib\",\"t\"]") != NULL);+ free(json);++ /* A value that merely starts with '[' but is not JSON stays one element. */+ char *argv3[] = {"--project", "p", "--paths", "[weird"};+ json = cbm_cli_build_args_json("check_index_coverage", 4, argv3, &err);+ ASSERT_NOT_NULL(json);+ ASSERT(strstr(json, "\"paths\":[\"[weird\"]") != NULL);+ free(json);+ PASS();+}+/* An unknown flag for a KNOWN tool must be rejected loudly, not silently* typed as a string and dropped server-side (#997). GF1 eval: `trace_path* --max-depth 1` was accepted, the real --depth stayed at default 3, and@@ -16347,6 +16369,7 @@ SUITE(cli) {RUN_TEST(cli_build_args_json_string_flag_issue680);RUN_TEST(cli_build_args_json_integer_flag_issue680);RUN_TEST(cli_build_args_json_bare_boolean_issue680);+ RUN_TEST(cli_build_args_json_array_flag_accepts_json_literal);RUN_TEST(cli_build_args_json_unknown_flag_rejected);RUN_TEST(cli_build_args_json_repeated_array_issue680);RUN_TEST(cli_build_args_json_kebab_to_snake_issue680);diff --git a/tests/test_cypher.c b/tests/test_cypher.cindex 756afc4a9..8bdee76c9 100644--- a/tests/test_cypher.c+++ b/tests/test_cypher.c@@ -4468,6 +4468,63 @@ TEST(cypher_exec_prop_array_with_internal_commas) {/* A string property must not end at an ESCAPED quote: the scan stopped at the* first '"' regardless of a preceding backslash, cutting the value short. */+/* Planner (2026-09-16): a single-hop pattern whose FAR node carries the+ * selective filter is walked from that end. `MATCH (a)-[:CALLS]->(b) WHERE+ * b.name = 'X'` used to scan every node before the filter on b could act — on+ * the 8.5 M node kernel graph it hit the execution-time limit while the+ * anchored spelling answered in seconds. The rows must be the same in every+ * spelling, including the inline-property and inbound-direction forms, and+ * the caller-side variable must still bind the right nodes after the swap. */+TEST(cypher_single_hop_seeds_from_selective_far_node) {+ cbm_store_t *s = setup_cypher_store();++ cbm_cypher_result_t where_form = {0};+ ASSERT_EQ(cbm_cypher_execute(s,+ "MATCH (a)-[:CALLS]->(b) WHERE b.name = 'ValidateOrder' "+ "RETURN a.name ORDER BY a.name",+ "test", 0, &where_form),+ 0);+ ASSERT_EQ(where_form.row_count, 1);+ ASSERT_STR_EQ(where_form.rows[0][0], "HandleOrder");+ cbm_cypher_result_free(&where_form);++ cbm_cypher_result_t inline_form = {0};+ ASSERT_EQ(cbm_cypher_execute(s,+ "MATCH (a)-[:CALLS]->(b {name: 'SubmitOrder'}) "+ "RETURN a.name",+ "test", 0, &inline_form),+ 0);+ ASSERT_EQ(inline_form.row_count, 1);+ ASSERT_STR_EQ(inline_form.rows[0][0], "ValidateOrder");+ cbm_cypher_result_free(&inline_form);++ /* Inbound spelling: the far node is now the CALLER; direction inverts back. */+ cbm_cypher_result_t inbound_form = {0};+ ASSERT_EQ(cbm_cypher_execute(s,+ "MATCH (callee)<-[:CALLS]-(caller) WHERE caller.name = "+ "'HandleOrder' RETURN callee.name ORDER BY callee.name",+ "test", 0, &inbound_form),+ 0);+ ASSERT_EQ(inbound_form.row_count, 2);+ ASSERT_STR_EQ(inbound_form.rows[0][0], "LogError");+ ASSERT_STR_EQ(inbound_form.rows[1][0], "ValidateOrder");+ cbm_cypher_result_free(&inbound_form);++ /* Count aggregation through the swapped seed. */+ cbm_cypher_result_t count_form = {0};+ ASSERT_EQ(cbm_cypher_execute(s,+ "MATCH (a)-[:CALLS]->(b) WHERE b.name = 'LogError' "+ "RETURN count(a) AS callers",+ "test", 0, &count_form),+ 0);+ ASSERT_EQ(count_form.row_count, 1);+ ASSERT_STR_EQ(count_form.rows[0][0], "1");+ cbm_cypher_result_free(&count_form);++ cbm_store_close(s);+ PASS();+}+TEST(cypher_exec_prop_string_with_escaped_quote) {cbm_store_t *s = cbm_store_open_memory();cbm_store_upsert_project(s, "test", "/tmp/test");@@ -4792,4 +4849,5 @@ SUITE(cypher) {/* Composite property projection (arrays/objects, escaped quotes) */RUN_TEST(cypher_exec_prop_array_with_internal_commas);RUN_TEST(cypher_exec_prop_string_with_escaped_quote);+ RUN_TEST(cypher_single_hop_seeds_from_selective_far_node);}diff --git a/tests/test_extraction.c b/tests/test_extraction.cindex e5800f8da..8d9bf742b 100644--- a/tests/test_extraction.c+++ b/tests/test_extraction.c@@ -2941,6 +2941,106 @@ TEST(commonlisp_defmacro) {PASS();}+/* 2026-09-16 probe: config extractors handed multi-line node text over as a+ * name (8,301 elasticsearch YAML Fields, 91 kernel Makefile/.conf nodes with a+ * line break inside), and JS/TS baselines named functions `{}` and variables+ * `1`. The definition push is the one place every extractor goes through. */+TEST(defs_push_cuts_multiline_names_and_rejects_js_literal_names) {+ CBMArena a;+ cbm_arena_init(&a);+ CBMDefArray defs = {0};++ CBMDefinition make = {0};+ make.name = "endif\n\n$(obj)/pm_data-offsets.h";+ make.qualified_name = "proj.arch.arm.mach-at91.Makefile.endif\n\n$(obj)/pm_data-offsets.h";+ make.label = "Function";+ make.file_path = "arch/arm/mach-at91/Makefile";+ cbm_defs_push(&defs, &a, make);+ ASSERT_EQ(defs.count, 1);+ ASSERT_STR_EQ(defs.items[0].name, "endif");+ ASSERT_STR_EQ(defs.items[0].qualified_name, "proj.arch.arm.mach-at91.Makefile.endif");++ CBMDefinition yaml = {0};+ yaml.name = "Test get datafeed stats given missing datafeed_id \r\n - do:";+ yaml.qualified_name =+ "proj.spec.Test get datafeed stats given missing datafeed_id \r\n - do:";+ yaml.label = "Field";+ yaml.file_path = "rest-api-spec/test/ml/get_datafeed_stats.yml";+ cbm_defs_push(&defs, &a, yaml);+ ASSERT_EQ(defs.count, 2);+ ASSERT_STR_EQ(defs.items[1].name, "Test get datafeed stats given missing datafeed_id");++ /* JS/TS: a literal token is not a name. */+ CBMDefinition brace = {0};+ brace.name = "{}";+ brace.qualified_name = "proj.tests.baselines.x.{}";+ brace.label = "Function";+ brace.file_path = "tests/baselines/reference/x.js";+ cbm_defs_push(&defs, &a, brace);+ CBMDefinition one = {0};+ one.name = "1";+ one.qualified_name = "proj.tests.cases.y.1";+ one.label = "Variable";+ one.file_path = "tests/cases/y.ts";+ cbm_defs_push(&defs, &a, one);+ ASSERT_EQ(defs.count, 2);++ /* Real JS names, including private members and `$`-prefixed ones, stay. */+ CBMDefinition priv = {0};+ priv.name = "#secret";+ priv.qualified_name = "proj.src.a.Klass.#secret";+ priv.label = "Method";+ priv.file_path = "src/a.ts";+ cbm_defs_push(&defs, &a, priv);+ CBMDefinition dollar = {0};+ dollar.name = "$scope";+ dollar.qualified_name = "proj.src.b.$scope";+ dollar.label = "Variable";+ dollar.file_path = "src/b.js";+ cbm_defs_push(&defs, &a, dollar);+ ASSERT_EQ(defs.count, 4);++ /* Member keys JS spells without an identifier start are names too:+ * computed, string-literal and escaped (1,782 real definitions in the+ * TypeScript corpus wore these spellings). */+ const char *member_keys[] = {"[Symbol.iterator]", "\"my-key\"", "'x'", "\\u0410"};+ for (int i = 0; i < 4; i++) {+ CBMDefinition member = {0};+ member.name = member_keys[i];+ member.qualified_name = member_keys[i];+ member.label = "Method";+ member.file_path = "src/c.ts";+ cbm_defs_push(&defs, &a, member);+ }+ ASSERT_EQ(defs.count, 8);++ /* Tokens that are not names in any spelling: patterns, numeric literals,+ * parenthesised types, rest elements. */+ const char *tokens[] = {"{ b11 } = { b11: \"string\" }", "0x0", "3.2e1",+ "(x: number) => string", "...a", "?"};+ for (int i = 0; i < 6; i++) {+ CBMDefinition token = {0};+ token.name = tokens[i];+ token.qualified_name = tokens[i];+ token.label = "Variable";+ token.file_path = "tests/cases/z.js";+ cbm_defs_push(&defs, &a, token);+ }+ ASSERT_EQ(defs.count, 8);++ /* Other languages may legitimately name operators: untouched. */+ CBMDefinition op = {0};+ op.name = "<$>";+ op.qualified_name = "proj.Data.Functor.<$>";+ op.label = "Function";+ op.file_path = "src/Data/Functor.hs";+ cbm_defs_push(&defs, &a, op);+ ASSERT_EQ(defs.count, 9);++ cbm_arena_destroy(&a);+ PASS();+}+TEST(makefile_rule_as_function) {CBMFileResult *r = extract("all:\n\t@echo hello\n", CBM_LANG_MAKEFILE, "test", "Makefile");ASSERT_NOT_NULL(r);@@ -7145,6 +7245,38 @@ static int find_call_args(const CBMFileResult *r, const char *callee, const charreturn -1;}+/* tree-sitter lists a comment inside an argument list as a named child; it is+ * not an argument. A Java constructor call whose argument list opened with a+ * slash-star comment handed the comment text to the Route pass as a URL+ * (three Route nodes named by comments on elasticsearch, 2026-09-16). */+TEST(call_args_skip_comments_between_arguments) {+ CBMFileResult *r = extract("class A {\n"+ " void f() {\n"+ " app.get(/* the orders listing */ \"/orders\", handler);\n"+ " new TestCase(\n"+ " /*\n"+ " * a multi-line note\n"+ " */\n"+ " \"x\", // trailing\n"+ " 1);\n"+ " }\n"+ "}\n",+ CBM_LANG_JAVA, "t", "A.java");+ ASSERT_NOT_NULL(r);+ const char *arg0 = NULL;+ const char *arg1 = NULL;+ int argc = find_call_args(r, "get", &arg0, &arg1);+ ASSERT_EQ(argc, 2);+ ASSERT_STR_EQ(arg0, "\"/orders\"");+ ASSERT_STR_EQ(arg1, "handler");+ argc = find_call_args(r, "TestCase", &arg0, &arg1);+ ASSERT_EQ(argc, 2);+ ASSERT_STR_EQ(arg0, "\"x\"");+ ASSERT_STR_EQ(arg1, "1");+ cbm_free_result(r);+ PASS();+}+TEST(objectscript_data_flows_class_method_args) {CBMFileResult *r = extract("Class MyApp.Caller Extends %RegisteredObject\n""{\n"@@ -8014,6 +8146,7 @@ SUITE(extraction) {RUN_TEST(objectscript_macro_constant_no_extra_call);RUN_TEST(objectscript_udl_method_return_type);RUN_TEST(objectscript_udl_scalar_return_type_not_resolved);+ RUN_TEST(call_args_skip_comments_between_arguments);RUN_TEST(objectscript_data_flows_class_method_args);RUN_TEST(objectscript_data_flows_instance_method_args);RUN_TEST(iris_export_xml_simple_class);@@ -8224,6 +8357,7 @@ SUITE(extraction) {RUN_TEST(commonlisp_defun);RUN_TEST(commonlisp_multiple_functions);RUN_TEST(commonlisp_defmacro);+ RUN_TEST(defs_push_cuts_multiline_names_and_rejects_js_literal_names);RUN_TEST(makefile_rule_as_function);RUN_TEST(makefile_multiple_targets);RUN_TEST(makefile_variable_extraction);diff --git a/tests/test_infrascan.c b/tests/test_infrascan.cindex f6da94955..cd7df945d 100644--- a/tests/test_infrascan.c+++ b/tests/test_infrascan.c@@ -32,6 +32,19 @@ TEST(infrascan_http_route_literal_guard_rejects_filesystem_paths) {ASSERT_TRUE(cbm_service_pattern_is_http_route_literal("/api/orders", "requests.get"));ASSERT_TRUE(cbm_service_pattern_is_http_route_literal("https://orders.example/api/orders","requests.get"));+ /* A comment that leads an argument list is not a route (elasticsearch+ * RestHandler routes: three Java block comments became Route nodes). */+ ASSERT_FALSE(cbm_service_pattern_is_http_route_literal(+ "/*\n * Deprecated in #64227, 7.12/8.0.\n */",+ "Route.builder"));+ ASSERT_FALSE(cbm_service_pattern_is_http_route_literal("// legacy path", "Route.builder"));+ ASSERT_FALSE(cbm_service_pattern_is_http_route_literal("/_cat\n/indices", "Route.builder"));+ ASSERT_FALSE(cbm_service_pattern_is_http_route_literal("/* all */", "Route.builder"));+ ASSERT_TRUE(cbm_service_pattern_is_http_route_literal("/_cat/indices", "Route.builder"));+ /* The wildcard path (slash-star alone) is a route, not a comment:+ * elasticsearch's RestClient.buildUri(null, wildcard) registers one. */+ ASSERT_TRUE(cbm_service_pattern_is_http_route_literal("/*", "RestClient.buildUri"));+ ASSERT_TRUE(cbm_service_pattern_is_http_route_literal("/api/*", "app.get"));PASS();}diff --git a/tests/test_mcp.c b/tests/test_mcp.cindex 7d51c9c6d..ffa9ea3a3 100644--- a/tests/test_mcp.c+++ b/tests/test_mcp.c@@ -3786,6 +3786,124 @@ TEST(tool_search_graph_bm25_reports_candidate_saturation) {PASS();}+/* Shared fixture for the two BM25 findability probes (2026-09-16, measured on+ * JetBrains/Exposed and django/django): a Class named exactly like the query,+ * that class's own Methods, and test Methods whose long names repeat the+ * query token — the shapes that outranked the class and hid it entirely. */+static void bm25_findability_fixture(cbm_store_t *store, const char *project) {+ cbm_store_upsert_project(store, project, "/tmp/bm25-findability");+ struct {+ const char *label, *name, *qn, *file;+ } rows[] = {+ {"Class", "Table", "bm25-find.core.Table.Table", "core/Table.kt"},+ {"Method", "unquoted", "bm25-find.core.Table.Table.unquoted", "core/Table.kt"},+ {"Method", "describe", "bm25-find.core.Table.Table.describe", "core/Table.kt"},+ {"Method", "table references table with same name in other database",+ "bm25-find.tests.SchemaTests.table_references_table_with_same_name", "tests/Schema.kt"},+ {"Method", "table references table with same name in mysql",+ "bm25-find.tests.SchemaTests.table_references_table_with_same_name_mysql",+ "tests/Schema.kt"},+ {"Function", "get_object_or_404", "bm25-find.shortcuts.get_object_or_404", "shortcuts.py"},+ {"Method", "test_get_object_or_404",+ "bm25-find.tests.GetObjectOr404Tests.test_get_object_or_404", "tests/tests.py"},+ {"Method", "test_get_object_or_404_queryset_attribute_error",+ "bm25-find.tests.GetObjectOr404Tests.test_get_object_or_404_queryset_attribute_error",+ "tests/tests.py"},+ {"Method", "test_get_object_or_404_bad_class",+ "bm25-find.tests.GetListObjectOr404Test.test_get_object_or_404_bad_class",+ "tests/async.py"},+ };+ for (size_t i = 0; i < sizeof(rows) / sizeof(rows[0]); i++) {+ cbm_node_t node = {.project = project,+ .label = rows[i].label,+ .name = rows[i].name,+ .qualified_name = rows[i].qn,+ .file_path = rows[i].file,+ .start_line = (int)i + 1,+ .end_line = (int)i + 2};+ cbm_store_upsert_node(store, &node);+ }+ cbm_store_exec(store, "INSERT INTO nodes_fts(nodes_fts) VALUES('delete-all');");+ cbm_store_exec(store, "INSERT INTO nodes_fts(rowid, name, qualified_name, label, "+ "file_path) SELECT id, cbm_camel_split(name), qualified_name, "+ "label, file_path FROM nodes;");+}++/* The label filter must apply in query (BM25) mode exactly as in structural+ * mode: `query=Table label=Class` returns the class, and no Method. */+TEST(tool_search_graph_bm25_applies_label_filter) {+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ ASSERT_NOT_NULL(srv);+ cbm_store_t *store = cbm_mcp_server_store(srv);+ ASSERT_NOT_NULL(store);+ const char *project = "bm25-find";+ cbm_mcp_server_set_project(srv, project);+ bm25_findability_fixture(store, project);++ char *resp = cbm_mcp_server_handle(+ srv, "{\"jsonrpc\":\"2.0\",\"id\":554,\"method\":\"tools/call\","+ "\"params\":{\"name\":\"search_graph\",\"arguments\":{"+ "\"project\":\"bm25-find\",\"query\":\"Table\",\"label\":\"Class\","+ "\"limit\":5,\"format\":\"json\"}}}");+ ASSERT_NOT_NULL(resp);+ char *inner = extract_text_content(resp);+ ASSERT_NOT_NULL(inner);+ ASSERT_NOT_NULL(strstr(inner, "\"bm25-find.core.Table.Table\",\"Class\""));+ ASSERT_NULL(strstr(inner, "\"Method\""));+ /* The reported total describes the filtered rows, not the unfiltered window. */+ ASSERT_NOT_NULL(strstr(inner, "\"total\":1"));+ free(inner);+ free(resp);+ cbm_mcp_server_free(srv);+ PASS();+}++/* The definition whose NAME is the query ranks first: the `Table` class above+ * its own methods and above test methods that repeat "table" three times; the+ * `get_object_or_404` function above the test methods that contain it. */+TEST(tool_search_graph_bm25_ranks_exact_name_first) {+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ ASSERT_NOT_NULL(srv);+ cbm_store_t *store = cbm_mcp_server_store(srv);+ ASSERT_NOT_NULL(store);+ const char *project = "bm25-find";+ cbm_mcp_server_set_project(srv, project);+ bm25_findability_fixture(store, project);++ char *resp = cbm_mcp_server_handle(+ srv, "{\"jsonrpc\":\"2.0\",\"id\":555,\"method\":\"tools/call\","+ "\"params\":{\"name\":\"search_graph\",\"arguments\":{"+ "\"project\":\"bm25-find\",\"query\":\"Table\",\"limit\":5,\"format\":\"json\"}}}");+ ASSERT_NOT_NULL(resp);+ char *inner = extract_text_content(resp);+ ASSERT_NOT_NULL(inner);+ const char *rows = strstr(inner, "\"rows\":[");+ ASSERT_NOT_NULL(rows);+ const char *first_qn = strstr(rows, "[\"");+ ASSERT_NOT_NULL(first_qn);+ ASSERT_EQ(strncmp(first_qn, "[\"bm25-find.core.Table.Table\"", 29), 0);+ free(inner);+ free(resp);++ resp = cbm_mcp_server_handle(+ srv, "{\"jsonrpc\":\"2.0\",\"id\":556,\"method\":\"tools/call\","+ "\"params\":{\"name\":\"search_graph\",\"arguments\":{"+ "\"project\":\"bm25-find\",\"query\":\"get_object_or_404\",\"limit\":5,"+ "\"format\":\"json\"}}}");+ ASSERT_NOT_NULL(resp);+ inner = extract_text_content(resp);+ ASSERT_NOT_NULL(inner);+ rows = strstr(inner, "\"rows\":[");+ ASSERT_NOT_NULL(rows);+ first_qn = strstr(rows, "[\"");+ ASSERT_NOT_NULL(first_qn);+ ASSERT_EQ(strncmp(first_qn, "[\"bm25-find.shortcuts.get_object_or_404\"", 40), 0);+ free(inner);+ free(resp);+ cbm_mcp_server_free(srv);+ PASS();+}+/* `query` selects the BM25 fast path, which returns before semantic_query is* evaluated. Accepting both therefore used to report success while silently* discarding one of the caller's two requested result sets. The contract is@@ -5583,9 +5701,9 @@ TEST(tool_check_index_coverage_reports_truncation_marker_issue963) {/* The marked file: both real ranges survive, the marker is flagged, and the* "12" from the marker never becomes a range of its own. */- char *marked =- cbm_mcp_handle_tool(srv, "check_index_coverage",- "{\"project\":\"coverage-marker\",\"paths\":[\"src/marked.c\"],\"format\":\"json\"}");+ char *marked = cbm_mcp_handle_tool(+ srv, "check_index_coverage",+ "{\"project\":\"coverage-marker\",\"paths\":[\"src/marked.c\"],\"format\":\"json\"}");ASSERT_NOT_NULL(marked);char *marked_inner = extract_text_content(marked);ASSERT_NOT_NULL(marked_inner);@@ -5597,9 +5715,9 @@ TEST(tool_check_index_coverage_reports_truncation_marker_issue963) {free(marked);/* The same ranges without a marker must NOT be reported as truncated. */- char *plain =- cbm_mcp_handle_tool(srv, "check_index_coverage",- "{\"project\":\"coverage-marker\",\"paths\":[\"src/plain.c\"],\"format\":\"json\"}");+ char *plain = cbm_mcp_handle_tool(+ srv, "check_index_coverage",+ "{\"project\":\"coverage-marker\",\"paths\":[\"src/plain.c\"],\"format\":\"json\"}");ASSERT_NOT_NULL(plain);char *plain_inner = extract_text_content(plain);ASSERT_NOT_NULL(plain_inner);@@ -5610,9 +5728,9 @@ TEST(tool_check_index_coverage_reports_truncation_marker_issue963) {/* The reader's own limit stops the list early, so it must say so even* though the producer sent no marker. */- char *widest =- cbm_mcp_handle_tool(srv, "check_index_coverage",- "{\"project\":\"coverage-marker\",\"paths\":[\"src/wide.c\"],\"format\":\"json\"}");+ char *widest = cbm_mcp_handle_tool(+ srv, "check_index_coverage",+ "{\"project\":\"coverage-marker\",\"paths\":[\"src/wide.c\"],\"format\":\"json\"}");ASSERT_NOT_NULL(widest);char *wide_inner = extract_text_content(widest);ASSERT_NOT_NULL(wide_inner);@@ -20418,6 +20536,8 @@ SUITE(mcp) {RUN_TEST(tool_output_byte_budgets);RUN_TEST(tool_search_graph_query_honors_file_pattern_issue552);RUN_TEST(tool_search_graph_bm25_reports_candidate_saturation);+ RUN_TEST(tool_search_graph_bm25_applies_label_filter);+ RUN_TEST(tool_search_graph_bm25_ranks_exact_name_first);RUN_TEST(tool_search_graph_rejects_bm25_and_semantic_query_together);RUN_TEST(tool_search_graph_semantic_ceiling_never_emits_unusable_continuation);RUN_TEST(tool_search_graph_semantic_pagination_is_lossless_and_independent);diff --git a/tests/test_parse_coverage.c b/tests/test_parse_coverage.cindex f657e1e81..fd0e64e47 100644--- a/tests/test_parse_coverage.c+++ b/tests/test_parse_coverage.c@@ -112,21 +112,21 @@ static const char *PY_CLEAN = "def ok():\n"* Guards against over-suppression: the preprocessor explains the guarded* region but explains nothing about the garbage, so BOTH must stay flagged* and they must be reported as two separate ranges, not one big one. */-static const char *C_IFDEF_SPLIT_PLUS_GARBAGE = "#include <stdio.h>\n" /* 1 */- "\n" /* 2 */- "void ok_before(void) { }\n" /* 3 */- "\n" /* 4 */- "#ifdef FEATURE_A\n" /* 5 */- "static int guarded(int x) {\n" /* 6 */- "#else\n" /* 7 */+static const char *C_IFDEF_SPLIT_PLUS_GARBAGE = "#include <stdio.h>\n" /* 1 */+ "\n" /* 2 */+ "void ok_before(void) { }\n" /* 3 */+ "\n" /* 4 */+ "#ifdef FEATURE_A\n" /* 5 */+ "static int guarded(int x) {\n" /* 6 */+ "#else\n" /* 7 */"static int guarded_alt(int x) {\n" /* 8 */- "#endif\n" /* 9 */- " return x + 1;\n" /* 10 */- "}\n" /* 11 */- "\n" /* 12 */- "%%% ((( &&& ))) %%%\n" /* 13 */- "\n" /* 14 */- "void ok_after(void) { }\n"; /* 15 */+ "#endif\n" /* 9 */+ " return x + 1;\n" /* 10 */+ "}\n" /* 11 */+ "\n" /* 12 */+ "%%% ((( &&& ))) %%%\n" /* 13 */+ "\n" /* 14 */+ "void ok_after(void) { }\n"; /* 15 *//* Perl formats have a line-oriented body terminated by a lone dot. The* following named sub pins the important recovery boundary: a grammar must@@ -494,7 +494,8 @@ TEST(real_error_before_eof_still_flagged_without_final_newline_issue1610) {bool has_ranges = r->error_ranges != NULL;cbm_free_result(r);if (!flagged) {- FAIL("a real mid-file parse failure must still be reported when the file also lacks its final newline");+ FAIL("a real mid-file parse failure must still be reported when the file also lacks its "+ "final newline");}if (!has_ranges) {FAIL("a reported failure must still name its line range");@@ -529,11 +530,8 @@ TEST(perl_format_followed_by_named_sub_is_complete_issue1838) {bool has_error_ranges = r->error_ranges != NULL;bool has_following_sub = has_def(r, "after_format");if (partial || error_regions != 0 || has_error_ranges || !has_following_sub) {- fprintf(stderr,- " Perl format result: partial=%d regions=%d ranges=%s following_sub=%d\n",- partial,- error_regions,- r->error_ranges ? r->error_ranges : "(none)",+ fprintf(stderr, " Perl format result: partial=%d regions=%d ranges=%s following_sub=%d\n",+ partial, error_regions, r->error_ranges ? r->error_ranges : "(none)",has_following_sub);cbm_free_result(r);FAIL("a valid Perl format and its following named sub must parse completely");@@ -619,7 +617,8 @@ TEST(width_bearing_error_at_eof_still_flagged_with_trailing_blank_issue1746) {bool flagged = r->parse_incomplete;cbm_free_result(r);if (!flagged) {- FAIL("a width-bearing parse failure at EOF must still be reported when the file ends in blanks");+ FAIL("a width-bearing parse failure at EOF must still be reported when the file ends in "+ "blanks");}PASS();}@@ -734,7 +733,6 @@ TEST(c_clean_file_stays_unflagged_after_refinement) {PASS();}-/* The whole-file class, and the reason the parse_unusable kind exists.** The Phase 2 refinement that narrows a whole-file range using the@@ -806,18 +804,31 @@ TEST(c_ifdef_split_is_partial_never_unusable) {* says so, instead of leaving a wrong note in the plan. (The plan's Phase 0* also listed the pointer form as failing. It does not fail today.) */TEST(c_thread_local_grammar_limit_is_pinned_issue963) {+ /* The init form used to read as "parses clean", but that was a masking+ * effect, not a clean parse: the grammar leaves an ERROR on line 1 and+ * salvages a one-line Variable named `int` from it, which the old+ * all-or-nothing recovery rule accepted as evidence the line was+ * understood. Since 2026-09-16 a one-line salvage is not evidence, so the+ * line is flagged — honest, because `x` is what the graph lacks. */CBMFileResult *ok = do_extract("static _Thread_local int x = 0;\n""void f(void) { x = 1; }\n",CBM_LANG_C, "tls_init.c");ASSERT_NOT_NULL(ok);- ASSERT_FALSE(ok->parse_incomplete);+ ASSERT_TRUE(ok->parse_incomplete);+ ASSERT_NOT_NULL(ok->error_ranges);+ ASSERT_STR_EQ("1-1", ok->error_ranges);+ ASSERT_TRUE(has_def(ok, "f"));cbm_free_result(ok);+ /* The pointer form: the same masking, the same honest answer now. */CBMFileResult *ptr = do_extract("static _Thread_local int *p;\n""void f(void) { p = 0; }\n",CBM_LANG_C, "tls_ptr.c");ASSERT_NOT_NULL(ptr);- ASSERT_FALSE(ptr->parse_incomplete);+ ASSERT_TRUE(ptr->parse_incomplete);+ ASSERT_NOT_NULL(ptr->error_ranges);+ ASSERT_STR_EQ("1-1", ptr->error_ranges);+ ASSERT_TRUE(has_def(ptr, "f"));cbm_free_result(ptr);CBMFileResult *arr = do_extract("static _Thread_local char b[8];\n"@@ -879,6 +890,99 @@ TEST(coverage_range_never_ends_past_the_last_line_issue963) {PASS();}+/* ── Residual ranges (2026-09-16) ─────────────────────────────────────────+ * The recovery subtraction used to be all-or-nothing: a region stayed flagged+ * whole unless every one of its lines was covered by a definition that started+ * inside it. On torvalds/linux one ERROR node that swallowed the second half of+ * kernel/sched/core.c (lines 5522-11284) survived on the strength of the+ * comment and macro lines BETWEEN its 286 extracted functions, and+ * check_index_coverage told a reader 68 % of the scheduler was unindexed. The+ * ranges must now name only the lines no extracted definition covers. */++/* A brace-unbalanced junk line between two clean functions: the recovery+ * walker still extracts both functions, so the reported range must not cover+ * either of them, only the junk. */+static const char *C_JUNK_BETWEEN_FUNCTIONS = "int alpha(void) {\n" /* 1 */+ " return 1;\n" /* 2 */+ "}\n" /* 3 */+ "\n" /* 4 */+ "} ] junk ( {\n" /* 5 */+ "\n" /* 6 */+ "int beta(void) {\n" /* 7 */+ " return 2;\n" /* 8 */+ "}\n" /* 9 */+ "\n" /* 10 */+ "int gamma(void) {\n" /* 11 */+ " return 3;\n" /* 12 */+ "}\n"; /* 13 */++static int range_covers_line(const char *ranges, unsigned int line) {+ const char *p = ranges;+ while (p && *p) {+ unsigned int s = 0;+ unsigned int e = 0;+ if (sscanf(p, "%u-%u", &s, &e) == 2 && s <= line && line <= e) {+ return 1;+ }+ p = strchr(p, ',');+ if (p) {+ p++;+ }+ }+ return 0;+}++TEST(coverage_range_never_covers_an_extracted_definition) {+ CBMFileResult *r = do_extract(C_JUNK_BETWEEN_FUNCTIONS, CBM_LANG_C, "junk.c");+ ASSERT_NOT_NULL(r);+ ASSERT_TRUE(has_def(r, "alpha"));+ ASSERT_TRUE(has_def(r, "beta"));+ ASSERT_TRUE(has_def(r, "gamma"));+ ASSERT_TRUE(r->parse_incomplete);+ ASSERT_NOT_NULL(r->error_ranges);+ /* Every extracted definition's own lines are in the graph, so no reported+ * range may cover its start line. */+ for (int i = 0; i < r->defs.count; i++) {+ const CBMDefinition *d = &r->defs.items[i];+ if (!d->label || strcmp(d->label, "Module") == 0) {+ continue;+ }+ ASSERT_FALSE(range_covers_line(r->error_ranges, d->start_line));+ }+ /* And the junk line itself is still reported. */+ ASSERT_TRUE(range_covers_line(r->error_ranges, 5u));+ cbm_free_result(r);+ PASS();+}++/* The lines between recovered definitions are comments and blanks here: a gap+ * with no code in it is not a miss, so nothing may be reported for it. The+ * junk line stays reported. */+static const char *C_JUNK_WITH_COMMENT_GAPS = "int alpha(void) {\n" /* 1 */+ " return 1;\n" /* 2 */+ "}\n" /* 3 */+ "/* between alpha and the junk */\n" /* 4 */+ "} ] junk ( {\n" /* 5 */+ "// trailing note\n" /* 6 */+ "int beta(void) {\n" /* 7 */+ " return 2;\n" /* 8 */+ "}\n"; /* 9 */++TEST(coverage_gap_of_only_comments_is_not_a_miss) {+ CBMFileResult *r = do_extract(C_JUNK_WITH_COMMENT_GAPS, CBM_LANG_C, "gaps.c");+ ASSERT_NOT_NULL(r);+ ASSERT_TRUE(has_def(r, "alpha"));+ ASSERT_TRUE(has_def(r, "beta"));+ ASSERT_TRUE(r->parse_incomplete);+ ASSERT_NOT_NULL(r->error_ranges);+ ASSERT_TRUE(range_covers_line(r->error_ranges, 5u));+ ASSERT_FALSE(range_covers_line(r->error_ranges, 1u));+ ASSERT_FALSE(range_covers_line(r->error_ranges, 7u));+ ASSERT_FALSE(range_covers_line(r->error_ranges, 9u));+ cbm_free_result(r);+ PASS();+}+SUITE(parse_coverage) {RUN_TEST(c_ifdef_split_brace_sets_parse_incomplete);RUN_TEST(c_ifdef_split_brace_neighbors_still_extracted);@@ -917,4 +1021,6 @@ SUITE(parse_coverage) {RUN_TEST(c_thread_local_grammar_limit_is_pinned_issue963);RUN_TEST(coverage_repeated_error_line_reports_one_range_issue963);RUN_TEST(coverage_range_never_ends_past_the_last_line_issue963);+ RUN_TEST(coverage_range_never_covers_an_extracted_definition);+ RUN_TEST(coverage_gap_of_only_comments_is_not_a_miss);}diff --git a/tests/test_pipeline.c b/tests/test_pipeline.cindex 3a69a0877..ad7e82ae7 100644--- a/tests/test_pipeline.c+++ b/tests/test_pipeline.c@@ -5710,6 +5710,123 @@ TEST(pipeline_python_receiver_suppresses_weak_method_edge) {PASS();}+/* The member guard's one exemption (2026-09-16, v0.10.8 → v0.11.0 A/B on+ * django/django): a member call whose receiver is an attribute chain rooted at+ * self/cls, whose callee has exactly ONE definition in the project and is not a+ * builtin type's own method keeps its unique_name edge —+ * `self.compiler.apply_converters()` names the only apply_converters there is.+ * A bare parameter receiver and the builtin-member class the guard was built+ * for (`parts.extend()` -> a project ListMixin.extend) stay suppressed.+ * Fewer than 50 files exercises pass_calls.c. */+TEST(pipeline_python_receiver_keeps_specific_unique_name_member_call) {+ char tmp[256];+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_python_uniq_XXXXXX");+ if (!cbm_mkdtemp(tmp)) {+ FAIL("tmpdir");+ }++ write_temp_file(tmp, "compiler.py",+ "class SQLCompiler:\n"+ " def apply_converters(self, rows):\n"+ " return rows\n");+ write_temp_file(tmp, "mixin.py",+ "class ListMixin:\n"+ " def extend(self, other):\n"+ " return other\n");+ write_temp_file(tmp, "caller.py",+ "class RawIterable:\n"+ " def __init__(self, compiler):\n"+ " self.compiler = compiler\n"+ "\n"+ " def iterate(self):\n"+ " return self.compiler.apply_converters([])\n"+ "\n"+ "\n"+ "def collect(parts):\n"+ " parts.extend([1])\n"+ " return parts\n"+ "\n"+ "\n"+ "def handed_in(compiler):\n"+ " return compiler.apply_converters([])\n");++ char db_path[512];+ snprintf(db_path, sizeof(db_path), "%s/python_uniq.db", tmp);+ cbm_pipeline_t *p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);+ ASSERT_NOT_NULL(p);+ ASSERT_EQ(cbm_pipeline_run(p), 0);+ const char *project = cbm_pipeline_project_name(p);++ cbm_store_t *s = cbm_store_open_path(db_path);+ ASSERT_NOT_NULL(s);++ /* POSITIVE: the only apply_converters in the project binds through+ * self.compiler, an object the class owns. */+ ASSERT_TRUE(cross_file_call_exists(s, project, "iterate", "apply_converters"));+ /* NEGATIVE: the same unique name through a bare parameter carries no+ * ownership evidence and stays suppressed (#1276's own shape). */+ ASSERT_FALSE(cross_file_call_exists(s, project, "handed_in", "apply_converters"));+ /* NEGATIVE: list.extend on a parameter must not bind ListMixin.extend. */+ ASSERT_FALSE(cross_file_call_exists(s, project, "collect", "extend"));+ /* Tripwire against a vacuous run. */+ ASSERT_GTE(cbm_store_count_edges_by_type(s, project, "CALLS"), 1);++ cbm_store_close(s);+ cbm_pipeline_free(p);+ th_rmtree(tmp);+ PASS();+}++/* Embedded-script hosts (2026-09-16 probe on JetBrains/Exposed): a member call+ * inside an HTML <script> body is extracted as JavaScript and carries the JS+ * receiver flag, but the weak-member guard was gated on the FILE language, so+ * 4,207 generated Dokka pages bound `localStorage.getItem` to a docs bundle+ * function through unique_name. HTML (and Vue/Svelte/Astro) join the gate.+ * POSITIVE tripwire: a bare project call in a plain .js file still resolves. */+TEST(pipeline_html_embedded_member_call_stays_unbound) {+ char tmp[256];+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_html_member_XXXXXX");+ if (!cbm_mkdtemp(tmp)) {+ FAIL("tmpdir");+ }++ /* One directory level each: write_temp_file creates a single parent. */+ write_temp_file(tmp, "scripts/storage.js",+ "function getItem(key) {\n"+ " return key;\n"+ "}\n");+ write_temp_file(tmp, "scripts/theme.js",+ "import { getItem } from './storage.js';\n"+ "\n"+ "function loadTheme() {\n"+ " return getItem('theme');\n"+ "}\n");+ write_temp_file(tmp, "docs/index.html",+ "<html><head><script>\n"+ "var mode = localStorage.getItem('dokka-dark-mode');\n"+ "</script></head><body></body></html>\n");++ char db_path[512];+ snprintf(db_path, sizeof(db_path), "%s/html_member.db", tmp);+ cbm_pipeline_t *p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);+ ASSERT_NOT_NULL(p);+ ASSERT_EQ(cbm_pipeline_run(p), 0);+ const char *project = cbm_pipeline_project_name(p);++ cbm_store_t *s = cbm_store_open_path(db_path);+ ASSERT_NOT_NULL(s);++ /* NEGATIVE: localStorage's own method must not bind the docs bundle. */+ ASSERT_FALSE(cross_file_call_exists(s, project, "index", "getItem"));+ /* POSITIVE: the bare project call in storage.js resolves as before. */+ ASSERT_TRUE(cross_file_call_exists(s, project, "loadTheme", "getItem"));++ cbm_store_close(s);+ cbm_pipeline_free(p);+ th_rmtree(tmp);+ PASS();+}+/* Fixture for the #1928 cross-language reference-guard probes (sequential and* parallel twins). pad_files > 0 adds filler files to push the index over the* parallel-pipeline threshold, since USAGE/WRITES/READS have one resolver per@@ -7589,6 +7706,60 @@ TEST(pipeline_python_project) {PASS();}+/* `#include <linux/device.h>` from arch/x/bugs.c: two headers end with the+ * include path (include/linux/device.h, tools/virtio/linux/device.h) and each+ * declares `struct device`. The exact-file lookup returned the first matching+ * node in by-name bucket order — the workers' merge order, different run to+ * run: 5,821 kernel IMPORTS edges moved between two indexes of one tree and+ * the CALLS resolved through their import maps moved with them. The target is+ * the least nested File node, whichever order the nodes were registered in. */+static void add_device_header(cbm_gbuf_t *gb, const char *rel, const char *qn_stem) {+ char fqn[256];+ snprintf(fqn, sizeof(fqn), "%s.h.__file__", qn_stem);+ cbm_gbuf_upsert_node(gb, "File", "device.h", fqn, rel, 0, 0, "{}");+ char cqn[256];+ snprintf(cqn, sizeof(cqn), "%s.device", qn_stem);+ cbm_gbuf_upsert_node(gb, "Class", "device", cqn, rel, 10, 40, "{}");+}++static const cbm_gbuf_node_t *resolve_device_h_from(cbm_gbuf_t *gb) {+ atomic_int cancelled = 0;+ cbm_pipeline_ctx_t ctx = {+ .project_name = "p",+ .repo_path = "/tmp/p",+ .gbuf = gb,+ .registry = NULL,+ .cancelled = &cancelled,+ };+ CBMImport imp = {0};+ imp.module_path = "linux/device.h";+ imp.local_name = "h";+ return cbm_pipeline_resolve_import_node(&ctx, "arch/x/bugs.c", "p.arch.x.bugs.c.__file__", &imp,+ NULL);+}++TEST(pipeline_header_include_target_is_independent_of_registration_order) {+ cbm_gbuf_t *a = cbm_gbuf_new("p", "/tmp/cbm_include_order_a");+ cbm_gbuf_t *b = cbm_gbuf_new("p", "/tmp/cbm_include_order_b");+ ASSERT_NOT_NULL(a);+ ASSERT_NOT_NULL(b);+ add_device_header(a, "include/linux/device.h", "p.include.linux.device");+ add_device_header(a, "tools/virtio/linux/device.h", "p.tools.virtio.linux.device");+ add_device_header(b, "tools/virtio/linux/device.h", "p.tools.virtio.linux.device");+ add_device_header(b, "include/linux/device.h", "p.include.linux.device");++ const cbm_gbuf_node_t *ta = resolve_device_h_from(a);+ const cbm_gbuf_node_t *tb = resolve_device_h_from(b);+ ASSERT_NOT_NULL(ta);+ ASSERT_NOT_NULL(tb);+ ASSERT_STR_EQ(ta->qualified_name, "p.include.linux.device.h.__file__");+ ASSERT_STR_EQ(tb->qualified_name, "p.include.linux.device.h.__file__");++ cbm_gbuf_free(a);+ cbm_gbuf_free(b);+ PASS();+}+/* #768 end-to-end: `import { A, B } from './lib'` must survive the REAL* pipeline (extract -> gbuf dedup -> raw SQLite dump) as TWO IMPORTS edges* with distinct local_name — and the dumped DB must satisfy its own schema.@@ -10517,6 +10688,61 @@ TEST(registry_receiver_chain_keeps_project_extension_issue1893) {PASS();}+/* A factory chain into a nested type: Settings.builder().putList names the only+ * putList in the project, Settings.Builder.putList, and Settings — the chain's+ * root — is in the candidate's ancestry even though the candidate's immediate+ * parent (Builder) is not spelled in the chain. The parent-only rule refused+ * 9,473 such unique-name calls on elastic/elasticsearch (v0.10.8 → v0.11.0 A/B,+ * 2026-09-16). */+TEST(registry_receiver_chain_admits_factory_chain_into_nested_type) {+ cbm_registry_t *reg = cbm_registry_new();+ cbm_registry_add(reg, "putList", "org.elasticsearch.common.settings.Settings.Builder.putList",+ "Method");++ cbm_resolution_t r = cbm_registry_resolve(+ reg, "Settings.builder().putList", "org.elasticsearch.index.IndexSettings", NULL, NULL, 0);+ ASSERT_STR_EQ(r.qualified_name, "org.elasticsearch.common.settings.Settings.Builder.putList");+ ASSERT_STR_EQ(r.strategy, "unique_name");++ /* The same shape through a value in between: RequestOptions.DEFAULT+ * .toBuilder().setWarningsHandler -> RequestOptions.Builder.setWarningsHandler. */+ cbm_registry_add(reg, "setWarningsHandler",+ "org.elasticsearch.client.RequestOptions.Builder.setWarningsHandler",+ "Method");+ r = cbm_registry_resolve(reg, "RequestOptions.DEFAULT.toBuilder().setWarningsHandler",+ "org.elasticsearch.client.Rest", NULL, NULL, 0);+ ASSERT_STR_EQ(r.qualified_name,+ "org.elasticsearch.client.RequestOptions.Builder.setWarningsHandler");++ cbm_registry_free(reg);+ PASS();+}++/* The ancestry rule must not widen the gate to foreign roots: Base64 is the+ * JDK's, so the project's DocOffsetsCodec.getEncoder stays refused, exactly as+ * #1893's URLSession case above. */+TEST(registry_receiver_chain_still_refuses_foreign_root_with_ancestry_rule) {+ cbm_registry_t *reg = cbm_registry_new();+ cbm_registry_add(reg, "getEncoder", "org.elasticsearch.index.codec.DocOffsetsCodec.getEncoder",+ "Method");++ cbm_resolution_t r = cbm_registry_resolve(+ reg, "Base64.getEncoder", "org.elasticsearch.index.IndexSettings", NULL, NULL, 0);+ ASSERT_NULL(r.qualified_name);++ /* Nor may a package segment admit it: Math.toIntExact must not bind+ * org.elasticsearch.common.Math.toIntExact through "Math" appearing as an+ * ancestry segment ONLY IF that segment really is the type — here it is, and+ * that is the correct outcome (the project's own Math.toIntExact). */+ cbm_registry_add(reg, "toIntExact", "org.elasticsearch.common.Math.toIntExact", "Method");+ r = cbm_registry_resolve(reg, "Math.toIntExact", "org.elasticsearch.index.IndexSettings", NULL,+ NULL, 0);+ ASSERT_STR_EQ(r.qualified_name, "org.elasticsearch.common.Math.toIntExact");++ cbm_registry_free(reg);+ PASS();+}+/* A lower-case root names a value, whose type the chain does not show. The gate* must not look at it, or every ordinary vm.load style call would be refused. */TEST(registry_receiver_chain_ignores_lowercase_root_issue1893) {@@ -14841,6 +15067,8 @@ SUITE(pipeline) {#endifRUN_TEST(pipeline_tsjs_receiver_suppresses_weak_method_edge);RUN_TEST(pipeline_python_receiver_suppresses_weak_method_edge);+ RUN_TEST(pipeline_python_receiver_keeps_specific_unique_name_member_call);+ RUN_TEST(pipeline_html_embedded_member_call_stays_unbound);RUN_TEST(pipeline_go_rw_usage_never_cross_into_c);RUN_TEST(pipeline_go_rw_usage_never_cross_into_c_parallel);RUN_TEST(pipeline_go_bare_ref_never_binds_field);@@ -14876,6 +15104,7 @@ SUITE(pipeline) {RUN_TEST(usages_kotlin_no_duplicate_calls);/* Language integration tests */RUN_TEST(pipeline_python_project);+ RUN_TEST(pipeline_header_include_target_is_independent_of_registration_order);RUN_TEST(pipeline_imports_multi_symbol_edges);RUN_TEST(pipeline_go_cross_package_call);RUN_TEST(pipeline_swift_cross_package_import);@@ -15019,6 +15248,8 @@ SUITE(pipeline) {RUN_TEST(registry_receiver_chain_refuses_library_unique_name_issue1893);RUN_TEST(registry_receiver_chain_refuses_library_suffix_match_issue1893);RUN_TEST(registry_receiver_chain_keeps_project_extension_issue1893);+ RUN_TEST(registry_receiver_chain_admits_factory_chain_into_nested_type);+ RUN_TEST(registry_receiver_chain_still_refuses_foreign_root_with_ancestry_rule);RUN_TEST(registry_receiver_chain_ignores_lowercase_root_issue1893);RUN_TEST(registry_receiver_chain_ignores_bare_name_issue1893);RUN_TEST(registry_fuzzy_confidence_single);diff --git a/tests/test_registry.c b/tests/test_registry.cindex 2674e7b1d..5f751a899 100644--- a/tests/test_registry.c+++ b/tests/test_registry.c@@ -820,6 +820,96 @@ TEST(perl_suppress_keeps_high_confidence_and_genuine_calls) {PASS();}+/* 2026-09-16 probe on torvalds/linux: a Makefile target bound the C function+ * `sk_psock.eval` through unique_name. Build and configuration languages have+ * no cross-language call semantics, so for them a unique match into another+ * language is a collision by construction; a code caller keeps #1572. */+TEST(cross_language_config_caller_drops_unique_name_too) {+ ASSERT_TRUE(cbm_suppress_cross_language_suffix_match(CBM_LANG_MAKEFILE, "include/linux/skmsg.h",+ "unique_name"));+ ASSERT_TRUE(+ cbm_suppress_cross_language_suffix_match(CBM_LANG_CMAKE, "src/main.c", "unique_name"));+ ASSERT_TRUE(+ cbm_suppress_cross_language_suffix_match(CBM_LANG_YAML, "app/models.py", "unique_name"));+ /* A code caller's unique_name into another language is still #1572. */+ ASSERT_FALSE(cbm_suppress_cross_language_suffix_match(+ CBM_LANG_PYTHON, "web/src/pages/Editor.js", "unique_name"));+ /* Same-language config targets are untouched. */+ ASSERT_FALSE(+ cbm_suppress_cross_language_suffix_match(CBM_LANG_MAKEFILE, "lib/Makefile", "unique_name"));+ /* Receiver-aware strategies are never this guard's business. */+ ASSERT_FALSE(+ cbm_suppress_cross_language_suffix_match(CBM_LANG_MAKEFILE, "src/main.c", "same_module"));+ PASS();+}++/* Same-named candidates that tie on test-status and namespace proximity used+ * to be settled by bucket position, i.e. by the order files were registered:+ * two indexes of one kernel tree differed by 632 CALLS edges, `dev_name`+ * landing on any of twenty same-named struct fields or on nothing at all.+ * The tie is now a function of the candidate set: the least nested+ * definition, then the smaller QN — whichever order the registry was built+ * in (O9). */+TEST(registry_tie_break_is_independent_of_registration_order) {+ const char *cands[] = {+ "proj.drivers.media.cec.i2c.ch7322.ch7322_conn_match.dev_name", /* struct field */+ "proj.sound.soc.codecs.tas2783-sdw.tas2783_prv.dev_name", /* struct field */+ "proj.include.linux.device.dev_name", /* the function */+ "proj.arch.um.drivers.pty.pty_chan.dev_name", /* struct field */+ };+ const char *labels[] = {"Field", "Field", "Function", "Field"};+ const int n = 4;++ cbm_registry_t *forward = cbm_registry_new();+ cbm_registry_t *backward = cbm_registry_new();+ for (int i = 0; i < n; i++) {+ cbm_registry_add(forward, "dev_name", cands[i], labels[i]);+ cbm_registry_add(backward, "dev_name", cands[n - 1 - i], labels[n - 1 - i]);+ }++ /* A far-away caller with no imports: every candidate scores the same. */+ cbm_resolution_t f =+ cbm_registry_resolve(forward, "dev_name", "proj.kernel.irq.msi", NULL, NULL, 0);+ cbm_resolution_t b =+ cbm_registry_resolve(backward, "dev_name", "proj.kernel.irq.msi", NULL, NULL, 0);+ ASSERT_NOT_NULL(f.qualified_name);+ ASSERT_NOT_NULL(b.qualified_name);+ ASSERT_STR_EQ(f.qualified_name, "proj.include.linux.device.dev_name");+ ASSERT_STR_EQ(b.qualified_name, "proj.include.linux.device.dev_name");+ ASSERT_STR_EQ(f.strategy, "suffix_match");+ ASSERT_STR_EQ(b.strategy, "suffix_match");++ /* Equal depth: the smaller QN, from either order. */+ cbm_registry_t *lex_a = cbm_registry_new();+ cbm_registry_t *lex_b = cbm_registry_new();+ cbm_registry_add(lex_a, "sg_next", "proj.tools.virtio.scatterlist.sg_next", "Function");+ cbm_registry_add(lex_a, "sg_next", "proj.include.linux.scatterlist.sg_next", "Function");+ cbm_registry_add(lex_b, "sg_next", "proj.include.linux.scatterlist.sg_next", "Function");+ cbm_registry_add(lex_b, "sg_next", "proj.tools.virtio.scatterlist.sg_next", "Function");+ cbm_resolution_t la =+ cbm_registry_resolve(lex_a, "sg_next", "proj.drivers.scsi.arm_scsi", NULL, NULL, 0);+ cbm_resolution_t lb =+ cbm_registry_resolve(lex_b, "sg_next", "proj.drivers.scsi.arm_scsi", NULL, NULL, 0);+ ASSERT_STR_EQ(la.qualified_name, "proj.include.linux.scatterlist.sg_next");+ ASSERT_STR_EQ(lb.qualified_name, "proj.include.linux.scatterlist.sg_next");++ /* Proximity still outranks depth: the sibling wins over a shallower stranger. */+ cbm_registry_t *near = cbm_registry_new();+ cbm_registry_add(near, "vnic_rq_free", "proj.lib.vnic_rq_free", "Function");+ cbm_registry_add(near, "vnic_rq_free", "proj.drivers.scsi.fnic.vnic_rq.vnic_rq_free",+ "Function");+ cbm_resolution_t nr = cbm_registry_resolve(near, "vnic_rq_free",+ "proj.drivers.scsi.fnic.fnic_res", NULL, NULL, 0);+ ASSERT_STR_EQ(nr.qualified_name, "proj.drivers.scsi.fnic.vnic_rq.vnic_rq_free");++ cbm_registry_free(forward);+ cbm_registry_free(backward);+ cbm_registry_free(lex_a);+ cbm_registry_free(lex_b);+ cbm_registry_free(near);+ PASS();+}+TEST(cross_language_suffix_match_drops_py_vs_js) {/* #725: two same-named symbols in different languages. suffix_match is the* strategy that collapses them; unique_name is #1572 and must stay. */@@ -939,6 +1029,53 @@ TEST(dynamic_suppress_keeps_high_confidence_and_non_methods) {PASS();}+TEST(python_builtin_member_table_matches_builtin_type_methods) {+ /* Ends and middle of the sorted table, so a mis-sorted insert shows up. */+ ASSERT_TRUE(cbm_python_is_builtin_member("add"));+ ASSERT_TRUE(cbm_python_is_builtin_member("extend"));+ ASSERT_TRUE(cbm_python_is_builtin_member("items"));+ ASSERT_TRUE(cbm_python_is_builtin_member("print"));+ ASSERT_TRUE(cbm_python_is_builtin_member("startswith"));+ ASSERT_TRUE(cbm_python_is_builtin_member("zfill"));+ /* Project-specific spellings are not builtin members. */+ ASSERT_FALSE(cbm_python_is_builtin_member("apply_converters"));+ ASSERT_FALSE(cbm_python_is_builtin_member("lazy_model_operation"));+ ASSERT_FALSE(cbm_python_is_builtin_member("describe"));+ ASSERT_FALSE(cbm_python_is_builtin_member(NULL));+ ASSERT_FALSE(cbm_python_is_builtin_member(""));+ PASS();+}++TEST(weak_member_unique_name_exempt_is_python_self_rooted_unique_and_specific_only) {+ /* The exemption: Python, self/cls-rooted receiver, unique_name, callee not+ * a builtin member. */+ ASSERT_TRUE(cbm_weak_member_unique_name_exempt(true, true, "self.compiler.apply_converters",+ "unique_name"));+ ASSERT_TRUE(cbm_weak_member_unique_name_exempt(true, true, "cls.registry.lazy_model_operation",+ "unique_name"));+ /* A bare parameter/local receiver carries no ownership evidence: #1276's+ * accelerator.backward() and c.describe() stay suppressed. */+ ASSERT_FALSE(+ cbm_weak_member_unique_name_exempt(true, false, "accelerator.backward", "unique_name"));+ /* A builtin type's own method stays suppressed even on self. */+ ASSERT_FALSE(+ cbm_weak_member_unique_name_exempt(true, true, "self.parts.extend", "unique_name"));+ ASSERT_FALSE(cbm_weak_member_unique_name_exempt(true, true, "self.out.print", "unique_name"));+ /* Only unique_name carries the one-definition evidence. */+ ASSERT_FALSE(cbm_weak_member_unique_name_exempt(true, true, "self.compiler.apply_converters",+ "suffix_match"));+ ASSERT_FALSE(cbm_weak_member_unique_name_exempt(true, true, "self.compiler.apply_converters",+ "field_type_hint"));+ /* Python only: the JS/TS family keeps its recorded trade. */+ ASSERT_FALSE(+ cbm_weak_member_unique_name_exempt(false, true, "this.compiler.apply", "unique_name"));+ /* Degenerate inputs never exempt. */+ ASSERT_FALSE(cbm_weak_member_unique_name_exempt(true, true, NULL, "unique_name"));+ ASSERT_FALSE(cbm_weak_member_unique_name_exempt(true, true, "", "unique_name"));+ ASSERT_FALSE(cbm_weak_member_unique_name_exempt(true, true, "self.x.y", NULL));+ PASS();+}+TEST(local_binding_suppress_drops_weak_shadowed_bare_calls) {/* A bare `run()` whose callee is a parameter of an enclosing scope cannot be* the module-level `run`, so a weak short-name match fabricates the edge. */@@ -1103,10 +1240,14 @@ SUITE(registry) {RUN_TEST(perl_suppress_drops_weak_builtin_and_method_matches);RUN_TEST(perl_suppress_keeps_high_confidence_and_genuine_calls);RUN_TEST(cross_language_suffix_match_drops_py_vs_js);+ RUN_TEST(cross_language_config_caller_drops_unique_name_too);+ RUN_TEST(registry_tie_break_is_independent_of_registration_order);RUN_TEST(cross_language_ref_drops_go_vs_c);RUN_TEST(go_bare_ref_never_binds_field);RUN_TEST(dynamic_suppress_drops_weak_method_matches);RUN_TEST(dynamic_suppress_keeps_high_confidence_and_non_methods);+ RUN_TEST(python_builtin_member_table_matches_builtin_type_methods);+ RUN_TEST(weak_member_unique_name_exempt_is_python_self_rooted_unique_and_specific_only);RUN_TEST(local_binding_suppress_drops_weak_shadowed_bare_calls);RUN_TEST(local_binding_suppress_keeps_unshadowed_and_strong_strategies);RUN_TEST(weak_call_guards_share_one_drop_list);diff --git a/tests/test_str_util.c b/tests/test_str_util.cindex cd6f54210..7ad729df9 100644--- a/tests/test_str_util.c+++ b/tests/test_str_util.c@@ -436,6 +436,30 @@ TEST(json_escape_control_chars) {PASS();}+/* A truncated escape must never end inside a multibyte UTF-8 sequence: the+ * callee text of a CALLS edge is escaped into a fixed buffer, and a cut umlaut+ * persisted bytes SQLite could not decode as text (2026-09-16 probe: rust,+ * java and typescript stores). "aé" is a, 0xC3, 0xA9. */+TEST(json_escape_never_splits_utf8) {+ char buf[3]; /* room for two payload bytes + NUL: the lead byte would fit, its continuation not+ */+ int len = cbm_json_escape(buf, sizeof(buf), "a\xC3\xA9");+ ASSERT_STR_EQ(buf, "a");+ ASSERT_EQ(len, 1);++ char whole[4];+ len = cbm_json_escape(whole, sizeof(whole), "a\xC3\xA9");+ ASSERT_STR_EQ(whole, "a\xC3\xA9");+ ASSERT_EQ(len, 3);++ /* A four-byte sequence cut after two bytes is dropped whole. */+ char emoji[3];+ len = cbm_json_escape(emoji, sizeof(emoji), "\xF0\x9F\x98\x80z");+ ASSERT_STR_EQ(emoji, "");+ ASSERT_EQ(len, 0);+ PASS();+}+/* ── SNPRINTF_APPEND tests ────────────────────────────────────── */TEST(snprintf_append_basic) {@@ -547,6 +571,7 @@ SUITE(str_util) {RUN_TEST(validate_shell_arg_spaces);/* JSON Escaping */RUN_TEST(json_escape_control_chars);+ RUN_TEST(json_escape_never_splits_utf8);/* SNPRINTF_APPEND */RUN_TEST(snprintf_append_basic);RUN_TEST(snprintf_append_fills_exactly);