fix(mcp+extraction): C# class has_method + C# channel detection

Fix A — Class node 0-degree early exit:
The crash guard that returns early for nodes with 0 CALLS edges was
incorrectly catching Class/Interface nodes that have DEFINES_METHOD and
INHERITS edges (cbm_store_node_degree only counts CALLS). Re-add the
is_class_like exemption so Class nodes always proceed to DEFINES_METHOD
resolution. Cap method resolution to 5 methods to prevent excessive BFS.

Fix A2 — has_method uses Class node ID:
The DEFINES_METHOD BFS was using method start_ids (from class resolution)
as the BFS root, but DEFINES_METHOD edges go FROM the Class TO Methods.
Use the original Class node ID for the has_method query.
Result: 30 methods found (GitNexus: 29), extends chain shown.

Fix B1 — Add .cs to channel detection file filter:
Channel detection SQL now includes .cs files alongside JS/TS/Python.

Fix B2 — C# channel extraction with constant resolution:
New cbm_extract_csharp_channels() in httplink.c that handles:
- const string CONSTANT = "value" → builds name-to-value map
- .Emit(CONSTANT, ...) → resolves to string value, marks as emit
- .OnRequest<T>(CONSTANT, ...) → resolves to string value, marks as listen
- .Emit("literal", ...) → direct string literal matching
Result: 73 channel references, 35 unique channels in C# repo (was 0).

Author: Your Name

src/mcp/mcp.c

