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.

50.5 KB
Raw Blame
/*
 * test_cross_repo.c — Input, work-bound, and write-failure guards for the
 * cross-repository matching pass.
 */
#include "test_framework.h"
#include "test_helpers.h"

#include "foundation/compat.h"
#include "pipeline/pass_cross_repo.h"
#include "pipeline/pipeline_internal.h"

#include <sqlite3/sqlite3.h>
#include <yyjson/yyjson.h>
#include <stdatomic.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if !defined(_WIN32)
#include <sys/wait.h>
#endif

typedef struct {
    char cache[256];
    char *saved_cache;
} cross_repo_fixture_t;

static bool cross_repo_fixture_begin(cross_repo_fixture_t *fixture) {
    memset(fixture, 0, sizeof(*fixture));
    const char *saved = getenv("CBM_CACHE_DIR");
    if (saved) {
        fixture->saved_cache = strdup(saved);
        if (!fixture->saved_cache) {
            return false;
        }
    }
    snprintf(fixture->cache, sizeof(fixture->cache), "/tmp/cbm-cross-hardening-XXXXXX");
    return cbm_mkdtemp(fixture->cache) != NULL &&
           cbm_setenv("CBM_CACHE_DIR", fixture->cache, 1) == 0;
}

static void cross_repo_fixture_end(cross_repo_fixture_t *fixture) {
    if (fixture->saved_cache) {
        (void)cbm_setenv("CBM_CACHE_DIR", fixture->saved_cache, 1);
    } else {
        (void)cbm_unsetenv("CBM_CACHE_DIR");
    }
    if (fixture->cache[0]) {
        th_rmtree(fixture->cache);
    }
    free(fixture->saved_cache);
    memset(fixture, 0, sizeof(*fixture));
}

static bool cross_repo_project_path(const cross_repo_fixture_t *fixture, const char *project,
                                    char *out, size_t out_size) {
    int written = snprintf(out, out_size, "%s/%s.db", fixture->cache, project);
    return written > 0 && (size_t)written < out_size;
}

static bool cross_repo_create_project(const cross_repo_fixture_t *fixture, const char *project) {
    char path[512];
    if (!cross_repo_project_path(fixture, project, path, sizeof(path))) {
        return false;
    }
    cbm_store_t *store = cbm_store_open_path(path);
    if (!store) {
        return false;
    }
    bool ok = cbm_store_upsert_project(store, project, fixture->cache) == CBM_STORE_OK;
    cbm_store_close(store);
    return ok;
}

/* Seed one HTTP_CALLS/HANDLES pair into two exact project stores. The suffix
 * keeps node QNs unique when a source is linked to more than one target. */
static bool cross_repo_seed_http_pair(const cross_repo_fixture_t *fixture,
                                      const char *source_project, const char *target_project,
                                      const char *route_path, const char *suffix) {
    char source_path[512];
    char target_path[512];
    if (!cross_repo_project_path(fixture, source_project, source_path, sizeof(source_path)) ||
        !cross_repo_project_path(fixture, target_project, target_path, sizeof(target_path))) {
        return false;
    }
    cbm_store_t *source = cbm_store_open_path(source_path);
    cbm_store_t *target = cbm_store_open_path(target_path);
    if (!source || !target) {
        cbm_store_close(source);
        cbm_store_close(target);
        return false;
    }

    bool ok = cbm_store_upsert_project(source, source_project, fixture->cache) == CBM_STORE_OK &&
              cbm_store_upsert_project(target, target_project, fixture->cache) == CBM_STORE_OK;
    char caller_qn[256];
    char local_route_qn[256];
    char target_route_qn[256];
    char handler_qn[256];
    char route_name[128];
    char edge_props[256];
    snprintf(caller_qn, sizeof(caller_qn), "%s.call.%s", source_project, suffix);
    snprintf(local_route_qn, sizeof(local_route_qn), "%s.local-route.%s", source_project, suffix);
    snprintf(target_route_qn, sizeof(target_route_qn), "__route__GET__%s", route_path);
    snprintf(handler_qn, sizeof(handler_qn), "%s.handle.%s", target_project, suffix);
    snprintf(route_name, sizeof(route_name), "GET %s", route_path);
    snprintf(edge_props, sizeof(edge_props), "{\"url_path\":\"%s\",\"method\":\"GET\"}",
             route_path);

    cbm_node_t caller = {.project = source_project,
                         .label = "Function",
                         .name = "call_remote",
                         .qualified_name = caller_qn,
                         .file_path = "client.c"};
    cbm_node_t local_route = {.project = source_project,
                              .label = "Route",
                              .name = route_name,
                              .qualified_name = local_route_qn,
                              .file_path = "client.c"};
    int64_t caller_id = ok ? cbm_store_upsert_node(source, &caller) : 0;
    int64_t local_route_id = ok ? cbm_store_upsert_node(source, &local_route) : 0;
    cbm_edge_t http_call = {.project = source_project,
                            .source_id = caller_id,
                            .target_id = local_route_id,
                            .type = "HTTP_CALLS",
                            .properties_json = edge_props};
    ok = ok && caller_id > 0 && local_route_id > 0 && cbm_store_insert_edge(source, &http_call) > 0;

    cbm_node_t target_route = {.project = target_project,
                               .label = "Route",
                               .name = route_name,
                               .qualified_name = target_route_qn,
                               .file_path = "server.c"};
    cbm_node_t handler = {.project = target_project,
                          .label = "Function",
                          .name = "handle_remote",
                          .qualified_name = handler_qn,
                          .file_path = "server.c"};
    int64_t target_route_id = ok ? cbm_store_upsert_node(target, &target_route) : 0;
    int64_t handler_id = ok ? cbm_store_upsert_node(target, &handler) : 0;
    cbm_edge_t handles = {.project = target_project,
                          .source_id = handler_id,
                          .target_id = target_route_id,
                          .type = "HANDLES"};
    ok = ok && target_route_id > 0 && handler_id > 0 && cbm_store_insert_edge(target, &handles) > 0;

    cbm_store_close(source);
    cbm_store_close(target);
    return ok;
}

