feat(pipeline): resolve relative import paths for IMPORTS edge creation

Root cause: cbm_pipeline_fqn_module() received raw import paths like
'./utils/trace' or '../controllers/auth' and converted them directly to QNs
without resolving against the importing file's directory. The resulting QN
never matched any Module node, so IMPORTS edges were silently dropped.

New function cbm_pipeline_resolve_import_path() in fqn.c:
- Resolves ./ and ../ segments against the importer's directory
- Normalizes path (collapses a/b/../c → a/c)
- Bare module specifiers (no ./ prefix) pass through unchanged

Extension probing in pass_parallel.c and pass_definitions.c:
- After resolving the path, tries exact match first
- Then probes: .js, .ts, .tsx, .jsx, .mjs, .mts, .css, .scss, .json
- Then probes /index variants: /index.js, /index.ts, /index.tsx, etc.
- Then probes C/C++ headers: .h, .hpp, .hh

Results:
- JS service: 0 → 335 IMPORTS edges
- TS monolith: 153 → 11,770 IMPORTS edges (77x increase)
- TS/React monorepo: 0 → 344 IMPORTS edges
- TS/Electron app: 1 → 161 IMPORTS edges

Author: Your Name

src/pipeline/fqn.c

@@ -158,6 +158,91 @@ char *cbm_pipeline_fqn_folder(const char *project, const char *rel_dir) {
     return result;
 }
 
