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
perf(mcp): fast query tools on every platform
Martin Vogelc9cacdf0186c
diff --git a/src/cypher/cypher.c b/src/cypher/cypher.cindex 1889efe8a..5f29be2b7 100644--- a/src/cypher/cypher.c+++ b/src/cypher/cypher.c@@ -3716,6 +3716,113 @@ static void expand_pattern_rels(cbm_store_t *store, cbm_pattern_t *pat, binding_}}+/* ── Sorting and key lookup ────────────────────────────────────────+ * ORDER BY, GROUP BY and DISTINCT used to compare every row with every other+ * row (bubble sorts, linear group and duplicate scans). These helpers keep the+ * exact same comparisons and keys, in O(n log n) and O(n). */++/* Compare items a and b; positive means a sorts after b. */+typedef int (*cypher_index_cmp_fn)(const void *ctx, int a, int b);++/* Stable sort of idx[0..n). Both this and the bubble sorts it replaces are+ * stable, so for any consistent ordering they give the same permutation. An+ * item moves before an earlier one only when cmp(earlier, item) > 0, which is+ * the bubble sorts' swap test. Without scratch memory it degrades to an+ * insertion sort with the same test and result. */+static void cypher_stable_sort(int *idx, int n, cypher_index_cmp_fn cmp, const void *ctx) {+ if (n < PAIR_LEN) {+ return;+ }+ int *tmp = malloc((size_t)n * sizeof(int));+ if (!tmp) {+ for (int i = SKIP_ONE; i < n; i++) {+ for (int j = i; j > 0 && cmp(ctx, idx[j - SKIP_ONE], idx[j]) > 0; j--) {+ int swap = idx[j];+ idx[j] = idx[j - SKIP_ONE];+ idx[j - SKIP_ONE] = swap;+ }+ }+ return;+ }+ for (int64_t width = SKIP_ONE; width < n; width *= PAIR_LEN) {+ for (int64_t lo = 0; lo < n; lo += PAIR_LEN * width) {+ int64_t mid = lo + width < n ? lo + width : n;+ int64_t hi = mid + width < n ? mid + width : n;+ int64_t i = lo;+ int64_t j = mid;+ int64_t k = lo;+ while (i < mid && j < hi) {+ tmp[k++] = cmp(ctx, idx[i], idx[j]) > 0 ? idx[j++] : idx[i++];+ }+ while (i < mid) {+ tmp[k++] = idx[i++];+ }+ while (j < hi) {+ tmp[k++] = idx[j++];+ }+ }+ memcpy(idx, tmp, (size_t)n * sizeof(int));+ }+ free(tmp);+}++/* String key → the index it was first recorded with. Keys are copied: the+ * arrays they mirror are reallocated as they grow. */+typedef struct {+ CBMHashTable *table;+ char **keys;+ int count;+ int cap;+ bool failed; /* an allocation failed: callers fall back to their scans */+} cypher_key_index_t;++/* The recorded index, CYP_FOUND_NONE, or KEY_INDEX_UNKNOWN after a failed+ * allocation (the caller then scans, so a result never depends on memory). */+enum { KEY_INDEX_UNKNOWN = -2 };++static int key_index_find(const cypher_key_index_t *ix, const char *key) {+ if (ix->failed) {+ return KEY_INDEX_UNKNOWN;+ }+ void *value = ix->table ? cbm_ht_get(ix->table, key) : NULL;+ return value ? (int)((intptr_t)value - SKIP_ONE) : CYP_FOUND_NONE;+}++static void key_index_add(cypher_key_index_t *ix, const char *key, int index) {+ if (ix->failed) {+ return;+ }+ if (!ix->table) {+ ix->table = cbm_ht_create(CBM_SZ_256);+ }+ if (ix->table && ix->count >= ix->cap) {+ int cap = ix->cap ? ix->cap * PAIR_LEN : CBM_SZ_256;+ char **keys = realloc(ix->keys, (size_t)cap * sizeof(char *));+ if (keys) {+ ix->keys = keys;+ ix->cap = cap;+ }+ }+ char *copy = ix->table && ix->count < ix->cap ? heap_strdup(key) : NULL;+ if (!copy) {+ ix->failed = true;+ return;+ }+ ix->keys[ix->count++] = copy;+ (void)cbm_ht_set(ix->table, copy, (void *)(intptr_t)(index + SKIP_ONE));+}++static void key_index_free(cypher_key_index_t *ix) {+ if (ix->table) {+ cbm_ht_free(ix->table);+ }+ for (int i = 0; i < ix->count; i++) {+ free(ix->keys[i]);+ }+ free(ix->keys);+ memset(ix, 0, sizeof(*ix));+}+/* ── Result postprocessing helpers ─────────────────────────────── *//* Find the column index for one ORDER BY key, checking both column names and@@ -3755,6 +3862,43 @@ static bool rb_is_numeric_column(const result_builder_t *rb, int col) {return false;}+typedef struct {+ const int *cols;+ const bool *numeric;+ const bool *descs;+ int keys;+ const char ***rows; /* the rows in their pre-sort order */+ const int *values; /* numeric keys parsed once: values[row * keys + k], or NULL */+} rb_order_ctx_t;++/* One ORDER BY comparison: numeric columns by their (int)strtol value,+ * others by strcmp, a later key breaking ties; positive = a after b.+ * va/vb are the rows' parsed numeric keys, or NULL to parse here. */+static int rb_order_compare_rows(const rb_order_ctx_t *ctx, const char **ra, const char **rb_row,+ const int *va, const int *vb) {+ int cmp = 0;+ for (int k = 0; k < ctx->keys && cmp == 0; k++) {+ if (ctx->numeric[k]) {+ int a = va ? va[k] : (int)strtol(ra[ctx->cols[k]], NULL, CBM_DECIMAL_BASE);+ int b = vb ? vb[k] : (int)strtol(rb_row[ctx->cols[k]], NULL, CBM_DECIMAL_BASE);+ cmp = (a > b) - (a < b);+ } else {+ cmp = strcmp(ra[ctx->cols[k]], rb_row[ctx->cols[k]]);+ }+ if (ctx->descs[k]) {+ cmp = -cmp;+ }+ }+ return cmp;+}++static int rb_order_compare(const void *context, int a, int b) {+ const rb_order_ctx_t *ctx = context;+ const int *va = ctx->values ? ctx->values + (size_t)a * (size_t)ctx->keys : NULL;+ const int *vb = ctx->values ? ctx->values + (size_t)b * (size_t)ctx->keys : NULL;+ return rb_order_compare_rows(ctx, ctx->rows[a], ctx->rows[b], va, vb);+}+static void rb_apply_order_by(result_builder_t *rb, const cbm_return_clause_t *ret) {if (ret->order_key_count == 0) {return;@@ -3776,30 +3920,46 @@ static void rb_apply_order_by(result_builder_t *rb, const cbm_return_clause_t *rdescs[keys] = ret->order_descs[k];keys++;}- if (keys == 0) {+ if (keys == 0 || rb->row_count < PAIR_LEN) {return;}- for (int i = 0; i < rb->row_count - SKIP_ONE; i++) {- for (int j = 0; j < rb->row_count - i - SKIP_ONE; j++) {- int cmp = 0;- for (int k = 0; k < keys && cmp == 0; k++) {- if (numeric[k]) {- cmp = (int)strtol(rb->rows[j][cols[k]], NULL, CBM_DECIMAL_BASE) -- (int)strtol(rb->rows[j + SKIP_ONE][cols[k]], NULL, CBM_DECIMAL_BASE);- } else {- cmp = strcmp(rb->rows[j][cols[k]], rb->rows[j + SKIP_ONE][cols[k]]);- }- if (descs[k]) {- cmp = -cmp;- }- }- if (cmp > 0) {+ int n = rb->row_count;+ rb_order_ctx_t ctx = {.cols = cols, .numeric = numeric, .descs = descs, .keys = keys};+ int *idx = malloc((size_t)n * sizeof(int));+ const char ***rows = malloc((size_t)n * sizeof(const char **));+ if (!idx || !rows) {+ /* No scratch memory: insertion sort in place, same comparisons. */+ free(idx);+ free(rows);+ for (int i = SKIP_ONE; i < n; i++) {+ for (int j = i; j > 0 && rb_order_compare_rows(&ctx, rb->rows[j - SKIP_ONE],+ rb->rows[j], NULL, NULL) > 0;+ j--) {const char **tmp = rb->rows[j];- rb->rows[j] = rb->rows[j + SKIP_ONE];- rb->rows[j + SKIP_ONE] = tmp;+ rb->rows[j] = rb->rows[j - SKIP_ONE];+ rb->rows[j - SKIP_ONE] = tmp;}}+ return;+ }+ int *values = malloc((size_t)n * (size_t)keys * sizeof(int));+ for (int r = 0; r < n; r++) {+ idx[r] = r;+ rows[r] = rb->rows[r];+ for (int k = 0; values && k < keys; k++) {+ values[(size_t)r * (size_t)keys + (size_t)k] =+ numeric[k] ? (int)strtol(rb->rows[r][cols[k]], NULL, CBM_DECIMAL_BASE) : 0;+ }}+ ctx.rows = rows;+ ctx.values = values;+ cypher_stable_sort(idx, n, rb_order_compare, &ctx);+ for (int r = 0; r < n; r++) {+ rb->rows[r] = rows[idx[r]];+ }+ free(values);+ free(rows);+ free(idx);}static void rb_apply_skip_limit(result_builder_t *rb, int skip_n, int limit,@@ -3838,25 +3998,60 @@ static void rb_apply_skip_limit(result_builder_t *rb, int skip_n, int limit,}}+/* A row's DISTINCT identity: every column, length-prefixed so no value can+ * run into the next — equal keys exactly when every column is equal. Built in+ * *buf (grown as needed); NULL when out of memory. */+static const char *rb_row_key(const result_builder_t *rb, const char **row, char **buf,+ size_t *cap) {+ size_t need = SKIP_ONE;+ for (int c = 0; c < rb->col_count; c++) {+ need += strlen(row[c]) + CBM_SZ_32;+ }+ if (need > *cap) {+ char *grown = realloc(*buf, need);+ if (!grown) {+ return NULL;+ }+ *buf = grown;+ *cap = need;+ }+ size_t used = 0;+ (*buf)[0] = '\0';+ for (int c = 0; c < rb->col_count; c++) {+ used += (size_t)snprintf(*buf + used, *cap - used, "%zu:%s", strlen(row[c]), row[c]);+ }+ return *buf;+}++/* Whether row i equals one of the first `kept` rows, column by column. */+static bool rb_row_seen_before(const result_builder_t *rb, int i, int kept) {+ for (int j = 0; j < kept; j++) {+ bool same = true;+ for (int c = 0; c < rb->col_count && same; c++) {+ same = strcmp(rb->rows[i][c], rb->rows[j][c]) == 0;+ }+ if (same) {+ return true;+ }+ }+ return false;+}+static void rb_apply_distinct(result_builder_t *rb) {if (rb->row_count <= SKIP_ONE) {return;}- int kept = SKIP_ONE;- for (int i = SKIP_ONE; i < rb->row_count; i++) {- bool dup = false;- for (int j = 0; j < kept && !dup; j++) {- bool same = true;- for (int c = 0; c < rb->col_count && same; c++) {- if (strcmp(rb->rows[i][c], rb->rows[j][c]) != 0) {- same = false;- }- }- if (same) {- dup = true;- }- }+ cypher_key_index_t seen = {0};+ char *key_buf = NULL;+ size_t key_cap = 0;+ int kept = 0;+ for (int i = 0; i < rb->row_count; i++) {+ const char *key = rb_row_key(rb, rb->rows[i], &key_buf, &key_cap);+ seen.failed = seen.failed || !key;+ int found = key_index_find(&seen, key);+ bool dup = found == KEY_INDEX_UNKNOWN ? rb_row_seen_before(rb, i, kept) : found >= 0;if (!dup) {+ key_index_add(&seen, key, kept);if (kept != i) {rb->rows[kept] = rb->rows[i];}@@ -3869,6 +4064,8 @@ static void rb_apply_distinct(result_builder_t *rb) {}}rb->row_count = kept;+ key_index_free(&seen);+ free(key_buf);}static void rb_free(result_builder_t *rb) {@@ -4113,17 +4310,57 @@ static bool is_aggregate_func(const char *func) {strcmp(func, "MIN") == 0 || strcmp(func, "MAX") == 0 || strcmp(func, "COLLECT") == 0);}+/* Grow a string list for one more entry at `idx`: the capacity doubles at+ * every power of two, so n appends cost O(n) copying, not O(n^2). */+static char **string_list_reserve(char **list, int idx) {+ if (idx > 0 && (idx & (idx - SKIP_ONE)) != 0) {+ return list; /* capacity is the next power of two above idx */+ }+ return safe_realloc(list, (size_t)(idx ? idx * PAIR_LEN : SKIP_ONE) * sizeof(char *));+}++enum { DISTINCT_SET_MIN = 16 }; /* below this a set is scanned, not hashed */+/* Append `val` to a string list only if not already present — i.e. maintain a- * set of distinct values. Used by COUNT(DISTINCT x) (#239). */-static void distinct_list_add(char ***list, int *count, const char *val) {- for (int i = 0; i < *count; i++) {- if (strcmp((*list)[i], val) == 0) {+ * set of distinct values. Used by COUNT(DISTINCT x) (#239). Past+ * DISTINCT_SET_MIN values the membership test goes through *set, whose keys+ * are the list's own strings; a set that cannot be built stays a scan. */+static void distinct_list_add(char ***list, int *count, CBMHashTable **set, const char *val) {+ if (*set) {+ if (cbm_ht_has(*set, val)) {return;}+ } else {+ for (int i = 0; i < *count; i++) {+ if (strcmp((*list)[i], val) == 0) {+ return;+ }+ }+ }+ int idx = *count;+ *list = string_list_reserve(*list, idx);+ char *copy = *list ? heap_strdup(val) : NULL;+ if (!copy) {+ /* Out of memory: keep a consistent (possibly emptied) set. */+ if (!*list) {+ *count = 0;+ if (*set) {+ cbm_ht_free(*set);+ *set = NULL;+ }+ }+ return;+ }+ (*list)[idx] = copy;+ (*count)++;+ if (*set) {+ (void)cbm_ht_set(*set, (*list)[idx], (void *)SKIP_ONE);+ } else if (*count >= DISTINCT_SET_MIN) {+ *set = cbm_ht_create(CBM_SZ_64);+ for (int i = 0; *set && i < *count; i++) {+ (void)cbm_ht_set(*set, (*list)[i], (void *)SKIP_ONE);+ }}- int idx = (*count)++;- *list = safe_realloc(*list, (size_t)(idx + SKIP_ONE) * sizeof(char *));- (*list)[idx] = heap_strdup(val);}/* Resolve one WITH ORDER BY key on a projected binding. The key is either a@@ -4150,31 +4387,109 @@ static const char *order_key_value(binding_t *b, const char *key) {return binding_get_virtual(b, var, dot + SKIP_ONE);}-/* Sort bindings by the ORDER BY key list (virtual variables) using bubble- * sort; later keys break ties, direction is per key (#1334). */+/* One WITH ORDER BY key comparison: numerically when both values start with a+ * number, else by strcmp; positive = a after b. */+static int with_order_compare_value(const char *va, const char *vb) {+ char *ea = NULL;+ char *eb = NULL;+ double da = strtod(va, &ea);+ double db = strtod(vb, &eb);+ return (ea != va && eb != vb) ? ((da > db) - (da < db)) : strcmp(va, vb);+}++/* The full comparison over the ORDER BY key list: later keys break ties,+ * direction is per key (#1334). */+static int with_order_compare_bindings(const cbm_return_clause_t *wc, binding_t *a, binding_t *b) {+ int cmp = 0;+ for (int k = 0; k < wc->order_key_count && cmp == 0; k++) {+ cmp = with_order_compare_value(order_key_value(a, wc->order_keys[k]),+ order_key_value(b, wc->order_keys[k]));+ if (wc->order_descs[k]) {+ cmp = -cmp;+ }+ }+ return cmp;+}++typedef struct {+ const cbm_return_clause_t *wc;+ char **values; /* values[i * keys + k]: owned copy of binding i's key k */+ bool *numbered; /* whether strtod consumed a number from that value */+ double *numbers;+} with_order_ctx_t;++/* The same comparison on values resolved once per binding. order_key_value+ * may return a rotating thread-local buffer, so the values are copies. */+static int with_order_compare(const void *context, int a, int b) {+ const with_order_ctx_t *ctx = context;+ size_t keys = (size_t)ctx->wc->order_key_count;+ int cmp = 0;+ for (size_t k = 0; k < keys && cmp == 0; k++) {+ size_t ia = (size_t)a * keys + k;+ size_t ib = (size_t)b * keys + k;+ if (ctx->numbered[ia] && ctx->numbered[ib]) {+ cmp = (ctx->numbers[ia] > ctx->numbers[ib]) - (ctx->numbers[ia] < ctx->numbers[ib]);+ } else {+ cmp = strcmp(ctx->values[ia], ctx->values[ib]);+ }+ if (ctx->wc->order_descs[k]) {+ cmp = -cmp;+ }+ }+ return cmp;+}++/* Sort bindings by the ORDER BY key list (virtual variables), stably. */static void sort_bindings(binding_t *vbindings, int count, const cbm_return_clause_t *wc) {- for (int i = 0; i < count - SKIP_ONE; i++) {- for (int j = 0; j < count - i - SKIP_ONE; j++) {- int cmp = 0;- for (int k = 0; k < wc->order_key_count && cmp == 0; k++) {- const char *va = order_key_value(&vbindings[j], wc->order_keys[k]);- const char *vb2 = order_key_value(&vbindings[j + SKIP_ONE], wc->order_keys[k]);- char *ea = NULL;- char *eb = NULL;- double da = strtod(va, &ea);- double db = strtod(vb2, &eb);- cmp = (ea != va && eb != vb2) ? ((da > db) - (da < db)) : strcmp(va, vb2);- if (wc->order_descs[k]) {- cmp = -cmp;- }- }- if (cmp > 0) {+ if (count < PAIR_LEN || wc->order_key_count <= 0) {+ return;+ }+ size_t keys = (size_t)wc->order_key_count;+ size_t cells = (size_t)count * keys;+ with_order_ctx_t ctx = {.wc = wc,+ .values = calloc(cells, sizeof(char *)),+ .numbered = calloc(cells, sizeof(bool)),+ .numbers = calloc(cells, sizeof(double))};+ int *idx = malloc((size_t)count * sizeof(int));+ binding_t *sorted = malloc((size_t)count * sizeof(binding_t));+ bool ready = ctx.values && ctx.numbered && ctx.numbers && idx && sorted;+ for (int i = 0; ready && i < count; i++) {+ idx[i] = i;+ for (size_t k = 0; ready && k < keys; k++) {+ size_t cell = (size_t)i * keys + k;+ ctx.values[cell] = heap_strdup(order_key_value(&vbindings[i], wc->order_keys[k]));+ ready = ctx.values[cell] != NULL;+ char *end = NULL;+ ctx.numbers[cell] = ready ? strtod(ctx.values[cell], &end) : 0;+ ctx.numbered[cell] = ready && end != ctx.values[cell];+ }+ }+ if (ready) {+ cypher_stable_sort(idx, count, with_order_compare, &ctx);+ for (int i = 0; i < count; i++) {+ sorted[i] = vbindings[idx[i]];+ }+ memcpy(vbindings, sorted, (size_t)count * sizeof(binding_t));+ } else {+ /* No scratch memory: insertion sort in place, same comparisons. */+ for (int i = SKIP_ONE; i < count; i++) {+ for (int j = i; j > 0 && with_order_compare_bindings(wc, &vbindings[j - SKIP_ONE],+ &vbindings[j]) > 0;+ j--) {binding_t tmp = vbindings[j];- vbindings[j] = vbindings[j + SKIP_ONE];- vbindings[j + SKIP_ONE] = tmp;+ vbindings[j] = vbindings[j - SKIP_ONE];+ vbindings[j - SKIP_ONE] = tmp;}}}+ for (size_t c = 0; ctx.values && c < cells; c++) {+ free(ctx.values[c]);+ }+ free(ctx.values);+ free(ctx.numbered);+ free(ctx.numbers);+ free(idx);+ free(sorted);}/* Apply skip and limit to a binding array, freeing discarded entries */@@ -4230,9 +4545,10 @@ typedef struct {double *sums;int *counts;double *mins, *maxs;- char ***distinct_lists; /* per-item set of seen values for COUNT(DISTINCT) */- int *distinct_n; /* per-item distinct count (#239) */- cbm_node_t *group_nodes; /* per-item carried node (deep copy; id 0 = not a node) */+ char ***distinct_lists; /* per-item set of seen values for COUNT(DISTINCT) */+ int *distinct_n; /* per-item distinct count (#239) */+ CBMHashTable **distinct_sets; /* per-item hash over distinct_lists (lazy) */+ cbm_node_t *group_nodes; /* per-item carried node (deep copy; id 0 = not a node) */} with_agg_t;/* A WITH item that is a bare, bound node variable (`WITH f`, `WITH f AS g`)@@ -4278,18 +4594,24 @@ static int with_agg_build_key(cbm_return_clause_t *wc, binding_t *b, char *key,/* Find or create an aggregation group. Returns index. */static int with_agg_find_or_create(with_agg_t **aggs, int *agg_cnt, int *agg_cap,- cbm_return_clause_t *wc, binding_t *b, const char *key) {- for (int a = 0; a < *agg_cnt; a++) {+ cypher_key_index_t *groups, cbm_return_clause_t *wc,+ binding_t *b, const char *key) {+ int existing = key_index_find(groups, key);+ for (int a = 0; existing == KEY_INDEX_UNKNOWN && a < *agg_cnt; a++) {if (strcmp((*aggs)[a].group_key, key) == 0) {- return a;+ existing = a;}}+ if (existing >= 0) {+ return existing;+ }if (*agg_cnt >= *agg_cap) {*agg_cap *= PAIR_LEN;*aggs = safe_realloc(*aggs, *agg_cap * sizeof(with_agg_t));}int found = (*agg_cnt)++;snprintf((*aggs)[found].group_key, sizeof((*aggs)[found].group_key), "%s", key);+ key_index_add(groups, (*aggs)[found].group_key, found);(*aggs)[found].group_vals = calloc(wc->count, sizeof(const char *));(*aggs)[found].sums = calloc(wc->count, sizeof(double));(*aggs)[found].counts = calloc(wc->count, sizeof(int));@@ -4297,6 +4619,7 @@ static int with_agg_find_or_create(with_agg_t **aggs, int *agg_cnt, int *agg_cap(*aggs)[found].maxs = calloc(wc->count, sizeof(double));(*aggs)[found].distinct_lists = calloc(wc->count, sizeof(char **));(*aggs)[found].distinct_n = calloc(wc->count, sizeof(int));+ (*aggs)[found].distinct_sets = calloc(wc->count, sizeof(CBMHashTable *));(*aggs)[found].group_nodes = calloc(wc->count, sizeof(cbm_node_t));for (int ci = 0; ci < wc->count; ci++) {(*aggs)[found].mins[ci] = CYP_DBL_MAX;@@ -4327,7 +4650,8 @@ static void with_agg_accumulate(with_agg_t *agg, cbm_return_clause_t *wc, bindinagg->counts[ci]++;const char *raw = binding_get_virtual(b, wc->items[ci].variable, wc->items[ci].property);if (wc->items[ci].distinct && strcmp(wc->items[ci].func, "COUNT") == 0) {- distinct_list_add(&agg->distinct_lists[ci], &agg->distinct_n[ci], raw);+ distinct_list_add(&agg->distinct_lists[ci], &agg->distinct_n[ci],+ &agg->distinct_sets[ci], raw);}double dv = strtod(raw, NULL);agg->sums[ci] += dv;@@ -4373,6 +4697,9 @@ static void with_agg_free(with_agg_t *aggs, int agg_cnt, int item_count) {for (int a = 0; a < agg_cnt; a++) {for (int ci = 0; ci < item_count; ci++) {safe_str_free(&aggs[a].group_vals[ci]);+ if (aggs[a].distinct_sets && aggs[a].distinct_sets[ci]) {+ cbm_ht_free(aggs[a].distinct_sets[ci]);+ }if (aggs[a].distinct_lists && aggs[a].distinct_lists[ci]) {for (int j = 0; j < aggs[a].distinct_n[ci]; j++) {free(aggs[a].distinct_lists[ci][j]);@@ -4387,6 +4714,7 @@ static void with_agg_free(with_agg_t *aggs, int agg_cnt, int item_count) {free(aggs[a].maxs);free(aggs[a].distinct_lists);free(aggs[a].distinct_n);+ free(aggs[a].distinct_sets);if (aggs[a].group_nodes) {for (int ci = 0; ci < item_count; ci++) {node_fields_free(&aggs[a].group_nodes[ci]);@@ -4403,13 +4731,16 @@ static void execute_with_aggregate(cbm_return_clause_t *wc, binding_t *bindings,int agg_cap = CBM_SZ_256;with_agg_t *aggs = calloc(agg_cap, sizeof(with_agg_t));int agg_cnt = 0;+ cypher_key_index_t groups = {0};for (int bi = 0; bi < bind_count; bi++) {char key[CBM_SZ_1K] = "";with_agg_build_key(wc, &bindings[bi], key, sizeof(key));- int found = with_agg_find_or_create(&aggs, &agg_cnt, &agg_cap, wc, &bindings[bi], key);+ int found =+ with_agg_find_or_create(&aggs, &agg_cnt, &agg_cap, &groups, wc, &bindings[bi], key);with_agg_accumulate(&aggs[found], wc, &bindings[bi]);}+ key_index_free(&groups);*vbindings = safe_realloc(*vbindings, (agg_cnt + SKIP_ONE) * sizeof(binding_t));if (!*vbindings) {@@ -4505,22 +4836,23 @@ static void with_proj_key(cbm_return_clause_t *wc, binding_t *b, char *key, size/* Apply WITH DISTINCT: drop projected rows whose value tuple duplicates an* earlier one, keeping first occurrence (#238 — previously silently ignored). */static void with_apply_distinct(cbm_return_clause_t *wc, binding_t *vbindings, int *vcount) {+ cypher_key_index_t seen = {0};int kept = 0;for (int i = 0; i < *vcount; i++) {char key[CBM_SZ_1K];with_proj_key(wc, &vbindings[i], key, sizeof(key));- bool dup = false;- for (int j = 0; j < kept; j++) {+ int found = key_index_find(&seen, key);+ for (int j = 0; found == KEY_INDEX_UNKNOWN && j < kept; j++) {char pkey[CBM_SZ_1K];with_proj_key(wc, &vbindings[j], pkey, sizeof(pkey));if (strcmp(key, pkey) == 0) {- dup = true;- break;+ found = j;}}- if (dup) {+ if (found >= 0) {binding_free(&vbindings[i]);} else {+ key_index_add(&seen, key, kept);if (kept != i) {vbindings[kept] = vbindings[i];}@@ -4528,6 +4860,7 @@ static void with_apply_distinct(cbm_return_clause_t *wc, binding_t *vbindings, i}}*vcount = kept;+ key_index_free(&seen);}static void execute_with_clause(cbm_query_t *q, binding_t **bindings_ptr, int *bind_count_ptr) {@@ -4774,6 +5107,7 @@ typedef struct {double *mins, *maxs;char ***collect_lists;int *collect_counts;+ CBMHashTable **distinct_sets; /* per-item hash over a COUNT(DISTINCT) list (lazy) */} ret_agg_entry_t;/* Initialize a new RETURN aggregation group */@@ -4790,6 +5124,7 @@ static void ret_agg_init_group(ret_agg_entry_t *entry, const char *key, int itementry->maxs = calloc(item_count, sizeof(double));entry->collect_lists = calloc(item_count, sizeof(char **));entry->collect_counts = calloc(item_count, sizeof(int));+ entry->distinct_sets = calloc(item_count, sizeof(CBMHashTable *));for (int ci = 0; ci < item_count; ci++) {entry->mins[ci] = CYP_DBL_MAX;entry->maxs[ci] = -CYP_DBL_MAX;@@ -4836,13 +5171,18 @@ static void ret_agg_accumulate(ret_agg_entry_t *entry, cbm_return_clause_t *ret,entry->maxs[ci] = dv;}if (strcmp(ret->items[ci].func, "COLLECT") == 0) {- int idx = entry->collect_counts[ci]++;- entry->collect_lists[ci] =- safe_realloc(entry->collect_lists[ci], (idx + SKIP_ONE) * sizeof(char *));+ int idx = entry->collect_counts[ci];+ entry->collect_lists[ci] = string_list_reserve(entry->collect_lists[ci], idx);+ if (!entry->collect_lists[ci]) {+ entry->collect_counts[ci] = 0;+ continue;+ }entry->collect_lists[ci][idx] = heap_strdup(raw);+ entry->collect_counts[ci]++;} else if (ret->items[ci].distinct && strcmp(ret->items[ci].func, "COUNT") == 0) {/* COUNT(DISTINCT x): track unique values; emit the set size (#239). */- distinct_list_add(&entry->collect_lists[ci], &entry->collect_counts[ci], raw);+ distinct_list_add(&entry->collect_lists[ci], &entry->collect_counts[ci],+ &entry->distinct_sets[ci], raw);}}}@@ -4852,6 +5192,9 @@ static void ret_agg_free(ret_agg_entry_t *aggs, int agg_count, int item_count) {for (int a = 0; a < agg_count; a++) {for (int ci = 0; ci < item_count; ci++) {safe_str_free(&aggs[a].group_vals[ci]);+ if (aggs[a].distinct_sets && aggs[a].distinct_sets[ci]) {+ cbm_ht_free(aggs[a].distinct_sets[ci]);+ }for (int j = 0; j < aggs[a].collect_counts[ci]; j++) {free(aggs[a].collect_lists[ci][j]);}@@ -4864,6 +5207,7 @@ static void ret_agg_free(ret_agg_entry_t *aggs, int agg_count, int item_count) {free(aggs[a].maxs);free(aggs[a].collect_lists);free(aggs[a].collect_counts);+ free(aggs[a].distinct_sets);}free(aggs);}@@ -4921,10 +5265,11 @@ static void execute_return_agg(cbm_return_clause_t *ret, binding_t *bindings, inint agg_cap = CBM_SZ_256;ret_agg_entry_t *aggs = calloc(agg_cap, sizeof(ret_agg_entry_t));int agg_count = 0;+ cypher_key_index_t groups = {0};for (int bi = 0; bi < bind_count; bi++) {- /* #601: grouping is O(bindings x groups) — the dominant cost on a- * whole-graph GROUP BY. Abort if we blow the wall-clock budget. */+ /* #601: a whole-graph GROUP BY visits every binding. Abort if we blow+ * the wall-clock budget. */if ((bi & CYPHER_DEADLINE_CHECK_MASK) == 0 && cypher_deadline_exceeded()) {break;}@@ -4933,11 +5278,10 @@ static void execute_return_agg(cbm_return_clause_t *ret, binding_t *bindings, inchar valbufs[CBM_SZ_32][CBM_SZ_512];ret_agg_build_key(ret, &bindings[bi], key, sizeof(key), vals, valbufs);- int found = CYP_FOUND_NONE;- for (int a = 0; a < agg_count; a++) {+ int found = key_index_find(&groups, key);+ for (int a = 0; found == KEY_INDEX_UNKNOWN && a < agg_count; a++) {if (strcmp(aggs[a].group_key, key) == 0) {found = a;- break;}}if (found < 0) {@@ -4947,9 +5291,11 @@ static void execute_return_agg(cbm_return_clause_t *ret, binding_t *bindings, in}found = agg_count++;ret_agg_init_group(&aggs[found], key, ret->count, vals);+ key_index_add(&groups, aggs[found].group_key, found);}ret_agg_accumulate(&aggs[found], ret, &bindings[bi]);}+ key_index_free(&groups);for (int a = 0; a < agg_count; a++) {ret_agg_emit_row(ret, &aggs[a], rb);diff --git a/src/git/git_context.c b/src/git/git_context.cindex f0be0c4b5..2bd8cf564 100644--- a/src/git/git_context.c+++ b/src/git/git_context.c@@ -313,6 +313,30 @@ int cbm_git_context_resolve(const char *path, cbm_git_context_t *out) {return 0;}+int cbm_git_branch_resolve(const char *path, bool *is_git, char **branch) {+ if (!is_git || !branch) {+ return CBM_NOT_FOUND;+ }+ *is_git = false;+ *branch = NULL;+ if (!path || !path[0]) {+ return CBM_NOT_FOUND;+ }+ if (!cbm_is_dir(path)) {+ return 0;+ }+ char *worktree_root = NULL;+ if (git_capture(path, "rev-parse --show-toplevel", &worktree_root) != 0) {+ return 0;+ }+ free(worktree_root);+ *is_git = true;+ if (git_capture(path, "symbolic-ref --quiet --short HEAD", branch) != 0) {+ *branch = git_strdup("DETACHED");+ }+ return *branch ? 0 : CBM_NOT_FOUND;+}+char *cbm_git_context_branch_qn(const char *project_name, const cbm_git_context_t *ctx) {const char *project = project_name && project_name[0] ? project_name : "project";const char *slug = "working-tree";diff --git a/src/git/git_context.h b/src/git/git_context.hindex 876309eb6..31dd4babf 100644--- a/src/git/git_context.h+++ b/src/git/git_context.h@@ -20,6 +20,10 @@ typedef struct {} cbm_git_context_t;int cbm_git_context_resolve(const char *path, cbm_git_context_t *out);+/* Only the is_git and branch fields of cbm_git_context_resolve, from the same+ * two git commands it uses for them (2 git processes instead of 7). *branch+ * is heap-owned, NULL when path is not in a git work tree. */+int cbm_git_branch_resolve(const char *path, bool *is_git, char **branch);void cbm_git_context_free(cbm_git_context_t *ctx);char *cbm_git_context_branch_qn(const char *project_name, const cbm_git_context_t *ctx);int cbm_git_context_props_json(const cbm_git_context_t *ctx, char *buf, int buf_size);diff --git a/src/mcp/mcp.c b/src/mcp/mcp.cindex 03741e23a..f94c04e26 100644--- a/src/mcp/mcp.c+++ b/src/mcp/mcp.c@@ -82,6 +82,7 @@ enum {#include "foundation/compat_thread.h"#include "foundation/log.h"#include "foundation/limits.h"+#include "foundation/hash_table.h"#include "foundation/subprocess.h"#include "foundation/sha256.h"#include "mcp/index_supervisor.h"@@ -1863,6 +1864,7 @@ struct cbm_mcp_server {cbm_mcp_snapshot_read_test_hook_fn snapshot_read_test_hook;void *snapshot_read_test_context;#endif+ bool read_batch_tool; /* this request's store reads run in a read batch */size_t search_output_limit_override;const char *search_scan_command_override;const char *search_scratch_dir_override; /* NULL = cbm_tmpdir() */@@ -2648,7 +2650,11 @@ static cbm_store_t *resolve_store_internal(cbm_mcp_server_t *srv, const char *prstatic cbm_store_t *resolve_store(cbm_mcp_server_t *srv, const char *project) {/* Query-only callers (every read tool): strictly non-mutating resolve. */- return resolve_store_internal(srv, project, false, false, NULL, false);+ cbm_store_t *store = resolve_store_internal(srv, project, false, false, NULL, false);+ if (store && srv->read_batch_tool) {+ (void)cbm_store_read_batch_begin(store);+ }+ return store;}/* Forward decl — definition lives below in handle_trace_call_path's helpers. */@@ -3018,16 +3024,17 @@ static bool populate_project_record(const char *dir_path, bool include_stats,* null for non-git roots — cost ~10KB across a full cache and is one* index_status call away for the project you actually care about. */if (record->root_path[0]) {- cbm_git_context_t gctx = {0};- (void)cbm_git_context_resolve(record->root_path, &gctx);- if (gctx.is_git && gctx.branch) {- record->branch = heap_strdup(gctx.branch);+ bool is_git = false;+ char *branch = NULL;+ (void)cbm_git_branch_resolve(record->root_path, &is_git, &branch);+ if (is_git && branch) {+ record->branch = heap_strdup(branch);if (!record->branch) {- cbm_git_context_free(&gctx);+ free(branch);return false;}}- cbm_git_context_free(&gctx);+ free(branch);}record->populated = true;return true;@@ -10431,20 +10438,33 @@ static char *read_file_lines(const char *path, int start, int end) {return NULL;}+ /* Whole line spans per memchr instead of one locked fgetc and one append+ * per byte: search_code's full mode reads the source of every result, and+ * the byte loop was half of a 500-result page. Same text-mode stream, so+ * Windows CRLF translation is unchanged. */+ enum { READ_FILE_LINES_CHUNK = 16384 };cbm_sb_t selected;cbm_sb_init(&selected);int lineno = 1;- int byte;- while ((byte = fgetc(fp)) != EOF) {- if (lineno >= start && lineno <= end) {- char ch = (char)byte;- cbm_sb_append_n(&selected, &ch, 1U);- }- if (byte == '\n') {- if (lineno >= end) {- break;+ char chunk[READ_FILE_LINES_CHUNK];+ bool done = false;+ size_t got;+ while (!done && (got = fread(chunk, 1, sizeof(chunk), fp)) > 0) {+ size_t pos = 0;+ while (pos < got) {+ const char *newline = memchr(chunk + pos, '\n', got - pos);+ size_t span_end = newline ? (size_t)(newline - chunk) + SKIP_ONE : got;+ if (lineno >= start && lineno <= end) {+ cbm_sb_append_n(&selected, chunk + pos, span_end - pos);+ }+ pos = span_end;+ if (newline) {+ if (lineno >= end) {+ done = true;+ break;+ }+ lineno++;}- lineno++;}}@@ -12738,6 +12758,64 @@ bool cbm_path_within_root(const char *root_path, const char *abs_path) {return false;}+/* cbm_path_within_root with the root resolved once per request: search_code+ * checks every hit file and every rendered result against the same root, and+ * resolving the root again for each check was a third of a 500-result page.+ * An unresolvable root fails every check, exactly as cbm_path_within_root. */+typedef struct {+ char canonical[CBM_SZ_4K];+ bool resolved;+ /* Verdict per absolute path, for the life of one request: the reply is+ * rendered up to dozens of times while it is fitted to its byte budget,+ * and each render checks every result's file again. Keys are owned. */+ CBMHashTable *verdicts;+} root_containment_t;++enum { ROOT_CONTAINMENT_INSIDE = 1, ROOT_CONTAINMENT_OUTSIDE = 2 };++static void root_containment_init(root_containment_t *containment, const char *root_path) {+ containment->verdicts = NULL;+ containment->resolved = root_path && resolve_canonical_path(root_path, containment->canonical,+ sizeof(containment->canonical));+}++static void root_containment_free_key(const char *key, void *value, void *userdata) {+ (void)value;+ (void)userdata;+ free((void *)key);+}++static void root_containment_free(root_containment_t *containment) {+ if (containment->verdicts) {+ cbm_ht_foreach(containment->verdicts, root_containment_free_key, NULL);+ cbm_ht_free(containment->verdicts);+ containment->verdicts = NULL;+ }+}++static bool root_containment_check(root_containment_t *containment, const char *abs_path) {+ if (!containment->resolved || !abs_path) {+ return false;+ }+ void *cached = containment->verdicts ? cbm_ht_get(containment->verdicts, abs_path) : NULL;+ if (cached) {+ return (uintptr_t)cached == ROOT_CONTAINMENT_INSIDE;+ }+ char real_file[CBM_SZ_4K];+ bool inside = resolve_canonical_path(abs_path, real_file, sizeof(real_file)) &&+ canonical_path_has_root(containment->canonical, real_file);+ if (!containment->verdicts) {+ containment->verdicts = cbm_ht_create(0);+ }+ char *key = containment->verdicts ? heap_strdup(abs_path) : NULL;+ if (key) {+ (void)cbm_ht_set(+ containment->verdicts, key,+ (void *)(uintptr_t)(inside ? ROOT_CONTAINMENT_INSIDE : ROOT_CONTAINMENT_OUTSIDE));+ }+ return inside;+}+/* #1690: a path-shaped `project` names a directory; the installed guidance tells* agents to pass their working directory. Turning it into the path-DERIVED name* alone missed a checkout indexed under an explicit name and every directory@@ -14285,7 +14363,7 @@ static yyjson_mut_val *build_dedup_files_array(yyjson_mut_doc *doc, search_resul/* Attach source or context lines to a search result JSON item. */static void attach_result_source(yyjson_mut_doc *doc, yyjson_mut_val *item, search_result_t *r,int mode, int context_lines, int source_max_lines,- const char *root_path) {+ const char *root_path, root_containment_t *containment) {enum { MODE_FULL = 1 };if (r->start_line <= 0 || r->end_line <= 0) {return;@@ -14307,7 +14385,7 @@ static void attach_result_source(yyjson_mut_doc *doc, yyjson_mut_val *item, sear* project root (a `..` segment, or a symlink/junction that discovery* followed) must not be read back into the response. Same guard the* snippet path already uses. */- if (!cbm_path_within_root(root_path, abs_path)) {+ if (!root_containment_check(containment, abs_path)) {free(abs_path);return;}@@ -14712,7 +14790,8 @@ static char *assemble_search_output(int gm_count, int result_start, int result_limit, int output_count, int raw_start,int raw_output, int directory_start, int directory_output, int raw_limit, int directory_limit,int match_limit, int mode, int context_lines, int source_max_lines, const char *root_path,- bool scan_saturated, bool warn_literal_pipe, const search_metrics_t *metrics, bool budget_hit) {+ bool scan_saturated, bool warn_literal_pipe, const search_metrics_t *metrics, bool budget_hit,+ root_containment_t *containment) {enum { MODE_COMPACT = 0, MODE_FULL = 1, MODE_FILES = 2, SEARCH_SLOW_MS = 5000 };yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);@@ -14769,7 +14848,8 @@ static char *assemble_search_output(yyjson_mut_arr_add_int(doc, row, r->out_degree);if (mode == MODE_FULL || attach_context) {yyjson_mut_val *src = yyjson_mut_obj(doc);- attach_result_source(doc, src, r, mode, context_lines, source_max_lines, root_path);+ attach_result_source(doc, src, r, mode, context_lines, source_max_lines, root_path,+ containment);yyjson_mut_arr_add_val(row, src);}yyjson_mut_arr_add_val(results_arr, row);@@ -14953,15 +15033,13 @@ static char *assemble_search_output(* form. Compact search has a purpose-built table renderer so repeated paths* and qualified-name prefixes can use the response-local directory. Full and* files mode first build the canonical JSON model, then project it to tree. */-static char *render_search_payload(search_result_t *sr, int sr_count, grep_match_t *raw,- int raw_count, int raw_content_truncated, int gm_count,- int result_start, int result_limit, int output_count,- int raw_start, int raw_output, int directory_start,- int directory_output, int raw_limit, int directory_limit,- int match_limit, int mode, int context_lines,- int source_max_lines, const char *root_path, bool scan_saturated,- bool warn_literal_pipe, const search_metrics_t *metrics,- bool budget_hit, bool json_format) {+static char *render_search_payload(+ search_result_t *sr, int sr_count, grep_match_t *raw, int raw_count, int raw_content_truncated,+ int gm_count, int result_start, int result_limit, int output_count, int raw_start,+ int raw_output, int directory_start, int directory_output, int raw_limit, int directory_limit,+ int match_limit, int mode, int context_lines, int source_max_lines, const char *root_path,+ bool scan_saturated, bool warn_literal_pipe, const search_metrics_t *metrics, bool budget_hit,+ bool json_format, root_containment_t *request_containment) {if (mode == 0 && !json_format) {return assemble_search_output_toon(sr, sr_count, raw, raw_count, raw_content_truncated,gm_count, result_start, result_limit, output_count,@@ -14970,11 +15048,22 @@ static char *render_search_payload(search_result_t *sr, int sr_count, grep_matchwarn_literal_pipe, metrics, budget_hit, -1);}+ /* A caller that renders once passes NULL; search_code passes the+ * containment it keeps for the whole request (see root_containment_t). */+ root_containment_t local_containment;+ root_containment_t *containment = request_containment;+ if (!containment) {+ root_containment_init(&local_containment, root_path);+ containment = &local_containment;+ }char *json = assemble_search_output(sr, sr_count, raw, raw_count, raw_content_truncated, gm_count, result_start, result_limit,output_count, raw_start, raw_output, directory_start, directory_output, raw_limit,directory_limit, match_limit, mode, context_lines, source_max_lines, root_path,- scan_saturated, warn_literal_pipe, metrics, budget_hit);+ scan_saturated, warn_literal_pipe, metrics, budget_hit, containment);+ if (!request_containment) {+ root_containment_free(&local_containment);+ }if (!json || json_format) {return json;}@@ -15016,7 +15105,7 @@ char *cbm_mcp_render_search_rows_for_testing(const char *const *qualified_names,char *payload =render_search_payload(results, row_count, NULL, 0, 0, row_count, 0, row_count, row_count, 0,0, 0, row_count, 0, row_count > 0 ? 1 : 0, row_count > 0 ? 1 : 0, 0,- 0, 0, "", false, false, &zero_metrics, false, json_format);+ 0, 0, "", false, false, &zero_metrics, false, json_format, NULL);free_search_results(results, initialized);return payload;}@@ -15250,7 +15339,7 @@ char *cbm_mcp_render_raw_preview_for_testing(const char *content, bool content_osearch_raw_preview(&raw, content, content_offset_set, content_offset, false, 0, 0);return render_search_payload(NULL, 0, &raw, 1, raw.content_truncated ? 1 : 0, 1, 0, 0, 0, 0, 1,0, 0, 1, 0, 0, 0, 0, 0, "", false, false, &zero_metrics, false,- json_format);+ json_format, NULL);}#endif@@ -15324,13 +15413,89 @@ static bool append_search_match_line(search_result_t *result, int line) {return true;}-/* Add a grep hit to the search result set (merge into existing or create new). */-static bool add_to_search_results(search_result_t **sr, int *sr_count, int *sr_cap, cbm_node_t *n,- int line) {- for (int j = 0; j < *sr_count; j++) {- if ((*sr)[j].node_id == n->id) {- return append_search_match_line(&(*sr)[j], line);+/* Node id -> index into the search result array, so merging a hit into its+ * node's result is O(1). Finding it by scanning every result so far made a+ * common pattern quadratic: `def ` on django is 33,672 hits against a result+ * list that grows to tens of thousands. Open addressing over a power-of-two+ * table; a slot stores index + 1, so 0 is free and no node id is reserved. */+typedef struct {+ int64_t *ids;+ int *slots;+ int capacity;+ int count;+} search_result_index_t;++enum { SEARCH_RESULT_INDEX_MIN_CAPACITY = 64 };++static uint32_t search_result_index_hash(int64_t id, int capacity) {+ uint64_t mixed = (uint64_t)id * UINT64_C(0x9E3779B97F4A7C15);+ return (uint32_t)(mixed >> 32) & (uint32_t)(capacity - 1);+}++static void search_result_index_free(search_result_index_t *index) {+ free(index->ids);+ free(index->slots);+ memset(index, 0, sizeof(*index));+}++static int search_result_index_find(const search_result_index_t *index, int64_t id) {+ if (index->capacity == 0) {+ return CBM_NOT_FOUND;+ }+ uint32_t at = search_result_index_hash(id, index->capacity);+ while (index->slots[at] != 0) {+ if (index->ids[at] == id) {+ return index->slots[at] - SKIP_ONE;}+ at = (at + SKIP_ONE) & (uint32_t)(index->capacity - 1);+ }+ return CBM_NOT_FOUND;+}++static bool search_result_index_put(search_result_index_t *index, int64_t id, int value);++static bool search_result_index_grow(search_result_index_t *index) {+ int capacity = index->capacity ? index->capacity * PAIR_LEN : SEARCH_RESULT_INDEX_MIN_CAPACITY;+ search_result_index_t grown = {+ .ids = calloc((size_t)capacity, sizeof(int64_t)),+ .slots = calloc((size_t)capacity, sizeof(int)),+ .capacity = capacity,+ };+ if (!grown.ids || !grown.slots) {+ search_result_index_free(&grown);+ return false;+ }+ for (int i = 0; i < index->capacity; i++) {+ if (index->slots[i] != 0) {+ (void)search_result_index_put(&grown, index->ids[i], index->slots[i] - SKIP_ONE);+ }+ }+ search_result_index_free(index);+ *index = grown;+ return true;+}++static bool search_result_index_put(search_result_index_t *index, int64_t id, int value) {+ if ((index->count + SKIP_ONE) * PAIR_LEN > index->capacity &&+ !search_result_index_grow(index)) {+ return false;+ }+ uint32_t at = search_result_index_hash(id, index->capacity);+ while (index->slots[at] != 0) {+ at = (at + SKIP_ONE) & (uint32_t)(index->capacity - 1);+ }+ index->ids[at] = id;+ index->slots[at] = value + SKIP_ONE;+ index->count++;+ return true;+}++/* Add a grep hit to the search result set (merge into existing or create new). */+static bool add_to_search_results(search_result_t **sr, int *sr_count, int *sr_cap,+ search_result_index_t *index, cbm_node_t *n, int line) {+ int existing = search_result_index_find(index, n->id);+ if (existing >= 0) {+ return append_search_match_line(&(*sr)[existing], line);}if (*sr_count >= *sr_cap) {int next_capacity = *sr_cap * PAIR_LEN;@@ -15353,18 +15518,26 @@ static bool add_to_search_results(search_result_t **sr, int *sr_count, int *sr_cr->file = NULL;return false;}+ if (!search_result_index_put(index, n->id, *sr_count)) {+ free(r->qualified_name);+ free(r->file);+ free(r->match_lines);+ memset(r, 0, sizeof(*r));+ return false;+ }(*sr_count)++;return true;}/* Match a single grep hit to the tightest containing node, then add to sr or raw. */static bool classify_grep_hit(grep_match_t *hit, cbm_node_t *file_nodes, int file_node_count,- search_result_t **sr, int *sr_count, int *sr_cap, grep_match_t **raw,- int raw_offset, int raw_limit, int *raw_count, int *raw_stored_count,- int *raw_cap, int *raw_content_truncated) {+ search_result_t **sr, int *sr_count, int *sr_cap,+ search_result_index_t *sr_index, grep_match_t **raw, int raw_offset,+ int raw_limit, int *raw_count, int *raw_stored_count, int *raw_cap,+ int *raw_content_truncated) {int best = find_tightest_node(file_nodes, file_node_count, hit->line);if (best >= 0) {- return add_to_search_results(sr, sr_count, sr_cap, &file_nodes[best], hit->line);+ return add_to_search_results(sr, sr_count, sr_cap, sr_index, &file_nodes[best], hit->line);} else {if (*raw_count == INT_MAX) {return false;@@ -15421,13 +15594,14 @@ static void free_file_nodes(cbm_node_t *nodes, int count) {* applies before it reads a result's source, applied to the match itself,* once per distinct file (grep groups a file's hits). A path too long for* the canonical-path buffers is one that check cannot resolve either. */-static bool search_hit_file_within_root(const char *root_path, const char *file) {+static bool search_hit_file_within_root(root_containment_t *containment, const char *root_path,+ const char *file) {char abs_path[CBM_SZ_4K];int length = snprintf(abs_path, sizeof(abs_path), "%s/%s", root_path, file);if (length < 0 || (size_t)length >= sizeof(abs_path)) {return false;}- return cbm_path_within_root(root_path, abs_path);+ return root_containment_check(containment, abs_path);}/* Parse and classify the complete grep stream without retaining one object per@@ -15446,6 +15620,16 @@ static bool scan_and_classify_grep_matches(bool current_file_inside = false;cbm_node_t *file_nodes = NULL;int file_node_count = 0;+ root_containment_t containment;+ root_containment_init(&containment, root_path);+ search_result_index_t sr_index = {0};+ for (int i = 0; i < *sr_count; i++) {+ if (!search_result_index_put(&sr_index, (*sr)[i].node_id, i)) {+ search_result_index_free(&sr_index);+ root_containment_free(&containment);+ return false;+ }+ }cbm_regex_t content_regex;bool content_regex_ready = use_regex && pattern &&cbm_regcomp(&content_regex, pattern, CBM_REG_EXTENDED) == CBM_REG_OK;@@ -15499,7 +15683,7 @@ static bool scan_and_classify_grep_matches(ok = false;break;}- current_file_inside = search_hit_file_within_root(root_path, file);+ current_file_inside = search_hit_file_within_root(&containment, root_path, file);if (store && current_file_inside) {(void)cbm_store_find_nodes_by_file(store, project, file, &file_nodes,&file_node_count);@@ -15531,8 +15715,8 @@ static bool scan_and_classify_grep_matches(&match_start, &match_end);search_raw_preview(&hit, content, raw_content_offset_set, raw_content_offset, match_known,match_start, match_end);- if (!classify_grep_hit(&hit, file_nodes, file_node_count, sr, sr_count, sr_cap, raw,- raw_offset, raw_limit, raw_count, raw_stored_count, raw_cap,+ if (!classify_grep_hit(&hit, file_nodes, file_node_count, sr, sr_count, sr_cap, &sr_index,+ raw, raw_offset, raw_limit, raw_count, raw_stored_count, raw_cap,raw_content_truncated)) {free(hit.file);ok = false;@@ -15541,6 +15725,8 @@ static bool scan_and_classify_grep_matches(free(hit.file);}+ search_result_index_free(&sr_index);+ root_containment_free(&containment);if (content_regex_ready) {cbm_regfree(&content_regex);}@@ -15832,6 +16018,372 @@ static void search_scratch_close(search_scratch_t *scratch) {}}+/* ── In-process content scan ────────────────────────────────────────+ * search_code used to hand the scoped file list to `xargs sh grep` on POSIX and+ * to a PowerShell Select-String pipeline on Windows: a process spawn per call,+ * BSD grep's ~130 MB/s on macOS, and one cmdlet invocation per file on Windows+ * (23-31 s per call on GitHub's windows-11-arm image, against the 30 s scan+ * deadline). This scanner reads the same list and writes the records+ * `grep -Hn` printed, so the classifier and everything after it are unchanged:+ * - patterns: the pattern split on '\n', as `grep -f` reads its file; an+ * empty pattern matches every line (grep special-cases it in -E mode too);+ * - literal mode is a substring match (grep -F); regex mode runs each line+ * through cbm_regex, the platform's POSIX ERE engine (grep -E);+ * - a NUL byte in the first 32 KiB marks the file binary and yields no+ * record, as grep prints no lines for it; after a later NUL nothing more+ * is reported, as GNU grep stops line output there;+ * - a record is `<listed path><sep><line number><sep><line bytes>\n` with+ * ':' (POSIX) or TAB (Windows), the separators the classifier reads; the+ * line keeps a CR, which the classifier strips as before.+ * Deadline, cancellation and the output limit end the scan with the causes the+ * subprocess runner reported; an unreadable listed file fails the scan closed,+ * as grep's error exit did. */+enum {+ SEARCH_SCAN_BINARY_PROBE = 32768,+ SEARCH_SCAN_CHECK_EVERY = 4096, /* lines between deadline/cancel checks */+};++typedef struct {+ char **items;+ size_t *lengths;+ int count;+ cbm_regex_t *regexes; /* regex mode: one per non-empty pattern */+ int compiled;+ bool any_empty; /* an empty pattern: every line matches */+} search_scan_patterns_t;++static void search_scan_patterns_free(search_scan_patterns_t *patterns) {+ for (int i = 0; i < patterns->count; i++) {+ free(patterns->items[i]);+ }+ for (int i = 0; patterns->regexes && i < patterns->count; i++) {+ if (i < patterns->compiled && patterns->lengths[i] > 0) {+ cbm_regfree(&patterns->regexes[i]);+ }+ }+ free(patterns->items);+ free(patterns->lengths);+ free(patterns->regexes);+ memset(patterns, 0, sizeof(*patterns));+}++static bool search_scan_patterns_parse(search_scan_patterns_t *patterns, const char *pattern,+ bool use_regex) {+ memset(patterns, 0, sizeof(*patterns));+ int count = 1;+ for (const char *p = pattern; *p; p++) {+ count += *p == '\n' ? SKIP_ONE : 0;+ }+ patterns->items = calloc((size_t)count, sizeof(char *));+ patterns->lengths = calloc((size_t)count, sizeof(size_t));+ patterns->regexes = use_regex ? calloc((size_t)count, sizeof(cbm_regex_t)) : NULL;+ if (!patterns->items || !patterns->lengths || (use_regex && !patterns->regexes)) {+ search_scan_patterns_free(patterns);+ return false;+ }+ const char *start = pattern;+ for (int i = 0; i < count; i++) {+ const char *end = strchr(start, '\n');+ size_t length = end ? (size_t)(end - start) : strlen(start);+ patterns->items[i] = malloc(length + SKIP_ONE);+ if (!patterns->items[i]) {+ patterns->count = i;+ search_scan_patterns_free(patterns);+ return false;+ }+ memcpy(patterns->items[i], start, length);+ patterns->items[i][length] = '\0';+ patterns->lengths[i] = length;+ patterns->any_empty = patterns->any_empty || length == 0;+ start = end ? end + SKIP_ONE : start + length;+ }+ patterns->count = count;+ for (int i = 0; use_regex && i < count; i++) {+ if (patterns->lengths[i] > 0 &&+ cbm_regcomp(&patterns->regexes[i], patterns->items[i],+ CBM_REG_EXTENDED | CBM_REG_NOSUB) != CBM_REG_OK) {+ patterns->compiled = i;+ search_scan_patterns_free(patterns);+ return false;+ }+ patterns->compiled = i + SKIP_ONE;+ }+ return true;+}++/* First occurrence of needle in hay; memmem where the C library has it. */+static const char *search_scan_find(const char *hay, size_t hay_length, const char *needle,+ size_t needle_length) {+ if (needle_length == 0) {+ return hay;+ }+ if (needle_length > hay_length) {+ return NULL;+ }+#ifdef _WIN32+ const char *last = hay + (hay_length - needle_length);+ for (const char *p = hay; p <= last;) {+ p = memchr(p, (unsigned char)needle[0], (size_t)(last - p) + SKIP_ONE);+ if (!p) {+ return NULL;+ }+ if (memcmp(p, needle, needle_length) == 0) {+ return p;+ }+ p++;+ }+ return NULL;+#else+ return memmem(hay, hay_length, needle, needle_length);+#endif+}++static size_t search_scan_count_newlines(const char *from, const char *to) {+ size_t count = 0;+ while (from < to) {+ const char *newline = memchr(from, '\n', (size_t)(to - from));+ if (!newline) {+ break;+ }+ count++;+ from = newline + SKIP_ONE;+ }+ return count;+}++typedef struct {+ FILE *out;+ size_t written;+ size_t output_limit;+ char separator;+} search_scan_sink_t;++/* One `grep -Hn` record. False on a write error or once past the output limit. */+static bool search_scan_emit(search_scan_sink_t *sink, const char *path, size_t path_length,+ size_t line_number, const char *line, size_t line_length,+ bool *over_limit) {+ char number[CBM_SZ_32];+ int number_length =+ snprintf(number, sizeof(number), "%c%zu%c", sink->separator, line_number, sink->separator);+ if (number_length <= 0 || (size_t)number_length >= sizeof(number) ||+ fwrite(path, 1, path_length, sink->out) != path_length ||+ fwrite(number, 1, (size_t)number_length, sink->out) != (size_t)number_length ||+ fwrite(line, 1, line_length, sink->out) != line_length || fputc('\n', sink->out) == EOF) {+ return false;+ }+ sink->written += path_length + (size_t)number_length + line_length + SKIP_ONE;+ if (sink->output_limit > 0 && sink->written > sink->output_limit) {+ *over_limit = true;+ return false;+ }+ return true;+}++static bool search_scan_line_matches(const search_scan_patterns_t *patterns, bool use_regex,+ const char *line) {+ if (patterns->any_empty) {+ return true;+ }+ for (int i = 0; i < patterns->count; i++) {+ if (use_regex ? cbm_regexec(&patterns->regexes[i], line, 0, NULL, 0) == CBM_REG_OK+ : strstr(line, patterns->items[i]) != NULL) {+ return true;+ }+ }+ return false;+}++/* Scan one file. `buffer` holds its bytes plus one spare byte. */+static mcp_scan_cause_t search_scan_buffer(cbm_mcp_server_t *srv, search_scan_sink_t *sink,+ const search_scan_patterns_t *patterns, bool use_regex,+ const char *path, size_t path_length, char *buffer,+ size_t length, uint64_t deadline_ms) {+ size_t probe = length < SEARCH_SCAN_BINARY_PROBE ? length : SEARCH_SCAN_BINARY_PROBE;+ if (memchr(buffer, '\0', probe)) {+ return MCP_SCAN_SUCCESS;+ }+ const char *nul = memchr(buffer, '\0', length);+ if (nul) {+ /* Lines up to the last complete line before the NUL. */+ size_t keep = 0;+ for (size_t i = (size_t)(nul - buffer); i > 0; i--) {+ if (buffer[i - SKIP_ONE] == '\n') {+ keep = i;+ break;+ }+ }+ length = keep;+ }+ buffer[length] = '\0';+ bool over_limit = false;+ size_t line_number = 1;+ size_t since_check = 0;+ bool single_literal = !use_regex && !patterns->any_empty && patterns->count == 1;+ size_t pos = 0;+ while (pos < length) {+ if (++since_check >= SEARCH_SCAN_CHECK_EVERY) {+ since_check = 0;+ if (mcp_request_cancelled(srv)) {+ return MCP_SCAN_CANCELLED;+ }+ if (cbm_now_ms() >= deadline_ms) {+ return MCP_SCAN_DEADLINE;+ }+ }+ size_t line_start = pos;+ if (single_literal) {+ /* Jump to the next occurrence instead of visiting every line. */+ const char *hit = search_scan_find(buffer + pos, length - pos, patterns->items[0],+ patterns->lengths[0]);+ if (!hit) {+ break;+ }+ line_start = (size_t)(hit - buffer);+ while (line_start > pos && buffer[line_start - SKIP_ONE] != '\n') {+ line_start--;+ }+ line_number += search_scan_count_newlines(buffer + pos, buffer + line_start);+ }+ char *newline = memchr(buffer + line_start, '\n', length - line_start);+ size_t line_end = newline ? (size_t)(newline - buffer) : length;+ /* Windows matched Select-String's Line, which has no trailing CR, so+ * `foo$` matched a CRLF line there; POSIX grep matches with the CR. */+ size_t match_end = line_end;+#ifdef _WIN32+ if (match_end > line_start && buffer[match_end - SKIP_ONE] == '\r') {+ match_end--;+ }+#endif+ char saved = buffer[match_end];+ buffer[match_end] = '\0';+ bool matched =+ single_literal || search_scan_line_matches(patterns, use_regex, buffer + line_start);+ buffer[match_end] = saved;+ if (newline) {+ *newline = '\n';+ }+ if (matched && !search_scan_emit(sink, path, path_length, line_number, buffer + line_start,+ line_end - line_start, &over_limit)) {+ return over_limit ? MCP_SCAN_OUTPUT_LIMIT : MCP_SCAN_COMMAND_FAILURE;+ }+ pos = line_end + SKIP_ONE;+ line_number++;+ }+ return MCP_SCAN_SUCCESS;+}++/* Read a whole file into *buffer (grown as needed), leaving one spare byte. */+static bool search_scan_read_file(const char *path, char **buffer, size_t *capacity,+ size_t *length) {+ FILE *fp = cbm_fopen(path, "rb");+ if (!fp) {+ return false;+ }+ size_t used = 0;+ bool ok = true;+ for (;;) {+ if (*capacity - used < CBM_SZ_64K + SKIP_ONE) {+ size_t grown = *capacity ? *capacity * PAIR_LEN : (size_t)CBM_SZ_64K * PAIR_LEN;+ if (grown <= *capacity || grown > (size_t)INT_MAX) {+ ok = false;+ break;+ }+ char *next = realloc(*buffer, grown);+ if (!next) {+ ok = false;+ break;+ }+ *buffer = next;+ *capacity = grown;+ }+ size_t want = *capacity - used - SKIP_ONE;+ size_t got = fread(*buffer + used, 1, want, fp);+ used += got;+ if (got < want) {+ ok = !ferror(fp);+ break;+ }+ }+ (void)fclose(fp);+ *length = used;+ return ok;+}++static mcp_scan_cause_t search_scan_in_process(cbm_mcp_server_t *srv, const char *filelist_path,+ const char *pattern, bool use_regex, FILE *out,+ size_t output_limit, uint64_t deadline_ms) {+#ifdef _WIN32+ const char record_separator = '\n';+ const char field_separator = '\t';+#else+ const char record_separator = '\0';+ const char field_separator = ':';+#endif+ search_scan_patterns_t patterns;+ if (!search_scan_patterns_parse(&patterns, pattern, use_regex)) {+ return MCP_SCAN_COMMAND_FAILURE;+ }+ char *list = NULL;+ size_t list_capacity = 0;+ size_t list_length = 0;+ if (!search_scan_read_file(filelist_path, &list, &list_capacity, &list_length)) {+ free(list);+ search_scan_patterns_free(&patterns);+ return MCP_SCAN_COMMAND_FAILURE;+ }+ search_scan_sink_t sink = {+ .out = out, .output_limit = output_limit, .separator = field_separator};+ char *buffer = NULL;+ size_t capacity = 0;+ mcp_scan_cause_t cause = MCP_SCAN_SUCCESS;+ size_t pos = 0;+ while (cause == MCP_SCAN_SUCCESS && pos < list_length) {+ const char *end = memchr(list + pos, record_separator, list_length - pos);+ size_t record_end = end ? (size_t)(end - list) : list_length;+ list[record_end] = '\0';+ const char *path = list + pos;+ size_t path_length = record_end - pos;+ pos = record_end + SKIP_ONE;+ if (path_length == 0) {+ continue;+ }+ if (mcp_request_cancelled(srv)) {+ cause = MCP_SCAN_CANCELLED;+ break;+ }+ if (cbm_now_ms() >= deadline_ms) {+ cause = MCP_SCAN_DEADLINE;+ break;+ }+ size_t length = 0;+ if (!search_scan_read_file(path, &buffer, &capacity, &length)) {+ cause = MCP_SCAN_COMMAND_FAILURE;+ break;+ }+ cause = search_scan_buffer(srv, &sink, &patterns, use_regex, path, path_length, buffer,+ length, deadline_ms);+ }+ free(buffer);+ free(list);+ search_scan_patterns_free(&patterns);+ return cause;+}++int cbm_mcp_search_scan_for_test(cbm_mcp_server_t *srv, const char *filelist_path,+ const char *pattern, bool use_regex, const char *out_path,+ size_t output_limit, uint64_t deadline_ms) {+ FILE *out = cbm_fopen(out_path, "wb");+ if (!out) {+ return MCP_SCAN_COMMAND_FAILURE;+ }+ mcp_scan_cause_t cause = search_scan_in_process(srv, filelist_path, pattern, use_regex, out,+ output_limit, deadline_ms);+ if (fclose(out) != 0 && cause == MCP_SCAN_SUCCESS) {+ cause = MCP_SCAN_COMMAND_FAILURE;+ }+ return (int)cause;+}+/* Open the scratch directory, write `pattern` to the grep -f file, and leave the* file list open for write_scoped_filelist. Returns true on success; on failure* everything already created is removed before returning. */@@ -16258,10 +16810,39 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {: MCP_SEARCH_OUTPUT_MAX;const char *scan_command =srv->search_scan_command_override ? srv->search_scan_command_override : cmd;- mcp_scan_cause_t scan_cause = mcp_run_shell_command_cancellable_bounded(- srv, scan_command, output_path, scan_output_limit, scan_deadline_ms, true,- scan_deadline_latched, /*exit_one_is_no_match=*/false, /*git_child=*/false,- &scan_result);+ /* An indexed project is scanned in process (see search_scan_in_process).+ * The recursive fallback for an unindexed root, a Windows file_pattern+ * whose -like post-filter cannot be applied ahead of the scan, and the+ * test command override keep the subprocess runner. */+ bool scan_in_process = scoped && !srv->search_scan_command_override;+#ifdef _WIN32+ scan_in_process =+ scan_in_process &&+ (!file_pattern || cbm_search_code_file_pattern_can_prefilter(file_pattern));+#endif+ mcp_scan_cause_t scan_cause;+ if (scan_in_process) {+ FILE *scan_out = NULL;+ if (scan_cancellation_latched || mcp_request_cancelled(srv)) {+ scan_cause = MCP_SCAN_CANCELLED;+ } else if (scan_deadline_latched || cbm_now_ms() >= scan_deadline_ms) {+ scan_cause = MCP_SCAN_DEADLINE;+ } else if (!(scan_out = search_scratch_file(scratch.dir, "scan", output_path,+ sizeof(output_path)))) {+ scan_cause = MCP_SCAN_COMMAND_FAILURE;+ } else {+ scan_cause = search_scan_in_process(srv, filelist, pattern, use_regex, scan_out,+ scan_output_limit, scan_deadline_ms);+ }+ if (scan_out && fclose(scan_out) != 0 && scan_cause == MCP_SCAN_SUCCESS) {+ scan_cause = MCP_SCAN_COMMAND_FAILURE;+ }+ } else {+ scan_cause = mcp_run_shell_command_cancellable_bounded(+ srv, scan_command, output_path, scan_output_limit, scan_deadline_ms, true,+ scan_deadline_latched, /*exit_one_is_no_match=*/false, /*git_child=*/false,+ &scan_result);+ }/* Both POSIX commands wrap grep and map its no-match status to 0, so any* non-zero exit (a failed find/sort, an unreadable operand, a broken* grep) is an incomplete scan and fails closed. */@@ -16409,11 +16990,15 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {directory_output = directory_limit;}bool warn_literal_pipe = pat_has_pipe && !use_regex;+ /* Every render below re-checks each result's file against the root; one+ * containment for the request keeps that to one resolution per file. */+ root_containment_t request_containment;+ root_containment_init(&request_containment, root_path);char *payload = render_search_payload(sr, sr_count, raw, raw_count, raw_content_truncated, gm_count, result_start, result_limit,output_count, raw_start, raw_output, directory_start, directory_output, raw_limit,directory_limit, match_limit, mode, context_lines, source_max_lines, root_path,- scan_saturated, warn_literal_pipe, &metrics, false, sc_legacy_json);+ scan_saturated, warn_literal_pipe, &metrics, false, sc_legacy_json, &request_containment);if (payload && strlen(payload) > byte_budget) {free(payload);@@ -16421,7 +17006,8 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {sr, sr_count, raw, raw_count, raw_content_truncated, gm_count, result_start,result_limit, output_count, raw_start, raw_output, directory_start, directory_output,raw_limit, directory_limit, match_limit, mode, context_lines, source_max_lines,- root_path, scan_saturated, warn_literal_pipe, &metrics, true, sc_legacy_json);+ root_path, scan_saturated, warn_literal_pipe, &metrics, true, sc_legacy_json,+ &request_containment);}/* Preserve ranked graph answers. Unclassified raw grep rows and directory@@ -16433,7 +17019,8 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {sr, sr_count, raw, raw_count, raw_content_truncated, gm_count, result_start,result_limit, output_count, raw_start, raw_output, directory_start, directory_output,raw_limit, directory_limit, match_limit, mode, context_lines, source_max_lines,- root_path, scan_saturated, warn_literal_pipe, &metrics, true, sc_legacy_json);+ root_path, scan_saturated, warn_literal_pipe, &metrics, true, sc_legacy_json,+ &request_containment);}while (payload && strlen(payload) > byte_budget && directory_output > 0) {directory_output--;@@ -16442,7 +17029,8 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {sr, sr_count, raw, raw_count, raw_content_truncated, gm_count, result_start,result_limit, output_count, raw_start, raw_output, directory_start, directory_output,raw_limit, directory_limit, match_limit, mode, context_lines, source_max_lines,- root_path, scan_saturated, warn_literal_pipe, &metrics, true, sc_legacy_json);+ root_path, scan_saturated, warn_literal_pipe, &metrics, true, sc_legacy_json,+ &request_containment);}/* Full source is the next detail tier. Find the largest whole-line window@@ -16459,7 +17047,7 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {result_limit, output_count, raw_start, raw_output, directory_start,directory_output, raw_limit, directory_limit, match_limit, mode, context_lines,middle, root_path, scan_saturated, warn_literal_pipe, &metrics, true,- sc_legacy_json);+ sc_legacy_json, &request_containment);if (candidate && strlen(candidate) <= byte_budget) {free(best_payload);best_payload = candidate;@@ -16481,7 +17069,7 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {result_limit, output_count, raw_start, raw_output, directory_start,directory_output, raw_limit, directory_limit, match_limit, mode, context_lines,source_max_lines, root_path, scan_saturated, warn_literal_pipe, &metrics, true,- sc_legacy_json);+ sc_legacy_json, &request_containment);}}@@ -16497,7 +17085,7 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {result_limit, candidate_rows, raw_start, raw_output, directory_start,directory_output, raw_limit, directory_limit, match_limit, mode, context_lines,source_max_lines, root_path, scan_saturated, warn_literal_pipe, &metrics, true,- sc_legacy_json);+ sc_legacy_json, &request_containment);if (candidate && strlen(candidate) <= byte_budget) {best_payload = candidate;break;@@ -16514,6 +17102,7 @@ static char *handle_search_code(cbm_mcp_server_t *srv, const char *args) {raw_start, raw_limit, directory_start, directory_limit,dir_total, scan_saturated, sc_legacy_json, max_output_tokens);}+ root_containment_free(&request_containment);char *result = cbm_mcp_text_result(payload ? payload : "out of memory", payload == NULL);free(payload);free_search_results(sr, sr_count);@@ -19963,6 +20552,24 @@ static char *dispatch_tool(cbm_mcp_server_t *srv, const char *tool_name, const creturn cbm_mcp_text_result(msg, true);}+/* Read tools whose work is store reads from start to end run them in one store+ * read batch (cbm_store_read_batch_begin). Left out: tools that write, open+ * their own transaction or read scope (detect_changes), or hold the store+ * across a long scan or a git subprocess (search_code, index_status). */+static bool mcp_tool_reads_in_batch(const char *tool_name) {+ static const char *const batched[] = {+ "query_graph", "trace_path", "trace_call_path", "search_graph",+ "get_architecture", "get_graph_schema", "get_code_snippet", "get_file_outline",+ "compare_graphs", "check_index_coverage",+ };+ for (size_t i = 0; tool_name && i < sizeof(batched) / sizeof(batched[0]); i++) {+ if (strcmp(tool_name, batched[i]) == 0) {+ return true;+ }+ }+ return false;+}+/* File-backed query stores are request-scoped. Keeping one open between MCP* calls pins an old database generation after another process atomically* replaces the project DB. On Windows it can also prevent that replacement@@ -19998,7 +20605,15 @@ char *cbm_mcp_handle_tool(cbm_mcp_server_t *srv, const char *tool_name, const chreturn cbm_mcp_text_result("request cancellation scope unavailable", true);}cbm_mem_phase_mark("request.dispatch_tool");+ if (srv) {+ srv->read_batch_tool = mcp_tool_reads_in_batch(tool_name);+ }char *result = dispatch_tool(srv, tool_name, args_json);+ if (srv) {+ /* An embedded store outlives the request: end its batch here. */+ srv->read_batch_tool = false;+ cbm_store_read_batch_end(srv->store);+ }cbm_mem_phase_mark("request.scope_end");if (srv) {cbm_mcp_server_request_scope_end(srv);diff --git a/src/mcp/mcp_internal.h b/src/mcp/mcp_internal.hindex 02da636b2..7035d80ba 100644--- a/src/mcp/mcp_internal.h+++ b/src/mcp/mcp_internal.h@@ -39,6 +39,13 @@ void cbm_mcp_server_set_search_scan_timeout_for_test(cbm_mcp_server_t *srv, uint* scratch count cannot see other processes' entries in the shared temp dir.* The server borrows dir until it is reset or the server is freed. */void cbm_mcp_server_set_search_scratch_dir_for_test(cbm_mcp_server_t *srv, const char *dir);+/* search_code's in-process scan of `filelist_path` (records separated as the+ * scoped list is written: NUL on POSIX, newline on Windows) into `out_path`.+ * Returns the scan cause in mcp_scan_cause_t order: 0 success, 1 command+ * failure, 3 output limit, 4 deadline, 5 cancelled. */+int cbm_mcp_search_scan_for_test(cbm_mcp_server_t *srv, const char *filelist_path,+ const char *pattern, bool use_regex, const char *out_path,+ size_t output_limit, uint64_t deadline_ms);/* Release only the constructor-created pristine in-memory store. Public* cbm_mcp_server_new(NULL) semantics remain unchanged; daemon sessions usediff --git a/src/store/store.c b/src/store/store.cindex 7a2cbe616..9d2c33119 100644--- a/src/store/store.c+++ b/src/store/store.c@@ -121,6 +121,8 @@ struct cbm_store {const void *progress_owner; /* exclusive native progress guard token */const char *db_path; /* heap-allocated, or NULL for :memory: */char errbuf[CBM_SZ_512];+ bool read_batch; /* a read batch's transaction is open */+ uint64_t read_batch_started_ms; /* when it was last (re)begun *//* Prepared statements (lazily initialized, cached for lifetime) */sqlite3_stmt *stmt_upsert_node;@@ -207,10 +209,60 @@ static char *heap_strdup(const char *s) {}/* Prepare a statement (cached). If already prepared, reset+clear. */+/* ── Read batch ────────────────────────────────────────────────────+ * A read tool issues thousands of small statements. In autocommit mode each+ * one takes and drops the database file lock and stats the journal and WAL+ * files — most of a whole-graph count(*)'s time. A read batch runs them in one+ * deferred read transaction, renewed every ST_READ_BATCH_MS at the next+ * statement: a writer never waits behind the batch much longer than that, and+ * every statement still reads data committed at most that long ago (while the+ * batch holds a rollback-journal database's shared lock, no commit happens).+ * Committing a read transaction is allowed with read statements still+ * stepping; their lock is then held until they finish, as before. */+enum { ST_READ_BATCH_MS = 100 };++bool cbm_store_read_batch_begin(cbm_store_t *s) {+ if (!s || !s->db || s->read_batch || !sqlite3_get_autocommit(s->db)) {+ return false;+ }+ if (sqlite3_exec(s->db, "BEGIN DEFERRED;", NULL, NULL, NULL) != SQLITE_OK) {+ return false;+ }+ s->read_batch = true;+ s->read_batch_started_ms = cbm_now_ms();+ return true;+}++void cbm_store_read_batch_end(cbm_store_t *s) {+ if (!s || !s->read_batch) {+ return;+ }+ s->read_batch = false;+ if (s->db && !sqlite3_get_autocommit(s->db)) {+ (void)sqlite3_exec(s->db, "COMMIT;", NULL, NULL, NULL);+ }+}++void cbm_store_read_batch_expire_for_test(cbm_store_t *s) {+ if (s && s->read_batch) {+ uint64_t now = cbm_now_ms();+ s->read_batch_started_ms = now > ST_READ_BATCH_MS ? now - ST_READ_BATCH_MS : 0;+ }+}++static void read_batch_renew(cbm_store_t *s) {+ if (!s->read_batch || cbm_now_ms() - s->read_batch_started_ms < ST_READ_BATCH_MS) {+ return;+ }+ cbm_store_read_batch_end(s);+ (void)cbm_store_read_batch_begin(s);+}+static sqlite3_stmt *prepare_cached(cbm_store_t *s, sqlite3_stmt **slot, const char *sql) {if (!s || !s->db) {return NULL;}+ read_batch_renew(s);if (*slot) {sqlite3_reset(*slot);sqlite3_clear_bindings(*slot);@@ -1363,6 +1415,7 @@ void cbm_store_close(cbm_store_t *s) {if (!s) {return;}+ cbm_store_read_batch_end(s);/* Checkpoint WAL before close to prevent orphan WAL accumulation.* Best-effort — silently skips if concurrent reader holds a lock. */diff --git a/src/store/store.h b/src/store/store.hindex da4026d29..cd58b53c5 100644--- a/src/store/store.h+++ b/src/store/store.h@@ -478,6 +478,16 @@ int cbm_store_commit(cbm_store_t *s);/* Rollback the current transaction. */int cbm_store_rollback(cbm_store_t *s);+/* Read batch: run the reads that follow in one deferred read transaction,+ * renewed every 100 ms so a writer is never held back longer, instead of one+ * lock round trip per statement. Begin returns false (and does nothing) when+ * a transaction is already open. For read-only work only; end it before any+ * write, transaction or read scope on the same store. Close ends it. */+bool cbm_store_read_batch_begin(cbm_store_t *s);+void cbm_store_read_batch_end(cbm_store_t *s);+/* Test seam: make an open read batch due for renewal at its next statement. */+void cbm_store_read_batch_expire_for_test(cbm_store_t *s);+/* Stable request read scope. Borrows an exclusively owned, single-thread* store and callback context. Refuses a transaction, busy statement or owned* progress handler; idle cached statements are allowed. Saves query_only anddiff --git a/tests/test_cypher.c b/tests/test_cypher.cindex e13ea5c43..3fc48347e 100644--- a/tests/test_cypher.c+++ b/tests/test_cypher.c@@ -5580,6 +5580,257 @@ TEST(cypher_fifty_union_branches) {PASS();}+/* ── ORDER BY, DISTINCT and grouping against a reference ───────────+ * These were bubble sorts and linear duplicate/group scans — seconds to+ * minutes on a 30k-row result. The results must stay exactly the old ones: a+ * stable sort of the unsorted rows, first-occurrence DISTINCT, first-seen+ * group order. Each case derives that reference from the engine's own+ * unsorted rows, on a graph built for ties, duplicates and large groups. */++enum { REF_NODES = 400, REF_NAMES = 97 };++static cbm_store_t *setup_reference_store(void) {+ cbm_store_t *s = cbm_store_open_memory();+ cbm_store_upsert_project(s, "test", "/tmp/test");+ int64_t ids[REF_NODES];+ for (int i = 0; i < REF_NODES; i++) {+ char name[32];+ char qn[32];+ char file[32];+ snprintf(name, sizeof(name), "fn_%02d", (i * 7) % REF_NAMES); /* repeated names */+ snprintf(qn, sizeof(qn), "test.n%d", i);+ snprintf(file, sizeof(file), "f%02d.c", i % 13);+ cbm_node_t n = {.project = "test",+ .label = "Function",+ .name = name,+ .qualified_name = qn,+ .file_path = file,+ .start_line = (i * 31) % 50, /* tied lines */+ .end_line = 60};+ ids[i] = cbm_store_upsert_node(s, &n);+ }+ /* Every node calls both hubs (n0, n1: ~400 callers, 97 distinct names,+ * past the hashed COUNT(DISTINCT) threshold) and one more node. */+ for (int i = 0; i < REF_NODES; i++) {+ int targets[3] = {0, 1, (i * i + 3) % REF_NODES};+ for (int t = 0; t < 3; t++) {+ if (targets[t] != i) {+ cbm_edge_t e = {.project = "test",+ .source_id = ids[i],+ .target_id = ids[targets[t]],+ .type = "CALLS"};+ cbm_store_insert_edge(s, &e);+ }+ }+ }+ return s;+}++typedef int (*ref_cmp_fn)(const cbm_cypher_result_t *r, int a, int b);++/* The reference order: an insertion sort that moves a row before an earlier+ * one only when the earlier one compares greater — stable, like the old+ * bubble sorts. */+static void ref_stable_order(const cbm_cypher_result_t *r, int *order, ref_cmp_fn cmp) {+ for (int i = 0; i < r->row_count; i++) {+ order[i] = i;+ }+ for (int i = 1; i < r->row_count; i++) {+ for (int j = i; j > 0 && cmp(r, order[j - 1], order[j]) > 0; j--) {+ int swap = order[j];+ order[j] = order[j - 1];+ order[j - 1] = swap;+ }+ }+}++/* Columns 0 (name) and 1 (line): line descending, then name ascending. */+static int ref_line_desc_name(const cbm_cypher_result_t *r, int a, int b) {+ long la = strtol(r->rows[a][1], NULL, 10);+ long lb = strtol(r->rows[b][1], NULL, 10);+ int cmp = (lb > la) - (lb < la);+ return cmp != 0 ? cmp : strcmp(r->rows[a][0], r->rows[b][0]);+}++static int ref_all_equal(const cbm_cypher_result_t *r, int a, int b) {+ (void)r;+ (void)a;+ (void)b;+ return 0;+}++/* `sorted` must hold the rows of `unsorted` in the reference order. */+static bool ref_rows_in_order(const cbm_cypher_result_t *sorted,+ const cbm_cypher_result_t *unsorted, ref_cmp_fn cmp) {+ if (sorted->row_count != unsorted->row_count || sorted->col_count != unsorted->col_count ||+ unsorted->row_count < REF_NODES) {+ return false;+ }+ int order[REF_NODES * 4];+ ref_stable_order(unsorted, order, cmp);+ for (int i = 0; i < sorted->row_count; i++) {+ for (int c = 0; c < sorted->col_count; c++) {+ if (strcmp(sorted->rows[i][c], unsorted->rows[order[i]][c]) != 0) {+ return false;+ }+ }+ }+ return true;+}++static bool ref_query(cbm_store_t *s, const char *query, cbm_cypher_result_t *out) {+ memset(out, 0, sizeof(*out));+ return cbm_cypher_execute(s, query, "test", 0, out) == 0 && !out->truncated;+}++TEST(cypher_order_by_is_the_stable_reference_order) {+ cbm_store_t *s = setup_reference_store();+ cbm_cypher_result_t plain;+ cbm_cypher_result_t sorted;+ ASSERT_TRUE(ref_query(s, "MATCH (f:Function) RETURN f.name, f.start_line", &plain));++ /* RETURN: numeric key descending, ties broken by the next key. */+ ASSERT_TRUE(ref_query(+ s, "MATCH (f:Function) RETURN f.name, f.start_line ORDER BY f.start_line DESC, f.name",+ &sorted));+ ASSERT_TRUE(ref_rows_in_order(&sorted, &plain, ref_line_desc_name));+ cbm_cypher_result_free(&sorted);++ /* WITH: the same keys through a projection. */+ ASSERT_TRUE(ref_query(s,+ "MATCH (f:Function) WITH f.name AS n, f.start_line AS l "+ "ORDER BY l DESC, n RETURN n, l",+ &sorted));+ ASSERT_TRUE(ref_rows_in_order(&sorted, &plain, ref_line_desc_name));+ cbm_cypher_result_free(&sorted);+ cbm_cypher_result_free(&plain);++ /* All keys tied: both sorts keep the unsorted order. */+ ASSERT_TRUE(ref_query(s, "MATCH (f:Function) RETURN f.name, f.label", &plain));+ ASSERT_TRUE(+ ref_query(s, "MATCH (f:Function) RETURN f.name, f.label ORDER BY f.label", &sorted));+ ASSERT_TRUE(ref_rows_in_order(&sorted, &plain, ref_all_equal));+ cbm_cypher_result_free(&sorted);+ ASSERT_TRUE(ref_query(+ s, "MATCH (f:Function) WITH f.name AS n, f.label AS l ORDER BY l RETURN n, l", &sorted));+ ASSERT_TRUE(ref_rows_in_order(&sorted, &plain, ref_all_equal));+ cbm_cypher_result_free(&sorted);+ cbm_cypher_result_free(&plain);+ cbm_store_close(s);+ PASS();+}++/* `got` must be the first occurrence of every value in column 0 of `all`. */+static bool ref_first_occurrences(const cbm_cypher_result_t *got, const cbm_cypher_result_t *all) {+ int kept = 0;+ for (int i = 0; i < all->row_count; i++) {+ bool seen = false;+ for (int j = 0; j < i && !seen; j++) {+ seen = strcmp(all->rows[i][0], all->rows[j][0]) == 0;+ }+ if (seen) {+ continue;+ }+ if (kept >= got->row_count || strcmp(got->rows[kept][0], all->rows[i][0]) != 0) {+ return false;+ }+ kept++;+ }+ return kept == got->row_count;+}++TEST(cypher_distinct_keeps_first_occurrences) {+ cbm_store_t *s = setup_reference_store();+ cbm_cypher_result_t all;+ cbm_cypher_result_t got;+ ASSERT_TRUE(ref_query(s, "MATCH (f:Function) RETURN f.name", &all));+ ASSERT_TRUE(ref_query(s, "MATCH (f:Function) RETURN DISTINCT f.name", &got));+ ASSERT_EQ(got.row_count, REF_NAMES);+ ASSERT_TRUE(ref_first_occurrences(&got, &all));+ cbm_cypher_result_free(&got);+ ASSERT_TRUE(ref_query(s, "MATCH (f:Function) WITH DISTINCT f.name AS n RETURN n", &got));+ ASSERT_EQ(got.row_count, REF_NAMES);+ ASSERT_TRUE(ref_first_occurrences(&got, &all));+ cbm_cypher_result_free(&got);+ cbm_cypher_result_free(&all);+ cbm_store_close(s);+ PASS();+}++/* `got` (column 0 = callee, column 1 = count) must list the callees of+ * `pairs` (column 0 = callee, column 1 = caller name) in first-seen order,+ * each with its caller count — of distinct names when `distinct`. */+static bool ref_groups_match(const cbm_cypher_result_t *got, const cbm_cypher_result_t *pairs,+ bool distinct) {+ enum { REF_PAIRS_MAX = REF_NODES * 4 };+ if (pairs->row_count > REF_PAIRS_MAX) {+ return false;+ }+ bool first_callee[REF_PAIRS_MAX];+ bool first_pair[REF_PAIRS_MAX];+ for (int k = 0; k < pairs->row_count; k++) {+ first_callee[k] = true;+ first_pair[k] = true;+ for (int m = 0; m < k; m++) {+ if (strcmp(pairs->rows[m][0], pairs->rows[k][0]) == 0) {+ first_callee[k] = false;+ first_pair[k] = first_pair[k] && strcmp(pairs->rows[m][1], pairs->rows[k][1]) != 0;+ }+ }+ }+ int groups = 0;+ for (int i = 0; i < pairs->row_count; i++) {+ if (!first_callee[i]) {+ continue;+ }+ int count = 0;+ for (int k = 0; k < pairs->row_count; k++) {+ if (strcmp(pairs->rows[k][0], pairs->rows[i][0]) == 0) {+ count += !distinct || first_pair[k] ? 1 : 0;+ }+ }+ char want[16];+ snprintf(want, sizeof(want), "%d", count);+ if (groups >= got->row_count || strcmp(got->rows[groups][0], pairs->rows[i][0]) != 0 ||+ strcmp(got->rows[groups][1], want) != 0) {+ return false;+ }+ groups++;+ }+ return groups == got->row_count;+}++TEST(cypher_grouping_keeps_first_seen_groups) {+ cbm_store_t *s = setup_reference_store();+ cbm_cypher_result_t pairs;+ cbm_cypher_result_t got;+ ASSERT_TRUE(ref_query(+ s, "MATCH (a)-[:CALLS]->(b:Function) RETURN b.qualified_name, a.name", &pairs));+ ASSERT_GT(pairs.row_count, REF_NODES * 2);++ ASSERT_TRUE(ref_query(+ s, "MATCH (a)-[:CALLS]->(b:Function) RETURN b.qualified_name, count(a) AS c", &got));+ ASSERT_TRUE(ref_groups_match(&got, &pairs, false));+ cbm_cypher_result_free(&got);++ ASSERT_TRUE(ref_query(s,+ "MATCH (a)-[:CALLS]->(b:Function) "+ "RETURN b.qualified_name, count(DISTINCT a.name) AS c",+ &got));+ ASSERT_TRUE(ref_groups_match(&got, &pairs, true));+ cbm_cypher_result_free(&got);++ ASSERT_TRUE(ref_query(s,+ "MATCH (a)-[:CALLS]->(b:Function) WITH b.qualified_name AS q, "+ "count(DISTINCT a.name) AS c RETURN q, c",+ &got));+ ASSERT_TRUE(ref_groups_match(&got, &pairs, true));+ cbm_cypher_result_free(&got);+ cbm_cypher_result_free(&pairs);+ cbm_store_close(s);+ PASS();+}+/* ══════════════════════════════════════════════════════════════════ */SUITE(cypher) {@@ -5823,4 +6074,7 @@ SUITE(cypher) {RUN_TEST(cypher_chain_with_unbound_alias_keeps_seed);RUN_TEST(cypher_many_union_branches);RUN_TEST(cypher_fifty_union_branches);+ RUN_TEST(cypher_order_by_is_the_stable_reference_order);+ RUN_TEST(cypher_distinct_keeps_first_occurrences);+ RUN_TEST(cypher_grouping_keeps_first_seen_groups);}diff --git a/tests/test_git_context.c b/tests/test_git_context.cindex 20bea722f..e21c10c8a 100644--- a/tests/test_git_context.c+++ b/tests/test_git_context.c@@ -440,9 +440,66 @@ TEST(githistory_ignores_inherited_repo_env) {#endif /* _WIN32 */}+/* ── Branch-only resolve (list_projects) ───────────────────────────+ * The listing prints only the branch; cbm_git_branch_resolve gets it from the+ * two git calls cbm_git_context_resolve uses for it, so both must agree. */++#ifndef _WIN32+/* The branch resolver against the full context at `path`; NULL `want` = not git. */+static bool branch_resolve_agrees(const char *path, const char *want) {+ cbm_git_context_t ctx = {0};+ (void)cbm_git_context_resolve(path, &ctx);+ bool is_git = false;+ char *branch = NULL;+ (void)cbm_git_branch_resolve(path, &is_git, &branch);+ bool agrees = is_git == ctx.is_git && is_git == (want != NULL) &&+ (!want || (branch && ctx.branch && strcmp(branch, want) == 0 &&+ strcmp(ctx.branch, want) == 0));+ free(branch);+ cbm_git_context_free(&ctx);+ return agrees;+}+#endif /* _WIN32 */++TEST(git_branch_resolve_matches_full_context) {+#ifdef _WIN32+ SKIP_PLATFORM("git-based branch test not supported on Windows CI");+#else+ char plain[512];+ char *tmp = th_mktempdir("cbm_gitbranch_plain");+ if (!tmp) FAIL("th_mktempdir returned NULL");+ snprintf(plain, sizeof(plain), "%s", tmp);+ tmp = th_mktempdir("cbm_gitbranch");+ if (!tmp) FAIL("th_mktempdir returned NULL");+ if (make_git_repo(tmp) != 0) {+ th_rmtree(tmp);+ th_rmtree(plain);+ SKIP_PLATFORM("git not available to init a repo");+ }+ char sub[600];+ snprintf(sub, sizeof(sub), "%s/sub", tmp);+ ASSERT_EQ(th_mkdir_p(sub), 0);+ char missing[600];+ snprintf(missing, sizeof(missing), "%s/missing", plain);++ ASSERT_TRUE(branch_resolve_agrees(plain, NULL));+ ASSERT_TRUE(branch_resolve_agrees(missing, NULL));+ ASSERT_EQ(git_run(tmp, "checkout -q -b feat/x"), 0);+ ASSERT_TRUE(branch_resolve_agrees(tmp, "feat/x"));+ ASSERT_TRUE(branch_resolve_agrees(sub, "feat/x"));+ ASSERT_EQ(git_run(tmp, "checkout -q --detach"), 0);+ ASSERT_TRUE(branch_resolve_agrees(tmp, "DETACHED"));++ th_rmtree(tmp);+ th_rmtree(plain);+ PASS();+#endif /* _WIN32 */+}+/* ── Suite ──────────────────────────────────────────────────────── */SUITE(git_context) {+ RUN_TEST(git_branch_resolve_matches_full_context);RUN_TEST(root_exists_non_ascii_directory);RUN_TEST(canonical_root_repo_root);RUN_TEST(canonical_root_subdir);diff --git a/tests/test_mcp.c b/tests/test_mcp.cindex 907471f30..ebf24a827 100644--- a/tests/test_mcp.c+++ b/tests/test_mcp.c@@ -12205,6 +12205,16 @@ TEST(search_code_windows_scope_prefilter_removes_pipeline_filter) {#endif}+/* An indexed project's scan runs in process; the supervised runner now serves+ * the unindexed recursive fallback and a Windows file_pattern it cannot+ * prefilter. The supervision tests below pin that runner through the command+ * override, with a command that does nothing: their probes act at spawn. */+#ifdef _WIN32+static const char MCP_SUPERVISED_SCAN_NOOP[] = "cd .";+#else+static const char MCP_SUPERVISED_SCAN_NOOP[] = ":";+#endif+TEST(search_code_cancel_cleans_supervised_scan) {mcp_search_cache_t cache;ASSERT_TRUE(mcp_search_cache_open(&cache, "cbm-search-cancel"));@@ -12213,6 +12223,7 @@ TEST(search_code_cancel_cleans_supervised_scan) {cbm_mcp_server_t *srv = setup_prefilter_server(tmp, sizeof(tmp), src_path, sizeof(src_path),vendor_path, sizeof(vendor_path));ASSERT_NOT_NULL(srv);+ cbm_mcp_server_set_search_scan_command_for_test(srv, MCP_SUPERVISED_SCAN_NOOP);mcp_search_command_probe_t probe = {.server = srv,.cancel_on_call = true,@@ -12490,6 +12501,7 @@ TEST(search_code_scan_deadline_precedes_output_limit) {cbm_mcp_server_t *srv = setup_prefilter_server(tmp, sizeof(tmp), src_path, sizeof(src_path),vendor_path, sizeof(vendor_path));ASSERT_NOT_NULL(srv);+ cbm_mcp_server_set_search_scan_command_for_test(srv, MCP_SUPERVISED_SCAN_NOOP);mcp_search_command_probe_t probe = {.fill_output_directory = logs, .delay_ms = 1100};cbm_mcp_server_set_command_test_hook(srv, mcp_search_command_hook_probe, &probe);cbm_mcp_server_set_search_scan_timeout_for_test(srv, 1000, true);@@ -12521,6 +12533,7 @@ TEST(search_code_scan_hook_rejection_is_contained_and_cleans_up) {vendor_path, sizeof(vendor_path));ASSERT_NOT_NULL(srv);cbm_mcp_server_set_search_scratch_dir_for_test(srv, cache.path);+ cbm_mcp_server_set_search_scan_command_for_test(srv, MCP_SUPERVISED_SCAN_NOOP);mcp_search_command_probe_t probe = {.reject = true, .scratch_directory = cache.path};cbm_mcp_server_set_command_test_hook(srv, mcp_search_command_hook_probe, &probe);@@ -24546,6 +24559,272 @@ TEST(search_code_drops_walker_hits_that_resolve_outside_root) {#endif}+/* ── In-process search_code scan ───────────────────────────────────+ * The scoped scan used to shell out to grep (POSIX) or Select-String+ * (Windows) and now runs in process. These cases pin its records to the+ * `grep -Hn` shape the subprocess wrote: path:line:content on POSIX, the+ * same fields TAB-separated on Windows. */++#ifdef _WIN32+#define SCAN_FS "\t"+#define SCAN_RS '\n'+#else+#define SCAN_FS ":"+#define SCAN_RS '\0'+#endif++typedef struct {+ char dir[256];+ char list[512];+ char out[512];+ char files[4][512];+ int count;+} scan_fixture_t;++static bool scan_fixture_open(scan_fixture_t *fx) {+ memset(fx, 0, sizeof(*fx));+ const char *tmp = th_mktempdir("cbm_scan");+ if (!tmp) {+ return false;+ }+ snprintf(fx->dir, sizeof(fx->dir), "%s", tmp);+ snprintf(fx->list, sizeof(fx->list), "%s/list", tmp);+ snprintf(fx->out, sizeof(fx->out), "%s/out", tmp);+ return true;+}++/* Add a file holding exactly `length` bytes (NUL bytes allowed). */+static bool scan_fixture_add(scan_fixture_t *fx, const char *name, const char *data,+ size_t length) {+ if (fx->count >= 4) {+ return false;+ }+ /* Format from a copy: GCC's -Werror=restrict rejects a source and a+ * destination inside the same struct. */+ char dir[sizeof(fx->dir)];+ memcpy(dir, fx->dir, sizeof(dir));+ char *path = fx->files[fx->count];+ snprintf(path, sizeof(fx->files[0]), "%s/%s", dir, name);+ FILE *fp = cbm_fopen(path, "wb");+ if (!fp) {+ return false;+ }+ bool ok = fwrite(data, 1, length, fp) == length;+ ok = fclose(fp) == 0 && ok;+ fx->count += ok ? 1 : 0;+ return ok;+}++/* Write the scoped file list as search_code does (NUL records on POSIX,+ * lines on Windows); `extra` names one more path that need not exist. */+static bool scan_fixture_list(const scan_fixture_t *fx, const char *extra) {+ FILE *fp = cbm_fopen(fx->list, "wb");+ if (!fp) {+ return false;+ }+ bool ok = true;+ for (int i = 0; i < fx->count; i++) {+ ok = ok && fputs(fx->files[i], fp) != EOF && fputc(SCAN_RS, fp) != EOF;+ }+ if (extra) {+ ok = ok && fputs(extra, fp) != EOF && fputc(SCAN_RS, fp) != EOF;+ }+ return fclose(fp) == 0 && ok;+}++/* Run the scan; returns the records it wrote (caller frees), CRs kept. */+static char *scan_fixture_run(const scan_fixture_t *fx, const char *pattern, bool use_regex,+ size_t output_limit, int *cause) {+ *cause = cbm_mcp_search_scan_for_test(NULL, fx->list, pattern, use_regex, fx->out,+ output_limit, UINT64_MAX);+ FILE *fp = cbm_fopen(fx->out, "rb");+ if (!fp) {+ return NULL;+ }+ char *text = calloc(CBM_SZ_64K, 1);+ size_t length = text ? fread(text, 1, CBM_SZ_64K - 1, fp) : 0;+ (void)fclose(fp);+ if (text) {+ text[length] = '\0';+ }+ return text;+}++/* Append one expected record to `buf`. */+static void scan_expect(char *buf, size_t cap, const char *path, int line, const char *content) {+ size_t used = strlen(buf);+ snprintf(buf + used, cap - used, "%s" SCAN_FS "%d" SCAN_FS "%s\n", path, line, content);+}++TEST(search_code_scan_in_process_writes_grep_records) {+ scan_fixture_t fx;+ ASSERT_TRUE(scan_fixture_open(&fx));+ /* The last line has no newline and line 3 is empty. */+ static const char a[] = "alpha\nbeta gamma\n\nalpha beta\nlast alpha";+ static const char b[] = "nothing\nalpha\n";+ ASSERT_TRUE(scan_fixture_add(&fx, "a.txt", a, sizeof(a) - 1));+ ASSERT_TRUE(scan_fixture_add(&fx, "b.txt", b, sizeof(b) - 1));+ ASSERT_TRUE(scan_fixture_list(&fx, NULL));+ const char *pa = fx.files[0];+ const char *pb = fx.files[1];+ char want[4096];+ int cause = -1;++ /* Literal: every matching line, file order, then line order. */+ want[0] = '\0';+ scan_expect(want, sizeof(want), pa, 1, "alpha");+ scan_expect(want, sizeof(want), pa, 4, "alpha beta");+ scan_expect(want, sizeof(want), pa, 5, "last alpha");+ scan_expect(want, sizeof(want), pb, 2, "alpha");+ char *got = scan_fixture_run(&fx, "alpha", false, 0, &cause);+ ASSERT_NOT_NULL(got);+ ASSERT_EQ(cause, 0);+ ASSERT_STR_EQ(got, want);+ free(got);++ /* A multi-line pattern is one pattern per line, as with grep -f. */+ want[0] = '\0';+ scan_expect(want, sizeof(want), pa, 2, "beta gamma");+ scan_expect(want, sizeof(want), pa, 4, "alpha beta");+ got = scan_fixture_run(&fx, "gamma\nbeta", false, 0, &cause);+ ASSERT_NOT_NULL(got);+ ASSERT_EQ(cause, 0);+ ASSERT_STR_EQ(got, want);+ free(got);++ /* An empty pattern matches every line, the empty one included. */+ want[0] = '\0';+ scan_expect(want, sizeof(want), pa, 1, "alpha");+ scan_expect(want, sizeof(want), pa, 2, "beta gamma");+ scan_expect(want, sizeof(want), pa, 3, "");+ scan_expect(want, sizeof(want), pa, 4, "alpha beta");+ scan_expect(want, sizeof(want), pa, 5, "last alpha");+ scan_expect(want, sizeof(want), pb, 1, "nothing");+ scan_expect(want, sizeof(want), pb, 2, "alpha");+ got = scan_fixture_run(&fx, "", false, 0, &cause);+ ASSERT_NOT_NULL(got);+ ASSERT_EQ(cause, 0);+ ASSERT_STR_EQ(got, want);+ free(got);++ /* Extended regex, anchored per line. */+ want[0] = '\0';+ scan_expect(want, sizeof(want), pa, 1, "alpha");+ scan_expect(want, sizeof(want), pa, 4, "alpha beta");+ scan_expect(want, sizeof(want), pa, 5, "last alpha");+ scan_expect(want, sizeof(want), pb, 2, "alpha");+ got = scan_fixture_run(&fx, "^(alpha|last)", true, 0, &cause);+ ASSERT_NOT_NULL(got);+ ASSERT_EQ(cause, 0);+ ASSERT_STR_EQ(got, want);+ free(got);++ /* No match: success with no records. */+ got = scan_fixture_run(&fx, "zzqqxx", false, 0, &cause);+ ASSERT_NOT_NULL(got);+ ASSERT_EQ(cause, 0);+ ASSERT_STR_EQ(got, "");+ free(got);+ th_rmtree(fx.dir);+ PASS();+}++TEST(search_code_scan_in_process_binary_and_crlf) {+ scan_fixture_t fx;+ ASSERT_TRUE(scan_fixture_open(&fx));+ /* A NUL in the first 32 KiB marks the whole file binary: no records. */+ static const char bin[] = "alpha\n\0alpha\n";+ ASSERT_TRUE(scan_fixture_add(&fx, "bin.dat", bin, sizeof(bin) - 1));+ /* A later NUL ends the text at the last complete line before it. */+ enum { FILLER_LINES = 4000 }; /* 10 bytes each: past the 32 KiB probe */+ size_t late_cap = (size_t)FILLER_LINES * 10 + 64;+ char *late = malloc(late_cap);+ ASSERT_NOT_NULL(late);+ size_t used = 0;+ for (int i = 0; i < FILLER_LINES; i++) {+ memcpy(late + used, "xxxxxxxxx\n", 10);+ used += 10;+ }+ static const char tail[] = "alpha one\nalpha two\0\nalpha three\n";+ memcpy(late + used, tail, sizeof(tail) - 1);+ used += sizeof(tail) - 1;+ ASSERT_TRUE(scan_fixture_add(&fx, "late.txt", late, used));+ free(late);+ static const char crlf[] = "alpha\r\nbeta\r\n";+ ASSERT_TRUE(scan_fixture_add(&fx, "crlf.txt", crlf, sizeof(crlf) - 1));+ ASSERT_TRUE(scan_fixture_list(&fx, NULL));+ char want[4096];+ int cause = -1;++ /* The record keeps the line's CR; the result parser trims it. */+ want[0] = '\0';+ scan_expect(want, sizeof(want), fx.files[1], FILLER_LINES + 1, "alpha one");+ scan_expect(want, sizeof(want), fx.files[2], 1, "alpha\r");+ char *got = scan_fixture_run(&fx, "alpha", false, 0, &cause);+ ASSERT_NOT_NULL(got);+ ASSERT_EQ(cause, 0);+ ASSERT_STR_EQ(got, want);+ free(got);++ /* `$` before a CR: grep on POSIX sees the CR and does not match;+ * Select-String's Line on Windows had no CR and did. */+ want[0] = '\0';+#ifdef _WIN32+ scan_expect(want, sizeof(want), fx.files[2], 2, "beta\r");+#endif+ got = scan_fixture_run(&fx, "^beta$", true, 0, &cause);+ ASSERT_NOT_NULL(got);+ ASSERT_EQ(cause, 0);+ ASSERT_STR_EQ(got, want);+ free(got);+ th_rmtree(fx.dir);+ PASS();+}++TEST(search_code_scan_in_process_limits_and_failures) {+ scan_fixture_t fx;+ ASSERT_TRUE(scan_fixture_open(&fx));+ static const char a[] = "alpha\nalpha\nalpha\n";+ ASSERT_TRUE(scan_fixture_add(&fx, "a.txt", a, sizeof(a) - 1));+ ASSERT_TRUE(scan_fixture_list(&fx, NULL));+ int cause = -1;++ /* Past the output limit: the output-limit cause (3), not a failure. */+ char *got = scan_fixture_run(&fx, "alpha", false, 8, &cause);+ free(got);+ ASSERT_EQ(cause, 3);++ /* An invalid regex is a command failure (1), as grep's exit 2 was. */+ got = scan_fixture_run(&fx, "(", true, 0, &cause);+ free(got);+ ASSERT_EQ(cause, 1);++ /* A passed deadline stops the scan before the next file (4); a request+ * cancelled under the server stops it too, and takes precedence (5). */+ ASSERT_EQ(cbm_mcp_search_scan_for_test(NULL, fx.list, "alpha", false, fx.out, 0, 0), 4);+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ ASSERT_NOT_NULL(srv);+ ASSERT_TRUE(cbm_mcp_server_request_scope_begin(srv));+ ASSERT_TRUE(cbm_mcp_server_cancel_active(srv));+ cause = cbm_mcp_search_scan_for_test(srv, fx.list, "alpha", false, fx.out, 0, 0);+ cbm_mcp_server_request_scope_end(srv);+ cbm_mcp_server_free(srv);+ ASSERT_EQ(cause, 5);++ /* A listed file that cannot be read is a command failure (1) as well. */+ char missing[600];+ snprintf(missing, sizeof(missing), "%s/missing.txt", fx.dir);+ ASSERT_TRUE(scan_fixture_list(&fx, missing));+ got = scan_fixture_run(&fx, "alpha", false, 0, &cause);+ free(got);+ ASSERT_EQ(cause, 1);+ th_rmtree(fx.dir);+ PASS();+}++#undef SCAN_FS+#undef SCAN_RS+SUITE(mcp) {RUN_TEST(index_repository_async_and_status_refused_without_daemon_issue2144);RUN_TEST(index_repository_schema_documents_async_polling_issue2144);@@ -24813,6 +25092,9 @@ SUITE(mcp) {RUN_TEST(search_code_scan_deadline_override_is_per_server);RUN_TEST(search_code_scan_setup_failures_respect_cause_precedence);RUN_TEST(search_code_scan_live_child_deadline_is_bounded_and_fails_closed);+ RUN_TEST(search_code_scan_in_process_writes_grep_records);+ RUN_TEST(search_code_scan_in_process_binary_and_crlf);+ RUN_TEST(search_code_scan_in_process_limits_and_failures);RUN_TEST(search_code_scan_cancellation_precedes_zero_deadline);RUN_TEST(search_code_scan_deadline_precedes_output_limit);RUN_TEST(search_code_scan_hook_rejection_is_contained_and_cleans_up);diff --git a/tests/test_store_pragmas.c b/tests/test_store_pragmas.cindex a81d73cbd..0db6a6e52 100644--- a/tests/test_store_pragmas.c+++ b/tests/test_store_pragmas.c@@ -345,7 +345,75 @@ TEST(corrupt_page_scan_returns_error_not_truncation) {PASS();}+/* A read tool's statements share one read batch instead of taking the file+ * lock once per statement. The batch reads one snapshot until it renews+ * (every 100 ms, forced here through the seam), then sees later commits. */+static char *read_batch_name(cbm_store_t *s) {+ cbm_node_t found = {0};+ if (cbm_store_find_node_by_qn(s, "p", "p.a", &found) != CBM_STORE_OK) {+ return NULL;+ }+ char *name = found.name ? strdup(found.name) : NULL;+ cbm_node_free_fields(&found);+ return name;+}++static bool read_batch_rename(cbm_store_t *writer, const char *name) {+ cbm_node_t node = {+ .project = "p", .label = "Function", .name = name, .qualified_name = "p.a", .file_path = "a.c"};+ return cbm_store_upsert_node(writer, &node) > 0;+}++TEST(store_read_batch_snapshot_renews) {+ char *td = th_mktempdir("cbm_read_batch");+ ASSERT_NOT_NULL(td);+ char db_path[512];+ snprintf(db_path, sizeof(db_path), "%s/batch.db", td);+ cbm_store_t *writer = cbm_store_open_path(db_path); /* WAL: commits beside a reader */+ ASSERT_NOT_NULL(writer);+ ASSERT_EQ(cbm_store_upsert_project(writer, "p", td), CBM_STORE_OK);+ ASSERT_TRUE(read_batch_rename(writer, "before"));+ cbm_store_t *reader = cbm_store_open_path_query(db_path);+ ASSERT_NOT_NULL(reader);++ ASSERT_TRUE(cbm_store_read_batch_begin(reader));+ ASSERT_FALSE(cbm_store_read_batch_begin(reader)); /* one batch at a time */+ char *name = read_batch_name(reader);+ ASSERT_STR_EQ(name, "before");+ free(name);++ /* Inside the batch the reader keeps its snapshot... */+ ASSERT_TRUE(read_batch_rename(writer, "after"));+ name = read_batch_name(reader);+ ASSERT_STR_EQ(name, "before");+ free(name);++ /* ...until the batch renews at its next statement. */+ cbm_store_read_batch_expire_for_test(reader);+ name = read_batch_name(reader);+ ASSERT_STR_EQ(name, "after");+ free(name);++ /* Ended, every statement reads the latest commit again. */+ cbm_store_read_batch_end(reader);+ ASSERT_TRUE(read_batch_rename(writer, "latest"));+ name = read_batch_name(reader);+ ASSERT_STR_EQ(name, "latest");+ free(name);++ /* Begin refuses while another transaction is open; close ends a batch. */+ ASSERT_EQ(cbm_store_begin(writer), CBM_STORE_OK);+ ASSERT_FALSE(cbm_store_read_batch_begin(writer));+ ASSERT_EQ(cbm_store_rollback(writer), CBM_STORE_OK);+ ASSERT_TRUE(cbm_store_read_batch_begin(reader));+ cbm_store_close(reader);+ cbm_store_close(writer);+ th_rmtree(td);+ PASS();+}+SUITE(store_pragmas) {+ RUN_TEST(store_read_batch_snapshot_renews);RUN_TEST(journal_size_limit_bounds_wal_issue1083);RUN_TEST(store_role_pragmas_issue1419);RUN_TEST(store_generation_tracks_mutations);