/* Give the source project its own handler for the local Route the seeded
 * HTTP_CALLS edge points at (caller-local HANDLES), as when a monorepo's
 * client code calls the API the same repo serves. (#1459) */
static bool cross_repo_seed_local_handler(const cross_repo_fixture_t *fixture,
                                          const char *source_project, const char *suffix) {
    char source_path[512];
    if (!cross_repo_project_path(fixture, source_project, source_path, sizeof(source_path))) {
        return false;
    }
    cbm_store_t *source = cbm_store_open_path(source_path);
    if (!source) {
        return false;
    }
    char local_route_qn[256];
    char handler_qn[256];
    snprintf(local_route_qn, sizeof(local_route_qn), "%s.local-route.%s", source_project, suffix);
    snprintf(handler_qn, sizeof(handler_qn), "%s.local-handle.%s", source_project, suffix);
    cbm_node_t route = {0};
    bool ok =
        cbm_store_find_node_by_qn(source, source_project, local_route_qn, &route) == CBM_STORE_OK;
    int64_t route_id = ok ? route.id : 0;
    if (ok) {
        cbm_node_free_fields(&route);
    }
    cbm_node_t handler = {.project = source_project,
                          .label = "Function",
                          .name = "handle_local",
                          .qualified_name = handler_qn,
                          .file_path = "server.c"};
    int64_t handler_id = ok ? cbm_store_upsert_node(source, &handler) : 0;
    cbm_edge_t handles = {.project = source_project,
                          .source_id = handler_id,
                          .target_id = route_id,
                          .type = "HANDLES"};
    ok = ok && route_id > 0 && handler_id > 0 && cbm_store_insert_edge(source, &handles) > 0;
    cbm_store_close(source);
    return ok;
}

/* Give the source project a canonical "__route__GET__<path>" Route with its
 * own handler, distinct from the node the seeded HTTP_CALLS points at — the
 * shape extraction produces for a method-less fetch() against a local
 * app.get() route. (#1459) */
static bool cross_repo_seed_local_get_route(const cross_repo_fixture_t *fixture,
                                            const char *source_project, const char *route_path) {
    char source_path[512];
    if (!cross_repo_project_path(fixture, source_project, source_path, sizeof(source_path))) {
        return false;
    }
    cbm_store_t *source = cbm_store_open_path(source_path);
    if (!source) {
        return false;
    }
    char route_qn[256];
    char handler_qn[256];
    snprintf(route_qn, sizeof(route_qn), "__route__GET__%s", route_path);
    snprintf(handler_qn, sizeof(handler_qn), "%s.local-get-handler", source_project);
    cbm_node_t route = {.project = source_project,
                        .label = "Route",
                        .name = route_path,
                        .qualified_name = route_qn,
                        .file_path = "server.c"};
    cbm_node_t handler = {.project = source_project,
                          .label = "Function",
                          .name = "handle_local_get",
                          .qualified_name = handler_qn,
                          .file_path = "server.c"};
    int64_t route_id = cbm_store_upsert_node(source, &route);
    int64_t handler_id = cbm_store_upsert_node(source, &handler);
    cbm_edge_t handles = {.project = source_project,
                          .source_id = handler_id,
                          .target_id = route_id,
                          .type = "HANDLES"};
    bool ok = route_id > 0 && handler_id > 0 && cbm_store_insert_edge(source, &handles) > 0;
    cbm_store_close(source);
    return ok;
}

static bool cross_repo_exec(const cross_repo_fixture_t *fixture, const char *project,
                            const char *sql) {
    char path[512];
    if (!cross_repo_project_path(fixture, project, path, sizeof(path))) {
        return false;
    }
    cbm_store_t *store = cbm_store_open_path_existing(path);
    if (!store) {
        return false;
    }
    char *error = NULL;
    int rc = sqlite3_exec(cbm_store_get_db(store), sql, NULL, NULL, &error);
    sqlite3_free(error);
    cbm_store_close(store);
    return rc == SQLITE_OK;
}

static int cross_repo_count_edges(const cross_repo_fixture_t *fixture, const char *project,
                                  const char *edge_type) {
    char path[512];
    if (!cross_repo_project_path(fixture, project, path, sizeof(path))) {
        return -1;
    }
    cbm_store_t *store = cbm_store_open_path_query(path);
    if (!store) {
        return -1;
    }
    int count = cbm_store_count_edges_by_type(store, project, edge_type);
    cbm_store_close(store);
    return count;
}

TEST(cross_repo_null_target_fails_without_dereference) {
    cross_repo_fixture_t fixture;
    if (!cross_repo_fixture_begin(&fixture) ||
        !cross_repo_create_project(&fixture, "null-target-source")) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to create isolated source project");
    }

    bool rejected = false;
#if defined(_WIN32)
    const char *targets[] = {NULL};
    cbm_cross_repo_result_t result = cbm_cross_repo_match("null-target-source", targets, 1);
    rejected = result.failed;
    cbm_cross_repo_result_free(&result);
