@veewo/gitnexus 1.4.9 → 1.4.11-rc

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

@@ -8,7 +8,14 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady } from '../core/lbug-adapter.js';
+import { parseUnityHydrationMode, parseUnityResourcesMode } from '../../core/unity/options.js';
 import { runUnityUiTrace } from '../../core/unity/ui-trace.js';
+import { loadUnityContext } from './unity-enrichment.js';
+import { hydrateUnityForSymbol } from './unity-runtime-hydration.js';
+import { mergeProcessEvidence } from './process-evidence.js';
+import { resolveUnityProcessConfidenceFieldsEnabled } from './unity-process-confidence-config.js';
+import { resolveUnityRuntimeChainVerifyEnabled } from './unity-runtime-chain-verify-config.js';
+import { verifyRuntimeChainOnDemand, } from './runtime-chain-verify.js';
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
 // git utilities available if needed
@@ -74,6 +81,46 @@ function resolveQueryScopePreset(scopePreset) {
     }
     return undefined;
 }
+function aggregateProcessConfidence(rows) {
+    if (rows.some((row) => row.process_confidence === 'high'))
+        return 'high';
+    if (rows.some((row) => row.process_confidence === 'medium'))
+        return 'medium';
+    return 'low';
+}
+function aggregateProcessEvidenceMode(rows) {
+    if (rows.some((row) => row.process_evidence_mode === 'direct_step'))
+        return 'direct_step';
+    if (rows.some((row) => row.process_evidence_mode === 'method_projected'))
+        return 'method_projected';
+    return 'resource_heuristic';
+}
+function selectVerificationHint(rows) {
+    return rows.find((row) => row.verification_hint)?.verification_hint;
+}
+function aggregateRuntimeChainEvidenceLevel(rows) {
+    if (rows.some((row) => row.runtime_chain_evidence_level === 'verified_chain'))
+        return 'verified_chain';
+    if (rows.some((row) => row.runtime_chain_evidence_level === 'verified_segment'))
+        return 'verified_segment';
+    if (rows.some((row) => row.runtime_chain_evidence_level === 'clue'))
+        return 'clue';
+    return 'none';
+}
+function confidenceRank(confidence) {
+    if (confidence === 'high')
+        return 3;
+    if (confidence === 'medium')
+        return 2;
+    return 1;
+}
+function evidenceModeRank(mode) {
+    if (mode === 'direct_step')
+        return 3;
+    if (mode === 'method_projected')
+        return 2;
+    return 1;
+}
 export function filterBm25ResultsByScopePreset(rows, scopePreset) {
     const preset = resolveQueryScopePreset(scopePreset);
     if (!preset || preset === 'unity-all')
@@ -504,7 +551,19 @@ export class LocalBackend {
         const processLimit = params.limit || 5;
         const maxSymbolsPerProcess = params.max_symbols || 10;
         const includeContent = params.include_content ?? false;
+        const confidenceFieldsEnabled = resolveUnityProcessConfidenceFieldsEnabled(process.env);
+        let unityResourcesMode = 'off';
+        let unityHydrationMode = 'compact';
+        try {
+            unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
+            unityHydrationMode = parseUnityHydrationMode(params.unity_hydration_mode);
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : String(error) };
+        }
         const searchQuery = params.query.trim();
+        const runtimeChainVerifyMode = String(params.runtime_chain_verify || 'off').trim().toLowerCase();
+        const runtimeChainVerifyEnabled = resolveUnityRuntimeChainVerifyEnabled(process.env);
         // Step 1: Run hybrid search to get matching symbols
         const searchLimit = processLimit * maxSymbolsPerProcess; // fetch enough raw results
         const [bm25Results, semanticResults] = await Promise.all([
@@ -554,17 +613,42 @@ export class LocalBackend {
                 });
                 continue;
             }
-            // Find processes this symbol participates in
-            let processRows = [];
+            // Find processes this symbol participates in (direct + method projection for class-like symbols).
+            let directProcessRows = [];
+            let projectedProcessRows = [];
             try {
-                processRows = await executeParameterized(repo.id, `
+                directProcessRows = await executeParameterized(repo.id, `
           MATCH (n {id: $nodeId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          RETURN p.id AS pid, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount, r.step AS step
+          RETURN p.id AS pid, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, p.stepCount AS stepCount, r.step AS step
         `, { nodeId: sym.nodeId });
             }
             catch (e) {
                 logQueryError('query:process-lookup', e);
             }
+            const symIdLower = String(sym.nodeId).toLowerCase();
+            const isClassLike = ['Class', 'Interface', 'Struct', 'Trait', 'Impl', 'Record'].includes(String(sym.type || ''))
+                || symIdLower.startsWith('class:')
+                || symIdLower.startsWith('interface:')
+                || symIdLower.startsWith('struct:')
+                || symIdLower.startsWith('trait:')
+                || symIdLower.startsWith('impl:')
+                || symIdLower.startsWith('record:');
+            if (isClassLike) {
+                try {
+                    projectedProcessRows = await executeParameterized(repo.id, `
+            MATCH (n {id: $nodeId})-[:CodeRelation {type: 'HAS_METHOD'}]->(m)
+            MATCH (m)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+            RETURN p.id AS pid, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, p.stepCount AS stepCount, MIN(r.step) AS step
+          `, { nodeId: sym.nodeId });
+                }
+                catch (e) {
+                    logQueryError('query:method-process-projection', e);
+                }
+            }
+            let processRows = mergeProcessEvidence({
+                directRows: directProcessRows,
+                projectedRows: isClassLike ? projectedProcessRows : [],
+            });
             // Get cluster membership + cohesion (cohesion used as internal ranking signal)
             let cohesion = 0;
             let module;
@@ -607,7 +691,57 @@ export class LocalBackend {
                 endLine: sym.endLine,
                 ...(module ? { module } : {}),
                 ...(includeContent && content ? { content } : {}),
+                ...((unityResourcesMode !== 'off'
+                    && sym.nodeId
+                    && (sym.type === 'Class' || String(sym.nodeId).toLowerCase().startsWith('class:')))
+                    ? await hydrateUnityForSymbol({
+                        mode: unityHydrationMode,
+                        basePayload: await loadUnityContext(repo.id, sym.nodeId, (query) => executeQuery(repo.id, query)),
+                        deps: {
+                            executeQuery: (query, queryParams) => {
+                                if (queryParams && Object.keys(queryParams).length > 0) {
+                                    return executeParameterized(repo.id, query, queryParams);
+                                }
+                                return executeQuery(repo.id, query);
+                            },
+                            repoPath: repo.repoPath,
+                            storagePath: repo.storagePath,
+                            indexedCommit: repo.lastCommit,
+                        },
+                        symbol: {
+                            uid: sym.nodeId,
+                            name: sym.name || '',
+                            filePath: sym.filePath || '',
+                        },
+                    })
+                    : {}),
             };
+            if (processRows.length === 0 && unityResourcesMode !== 'off') {
+                const resourceBindings = Array.isArray(symbolEntry.resourceBindings)
+                    ? symbolEntry.resourceBindings
+                    : [];
+                const needsParityRetry = Boolean(symbolEntry.hydrationMeta?.needsParityRetry);
+                const hasPartialUnityEvidence = resourceBindings.length > 0 || needsParityRetry;
+                if (hasPartialUnityEvidence) {
+                    const firstBindingPath = String(resourceBindings[0]?.resourcePath || '').trim();
+                    const verificationTarget = firstBindingPath || sym.filePath || sym.name || sym.nodeId;
+                    processRows = mergeProcessEvidence({
+                        directRows: [],
+                        projectedRows: [],
+                        heuristicRows: [{
+                                pid: `proc:heuristic:${String(sym.nodeId || '').replace(/\s+/g, '_')}`,
+                                label: `${String(sym.name || 'Symbol')} runtime heuristic clue`,
+                                processType: 'unity_resource_heuristic',
+                                processSubtype: 'unity_lifecycle',
+                                runtimeChainConfidence: 'low',
+                                step: 1,
+                                stepCount: 1,
+                                needsParityRetry,
+                                verificationTarget,
+                            }],
+                    });
+                }
+            }
             if (processRows.length === 0) {
                 // Symbol not in any process — goes to definitions
                 definitions.push(symbolEntry);
@@ -615,12 +749,12 @@ export class LocalBackend {
             else {
                 // Add to each process it belongs to
                 for (const row of processRows) {
-                    const pid = row.pid ?? row[0];
-                    const label = row.label ?? row[1];
-                    const hLabel = row.heuristicLabel ?? row[2];
-                    const pType = row.processType ?? row[3];
-                    const stepCount = row.stepCount ?? row[4];
-                    const step = row.step ?? row[5];
+                    const pid = String(row.pid || '');
+                    const label = String(row.label || '');
+                    const hLabel = String(row.heuristicLabel || label);
+                    const pType = String(row.processType || '');
+                    const stepCount = Number(row.stepCount || 0);
+                    const step = Number(row.step || 0);
                     if (!processMap.has(pid)) {
                         processMap.set(pid, {
                             id: pid,
@@ -628,6 +762,8 @@ export class LocalBackend {
                             heuristicLabel: hLabel,
                             processType: pType,
                             stepCount,
+                            processSubtype: String(row.processSubtype || ''),
+                            runtimeChainConfidence: String(row.runtimeChainConfidence || ''),
                             totalScore: 0,
                             cohesionBoost: 0,
                             symbols: [],
@@ -640,6 +776,14 @@ export class LocalBackend {
                         ...symbolEntry,
                         process_id: pid,
                         step_index: step,
+                        process_subtype: String(row.processSubtype || ''),
+                        process_evidence_mode: row.evidence_mode,
+                        process_confidence: row.confidence,
+                        ...(confidenceFieldsEnabled ? {
+                            runtime_chain_confidence: row.confidence,
+                            runtime_chain_evidence_level: row.runtime_chain_evidence_level,
+                            verification_hint: row.verification_hint,
+                        } : {}),
                     });
                 }
             }
@@ -659,25 +803,54 @@ export class LocalBackend {
             priority: Math.round(p.priority * 1000) / 1000,
             symbol_count: p.symbols.length,
             process_type: p.processType,
+            process_subtype: p.processSubtype || undefined,
             step_count: p.stepCount,
+            evidence_mode: aggregateProcessEvidenceMode(p.symbols),
+            confidence: aggregateProcessConfidence(p.symbols),
+            ...(confidenceFieldsEnabled ? {
+                runtime_chain_confidence: aggregateProcessConfidence(p.symbols),
+                runtime_chain_evidence_level: aggregateRuntimeChainEvidenceLevel(p.symbols),
+                verification_hint: selectVerificationHint(p.symbols),
+            } : {}),
         }));
         const processSymbols = rankedProcesses.flatMap(p => p.symbols.slice(0, maxSymbolsPerProcess).map(s => ({
             ...s,
             // remove internal fields
         })));
-        // Deduplicate process_symbols by id
-        const seen = new Set();
-        const dedupedSymbols = processSymbols.filter(s => {
-            if (seen.has(s.id))
-                return false;
-            seen.add(s.id);
-            return true;
-        });
-        return {
+        // Deduplicate process_symbols by id, keeping the highest-confidence/evidence variant.
+        const dedupedById = new Map();
+        for (const symbol of processSymbols) {
+            const existing = dedupedById.get(symbol.id);
+            if (!existing) {
+                dedupedById.set(symbol.id, symbol);
+                continue;
+            }
+            const existingScore = (confidenceRank(existing.process_confidence) * 10)
+                + evidenceModeRank(existing.process_evidence_mode);
+            const nextScore = (confidenceRank(symbol.process_confidence) * 10)
+                + evidenceModeRank(symbol.process_evidence_mode);
+            if (nextScore > existingScore) {
+                dedupedById.set(symbol.id, symbol);
+            }
+        }
+        const dedupedSymbols = [...dedupedById.values()];
+        const result = {
             processes,
             process_symbols: dedupedSymbols,
             definitions: definitions.slice(0, 20), // cap standalone definitions
         };
+        if (runtimeChainVerifyMode === 'on-demand' && runtimeChainVerifyEnabled) {
+            const resourceBindings = dedupedSymbols
+                .flatMap((symbol) => (Array.isArray(symbol.resourceBindings) ? symbol.resourceBindings : []))
+                .concat(definitions.flatMap((symbol) => (Array.isArray(symbol.resourceBindings) ? symbol.resourceBindings : [])));
+            result.runtime_chain = await verifyRuntimeChainOnDemand({
+                repoPath: repo.repoPath,
+                executeParameterized: (query, queryParams) => executeParameterized(repo.id, query, queryParams || {}),
+                queryText: searchQuery,
+                resourceBindings,
+            });
+        }
+        return result;
     }
     /**
      * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results
@@ -957,6 +1130,18 @@ export class LocalBackend {
     async context(repo, params) {
         await this.ensureInitialized(repo.id);
         const { name, uid, file_path, include_content } = params;
+        const runtimeChainVerifyMode = String(params.runtime_chain_verify || 'off').trim().toLowerCase();
+        const runtimeChainVerifyEnabled = resolveUnityRuntimeChainVerifyEnabled(process.env);
+        const confidenceFieldsEnabled = resolveUnityProcessConfidenceFieldsEnabled(process.env);
+        let unityResourcesMode = 'off';
+        let unityHydrationMode = 'compact';
+        try {
+            unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
+            unityHydrationMode = parseUnityHydrationMode(params.unity_hydration_mode);
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : String(error) };
+        }
         if (!name && !uid) {
             return { error: 'Either "name" or "uid" parameter is required.' };
         }
@@ -1011,6 +1196,9 @@ export class LocalBackend {
         // Step 3: Build full context
         const sym = symbols[0];
         const symId = sym.id || sym[0];
+        const symNodeId = String(symId || '');
+        const symName = String(sym.name || sym[1] || '');
+        const symFilePath = String(sym.filePath || sym[3] || '');
         // Direct incoming refs for the selected symbol.
         const directIncomingRows = await executeParameterized(repo.id, `
       MATCH (caller)-[r:CodeRelation]->(n {id: $symId})
@@ -1068,17 +1256,34 @@ export class LocalBackend {
             incomingRows = dedupe([...directIncomingRows, ...methodIncomingRows]);
             outgoingRows = dedupe([...directOutgoingRows, ...methodOutgoingRows]);
         }
-        // Process participation
-        let processRows = [];
+        // Process participation with class-level method projection.
+        let directProcessRows = [];
+        let projectedProcessRows = [];
         try {
-            processRows = await executeParameterized(repo.id, `
+            directProcessRows = await executeParameterized(repo.id, `
         MATCH (n {id: $symId})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-        RETURN p.id AS pid, p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
+        RETURN p.id AS pid, p.heuristicLabel AS label, p.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, r.step AS step, p.stepCount AS stepCount
       `, { symId });
         }
         catch (e) {
             logQueryError('context:process-participation', e);
         }
+        if (isMethodContainer) {
+            try {
+                projectedProcessRows = await executeParameterized(repo.id, `
+          MATCH (n {id: $symId})-[:CodeRelation {type: 'HAS_METHOD'}]->(m)
+          MATCH (m)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+          RETURN p.id AS pid, p.heuristicLabel AS label, p.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, MIN(r.step) AS step, p.stepCount AS stepCount
+        `, { symId });
+            }
+            catch (e) {
+                logQueryError('context:method-process-projection', e);
+            }
+        }
+        let processRows = mergeProcessEvidence({
+            directRows: directProcessRows,
+            projectedRows: projectedProcessRows,
+        });
         // Helper to categorize refs
         const categorize = (rows) => {
             const cats = {};
@@ -1096,13 +1301,13 @@ export class LocalBackend {
             }
             return cats;
         };
-        return {
+        const result = {
             status: 'found',
             symbol: {
                 uid: sym.id || sym[0],
-                name: sym.name || sym[1],
+                name: symName,
                 kind,
-                filePath: sym.filePath || sym[3],
+                filePath: symFilePath,
                 startLine: sym.startLine || sym[4],
                 endLine: sym.endLine || sym[5],
                 ...(include_content && (sym.content || sym[6]) ? { content: sym.content || sym[6] } : {}),
@@ -1111,13 +1316,81 @@ export class LocalBackend {
             outgoing: categorize(outgoingRows),
             directIncoming: categorize(directIncomingRows),
             directOutgoing: categorize(directOutgoingRows),
-            processes: processRows.map((r) => ({
-                id: r.pid || r[0],
-                name: r.label || r[1],
-                step_index: r.step || r[2],
-                step_count: r.stepCount || r[3],
-            })),
+            processes: [],
         };
+        if (unityResourcesMode !== 'off' && symNodeId && (kind === 'Class' || symNodeId.toLowerCase().startsWith('class:'))) {
+            const unityContext = await loadUnityContext(repo.id, symNodeId, (query) => executeQuery(repo.id, query));
+            const hydratedUnityContext = await hydrateUnityForSymbol({
+                mode: unityHydrationMode,
+                basePayload: unityContext,
+                deps: {
+                    executeQuery: (query, queryParams) => {
+                        if (queryParams && Object.keys(queryParams).length > 0) {
+                            return executeParameterized(repo.id, query, queryParams);
+                        }
+                        return executeQuery(repo.id, query);
+                    },
+                    repoPath: repo.repoPath,
+                    storagePath: repo.storagePath,
+                    indexedCommit: repo.lastCommit,
+                },
+                symbol: {
+                    uid: symNodeId,
+                    name: symName,
+                    filePath: symFilePath,
+                },
+            });
+            Object.assign(result, hydratedUnityContext);
+            if (processRows.length === 0) {
+                const resourceBindings = Array.isArray(result.resourceBindings)
+                    ? result.resourceBindings
+                    : [];
+                const needsParityRetry = Boolean(result.hydrationMeta?.needsParityRetry);
+                if (resourceBindings.length > 0 || needsParityRetry) {
+                    const firstBindingPath = String(resourceBindings[0]?.resourcePath || '').trim();
+                    const verificationTarget = firstBindingPath || symFilePath || symName || symNodeId;
+                    processRows = mergeProcessEvidence({
+                        directRows: [],
+                        projectedRows: [],
+                        heuristicRows: [{
+                                pid: `proc:heuristic:${String(symNodeId || '').replace(/\s+/g, '_')}`,
+                                label: `${String(symName || 'Symbol')} runtime heuristic clue`,
+                                processType: 'unity_resource_heuristic',
+                                processSubtype: 'unity_lifecycle',
+                                runtimeChainConfidence: 'low',
+                                step: 1,
+                                stepCount: 1,
+                                needsParityRetry,
+                                verificationTarget,
+                            }],
+                    });
+                }
+            }
+        }
+        result.processes = processRows.map((r) => ({
+            id: r.pid || r[0],
+            name: r.label || r[1],
+            process_subtype: r.processSubtype || r[2],
+            step_index: r.step || r[4],
+            step_count: r.stepCount || r[5],
+            evidence_mode: r.evidence_mode,
+            confidence: r.confidence,
+            ...(confidenceFieldsEnabled ? {
+                runtime_chain_confidence: r.confidence,
+                runtime_chain_evidence_level: r.runtime_chain_evidence_level,
+                verification_hint: r.verification_hint,
+            } : {}),
+        }));
+        if (runtimeChainVerifyMode === 'on-demand' && runtimeChainVerifyEnabled) {
+            result.runtime_chain = await verifyRuntimeChainOnDemand({
+                repoPath: repo.repoPath,
+                executeParameterized: (query, queryParams) => executeParameterized(repo.id, query, queryParams || {}),
+                symbolName: symName,
+                symbolFilePath: symFilePath,
+                resourceBindings: Array.isArray(result.resourceBindings) ? result.resourceBindings : [],
+            });
+        }
+        return result;
     }
     /**
      * Legacy explore — kept for backwards compatibility with resources.ts.
@@ -1171,7 +1444,7 @@ export class LocalBackend {
             const processes = await executeParameterized(repo.id, `
         MATCH (p:Process)
         WHERE p.label = $processName OR p.heuristicLabel = $processName
-        RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount
+        RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, p.stepCount AS stepCount
         LIMIT 1
       `, { processName: name });
             if (processes.length === 0)
@@ -1180,16 +1453,24 @@ export class LocalBackend {
             const procId = proc.id || proc[0];
             const steps = await executeParameterized(repo.id, `
         MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId})
-        RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step
+        RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step, r.reason AS reason, r.confidence AS confidence
         ORDER BY r.step
       `, { procId });
             return {
                 process: {
                     id: procId, label: proc.label || proc[1], heuristicLabel: proc.heuristicLabel || proc[2],
-                    processType: proc.processType || proc[3], stepCount: proc.stepCount || proc[4],
+                    processType: proc.processType || proc[3],
+                    processSubtype: proc.processSubtype || proc[4],
+                    runtimeChainConfidence: proc.runtimeChainConfidence || proc[5],
+                    stepCount: proc.stepCount || proc[6],
                 },
                 steps: steps.map((s) => ({
-                    step: s.step || s[3], name: s.name || s[0], type: s.type || s[1], filePath: s.filePath || s[2],
+                    step: s.step || s[3],
+                    reason: s.reason || s[4],
+                    confidence: s.confidence || s[5],
+                    name: s.name || s[0],
+                    type: s.type || s[1],
+                    filePath: s.filePath || s[2],
                 })),
             };
         }
@@ -1527,13 +1808,12 @@ export class LocalBackend {
             // Bridge class-like symbols through HAS_METHOD so class-level impact includes method-level dependencies.
             if (shouldBridgeClassMethods) {
                 if (frontier.length > 0) {
-                    const bridgeIdList = frontier.map(id => `'${id.replace(/'/g, "''")}'`).join(', ');
                     try {
-                        const bridgeRows = await executeQuery(repo.id, `
+                        const bridgeRows = await executeParameterized(repo.id, `
               MATCH (container)-[r:CodeRelation {type: 'HAS_METHOD'}]->(method)
-              WHERE container.id IN [${bridgeIdList}]${confidenceFilter}
+              WHERE container.id IN $frontierIds${confidenceFilter}
               RETURN container.id AS containerId, method.id AS methodId, method.name AS methodName, labels(method)[0] AS methodType, method.filePath AS methodFilePath
-            `);
+            `, { frontierIds: frontier });
                         for (const bridge of bridgeRows) {
                             const methodId = bridge.methodId || bridge[1];
                             const methodType = bridge.methodType || bridge[3];
@@ -1575,12 +1855,11 @@ export class LocalBackend {
             // de-dupe traversal frontier (class + bridged methods)
             traversalFrontier = [...new Set(traversalFrontier)];
             // Batch frontier nodes into a single Cypher query per depth level
-            const idList = traversalFrontier.map(id => `'${id.replace(/'/g, "''")}'`).join(', ');
             const query = direction === 'upstream'
-                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
-                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN [${idList}] AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
+                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN $frontierIds AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
+                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN $frontierIds AND r.type IN [${relTypeFilter}]${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
             try {
-                const related = await executeQuery(repo.id, query);
+                const related = await executeParameterized(repo.id, query, { frontierIds: traversalFrontier });
                 for (const rel of related) {
                     const relId = rel.id || rel[1];
                     const filePath = rel.filePath || rel[4] || '';
@@ -1738,7 +2017,7 @@ export class LocalBackend {
         try {
             const processes = await executeQuery(repo.id, `
         MATCH (p:Process)
-        RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount
+        RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, p.stepCount AS stepCount
         ORDER BY p.stepCount DESC
         LIMIT ${limit}
       `);
@@ -1748,7 +2027,9 @@ export class LocalBackend {
                     label: p.label || p[1],
                     heuristicLabel: p.heuristicLabel || p[2],
                     processType: p.processType || p[3],
-                    stepCount: p.stepCount || p[4],
+                    processSubtype: p.processSubtype || p[4],
+                    runtimeChainConfidence: p.runtimeChainConfidence || p[5],
+                    stepCount: p.stepCount || p[6],
                 })),
             };
         }
@@ -1810,7 +2091,7 @@ export class LocalBackend {
         const processes = await executeParameterized(repo.id, `
       MATCH (p:Process)
       WHERE p.label = $processName OR p.heuristicLabel = $processName
-      RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.stepCount AS stepCount
+      RETURN p.id AS id, p.label AS label, p.heuristicLabel AS heuristicLabel, p.processType AS processType, p.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, p.stepCount AS stepCount
       LIMIT 1
     `, { processName: name });
         if (processes.length === 0)
@@ -1819,16 +2100,24 @@ export class LocalBackend {
         const procId = proc.id || proc[0];
         const steps = await executeParameterized(repo.id, `
       MATCH (n)-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p {id: $procId})
-      RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step
+      RETURN n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, r.step AS step, r.reason AS reason, r.confidence AS confidence
       ORDER BY r.step
     `, { procId });
         return {
             process: {
                 id: procId, label: proc.label || proc[1], heuristicLabel: proc.heuristicLabel || proc[2],
-                processType: proc.processType || proc[3], stepCount: proc.stepCount || proc[4],
+                processType: proc.processType || proc[3],
+                processSubtype: proc.processSubtype || proc[4],
+                runtimeChainConfidence: proc.runtimeChainConfidence || proc[5],
+                stepCount: proc.stepCount || proc[6],
             },
             steps: steps.map((s) => ({
-                step: s.step || s[3], name: s.name || s[0], type: s.type || s[1], filePath: s.filePath || s[2],
+                step: s.step || s[3],
+                reason: s.reason || s[4],
+                confidence: s.confidence || s[5],
+                name: s.name || s[0],
+                type: s.type || s[1],
+                filePath: s.filePath || s[2],
             })),
         };
     }

package/dist/mcp/local/local-backend.unity-merge.test.js

@@ -2,7 +2,7 @@ import test from 'node:test';
 import assert from 'node:assert/strict';
 import { projectUnityBindings } from './unity-enrichment.js';
 import { hydrateLazyBindings } from './unity-lazy-hydrator.js';
-import { attachUnityHydrationMeta, mergeParityUnityBindings, mergeUnityBindings } from './local-backend.js';
+import { attachUnityHydrationMeta, mergeParityUnityBindings, mergeUnityBindings } from './unity-runtime-hydration.js';
 test('summary-only rows hydrate and merge into full bindings with preserved field coverage', async () => {
     const projected = projectUnityBindings([
         {

package/dist/mcp/local/process-confidence.d.ts

@@ -0,0 +1,19 @@
+export type ProcessEvidenceMode = 'direct_step' | 'method_projected' | 'resource_heuristic';
+export type ProcessConfidence = 'high' | 'medium' | 'low';
+export interface VerificationHint {
+    action: 'rerun_parity_hydration' | 'manual_asset_meta_verification';
+    target: string;
+    next_command: string;
+}
+export interface DeriveConfidenceInput {
+    evidenceMode: ProcessEvidenceMode;
+    processSubtype?: string;
+    hasPartialUnityEvidence?: boolean;
+}
+export interface BuildVerificationHintInput {
+    confidence: ProcessConfidence;
+    needsParityRetry?: boolean;
+    target?: string;
+}
+export declare function deriveConfidence(input: DeriveConfidenceInput): ProcessConfidence;
+export declare function buildVerificationHint(input: BuildVerificationHintInput): VerificationHint | undefined;

package/dist/mcp/local/process-confidence.js

@@ -0,0 +1,29 @@
+export function deriveConfidence(input) {
+    if (input.evidenceMode === 'resource_heuristic') {
+        return 'low';
+    }
+    if (input.evidenceMode === 'method_projected') {
+        return 'medium';
+    }
+    if (String(input.processSubtype || '').toLowerCase() === 'unity_lifecycle') {
+        return 'medium';
+    }
+    return 'high';
+}
+export function buildVerificationHint(input) {
+    if (input.confidence !== 'low')
+        return undefined;
+    const target = String(input.target || '').trim() || 'unity-runtime-chain';
+    if (input.needsParityRetry) {
+        return {
+            action: 'rerun_parity_hydration',
+            target,
+            next_command: 'GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on gitnexus query --unity-resources on --unity-hydration parity "<symbol-or-query>"',
+        };
+    }
+    return {
+        action: 'manual_asset_meta_verification',
+        target,
+        next_command: 'Inspect asset + .meta linkage for this target, then rerun query/context with --unity-resources on --unity-hydration parity',
+    };
+}

package/dist/mcp/local/process-confidence.test.d.ts

@@ -0,0 +1 @@
+export {};