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.

fix(pipeline): expose unresolved call coverage

Pcristin2c71746fa52f
diff --git a/src/mcp/mcp.c b/src/mcp/mcp.c
index 78b8dccf9..f3e700aea 100644
--- a/src/mcp/mcp.c
+++ b/src/mcp/mcp.c
@@ -64,6 +64,7 @@ enum {
#include "watcher/watcher.h"
#include "foundation/mem.h"
#include "foundation/mem_core.h"
+#include "foundation/hash_table.h"
#include "foundation/diagnostics.h"
#include "foundation/platform.h"
#include "foundation/compat.h"
@@ -6090,11 +6091,13 @@ static void add_coverage_report(yyjson_mut_doc *doc, yyjson_mut_val *root, cbm_s
yyjson_mut_val *pp_files = yyjson_mut_arr(doc);
yyjson_mut_val *pu_files = yyjson_mut_arr(doc);
+ yyjson_mut_val *unresolved_files = yyjson_mut_arr(doc);
yyjson_mut_val *sk_files = yyjson_mut_arr(doc);
yyjson_mut_val *ni_dirs = yyjson_mut_arr(doc);
yyjson_mut_val *ni_files = yyjson_mut_arr(doc);
int pp_n = 0;
int pu_n = 0;
+ int unresolved_n = 0;
int sk_n = 0;
int ni_dir_n = 0;
int ni_file_n = 0;
@@ -6124,6 +6127,11 @@ static void add_coverage_report(yyjson_mut_doc *doc, yyjson_mut_val *root, cbm_s
yyjson_mut_arr_add_val(pu_files, fe);
}
pu_n++;
+ } else if (strcmp(kind, "unresolved_calls") == 0) {
+ if (unresolved_n < sample_limit) {
+ yyjson_mut_arr_add_strcpy(doc, unresolved_files, rows[i].rel_path);
+ }
+ unresolved_n++;
} else if (strcmp(kind, "not_indexed_dir") == 0) {
if (ni_dir_n < sample_limit) {
yyjson_mut_arr_add_strcpy(doc, ni_dirs, rows[i].rel_path);
@@ -6181,6 +6189,12 @@ static void add_coverage_report(yyjson_mut_doc *doc, yyjson_mut_val *root, cbm_s
yyjson_mut_obj_add_bool(doc, pu, "truncated", pu_n > COVERAGE_FILE_CAP);
yyjson_mut_obj_add_val(doc, root, "parse_unusable", pu);
+ yyjson_mut_val *unresolved = yyjson_mut_obj(doc);
+ yyjson_mut_obj_add_val(doc, unresolved, "files", unresolved_files);
+ yyjson_mut_obj_add_int(doc, unresolved, "count", unresolved_n);
+ yyjson_mut_obj_add_bool(doc, unresolved, "truncated", unresolved_n > sample_limit);
+ yyjson_mut_obj_add_val(doc, root, "unresolved_calls", unresolved);
+
yyjson_mut_val *sk = yyjson_mut_obj(doc);
yyjson_mut_obj_add_val(doc, sk, "files", sk_files);
yyjson_mut_obj_add_int(doc, sk, "count", sk_n);
@@ -6218,7 +6232,7 @@ static void add_coverage_report(yyjson_mut_doc *doc, yyjson_mut_val *root, cbm_s
}
yyjson_mut_obj_add_val(doc, root, "not_indexed", ni);
- if (sample_limit > 0 && (pp_n > 0 || sk_n > 0)) {
+ if (sample_limit > 0 && (pp_n > 0 || sk_n > 0 || unresolved_n > 0)) {
yyjson_mut_obj_add_str(
doc, root, "coverage_note",
"Best-effort signal, not a completeness guarantee: parse_partial files WERE indexed, "
@@ -6226,7 +6240,9 @@ static void add_coverage_report(yyjson_mut_doc *doc, yyjson_mut_val *root, cbm_s
"(tree-sitter error recovery still salvages some). skipped files were not indexed at "
"all. Prefer text search (grep) for flagged files/ranges. Files absent from this list "
"are NOT guaranteed to be fully indexed. (not_indexed entries are a separate, "
- "BY-DESIGN class — deliberate ignore rules, not failures.)");
+ "BY-DESIGN class — deliberate ignore rules, not failures.) "
+ "Unresolved callsites need source verification because CALLS totals may be "
+ "incomplete.");
}
}
@@ -6467,6 +6483,9 @@ static const char *coverage_status(const cbm_coverage_row_t *rows, int count,
if (pass == 0 && strcmp(kind, "parse_partial") == 0) {
return "partial";
}
+ if (pass == 0 && strcmp(kind, "unresolved_calls") == 0) {
+ return "unresolved_calls";
+ }
if (pass == 1 && strncmp(kind, "not_indexed", 11) == 0) {
return "excluded";
}
@@ -6491,6 +6510,9 @@ static const char *coverage_recommended_action(const char *status, const char *f
if (strcmp(status, "partial") == 0) {
return "read_ranges_and_verify_scope";
}
+ if (strcmp(status, "unresolved_calls") == 0) {
+ return "read_source_and_verify_calls";
+ }
if (strcmp(status, "unusable") == 0) {
/* The ranges cover nearly the whole file, so sending a reader to them
* is the same as sending them to the file. Say the useful thing. */
@@ -9350,6 +9372,102 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
bool optional_fields_omitted = false;
char *json = NULL;
+ bool trace_includes_calls = false;
+ for (int i = 0; i < edge_type_count; i++) {
+ if (strcmp(edge_types[i], "CALLS") == 0) {
+ trace_includes_calls = true;
+ break;
+ }
+ }
+ bool unresolved_out = false;
+ bool unresolved_in = false;
+ if (trace_includes_calls) {
+ cbm_coverage_meta_t coverage_meta = {0};
+ int meta_rc = cbm_store_coverage_meta_get(store, project, &coverage_meta);
+ if (meta_rc == CBM_STORE_OK) {
+ if (coverage_meta.coverage_version < CBM_UNRESOLVED_CALL_COVERAGE_VERSION ||
+ !coverage_meta.recording_status ||
+ strcmp(coverage_meta.recording_status, "unavailable") == 0) {
+ unresolved_out = do_outbound;
+ unresolved_in = do_inbound;
+ }
+ } else {
+ unresolved_out = do_outbound;
+ unresolved_in = do_inbound;
+ }
+ cbm_store_coverage_meta_clear(&coverage_meta);
+ if ((do_outbound && !unresolved_out) || (do_inbound && !unresolved_in)) {
+ CBMHashTable *callers = do_outbound ? cbm_ht_create(0) : NULL;
+ CBMHashTable *leaves = do_inbound ? cbm_ht_create(0) : NULL;
+ if ((do_outbound && !callers) || (do_inbound && !leaves)) {
+ unresolved_out = do_outbound;
+ unresolved_in = do_inbound;
+ } else {
+ bool key_set_failed = false;
+ for (int i = 0; i < node_count; i++) {
+ if (callers && nodes[i].qualified_name) {
+ cbm_ht_set(callers, nodes[i].qualified_name, (void *)1);
+ key_set_failed |= !cbm_ht_has(callers, nodes[i].qualified_name);
+ }
+ if (leaves && nodes[i].name) {
+ cbm_ht_set(leaves, nodes[i].name, (void *)1);
+ key_set_failed |= !cbm_ht_has(leaves, nodes[i].name);
+ }
+ }
+ for (int i = 0; callers && i < tr_out.visited_count; i++) {
+ const cbm_node_t *node = &tr_out.visited[i].node;
+ if ((include_tests || !is_test_file(node->file_path)) && node->qualified_name) {
+ cbm_ht_set(callers, node->qualified_name, (void *)1);
+ key_set_failed |= !cbm_ht_has(callers, node->qualified_name);
+ }
+ }
+ for (int i = 0; leaves && i < tr_in.visited_count; i++) {
+ const cbm_node_t *node = &tr_in.visited[i].node;
+ if ((include_tests || !is_test_file(node->file_path)) && node->name) {
+ cbm_ht_set(leaves, node->name, (void *)1);
+ key_set_failed |= !cbm_ht_has(leaves, node->name);
+ }
+ }
+ cbm_coverage_row_t *rows = NULL;
+ int row_count = 0;
+ if (key_set_failed || cbm_store_coverage_get_unresolved_calls(
+ store, project, &rows, &row_count) != CBM_STORE_OK) {
+ unresolved_out = do_outbound;
+ unresolved_in = do_inbound;
+ } else {
+ for (int i = 0; i < row_count && ((!unresolved_out && do_outbound) ||
+ (!unresolved_in && do_inbound));
+ i++) {
+ yyjson_doc *detail = yyjson_read(rows[i].detail, strlen(rows[i].detail), 0);
+ yyjson_val *sites = detail ? yyjson_doc_get_root(detail) : NULL;
+ if (!yyjson_is_arr(sites)) {
+ unresolved_out = do_outbound;
+ unresolved_in = do_inbound;
+ } else {
+ size_t idx, max;
+ yyjson_val *site;
+ yyjson_arr_foreach(sites, idx, max, site) {
+ const char *caller = yyjson_get_str(yyjson_obj_get(site, "caller"));
+ const char *leaf = yyjson_get_str(yyjson_obj_get(site, "leaf"));
+ if (callers && caller && cbm_ht_has(callers, caller))
+ unresolved_out = true;
+ if (leaves && leaf && cbm_ht_has(leaves, leaf))
+ unresolved_in = true;
+ }
+ }
+ if (detail)
+ yyjson_doc_free(detail);
+ }
+ }
+ cbm_store_free_coverage(rows, row_count);
+ }
+ cbm_ht_free(callers);
+ cbm_ht_free(leaves);
+ }
+ }
+ const char *out_relation = unresolved_out ? "unknown" : (tr_out.truncated ? "gte" : "eq");
+ const char *in_relation = unresolved_in ? "unknown" : (tr_in.truncated ? "gte" : "eq");
+
render_trace_output:;
int rows_left = row_target;
out_len = requested_out_len < rows_left ? requested_out_len : rows_left;
@@ -9438,7 +9556,7 @@ render_trace_output:;
bool flat_trace = render_risk || render_data_flow;
if (do_outbound) {
cbm_tree_scalar_int(&sb, "callees_total", out_total);
- cbm_tree_scalar_str(&sb, "callees_total_relation", tr_out.truncated ? "gte" : "eq");
+ cbm_tree_scalar_str(&sb, "callees_total_relation", out_relation);
if (flat_trace) {
bfs_to_toon_table(&sb, "callees", &view_out, render_risk, include_tests,
render_data_flow, render_evidence, &out_edge_ctx);
@@ -9449,7 +9567,7 @@ render_trace_output:;
}
if (do_inbound) {
cbm_tree_scalar_int(&sb, "callers_total", in_total);
- cbm_tree_scalar_str(&sb, "callers_total_relation", tr_in.truncated ? "gte" : "eq");
+ cbm_tree_scalar_str(&sb, "callers_total_relation", in_relation);
if (flat_trace) {
bfs_to_toon_table(&sb, "callers", &view_in, render_risk, include_tests,
render_data_flow, render_evidence, &in_edge_ctx);
@@ -9515,8 +9633,7 @@ render_trace_output:;
}
if (do_outbound) {
yyjson_mut_obj_add_int(doc, root, "callees_total", out_total);
- yyjson_mut_obj_add_str(doc, root, "callees_total_relation",
- tr_out.truncated ? "gte" : "eq");
+ yyjson_mut_obj_add_str(doc, root, "callees_total_relation", out_relation);
yyjson_mut_obj_add_val(
doc, root, "callees",
bfs_to_tree_json(doc, &view_out, risk_labels && emit_optional_fields, include_tests,
@@ -9525,8 +9642,7 @@ render_trace_output:;
}
if (do_inbound) {
yyjson_mut_obj_add_int(doc, root, "callers_total", in_total);
- yyjson_mut_obj_add_str(doc, root, "callers_total_relation",
- tr_in.truncated ? "gte" : "eq");
+ yyjson_mut_obj_add_str(doc, root, "callers_total_relation", in_relation);
yyjson_mut_obj_add_val(
doc, root, "callers",
bfs_to_tree_json(doc, &view_in, risk_labels && emit_optional_fields, include_tests,
@@ -9584,13 +9700,11 @@ render_trace_output:;
cbm_sb_init(&floor);
if (do_outbound) {
cbm_tree_scalar_int(&floor, "callees_total", out_total);
- cbm_tree_scalar_str(&floor, "callees_total_relation",
- tr_out.truncated ? "gte" : "eq");
+ cbm_tree_scalar_str(&floor, "callees_total_relation", out_relation);
}
if (do_inbound) {
cbm_tree_scalar_int(&floor, "callers_total", in_total);
- cbm_tree_scalar_str(&floor, "callers_total_relation",
- tr_in.truncated ? "gte" : "eq");
+ cbm_tree_scalar_str(&floor, "callers_total_relation", in_relation);
}
cbm_tree_scalar_bool(&floor, "has_more", floor_has_more);
if (floor_has_more) {
@@ -9615,12 +9729,11 @@ render_trace_output:;
if (do_outbound) {
yyjson_mut_obj_add_int(floor_doc, floor, "callees_total", out_total);
yyjson_mut_obj_add_str(floor_doc, floor, "callees_total_relation",
- tr_out.truncated ? "gte" : "eq");
+ out_relation);
}
if (do_inbound) {
yyjson_mut_obj_add_int(floor_doc, floor, "callers_total", in_total);
- yyjson_mut_obj_add_str(floor_doc, floor, "callers_total_relation",
- tr_in.truncated ? "gte" : "eq");
+ yyjson_mut_obj_add_str(floor_doc, floor, "callers_total_relation", in_relation);
}
yyjson_mut_obj_add_bool(floor_doc, floor, "has_more", floor_has_more);
if (floor_has_more) {
diff --git a/src/pipeline/pipeline.c b/src/pipeline/pipeline.c
index c808cb1b4..9d12c55d9 100644
--- a/src/pipeline/pipeline.c
+++ b/src/pipeline/pipeline.c
@@ -20,6 +20,7 @@ enum { CBM_DIR_PERMS = 0755, PL_RING = 4, PL_RING_MASK = 3, PL_SEQ_PASSES = 6 };
#include "pipeline/artifact.h"
#include "pipeline/pipeline_internal.h"
#include "pipeline/lsp_surface.h"
+#include "pipeline/lsp_resolve.h"
#include "pipeline/pass_lsp_cross.h"
#include "pipeline/pass_ensemble_routing.h"
#include "pipeline/worker_pool.h"
@@ -42,6 +43,7 @@ enum { CBM_DIR_PERMS = 0755, PL_RING = 4, PL_RING_MASK = 3, PL_SEQ_PASSES = 6 };
#include "foundation/mem_core.h"
#include "result_spill.h"
#include "foundation/secure_random.h"
+#include "yyjson/yyjson.h"
#include <ctype.h>
#include <errno.h>
@@ -260,6 +262,11 @@ struct cbm_pipeline {
cbm_lsp_surface_row_t *surface_rows;
int surface_row_count;
+ /* Per-file unresolved invocation diagnostics, published as coverage rows. */
+ cbm_coverage_row_t *unresolved_rows;
+ int unresolved_count;
+ bool unresolved_capture_failed;
+
/* Deterministic test-only seam at the final publication boundary. Kept
* per pipeline so concurrent test/process activity cannot cross-trigger. */
void (*before_publish_hook)(cbm_pipeline_t *, const char *, void *);
@@ -431,6 +438,96 @@ void cbm_pipeline_set_lsp_surfaces(cbm_pipeline_t *p, cbm_lsp_surface_row_t *row
p->surface_row_count = count;
}
+static void *unresolved_json_alloc(void *ctx, size_t size) {
+ (void)ctx;
+ return cbm_alloc(CBM_MEM_CLASS_DUMP, size);
+}
+
+static void *unresolved_json_realloc(void *ctx, void *ptr, size_t old_size, size_t size) {
+ (void)ctx;
+ (void)old_size;
+ return cbm_realloc(CBM_MEM_CLASS_DUMP, ptr, size);
+}
+
+static void unresolved_json_free(void *ctx, void *ptr) {
+ (void)ctx;
+ cbm_free(CBM_MEM_CLASS_DUMP, ptr);
+}
+
+void cbm_pipeline_record_unresolved_calls(cbm_pipeline_t *p, const char *rel_path,
+ const CBMFileResult *result) {
+ if (!p || !rel_path || !result || result->resolved_calls.count == 0 ||
+ p->unresolved_capture_failed) {
+ return;
+ }
+ yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
+ if (!doc) {
+ p->unresolved_capture_failed = true;
+ return;
+ }
+ yyjson_mut_val *sites = yyjson_mut_arr(doc);
+ yyjson_mut_doc_set_root(doc, sites);
+ int count = 0;
+ for (int i = 0; i < result->resolved_calls.count; i++) {
+ const CBMResolvedCall *rc = &result->resolved_calls.items[i];
+ if (rc->kind != CBM_RESOLVED_INVOCATION || !rc->strategy ||
+ strcmp(rc->strategy, "lsp_unresolved") != 0 || !rc->caller_qn || !rc->callee_qn) {
+ continue;
+ }
+ const char *leaf = strrchr(rc->callee_qn, '.');
+ leaf = leaf ? leaf + 1 : rc->callee_qn;
+ yyjson_mut_val *site = yyjson_mut_obj(doc);
+ yyjson_mut_obj_add_strcpy(doc, site, "caller", rc->caller_qn);
+ yyjson_mut_obj_add_strcpy(doc, site, "leaf", leaf);
+ yyjson_mut_obj_add_uint(doc, site, "start_byte", rc->site_start_byte);
+ yyjson_mut_obj_add_uint(doc, site, "end_byte", rc->site_end_byte);
+ yyjson_mut_obj_add_strcpy(doc, site, "reason", rc->reason ? rc->reason : "unresolved");
+ yyjson_mut_arr_add_val(sites, site);
+ count++;
+ }
+ if (count > 0) {
+ yyjson_alc allocator = {.malloc = unresolved_json_alloc,
+ .realloc = unresolved_json_realloc,
+ .free = unresolved_json_free};
+ char *detail = yyjson_mut_write_opts(doc, 0, &allocator, NULL, NULL);
+ char *path = cbm_mem_strdup(CBM_MEM_CLASS_DUMP, rel_path);
+ if (!detail || !path) {
+ p->unresolved_capture_failed = true;
+ cbm_free(CBM_MEM_CLASS_DUMP, detail);
+ cbm_free(CBM_MEM_CLASS_DUMP, path);
+ } else {
+ cbm_coverage_row_t *rows =
+ cbm_realloc(CBM_MEM_CLASS_DUMP, p->unresolved_rows,
+ (size_t)(p->unresolved_count + 1) * sizeof(*rows));
+ if (!rows) {
+ p->unresolved_capture_failed = true;
+ cbm_free(CBM_MEM_CLASS_DUMP, detail);
+ cbm_free(CBM_MEM_CLASS_DUMP, path);
+ } else {
+ p->unresolved_rows = rows;
+ p->unresolved_rows[p->unresolved_count++] = (cbm_coverage_row_t){
+ .rel_path = path, .kind = "unresolved_calls", .detail = detail};
+ }
+ }
+ }
+ yyjson_mut_doc_free(doc);
+}
+
+void cbm_pipeline_mark_unresolved_capture_failed(cbm_pipeline_t *p) {
+ if (p)
+ p->unresolved_capture_failed = true;
+}
+
+void cbm_pipeline_get_unresolved_calls(cbm_pipeline_t *p, cbm_coverage_row_t **rows, int *count,
+ bool *complete) {
+ if (rows)
+ *rows = p ? p->unresolved_rows : NULL;
+ if (count)
+ *count = p ? p->unresolved_count : 0;
+ if (complete)
+ *complete = p && !p->unresolved_capture_failed;
+}
+
void cbm_pipeline_free(cbm_pipeline_t *p) {
if (!p) {
return;
@@ -461,6 +558,11 @@ void cbm_pipeline_free(cbm_pipeline_t *p) {
cbm_store_free_lsp_surfaces(p->surface_rows, p->surface_row_count);
p->surface_rows = NULL;
p->surface_row_count = 0;
+ for (int i = 0; i < p->unresolved_count; i++) {
+ cbm_free(CBM_MEM_CLASS_DUMP, (char *)p->unresolved_rows[i].rel_path);
+ cbm_free(CBM_MEM_CLASS_DUMP, (char *)p->unresolved_rows[i].detail);
+ }
+ cbm_free(CBM_MEM_CLASS_DUMP, p->unresolved_rows);
cbm_git_context_free(&p->git_ctx);
/* gbuf, store, registry freed during/after run */
/* Defensively free userconfig in case run() was never called or panicked */
@@ -1469,6 +1571,9 @@ static int run_sequential_pipeline(cbm_pipeline_t *p, cbm_pipeline_ctx_t *ctx,
if (seq_cache) {
for (int i = 0; i < file_count; i++) {
if (seq_cache[i]) {
+ if (rc == 0) {
+ cbm_pipeline_record_unresolved_calls(p, files[i].rel_path, seq_cache[i]);
+ }
cbm_free_result(seq_cache[i]);
}
}
@@ -1694,6 +1799,18 @@ static int run_parallel_pipeline(cbm_pipeline_t *p, cbm_pipeline_ctx_t *ctx,
cbm_clock_gettime(CLOCK_MONOTONIC, t);
rc = cbm_parallel_resolve(ctx, files, file_count, cache, &shared_ids, worker_count, all_defs,
def_count, def_modules, module_def_index, &cross_registries);
+ if (rc == 0) {
+ for (int i = 0; i < file_count; i++) {
+ bool loaded = false;
+ CBMFileResult *result = cbm_pipeline_result_acquire(ctx, cache, i, NULL, &loaded);
+ if (result) {
+ cbm_pipeline_record_unresolved_calls(p, files[i].rel_path, result);
+ } else if (ctx->spill && cbm_result_spill_has(ctx->spill, i)) {
+ cbm_pipeline_mark_unresolved_capture_failed(p);
+ }
+ cbm_pipeline_result_release(result, loaded);
+ }
+ }
cbm_log_info("pass.timing", "pass", "parallel_resolve", "elapsed_ms",
itoa_buf((int)elapsed_ms(*t)));
pipeline_phase_mark("parallel_resolve");
@@ -2497,14 +2614,18 @@ static int dump_and_persist_hashes(cbm_pipeline_t *p, const cbm_file_hash_t *bas
return CBM_PIPELINE_ABORT_PRESERVE_DB;
}
- int cov_total = p->file_errors_count + p->excluded_count + p->ignored_count;
+ int cov_total =
+ p->file_errors_count + p->excluded_count + p->ignored_count + p->unresolved_count;
cbm_coverage_row_t *cov = NULL;
int cov_count = 0;
- bool coverage_rows_available = cov_total == 0;
+ bool coverage_rows_available = cov_total == 0 && !p->unresolved_capture_failed;
if (cov_total > 0) {
cov = malloc((size_t)cov_total * sizeof(*cov));
if (cov) {
- coverage_rows_available = true;
+ coverage_rows_available = !p->unresolved_capture_failed;
+ for (int i = 0; i < p->unresolved_count; i++) {
+ cov[cov_count++] = p->unresolved_rows[i];
+ }
for (int i = 0; i < p->file_errors_count; i++) {
cov[cov_count++] = (cbm_coverage_row_t){.rel_path = p->file_errors[i].path,
.kind = p->file_errors[i].phase,
diff --git a/src/pipeline/pipeline_incremental.c b/src/pipeline/pipeline_incremental.c
index 154518658..f0953764e 100644
--- a/src/pipeline/pipeline_incremental.c
+++ b/src/pipeline/pipeline_incremental.c
@@ -30,6 +30,7 @@ enum { INCR_RING_BUF = 4, INCR_RING_MASK = 3, INCR_TS_BUF = 24 };
#include "foundation/compat_thread.h"
#include "foundation/platform.h"
#include "foundation/sha256.h"
+#include "result_spill.h"
#include <errno.h>
#include <stdlib.h>
@@ -1351,6 +1352,19 @@ static int run_extract_resolve(cbm_pipeline_ctx_t *ctx, cbm_file_info_t *changed
rc = cbm_parallel_resolve(ctx, changed_files, ci, cache, &shared_ids, worker_count,
all_defs, all_def_count, closure ? closure->def_modules : NULL,
module_def_index, registries_arg);
+ if (rc == 0) {
+ for (int i = 0; i < ci; i++) {
+ bool loaded = false;
+ CBMFileResult *result = cbm_pipeline_result_acquire(ctx, cache, i, NULL, &loaded);
+ if (result) {
+ cbm_pipeline_record_unresolved_calls(ctx->pipeline, changed_files[i].rel_path,
+ result);
+ } else if (ctx->spill && cbm_result_spill_has(ctx->spill, i)) {
+ cbm_pipeline_mark_unresolved_capture_failed(ctx->pipeline);
+ }
+ cbm_pipeline_result_release(result, loaded);
+ }
+ }
if (module_def_index) {
cbm_pxc_free_module_def_index(module_def_index);
}
@@ -1401,6 +1415,14 @@ static int run_extract_resolve(cbm_pipeline_ctx_t *ctx, cbm_file_info_t *changed
if (rc == 0) {
rc = cbm_pipeline_pass_semantic(ctx, changed_files, ci);
}
+ if (rc == 0 && cache) {
+ for (int i = 0; i < ci; i++) {
+ if (cache[i]) {
+ cbm_pipeline_record_unresolved_calls(ctx->pipeline, changed_files[i].rel_path,
+ cache[i]);
+ }
+ }
+ }
if (rc == 0) {
rc = cbm_pipeline_check_cancel(ctx);
}
@@ -2237,11 +2259,17 @@ static int run_closure_delta(cbm_pipeline_t *p, const char *db_path, const char
int run_ignored_count = 0;
int run_ignored_total = 0;
cbm_pipeline_get_ignored(p, &run_ignored, &run_ignored_count, &run_ignored_total);
- int cov_cap = old_cov_count + run_err_count + run_excluded_count + run_ignored_count;
- bool coverage_rows_available = cov_cap == 0;
+ cbm_coverage_row_t *run_unresolved = NULL;
+ int run_unresolved_count = 0;
+ bool unresolved_complete = false;
+ cbm_pipeline_get_unresolved_calls(p, &run_unresolved, &run_unresolved_count,
+ &unresolved_complete);
+ int cov_cap = old_cov_count + run_err_count + run_excluded_count + run_ignored_count +
+ run_unresolved_count;
+ bool coverage_rows_available = cov_cap == 0 && unresolved_complete;
if (cov_cap > 0) {
cov = (cbm_coverage_row_t *)malloc((size_t)cov_cap * sizeof(*cov));
- coverage_rows_available = cov != NULL;
+ coverage_rows_available = cov != NULL && unresolved_complete;
}
if (cov) {
for (int i = 0; i < old_cov_count; i++) {
@@ -2257,6 +2285,9 @@ static int run_closure_delta(cbm_pipeline_t *p, const char *db_path, const char
cov[cov_n].detail = run_errs[i].reason;
cov_n++;
}
+ for (int i = 0; i < run_unresolved_count; i++) {
+ cov[cov_n++] = run_unresolved[i];
+ }
for (int i = 0; i < run_excluded_count; i++) {
cov[cov_n].rel_path = run_excluded[i];
cov[cov_n].kind = "not_indexed_dir";
@@ -2810,11 +2841,17 @@ int cbm_pipeline_run_incremental(cbm_pipeline_t *p, const char *db_path, cbm_fil
cbm_pipeline_get_ignored(p, &run_ignored, &run_ignored_count, &run_ignored_total);
cbm_coverage_row_t *cov = NULL;
int cov_n = 0;
- int cov_cap = old_cov_count + run_err_count + run_excluded_count + run_ignored_count;
+ cbm_coverage_row_t *run_unresolved = NULL;
+ int run_unresolved_count = 0;
+ bool unresolved_complete = false;
+ cbm_pipeline_get_unresolved_calls(p, &run_unresolved, &run_unresolved_count,
+ &unresolved_complete);
+ int cov_cap = old_cov_count + run_err_count + run_excluded_count + run_ignored_count +
+ run_unresolved_count;
if (cov_cap > 0) {
cov = (cbm_coverage_row_t *)malloc((size_t)cov_cap * sizeof(*cov));
}
- bool coverage_rows_available = cov_cap == 0 || cov != NULL;
+ bool coverage_rows_available = (cov_cap == 0 || cov != NULL) && unresolved_complete;
if (cov) {
CBMHashTable *changed_set = cbm_ht_create(ci > 0 ? (size_t)ci * PAIR_LEN : CBM_SZ_64);
for (int i = 0; i < ci; i++) {
@@ -2834,6 +2871,9 @@ int cbm_pipeline_run_incremental(cbm_pipeline_t *p, const char *db_path, cbm_fil
cov[cov_n].detail = run_errs[i].reason;
cov_n++;
}
+ for (int i = 0; i < run_unresolved_count; i++) {
+ cov[cov_n++] = run_unresolved[i];
+ }
for (int i = 0; i < run_excluded_count; i++) {
cov[cov_n].rel_path = run_excluded[i];
cov[cov_n].kind = "not_indexed_dir";
diff --git a/src/pipeline/pipeline_internal.h b/src/pipeline/pipeline_internal.h
index e7782adef..182241eca 100644
--- a/src/pipeline/pipeline_internal.h
+++ b/src/pipeline/pipeline_internal.h
@@ -789,7 +789,7 @@ int cbm_pipeline_build_fresh_semantic_manifest(cbm_pipeline_t *p, const char *pr
/* Compatibility contract persisted in coverage metadata. Increment when a
* graph/manifest semantic change makes prior exact-input indexes unsafe. */
-enum { CBM_SEMANTIC_INDEX_VERSION = 3 };
+enum { CBM_SEMANTIC_INDEX_VERSION = CBM_UNRESOLVED_CALL_COVERAGE_VERSION };
typedef struct {
cbm_gbuf_t *gbuf;
@@ -874,6 +874,11 @@ void cbm_pipeline_discard_stage(const char *stage_path);
* Takes ownership; dump_and_persist_hashes writes them into the staging
* store and cbm_pipeline_free releases them. Passing NULL/0 clears. */
void cbm_pipeline_set_lsp_surfaces(cbm_pipeline_t *p, cbm_lsp_surface_row_t *rows, int count);
+void cbm_pipeline_record_unresolved_calls(cbm_pipeline_t *p, const char *rel_path,
+ const CBMFileResult *result);
+void cbm_pipeline_mark_unresolved_capture_failed(cbm_pipeline_t *p);
+void cbm_pipeline_get_unresolved_calls(cbm_pipeline_t *p, cbm_coverage_row_t **rows, int *count,
+ bool *complete);
/* Pipeline accessors for incremental use */
const char *cbm_pipeline_repo_path(const cbm_pipeline_t *p);
diff --git a/src/store/store.c b/src/store/store.c
index 558f974d2..5b1936dba 100644
--- a/src/store/store.c
+++ b/src/store/store.c
@@ -329,6 +329,8 @@ static int init_schema(cbm_store_t *s) {
" detail TEXT DEFAULT '',"
" PRIMARY KEY (project, rel_path, kind)"
");"
+ "CREATE INDEX IF NOT EXISTS idx_index_coverage_project_kind "
+ "ON index_coverage(project, kind);"
/* One row per completed coverage persistence attempt. Kept separate
* from projects so existing graph/artifact schema stays compatible and
* a missing row unambiguously means coverage metadata is unavailable. */
@@ -4215,6 +4217,14 @@ int cbm_store_coverage_get_scope(cbm_store_t *s, const char *project, const char
return coverage_query_rows(s, project, scope, sql, out, count);
}
+int cbm_store_coverage_get_unresolved_calls(cbm_store_t *s, const char *project,
+ cbm_coverage_row_t **out, int *count) {
+ static const char sql[] = "SELECT rel_path, kind, detail FROM index_coverage "
+ "WHERE project = ?1 AND kind = ?2 "
+ "ORDER BY rel_path;";
+ return coverage_query_rows(s, project, "unresolved_calls", sql, out, count);
+}
+
void cbm_store_coverage_meta_clear(cbm_coverage_meta_t *meta) {
if (!meta) {
return;
diff --git a/src/store/store.h b/src/store/store.h
index b6ce844f7..82489255e 100644
--- a/src/store/store.h
+++ b/src/store/store.h
@@ -639,7 +639,9 @@ int cbm_store_delete_file_hashes(cbm_store_t *s, const char *project);
/* One best-effort coverage row: a file the indexer could not fully cover.
* kind "parse_partial" = indexed but the parse tree had ERROR/MISSING regions
* (detail = 1-based line ranges "12-40,88-90"); skip kinds "read"/"extract"/
- * "oversized" = not indexed at all (detail = reason). Stored in the separate
+ * "oversized" = not indexed at all (detail = reason). "unresolved_calls" is
+ * indexed source whose invocation targets were not resolved (detail = JSON
+ * array of caller, leaf, source byte span, and reason). Stored in the separate
* index_coverage table — coverage is metadata ABOUT the graph, never mixed
* into the graph itself. */
typedef struct {
@@ -648,6 +650,10 @@ typedef struct {
const char *detail;
} cbm_coverage_row_t;
+/* Older generations have no unresolved-call records, so their exact trace
+ * totals cannot be trusted after this signal becomes part of coverage. */
+enum { CBM_UNRESOLVED_CALL_COVERAGE_VERSION = 4 };
+
/* Metadata describing how completely one index run recorded the best-effort
* coverage signal. `recording_status` is "complete", "truncated", or
* "unavailable"; it is deliberately separate from hash_records_complete.
@@ -690,6 +696,9 @@ int cbm_store_coverage_get_path(cbm_store_t *s, const char *project, const char
* ancestor that covers the scope. Prefix matching is segment-boundary safe. */
int cbm_store_coverage_get_scope(cbm_store_t *s, const char *project, const char *scope,
cbm_coverage_row_t **out, int *count);
+/* Fetch only unresolved invocation diagnostics for trace exactness checks. */
+int cbm_store_coverage_get_unresolved_calls(cbm_store_t *s, const char *project,
+ cbm_coverage_row_t **out, int *count);
/* Fetch/free the metadata paired with the current coverage row set. */
int cbm_store_coverage_meta_get(cbm_store_t *s, const char *project, cbm_coverage_meta_t *out);
diff --git a/tests/test_mcp.c b/tests/test_mcp.c
index 60649f505..02cb9db01 100644
--- a/tests/test_mcp.c
+++ b/tests/test_mcp.c
@@ -5971,9 +5971,9 @@ TEST(tool_check_index_coverage_freshness_uses_indexer_mtime_source_issue1714) {
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);
+ ASSERT_EQ(
+ cbm_store_upsert_file_hash(store, "test-project", "main.go", "", info.mtime_ns, info.size),
+ CBM_STORE_OK);
/* format=json, like every other coverage test here: the DEFAULT response is
* the compact table, in which a field name never appears. Keeping the
@@ -5990,11 +5990,11 @@ TEST(tool_check_index_coverage_freshness_uses_indexer_mtime_source_issue1714) {
/* 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;
+ 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),
+ 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\"],"
@@ -6638,6 +6638,13 @@ TEST(tool_trace_budget_never_slices_identifiers) {
const char *project = "trace-byte-budget";
cbm_mcp_server_set_project(srv, project);
ASSERT_EQ(cbm_store_upsert_project(store, project, "/tmp/trace-byte-budget"), CBM_STORE_OK);
+ cbm_coverage_meta_t coverage_meta = {.generation = "fixture",
+ .index_mode = "full",
+ .recorded_at = "2026-09-24T00:00:00Z",
+ .recording_status = "complete",
+ .coverage_version = CBM_UNRESOLVED_CALL_COVERAGE_VERSION,
+ .hash_records_complete = true};
+ ASSERT_EQ(cbm_store_coverage_replace_ex(store, project, NULL, 0, &coverage_meta), CBM_STORE_OK);
cbm_node_t hub = {.project = project,
.label = "Function",
@@ -6983,6 +6990,13 @@ TEST(tool_trace_reports_engine_saturation_as_lower_bound) {
const char *project = "trace-engine-cap";
cbm_mcp_server_set_project(srv, project);
ASSERT_EQ(cbm_store_upsert_project(store, project, "/tmp/trace-engine-cap"), CBM_STORE_OK);
+ cbm_coverage_meta_t coverage_meta = {.generation = "fixture",
+ .index_mode = "full",
+ .recorded_at = "2026-09-24T00:00:00Z",
+ .recording_status = "complete",
+ .coverage_version = CBM_UNRESOLVED_CALL_COVERAGE_VERSION,
+ .hash_records_complete = true};
+ ASSERT_EQ(cbm_store_coverage_replace_ex(store, project, NULL, 0, &coverage_meta), CBM_STORE_OK);
cbm_node_t hub = {.project = project,
.label = "Function",
.name = "hub",
@@ -7412,6 +7426,92 @@ TEST(tool_trace_path_evidence_is_opt_in_and_class_mapped) {
PASS();
}
+TEST(tool_trace_path_marks_unresolved_call_totals_unknown) {
+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
+ cbm_store_t *st = cbm_mcp_server_store(srv);
+ const char *proj = "unresolved-trace";
+ cbm_mcp_server_set_project(srv, proj);
+ cbm_store_upsert_project(st, proj, "/tmp/unresolved-trace");
+ cbm_node_t caller = {.project = proj,
+ .label = "Function",
+ .name = "run",
+ .qualified_name = "unresolved-trace.service.run",
+ .file_path = "service.js",
+ .start_line = 1,
+ .end_line = 4};
+ cbm_node_t callee = {.project = proj,
+ .label = "Function",
+ .name = "buscar",
+ .qualified_name = "unresolved-trace.client.buscar",
+ .file_path = "client.js",
+ .start_line = 1,
+ .end_line = 2};
+ ASSERT_GT(cbm_store_upsert_node(st, &caller), 0);
+ ASSERT_GT(cbm_store_upsert_node(st, &callee), 0);
+ ASSERT_EQ(cbm_store_upsert_file_hash(st, proj, "service.js", "fixture", 0, 0), CBM_STORE_OK);
+ char *out = cbm_mcp_server_handle(
+ srv, "{\"jsonrpc\":\"2.0\",\"id\":0,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_path\",\"arguments\":{\"project\":"
+ "\"unresolved-trace\",\"function_name\":\"run\",\"direction\":\"outbound\","
+ "\"format\":\"json\"}}}");
+ char *txt = extract_text_content(out);
+ ASSERT_NOT_NULL(strstr(txt, "\"callees_total_relation\":\"unknown\""));
+ free(txt);
+ free(out);
+ cbm_coverage_row_t row = {
+ .rel_path = "service.js",
+ .kind = "unresolved_calls",
+ .detail = "[{\"caller\":\"unresolved-trace.service.run\",\"leaf\":\"buscar\","
+ "\"start_byte\":42,\"end_byte\":59,\"reason\":\"method_not_in_registry\"}]"};
+ cbm_coverage_meta_t meta = {.generation = "fixture",
+ .index_mode = "full",
+ .recorded_at = "2026-09-24T00:00:00Z",
+ .recording_status = "complete",
+ .coverage_version = CBM_UNRESOLVED_CALL_COVERAGE_VERSION,
+ .hash_records_complete = true};
+ ASSERT_EQ(cbm_store_coverage_replace_ex(st, proj, &row, 1, &meta), CBM_STORE_OK);
+
+ out = cbm_mcp_server_handle(
+ srv, "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_path\",\"arguments\":{\"project\":"
+ "\"unresolved-trace\",\"function_name\":\"run\",\"direction\":\"outbound\","
+ "\"format\":\"json\"}}}");
+ txt = extract_text_content(out);
+ ASSERT_NOT_NULL(strstr(txt, "\"callees_total_relation\":\"unknown\""));
+ free(txt);
+ free(out);
+ out = cbm_mcp_server_handle(
+ srv, "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_path\",\"arguments\":{\"project\":"
+ "\"unresolved-trace\",\"function_name\":\"buscar\",\"direction\":\"inbound\","
+ "\"format\":\"json\"}}}");
+ txt = extract_text_content(out);
+ ASSERT_NOT_NULL(strstr(txt, "\"callers_total_relation\":\"unknown\""));
+ free(txt);
+ free(out);
+ out = cbm_mcp_server_handle(
+ srv, "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"check_index_coverage\",\"arguments\":{\"project\":"
+ "\"unresolved-trace\",\"paths\":[\"service.js\"],\"diagnostics\":\"full\","
+ "\"format\":\"json\"}}}");
+ txt = extract_text_content(out);
+ ASSERT_NOT_NULL(strstr(txt, "\"status\":\"unresolved_calls\""));
+ ASSERT_NOT_NULL(strstr(txt, "method_not_in_registry"));
+ free(txt);
+ free(out);
+ out = cbm_mcp_server_handle(
+ srv, "{\"jsonrpc\":\"2.0\",\"id\":4,\"method\":\"tools/call\","
+ "\"params\":{\"name\":\"trace_path\",\"arguments\":{\"project\":"
+ "\"unresolved-trace\",\"function_name\":\"run\",\"direction\":\"outbound\","
+ "\"edge_types\":[\"IMPORTS\"],\"format\":\"json\"}}}");
+ txt = extract_text_content(out);
+ ASSERT_NOT_NULL(strstr(txt, "\"callees_total_relation\":\"eq\""));
+ free(txt);
+ free(out);
+ cbm_mcp_server_free(srv);
+ PASS();
+}
+
/* Edge-data lookup must follow the traversal direction and shortest-path hop.
* The induced edge set contains a same-hop cross edge whose source is the row
* node and sorts before its real inbound predecessor. An arbitrary incident-
@@ -20640,6 +20740,7 @@ SUITE(mcp) {
RUN_TEST(tool_trace_call_path_prefers_definition);
RUN_TEST(trace_evidence_strategy_class_vocabulary_is_closed);
RUN_TEST(tool_trace_path_evidence_is_opt_in_and_class_mapped);
+ RUN_TEST(tool_trace_path_marks_unresolved_call_totals_unknown);
RUN_TEST(tool_trace_path_evidence_columns_match_header_issue1542);
RUN_TEST(tool_trace_path_unreadable_confidence_reports_not_recorded);
RUN_TEST(tool_trace_path_edge_details_use_canonical_predecessor);
diff --git a/tests/test_pipeline.c b/tests/test_pipeline.c
index 568740f17..9a072cd83 100644
--- a/tests/test_pipeline.c
+++ b/tests/test_pipeline.c
@@ -765,6 +765,98 @@ TEST(pipeline_adr_survives_full_reindex) {
PASS();
}
+TEST(pipeline_records_unresolved_injected_call_sites) {
+ char tmp[256] = "/tmp/cbm_unresolved_calls_XXXXXX";
+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
+ char db_path[512], path[512];
+ snprintf(db_path, sizeof(db_path), "%s/test.db", tmp);
+ snprintf(path, sizeof(path), "%s/cliente.js", tmp);
+ FILE *f = fopen(path, "w");
+ ASSERT_NOT_NULL(f);
+ fputs("export function crearCliente() { function buscar(id) { return id; } "
+ "return { buscar }; }\n",
+ f);
+ fclose(f);
+ snprintf(path, sizeof(path), "%s/servicio.js", tmp);
+ f = fopen(path, "w");
+ ASSERT_NOT_NULL(f);
+ fputs("export function crearServicio({ cliente }) {\n"
+ " function procesar(id) { return cliente.buscar(id); }\n"
+ " return { procesar };\n}\n",
+ f);
+ fclose(f);
+
+ cbm_pipeline_t *p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);
+ ASSERT_NOT_NULL(p);
+ ASSERT_EQ(cbm_pipeline_run(p), 0);
+ char project[256];
+ snprintf(project, sizeof(project), "%s", cbm_pipeline_project_name(p));
+ cbm_pipeline_free(p);
+ cbm_store_t *st = cbm_store_open_path(db_path);
+ ASSERT_NOT_NULL(st);
+ cbm_coverage_row_t *rows = NULL;
+ int count = 0;
+ ASSERT_EQ(cbm_store_coverage_get_path(st, project, "servicio.js", &rows, &count), CBM_STORE_OK);
+ bool found = false;
+ for (int i = 0; i < count; i++) {
+ if (strcmp(rows[i].kind, "unresolved_calls") == 0 && strstr(rows[i].detail, "buscar") &&
+ strstr(rows[i].detail, "method_not_in_registry")) {
+ found = true;
+ }
+ }
+ ASSERT_TRUE(found);
+ cbm_store_free_coverage(rows, count);
+ cbm_store_close(st);
+
+ /* Reindexing another file must retain this file's diagnostic. */
+ snprintf(path, sizeof(path), "%s/cliente.js", tmp);
+ f = fopen(path, "a");
+ ASSERT_NOT_NULL(f);
+ fputs("\n// unrelated edit\n", f);
+ fclose(f);
+ p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);
+ ASSERT_NOT_NULL(p);
+ ASSERT_EQ(cbm_pipeline_run(p), 0);
+ cbm_pipeline_free(p);
+ st = cbm_store_open_path(db_path);
+ ASSERT_NOT_NULL(st);
+ rows = NULL;
+ count = 0;
+ ASSERT_EQ(cbm_store_coverage_get_path(st, project, "servicio.js", &rows, &count), CBM_STORE_OK);
+ found = false;
+ for (int i = 0; i < count; i++) {
+ found |= strcmp(rows[i].kind, "unresolved_calls") == 0;
+ }
+ ASSERT_TRUE(found);
+ cbm_store_free_coverage(rows, count);
+ cbm_store_close(st);
+
+ /* The edited file must lose its old diagnostic on the next generation. */
+ snprintf(path, sizeof(path), "%s/servicio.js", tmp);
+ f = fopen(path, "w");
+ ASSERT_NOT_NULL(f);
+ fputs(
+ "export function crearServicio({ cliente }) { return { procesar(id) { return id; } }; }\n",
+ f);
+ fclose(f);
+ p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);
+ ASSERT_NOT_NULL(p);
+ ASSERT_EQ(cbm_pipeline_run(p), 0);
+ cbm_pipeline_free(p);
+ st = cbm_store_open_path(db_path);
+ ASSERT_NOT_NULL(st);
+ rows = NULL;
+ count = 0;
+ ASSERT_EQ(cbm_store_coverage_get_path(st, project, "servicio.js", &rows, &count), CBM_STORE_OK);
+ for (int i = 0; i < count; i++) {
+ ASSERT_FALSE(strcmp(rows[i].kind, "unresolved_calls") == 0);
+ }
+ cbm_store_free_coverage(rows, count);
+ cbm_store_close(st);
+ rm_rf(tmp);
+ PASS();
+}
+
TEST(pipeline_structure_edges) {
if (setup_test_repo() != 0) {
FAIL("failed to create temp dir");
@@ -15846,6 +15938,7 @@ SUITE(pipeline) {
RUN_TEST(pipeline_committed_counts_match_persisted);
RUN_TEST(pipeline_adr_survives_full_reindex);
RUN_TEST(pipeline_export_error_snapshot_on_artifact_failure);
+ RUN_TEST(pipeline_records_unresolved_injected_call_sites);
RUN_TEST(pipeline_structure_edges);
RUN_TEST(pipeline_branch_root_structure);
RUN_TEST(pipeline_project_name_derived);