#else
    fflush(NULL);
    pid_t child = fork();
    if (child == 0) {
        const char *targets[] = {NULL};
        cbm_cross_repo_result_t result = cbm_cross_repo_match("null-target-source", targets, 1);
        cbm_cross_repo_result_free(&result);
        _exit(result.failed ? 0 : 2);
    }
    int status = 0;
    rejected = child > 0 && waitpid(child, &status, 0) == child && WIFEXITED(status) &&
               WEXITSTATUS(status) == 0;
#endif

    cross_repo_fixture_end(&fixture);
    ASSERT_TRUE(rejected);
    PASS();
}

TEST(cross_repo_wildcard_keeps_projects_containing_internal_tokens) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_http_pair(&fixture, "wildcard-source", "orders_config_service",
                                           "/config-orders", "a") &&
                 cross_repo_seed_http_pair(&fixture, "wildcard-source", "orders_cross_repo_service",
                                           "/cross-orders", "b") &&
                 cross_repo_seed_http_pair(&fixture, "wildcard-source", "orders-wal-service",
                                           "/wal-orders", "c") &&
                 cross_repo_seed_http_pair(&fixture, "wildcard-source", "orders-shm-service",
                                           "/shm-orders", "d");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed wildcard fixture");
    }

    const char *targets[] = {"*"};
    cbm_cross_repo_result_t result = cbm_cross_repo_match("wildcard-source", targets, 1);
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&result);

    ASSERT_FALSE(result.failed);
    ASSERT_EQ(result.projects_scanned, 4);
    ASSERT_EQ(result.http_edges, 4);
    PASS();
}

/* A project store written before the #768 edges.local_name_gen column: it
 * still answers read-only queries (list_projects shows it), but the
 * read-write open every cross-repo target needs refuses it until a reindex. */
static bool cross_repo_create_pre768_project(const cross_repo_fixture_t *fixture,
                                             const char *project) {
    char path[512];
    if (!cross_repo_project_path(fixture, project, path, sizeof(path))) {
        return false;
    }
    sqlite3 *db = NULL;
    if (sqlite3_open(path, &db) != SQLITE_OK) {
        sqlite3_close(db);
        return false;
    }
    char sql[1024];
    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: ["*"] enumerated every store a read-only open accepts, then aborted
 * the whole run on the first one the matcher's read-write open refused — a
 * single pre-#768 index anywhere in the cache made the wildcard fail with
 * "missing, invalid, or not indexed" while naming the same live targets
 * worked. A store the matcher cannot use is not a wildcard target. */
TEST(cross_repo_wildcard_skips_pre768_store_issue2133) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_http_pair(&fixture, "wild-src", "wild-api", "/orders", "w") &&
                 cross_repo_create_pre768_project(&fixture, "aa-pre768-store");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed pre-#768 wildcard fixture");
    }

    const char *targets[] = {"*"};
    cbm_cross_repo_result_t result = cbm_cross_repo_match("wild-src", targets, 1);
    int edges = cross_repo_count_edges(&fixture, "wild-src", "CROSS_HTTP_CALLS");
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&result);

    ASSERT_FALSE(result.failed);
    ASSERT_EQ(result.projects_scanned, 1);
    ASSERT_EQ(result.http_edges, 1);
    ASSERT_EQ(edges, 1);
    PASS();
}

/* Naming an unusable store stays an error, but it must be refused during
 * validation, before the source's previous CROSS_* generation is deleted. */
TEST(cross_repo_named_pre768_target_fails_before_cleanup_issue2133) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_http_pair(&fixture, "named-src", "named-api", "/orders", "n") &&
                 cross_repo_create_pre768_project(&fixture, "aa-pre768-store");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed pre-#768 named fixture");
    }

    const char *live[] = {"named-api"};
    cbm_cross_repo_result_t initial = cbm_cross_repo_match("named-src", live, 1);
    int before = cross_repo_count_edges(&fixture, "named-src", "CROSS_HTTP_CALLS");
    const char *with_pre768[] = {"named-api", "aa-pre768-store"};
    cbm_cross_repo_result_t result = cbm_cross_repo_match("named-src", with_pre768, 2);
    int after = cross_repo_count_edges(&fixture, "named-src", "CROSS_HTTP_CALLS");
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&initial);
    cbm_cross_repo_result_free(&result);

    ASSERT_FALSE(initial.failed);
    ASSERT_EQ(before, 1);
    ASSERT_TRUE(result.failed);
    ASSERT_EQ(after, before);
    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 };
    char source_path[512];
    char target_path[512];
    if (!cross_repo_project_path(fixture, source_project, source_path, sizeof(source_path)) ||
        !cross_repo_project_path(fixture, target_project, target_path, sizeof(target_path))) {
        return false;
    }
    cbm_store_t *source = cbm_store_open_path(source_path);
    cbm_store_t *target = cbm_store_open_path(target_path);
    if (!source || !target) {
        cbm_store_close(source);
        cbm_store_close(target);
        return false;
    }
    bool ok = cbm_store_upsert_project(source, source_project, fixture->cache) == CBM_STORE_OK &&
              cbm_store_upsert_project(target, target_project, fixture->cache) == CBM_STORE_OK;
    cbm_node_t caller = {.project = source_project,
                         .label = "Function",
                         .name = "bounded_caller",
                         .qualified_name = "bounded.source.caller",
                         .file_path = "client.c"};
    int64_t caller_id = ok ? cbm_store_upsert_node(source, &caller) : 0;
    ok = ok && caller_id > 0 &&
         sqlite3_exec(cbm_store_get_db(source), "BEGIN IMMEDIATE", NULL, NULL, NULL) == SQLITE_OK;
    for (int i = 0; ok && i < TEST_SCAN_ROWS; i++) {
        char name[64];
        char qn[96];
        snprintf(name, sizeof(name), "local_route_%d", i);
        snprintf(qn, sizeof(qn), "bounded.source.route.%d", i);
        cbm_node_t local_route = {.project = source_project,
                                  .label = "Route",
                                  .name = name,
                                  .qualified_name = qn,
                                  .file_path = "client.c"};
        int64_t route_id = cbm_store_upsert_node(source, &local_route);
        cbm_edge_t edge = {
            .project = source_project,
            .source_id = caller_id,
            .target_id = route_id,
            .type = "HTTP_CALLS",
            .properties_json = i == TEST_SCAN_ROWS - 1
                                   ? "{\"url_path\":\"/after-bound\",\"method\":\"GET\"}"
                                   : "{}",
        };
        ok = route_id > 0 && cbm_store_insert_edge(source, &edge) > 0;
    }
    if (ok) {
        ok = sqlite3_exec(cbm_store_get_db(source), "COMMIT", NULL, NULL, NULL) == SQLITE_OK;
    } else {
        (void)sqlite3_exec(cbm_store_get_db(source), "ROLLBACK", NULL, NULL, NULL);
    }

    cbm_node_t target_route = {.project = target_project,
                               .label = "Route",
                               .name = "GET /after-bound",
                               .qualified_name = "__route__GET__/after-bound",
                               .file_path = "server.c"};
    cbm_node_t handler = {.project = target_project,
                          .label = "Function",
                          .name = "bounded_handler",
                          .qualified_name = "bounded.target.handler",
                          .file_path = "server.c"};
    int64_t target_route_id = ok ? cbm_store_upsert_node(target, &target_route) : 0;
    int64_t handler_id = ok ? cbm_store_upsert_node(target, &handler) : 0;
    cbm_edge_t handles = {.project = target_project,
                          .source_id = handler_id,
                          .target_id = target_route_id,
                          .type = "HANDLES"};
    ok = ok && target_route_id > 0 && handler_id > 0 && cbm_store_insert_edge(target, &handles) > 0;
    cbm_store_close(source);
    cbm_store_close(target);
    return ok;
}

