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
feat(cross-repo): report run status and skipped legacy stores (#2133)
Martin Vogele4f9735dea30
diff --git a/README.md b/README.mdindex 7564427ea..2500d6c51 100644--- a/README.md+++ b/README.md@@ -213,6 +213,8 @@ The install script placed beside the binary is **reported, not deleted** — uni- **`CROSS_*` edges** link nodes across multiple repos indexed under the same store- **Multi-galaxy 3D UI layout** for cross-repo architecture visualization- **Cross-repo architecture summary** combining services, routes, and dependencies across the indexed fleet+- **Run status**: `index_status` (and the UI layout next to `linked_projects`) carries a `cross_repo` object, `{"status":"never_run"}` until `index_repository(mode="cross-repo-intelligence")` has run with that project as the source, then `"ran"` with `last_run_at`, `outcome`, `targets`, `projects_scanned`, `total_cross_edges` and `skipped_projects`. That is how you tell "never linked" apart from "linked, nothing matched". The status is stored in the project's own index next to its `CROSS_*` edges, so a reindex that rebuilds the index drops both at once and the status goes back to `never_run`.+- **Skipped stores**: `target_projects: ["*"]` skips an index built before the #768 schema change rather than failing the whole run. The response lists each one as `skipped_projects: [{"name", "reason": "pre_768_schema", "hint": "reindex this project"}]`.### Edge types (selected)- `CALLS` — a callable is invoked at the source sitediff --git a/src/mcp/mcp.c b/src/mcp/mcp.cindex 2ed29799b..e67595882 100644--- a/src/mcp/mcp.c+++ b/src/mcp/mcp.c@@ -6906,6 +6906,7 @@ static char *handle_index_status(cbm_mcp_server_t *srv, const char *args) {}add_coverage_report(doc, root, store, project, have_proj_info ? proj_info.indexed_at : NULL,coverage_samples);+ (void)cbm_cross_repo_add_status_json(doc, root, store, project);safe_str_free(&proj_info.name);safe_str_free(&proj_info.indexed_at);safe_str_free(&proj_info.root_path);@@ -10054,6 +10055,7 @@ static char *handle_cross_repo_mode(cbm_mcp_server_t *srv, const char *repo_pathyyjson_doc_free(jdoc);if (result.no_targets || result.failed) {+ cbm_cross_repo_result_free(&result);free(project);return cbm_mcp_text_result(result.no_targets@@ -10091,9 +10093,23 @@ static char *handle_cross_repo_mode(cbm_mcp_server_t *srv, const char *repo_pathyyjson_mut_obj_add_int(doc, root, "cross_trpc_calls", result.trpc_edges);yyjson_mut_obj_add_int(doc, root, "total_cross_edges", total);yyjson_mut_obj_add_real(doc, root, "elapsed_ms", result.elapsed_ms);+ /* ["*"] skips stores it cannot link (#2133); name them so a partial fleet+ * is visible instead of silently smaller. Only emitted when non-empty. */+ if (result.skipped_count > 0) {+ yyjson_mut_val *skipped = yyjson_mut_arr(doc);+ for (int i = 0; i < result.skipped_count; i++) {+ yyjson_mut_val *item = yyjson_mut_obj(doc);+ yyjson_mut_obj_add_strcpy(doc, item, "name", result.skipped_projects[i].project);+ yyjson_mut_obj_add_str(doc, item, "reason", result.skipped_projects[i].reason);+ yyjson_mut_obj_add_str(doc, item, "hint", "reindex this project");+ yyjson_mut_arr_append(skipped, item);+ }+ yyjson_mut_obj_add_val(doc, root, "skipped_projects", skipped);+ }char *json = yy_doc_to_str(doc);yyjson_mut_doc_free(doc);+ cbm_cross_repo_result_free(&result);free(project);char *out = cbm_mcp_text_result(json, result.cancelled);free(json);diff --git a/src/pipeline/pass_cross_repo.c b/src/pipeline/pass_cross_repo.cindex b86d8cee4..f645db349 100644--- a/src/pipeline/pass_cross_repo.c+++ b/src/pipeline/pass_cross_repo.c@@ -13,12 +13,14 @@#include "pipeline/pipeline_internal.h" // cbm_route_canon_path#include "foundation/constants.h"#include "foundation/log.h"+#include "foundation/mem_core.h"#include "foundation/platform.h"#include "foundation/compat.h"#include "foundation/compat_fs.h"#include "foundation/str_util.h"#include <sqlite3/sqlite3.h>+#include <yyjson/yyjson.h>#include <stdint.h>#include <stdio.h>#include <stdlib.h>@@ -153,27 +155,38 @@ static bool cr_store_has_exact_project(cbm_store_t *store, const char *project)return matches;}-/* True when `project` is a usable cross-repo input: its store holds exactly- * that project AND carries the schema the read-write open in+typedef enum {+ CR_PROJECT_USABLE = 0,+ CR_PROJECT_MISSING, /* no store, or the store is not exactly this project */+ CR_PROJECT_LEGACY, /* exact project, but a pre-#768 schema (reindex required) */+} cr_project_state_t;++/* Classify `project` as a cross-repo input: usable when its store holds+ * exactly that project AND carries the schema the read-write open in* cr_open_existing_project requires. Checking only the first let a pre-#768* store (still readable, so list_projects shows it) pass validation and the* ["*"] enumeration, then abort the whole run at its write open — after the* source's previous CROSS_* generation had already been deleted. The probe is* read-only, so the legacy store is left untouched for its reindex. (#2133) */-static bool cr_project_exists(const char *project) {+static cr_project_state_t cr_project_state(const char *project) {char path[CR_PATH_BUF];if (!cr_db_path(project, path, sizeof(path))) {- return false;+ return CR_PROJECT_MISSING;}cbm_store_t *store = cbm_store_open_path_query(path);- bool exists = cr_store_has_exact_project(store, project);- if (exists && !cbm_store_edges_schema_current(store)) {+ cr_project_state_t state =+ cr_store_has_exact_project(store, project) ? CR_PROJECT_USABLE : CR_PROJECT_MISSING;+ if (state == CR_PROJECT_USABLE && !cbm_store_edges_schema_current(store)) {cbm_log_warn("cross_repo.project_unusable", "project", project, "reason","pre_768_schema_reindex_required");- exists = false;+ state = CR_PROJECT_LEGACY;}cbm_store_close(store);- return exists;+ return state;+}++static bool cr_project_exists(const char *project) {+ return cr_project_state(project) == CR_PROJECT_USABLE;}static cbm_store_t *cr_open_existing_project(const char *project) {@@ -1139,8 +1152,33 @@ static cr_match_result_t match_typed_routes(cbm_store_t *src_store, const char *static void free_project_list(char **projects, int count);+/* Remember a store the ["*"] enumeration skipped, so the caller can name it+ * instead of the run silently covering fewer projects than exist. */+static bool cr_record_skip(cbm_cross_repo_result_t *result, const char *project,+ const char *reason) {+ if (!result) {+ return true;+ }+ cbm_cross_repo_skip_t *grown =+ cbm_realloc(CBM_MEM_CLASS_OTHER, result->skipped_projects,+ ((size_t)result->skipped_count + 1U) * sizeof(*result->skipped_projects));+ if (!grown) {+ return false;+ }+ result->skipped_projects = grown;+ char *name = cbm_mem_strdup(CBM_MEM_CLASS_OTHER, project);+ if (!name) {+ return false;+ }+ grown[result->skipped_count].project = name;+ grown[result->skipped_count].reason = reason;+ result->skipped_count++;+ return true;+}+/* When target_projects = ["*"], scan the cache directory for all .db files. */-static int collect_all_projects(char ***out, cr_run_context_t *ctx) {+static int collect_all_projects(char ***out, cr_run_context_t *ctx,+ cbm_cross_repo_result_t *result) {*out = NULL;const char *dir = cr_cache_dir();cbm_dir_t *d = cbm_opendir(dir);@@ -1188,7 +1226,15 @@ static int collect_all_projects(char ***out, cr_run_context_t *ctx) {}memcpy(project, ent->name, project_length);project[project_length] = '\0';- if (!cbm_validate_project_name(project) || !cr_project_exists(project)) {+ if (!cbm_validate_project_name(project)) {+ continue;+ }+ cr_project_state_t state = cr_project_state(project);+ if (state == CR_PROJECT_LEGACY && !cr_record_skip(result, project, "pre_768_schema")) {+ failed = true;+ break;+ }+ if (state != CR_PROJECT_USABLE) {continue;}if (count >= cap) {@@ -1273,6 +1319,106 @@ static int collect_named_projects(const char **targets, int target_count, char *return unique_count;}+/* ── Last-run marker ─────────────────────────────────────────────── */++static bool cr_status_key(const char *project, char *buf, size_t bufsz) {+ int written = snprintf(buf, bufsz, "cross_repo_last_run:%s", project);+ return written > 0 && (size_t)written < bufsz;+}++/* Record this run in the SOURCE store's store_meta, next to the CROSS_*+ * edges it just rewrote: a reindex that rebuilds the store drops both+ * together, so the marker can never outlive the links it describes. Written+ * once the source's previous CROSS_* generation was cleaned, whatever the+ * outcome, because from then on the old summary no longer matches the graph.+ * Project names are validated ([A-Za-z0-9._-]) or "*", so no JSON escaping is+ * needed. Best-effort: a marker failure is logged, never fails the run. */+static void cr_record_last_run(cbm_store_t *src_store, const char *project, const char **targets,+ int target_count, const cbm_cross_repo_result_t *result) {+ char key[CR_QN_BUF];+ if (!cr_status_key(project, key, sizeof(key))) {+ return;+ }+ size_t cap = CR_PROPS_BUF;+ for (int i = 0; i < target_count; i++) {+ cap += (targets[i] ? strlen(targets[i]) : 0) + CR_COL_4;+ }+ char *json = cbm_alloc(CBM_MEM_CLASS_OTHER, cap);+ if (!json) {+ return;+ }+ char when[CBM_SZ_32];+ time_t now = time(NULL);+ struct tm tm_now;+ if (!cbm_gmtime_r(&now, &tm_now) ||+ strftime(when, sizeof(when), "%Y-%m-%dT%H:%M:%SZ", &tm_now) == 0) {+ when[0] = '\0';+ }+ const char *outcome = result->failed ? "failed" : result->cancelled ? "cancelled" : "complete";+ size_t len = (size_t)snprintf(+ json, cap, "{\"last_run_at\":\"%s\",\"outcome\":\"%s\",\"targets\":[", when, outcome);+ for (int i = 0; i < target_count && len < cap; i++) {+ len += (size_t)snprintf(json + len, cap - len, "%s\"%s\"", i ? "," : "",+ targets[i] ? targets[i] : "");+ }+ int total = result->http_edges + result->async_edges + result->channel_edges ++ result->grpc_edges + result->graphql_edges + result->trpc_edges;+ if (len < cap) {+ len += (size_t)snprintf(json + len, cap - len,+ "],\"projects_scanned\":%d,\"total_cross_edges\":%d,"+ "\"skipped_projects\":%d}",+ result->projects_scanned, total, result->skipped_count);+ }+ if (len >= cap || cbm_store_meta_put(src_store, key, json) != CBM_STORE_OK) {+ cbm_log_warn("cross_repo.status_unrecorded", "project", project);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, json);+}++bool cbm_cross_repo_add_status_json(struct yyjson_mut_doc *doc, struct yyjson_mut_val *parent,+ cbm_store_t *store, const char *project) {+ char key[CR_QN_BUF];+ if (!doc || !parent || !store || !project || !cr_status_key(project, key, sizeof(key))) {+ return false;+ }+ char *raw = NULL;+ int rc = cbm_store_meta_get(store, key, &raw);+ yyjson_doc *recorded = rc == CBM_STORE_OK ? yyjson_read(raw, strlen(raw), 0) : NULL;+ cbm_free(CBM_MEM_CLASS_STORE, raw);+ yyjson_val *recorded_root = recorded ? yyjson_doc_get_root(recorded) : NULL;+ yyjson_mut_val *status = NULL;+ if (yyjson_is_obj(recorded_root)) {+ status = yyjson_val_mut_copy(doc, recorded_root);+ }+ if (!status) {+ status = yyjson_mut_obj(doc);+ }+ yyjson_doc_free(recorded);+ if (!status) {+ return false;+ }+ /* "never_run" is the honest reading of an absent marker: no run with this+ * project as the source has completed its cleanup since the store was+ * (re)built. A target-side run still leaves its CROSS_* edges here. */+ const char *state = rc == CBM_STORE_NOT_FOUND ? "never_run"+ : yyjson_mut_obj_size(status) > 0 ? "ran"+ : "unavailable";+ yyjson_mut_obj_add_str(doc, status, "status", state);+ return yyjson_mut_obj_add_val(doc, parent, "cross_repo", status);+}++void cbm_cross_repo_result_free(cbm_cross_repo_result_t *result) {+ if (!result) {+ return;+ }+ for (int i = 0; i < result->skipped_count; i++) {+ cbm_free(CBM_MEM_CLASS_OTHER, result->skipped_projects[i].project);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, result->skipped_projects);+ result->skipped_projects = NULL;+ result->skipped_count = 0;+}+static cr_run_status_t add_match_count(int *total, cr_match_result_t matched) {*total += matched.count;return matched.status;@@ -1304,7 +1450,7 @@ cbm_cross_repo_result_t cbm_cross_repo_match_cancellable(const char *project,int resolved_count = 0;if (target_count == SKIP_ONE && target_projects[0] && strcmp(target_projects[0], "*") == 0) {- resolved_count = collect_all_projects(&resolved, &run);+ resolved_count = collect_all_projects(&resolved, &run, &result);} else {resolved_count = collect_named_projects(target_projects, target_count, &resolved, &run);}@@ -1442,6 +1588,7 @@ cbm_cross_repo_result_t cbm_cross_repo_match_cancellable(const char *project,result.projects_scanned++;}+ cr_record_last_run(src_store, project, target_projects, target_count, &result);cbm_store_close(src_store);free_project_list(resolved, resolved_count);diff --git a/src/pipeline/pass_cross_repo.h b/src/pipeline/pass_cross_repo.hindex 898283c3e..85c832b2d 100644--- a/src/pipeline/pass_cross_repo.h+++ b/src/pipeline/pass_cross_repo.h@@ -9,6 +9,12 @@#include <stdatomic.h>+/* A store the ["*"] enumeration skipped instead of linking. */+typedef struct {+ char *project; /* heap-owned */+ const char *reason; /* static, e.g. "pre_768_schema" (reindex required) */+} cbm_cross_repo_skip_t;+/* Result of a cross-repo matching run. */typedef struct {int http_edges; /* CROSS_HTTP_CALLS edges created */@@ -23,8 +29,26 @@ typedef struct {bool no_targets; /* failed: nothing but the source project resolved (#1133) */bool cancelled; /* stopped at a bounded cancellation checkpoint */bool partial_results; /* committed writes before cancellation were retained */+ cbm_cross_repo_skip_t *skipped_projects; /* ["*"] only; free with ..._result_free */+ int skipped_count;} cbm_cross_repo_result_t;+/* Release the heap-owned parts of a result (safe on a zeroed result). */+void cbm_cross_repo_result_free(cbm_cross_repo_result_t *result);++struct yyjson_mut_doc;+struct yyjson_mut_val;++/* Add a "cross_repo" object to `parent` describing the last cross-repo run+ * with `project` as the source, as recorded in that project's store:+ * {"status":"never_run"} -- no run recorded since the store was (re)built+ * {"status":"ran","last_run_at","outcome","targets","projects_scanned",+ * "total_cross_edges","skipped_projects"}+ * Read-only (works on a query store). Returns false only on invalid input or+ * allocation failure. */+bool cbm_cross_repo_add_status_json(struct yyjson_mut_doc *doc, struct yyjson_mut_val *parent,+ cbm_store_t *store, const char *project);+/* Run cross-repo matching for `project` against `target_projects`.* If target_count == 1 and target_projects[0] == "*", matches against all* indexed projects. Writes CROSS_* edges bidirectionally into both thediff --git a/src/store/store.c b/src/store/store.cindex d66ef0ffb..430efd8a3 100644--- a/src/store/store.c+++ b/src/store/store.c@@ -2456,6 +2456,77 @@ int cbm_store_generation(cbm_store_t *s, char *buf, size_t bufsz) {return CBM_STORE_OK;}+int cbm_store_meta_get(cbm_store_t *s, const char *key, char **out) {+ if (!out) {+ return CBM_STORE_ERR;+ }+ *out = NULL;+ if (!s || !s->db || !key) {+ return CBM_STORE_ERR;+ }+ sqlite3_stmt *get = NULL;+ /* A store that never advanced its generation has no store_meta table:+ * that is "no value recorded", not an error. */+ if (sqlite3_prepare_v2(s->db, "SELECT v FROM store_meta WHERE k = ?1;", CBM_NOT_FOUND, &get,+ NULL) != SQLITE_OK) {+ sqlite3_finalize(get);+ return CBM_STORE_NOT_FOUND;+ }+ bind_text(get, SKIP_ONE, key);+ int rc = sqlite3_step(get);+ if (rc == SQLITE_ROW) {+ const char *value = (const char *)sqlite3_column_text(get, 0);+ *out = cbm_mem_strdup(CBM_MEM_CLASS_STORE, value ? value : "");+ sqlite3_finalize(get);+ return *out ? CBM_STORE_OK : CBM_STORE_ERR;+ }+ sqlite3_finalize(get);+ return rc == SQLITE_DONE ? CBM_STORE_NOT_FOUND : CBM_STORE_ERR;+}++int cbm_store_meta_put(cbm_store_t *s, const char *key, const char *value) {+ static const char savepoint[] = "SAVEPOINT cbm_meta_put;";+ static const char rollback[] = "ROLLBACK TO cbm_meta_put;";+ static const char release[] = "RELEASE cbm_meta_put;";+ if (!s || !s->db || !key || !value) {+ return CBM_STORE_ERR;+ }+ if (exec_sql(s, savepoint) != CBM_STORE_OK) {+ return CBM_STORE_ERR;+ }+ /* store_meta is only ever created by the generation seed, which writes+ * db_uid + mutation_gen with it. Creating the table here without them+ * would make cbm_store_generation() report malformed metadata, so an+ * absent table is seeded through that one path. */+ bool absent = false;+ char uid[17] = {0};+ char counter[21] = {0};+ uint64_t counter_value = 0;+ if (generation_metadata_read(s, &absent, uid, counter, &counter_value) != CBM_STORE_OK ||+ (absent && cbm_store_generation_advance(s) != CBM_STORE_OK)) {+ return rollback_savepoint_preserving_error(s, rollback, release);+ }+ sqlite3_stmt *set = NULL;+ if (sqlite3_prepare_v2(s->db, "INSERT OR REPLACE INTO store_meta (k, v) VALUES (?1, ?2);",+ CBM_NOT_FOUND, &set, NULL) != SQLITE_OK) {+ store_set_error_sqlite(s, "store_meta put prepare");+ sqlite3_finalize(set);+ return rollback_savepoint_preserving_error(s, rollback, release);+ }+ bind_text(set, SKIP_ONE, key);+ bind_text(set, ST_COL_2, value);+ int rc = sqlite3_step(set);+ sqlite3_finalize(set);+ if (rc != SQLITE_DONE) {+ store_set_error_sqlite(s, "store_meta put");+ return rollback_savepoint_preserving_error(s, rollback, release);+ }+ if (exec_sql(s, release) != CBM_STORE_OK) {+ return rollback_savepoint_preserving_error(s, rollback, release);+ }+ return CBM_STORE_OK;+}+int cbm_store_get_project(cbm_store_t *s, const char *name, cbm_project_t *out) {sqlite3_stmt *stmt =prepare_cached(s, &s->stmt_get_project,diff --git a/src/store/store.h b/src/store/store.hindex 06ea1fbb7..ca4f1eb58 100644--- a/src/store/store.h+++ b/src/store/store.h@@ -462,6 +462,17 @@ int cbm_store_generation_advance(cbm_store_t *s);* an error. */int cbm_store_generation(cbm_store_t *s, char *buf, size_t bufsz);+/* Per-store feature metadata in store_meta (key/value text). Keys are+ * namespaced by the owning feature, e.g. "cross_repo_last_run:<project>".+ * get: CBM_STORE_OK with *out owned by the caller (release with+ * cbm_free(CBM_MEM_CLASS_STORE, *out)), or+ * CBM_STORE_NOT_FOUND when the key -- or store_meta itself -- is absent.+ * Read-only: safe on a store opened for query.+ * put: upserts the key; seeds store_meta through the generation path when a+ * legacy store lacks it. Atomic (savepoint); needs a read-write store. */+int cbm_store_meta_get(cbm_store_t *s, const char *key, char **out);+int cbm_store_meta_put(cbm_store_t *s, const char *key, const char *value);+/* Seal a fully-written staging database before atomic publication.* Raises synchronous to FULL, requires an exclusive TRUNCATE checkpoint to* complete, then leaves the database in verified DELETE journal mode so thediff --git a/src/ui/http_server.c b/src/ui/http_server.cindex 66f1affb8..ae0dd2754 100644--- a/src/ui/http_server.c+++ b/src/ui/http_server.c@@ -19,6 +19,7 @@#include "ui/layout3d.h"#include "mcp/mcp.h"#include "store/store.h"+#include "pipeline/pass_cross_repo.h"#include "watcher/watcher.h"#include "cli/cli.h"#include "git/git_context.h"@@ -1729,6 +1730,9 @@ static void handle_layout(cbm_http_conn_t *c, const cbm_http_req_t *req) {free(linked[li]);}+ /* Next to linked_projects: an empty list alone cannot tell "never linked"+ * from "linked, nothing matched". */+ (void)cbm_cross_repo_add_status_json(mdoc, mroot, store, project);cbm_store_close(store);yyjson_mut_obj_add_val(mdoc, mroot, "linked_projects", lp_arr);diff --git a/tests/test_cross_repo.c b/tests/test_cross_repo.cindex cb4ab0607..54c75cbd5 100644--- a/tests/test_cross_repo.c+++ b/tests/test_cross_repo.c@@ -10,6 +10,7 @@#include "pipeline/pipeline_internal.h"#include <sqlite3/sqlite3.h>+#include <yyjson/yyjson.h>#include <stdatomic.h>#include <stdio.h>#include <stdlib.h>@@ -401,6 +402,96 @@ TEST(cross_repo_named_pre768_target_fails_before_cleanup_issue2133) {PASS();}+/* Render the "cross_repo" status object the MCP/UI surfaces attach for+ * `project`, read from its store the way index_status does (query open). */+static char *cross_repo_status_json(const cross_repo_fixture_t *fixture, const char *project) {+ char path[512];+ if (!cross_repo_project_path(fixture, project, path, sizeof(path))) {+ return NULL;+ }+ cbm_store_t *store = cbm_store_open_path_query(path);+ if (!store) {+ return NULL;+ }+ yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);+ yyjson_mut_val *root = yyjson_mut_obj(doc);+ yyjson_mut_doc_set_root(doc, root);+ char *json = NULL;+ if (cbm_cross_repo_add_status_json(doc, root, store, project)) {+ json = yyjson_mut_write(doc, 0, NULL);+ }+ yyjson_mut_doc_free(doc);+ cbm_store_close(store);+ return json;+}++/* #2133 follow-up: an empty CROSS_* set could mean "never linked" or "linked,+ * nothing matched" and no surface told them apart. The source store records+ * each run; before any run the status says so explicitly. */+TEST(cross_repo_status_distinguishes_never_run_from_ran_without_links) {+ cross_repo_fixture_t fixture;+ bool setup = cross_repo_fixture_begin(&fixture) &&+ cross_repo_create_project(&fixture, "status-src") &&+ cross_repo_create_project(&fixture, "status-api");+ if (!setup) {+ cross_repo_fixture_end(&fixture);+ FAIL("failed to seed status fixture");+ }++ char *before = cross_repo_status_json(&fixture, "status-src");+ const char *targets[] = {"status-api"};+ cbm_cross_repo_result_t result = cbm_cross_repo_match("status-src", targets, 1);+ char *after = cross_repo_status_json(&fixture, "status-src");+ cross_repo_fixture_end(&fixture);++ bool before_never = before && strstr(before, "\"cross_repo\":{\"status\":\"never_run\"}");+ bool after_ran =+ after && strstr(after, "\"status\":\"ran\"") && strstr(after, "\"outcome\":\"complete\"") &&+ strstr(after, "\"targets\":[\"status-api\"]") && strstr(after, "\"projects_scanned\":1") &&+ strstr(after, "\"total_cross_edges\":0") && strstr(after, "\"last_run_at\":\"20");+ free(before);+ free(after);+ cbm_cross_repo_result_free(&result);++ ASSERT_FALSE(result.failed);+ ASSERT_TRUE(before_never);+ ASSERT_TRUE(after_ran);+ PASS();+}++/* #2133 follow-up: ["*"] skips a pre-#768 store (it cannot be linked until a+ * reindex); the result must name it rather than silently covering fewer+ * projects, and the recorded status counts it. */+TEST(cross_repo_wildcard_reports_skipped_pre768_store) {+ cross_repo_fixture_t fixture;+ bool setup = cross_repo_fixture_begin(&fixture) &&+ cross_repo_seed_http_pair(&fixture, "skip-src", "skip-api", "/orders", "s") &&+ cross_repo_create_pre768_project(&fixture, "aa-pre768-store");+ if (!setup) {+ cross_repo_fixture_end(&fixture);+ FAIL("failed to seed skipped-store fixture");+ }++ const char *targets[] = {"*"};+ cbm_cross_repo_result_t result = cbm_cross_repo_match("skip-src", targets, 1);+ char *status = cross_repo_status_json(&fixture, "skip-src");+ cross_repo_fixture_end(&fixture);++ bool named = result.skipped_count == 1 && result.skipped_projects &&+ strcmp(result.skipped_projects[0].project, "aa-pre768-store") == 0 &&+ strcmp(result.skipped_projects[0].reason, "pre_768_schema") == 0;+ bool status_counts =+ status && strstr(status, "\"skipped_projects\":1") && strstr(status, "\"targets\":[\"*\"]");+ free(status);+ cbm_cross_repo_result_free(&result);++ ASSERT_FALSE(result.failed);+ ASSERT_EQ(result.projects_scanned, 1);+ ASSERT_TRUE(named);+ ASSERT_TRUE(status_counts);+ PASS();+}+static bool cross_repo_seed_bounded_scan(const cross_repo_fixture_t *fixture,const char *source_project, const char *target_project) {enum { TEST_SCAN_ROWS = 4097 };@@ -836,6 +927,8 @@ SUITE(cross_repo) {RUN_TEST(cross_repo_wildcard_keeps_projects_containing_internal_tokens);RUN_TEST(cross_repo_wildcard_skips_pre768_store_issue2133);RUN_TEST(cross_repo_named_pre768_target_fails_before_cleanup_issue2133);+ RUN_TEST(cross_repo_status_distinguishes_never_run_from_ran_without_links);+ RUN_TEST(cross_repo_wildcard_reports_skipped_pre768_store);RUN_TEST(cross_repo_scan_bound_counts_examined_rows_not_matches);RUN_TEST(cross_repo_propagates_delete_failure);RUN_TEST(cross_repo_failed_bidirectional_insert_is_not_counted);diff --git a/tests/test_mcp.c b/tests/test_mcp.cindex 7a2219c5a..883812157 100644--- a/tests/test_mcp.c+++ b/tests/test_mcp.c@@ -13033,6 +13033,102 @@ TEST(tool_cross_repo_dedupes_targets_before_scanning_and_counting) {PASS();}+/* A store written before the #768 edges.local_name_gen column: readable, but+ * refused by every read-write open until a reindex. */+static bool mcp_cross_repo_create_pre768_store(const char *cache, const char *project) {+ char db_path[CBM_SZ_1K];+ snprintf(db_path, sizeof(db_path), "%s/%s.db", cache, project);+ sqlite3 *db = NULL;+ if (sqlite3_open(db_path, &db) != SQLITE_OK) {+ sqlite3_close(db);+ return false;+ }+ char sql[CBM_SZ_1K];+ snprintf(sql, sizeof(sql),+ "CREATE TABLE projects(name TEXT PRIMARY KEY, indexed_at TEXT NOT NULL,"+ " root_path TEXT NOT NULL);"+ "CREATE TABLE nodes(id INTEGER PRIMARY KEY AUTOINCREMENT, project TEXT NOT NULL,"+ " label TEXT NOT NULL, name TEXT NOT NULL, qualified_name TEXT NOT NULL,"+ " file_path TEXT DEFAULT '', start_line INTEGER DEFAULT 0,"+ " end_line INTEGER DEFAULT 0, properties TEXT DEFAULT '{}',"+ " UNIQUE(project, qualified_name));"+ "CREATE TABLE edges(id INTEGER PRIMARY KEY AUTOINCREMENT, project TEXT NOT NULL,"+ " source_id INTEGER NOT NULL, target_id INTEGER NOT NULL, type TEXT NOT NULL,"+ " properties TEXT DEFAULT '{}', UNIQUE(source_id, target_id, type));"+ "INSERT INTO projects VALUES('%s', '2026-06-01T00:00:00Z', '/pre768');",+ project);+ bool ok = sqlite3_exec(db, sql, NULL, NULL, NULL) == SQLITE_OK;+ sqlite3_close(db);+ return ok;+}++/* #2133 follow-up, both user-visible halves: index_status tells "never run"+ * from "ran" via a `cross_repo` object, and a ["*"] run names the legacy+ * store it skipped (with the reindex hint) instead of silently linking fewer+ * projects. */+TEST(tool_cross_repo_status_and_wildcard_skipped_projects) {+ char cache[256];+ snprintf(cache, sizeof(cache), "%s/cbm-mcp-cross-status-XXXXXX", cbm_tmpdir());+ ASSERT_NOT_NULL(cbm_mkdtemp(cache));++ const char *saved_cache = getenv("CBM_CACHE_DIR");+ char *saved_cache_copy = saved_cache ? strdup(saved_cache) : NULL;+ cbm_setenv("CBM_CACHE_DIR", cache, 1);++ char *source_project = cbm_project_name_from_path(cache);+ ASSERT_NOT_NULL(source_project);+ const char *target_project = "cross-status-target";+ const char *legacy_project = "cross-status-pre768";+ ASSERT_TRUE(mcp_cross_repo_seed_http_match(cache, source_project, target_project, cache));+ ASSERT_TRUE(mcp_cross_repo_create_pre768_store(cache, legacy_project));++ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ ASSERT_NOT_NULL(srv);+ ASSERT_TRUE(cbm_mcp_server_set_session_context(srv, cache, NULL));++ char status_args[CBM_SZ_1K];+ snprintf(status_args, sizeof(status_args), "{\"project\":\"%s\",\"format\":\"json\"}",+ source_project);+ char *before = cbm_mcp_handle_tool(srv, "index_status", status_args);+ bool before_never =+ response_contains_json_fragment(before, "\"cross_repo\":{\"status\":\"never_run\"}");++ char args[CBM_SZ_2K];+ snprintf(args, sizeof(args),+ "{\"repo_path\":\"%s\",\"mode\":\"cross-repo-intelligence\","+ "\"target_projects\":[\"*\"]}",+ cache);+ char *run = cbm_mcp_handle_tool(srv, "index_repository", args);+ bool run_ok = run && strstr(run, "\"isError\":true") == NULL &&+ response_contains_json_fragment(run, "\"total_cross_edges\":1");+ bool skipped_named = response_contains_json_fragment(+ run, "\"skipped_projects\":[{\"name\":\"cross-status-pre768\","+ "\"reason\":\"pre_768_schema\",\"hint\":\"reindex this project\"}]");++ char *after = cbm_mcp_handle_tool(srv, "index_status", status_args);+ bool after_ran = response_contains_json_fragment(after, "\"status\":\"ran\"") &&+ response_contains_json_fragment(after, "\"total_cross_edges\":1") &&+ response_contains_json_fragment(after, "\"skipped_projects\":1");++ free(before);+ free(run);+ free(after);+ cbm_mcp_server_free(srv);+ cleanup_project_db(cache, source_project);+ cleanup_project_db(cache, target_project);+ cleanup_project_db(cache, legacy_project);+ free(source_project);+ restore_cache_dir(saved_cache_copy);+ free(saved_cache_copy);+ cbm_rmdir(cache);++ ASSERT_TRUE(before_never);+ ASSERT_TRUE(run_ok);+ ASSERT_TRUE(skipped_named);+ ASSERT_TRUE(after_ran);+ PASS();+}+/* `name` is the documented index project-name override and must identify the* cross-repo source too. Deriving from repo_path here makes custom-named* projects impossible to rescan even though ordinary indexing created them. */@@ -21212,6 +21308,7 @@ SUITE(mcp_mutation_guard) {RUN_TEST(tool_cross_repo_checks_cancellation_after_acquiring_leases);RUN_TEST(tool_cross_repo_missing_inputs_fail_without_creating_ghost_databases);RUN_TEST(tool_cross_repo_dedupes_targets_before_scanning_and_counting);+ RUN_TEST(tool_cross_repo_status_and_wildcard_skipped_projects);RUN_TEST(tool_cross_repo_honors_source_name_override);RUN_TEST(tool_corrupt_store_cleanup_guard_is_balanced_and_not_nested);RUN_TEST(tool_corrupt_store_cleanup_guard_denial_preserves_db_and_wal);