+/**
+ * Resolve an import module_path relative to the importing file's directory.
+ *
+ * For relative paths (starting with ./ or ../), resolves against the importer's
+ * directory. For bare module specifiers (no ./ prefix), returns a copy unchanged.
+ *
+ * Examples (importer_rel_path="src/routes/api.js"):
+ *   "./controllers/auth"     → "src/routes/controllers/auth"
+ *   "../utils/helpers"       → "src/utils/helpers"
+ *   "lodash"                 → "lodash" (bare module, unchanged)
+ *   "@hapi/hapi"             → "@hapi/hapi" (scoped package, unchanged)
+ *
+ * Returns: heap-allocated resolved path. Caller must free().
+ */
+char *cbm_pipeline_resolve_import_path(const char *importer_rel_path, const char *module_path) {
+    if (!module_path || !module_path[0]) {
+        return strdup("");
+    }
+
+    /* Bare module specifier — no relative path resolution needed */
+    if (module_path[0] != '.') {
+        return strdup(module_path);
+    }
+
+    /* Get the importing file's directory */
+    char *importer_dir = strdup(importer_rel_path ? importer_rel_path : "");
+    cbm_normalize_path_sep(importer_dir);
+    char *last_slash = strrchr(importer_dir, '/');
+    if (last_slash) {
+        *(last_slash + 1) = '\0'; /* keep trailing slash */
+    } else {
+        importer_dir[0] = '\0'; /* file is at root */
+    }
+
+    /* Concatenate: importer_dir + module_path */
+    size_t dir_len = strlen(importer_dir);
+    size_t mod_len = strlen(module_path);
+    char *combined = malloc(dir_len + mod_len + 2);
+    snprintf(combined, dir_len + mod_len + 2, "%s%s", importer_dir, module_path);
+    free(importer_dir);
+
+    /* Normalize: resolve . and .. segments */
+    cbm_normalize_path_sep(combined);
+    const char *segments[256];
+    int seg_count = 0;
+
+    char *tok = combined;
+    while (tok && *tok) {
+        char *slash = strchr(tok, '/');
+        if (slash) *slash = '\0';
+
+        if (strcmp(tok, ".") == 0) {
+            /* skip */
+        } else if (strcmp(tok, "..") == 0) {
+            if (seg_count > 0) seg_count--; /* pop parent */
+        } else if (tok[0] != '\0') {
+            if (seg_count < 255) {
+                segments[seg_count++] = tok;
+            }
+        }
+
+        tok = slash ? slash + 1 : NULL;
+    }
+
+    /* Rebuild path */
+    if (seg_count == 0) {
+        free(combined);
+        return strdup("");
+    }
+
+    size_t total = 0;
+    for (int i = 0; i < seg_count; i++) {
+        total += strlen(segments[i]) + 1;
+    }
+    char *result = malloc(total + 1);
+    result[0] = '\0';
+    for (int i = 0; i < seg_count; i++) {
+        if (i > 0) strcat(result, "/");
+        strcat(result, segments[i]);
+    }
+
+    free(combined);
+    return result;
+}
+
 char *cbm_project_name_from_path(const char *abs_path) {
     if (!abs_path || !abs_path[0]) {
         return strdup("root");

src/pipeline/pass_definitions.c

@@ -288,28 +288,76 @@ int cbm_pipeline_pass_definitions(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t
         total_imports += result->imports.count;
 
         /* Store per-file import map for later use by pass_calls.
-         * For each import, create an IMPORTS edge: File → imported module. */
-        for (int j = 0; j < result->imports.count; j++) {
-            CBMImport *imp = &result->imports.items[j];
-            if (!imp->module_path) {
-                continue;
-            }
-
-            /* Find or create the target module node */
-            char *target_qn = cbm_pipeline_fqn_module(ctx->project_name, imp->module_path);
-            const cbm_gbuf_node_t *target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
-
+         * For each import, create an IMPORTS edge: File → imported module.
+         * Resolve relative paths (./ ../) and probe common extensions. */
+        {
             char *file_qn = cbm_pipeline_fqn_compute(ctx->project_name, rel, "__file__");
             const cbm_gbuf_node_t *source_node = cbm_gbuf_find_by_qn(ctx->gbuf, file_qn);
+            free(file_qn);
+
+            for (int j = 0; j < result->imports.count && source_node; j++) {
+                CBMImport *imp = &result->imports.items[j];
+                if (!imp->module_path) {
+                    continue;
+                }
+
+                /* Resolve relative paths against importing file's directory */
+                char *resolved = cbm_pipeline_resolve_import_path(rel, imp->module_path);
+                char *target_qn = cbm_pipeline_fqn_module(ctx->project_name, resolved);
+                const cbm_gbuf_node_t *target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
+
+                /* Probe common extensions */
+                if (!target) {
+                    static const char *exts[] = {
+                        ".js", ".ts", ".tsx", ".jsx", ".mjs", ".mts",
+                        ".css", ".scss", ".json", NULL
+                    };
+                    for (int e = 0; !target && exts[e]; e++) {
+                        char buf[2048];
+                        snprintf(buf, sizeof(buf), "%s%s", resolved, exts[e]);
+                        free(target_qn);
+                        target_qn = cbm_pipeline_fqn_module(ctx->project_name, buf);
+                        target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
+                    }
+                }
 
-            if (source_node && target) {
-                char imp_props[256];
-                snprintf(imp_props, sizeof(imp_props), "{\"local_name\":\"%s\"}",
-                         imp->local_name ? imp->local_name : "");
-                cbm_gbuf_insert_edge(ctx->gbuf, source_node->id, target->id, "IMPORTS", imp_props);
+                /* Probe /index variants */
+                if (!target) {
+                    static const char *idx[] = {
+                        "/index.js", "/index.ts", "/index.tsx", "/index.jsx",
+                        "/index.mjs", "/index", NULL
+                    };
+                    for (int e = 0; !target && idx[e]; e++) {
+                        char buf[2048];
+                        snprintf(buf, sizeof(buf), "%s%s", resolved, idx[e]);
+                        free(target_qn);
+                        target_qn = cbm_pipeline_fqn_module(ctx->project_name, buf);
+                        target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
+                    }
+                }
+
+                /* C/C++ include: try .h, .hpp */
+                if (!target) {
+                    static const char *hdr[] = {".h", ".hpp", ".hh", NULL};
+                    for (int e = 0; !target && hdr[e]; e++) {
+                        char buf[2048];
+                        snprintf(buf, sizeof(buf), "%s%s", resolved, hdr[e]);
+                        free(target_qn);
+                        target_qn = cbm_pipeline_fqn_module(ctx->project_name, buf);
+                        target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
+                    }
+                }
+
+                if (target) {
+                    char imp_props[256];
+                    snprintf(imp_props, sizeof(imp_props), "{\"local_name\":\"%s\"}",
+                             imp->local_name ? imp->local_name : "");
+                    cbm_gbuf_insert_edge(ctx->gbuf, source_node->id, target->id, "IMPORTS",
+                                         imp_props);
+                }
+                free(target_qn);
+                free(resolved);
             }
-            free(target_qn);
-            free(file_qn);
         }
 
         /* Cache or free the extraction result */

src/pipeline/pass_parallel.c

@@ -953,28 +953,73 @@ int cbm_build_registry_from_cache(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t
             }
         }
 
-        /* IMPORTS edges */
-        for (int j = 0; j < result->imports.count; j++) {
+        /* IMPORTS edges — resolve relative paths and probe extensions */
+        char *file_qn = cbm_pipeline_fqn_compute(ctx->project_name, rel, "__file__");
+        const cbm_gbuf_node_t *source_node = cbm_gbuf_find_by_qn(ctx->gbuf, file_qn);
+        free(file_qn);
+
+        for (int j = 0; j < result->imports.count && source_node; j++) {
             CBMImport *imp = &result->imports.items[j];
             if (!imp->module_path) {
                 continue;
             }
 
-            char *target_qn = cbm_pipeline_fqn_module(ctx->project_name, imp->module_path);
+            /* Resolve relative paths (./ ../) against importing file's directory */
+            char *resolved = cbm_pipeline_resolve_import_path(rel, imp->module_path);
+            char *target_qn = cbm_pipeline_fqn_module(ctx->project_name, resolved);
             const cbm_gbuf_node_t *target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
 
-            char *file_qn = cbm_pipeline_fqn_compute(ctx->project_name, rel, "__file__");
-            const cbm_gbuf_node_t *source_node = cbm_gbuf_find_by_qn(ctx->gbuf, file_qn);
+            /* Probe common extensions if no exact match: .js, .ts, .tsx, .jsx, .mjs */
+            if (!target) {
+                static const char *exts[] = {
+                    ".js", ".ts", ".tsx", ".jsx", ".mjs", ".mts",
+                    ".css", ".scss", ".json", NULL
+                };
+                for (int e = 0; !target && exts[e]; e++) {
+                    char buf[2048];
+                    snprintf(buf, sizeof(buf), "%s%s", resolved, exts[e]);
+                    free(target_qn);
+                    target_qn = cbm_pipeline_fqn_module(ctx->project_name, buf);
+                    target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
+                }
+            }
 
-            if (source_node && target) {
+            /* Probe /index variants (directory imports) */
+            if (!target) {
+                static const char *idx[] = {
+                    "/index.js", "/index.ts", "/index.tsx", "/index.jsx",
+                    "/index.mjs", "/index", NULL
+                };
+                for (int e = 0; !target && idx[e]; e++) {
+                    char buf[2048];
+                    snprintf(buf, sizeof(buf), "%s%s", resolved, idx[e]);
+                    free(target_qn);
+                    target_qn = cbm_pipeline_fqn_module(ctx->project_name, buf);
+                    target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
+                }
+            }
+
+            /* C/C++ include: try .h, .hpp variants */
+            if (!target && (resolved[0] != '.' || resolved[1] == '.')) {
+                static const char *hdr[] = {".h", ".hpp", ".hh", NULL};
+                for (int e = 0; !target && hdr[e]; e++) {
+                    char buf[2048];
+                    snprintf(buf, sizeof(buf), "%s%s", resolved, hdr[e]);
+                    free(target_qn);
+                    target_qn = cbm_pipeline_fqn_module(ctx->project_name, buf);
+                    target = cbm_gbuf_find_by_qn(ctx->gbuf, target_qn);
+                }
+            }
+
+            if (target) {
                 char imp_props[256];
                 snprintf(imp_props, sizeof(imp_props), "{\"local_name\":\"%s\"}",
                          imp->local_name ? imp->local_name : "");
                 cbm_gbuf_insert_edge(ctx->gbuf, source_node->id, target->id, "IMPORTS", imp_props);
                 imports_edges++;
             }
             free(target_qn);
-            free(file_qn);
+            free(resolved);
         }
     }
 

src/pipeline/pipeline.h

@@ -82,6 +82,10 @@ char *cbm_pipeline_fqn_module(const char *project, const char *rel_path);
 /* Folder QN: project.dir.parts. Caller must free(). */
 char *cbm_pipeline_fqn_folder(const char *project, const char *rel_dir);
 
+/* Resolve an import module_path relative to the importing file's directory.
+ * Handles ./ and ../ resolution. Bare modules returned unchanged. Caller must free(). */
+char *cbm_pipeline_resolve_import_path(const char *importer_rel_path, const char *module_path);
+
 /* Derive project name from an absolute path.
  * Replaces / and : with -, collapses --, trims leading -.
  * Caller must free() the returned string. */