/* No row count decides which calls are matched: the scans stopped after 4,096
 * rows, so a call examined after 4,096 others never got its CROSS_HTTP_CALLS
 * edge even though the target serves its route. */
TEST(cross_repo_matches_calls_past_4096_rows) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_bounded_scan(&fixture, "bounded-source", "bounded-target");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed bounded scan fixture");
    }
    const char *target = "bounded-target";
    cbm_cross_repo_result_t result = cbm_cross_repo_match("bounded-source", &target, 1);
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&result);

    ASSERT_FALSE(result.failed);
    ASSERT_EQ(result.projects_scanned, 1);
    ASSERT_EQ(result.http_edges, 1);
    PASS();
}

TEST(cross_repo_propagates_delete_failure) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_http_pair(&fixture, "delete-source", "delete-target",
                                           "/delete-failure", "delete");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed delete failure fixture");
    }
    const char *target = "delete-target";
    cbm_cross_repo_result_t initial = cbm_cross_repo_match("delete-source", &target, 1);
    bool trigger_created =
        !initial.failed && initial.http_edges == 1 &&
        cross_repo_exec(&fixture, "delete-source",
                        "CREATE TRIGGER fail_cross_delete BEFORE DELETE ON edges "
                        "WHEN OLD.type = 'CROSS_HTTP_CALLS' BEGIN "
                        "SELECT RAISE(ABORT, 'forced cross delete failure'); END;");
    cbm_cross_repo_result_t failed = {0};
    if (trigger_created) {
        failed = cbm_cross_repo_match("delete-source", &target, 1);
    }
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&initial);
    cbm_cross_repo_result_free(&failed);

    ASSERT_TRUE(trigger_created);
    ASSERT_TRUE(failed.failed);
    ASSERT_EQ(failed.http_edges, 0);
    PASS();
}

TEST(cross_repo_failed_bidirectional_insert_is_not_counted) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_http_pair(&fixture, "insert-source", "insert-target",
                                           "/insert-failure", "insert") &&
                 cross_repo_exec(&fixture, "insert-target",
                                 "CREATE TRIGGER fail_cross_insert BEFORE INSERT ON edges "
                                 "WHEN NEW.type = 'CROSS_HTTP_CALLS' BEGIN "
                                 "SELECT RAISE(ABORT, 'forced cross insert failure'); END;");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed insert failure fixture");
    }
    const char *target = "insert-target";
    cbm_cross_repo_result_t result = cbm_cross_repo_match("insert-source", &target, 1);
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&result);

    ASSERT_TRUE(result.failed);
    ASSERT_EQ(result.http_edges, 0);
    ASSERT_EQ(result.projects_scanned, 0);
    PASS();
}

typedef struct {
    atomic_int *cancelled;
    int fired;
} cross_repo_cancel_hook_t;

static void cross_repo_cancel_after_target_write(const char *project, const char *edge_type,
                                                 void *opaque) {
    cross_repo_cancel_hook_t *hook = opaque;
    if (strcmp(project, "cancel-target-b") == 0 && strcmp(edge_type, "CROSS_HTTP_CALLS") == 0) {
        hook->fired++;
        atomic_store_explicit(hook->cancelled, 1, memory_order_release);
    }
}

