@codragraph/cli 2.1.5 → 2.2.0-rc.6

package/dist/core/search/bm25-index.d.ts

@@ -15,7 +15,26 @@ export interface BM25SearchResult {
     score: number;
     rank: number;
     nodeIds?: string[];
+    /** False when results came from the bounded fallback scan instead of FTS. */
+    ftsUsed?: boolean;
 }
+/**
+ * FTS table set served by `searchFTSFromCgdb`. Centralised so that both
+ * the CLI/pipeline path and the MCP pool path stay in lockstep.
+ *
+ * The properties list is computed at FTS-create time via `ftsPropertiesFor`
+ * — for repos that were analysed with `--compress brotli|zstd`, the
+ * `content` column holds base64-of-encoded-bytes and would tokenise to
+ * useless tokens. Those repos get name-only FTS so search at least
+ * matches function/class names instead of returning random hits on
+ * base64 alphabet. Plain (compress='none' / unset) repos get the full
+ * `name + content` index for body-text matches. RFC 0001 Phase 2.5.
+ */
+export declare const FTS_TABLES: ReadonlyArray<{
+    table: string;
+    indexName: string;
+}>;
+export declare const ftsPropertiesFor: (compress: "none" | "brotli" | "zstd" | undefined) => readonly string[];
 /**
  * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *

package/dist/core/search/bm25-index.js

@@ -23,22 +23,21 @@ import { queryFTS, ensureFTSIndex, executeQuery as executeCoreQuery, } from '../
  * base64 alphabet. Plain (compress='none' / unset) repos get the full
  * `name + content` index for body-text matches. RFC 0001 Phase 2.5.
  */
