Skip to content

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.

Merge pull request #1787 from umi008/fix/issue-1714-freshness-mtime

Martin Vogelf347d59650ac
diff --cc tests/test_mcp.c
index 974aad10e,30735b8d4..4a02211b2
--- a/tests/test_mcp.c
+++ b/tests/test_mcp.c
@@@ -5545,661 -3139,108 +5545,706 @@@ TEST(tool_check_index_coverage_pages_ex
PASS();
}
-/* Exactly-once trace pagination: 12 callees paged at limit=5 must yield
- * 5+5+2 rows with every callee appearing on exactly one page, exact totals
- * on every page, and a final page without a cursor. Stale and mismatched
- * cursors must fail with teaching errors, never silently restart. */
-TEST(tool_trace_pagination_exactly_once) {
+/* The range string can carry a trailing ",+<N>" marker saying the producer hit
+ * its own cap and threw ranges away. The reader must emit every range in front
+ * of the marker, must not turn the marker itself into a range, and must say
+ * "ranges_truncated" so nobody reads a short list as a complete one. The reader has a
+ * second cap of its own, and that one must report itself the same way. */
+TEST(tool_check_index_coverage_reports_truncation_marker_issue963) {
+ enum { WIDE_RANGE_COUNT = 300 };
cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+ ASSERT_NOT_NULL(srv);
cbm_store_t *st = cbm_mcp_server_store(srv);
- const char *proj = "pageproj";
- cbm_mcp_server_set_project(srv, proj);
- cbm_store_upsert_project(st, proj, "/tmp/page");
+ ASSERT_NOT_NULL(st);
- cbm_node_t hub = {.project = proj,
- .label = "Function",
- .name = "hub",
- .qualified_name = "pageproj.h.hub",
- .file_path = "h.c",
- .start_line = 1,
- .end_line = 9};
- int64_t hid = cbm_store_upsert_node(st, &hub);
- ASSERT_GT(hid, 0);
- enum { CALLEES = 12 };
- for (int i = 0; i < CALLEES; i++) {
- char nm[16];
- char qn[48];
- snprintf(nm, sizeof(nm), "c%02d", i);
- snprintf(qn, sizeof(qn), "pageproj.m.c%02d", i);
- cbm_node_t n = {.project = proj,
- .label = "Function",
- .name = nm,
- .qualified_name = qn,
- .file_path = "m.c",
- .start_line = 1,
- .end_line = 3};
- int64_t nid = cbm_store_upsert_node(st, &n);
- ASSERT_GT(nid, 0);
- cbm_edge_t e = {.project = proj, .source_id = hid, .target_id = nid, .type = "CALLS"};
- ASSERT_GT(cbm_store_insert_edge(st, &e), 0);
- }
+ const char *project = "coverage-marker";
+ ASSERT_EQ(cbm_store_upsert_project(st, project, "/tmp/coverage-marker"), CBM_STORE_OK);
+ cbm_mcp_server_set_project(srv, project);
- char pages[3][4096];
- char tok[192] = "";
- int npages = 0;
- for (; npages < 3; npages++) {
- char req[640];
- if (tok[0]) {
- snprintf(req, sizeof(req),
- "{\"jsonrpc\":\"2.0\",\"id\":80,\"method\":\"tools/call\",\"params\":{"
- "\"name\":\"trace_call_path\",\"arguments\":{\"project\":\"pageproj\","
- "\"function_name\":\"hub\",\"direction\":\"outbound\",\"limit\":5,"
- "\"cursor\":\"%s\"}}}",
- tok);
- } else {
- snprintf(req, sizeof(req),
- "{\"jsonrpc\":\"2.0\",\"id\":80,\"method\":\"tools/call\",\"params\":{"
- "\"name\":\"trace_call_path\",\"arguments\":{\"project\":\"pageproj\","
- "\"function_name\":\"hub\",\"direction\":\"outbound\",\"limit\":5}}}");
- }
- char *resp = cbm_mcp_server_handle(srv, req);
- ASSERT_NOT_NULL(resp);
- char *inner = extract_text_content(resp);
- free(resp);
- ASSERT_NOT_NULL(inner);
- snprintf(pages[npages], sizeof(pages[npages]), "%s", inner);
- ASSERT_NOT_NULL(strstr(inner, "callees_total: 12")); /* exact total, every page */
- const char *nx = strstr(inner, "next: ");
- if (nx) {
- const char *e = strchr(nx + 6, '\n');
- size_t tl = e ? (size_t)(e - (nx + 6)) : strlen(nx + 6);
- ASSERT_TRUE(tl < sizeof(tok));
- memcpy(tok, nx + 6, tl);
- tok[tl] = '\0';
- } else {
- tok[0] = '\0';
- }
- free(inner);
- if (!tok[0]) {
- npages++;
- break;
- }
+ /* 300 one-line ranges — past the reader's own 256 limit. */
+ char *wide = calloc(1, WIDE_RANGE_COUNT * 12 + 1);
+ ASSERT_NOT_NULL(wide);
+ size_t off = 0;
+ for (int i = 0; i < WIDE_RANGE_COUNT; i++) {
+ off += (size_t)snprintf(wide + off, WIDE_RANGE_COUNT * 12 + 1 - off, "%s%d-%d",
+ i ? "," : "", i * 3 + 1, i * 3 + 1);
}
- ASSERT_EQ(npages, 3); /* 5 + 5 + 2 */
- /* Exactly-once: every callee appears on exactly ONE page. */
- for (int i = 0; i < CALLEES; i++) {
- char qn[48];
- snprintf(qn, sizeof(qn), " c%02d 1\n", i);
- int seen = 0;
- for (int p = 0; p < 3; p++) {
- if (strstr(pages[p], qn)) {
- seen++;
- }
- }
- ASSERT_EQ(seen, 1);
+
+ cbm_coverage_row_t rows[3] = {
+ {.rel_path = "src/marked.c", .kind = "parse_partial", .detail = "3-4,9-9,+12"},
+ {.rel_path = "src/plain.c", .kind = "parse_partial", .detail = "3-4,9-9"},
+ {.rel_path = "src/wide.c", .kind = "parse_partial", .detail = wide},
+ };
+ for (int i = 0; i < 3; i++) {
+ ASSERT_EQ(cbm_store_upsert_file_hash(st, project, rows[i].rel_path, "fixture", i + 1, 10),
+ CBM_STORE_OK);
}
- /* Final page carries no cursor. */
- ASSERT_NULL(strstr(pages[2], "next: "));
+ ASSERT_EQ(cbm_store_coverage_replace(st, project, rows, 3), CBM_STORE_OK);
- /* Params mismatch: replay a page-2-era cursor with a different depth. */
- const char *nx1 = strstr(pages[0], "next: ");
- ASSERT_NOT_NULL(nx1);
- char tok1[192];
- const char *e1 = strchr(nx1 + 6, '\n');
- size_t tl1 = e1 ? (size_t)(e1 - (nx1 + 6)) : strlen(nx1 + 6);
+ /* The marked file: both real ranges survive, the marker is flagged, and the
+ * "12" from the marker never becomes a range of its own. */
+ char *marked =
+ cbm_mcp_handle_tool(srv, "check_index_coverage",
+ "{\"project\":\"coverage-marker\",\"paths\":[\"src/marked.c\"],\"format\":\"json\"}");
+ ASSERT_NOT_NULL(marked);
+ char *marked_inner = extract_text_content(marked);
+ ASSERT_NOT_NULL(marked_inner);
+ ASSERT_NOT_NULL(strstr(marked_inner, "\"start\":3"));
+ ASSERT_NOT_NULL(strstr(marked_inner, "\"start\":9"));
+ ASSERT_NULL(strstr(marked_inner, "\"start\":12"));
+ ASSERT_NOT_NULL(strstr(marked_inner, "\"ranges_truncated\":true"));
+ free(marked_inner);
+ free(marked);
+
+ /* The same ranges without a marker must NOT be reported as truncated. */
+ char *plain =
+ cbm_mcp_handle_tool(srv, "check_index_coverage",
+ "{\"project\":\"coverage-marker\",\"paths\":[\"src/plain.c\"],\"format\":\"json\"}");
+ ASSERT_NOT_NULL(plain);
+ char *plain_inner = extract_text_content(plain);
+ ASSERT_NOT_NULL(plain_inner);
+ ASSERT_NOT_NULL(strstr(plain_inner, "\"start\":3"));
+ ASSERT_NULL(strstr(plain_inner, "\"ranges_truncated\":true"));
+ free(plain_inner);
+ free(plain);
+
+ /* The reader's own limit stops the list early, so it must say so even
+ * though the producer sent no marker. */
+ char *widest =
+ cbm_mcp_handle_tool(srv, "check_index_coverage",
+ "{\"project\":\"coverage-marker\",\"paths\":[\"src/wide.c\"],\"format\":\"json\"}");
+ ASSERT_NOT_NULL(widest);
+ char *wide_inner = extract_text_content(widest);
+ ASSERT_NOT_NULL(wide_inner);
+ ASSERT_NOT_NULL(strstr(wide_inner, "\"ranges_truncated\":true"));
+ free(wide_inner);
+ free(widest);
+
+ free(wide);
+ cbm_mcp_server_free(srv);
+ PASS();
+}
+
+TEST(tool_check_index_coverage_reports_paths_scopes_and_ranges) {
+ char tmp[256];
+ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
+ ASSERT_NOT_NULL(srv);
+ cbm_store_t *st = cbm_mcp_server_store(srv);
+ ASSERT_NOT_NULL(st);
+
+ ASSERT_EQ(cbm_store_upsert_file_hash(st, "test-project", "main.go", "", 0, 0), CBM_STORE_OK);
+ ASSERT_EQ(cbm_store_upsert_file_hash(st, "test-project", "src/skip.c", "", 0, 0), CBM_STORE_OK);
+ cbm_coverage_row_t rows[] = {
+ {.rel_path = "main.go", .kind = "parse_partial", .detail = "3-4,9"},
+ {.rel_path = "generated", .kind = "not_indexed_dir", .detail = "excluded subtree"},
+ {.rel_path = "src/skip.c", .kind = "oversized", .detail = "file exceeds cap"},
+ };
+ ASSERT_EQ(cbm_store_coverage_replace(st, "test-project", rows, 3), CBM_STORE_OK);
+
+ char *coverage =
+ cbm_mcp_handle_tool(srv, "check_index_coverage",
+ "{\"project\":\"test-project\","
+ "\"paths\":[\"main.go\",\"generated/pkg/a.c\",\"../escape.c\"],"
+ "\"scopes\":[\".\"],\"format\":\"json\"}");
+ ASSERT_NOT_NULL(coverage);
+ char *inner = extract_text_content(coverage);
+ ASSERT_NOT_NULL(inner);
+ ASSERT_NOT_NULL(strstr(inner, "\"path\":\"main.go\""));
+ ASSERT_NOT_NULL(strstr(inner, "\"status\":\"partial\""));
+ ASSERT_NOT_NULL(strstr(inner, "\"start\":3"));
+ ASSERT_NOT_NULL(strstr(inner, "\"end\":4"));
+ ASSERT_NOT_NULL(strstr(inner, "\"start\":9"));
+ ASSERT_NOT_NULL(strstr(inner, "generated/pkg/a.c"));
+ ASSERT_NOT_NULL(strstr(inner, "not_indexed_dir"));
+ ASSERT_NOT_NULL(strstr(inner, "outside_project"));
+ ASSERT_NOT_NULL(strstr(inner, "src/skip.c"));
+ ASSERT_NOT_NULL(strstr(inner, "file exceeds cap"));
+ ASSERT_NOT_NULL(strstr(inner, "best_effort"));
+
+ free(inner);
+ free(coverage);
+ cbm_mcp_server_free(srv);
+ cleanup_snippet_dir(tmp);
+ PASS();
+}
+
+TEST(tool_check_index_coverage_preserves_multiple_scope_labels) {
+ char tmp[256];
+ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
+ ASSERT_NOT_NULL(srv);
+
+ char *coverage = cbm_mcp_handle_tool(srv, "check_index_coverage",
+ "{\"project\":\"test-project\","
+ "\"scopes\":[\"alpha/one\",\"bravo/two\",\"charl/tri\"],"
+ "\"format\":\"json\"}");
+ ASSERT_NOT_NULL(coverage);
+ char *inner = extract_text_content(coverage);
+ ASSERT_NOT_NULL(inner);
+ yyjson_doc *doc = yyjson_read(inner, strlen(inner), 0);
+ ASSERT_NOT_NULL(doc);
+ yyjson_val *scopes = yyjson_obj_get(yyjson_doc_get_root(doc), "scopes");
+ ASSERT_NOT_NULL(scopes);
+ ASSERT_TRUE(yyjson_is_arr(scopes));
+ ASSERT_EQ(yyjson_arr_size(scopes), 3);
+
+ const char *expected[] = {"alpha/one", "bravo/two", "charl/tri"};
+ for (size_t i = 0; i < 3; i++) {
+ yyjson_val *scope = yyjson_obj_get(yyjson_arr_get(scopes, i), "scope");
+ ASSERT_NOT_NULL(scope);
+ ASSERT_TRUE(yyjson_is_str(scope));
+ ASSERT_STR_EQ(yyjson_get_str(scope), expected[i]);
+ }
+
+ yyjson_doc_free(doc);
+ free(inner);
+ free(coverage);
+ cbm_mcp_server_free(srv);
+ cleanup_snippet_dir(tmp);
+ PASS();
+}
+
+static int write_coverage_meta(cbm_store_t *store, const char *generation,
+ const char *recording_status) {
+ cbm_coverage_meta_t meta = {
+ .generation = generation,
+ .index_mode = "fast",
+ .recorded_at = "2026-07-12T00:00:00Z",
+ .recording_status = recording_status,
+ .ignored_files_stored = 0,
+ .ignored_files_total = 0,
+ .coverage_version = 1,
+ .hash_records_complete = true,
+ };
+ return cbm_store_coverage_replace_ex(store, "test-project", NULL, 0, &meta);
+}
+
+TEST(tool_check_index_coverage_accepts_truncated_ignored_catalog_for_fresh_path_issue1613) {
+ char tmp[256];
+ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
+ ASSERT_NOT_NULL(srv);
+ cbm_store_t *store = cbm_mcp_server_store(srv);
+ ASSERT_NOT_NULL(store);
+ char source_path[512];
+ snprintf(source_path, sizeof(source_path), "%s/project/main.go", tmp);
- struct stat source_stat;
- ASSERT_EQ(stat(source_path, &source_stat), 0);
- #ifdef __APPLE__
- int64_t source_mtime_ns =
- ((int64_t)source_stat.st_mtimespec.tv_sec * (int64_t)CBM_NSEC_PER_SEC) +
- (int64_t)source_stat.st_mtimespec.tv_nsec;
- #elif defined(_WIN32)
- int64_t source_mtime_ns = (int64_t)source_stat.st_mtime * (int64_t)CBM_NSEC_PER_SEC;
- #else
- int64_t source_mtime_ns = ((int64_t)source_stat.st_mtim.tv_sec * (int64_t)CBM_NSEC_PER_SEC) +
- (int64_t)source_stat.st_mtim.tv_nsec;
- #endif
- ASSERT_EQ(cbm_store_upsert_file_hash(store, "test-project", "main.go", "", source_mtime_ns,
- source_stat.st_size),
++ /* The fixture must record the hash with the SAME mtime source the indexer
++ * writes with — cbm_path_info_utf8 — not struct stat. On Windows stat
++ * truncates to seconds while the stored record carries FILETIME-derived
++ * nanoseconds, so a stat-written fixture would never compare equal and the
++ * metadata_match contract below would fail. */
++ cbm_path_info_t path_info;
++ ASSERT_EQ(cbm_path_info_utf8(source_path, &path_info), 0);
++ ASSERT_EQ(cbm_store_upsert_file_hash(store, "test-project", "main.go", "", path_info.mtime_ns,
++ path_info.size),
+ CBM_STORE_OK);
+ cbm_project_t project = {0};
+ ASSERT_EQ(cbm_store_get_project(store, "test-project", &project), CBM_STORE_OK);
+ cbm_coverage_meta_t meta = {
+ .generation = project.indexed_at,
+ .index_mode = "fast",
+ .recorded_at = "2026-07-12T00:00:00Z",
+ .recording_status = "truncated",
+ .ignored_files_stored = 2000,
+ .ignored_files_total = 2001,
+ .coverage_version = 1,
+ .hash_records_complete = true,
+ };
+ ASSERT_EQ(cbm_store_coverage_replace_ex(store, "test-project", NULL, 0, &meta), CBM_STORE_OK);
+ cbm_project_free_fields(&project);
+
+ char *response = cbm_mcp_handle_tool(
+ srv, "check_index_coverage",
+ "{\"project\":\"test-project\",\"paths\":[\"main.go\"],\"scopes\":[\".\"],"
+ "\"format\":\"json\"}");
+ ASSERT_NOT_NULL(response);
+ char *inner = extract_text_content(response);
+ ASSERT_NOT_NULL(inner);
+ yyjson_doc *doc = yyjson_read(inner, strlen(inner), 0);
+ ASSERT_NOT_NULL(doc);
+ yyjson_val *root = yyjson_doc_get_root(doc);
+ yyjson_val *path = yyjson_arr_get(yyjson_obj_get(root, "paths"), 0);
+ ASSERT_STR_EQ(yyjson_get_str(yyjson_obj_get(path, "status")), "no_recorded_issue");
+ ASSERT_STR_EQ(yyjson_get_str(yyjson_obj_get(path, "freshness")), "metadata_match");
+ ASSERT_STR_EQ(yyjson_get_str(yyjson_obj_get(path, "recommended_action")),
+ "use_graph_with_best_effort_caveat");
+ yyjson_val *scope = yyjson_arr_get(yyjson_obj_get(root, "scopes"), 0);
+ ASSERT_STR_EQ(yyjson_get_str(yyjson_obj_get(scope, "status")), "coverage_unavailable");
+
+ yyjson_doc_free(doc);
+ free(inner);
+ free(response);
+ cbm_mcp_server_free(srv);
+ cleanup_snippet_dir(tmp);
+ PASS();
+}
+
++/* #1714: coverage freshness must compare mtime_ns at the SAME precision the
++ * indexer records it. The pipeline records cbm_path_info_utf8's value (which
++ * on Windows derives from FILETIME — nanosecond), while the freshness reader
++ * used to recompute from struct stat, which on Windows truncates to seconds
++ * (st_mtime). A byte-identical file therefore never matched and every path was
++ * reported metadata_changed. The reader now uses the indexer's own source. */
++TEST(tool_check_index_coverage_freshness_uses_indexer_mtime_source_issue1714) {
++ char tmp[256];
++ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
++ ASSERT_NOT_NULL(srv);
++ cbm_store_t *store = cbm_mcp_server_store(srv);
++ ASSERT_NOT_NULL(store);
++
++ char source_path[512];
++ snprintf(source_path, sizeof(source_path), "%s/project/main.go", tmp);
++ cbm_path_info_t info;
++ ASSERT_EQ(cbm_path_info_utf8(source_path, &info), 0);
++
++ /* The hash exactly as the indexer writes it: same source, ns precision. */
++ ASSERT_EQ(cbm_store_upsert_file_hash(store, "test-project", "main.go", "", info.mtime_ns,
++ info.size),
++ CBM_STORE_OK);
++
++ char *response = cbm_mcp_handle_tool(
++ srv, "check_index_coverage", "{\"project\":\"test-project\",\"paths\":[\"main.go\"]}");
++ ASSERT_NOT_NULL(response);
++ ASSERT_NOT_NULL(strstr(response, "\"freshness\":\"metadata_match\""));
++ free(response);
++
++ /* A hash stored at seconds precision — what a stat-based reader previously
++ * compared against — must NOT match an unchanged file: the comparison must
++ * stay nanosecond-exact, or part of mtime resolution is silently dropped. */
++ int64_t seconds_mtime_ns = (info.mtime_ns / (int64_t)CBM_NSEC_PER_SEC) *
++ (int64_t)CBM_NSEC_PER_SEC;
++ if (seconds_mtime_ns != info.mtime_ns) {
++ ASSERT_EQ(cbm_store_upsert_file_hash(store, "test-project", "main.go", "",
++ seconds_mtime_ns, info.size),
++ CBM_STORE_OK);
++ response = cbm_mcp_handle_tool(
++ srv, "check_index_coverage", "{\"project\":\"test-project\",\"paths\":[\"main.go\"]}");
++ ASSERT_NOT_NULL(response);
++ ASSERT_NOT_NULL(strstr(response, "\"freshness\":\"metadata_changed\""));
++ free(response);
++ }
++
++ cleanup_snippet_dir(tmp);
++ cbm_mcp_server_free(srv);
++ PASS();
++}
++
+TEST(tool_check_index_coverage_rejects_stale_generation) {
+ char tmp[256];
+ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
+ ASSERT_NOT_NULL(srv);
+ cbm_store_t *store = cbm_mcp_server_store(srv);
+ ASSERT_NOT_NULL(store);
+ ASSERT_EQ(write_coverage_meta(store, "stale-generation", "complete"), CBM_STORE_OK);
+
+ char *response = cbm_mcp_handle_tool(srv, "check_index_coverage",
+ "{\"project\":\"test-project\",\"paths\":[\"main.go\"],"
+ "\"format\":\"json\"}");
+ ASSERT_NOT_NULL(response);
+ char *inner = extract_text_content(response);
+ ASSERT_NOT_NULL(inner);
+ ASSERT_NOT_NULL(strstr(inner, "\"generation_matches\":false"));
+ ASSERT_NOT_NULL(strstr(inner, "\"status\":\"coverage_unavailable\""));
+ ASSERT_NOT_NULL(strstr(inner, "\"recommended_action\":\"read_source_and_reindex\""));
+
+ free(inner);
+ free(response);
+ cbm_mcp_server_free(srv);
+ cleanup_snippet_dir(tmp);
+ PASS();
+}
+
+TEST(tool_check_index_coverage_requires_source_when_file_metadata_changed) {
+ char tmp[256];
+ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
+ ASSERT_NOT_NULL(srv);
+ cbm_store_t *store = cbm_mcp_server_store(srv);
+ ASSERT_NOT_NULL(store);
+ cbm_project_t project = {0};
+ ASSERT_EQ(cbm_store_get_project(store, "test-project", &project), CBM_STORE_OK);
+ ASSERT_EQ(write_coverage_meta(store, project.indexed_at, "complete"), CBM_STORE_OK);
+ cbm_project_free_fields(&project);
+ ASSERT_EQ(cbm_store_upsert_file_hash(store, "test-project", "main.go", "fixture", 0, 0),
+ CBM_STORE_OK);
+
+ char *response = cbm_mcp_handle_tool(srv, "check_index_coverage",
+ "{\"project\":\"test-project\",\"paths\":[\"main.go\"],"
+ "\"format\":\"json\"}");
+ ASSERT_NOT_NULL(response);
+ char *inner = extract_text_content(response);
+ ASSERT_NOT_NULL(inner);
+ ASSERT_NOT_NULL(strstr(inner, "\"generation_matches\":true"));
+ ASSERT_NOT_NULL(strstr(inner, "\"freshness\":\"metadata_changed\""));
+ ASSERT_NOT_NULL(strstr(inner, "\"recommended_action\":\"read_source_and_reindex\""));
+
+ free(inner);
+ free(response);
+ cbm_mcp_server_free(srv);
+ cleanup_snippet_dir(tmp);
+ PASS();
+}
+
+TEST(tool_check_index_coverage_surfaces_lookup_errors) {
+ char tmp[256];
+ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
+ ASSERT_NOT_NULL(srv);
+ cbm_store_t *store = cbm_mcp_server_store(srv);
+ ASSERT_NOT_NULL(store);
+ cbm_project_t project = {0};
+ ASSERT_EQ(cbm_store_get_project(store, "test-project", &project), CBM_STORE_OK);
+ ASSERT_EQ(write_coverage_meta(store, project.indexed_at, "complete"), CBM_STORE_OK);
+ cbm_project_free_fields(&project);
+ ASSERT_EQ(
+ cbm_store_exec(store, "ALTER TABLE index_coverage RENAME COLUMN detail TO broken_detail;"),
+ CBM_STORE_OK);
+
+ char *response = cbm_mcp_handle_tool(
+ srv, "check_index_coverage",
+ "{\"project\":\"test-project\",\"paths\":[\"main.go\"],\"scopes\":[\".\"],"
+ "\"format\":\"json\"}");
+ ASSERT_NOT_NULL(response);
+ char *inner = extract_text_content(response);
+ ASSERT_NOT_NULL(inner);
+ ASSERT_NOT_NULL(strstr(inner, "\"coverage_lookup\":\"error\""));
+ ASSERT_NOT_NULL(strstr(inner, "\"status\":\"coverage_unavailable\""));
+ ASSERT_NULL(strstr(inner, "\"status\":\"no_recorded_issue\""));
+
+ free(inner);
+ free(response);
+ cbm_mcp_server_free(srv);
+ cleanup_snippet_dir(tmp);
+ PASS();
+}
+
+TEST(tool_index_status_includes_git_metadata) {
+ /* The git context block moved behind verbose:true (lean-default contract,
+ * TOON round 2) — this test pins the verbose path's content; the default-
+ * omission guard lives in tool_lean_defaults_schema_and_status. */
+ char tmp[256];
+ cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
+ ASSERT_NOT_NULL(srv);
+
+ char *resp =
+ cbm_mcp_server_handle(srv, "{\"jsonrpc\":\"2.0\",\"id\":16,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"index_status\","
+ "\"arguments\":{\"project\":\"test-project\",\"verbose\":true,"
+ "\"format\":\"json\"}}}");
+ ASSERT_NOT_NULL(resp);
+ char *inner = extract_text_content(resp);
+ ASSERT_NOT_NULL(inner);
+ ASSERT_NOT_NULL(strstr(inner, "\"root_path\""));
+ ASSERT_NOT_NULL(strstr(inner, "\"git\""));
+ ASSERT_NOT_NULL(strstr(inner, "\"is_git\":false"));
+ ASSERT_NOT_NULL(strstr(inner, "\"root_exists\":true"));
+
+ free(inner);
+ free(resp);
+ cbm_mcp_server_free(srv);
+ cleanup_snippet_dir(tmp);
+ PASS();
+}
+
+/* ══════════════════════════════════════════════════════════════════
+ * TOOL HANDLERS WITH DATA
+ * ══════════════════════════════════════════════════════════════════ */
+
+TEST(tool_trace_call_path_not_found) {
+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+
+ char *resp =
+ cbm_mcp_server_handle(srv, "{\"jsonrpc\":\"2.0\",\"id\":20,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_call_path\","
+ "\"arguments\":{\"function_name\":\"NonExistent\","
+ "\"project\":\"nonexistent\"}}}");
+ ASSERT_NOT_NULL(resp);
+ /* Should return error about project not found */
+ ASSERT_NOT_NULL(strstr(resp, "not found"));
+ free(resp);
+
+ cbm_mcp_server_free(srv);
+ PASS();
+}
+
+/* Regression for #1425: a project name that fails validation must produce a
+ * clean "not found" error and NOTHING else. project_db_path() yields "" for
+ * such names; SQLite opens "" as an anonymous temp db, its integrity check
+ * fails, and quarantine rendered "".corrupt.<hex> - a RELATIVE path dropped
+ * into the daemon's cwd on every such query. */
+TEST(tool_call_invalid_project_name_leaves_no_corrupt_litter_issue1425) {
+ char tmpdir[256];
+ snprintf(tmpdir, sizeof(tmpdir), "/tmp/mcp-litter-XXXXXX");
+ if (!cbm_mkdtemp(tmpdir))
+ FAIL("cbm_mkdtemp failed");
+ char oldcwd[CBM_SZ_1K];
+ if (!cbm_getcwd(oldcwd, sizeof(oldcwd)))
+ FAIL("getcwd failed");
+ if (cbm_chdir(tmpdir) != 0)
+ FAIL("chdir failed");
+
+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+ char *resp =
+ cbm_mcp_server_handle(srv, "{\"jsonrpc\":\"2.0\",\"id\":30,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"search_graph\","
+ "\"arguments\":{\"name_pattern\":\"x\","
+ "\"project\":\"bad name\"}}}");
+ bool clean_error = resp && strstr(resp, "not found") != NULL;
+ free(resp);
+ cbm_mcp_server_free(srv);
+
+ int litter = 0;
+ cbm_dir_t *dir = cbm_opendir(tmpdir);
+ if (dir) {
+ cbm_dirent_t *entry;
+ while ((entry = cbm_readdir(dir)) != NULL) {
+ if (strstr(entry->name, ".corrupt.")) {
+ litter++;
+ }
+ }
+ cbm_closedir(dir);
+ }
+ if (cbm_chdir(oldcwd) != 0)
+ FAIL("chdir back failed");
+ th_rmtree(tmpdir);
+ if (!clean_error)
+ FAIL("invalid project name must produce a clean not-found error");
+ if (litter != 0)
+ FAIL("invalid project name must not quarantine an anonymous temp db into cwd (#1425)");
+ PASS();
+}
+
+TEST(tool_trace_missing_function_name) {
+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+
+ char *resp =
+ cbm_mcp_server_handle(srv, "{\"jsonrpc\":\"2.0\",\"id\":21,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_call_path\","
+ "\"arguments\":{}}}");
+ ASSERT_NOT_NULL(resp);
+ ASSERT_NOT_NULL(strstr(resp, "required"));
+ free(resp);
+
+ cbm_mcp_server_free(srv);
+ PASS();
+}
+
+/* Regression: two same-named definitions with equal rank must be reported
+ * ambiguous, not silently traced (trace_path previously took nodes[0]). */
+TEST(tool_trace_call_path_ambiguous) {
+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+ cbm_store_t *st = cbm_mcp_server_store(srv);
+ const char *proj = "amb-proj";
+ cbm_mcp_server_set_project(srv, proj);
+ cbm_store_upsert_project(st, proj, "/tmp/amb");
+ cbm_node_t a = {.project = proj,
+ .label = "Function",
+ .name = "amb",
+ .qualified_name = "amb-proj.a.amb",
+ .file_path = "a.c",
+ .start_line = 10,
+ .end_line = 20};
+ cbm_node_t b = {.project = proj,
+ .label = "Function",
+ .name = "amb",
+ .qualified_name = "amb-proj.b.amb",
+ .file_path = "b.c",
+ .start_line = 10,
+ .end_line = 20}; /* equal span -> genuine tie */
+ ASSERT_GT(cbm_store_upsert_node(st, &a), 0);
+ ASSERT_GT(cbm_store_upsert_node(st, &b), 0);
+
+ char *resp = cbm_mcp_server_handle(
+ srv, "{\"jsonrpc\":\"2.0\",\"id\":61,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_call_path\","
+ "\"arguments\":{\"function_name\":\"amb\",\"project\":\"amb-proj\"}}}");
+ ASSERT_NOT_NULL(resp);
+ char *inner = extract_text_content(resp);
+ ASSERT_NOT_NULL(inner);
+ ASSERT_NOT_NULL(strstr(inner, "ambiguous"));
+ ASSERT_NOT_NULL(strstr(inner, "suggestions"));
+ ASSERT_NULL(strstr(inner, "\"callees\""));
+ free(inner);
+ free(resp);
+ cbm_mcp_server_free(srv);
+ PASS();
+}
+
+/* Multi-seed union hop semantics: bfs_union_same_name deduped visited nodes
+ * keep-FIRST-seen, so a node reached at hop 2 from the first seed kept hop 2
+ * even when the second seed reaches it at hop 1. hop feeds risk_labels and
+ * (soon) pagination watermarks — it must be the MINIMUM across seeds, matching
+ * the single-BFS MIN(hop) semantics (#797). */
+TEST(tool_trace_union_records_min_hop_across_seeds) {
+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+ cbm_store_t *st = cbm_mcp_server_store(srv);
+ const char *proj = "dualproj";
+ cbm_mcp_server_set_project(srv, proj);
+ cbm_store_upsert_project(st, proj, "/tmp/dual");
+
+ /* One real definition + one body-less stub (start==end) — the #546/#650
+ * shape pick_resolved_node resolves WITHOUT ambiguity while
+ * bfs_union_same_name still traverses both. Seed A (real def, lower id,
+ * traversed first) reaches tgt only via mid (hop 2); the stub seed B
+ * reaches tgt directly (hop 1). */
+ cbm_node_t sa = {.project = proj,
+ .label = "Function",
+ .name = "dual",
+ .qualified_name = "dualproj.a.dual",
+ .file_path = "a.c",
+ .start_line = 1,
+ .end_line = 50};
+ cbm_node_t sb = {.project = proj,
+ .label = "Function",
+ .name = "dual",
+ .qualified_name = "dualproj.b.dual",
+ .file_path = "b.d.ts",
+ .start_line = 1,
+ .end_line = 1};
+ cbm_node_t mid = {.project = proj,
+ .label = "Function",
+ .name = "mid",
+ .qualified_name = "dualproj.c.mid",
+ .file_path = "c.c",
+ .start_line = 1,
+ .end_line = 5};
+ cbm_node_t tgt = {.project = proj,
+ .label = "Function",
+ .name = "tgt",
+ .qualified_name = "dualproj.c.tgt",
+ .file_path = "c.c",
+ .start_line = 10,
+ .end_line = 15};
+ int64_t ida = cbm_store_upsert_node(st, &sa);
+ int64_t idb = cbm_store_upsert_node(st, &sb);
+ int64_t idm = cbm_store_upsert_node(st, &mid);
+ int64_t idt = cbm_store_upsert_node(st, &tgt);
+ ASSERT_GT(ida, 0);
+ ASSERT_GT(idb, 0);
+ ASSERT_GT(idm, 0);
+ ASSERT_GT(idt, 0);
+ cbm_edge_t e1 = {.project = proj, .source_id = ida, .target_id = idm, .type = "CALLS"};
+ cbm_edge_t e2 = {.project = proj, .source_id = idm, .target_id = idt, .type = "CALLS"};
+ cbm_edge_t e3 = {.project = proj, .source_id = idb, .target_id = idt, .type = "CALLS"};
+ ASSERT_GT(cbm_store_insert_edge(st, &e1), 0);
+ ASSERT_GT(cbm_store_insert_edge(st, &e2), 0);
+ ASSERT_GT(cbm_store_insert_edge(st, &e3), 0);
+
+ char *resp = cbm_mcp_server_handle(
+ srv, "{\"jsonrpc\":\"2.0\",\"id\":62,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_call_path\","
+ "\"arguments\":{\"function_name\":\"dual\",\"project\":\"dualproj\","
+ "\"direction\":\"outbound\",\"depth\":3}}}");
+ ASSERT_NOT_NULL(resp);
+ char *inner = extract_text_content(resp);
+ ASSERT_NOT_NULL(inner);
+ /* tgt is one hop from seed B — the union must record hop 1, not seed A's 2. */
+ ASSERT_NOT_NULL(strstr(inner, "dualproj.c.tgt 1"));
+ ASSERT_NULL(strstr(inner, "dualproj.c.tgt 2"));
+ free(inner);
+ free(resp);
+ cbm_mcp_server_free(srv);
+ PASS();
+}
+
+/* Exactly-once trace pagination: 12 callees paged at limit=5 must yield
+ * 5+5+2 rows with every callee appearing on exactly one page, exact totals
+ * on every page, and a final page without a cursor. Stale and mismatched
+ * cursors must fail with teaching errors, never silently restart. */
+TEST(tool_trace_pagination_exactly_once) {
+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+ cbm_store_t *st = cbm_mcp_server_store(srv);
+ const char *proj = "pageproj";
+ cbm_mcp_server_set_project(srv, proj);
+ cbm_store_upsert_project(st, proj, "/tmp/page");
+
+ cbm_node_t hub = {.project = proj,
+ .label = "Function",
+ .name = "hub",
+ .qualified_name = "pageproj.h.hub",
+ .file_path = "h.c",
+ .start_line = 1,
+ .end_line = 9};
+ int64_t hid = cbm_store_upsert_node(st, &hub);
+ ASSERT_GT(hid, 0);
+ enum { CALLEES = 12 };
+ for (int i = 0; i < CALLEES; i++) {
+ char nm[16];
+ char qn[48];
+ snprintf(nm, sizeof(nm), "c%02d", i);
+ snprintf(qn, sizeof(qn), "pageproj.m.c%02d", i);
+ cbm_node_t n = {.project = proj,
+ .label = "Function",
+ .name = nm,
+ .qualified_name = qn,
+ .file_path = "m.c",
+ .start_line = 1,
+ .end_line = 3};
+ int64_t nid = cbm_store_upsert_node(st, &n);
+ ASSERT_GT(nid, 0);
+ cbm_edge_t e = {.project = proj, .source_id = hid, .target_id = nid, .type = "CALLS"};
+ ASSERT_GT(cbm_store_insert_edge(st, &e), 0);
+ }
+
+ char pages[3][4096];
+ char tok[192] = "";
+ int npages = 0;
+ for (; npages < 3; npages++) {
+ char req[640];
+ if (tok[0]) {
+ snprintf(req, sizeof(req),
+ "{\"jsonrpc\":\"2.0\",\"id\":80,\"method\":\"tools/call\",\"params\":{"
+ "\"name\":\"trace_call_path\",\"arguments\":{\"project\":\"pageproj\","
+ "\"function_name\":\"hub\",\"direction\":\"outbound\",\"limit\":5,"
+ "\"cursor\":\"%s\"}}}",
+ tok);
+ } else {
+ snprintf(req, sizeof(req),
+ "{\"jsonrpc\":\"2.0\",\"id\":80,\"method\":\"tools/call\",\"params\":{"
+ "\"name\":\"trace_call_path\",\"arguments\":{\"project\":\"pageproj\","
+ "\"function_name\":\"hub\",\"direction\":\"outbound\",\"limit\":5}}}");
+ }
+ char *resp = cbm_mcp_server_handle(srv, req);
+ ASSERT_NOT_NULL(resp);
+ char *inner = extract_text_content(resp);
+ free(resp);
+ ASSERT_NOT_NULL(inner);
+ snprintf(pages[npages], sizeof(pages[npages]), "%s", inner);
+ ASSERT_NOT_NULL(strstr(inner, "callees_total: 12")); /* exact total, every page */
+ const char *nx = strstr(inner, "next: ");
+ if (nx) {
+ const char *e = strchr(nx + 6, '\n');
+ size_t tl = e ? (size_t)(e - (nx + 6)) : strlen(nx + 6);
+ ASSERT_TRUE(tl < sizeof(tok));
+ memcpy(tok, nx + 6, tl);
+ tok[tl] = '\0';
+ } else {
+ tok[0] = '\0';
+ }
+ free(inner);
+ if (!tok[0]) {
+ npages++;
+ break;
+ }
+ }
+ ASSERT_EQ(npages, 3); /* 5 + 5 + 2 */
+ /* Exactly-once: every callee appears on exactly ONE page. */
+ for (int i = 0; i < CALLEES; i++) {
+ char qn[48];
+ snprintf(qn, sizeof(qn), "pageproj.m.c%02d 1\n", i);
+ int seen = 0;
+ for (int p = 0; p < 3; p++) {
+ if (strstr(pages[p], qn)) {
+ seen++;
+ }
+ }
+ ASSERT_EQ(seen, 1);
+ }
+ /* Final page carries no cursor. */
+ ASSERT_NULL(strstr(pages[2], "next: "));
+
+ /* Params mismatch: replay a page-2-era cursor with a different depth. */
+ const char *nx1 = strstr(pages[0], "next: ");
+ ASSERT_NOT_NULL(nx1);
+ char tok1[192];
+ const char *e1 = strchr(nx1 + 6, '\n');
+ size_t tl1 = e1 ? (size_t)(e1 - (nx1 + 6)) : strlen(nx1 + 6);
memcpy(tok1, nx1 + 6, tl1);
tok1[tl1] = '\0';
char req2[640];