TEST(cross_repo_cancel_mid_run_keeps_completed_target_and_stops_before_later_target) {
    cross_repo_fixture_t fixture;
    bool setup =
        cross_repo_fixture_begin(&fixture) &&
        cross_repo_seed_http_pair(&fixture, "cancel-source", "cancel-target-a", "/cancel-a", "a") &&
        cross_repo_seed_http_pair(&fixture, "cancel-source", "cancel-target-b", "/cancel-b", "b") &&
        cross_repo_seed_http_pair(&fixture, "cancel-source", "cancel-target-c", "/cancel-c", "c");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed cancellation fixture");
    }

    atomic_int cancelled;
    atomic_init(&cancelled, 0);
    cross_repo_cancel_hook_t hook = {
        .cancelled = &cancelled,
    };

    const char *targets[] = {"cancel-target-c", "cancel-target-a", "cancel-target-b"};
    cbm_cross_repo_set_after_insert_hook_for_tests(cross_repo_cancel_after_target_write, &hook);
    cbm_cross_repo_result_t result =
        cbm_cross_repo_match_cancellable("cancel-source", targets, 3, &cancelled);
    cbm_cross_repo_set_after_insert_hook_for_tests(NULL, NULL);

    int completed_target_edges =
        cross_repo_count_edges(&fixture, "cancel-target-a", "CROSS_HTTP_CALLS");
    int interrupted_target_edges =
        cross_repo_count_edges(&fixture, "cancel-target-b", "CROSS_HTTP_CALLS");
    int later_target_edges =
        cross_repo_count_edges(&fixture, "cancel-target-c", "CROSS_HTTP_CALLS");
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&result);

    ASSERT_EQ(hook.fired, 1);
    ASSERT_TRUE(result.cancelled);
    ASSERT_TRUE(result.partial_results);
    ASSERT_FALSE(result.failed);
    ASSERT_EQ(result.projects_scanned, 1);
    ASSERT_TRUE(completed_target_edges > 0);
    ASSERT_TRUE(interrupted_target_edges > 0);
    ASSERT_EQ(later_target_edges, 0);
    PASS();
}

TEST(cross_repo_pre_cancel_preserves_existing_cross_edges) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_http_pair(&fixture, "pre-cancel-source", "pre-cancel-target",
                                           "/pre-cancel", "pre");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed pre-cancel fixture");
    }

    const char *target = "pre-cancel-target";
    cbm_cross_repo_result_t initial = cbm_cross_repo_match("pre-cancel-source", &target, 1);
    int before = cross_repo_count_edges(&fixture, "pre-cancel-source", "CROSS_HTTP_CALLS");
    atomic_int cancelled;
    atomic_init(&cancelled, 1);
    cbm_cross_repo_result_t result =
        cbm_cross_repo_match_cancellable("pre-cancel-source", &target, 1, &cancelled);
    int after = cross_repo_count_edges(&fixture, "pre-cancel-source", "CROSS_HTTP_CALLS");
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&initial);
    cbm_cross_repo_result_free(&result);

    ASSERT_FALSE(initial.failed);
    ASSERT_TRUE(before > 0);
    ASSERT_TRUE(result.cancelled);
    ASSERT_FALSE(result.partial_results);
    ASSERT_FALSE(result.failed);
    ASSERT_EQ(result.projects_scanned, 0);
    ASSERT_EQ(after, before);
    PASS();
}

/* #1133: a run whose targets resolve to nothing but the source project must
 * fail explicitly. It used to report "success" with projects_scanned:0 --
 * indistinguishable from "these services share no routes" -- and, worse, it
 * had already wiped the source's existing CROSS_* edges before noticing there
 * was nothing to match against. */
TEST(cross_repo_self_only_target_fails_and_keeps_edges_issue1133) {
    cross_repo_fixture_t fixture;
    bool setup =
        cross_repo_fixture_begin(&fixture) &&
        cross_repo_seed_http_pair(&fixture, "self-source", "self-target", "/self-only", "self");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed self-only fixture");
    }

    const char *target = "self-target";
    cbm_cross_repo_result_t initial = cbm_cross_repo_match("self-source", &target, 1);
    int before = cross_repo_count_edges(&fixture, "self-source", "CROSS_HTTP_CALLS");
    const char *self = "self-source";
    cbm_cross_repo_result_t result = cbm_cross_repo_match("self-source", &self, 1);
    int after = cross_repo_count_edges(&fixture, "self-source", "CROSS_HTTP_CALLS");
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&initial);
    cbm_cross_repo_result_free(&result);

    ASSERT_FALSE(initial.failed);
    ASSERT_TRUE(before > 0);
    ASSERT_TRUE(result.failed);
    ASSERT_TRUE(result.no_targets);
    ASSERT_EQ(result.projects_scanned, 0);
    ASSERT_EQ(after, before);
    PASS();
}

/* #1133: ["*"] in a store that holds only the source project resolves to zero
 * targets -- same contract as an explicit self-only list. */
TEST(cross_repo_wildcard_with_no_other_project_fails_issue1133) {
    cross_repo_fixture_t fixture;
    if (!cross_repo_fixture_begin(&fixture) ||
        !cross_repo_create_project(&fixture, "lonely-source")) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to create isolated source project");
    }

    const char *targets[] = {"*"};
    cbm_cross_repo_result_t result = cbm_cross_repo_match("lonely-source", targets, 1);
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&result);

    ASSERT_TRUE(result.failed);
    ASSERT_TRUE(result.no_targets);
    ASSERT_EQ(result.projects_scanned, 0);
    PASS();
}

/* Add the internal "<name>::missed" miss-graph row that indexing writes into
 * the SAME db whenever a file parses partially. */