-const FTS_TABLES = [
+export const FTS_TABLES = [
     { table: 'File', indexName: 'file_fts' },
     { table: 'Function', indexName: 'function_fts' },
     { table: 'Class', indexName: 'class_fts' },
     { table: 'Method', indexName: 'method_fts' },
     { table: 'Interface', indexName: 'interface_fts' },
 ];
-const ftsPropertiesFor = (compress) => !compress || compress === 'none' ? ['name', 'content'] : ['name'];
+export const ftsPropertiesFor = (compress) => (!compress || compress === 'none' ? ['name', 'content'] : ['name']);
 /**
- * Look up `meta.compress` for a repo. The MCP path passes `repoId`
- * (registry-derived); the CLI path passes nothing and we walk up from
- * cwd. Returns `'none'` whenever the lookup fails so the safe default
- * (full FTS index) is used — the failure mode is reduced search
- * quality, never wrong results.
+ * Look up query-related index metadata for a repo. The MCP path passes `repoId`
+ * (registry-derived); the CLI/core path passes nothing and we walk up from
+ * cwd. Read-only callers use `ftsReady` to avoid expensive probes for
+ * FTS indexes that older analyses never wrote.
  */
-async function getCompressMode(repoId) {
+async function getSearchMeta(repoId) {
     try {
         const repoMod = await import('../../storage/repo-manager.js');
         if (repoId) {
@@ -50,16 +49,22 @@ async function getCompressMode(repoId) {
                 const base = entry.name.toLowerCase();
                 if (base === repoId || repoId.startsWith(`${base}-`)) {
                     const meta = await repoMod.loadMeta(entry.storagePath);
-                    return meta?.compress ?? 'none';
+                    return {
+                        compress: meta?.compress ?? 'none',
+                        ftsReady: meta?.searchIndexes?.fts === true,
+                    };
                 }
             }
-            return 'none';
+            return { compress: 'none', ftsReady: false };
         }
         const repo = await repoMod.findRepo(process.cwd());
-        return repo?.meta?.compress ?? 'none';
+        return {
+            compress: repo?.meta?.compress ?? 'none',
+            ftsReady: repo?.meta?.searchIndexes?.fts,
+        };
     }
     catch {
-        return 'none';
+        return { compress: 'none', ftsReady: repoId ? false : undefined };
     }
 }
 const FALLBACK_SCAN_LIMIT = 50_000;
@@ -105,6 +110,22 @@ function searchTerms(query) {
         ?.filter((term) => term.length > 1 && !BOOLEAN_QUERY_TOKENS.has(term));
     return [...new Set(terms ?? [])];
 }
+function searchTermVariants(query) {
+    const rawTerms = query.match(/[\p{L}\p{N}_]+/gu) ?? [];
+    const variants = new Set();
+    for (const raw of rawTerms) {
+        const lower = raw.toLowerCase();
+        if (raw.length <= 1 || BOOLEAN_QUERY_TOKENS.has(lower))
+            continue;
+        variants.add(raw);
+        variants.add(lower);
+        variants.add(raw.charAt(0).toUpperCase() + raw.slice(1).toLowerCase());
+    }
+    return [...variants];
+}
+function cypherString(value) {
+    return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "''")}'`;
+}
 function scoreFallbackNode(node, query, properties) {
     const terms = searchTerms(query);
     if (terms.length === 0)
@@ -131,10 +152,15 @@ function scoreFallbackNode(node, query, properties) {
 }
 async function queryFallbackViaExecutor(executor, tableName, properties, query, limit) {
     try {
+        const variants = searchTermVariants(query);
+        const conditions = variants.flatMap((term) => properties.map((property) => `node.${property} CONTAINS ${cypherString(term)}`));
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' OR ')}` : '';
+        const candidateLimit = Math.min(FALLBACK_SCAN_LIMIT, Math.max(limit * 25, 200));
         const rows = await executor(`
       MATCH (node:${tableName})
+      ${whereClause}
       RETURN node
-      LIMIT ${FALLBACK_SCAN_LIMIT}
+      LIMIT ${candidateLimit}
     `);
         return rows
             .map((row) => {
@@ -158,10 +184,7 @@ async function fallbackSearchAllTables(executor, query, limit,
 // pre-Phase-2 behaviour (`['name', 'content']`) for callers that don't
 // pass a value.
 properties = ['name', 'content']) {
-    const results = [];
-    for (const { table } of FTS_TABLES) {
-        results.push(await queryFallbackViaExecutor(executor, table, properties, query, limit));
-    }
+    const results = await Promise.all(FTS_TABLES.map(({ table }) => queryFallbackViaExecutor(executor, table, properties, query, limit)));
     return results;
 }
 /**
@@ -179,6 +202,7 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
     if (!query.trim() || limit <= 0)
         return [];
     let fileResults, functionResults, classResults, methodResults, interfaceResults;
+    let usedFallback = false;
     if (repoId) {
         // Use MCP connection pool via dynamic import
         // IMPORTANT: FTS queries run sequentially to avoid connection contention.
@@ -188,34 +212,46 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
         const executor = (cypher) => executeQuery(repoId, cypher);
         // The MCP/LocalBackend pool is opened read-only so it can safely coexist
         // with `codragraph analyze`. Do not issue CREATE_FTS_INDEX here: when
-        // persisted FTS indexes are missing, QUERY_FTS_INDEX falls through to the
-        // bounded BM25 fallback below without noisy write-failure retries.
+        // persisted FTS indexes are missing, meta.searchIndexes lets us skip
+        // QUERY_FTS_INDEX and go straight to the bounded fallback below.
         // RFC 0001 Phase 2.5: drop `content` from fallback scoring for repos
         // analysed with --compress brotli|zstd — the column holds encoded bytes.
-        const compress = await getCompressMode(repoId);
-        const properties = ftsPropertiesFor(compress);
-        fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
-        functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
-        classResults = await queryFTSViaExecutor(executor, 'Class', 'class_fts', query, limit);
-        methodResults = await queryFTSViaExecutor(executor, 'Method', 'method_fts', query, limit);
-        interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
+        const meta = await getSearchMeta(repoId);
+        const properties = ftsPropertiesFor(meta.compress);
+        if (meta.ftsReady) {
+            fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
+            functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
+            classResults = await queryFTSViaExecutor(executor, 'Class', 'class_fts', query, limit);
+            methodResults = await queryFTSViaExecutor(executor, 'Method', 'method_fts', query, limit);
+            interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
+        }
+        else {
+            usedFallback = true;
+            fileResults = [];
+            functionResults = [];
+            classResults = [];
+            methodResults = [];
+            interfaceResults = [];
+        }
         if (fileResults.length +
             functionResults.length +
             classResults.length +
             methodResults.length +
             interfaceResults.length ===
             0) {
+            usedFallback = true;
             [fileResults, functionResults, classResults, methodResults, interfaceResults] =
                 await fallbackSearchAllTables(executor, query, limit, properties);
         }
     }
     else {
         // Use core cgdb adapter (CLI / pipeline context) — also sequential for safety.
-        // Lazy-create FTS indexes on first query (analyze no longer does it).
+        // Defensive fallback for older indexes or direct core callers: create FTS
+        // indexes on first query when this process owns a writable connection.
         // RFC 0001 Phase 2.5 — same `compress`-aware property selection as the MCP
         // path; the CLI walks up from cwd to find the repo's meta.json.
-        const compress = await getCompressMode();
-        const properties = ftsPropertiesFor(compress);
+        const meta = await getSearchMeta();
+        const properties = ftsPropertiesFor(meta.compress);
         for (const { table, indexName } of FTS_TABLES) {
             await ensureFTSIndex(table, indexName, [...properties]).catch(() => { });
         }
@@ -230,6 +266,7 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
             methodResults.length +
             interfaceResults.length ===
             0) {
+            usedFallback = true;
             [fileResults, functionResults, classResults, methodResults, interfaceResults] =
                 await fallbackSearchAllTables(executeCoreQuery, query, limit, properties);
         }
@@ -258,6 +295,7 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
             filePath,
             score: top3.reduce((acc, e) => acc + e.score, 0),
             nodeIds: top3.map((e) => e.nodeId).filter((id) => id),
+            ftsUsed: !usedFallback,
         });
     }
     // Sort by score descending and add rank
@@ -269,5 +307,6 @@ export const searchFTSFromCgdb = async (query, limit = 20, repoId) => {
         score: r.score,
         rank: index + 1,
         nodeIds: r.nodeIds,
+        ftsUsed: r.ftsUsed,
     }));
 };

package/dist/core/semantic/relationships.d.ts

@@ -0,0 +1,36 @@
+export declare const SEMANTIC_RELATIONSHIP_VERSION: "semantic-extractor-v1";
+export type SemanticRelationshipFamily = 'COMPOSES' | 'ADAPTS' | 'DELEGATES_TO' | 'WRAPS' | 'CONFIGURES' | 'FACTORY_CREATES' | 'ORCHESTRATES' | 'PROXIES_TO' | 'MAPS_TO';
+export type SemanticRelationshipProvenance = 'extracted' | 'inferred' | 'LLM_INFERRED' | 'human-confirmed';
+export interface SemanticRelationshipEvidence {
+    readonly filePath?: string;
+    readonly startLine?: number;
+    readonly endLine?: number;
+    readonly rawEdgeType: string;
+    readonly rawEdgeConfidence?: number;
+    readonly reason: string;
+}
+export interface SemanticRelationship {
+    readonly id: string;
+    readonly family: SemanticRelationshipFamily;
+    readonly sourceId: string;
+    readonly sourceName?: string;
+    readonly targetId: string;
+    readonly targetName?: string;
+    readonly confidence: number;
+    readonly provenance: SemanticRelationshipProvenance;
+    readonly extractorVersion: typeof SEMANTIC_RELATIONSHIP_VERSION;
+    readonly evidence: SemanticRelationshipEvidence;
+}
+export interface SemanticRelationshipReport {
+    readonly snapshotId?: string;
+    readonly extractorVersion: typeof SEMANTIC_RELATIONSHIP_VERSION;
+    readonly llmEnabled: boolean;
+    readonly relationships: readonly SemanticRelationship[];
+    readonly summary: Record<SemanticRelationshipFamily, number>;
+}
+export declare const analyzeSemanticRelationships: (opts: {
+    readonly storagePath: string;
+    readonly limit?: number;
+    readonly llm?: boolean;
+    readonly write?: boolean;
+}) => Promise<SemanticRelationshipReport>;

package/dist/core/semantic/relationships.js

@@ -0,0 +1,261 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { FsCAS, getJson, parseObjectId, readCommit, resolveHeadCommit, } from '@codragraph/graphstore';
+import { GRAPHSTORE_SUBDIR } from '../graphstore/index.js';
+export const SEMANTIC_RELATIONSHIP_VERSION = 'semantic-extractor-v1';
+export const analyzeSemanticRelationships = async (opts) => {
+    const graphstoreRoot = path.join(opts.storagePath, GRAPHSTORE_SUBDIR);
+    const cas = new FsCAS({ root: graphstoreRoot });
+    const head = await resolveHeadCommit({ root: graphstoreRoot });
+    if (head === null) {
+        throw new Error('semantic analyze requires a graphstore HEAD. Run `codragraph analyze` first.');
+    }
+    const commit = await readCommit(cas, head);
+    const snapshot = await getJson(cas, commit.snapshot);
+    const manifest = await getJson(cas, parseObjectId(snapshot.manifestId));
+    const nodes = await loadNodes(cas, manifest);
+    const relationships = await inferRelationships({
+        cas,
+        manifest,
+        nodes,
+        limit: opts.limit ?? 1000,
+    });
+    const report = {
+        snapshotId: commit.snapshot,
+        extractorVersion: SEMANTIC_RELATIONSHIP_VERSION,
+        llmEnabled: opts.llm === true,
+        relationships,
+        summary: summarize(relationships),
+    };
+    if (opts.write) {
+        await fs.writeFile(path.join(opts.storagePath, 'semantic-relationships.json'), `${JSON.stringify(report, null, 2)}\n`, 'utf-8');
+    }
+    return report;
+};
+const loadNodes = async (cas, manifest) => {
+    const nodes = new Map();
+    for (const [table, tableManifest] of Object.entries(manifest.nodeTables)) {
+        for (const [id, objectId] of Object.entries(tableManifest.rows)) {
+            const row = await getJson(cas, parseObjectId(objectId));
+            nodes.set(id, {
+                id,
+                table,
+                name: stringProp(row, 'name'),
+                filePath: stringProp(row, 'filePath'),
+                startLine: numberProp(row, 'startLine'),
+                endLine: numberProp(row, 'endLine'),
+            });
+        }
+    }
+    return nodes;
+};
+const inferRelationships = async (opts) => {
+    const highSignal = [];
+    const fallback = [];
+    const seen = new Set();
+    const edgeEntries = Object.entries(opts.manifest.edges.rows);
+    for (const [edgeKey, objectId] of edgeEntries) {
+        let edge;
+        const parsed = parseEdgeKey(edgeKey);
+        if (!parsed)
+            edge = await getJson(opts.cas, parseObjectId(objectId));
+        const from = parsed?.from ?? stringProp(edge, 'from');
+        const to = parsed?.to ?? stringProp(edge, 'to');
+        const rawType = parsed?.rawType ?? stringProp(edge, 'type');
+        if (!from || !to || !rawType)
+            continue;
+        if (!SEMANTIC_RAW_EDGE_TYPES.has(rawType))
+            continue;
+        const source = opts.nodes.get(from);
+        const target = opts.nodes.get(to);
+        const classified = classifySemanticEdge({ rawType, source, target });
+        if (!classified)
+            continue;
+        const key = `${from}|${classified.family}|${to}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const relationship = {
+            id: `semantic:${hashKey(key).slice(0, 32)}`,
+            family: classified.family,
+            sourceId: from,
+            ...(source?.name ? { sourceName: source.name } : {}),
+            targetId: to,
+            ...(target?.name ? { targetName: target.name } : {}),
+            confidence: classified.confidence,
+            provenance: rawType === classified.family ? 'extracted' : 'inferred',
+            extractorVersion: SEMANTIC_RELATIONSHIP_VERSION,
+            evidence: {
+                filePath: source?.filePath ?? target?.filePath,
+                startLine: source?.startLine ?? target?.startLine,
+                endLine: source?.endLine ?? target?.endLine,
+                rawEdgeType: rawType,
+                rawEdgeConfidence: edge ? numberProp(edge, 'confidence') : undefined,
+                reason: classified.reason,
+            },
+        };
+        const bucket = classified.family === 'COMPOSES' ? fallback : highSignal;
+        bucket.push(relationship);
+        if (highSignal.length >= opts.limit)
+            break;
+    }
+    return [
+        ...highSignal.sort(compareSemanticRelationships),
+        ...fallback.sort(compareSemanticRelationships),
+    ].slice(0, opts.limit);
+};
+const SEMANTIC_RAW_EDGE_TYPES = new Set([
+    'CALLS',
+    'IMPORTS',
+    'EXTENDS',
+    'IMPLEMENTS',
+    'HAS_METHOD',
+    'HAS_PROPERTY',
+    'ACCESSES',
+    'METHOD_OVERRIDES',
+    'METHOD_IMPLEMENTS',
+    'WRAPS',
+    'FETCHES',
+    'HANDLES_ROUTE',
+    'HANDLES_TOOL',
+    'QUERIES',
+]);
+const parseEdgeKey = (edgeKey) => {
+    const parts = edgeKey.split('|');
+    if (parts.length < 3)
+        return null;
+    const [from, rawType, ...toParts] = parts;
+    if (!from || !rawType || toParts.length === 0)
+        return null;
+    return { from, rawType, to: toParts.join('|') };
+};
+const classifySemanticEdge = (input) => {
+    const sourceName = input.source?.name ?? input.source?.id ?? '';
+    const targetName = input.target?.name ?? input.target?.id ?? '';
+    const source = sourceName.toLowerCase();
+    const target = targetName.toLowerCase();
+    const rawType = input.rawType;
+    if (rawType === 'WRAPS' || hasAny(source, ['wrapper', 'middleware', 'decorator'])) {
+        return {
+            family: 'WRAPS',
+            confidence: rawType === 'WRAPS' ? 0.95 : 0.78,
+            reason: 'wrapper/decorator naming or raw WRAPS edge',
+        };
+    }
+    if (rawType === 'IMPLEMENTS' && hasAny(source, ['adapter', 'adaptor'])) {
+        return { family: 'ADAPTS', confidence: 0.86, reason: 'adapter implementation edge' };
+    }
+    if (hasAny(source, ['adapter', 'adaptor']) && ['CALLS', 'IMPORTS'].includes(rawType)) {
+        return { family: 'ADAPTS', confidence: 0.72, reason: 'adapter symbol delegates to target' };
+    }
+    if (hasAny(source, ['proxy', 'client']) && ['CALLS', 'FETCHES', 'IMPORTS'].includes(rawType)) {
+        return {
+            family: 'PROXIES_TO',
+            confidence: 0.74,
+            reason: 'proxy/client symbol forwards to target',
+        };
+    }
+    if (hasAny(source, ['factory', 'builder']) || /^(create|make|build)[A-Z_]/.test(sourceName)) {
+        if (['CALLS', 'HAS_METHOD', 'IMPORTS'].includes(rawType)) {
+            return {
+                family: 'FACTORY_CREATES',
+                confidence: 0.75,
+                reason: 'factory/create/build symbol reaches constructed target',
+            };
+        }
+    }
+    if (hasAny(source, ['config', 'configure', 'setup', 'options']) &&
+        ['CALLS', 'ACCESSES', 'IMPORTS'].includes(rawType)) {
+        return {
+            family: 'CONFIGURES',
+            confidence: 0.7,
+            reason: 'configuration symbol controls target behavior',
+        };
+    }
+    if (hasAny(source, ['orchestrator', 'coordinator', 'workflow', 'pipeline', 'runner']) &&
+        rawType === 'CALLS') {
+        return {
+            family: 'ORCHESTRATES',
+            confidence: 0.76,
+            reason: 'orchestrator/coordinator call edge',
+        };
+    }
+    if (hasAny(source, ['mapper', 'map', 'dto', 'transformer', 'serializer']) ||
+        hasAny(target, ['dto', 'schema', 'model'])) {
+        if (['CALLS', 'IMPORTS', 'ACCESSES'].includes(rawType)) {
+            return { family: 'MAPS_TO', confidence: 0.7, reason: 'mapper/DTO transformation signal' };
+        }
+    }
+    if (rawType === 'HAS_PROPERTY' || rawType === 'ACCESSES') {
+        return {
+            family: 'COMPOSES',
+            confidence: 0.68,
+            reason: 'field/property ownership or access edge',
+        };
+    }
+    if (rawType === 'CALLS' && /^(handle|run|execute|process|dispatch)/i.test(sourceName)) {
+        return {
+            family: 'DELEGATES_TO',
+            confidence: 0.66,
+            reason: 'handler/executor delegates to callee',
+        };
+    }
+    return null;
+};
+const summarize = (relationships) => {
+    const summary = {
+        COMPOSES: 0,
+        ADAPTS: 0,
+        DELEGATES_TO: 0,
+        WRAPS: 0,
+        CONFIGURES: 0,
+        FACTORY_CREATES: 0,
+        ORCHESTRATES: 0,
+        PROXIES_TO: 0,
+        MAPS_TO: 0,
+    };
+    for (const rel of relationships)
+        summary[rel.family]++;
+    return summary;
+};
+const compareSemanticRelationships = (a, b) => {
+    const byFamily = familyPriority(a.family) - familyPriority(b.family);
+    if (byFamily !== 0)
+        return byFamily;
+    return b.confidence - a.confidence;
+};
+const familyPriority = (family) => {
+    switch (family) {
+        case 'ADAPTS':
+            return 0;
+        case 'WRAPS':
+            return 1;
+        case 'PROXIES_TO':
+            return 2;
+        case 'FACTORY_CREATES':
+            return 3;
+        case 'ORCHESTRATES':
+            return 4;
+        case 'CONFIGURES':
+            return 5;
+        case 'MAPS_TO':
+            return 6;
+        case 'DELEGATES_TO':
+            return 7;
+        case 'COMPOSES':
+            return 8;
+    }
+};
+const hasAny = (value, needles) => needles.some((needle) => value.includes(needle));
+const stringProp = (row, key) => {
+    const value = row[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+};
+const numberProp = (row, key) => {
+    const value = row[key];
+    return typeof value === 'number' ? value : undefined;
+};
+const hashKey = (key) => {
+    return crypto.createHash('sha256').update(key).digest('hex');
+};

package/dist/mcp/local/local-backend.js

@@ -768,6 +768,48 @@ export class LocalBackend {
                     params?.id ??
                     ''), params?.repo, params?.direction ??
                     'upstream', clampNumber(params?.limit, 1, 500, 100));