@@ -1774,11 +1774,14 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
         cbm_store_find_edges_by_source_type(store, nodes[best_idx].id, "DEFINES_METHOD",
                                             &dm_edges, &dm_count);
         if (dm_count > 0) {
-            start_ids = malloc((size_t)dm_count * sizeof(int64_t));
-            for (int i = 0; i < dm_count; i++) {
+            /* Cap at 5 methods to prevent excessive BFS calls (each method
+             * spawns ~6 BFS queries across edge type categories) */
+            int use_count = dm_count > 5 ? 5 : dm_count;
+            start_ids = malloc((size_t)use_count * sizeof(int64_t));
+            for (int i = 0; i < use_count; i++) {
                 start_ids[i] = dm_edges[i].target_id;
             }
-            start_id_count = dm_count;
+            start_id_count = use_count;
         }
         /* Free edge data */
         for (int i = 0; i < dm_count; i++) {
@@ -1842,8 +1845,11 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
         int in_deg = 0;
         int out_deg = 0;
         cbm_store_node_degree(store, nodes[best_idx].id, &in_deg, &out_deg);
-        if (in_deg == 0 && out_deg == 0) {
-            /* No edges — return basic info */
+        if (in_deg == 0 && out_deg == 0 && !is_class_like) {
+            /* No CALLS edges and not a Class — return basic info.
+             * Class/Interface nodes skip this check because they have
+             * DEFINES_METHOD and INHERITS edges that aren't counted by
+             * cbm_store_node_degree (which only counts CALLS). */
             char *json = yy_doc_to_str(doc);
             yyjson_mut_doc_free(doc);
             free(start_ids);
@@ -2013,12 +2019,14 @@ static char *handle_trace_call_path(cbm_mcp_server_t *srv, const char *args) {
             yyjson_mut_obj_add_val(doc, outgoing, "calls", calls_arr);
         }
 
-        /* Outgoing DEFINES_METHOD (for Classes) */
+        /* Outgoing DEFINES_METHOD (for Classes).
+         * Use the original Class node ID, not start_ids (which are method IDs).
+         * DEFINES_METHOD edges go FROM the Class TO its Methods. */
         {
             int saved_tr = tr_count;
-            for (int s = 0; s < start_id_count && tr_count < MAX_TR; s++) {
+            if (is_class_like && tr_count < MAX_TR) {
                 const char *dm_types[] = {"DEFINES_METHOD"};
-                cbm_store_bfs(store, start_ids[s], "outbound", dm_types, 1, 1, EDGE_QUERY_MAX,
+                cbm_store_bfs(store, nodes[best_idx].id, "outbound", dm_types, 1, 1, 30,
                               &all_tr[tr_count]);
                 tr_count++;
             }

src/pipeline/httplink.c

@@ -1995,3 +1995,119 @@ int cbm_extract_channels(const char *source, cbm_channel_match_t *out, int max_o
     cbm_regfree(&re);
     return count;
 }
+
+/* ── C# channel extraction: Socket.IO with constant resolution ─── */
+
+/* Extract channels from C# source that uses constant names for event strings.
+ * Pattern: _socket.Emit(CONSTANT_NAME, data) / _socket.OnRequest<T>(CONSTANT_NAME, ...)
+ * Resolves constants via: const string CONSTANT_NAME = "ActualChannelName"; */
+int cbm_extract_csharp_channels(const char *source, cbm_channel_match_t *out, int max_out) {
+    if (!source || !*source) return 0;
+
+    /* Pass 1: Collect const string mappings: name → value */
+    typedef struct { char name[128]; char value[256]; } const_map_t;
+    const_map_t cmap[128];
+    int cmap_count = 0;
+
+    cbm_regex_t re_const;
+    if (cbm_regcomp(&re_const,
+            "const[[:space:]]+string[[:space:]]+([A-Z_][A-Z_0-9]*)[[:space:]]*=[[:space:]]*\"([^\"]{1,128})\"",
+            CBM_REG_EXTENDED) == 0) {
+        const char *p = source;
+        cbm_regmatch_t cm[3];
+        while (cmap_count < 128 && cbm_regexec(&re_const, p, 3, cm, 0) == 0) {
+            int nlen = cm[1].rm_eo - cm[1].rm_so;
+            int vlen = cm[2].rm_eo - cm[2].rm_so;
+            if (nlen > 0 && nlen < 128 && vlen > 0 && vlen < 256) {
+                memcpy(cmap[cmap_count].name, p + cm[1].rm_so, (size_t)nlen);
+                cmap[cmap_count].name[nlen] = '\0';
+                memcpy(cmap[cmap_count].value, p + cm[2].rm_so, (size_t)vlen);
+                cmap[cmap_count].value[vlen] = '\0';
+                cmap_count++;
+            }
+            p += cm[0].rm_eo;
+        }
+        cbm_regfree(&re_const);
+    }
+
+    /* Pass 2: Find .Emit( and .OnRequest patterns */
+    int count = 0;
+
+    /* Pattern: .Emit(IDENTIFIER  or  .OnRequest<...>(IDENTIFIER */
+    cbm_regex_t re_emit;
+    if (cbm_regcomp(&re_emit,
+            "\\.(Emit|OnRequest)[^(]*\\([[:space:]]*([A-Z_][A-Z_0-9]*)",
+            CBM_REG_EXTENDED) == 0) {
+        const char *p = source;
+        cbm_regmatch_t em[3];
+        while (count < max_out && cbm_regexec(&re_emit, p, 3, em, 0) == 0) {
+            int mlen = em[1].rm_eo - em[1].rm_so;
+            char method[16];
+            if (mlen >= (int)sizeof(method)) mlen = (int)sizeof(method) - 1;
+            memcpy(method, p + em[1].rm_so, (size_t)mlen);
+            method[mlen] = '\0';
+
+            int ilen = em[2].rm_eo - em[2].rm_so;
+            char ident[128];
+            if (ilen >= (int)sizeof(ident)) ilen = (int)sizeof(ident) - 1;
+            memcpy(ident, p + em[2].rm_so, (size_t)ilen);
+            ident[ilen] = '\0';
+
+            /* Resolve constant to string value */
+            const char *resolved = NULL;
+            for (int i = 0; i < cmap_count; i++) {
+                if (strcmp(cmap[i].name, ident) == 0) {
+                    resolved = cmap[i].value;
+                    break;
+                }
+            }
+
+            if (resolved) {
+                strncpy(out[count].channel, resolved, sizeof(out[count].channel) - 1);
+                out[count].channel[sizeof(out[count].channel) - 1] = '\0';
+
+                if (strcmp(method, "Emit") == 0) {
+                    strncpy(out[count].direction, "emit", sizeof(out[count].direction) - 1);
+                } else {
+                    strncpy(out[count].direction, "listen", sizeof(out[count].direction) - 1);
+                }
+                strncpy(out[count].transport, "socketio", sizeof(out[count].transport) - 1);
+                count++;
+            }
+            p += em[0].rm_eo;
+        }
+        cbm_regfree(&re_emit);
+    }
+
+    /* Also match direct string literal patterns: .Emit("ChannelName" */
+    cbm_regex_t re_literal;
+    if (cbm_regcomp(&re_literal,
+            "\\.(Emit|On|OnRequest)[^(]*\\([[:space:]]*\"([^\"]{1,128})\"",
+            CBM_REG_EXTENDED) == 0) {
+        const char *p = source;
+        cbm_regmatch_t lm[3];
+        while (count < max_out && cbm_regexec(&re_literal, p, 3, lm, 0) == 0) {
+            int mlen = lm[1].rm_eo - lm[1].rm_so;
+            char method[16];
+            if (mlen >= (int)sizeof(method)) mlen = (int)sizeof(method) - 1;
+            memcpy(method, p + lm[1].rm_so, (size_t)mlen);
+            method[mlen] = '\0';
+
+            int clen = lm[2].rm_eo - lm[2].rm_so;
+            strncpy(out[count].channel, p + lm[2].rm_so, (size_t)(clen < 255 ? clen : 255));
+            out[count].channel[clen < 255 ? clen : 255] = '\0';
+
+            if (strcmp(method, "Emit") == 0) {
+                strncpy(out[count].direction, "emit", sizeof(out[count].direction) - 1);
+            } else {
+                strncpy(out[count].direction, "listen", sizeof(out[count].direction) - 1);
+            }
+            strncpy(out[count].transport, "socketio", sizeof(out[count].transport) - 1);
+            count++;
+            p += lm[0].rm_eo;
+        }
+        cbm_regfree(&re_literal);
+    }
+
+    return count;
+}

src/store/store.c

@@ -4956,13 +4956,14 @@ void cbm_store_free_process_steps(cbm_process_step_t *arr, int count) {
 
 /* ── Channels (cross-service message tracing) ────────────────────── */
 
-/* Forward declaration of channel extractor from httplink.c */
+/* Forward declaration of channel extractors from httplink.c */
 typedef struct {
     char channel[256];
     char direction[8];
     char transport[32];
 } cbm_channel_match_t;
 int cbm_extract_channels(const char *source, cbm_channel_match_t *out, int max_out);
+int cbm_extract_csharp_channels(const char *source, cbm_channel_match_t *out, int max_out);
 
 int cbm_store_detect_channels(cbm_store_t *s, const char *project, const char *repo_path) {
     if (!s || !s->db || !project || !repo_path) return 0;
@@ -4972,11 +4973,12 @@ int cbm_store_detect_channels(cbm_store_t *s, const char *project, const char *r
     snprintf(del, sizeof(del), "DELETE FROM channels WHERE project = '%s'", project);
     exec_sql(s, del);
 
-    /* Find all JS/TS Function/Method nodes with source file references */
+    /* Find all Function/Method nodes with source file references in supported languages */
     const char *sql = "SELECT id, name, file_path, start_line, end_line FROM nodes "
-                      "WHERE project = ?1 AND label IN ('Function','Method','Module') "
+                      "WHERE project = ?1 AND label IN ('Function','Method','Module','Class') "
                       "AND (file_path LIKE '%.ts' OR file_path LIKE '%.js' "
-                      "OR file_path LIKE '%.tsx' OR file_path LIKE '%.py')";
+                      "OR file_path LIKE '%.tsx' OR file_path LIKE '%.py' "
+                      "OR file_path LIKE '%.cs')";
     sqlite3_stmt *stmt = NULL;
     if (sqlite3_prepare_v2(s->db, sql, -1, &stmt, NULL) != SQLITE_OK) return 0;
     bind_text(stmt, 1, project);
@@ -5029,7 +5031,15 @@ int cbm_store_detect_channels(cbm_store_t *s, const char *project, const char *r
         if (source) {
             source[src_len] = '\0';
             cbm_channel_match_t matches[64];
-            int mc = cbm_extract_channels(source, matches, 64);
+            int mc = 0;
+            /* Use language-appropriate extractor */
+            bool is_cs = fpath && (strstr(fpath, ".cs") != NULL &&
+                                   strstr(fpath, ".css") == NULL);
+            if (is_cs) {
+                mc = cbm_extract_csharp_channels(source, matches, 64);
+            } else {
+                mc = cbm_extract_channels(source, matches, 64);
+            }
             for (int i = 0; i < mc && ins; i++) {
                 sqlite3_reset(ins);
                 bind_text(ins, 1, project);