static bool cross_repo_add_missed_shadow(const cross_repo_fixture_t *fixture, const char *project) {
    char path[512];
    char shadow[256];
    if (!cross_repo_project_path(fixture, project, path, sizeof(path))) {
        return false;
    }
    snprintf(shadow, sizeof(shadow), "%s::missed", project);
    cbm_store_t *store = cbm_store_open_path(path);
    if (!store) {
        return false;
    }
    bool ok = cbm_store_upsert_project(store, shadow, fixture->cache) == CBM_STORE_OK;
    cbm_store_close(store);
    return ok;
}

/* #1609: any project that has ever recorded a parse miss carries a
 * "<name>::missed" shadow row in its own db. cr_store_has_exact_project
 * demanded count == 1 over ALL rows, so that second row made the project
 * unresolvable — as source AND as target — and the whole feature failed with
 * "not indexed" for a project that plainly was. mcp.c already solved exactly
 * this shape for list_projects in #1044; this site never learned it.
 *
 * The control is the pair without shadow rows: the tests above already prove
 * that path returns edges, so a regression here cannot hide behind a fixture
 * that never matched in the first place. */
TEST(cross_repo_accepts_project_with_missed_shadow_row_issue1609) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 cross_repo_seed_http_pair(&fixture, "shadow-source", "shadow-target", "/orders",
                                           "s") &&
                 cross_repo_add_missed_shadow(&fixture, "shadow-source") &&
                 cross_repo_add_missed_shadow(&fixture, "shadow-target");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed shadow-row fixture");
    }

    const char *target = "shadow-target";
    cbm_cross_repo_result_t result = cbm_cross_repo_match("shadow-source", &target, 1);
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&result);

    ASSERT_FALSE(result.failed);
    ASSERT_EQ(result.projects_scanned, 1);
    ASSERT_EQ(result.http_edges, 1);
    PASS();
}

/* #1459 floor: a caller whose own project handles the route it calls is
 * calling itself — another project exposing the same path is not evidence of
 * a cross-service call. Neither direction of the pass may link it. */
TEST(cross_repo_caller_local_handler_blocks_cross_http_issue1459) {
    cross_repo_fixture_t fixture;
    bool setup =
        cross_repo_fixture_begin(&fixture) &&
        cross_repo_seed_http_pair(&fixture, "mono-1459", "api-1459", "/api/users", "mono") &&
        cross_repo_seed_local_handler(&fixture, "mono-1459", "mono");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed caller-local route fixture");
    }
    const char *target = "api-1459";
    cbm_cross_repo_result_t fwd = cbm_cross_repo_match("mono-1459", &target, 1);
    const char *consumer = "mono-1459";
    cbm_cross_repo_result_t rev = cbm_cross_repo_match("api-1459", &consumer, 1);
    int mono_edges = cross_repo_count_edges(&fixture, "mono-1459", "CROSS_HTTP_CALLS");
    int api_edges = cross_repo_count_edges(&fixture, "api-1459", "CROSS_HTTP_CALLS");
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&fwd);
    cbm_cross_repo_result_free(&rev);

    ASSERT_FALSE(fwd.failed);
    ASSERT_FALSE(rev.failed);
    ASSERT_EQ(fwd.http_edges, 0);
    ASSERT_EQ(rev.http_edges, 0);
    ASSERT_EQ(mono_edges, 0);
    ASSERT_EQ(api_edges, 0);
    PASS();
}

/* #1459 floor, real-world shape: a method-less client call points at the ANY
 * Route node, while the caller's own handler sits on the GET node for the same
 * path. The call is still served in-project and must not cross. */
TEST(cross_repo_methodless_call_to_local_get_route_blocks_cross_http_issue1459) {
    cross_repo_fixture_t fixture;
    bool setup =
        cross_repo_fixture_begin(&fixture) &&
        cross_repo_seed_http_pair(&fixture, "mono2-1459", "api3-1459", "/api/users", "mono2") &&
        cross_repo_exec(&fixture, "mono2-1459",
                        "UPDATE edges SET properties = '{\"url_path\":\"/api/users\"}' "
                        "WHERE type = 'HTTP_CALLS';") &&
        cross_repo_seed_local_get_route(&fixture, "mono2-1459", "/api/users");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed method-less caller-local fixture");
    }
    const char *target = "api3-1459";
    cbm_cross_repo_result_t fwd = cbm_cross_repo_match("mono2-1459", &target, 1);
    const char *consumer = "mono2-1459";
    cbm_cross_repo_result_t rev = cbm_cross_repo_match("api3-1459", &consumer, 1);
    int mono_edges = cross_repo_count_edges(&fixture, "mono2-1459", "CROSS_HTTP_CALLS");
    int api_edges = cross_repo_count_edges(&fixture, "api3-1459", "CROSS_HTTP_CALLS");
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&fwd);
    cbm_cross_repo_result_free(&rev);

    ASSERT_FALSE(fwd.failed);
    ASSERT_FALSE(rev.failed);
    ASSERT_EQ(fwd.http_edges, 0);
    ASSERT_EQ(rev.http_edges, 0);
    ASSERT_EQ(mono_edges, 0);
    ASSERT_EQ(api_edges, 0);
    PASS();
}

/* Control for the #1459 floor: without a caller-local handler the path match
 * still links the caller to the remote handler, in both run directions. */