+            case 'graphpack_status': {
+                const { getGraphpackStatus } = await import('../../core/graphpack/index.js');
+                return getGraphpackStatus({
+                    repoPath: repo.repoPath,
+                    storagePath: repo.storagePath,
+                    strict: params?.strict === true,
+                });
+            }
+            case 'graphpack_publish': {
+                const { publishGraphpack } = await import('../../core/graphpack/index.js');
+                const args = params ?? {};
+                return publishGraphpack({
+                    repoPath: repo.repoPath,
+                    storagePath: repo.storagePath,
+                    repoName: typeof args['repo'] === 'string' ? args['repo'] : repo.name,
+                    analyzerVersion: 'mcp',
+                    target: args['target'] === 'pr' ? 'pr' : 'main',
+                    artifactDir: typeof args['artifact_dir'] === 'string' ? args['artifact_dir'] : undefined,
+                    artifactUrl: typeof args['artifact_url'] === 'string' ? args['artifact_url'] : undefined,
+                    baseSnapshotId: typeof args['base_snapshot_id'] === 'string' ? args['base_snapshot_id'] : undefined,
+                    headSnapshotId: typeof args['head_snapshot_id'] === 'string' ? args['head_snapshot_id'] : undefined,
+                    pullRequest: typeof args['pull_request'] === 'string' ? args['pull_request'] : undefined,
+                });
+            }
+            case 'graphpack_pull': {
+                const { pullGraphpack } = await import('../../core/graphpack/index.js');
+                const args = params ?? {};
+                return pullGraphpack({
+                    repoPath: repo.repoPath,
+                    storagePath: repo.storagePath,
+                    artifactDir: typeof args['artifact_dir'] === 'string' ? args['artifact_dir'] : undefined,
+                });
+            }
+            case 'semantic_relationships': {
+                const { analyzeSemanticRelationships } = await import('../../core/semantic/relationships.js');
+                return analyzeSemanticRelationships({
+                    storagePath: repo.storagePath,
+                    llm: params?.llm === true,
+                    limit: clampNumber(params?.limit, 1, 10000, 1000),
+                    write: false,
+                });
+            }
             case 'harness_swarm_run': {
                 // Same lazy-import dance as harness_run (see comments below) — keeps
                 // codragraph-harness optional and avoids a circular build-time dep.
@@ -2107,10 +2149,12 @@ export class LocalBackend {
                 queryParams[`hunkEnd${i}`] = hunk.endLine;
             });
             const symbolQuery = `
-        MATCH (n) WHERE n.filePath ENDS WITH $filePath
+        MATCH (f:File)-[r:CodeRelation]->(n)
+        WHERE r.type IN ['DEFINES', 'CONTAINS']
+          AND f.filePath ENDS WITH $filePath
           AND n.startLine IS NOT NULL AND n.endLine IS NOT NULL
           AND (${overlapConditions})
-        RETURN n.id AS id, n.name AS name, labels(n)[0] AS type,
+        RETURN n.id AS id, n.name AS name, '' AS type,
                n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine
       `;
             try {
@@ -2119,7 +2163,8 @@ export class LocalBackend {
                     changedSymbols.push({
                         id: sym.id || sym[0],
                         name: sym.name || sym[1],
-                        type: sym.type || sym[2],
+                        type: safeNodeLabelForCypher(sym.type, sym.id || sym[0]) ??
+                            firstNonEmptyString(sym.type, sym.__cgLabel, sym[2]),
                         filePath: sym.filePath || sym[3],
                         change_type: 'touched',
                     });