TEST(cross_repo_caller_without_local_handler_keeps_cross_http_issue1459) {
    cross_repo_fixture_t fixture;
    bool setup =
        cross_repo_fixture_begin(&fixture) &&
        cross_repo_seed_http_pair(&fixture, "client-1459", "api2-1459", "/api/users", "client");
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed remote-only route fixture");
    }
    const char *target = "api2-1459";
    cbm_cross_repo_result_t fwd = cbm_cross_repo_match("client-1459", &target, 1);
    int client_edges = cross_repo_count_edges(&fixture, "client-1459", "CROSS_HTTP_CALLS");
    int api_edges = cross_repo_count_edges(&fixture, "api2-1459", "CROSS_HTTP_CALLS");
    const char *consumer = "client-1459";
    cbm_cross_repo_result_t rev = cbm_cross_repo_match("api2-1459", &consumer, 1);
    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&fwd);
    cbm_cross_repo_result_free(&rev);

    ASSERT_FALSE(fwd.failed);
    ASSERT_FALSE(rev.failed);
    ASSERT_EQ(fwd.http_edges, 1);
    ASSERT_EQ(rev.http_edges, 1);
    ASSERT_EQ(client_edges, 1);
    ASSERT_EQ(api_edges, 1);
    PASS();
}

static bool cross_repo_seed_server_route(const cross_repo_fixture_t *fixture,
                                         const char *target_project, const char *method,
                                         const char *route_path, const char *handler_name) {
    char target_path[512];
    if (!cross_repo_project_path(fixture, target_project, target_path, sizeof(target_path))) {
        return false;
    }
    cbm_store_t *target = cbm_store_open_path(target_path);
    if (!target) {
        return false;
    }
    bool ok = cbm_store_upsert_project(target, target_project, fixture->cache) == CBM_STORE_OK;
    char target_route_qn[256];
    char handler_qn[256];
    char route_name[128];
    snprintf(target_route_qn, sizeof(target_route_qn), "__route__%s__%s", method, route_path);
    snprintf(handler_qn, sizeof(handler_qn), "%s.%s", target_project, handler_name);
    snprintf(route_name, sizeof(route_name), "%s %s", method, route_path);

    cbm_node_t target_route = {.project = target_project,
                               .label = "Route",
                               .name = route_name,
                               .qualified_name = target_route_qn,
                               .file_path = "server.java"};
    cbm_node_t handler = {.project = target_project,
                          .label = "Function",
                          .name = handler_name,
                          .qualified_name = handler_qn,
                          .file_path = "server.java"};
    int64_t target_route_id = ok ? cbm_store_upsert_node(target, &target_route) : 0;
    int64_t handler_id = ok ? cbm_store_upsert_node(target, &handler) : 0;
    cbm_edge_t handles = {.project = target_project,
                          .source_id = handler_id,
                          .target_id = target_route_id,
                          .type = "HANDLES"};
    ok = ok && target_route_id > 0 && handler_id > 0 && cbm_store_insert_edge(target, &handles) > 0;
    cbm_store_close(target);
    return ok;
}

static bool cross_repo_seed_client_call(const cross_repo_fixture_t *fixture,
                                        const char *source_project, const char *caller_name,
                                        const char *callee_name, const char *url_path,
                                        const char *method) {
    char source_path[512];
    if (!cross_repo_project_path(fixture, source_project, source_path, sizeof(source_path))) {
        return false;
    }
    cbm_store_t *source = cbm_store_open_path(source_path);
    if (!source) {
        return false;
    }
    bool ok = cbm_store_upsert_project(source, source_project, fixture->cache) == CBM_STORE_OK;
    char caller_qn[256];
    char local_route_qn[256];
    char edge_props[512];
    snprintf(caller_qn, sizeof(caller_qn), "%s.%s", source_project, caller_name);
    snprintf(local_route_qn, sizeof(local_route_qn), "__route__%s__%s", method ? method : "ANY",
             url_path);
    if (method) {
        snprintf(edge_props, sizeof(edge_props),
                 "{\"callee\":\"%s\",\"url_path\":\"%s\",\"method\":\"%s\"}", callee_name,
                 url_path, method);
    } else {
        snprintf(edge_props, sizeof(edge_props),
                 "{\"callee\":\"%s\",\"url_path\":\"%s\"}", callee_name, url_path);
    }
    cbm_node_t caller = {.project = source_project,
                         .label = "Function",
                         .name = caller_name,
                         .qualified_name = caller_qn,
                         .file_path = "item.service.ts"};
    cbm_node_t local_route = {.project = source_project,
                              .label = "Route",
                              .name = url_path,
                              .qualified_name = local_route_qn,
                              .file_path = "item.service.ts"};
    int64_t caller_id = ok ? cbm_store_upsert_node(source, &caller) : 0;
    int64_t local_route_id = ok ? cbm_store_upsert_node(source, &local_route) : 0;
    cbm_edge_t http_call = {.project = source_project,
                            .source_id = caller_id,
                            .target_id = local_route_id,
                            .type = "HTTP_CALLS",
                            .properties_json = edge_props};
    ok = ok && caller_id > 0 && local_route_id > 0 && cbm_store_insert_edge(source, &http_call) > 0;
    cbm_store_close(source);
    return ok;
}

static int cross_repo_count_edges_like(const cross_repo_fixture_t *fixture, const char *project,
                                       const char *edge_type, const char *pattern) {
    char path[512];
    if (!cross_repo_project_path(fixture, project, path, sizeof(path))) {
        return -1;
    }
    cbm_store_t *store = cbm_store_open_path_query(path);
    if (!store) {
        return -1;
    }
    sqlite3_stmt *s = NULL;
    int count = -1;
    if (sqlite3_prepare_v2(
            cbm_store_get_db(store),
            "SELECT COUNT(*) FROM edges WHERE project = ?1 AND type = ?2 AND properties LIKE ?3",
            -1, &s, NULL) == SQLITE_OK) {
        sqlite3_bind_text(s, 1, project, -1, SQLITE_STATIC);
        sqlite3_bind_text(s, 2, edge_type, -1, SQLITE_STATIC);
        sqlite3_bind_text(s, 3, pattern, -1, SQLITE_STATIC);
        if (sqlite3_step(s) == SQLITE_ROW) {
            count = sqlite3_column_int(s, 0);
        }
        sqlite3_finalize(s);
    }
    cbm_store_close(store);
    return count;
}

/* #2768: Angular HttpClient calls must match cross-repo routes with exact HTTP verbs.
 * When client makes GET requests to /items/list, /items/42, and /items/job/10,
 * and the server defines overlapping routes:
 *   DELETE /items/{id} (seeded first in DB)
 *   GET    /items/{id} (seeded second in DB)
 *   POST   /items/{parentId}/{id} (seeded first in DB)
 *   GET    /items/job/{jobId} (seeded second in DB)
 * the fuzzy route matcher must enforce method compatibility, linking the GET calls
 * to their respective GET endpoints and never to DELETE or POST endpoints.
 * getItem and getJob are seeded WITHOUT a method property (an edge written by an
 * index that did not record the verb): the matcher must infer GET from the
 * callee's verb suffix, or the method-less fuzzy match lands on the DELETE / POST
 * route seeded first. getItems keeps its explicit "GET". */
TEST(cross_repo_angular_http_client_exact_verb_matching_issue2768) {
    cross_repo_fixture_t fixture;
    bool setup = cross_repo_fixture_begin(&fixture) &&
                 /* Target server with overlapping endpoints */
                 cross_repo_seed_server_route(&fixture, "api-2768", "GET", "/items/list",
                                              "handle_list_items") &&
                 cross_repo_seed_server_route(&fixture, "api-2768", "DELETE", "/items/{}",
                                              "handle_delete_item") &&
                 cross_repo_seed_server_route(&fixture, "api-2768", "GET", "/items/{}",
                                              "handle_get_item") &&
                 cross_repo_seed_server_route(&fixture, "api-2768", "POST", "/items/{}/{}",
                                              "handle_post_nested_item") &&
                 cross_repo_seed_server_route(&fixture, "api-2768", "GET", "/items/job/{}",
                                              "handle_get_job") &&
                 /* Angular client making GET requests */
                 cross_repo_seed_client_call(&fixture, "angular-2768", "getItems",
                                             "this.http.get", "/items/list", "GET") &&
                 cross_repo_seed_client_call(&fixture, "angular-2768", "getItem",
                                             "this.http.get", "/items/42", NULL) &&
                 cross_repo_seed_client_call(&fixture, "angular-2768", "getJob",
                                             "this.http.get", "/items/job/10", NULL);
    if (!setup) {
        cross_repo_fixture_end(&fixture);
        FAIL("failed to seed issue 2768 fixture");
    }

    const char *target = "api-2768";
    cbm_cross_repo_result_t fwd = cbm_cross_repo_match("angular-2768", &target, 1);
    ASSERT_FALSE(fwd.failed);
    ASSERT_EQ(fwd.http_edges, 3);

    /* Assert that client CROSS_HTTP_CALLS edges are linked to GET handlers, not DELETE or POST */
    ASSERT_EQ(cross_repo_count_edges_like(&fixture, "angular-2768", "CROSS_HTTP_CALLS",
                                          "%handle_delete_item%"),
              0);
    ASSERT_EQ(cross_repo_count_edges_like(&fixture, "angular-2768", "CROSS_HTTP_CALLS",
                                          "%handle_post_nested_item%"),
              0);
    ASSERT_EQ(cross_repo_count_edges_like(&fixture, "angular-2768", "CROSS_HTTP_CALLS",
                                          "%handle_list_items%"),
              1);
    ASSERT_EQ(cross_repo_count_edges_like(&fixture, "angular-2768", "CROSS_HTTP_CALLS",
                                          "%handle_get_item%"),
              1);
    ASSERT_EQ(cross_repo_count_edges_like(&fixture, "angular-2768", "CROSS_HTTP_CALLS",
                                          "%handle_get_job%"),
              1);

    /* Reverse pass */
    const char *consumer = "angular-2768";
    cbm_cross_repo_result_t rev = cbm_cross_repo_match("api-2768", &consumer, 1);
    ASSERT_FALSE(rev.failed);
    ASSERT_EQ(rev.http_edges, 3);

    cross_repo_fixture_end(&fixture);
    cbm_cross_repo_result_free(&fwd);
    cbm_cross_repo_result_free(&rev);
    PASS();
}

SUITE(cross_repo) {
    RUN_TEST(cross_repo_caller_local_handler_blocks_cross_http_issue1459);
    RUN_TEST(cross_repo_methodless_call_to_local_get_route_blocks_cross_http_issue1459);
    RUN_TEST(cross_repo_caller_without_local_handler_keeps_cross_http_issue1459);
    RUN_TEST(cross_repo_angular_http_client_exact_verb_matching_issue2768);
    RUN_TEST(cross_repo_accepts_project_with_missed_shadow_row_issue1609);
    RUN_TEST(cross_repo_null_target_fails_without_dereference);
    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_matches_calls_past_4096_rows);
    RUN_TEST(cross_repo_propagates_delete_failure);
    RUN_TEST(cross_repo_failed_bidirectional_insert_is_not_counted);
    RUN_TEST(cross_repo_cancel_mid_run_keeps_completed_target_and_stops_before_later_target);
    RUN_TEST(cross_repo_pre_cancel_preserves_existing_cross_edges);
    RUN_TEST(cross_repo_self_only_target_fails_and_keeps_edges_issue1133);
    RUN_TEST(cross_repo_wildcard_with_no_other_project_fails_issue1133);
}