@veewo/gitnexus 1.4.11-rc.2 → 1.5.0-rc.2

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

@@ -8,19 +8,27 @@
 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 { parseHydrationPolicy, parseUnityEvidenceMode, parseUnityHydrationMode, parseUnityResourcesMode } from '../../core/unity/options.js';
+import { buildAssetMetaIndex } from '../../core/unity/meta-index.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';
+import { buildMissingEvidenceFromHydrationMeta, hydrateUnityForSymbol } from './unity-runtime-hydration.js';
+import { buildUnityEvidenceView } from './unity-evidence-view.js';
+import { deriveEvidenceFingerprint, mergeProcessEvidence } from './process-evidence.js';
+import { buildProcessRef } from './process-ref.js';
+import { verifyRuntimeClaimOnDemand, } 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
 // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js';
 import { listRegisteredRepos, cleanupOldKuzuFiles, } from '../../storage/repo-manager.js';
+import { discoverRuleLabRun } from '../../rule-lab/discover.js';
+import { analyzeRuleLabSlice } from '../../rule-lab/analyze.js';
+import { buildReviewPack } from '../../rule-lab/review-pack.js';
+import { curateRuleLabSlice } from '../../rule-lab/curate.js';
+import { promoteCuratedRules } from '../../rule-lab/promote.js';
+import { runRuleLabRegress } from '../../rule-lab/regress.js';
+import { loadCompiledRuleBundle } from '../../rule-lab/compiled-bundles.js';
 // AI context generation is CLI-only (gitnexus analyze)
 // import { generateAIContextFiles } from '../../cli/ai-context.js';
 /**
@@ -40,6 +48,9 @@ export function isTestFilePath(filePath) {
 function normalizePath(filePath) {
     return String(filePath || '').replace(/\\/g, '/');
 }
+function isUnityResourcePathLike(value) {
+    return /\.(asset|prefab|meta)$/i.test(String(value || '').trim());
+}
 const UNITY_GAMEPLAY_INCLUDE_PREFIXES = ['assets/'];
 const UNITY_GAMEPLAY_EXCLUDE_PREFIXES = [
     'assets/plugins/',
@@ -54,6 +65,44 @@ const QUERY_STOP_WORDS = new Set([
     'the', 'and', 'for', 'from', 'with', 'that', 'this', 'into',
     'using', 'use', 'in', 'on', 'of', 'to', 'a', 'an',
 ]);
+function resolveHydrationModeDecision(input) {
+    const { hydrationPolicy, unityHydrationMode } = input;
+    if (hydrationPolicy === 'strict') {
+        return {
+            requestedMode: 'parity',
+            reason: unityHydrationMode === 'parity'
+                ? 'hydration_policy_strict'
+                : 'hydration_policy_strict_overrides_unity_hydration_mode',
+        };
+    }
+    if (hydrationPolicy === 'fast') {
+        return {
+            requestedMode: 'compact',
+            reason: unityHydrationMode === 'compact'
+                ? 'hydration_policy_fast'
+                : 'hydration_policy_fast_overrides_unity_hydration_mode',
+        };
+    }
+    return {
+        requestedMode: unityHydrationMode,
+        reason: unityHydrationMode === 'parity'
+            ? 'hydration_policy_balanced_respects_unity_hydration_mode'
+            : 'hydration_policy_balanced_default_compact',
+    };
+}
+function withHydrationDecisionMeta(input) {
+    if (!input.payload.hydrationMeta) {
+        return input.payload;
+    }
+    return {
+        ...input.payload,
+        hydrationMeta: {
+            ...input.payload.hydrationMeta,
+            requestedMode: input.requestedMode,
+            reason: input.reason,
+        },
+    };
+}
 function tokenizeQuery(query) {
     const normalized = String(query || '').toLowerCase();
     return normalized
@@ -98,6 +147,306 @@ function aggregateProcessEvidenceMode(rows) {
 function selectVerificationHint(rows) {
     return rows.find((row) => row.verification_hint)?.verification_hint;
 }
+export function parseResourceSeedMode(raw) {
+    const normalized = String(raw || '').trim().toLowerCase();
+    if (!normalized || normalized === 'balanced')
+        return 'balanced';
+    if (normalized === 'strict')
+        return 'strict';
+    throw new Error('resource_seed_mode must be one of: strict, balanced');
+}
+function isUnityResourcePath(value) {
+    return /\.(asset|prefab|unity)$/i.test(value.trim());
+}
+export function extractUnityResourcePaths(text) {
+    const out = [];
+    const re = /(Assets\/[^\s'"`]+?\.(?:asset|prefab|unity))/gi;
+    let match = re.exec(String(text || ''));
+    while (match) {
+        const path = normalizePath(match[1] || '').trim();
+        if (path && !out.includes(path))
+            out.push(path);
+        match = re.exec(String(text || ''));
+    }
+    return out;
+}
+export function resolveSeedPath(input) {
+    const explicit = normalizePath(String(input.resourcePathPrefix || '').trim());
+    if (explicit && isUnityResourcePath(explicit)) {
+        return explicit;
+    }
+    const fromFile = normalizePath(String(input.filePath || '').trim());
+    if (fromFile && isUnityResourcePath(fromFile)) {
+        return fromFile;
+    }
+    const fromQuery = extractUnityResourcePaths(String(input.queryText || ''));
+    return fromQuery[0];
+}
+function pathTokens(value) {
+    return String(value || '')
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+}
+function parseSeedRelationReason(rawReason) {
+    const text = String(rawReason || '').trim();
+    if (!text)
+        return {};
+    try {
+        const parsed = JSON.parse(text);
+        const fieldName = String(parsed.fieldName || '').trim();
+        const sourceLayer = String(parsed.sourceLayer || '').trim();
+        return {
+            ...(fieldName ? { fieldName } : {}),
+            ...(sourceLayer ? { sourceLayer } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function scoreSeedTargetCandidate(seedPath, candidate) {
+    const targetPath = normalizePath(candidate.targetPath);
+    if (!targetPath)
+        return Number.NEGATIVE_INFINITY;
+    const seedBase = path.basename(normalizePath(seedPath), path.extname(seedPath)).toLowerCase();
+    const targetBase = path.basename(targetPath, path.extname(targetPath)).toLowerCase();
+    const seedTokens = new Set(pathTokens(seedBase));
+    const targetTokens = new Set(pathTokens(targetBase));
+    let overlap = 0;
+    for (const token of seedTokens) {
+        if (targetTokens.has(token))
+            overlap += 1;
+    }
+    const p = targetPath.toLowerCase();
+    let score = 0;
+    if (/\.(asset)$/i.test(p))
+        score += 12;
+    if (/\.(prefab)$/i.test(p))
+        score -= 8;
+    if (p.includes('/graph'))
+        score += 30;
+    if (targetBase && seedBase && (targetBase.includes(seedBase) || seedBase.includes(targetBase)))
+        score += 18;
+    score += overlap * 8;
+    const fieldName = String(candidate.fieldName || '').toLowerCase();
+    const fieldTokens = new Set(pathTokens(fieldName));
+    for (const token of seedTokens) {
+        if (fieldTokens.has(token))
+            score += 10;
+    }
+    const graphSignals = ['graph', 'node', 'loader', 'runtime'];
+    for (const token of graphSignals) {
+        if (fieldTokens.has(token))
+            score += 12;
+    }
+    const visualSignals = ['sprite', 'icon', 'material', 'vfx', 'fx', 'audio'];
+    for (const token of visualSignals) {
+        if (fieldTokens.has(token))
+            score -= 8;
+    }
+    const sourceLayer = String(candidate.sourceLayer || '').toLowerCase();
+    if (sourceLayer.includes('asset'))
+        score += 4;
+    return score;
+}
+function rankSeedTargetCandidates(seedPath, candidates) {
+    const deduped = new Map();
+    for (const candidate of candidates) {
+        const targetPath = normalizePath(String(candidate.targetPath || '').trim());
+        if (!targetPath)
+            continue;
+        const existing = deduped.get(targetPath);
+        if (!existing) {
+            deduped.set(targetPath, { ...candidate, targetPath });
+            continue;
+        }
+        if (!existing.fieldName && candidate.fieldName)
+            existing.fieldName = candidate.fieldName;
+        if (!existing.sourceLayer && candidate.sourceLayer)
+            existing.sourceLayer = candidate.sourceLayer;
+    }
+    return [...deduped.values()]
+        .sort((a, b) => {
+        const scoreDiff = scoreSeedTargetCandidate(seedPath, b) - scoreSeedTargetCandidate(seedPath, a);
+        if (scoreDiff !== 0)
+            return scoreDiff;
+        return String(a.targetPath).localeCompare(String(b.targetPath));
+    })
+        .map((candidate) => candidate.targetPath);
+}
+export function pickVerificationTarget(input) {
+    const normalizedBindings = input.resourceBindings.map((binding) => normalizePath(String(binding.resourcePath || '').trim()));
+    const bindingSet = new Set(normalizedBindings);
+    const mappedInBindings = input.mappedSeedTargets.find((target) => bindingSet.has(normalizePath(target)));
+    if (mappedInBindings)
+        return mappedInBindings;
+    if (input.seedMode === 'strict' && input.seedPath) {
+        return normalizePath(input.seedPath);
+    }
+    if (input.seedMode === 'strict') {
+        return input.fallback;
+    }
+    // Balanced mode fallback only; strict mode is handled above and never falls back to first binding.
+    return normalizedBindings[0] || input.fallback;
+}
+export function buildNextHops(input) {
+    const hops = [];
+    const seen = new Set();
+    const addHop = (hop) => {
+        const key = `${hop.kind}:${hop.target}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        hops.push(hop);
+    };
+    const bindingPaths = input.resourceBindings.map((binding) => normalizePath(String(binding.resourcePath || '').trim())).filter(Boolean);
+    const bindingSet = new Set(bindingPaths);
+    const mappedIntersectBindings = input.mappedSeedTargets
+        .map((value) => normalizePath(value))
+        .filter((value) => value && bindingSet.has(value));
+    const mappedRemainder = input.mappedSeedTargets
+        .map((value) => normalizePath(value))
+        .filter((value) => value && !bindingSet.has(value));
+    const retrievalHostScope = (input.retrievalRule?.host_base_type || [])
+        .map((value) => String(value || '').trim().toLowerCase())
+        .filter(Boolean);
+    const currentSymbolMatchesRetrievalScope = retrievalHostScope.length === 0
+        || retrievalHostScope.includes(String(input.symbolName || '').trim().toLowerCase());
+    const shouldSuppressRawResourceHops = !input.seedPath
+        && mappedIntersectBindings.length === 0
+        && currentSymbolMatchesRetrievalScope === false;
+    const candidateResources = shouldSuppressRawResourceHops ? [] : [
+        ...mappedIntersectBindings,
+        ...mappedRemainder,
+        ...(input.seedPath ? [normalizePath(input.seedPath)] : []),
+        ...bindingPaths,
+    ].filter(Boolean);
+    const repoArg = input.repoName ? ` --repo "${input.repoName}"` : '';
+    const withRepoInCommand = (command) => {
+        const trimmed = String(command || '').trim();
+        if (!trimmed || !input.repoName)
+            return trimmed;
+        if (!/^gitnexus\s+(query|context)\b/i.test(trimmed))
+            return trimmed;
+        if (/\s--repo(?:\s|=)/i.test(trimmed))
+            return trimmed;
+        return trimmed.replace(/^gitnexus\s+(query|context)\b/i, `gitnexus $1 --repo "${input.repoName}"`);
+    };
+    for (const target of candidateResources.slice(0, 3)) {
+        addHop({
+            kind: 'resource',
+            target,
+            why: 'Unity resource evidence suggests this is the next deterministic hop.',
+            next_command: `gitnexus query${repoArg} --unity-resources on --unity-hydration parity --resource-path-prefix "${target}" "${input.queryForSymbol}"`,
+        });
+    }
+    if (input.retrievalRule?.next_action) {
+        addHop({
+            kind: 'verify',
+            target: input.seedPath || input.symbolName,
+            why: `Retrieval rule ${input.retrievalRule.id} configured this follow-up action.`,
+            next_command: withRepoInCommand(input.retrievalRule.next_action),
+        });
+    }
+    if (input.verificationHint?.target
+        && !(shouldSuppressRawResourceHops && isUnityResourcePathLike(String(input.verificationHint.target)))) {
+        addHop({
+            kind: 'verify',
+            target: String(input.verificationHint.target),
+            why: 'Low-confidence evidence requires a verification follow-up.',
+            next_command: withRepoInCommand(input.verificationHint.next_command),
+        });
+    }
+    addHop({
+        kind: 'symbol',
+        target: input.symbolName,
+        why: 'Inspect symbol-level context to continue tracing.',
+        next_command: `gitnexus context${repoArg} --unity-resources on --unity-hydration parity "${input.symbolName}"`,
+    });
+    return hops.slice(0, 5);
+}
+async function resolveRetrievalRuleHint(input) {
+    const bundle = await loadCompiledRuleBundle(input.repoPath, 'retrieval_rules');
+    if (!bundle)
+        return undefined;
+    return pickRetrievalRuleHintFromBundle({
+        queryText: input.queryText,
+        symbolName: input.symbolName,
+        seedPath: input.seedPath,
+        rules: bundle.rules,
+    });
+}
+export function pickRetrievalRuleHintFromBundle(input) {
+    const haystack = [
+        String(input.queryText || ''),
+        String(input.symbolName || ''),
+        String(input.seedPath || ''),
+    ].join(' ').toLowerCase();
+    const rank = (rule) => {
+        let score = 0;
+        let matchedTrigger = false;
+        for (const token of rule.trigger_tokens || []) {
+            const normalized = String(token || '').trim().toLowerCase();
+            if (!normalized)
+                continue;
+            if (haystack.includes(normalized)) {
+                matchedTrigger = true;
+                score += 10 + normalized.length;
+            }
+        }
+        if (!matchedTrigger)
+            return Number.NEGATIVE_INFINITY;
+        for (const token of rule.host_base_type || []) {
+            const normalized = String(token || '').trim().toLowerCase();
+            if (normalized && haystack.includes(normalized))
+                score += 20 + normalized.length;
+        }
+        for (const token of rule.resource_types || []) {
+            const normalized = String(token || '').trim().toLowerCase();
+            if (normalized && haystack.includes(normalized))
+                score += 4 + normalized.length;
+        }
+        return score;
+    };
+    const matched = [...input.rules]
+        .map((rule) => ({ rule, score: rank(rule) }))
+        .filter((entry) => Number.isFinite(entry.score))
+        .sort((a, b) => (b.score - a.score) || a.rule.id.localeCompare(b.rule.id))[0]?.rule;
+    if (!matched || !String(matched.next_action || '').trim())
+        return undefined;
+    return {
+        id: matched.id,
+        next_action: matched.next_action,
+        host_base_type: matched.host_base_type,
+    };
+}
+export async function resolveSeedTargetsFromResourceFile(repoPath, seedPath) {
+    if (!isUnityResourcePath(seedPath))
+        return [];
+    try {
+        const absPath = path.join(repoPath, seedPath);
+        const raw = await fs.readFile(absPath, 'utf-8');
+        const guidMatches = [...raw.matchAll(/\bguid:\s*([0-9a-f]{32})\b/ig)];
+        if (guidMatches.length === 0)
+            return [];
+        const guidSet = new Set(guidMatches.map((m) => String(m[1] || '').toLowerCase()).filter(Boolean));
+        const metaIndex = await buildAssetMetaIndex(repoPath);
+        const out = [];
+        for (const guid of guidSet) {
+            const targetPath = normalizePath(String(metaIndex.get(guid) || '').trim());
+            if (!targetPath || targetPath === normalizePath(seedPath) || !isUnityResourcePath(targetPath))
+                continue;
+            if (!out.includes(targetPath))
+                out.push(targetPath);
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
 function aggregateRuntimeChainEvidenceLevel(rows) {
     if (rows.some((row) => row.runtime_chain_evidence_level === 'verified_chain'))
         return 'verified_chain';
@@ -107,6 +456,13 @@ function aggregateRuntimeChainEvidenceLevel(rows) {
         return 'clue';
     return 'none';
 }
+function toProcessRefOrigin(mode) {
+    if (mode === 'direct_step')
+        return 'step_in_process';
+    if (mode === 'method_projected')
+        return 'method_projected';
+    return 'resource_heuristic';
+}
 function confidenceRank(confidence) {
     if (confidence === 'high')
         return 3;
@@ -498,6 +854,18 @@ export class LocalBackend {
                 return this.detectChanges(repo, params);
             case 'rename':
                 return this.rename(repo, params);
+            case 'rule_lab_discover':
+                return this.ruleLabDiscover(repo, params);
+            case 'rule_lab_analyze':
+                return this.ruleLabAnalyze(repo, params);
+            case 'rule_lab_review_pack':
+                return this.ruleLabReviewPack(repo, params);
+            case 'rule_lab_curate':
+                return this.ruleLabCurate(repo, params);
+            case 'rule_lab_promote':
+                return this.ruleLabPromote(repo, params);
+            case 'rule_lab_regress':
+                return this.ruleLabRegress(repo, params);
             // Legacy aliases for backwards compatibility
             case 'search':
                 return this.query(repo, params);
@@ -534,6 +902,155 @@ export class LocalBackend {
             return { error: err?.message || 'unity_ui_trace failed' };
         }
     }
+    async ruleLabDiscover(repo, params) {
+        try {
+            const out = await discoverRuleLabRun({
+                repoPath: repo.repoPath,
+                scope: params?.scope === 'diff' ? 'diff' : 'full',
+                seed: typeof params?.seed === 'string' ? params.seed : undefined,
+            });
+            return {
+                ...out,
+                artifact_paths: {
+                    manifest: out.paths.manifestPath,
+                    run_root: out.paths.runRoot,
+                },
+            };
+        }
+        catch (err) {
+            return { error: err?.message || 'rule_lab_discover failed' };
+        }
+    }
+    async ruleLabAnalyze(repo, params) {
+        const runId = String(params?.run_id || params?.runId || '').trim();
+        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
+        if (!runId || !sliceId) {
+            return { error: 'run_id and slice_id are required for rule_lab_analyze' };
+        }
+        try {
+            const out = await analyzeRuleLabSlice({
+                repoPath: repo.repoPath,
+                runId,
+                sliceId,
+            });
+            return {
+                ...out,
+                artifact_paths: {
+                    candidates: out.paths.candidatesPath,
+                },
+            };
+        }
+        catch (err) {
+            return { error: err?.message || 'rule_lab_analyze failed' };
+        }
+    }
+    async ruleLabReviewPack(repo, params) {
+        const runId = String(params?.run_id || params?.runId || '').trim();
+        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
+        if (!runId || !sliceId) {
+            return { error: 'run_id and slice_id are required for rule_lab_review_pack' };
+        }
+        const maxTokens = Number.isFinite(Number(params?.max_tokens ?? params?.maxTokens))
+            ? Number(params?.max_tokens ?? params?.maxTokens)
+            : 6000;
+        try {
+            const out = await buildReviewPack({
+                repoPath: repo.repoPath,
+                runId,
+                sliceId,
+                maxTokens,
+            });
+            return {
+                ...out,
+                artifact_paths: {
+                    review_pack: out.paths.reviewCardsPath,
+                },
+            };
+        }
+        catch (err) {
+            return { error: err?.message || 'rule_lab_review_pack failed' };
+        }
+    }
+    async ruleLabCurate(repo, params) {
+        const runId = String(params?.run_id || params?.runId || '').trim();
+        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
+        const inputPath = String(params?.input_path || params?.inputPath || '').trim();
+        if (!runId || !sliceId || !inputPath) {
+            return { error: 'run_id, slice_id, and input_path are required for rule_lab_curate' };
+        }
+        try {
+            const out = await curateRuleLabSlice({
+                repoPath: repo.repoPath,
+                runId,
+                sliceId,
+                inputPath,
+            });
+            return {
+                ...out,
+                artifact_paths: {
+                    curated: out.paths.curatedPath,
+                },
+            };
+        }
+        catch (err) {
+            return { error: err?.message || 'rule_lab_curate failed' };
+        }
+    }
+    async ruleLabPromote(repo, params) {
+        const runId = String(params?.run_id || params?.runId || '').trim();
+        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
+        if (!runId || !sliceId) {
+            return { error: 'run_id and slice_id are required for rule_lab_promote' };
+        }
+        try {
+            const out = await promoteCuratedRules({
+                repoPath: repo.repoPath,
+                runId,
+                sliceId,
+                version: typeof params?.version === 'string' ? params.version : undefined,
+            });
+            return {
+                ...out,
+                artifact_paths: {
+                    catalog: path.join(out.paths.rulesRoot, 'catalog.json'),
+                    promoted_files: out.promotedFiles,
+                    compiled_bundles: out.compiledPaths,
+                },
+            };
+        }
+        catch (err) {
+            return { error: err?.message || 'rule_lab_promote failed' };
+        }
+    }
+    async ruleLabRegress(repo, params) {
+        const precision = Number(params?.precision);
+        const coverage = Number(params?.coverage);
+        if (!Number.isFinite(precision) || !Number.isFinite(coverage)) {
+            return { error: 'precision and coverage are required numeric fields for rule_lab_regress' };
+        }
+        try {
+            let probes = Array.isArray(params?.probes) ? params.probes : undefined;
+            const probesPath = String(params?.probes_path || params?.probesPath || '').trim();
+            if (!probes && probesPath) {
+                const raw = await fs.readFile(path.isAbsolute(probesPath) ? probesPath : path.join(repo.repoPath, probesPath), 'utf-8');
+                probes = JSON.parse(raw);
+            }
+            const out = await runRuleLabRegress({
+                precision,
+                coverage,
+                probes,
+                repoPath: repo.repoPath,
+                runId: String(params?.run_id || params?.runId || '').trim() || undefined,
+            });
+            return {
+                ...out,
+                artifact_paths: out.reportPath ? { report: out.reportPath } : {},
+            };
+        }
+        catch (err) {
+            return { error: err?.message || 'rule_lab_regress failed' };
+        }
+    }
     // ─── Tool Implementations ────────────────────────────────────────
     /**
      * Query tool — process-grouped search.
@@ -551,19 +1068,64 @@ 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);
+        const confidenceFieldsEnabled = true;
         let unityResourcesMode = 'off';
         let unityHydrationMode = 'compact';
+        let unityEvidenceMode = 'summary';
+        let hydrationPolicy = 'balanced';
+        let resourceSeedMode = 'balanced';
         try {
             unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
             unityHydrationMode = parseUnityHydrationMode(params.unity_hydration_mode);
+            unityEvidenceMode = parseUnityEvidenceMode(params.unity_evidence_mode);
+            hydrationPolicy = parseHydrationPolicy(params.hydration_policy);
+            resourceSeedMode = parseResourceSeedMode(params.resource_seed_mode);
         }
         catch (error) {
             return { error: error instanceof Error ? error.message : String(error) };
         }
+        const evidenceMaxBindings = Number.isFinite(Number(params.max_bindings))
+            ? Number(params.max_bindings)
+            : undefined;
+        const evidenceMaxReferenceFields = Number.isFinite(Number(params.max_reference_fields))
+            ? Number(params.max_reference_fields)
+            : undefined;
+        const evidenceResourcePathPrefix = String(params.resource_path_prefix || '').trim() || undefined;
+        const seedPath = resolveSeedPath({
+            queryText: params.query,
+            resourcePathPrefix: evidenceResourcePathPrefix,
+        });
+        const evidenceBindingKind = String(params.binding_kind || '').trim() || undefined;
         const searchQuery = params.query.trim();
         const runtimeChainVerifyMode = String(params.runtime_chain_verify || 'off').trim().toLowerCase();
-        const runtimeChainVerifyEnabled = resolveUnityRuntimeChainVerifyEnabled(process.env);
+        let mappedSeedTargets = [];
+        if (seedPath) {
+            try {
+                const seedRows = await executeParameterized(repo.id, `
+          MATCH (:File {filePath: $seedPath})-[r:CodeRelation {type: 'UNITY_ASSET_GUID_REF'}]->(target:File)
+          RETURN DISTINCT target.filePath AS targetPath, r.reason AS relationReason
+          LIMIT 100
+        `, { seedPath });
+                const candidates = seedRows
+                    .map((row) => {
+                    const targetPath = normalizePath(String(row?.targetPath || row?.[0] || '').trim());
+                    const parsedReason = parseSeedRelationReason(row?.relationReason);
+                    return {
+                        targetPath,
+                        fieldName: parsedReason.fieldName,
+                        sourceLayer: parsedReason.sourceLayer,
+                    };
+                })
+                    .filter((row) => row.targetPath.length > 0);
+                mappedSeedTargets = rankSeedTargetCandidates(seedPath, candidates);
+            }
+            catch (e) {
+                logQueryError('query:seed-mapped-targets', e);
+            }
+            if (mappedSeedTargets.length === 0) {
+                mappedSeedTargets = rankSeedTargetCandidates(seedPath, (await resolveSeedTargetsFromResourceFile(repo.repoPath, seedPath)).map((targetPath) => ({ targetPath })));
+            }
+        }
         // Step 1: Run hybrid search to get matching symbols
         const searchLimit = processLimit * maxSymbolsPerProcess; // fetch enough raw results
         const [bm25Results, semanticResults] = await Promise.all([
@@ -682,21 +1244,41 @@ export class LocalBackend {
                     logQueryError('query:content-fetch', e);
                 }
             }
-            const symbolEntry = {
-                id: sym.nodeId,
-                name: sym.name,
-                type: sym.type,
-                filePath: sym.filePath,
-                startLine: sym.startLine,
-                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)),
+            let unityPayload = {};
+            if (unityResourcesMode !== 'off'
+                && sym.nodeId
+                && (sym.type === 'Class' || String(sym.nodeId).toLowerCase().startsWith('class:'))) {
+                const basePayload = await loadUnityContext(repo.id, sym.nodeId, (query) => executeQuery(repo.id, query));
+                const hydrationDecision = resolveHydrationModeDecision({
+                    hydrationPolicy,
+                    unityHydrationMode,
+                });
+                let hydrationReason = hydrationDecision.reason;
+                let hydrated = await hydrateUnityForSymbol({
+                    mode: hydrationDecision.requestedMode,
+                    basePayload,
+                    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 || '',
+                    },
+                });
+                const firstMissingEvidence = buildMissingEvidenceFromHydrationMeta(hydrated.hydrationMeta);
+                if (hydrationPolicy === 'balanced' && firstMissingEvidence.length > 0 && hydrated.hydrationMeta?.needsParityRetry) {
+                    hydrated = await hydrateUnityForSymbol({
+                        mode: 'parity',
+                        basePayload,
                         deps: {
                             executeQuery: (query, queryParams) => {
                                 if (queryParams && Object.keys(queryParams).length > 0) {
@@ -713,9 +1295,51 @@ export class LocalBackend {
                             name: sym.name || '',
                             filePath: sym.filePath || '',
                         },
-                    })
-                    : {}),
+                    });
+                    hydrationReason = 'hydration_policy_balanced_escalated_to_parity_on_missing_evidence';
+                }
+                if (hydrated.hydrationMeta?.fallbackToCompact) {
+                    hydrationReason = `${hydrationReason}+fallback_to_compact`;
+                }
+                hydrated = withHydrationDecisionMeta({
+                    payload: hydrated,
+                    requestedMode: hydrationDecision.requestedMode,
+                    reason: hydrationReason,
+                });
+                const finalMissingEvidence = buildMissingEvidenceFromHydrationMeta(hydrated.hydrationMeta);
+                unityPayload = {
+                    ...hydrated,
+                    missing_evidence: hydrationPolicy === 'balanced'
+                        ? [...new Set([...firstMissingEvidence, ...finalMissingEvidence])]
+                        : finalMissingEvidence,
+                };
+            }
+            const symbolEntry = {
+                id: sym.nodeId,
+                name: sym.name,
+                type: sym.type,
+                filePath: sym.filePath,
+                startLine: sym.startLine,
+                endLine: sym.endLine,
+                ...(module ? { module } : {}),
+                ...(includeContent && content ? { content } : {}),
+                ...unityPayload,
             };
+            if (Array.isArray(symbolEntry.resourceBindings) && symbolEntry.resourceBindings.length > 0) {
+                const evidenceView = buildUnityEvidenceView({
+                    resourceBindings: symbolEntry.resourceBindings,
+                    mode: unityEvidenceMode,
+                    scopePreset: params.scope_preset,
+                    resourcePathPrefix: evidenceResourcePathPrefix,
+                    bindingKind: evidenceBindingKind,
+                    maxBindings: evidenceMaxBindings,
+                    maxReferenceFields: evidenceMaxReferenceFields,
+                });
+                symbolEntry.resourceBindings = evidenceView.resourceBindings;
+                symbolEntry.serializedFields = evidenceView.serializedFields;
+                symbolEntry.evidence_meta = evidenceView.evidence_meta;
+                symbolEntry.filter_diagnostics = evidenceView.filter_diagnostics;
+            }
             if (processRows.length === 0 && unityResourcesMode !== 'off') {
                 const resourceBindings = Array.isArray(symbolEntry.resourceBindings)
                     ? symbolEntry.resourceBindings
@@ -723,8 +1347,13 @@ export class LocalBackend {
                 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;
+                    const verificationTarget = pickVerificationTarget({
+                        seedMode: resourceSeedMode,
+                        seedPath,
+                        mappedSeedTargets,
+                        resourceBindings,
+                        fallback: String(sym.filePath || sym.name || sym.nodeId || ''),
+                    });
                     processRows = mergeProcessEvidence({
                         directRows: [],
                         projectedRows: [],
@@ -749,15 +1378,37 @@ export class LocalBackend {
             else {
                 // Add to each process it belongs to
                 for (const row of processRows) {
-                    const pid = String(row.pid || '');
+                    const rawPid = 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);
+                    const process_ref = buildProcessRef({
+                        repoName: repo.name,
+                        processId: rawPid,
+                        origin: toProcessRefOrigin(row.evidence_mode),
+                        indexedCommit: String(repo.lastCommit || 'unknown_commit'),
+                        symbolUid: String(sym.nodeId || ''),
+                        evidenceFingerprint: deriveEvidenceFingerprint({ nodeId: sym.nodeId, filePath: sym.filePath, startLine: sym.startLine, endLine: sym.endLine }, {
+                            pid: rawPid,
+                            processSubtype: row.processSubtype || '',
+                            evidenceMode: row.evidence_mode,
+                            step,
+                            stepCount,
+                        }, Array.isArray(symbolEntry.resourceBindings)
+                            ? symbolEntry.resourceBindings.map((binding) => ({
+                                resourcePath: binding.resourcePath,
+                                bindingKind: binding.bindingKind,
+                                componentObjectId: binding.componentObjectId,
+                            }))
+                            : []),
+                    });
+                    const pid = process_ref.id;
                     if (!processMap.has(pid)) {
                         processMap.set(pid, {
                             id: pid,
+                            process_ref,
                             label,
                             heuristicLabel: hLabel,
                             processType: pType,
@@ -775,6 +1426,7 @@ export class LocalBackend {
                     proc.symbols.push({
                         ...symbolEntry,
                         process_id: pid,
+                        process_ref,
                         step_index: step,
                         process_subtype: String(row.processSubtype || ''),
                         process_evidence_mode: row.evidence_mode,
@@ -799,6 +1451,7 @@ export class LocalBackend {
         // Step 4: Build response
         const processes = rankedProcesses.map(p => ({
             id: p.id,
+            process_ref: p.process_ref,
             summary: p.heuristicLabel || p.label,
             priority: Math.round(p.priority * 1000) / 1000,
             symbol_count: p.symbols.length,
@@ -839,16 +1492,125 @@ export class LocalBackend {
             process_symbols: dedupedSymbols,
             definitions: definitions.slice(0, 20), // cap standalone definitions
         };
-        if (runtimeChainVerifyMode === 'on-demand' && runtimeChainVerifyEnabled) {
+        const hydrationMetas = [...dedupedSymbols, ...definitions]
+            .map((row) => row?.hydrationMeta)
+            .filter(Boolean);
+        if (hydrationMetas.length > 0) {
+            result.hydrationMeta = hydrationMetas[0];
+        }
+        const lowerQuery = searchQuery.toLowerCase();
+        const firstSymbolForHops = dedupedSymbols.find((row) => lowerQuery.includes(String(row?.name || '').toLowerCase()))
+            || definitions.find((row) => lowerQuery.includes(String(row?.name || '').toLowerCase()))
+            || dedupedSymbols[0]
+            || definitions[0];
+        const firstVerificationHint = processes.find((row) => row?.verification_hint)?.verification_hint;
+        const firstResourceBindings = Array.isArray(firstSymbolForHops?.resourceBindings)
+            ? firstSymbolForHops.resourceBindings
+            : [];
+        const retrievalRule = await resolveRetrievalRuleHint({
+            repoPath: repo.repoPath,
+            queryText: params.query,
+            symbolName: String(firstSymbolForHops?.name || searchQuery),
+            seedPath,
+        });
+        result.next_hops = buildNextHops({
+            seedPath,
+            mappedSeedTargets,
+            resourceBindings: firstResourceBindings,
+            verificationHint: firstVerificationHint,
+            retrievalRule,
+            repoName: repo.name,
+            symbolName: String(firstSymbolForHops?.name || searchQuery),
+            queryForSymbol: String(firstSymbolForHops?.name || searchQuery),
+        });
+        const missingEvidenceRows = [...dedupedSymbols, ...definitions]
+            .flatMap((row) => (Array.isArray(row?.missing_evidence) ? row.missing_evidence : []));
+        result.missing_evidence = [...new Set(missingEvidenceRows)];
+        const evidenceMetaRows = [...dedupedSymbols, ...definitions]
+            .map((row) => row?.evidence_meta)
+            .filter(Boolean);
+        const filterDiagnostics = [...dedupedSymbols, ...definitions]
+            .flatMap((row) => (Array.isArray(row?.filter_diagnostics) ? row.filter_diagnostics : []));
+        if (evidenceMetaRows.length > 0) {
+            const explicitTrimRequested = evidenceMaxBindings !== undefined || evidenceMaxReferenceFields !== undefined;
+            let omittedCount = evidenceMetaRows.reduce((sum, row) => sum + Number(row.omitted_count || 0), 0);
+            const allBindings = [...dedupedSymbols, ...definitions]
+                .flatMap((row) => (Array.isArray(row?.resourceBindings) ? row.resourceBindings : []));
+            const extraBindingOmission = (evidenceMaxBindings !== undefined && allBindings.length > evidenceMaxBindings)
+                ? (allBindings.length - evidenceMaxBindings)
+                : 0;
+            omittedCount += extraBindingOmission;
+            if (explicitTrimRequested && omittedCount === 0) {
+                omittedCount = 1;
+            }
+            const truncated = evidenceMetaRows.some((row) => Boolean(row.truncated))
+                || extraBindingOmission > 0
+                || explicitTrimRequested;
+            const filterExhausted = evidenceMetaRows.some((row) => Boolean(row.filter_exhausted));
+            result.evidence_meta = {
+                truncated,
+                omitted_count: omittedCount,
+                ...(truncated ? { next_fetch_hint: 'Rerun with unity_evidence_mode=full to fetch complete evidence.' } : {}),
+                ...(filterExhausted ? { filter_exhausted: true } : {}),
+                minimum_evidence_satisfied: !explicitTrimRequested
+                    && extraBindingOmission === 0
+                    && evidenceMetaRows.every((row) => row.minimum_evidence_satisfied !== false),
+                verifier_minimum_evidence_satisfied: evidenceMetaRows.some((row) => row.verifier_minimum_evidence_satisfied !== false),
+            };
+            if (filterDiagnostics.length > 0) {
+                result.filter_diagnostics = [...new Set(filterDiagnostics)];
+            }
+        }
+        else if (unityResourcesMode !== 'off'
+            && (evidenceMaxBindings !== undefined || evidenceMaxReferenceFields !== undefined)) {
+            result.evidence_meta = {
+                truncated: true,
+                omitted_count: 1,
+                next_fetch_hint: 'Rerun with unity_evidence_mode=full to fetch complete evidence.',
+                minimum_evidence_satisfied: false,
+                verifier_minimum_evidence_satisfied: false,
+            };
+        }
+        if (runtimeChainVerifyMode === 'on-demand') {
             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({
+            result.runtime_claim = await verifyRuntimeClaimOnDemand({
                 repoPath: repo.repoPath,
                 executeParameterized: (query, queryParams) => executeParameterized(repo.id, query, queryParams || {}),
                 queryText: searchQuery,
+                resourceSeedPath: seedPath,
+                mappedSeedTargets,
                 resourceBindings,
+                rulesRoot: path.join(repo.repoPath, '.gitnexus', 'rules'),
+                minimumEvidenceSatisfied: result.evidence_meta?.verifier_minimum_evidence_satisfied !== false,
             });
+            if (hydrationPolicy === 'strict' && result.hydrationMeta?.fallbackToCompact && result.runtime_claim) {
+                if (result.runtime_claim.status === 'verified_full') {
+                    result.runtime_claim.status = 'verified_partial';
+                }
+                if (result.runtime_claim.evidence_level === 'verified_chain' || result.runtime_claim.status === 'verified_partial') {
+                    result.runtime_claim.evidence_level = 'verified_segment';
+                }
+            }
+            if (result.runtime_claim?.reason === 'rule_matched_but_evidence_missing'
+                && (!Array.isArray(result.runtime_claim.gaps) || result.runtime_claim.gaps.length === 0)) {
+                result.runtime_claim.gaps = [
+                    {
+                        segment: 'runtime',
+                        reason: 'missing verifier evidence',
+                        next_command: result.runtime_claim.next_action || `gitnexus query --repo "${repo.name}" --runtime-chain-verify on-demand`,
+                    },
+                ];
+            }
+            if (result.runtime_claim) {
+                result.runtime_chain = {
+                    status: result.runtime_claim.status,
+                    evidence_level: result.runtime_claim.evidence_level,
+                    hops: Array.isArray(result.runtime_claim.hops) ? result.runtime_claim.hops : [],
+                    gaps: Array.isArray(result.runtime_claim.gaps) ? result.runtime_claim.gaps : [],
+                };
+            }
         }
         return result;
     }
@@ -1131,17 +1893,63 @@ export class LocalBackend {
         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);
+        const confidenceFieldsEnabled = true;
         let unityResourcesMode = 'off';
         let unityHydrationMode = 'compact';
+        let unityEvidenceMode = 'summary';
+        let hydrationPolicy = 'balanced';
+        let resourceSeedMode = 'balanced';
         try {
             unityResourcesMode = parseUnityResourcesMode(params.unity_resources);
             unityHydrationMode = parseUnityHydrationMode(params.unity_hydration_mode);
+            unityEvidenceMode = parseUnityEvidenceMode(params.unity_evidence_mode);
+            hydrationPolicy = parseHydrationPolicy(params.hydration_policy);
+            resourceSeedMode = parseResourceSeedMode(params.resource_seed_mode);
         }
         catch (error) {
             return { error: error instanceof Error ? error.message : String(error) };
         }
+        const evidenceMaxBindings = Number.isFinite(Number(params.max_bindings))
+            ? Number(params.max_bindings)
+            : undefined;
+        const evidenceMaxReferenceFields = Number.isFinite(Number(params.max_reference_fields))
+            ? Number(params.max_reference_fields)
+            : undefined;
+        const evidenceResourcePathPrefix = String(params.resource_path_prefix || '').trim() || undefined;
+        const seedPath = resolveSeedPath({
+            resourcePathPrefix: evidenceResourcePathPrefix,
+            filePath: file_path,
+            queryText: name,
+        });
+        const evidenceBindingKind = String(params.binding_kind || '').trim() || undefined;
+        let mappedSeedTargets = [];
+        if (seedPath) {
+            try {
+                const seedRows = await executeParameterized(repo.id, `
+          MATCH (:File {filePath: $seedPath})-[r:CodeRelation {type: 'UNITY_ASSET_GUID_REF'}]->(target:File)
+          RETURN DISTINCT target.filePath AS targetPath, r.reason AS relationReason
+          LIMIT 100
+        `, { seedPath });
+                const candidates = seedRows
+                    .map((row) => {
+                    const targetPath = normalizePath(String(row?.targetPath || row?.[0] || '').trim());
+                    const parsedReason = parseSeedRelationReason(row?.relationReason);
+                    return {
+                        targetPath,
+                        fieldName: parsedReason.fieldName,
+                        sourceLayer: parsedReason.sourceLayer,
+                    };
+                })
+                    .filter((row) => row.targetPath.length > 0);
+                mappedSeedTargets = rankSeedTargetCandidates(seedPath, candidates);
+            }
+            catch (e) {
+                logQueryError('context:seed-mapped-targets', e);
+            }
+            if (mappedSeedTargets.length === 0) {
+                mappedSeedTargets = rankSeedTargetCandidates(seedPath, (await resolveSeedTargetsFromResourceFile(repo.repoPath, seedPath)).map((targetPath) => ({ targetPath })));
+            }
+        }
         if (!name && !uid) {
             return { error: 'Either "name" or "uid" parameter is required.' };
         }
@@ -1320,8 +2128,13 @@ export class LocalBackend {
         };
         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,
+            const hydrationDecision = resolveHydrationModeDecision({
+                hydrationPolicy,
+                unityHydrationMode,
+            });
+            let hydrationReason = hydrationDecision.reason;
+            let hydratedUnityContext = await hydrateUnityForSymbol({
+                mode: hydrationDecision.requestedMode,
                 basePayload: unityContext,
                 deps: {
                     executeQuery: (query, queryParams) => {
@@ -1340,15 +2153,73 @@ export class LocalBackend {
                     filePath: symFilePath,
                 },
             });
+            const firstMissingEvidence = buildMissingEvidenceFromHydrationMeta(hydratedUnityContext.hydrationMeta);
+            if (hydrationPolicy === 'balanced' && firstMissingEvidence.length > 0 && hydratedUnityContext.hydrationMeta?.needsParityRetry) {
+                hydratedUnityContext = await hydrateUnityForSymbol({
+                    mode: 'parity',
+                    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,
+                    },
+                });
+                hydrationReason = 'hydration_policy_balanced_escalated_to_parity_on_missing_evidence';
+            }
+            if (hydratedUnityContext.hydrationMeta?.fallbackToCompact) {
+                hydrationReason = `${hydrationReason}+fallback_to_compact`;
+            }
+            hydratedUnityContext = withHydrationDecisionMeta({
+                payload: hydratedUnityContext,
+                requestedMode: hydrationDecision.requestedMode,
+                reason: hydrationReason,
+            });
+            const finalMissingEvidence = buildMissingEvidenceFromHydrationMeta(hydratedUnityContext.hydrationMeta);
             Object.assign(result, hydratedUnityContext);
+            result.missing_evidence = hydrationPolicy === 'balanced'
+                ? [...new Set([...firstMissingEvidence, ...finalMissingEvidence])]
+                : finalMissingEvidence;
+            if (Array.isArray(result.resourceBindings) && result.resourceBindings.length > 0) {
+                const evidenceView = buildUnityEvidenceView({
+                    resourceBindings: result.resourceBindings,
+                    mode: unityEvidenceMode,
+                    scopePreset: undefined,
+                    resourcePathPrefix: evidenceResourcePathPrefix,
+                    bindingKind: evidenceBindingKind,
+                    maxBindings: evidenceMaxBindings,
+                    maxReferenceFields: evidenceMaxReferenceFields,
+                });
+                result.resourceBindings = evidenceView.resourceBindings;
+                result.serializedFields = evidenceView.serializedFields;
+                result.evidence_meta = evidenceView.evidence_meta;
+                if (evidenceView.filter_diagnostics.length > 0) {
+                    result.filter_diagnostics = evidenceView.filter_diagnostics;
+                }
+            }
             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;
+                    const verificationTarget = pickVerificationTarget({
+                        seedMode: resourceSeedMode,
+                        seedPath,
+                        mappedSeedTargets,
+                        resourceBindings,
+                        fallback: symFilePath || symName || symNodeId,
+                    });
                     processRows = mergeProcessEvidence({
                         directRows: [],
                         projectedRows: [],
@@ -1367,28 +2238,101 @@ export class LocalBackend {
                 }
             }
         }
-        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({
+        result.processes = processRows.map((r) => {
+            const rawPid = String(r.pid || r[0] || '');
+            const process_ref = buildProcessRef({
+                repoName: repo.name,
+                processId: rawPid,
+                origin: toProcessRefOrigin(r.evidence_mode),
+                indexedCommit: String(repo.lastCommit || 'unknown_commit'),
+                symbolUid: String(symNodeId || ''),
+                evidenceFingerprint: deriveEvidenceFingerprint({ nodeId: symNodeId, filePath: symFilePath, startLine: sym.startLine || sym[4], endLine: sym.endLine || sym[5] }, {
+                    pid: rawPid,
+                    processSubtype: r.processSubtype || r[2] || '',
+                    evidenceMode: r.evidence_mode,
+                    step: r.step || r[4] || 0,
+                    stepCount: r.stepCount || r[5] || 0,
+                }, Array.isArray(result.resourceBindings)
+                    ? result.resourceBindings.map((binding) => ({
+                        resourcePath: binding.resourcePath,
+                        bindingKind: binding.bindingKind,
+                        componentObjectId: binding.componentObjectId,
+                    }))
+                    : []),
+            });
+            return {
+                id: process_ref.id,
+                process_ref,
+                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,
+                } : {}),
+            };
+        });
+        const topVerificationHint = result.processes.find((row) => row?.verification_hint)?.verification_hint;
+        const contextResourceBindings = Array.isArray(result.resourceBindings) ? result.resourceBindings : [];
+        const retrievalRule = await resolveRetrievalRuleHint({
+            repoPath: repo.repoPath,
+            queryText: name,
+            symbolName: symName || String(name || uid || ''),
+            seedPath,
+        });
+        result.next_hops = buildNextHops({
+            seedPath,
+            mappedSeedTargets,
+            resourceBindings: contextResourceBindings,
+            verificationHint: topVerificationHint,
+            retrievalRule,
+            repoName: repo.name,
+            symbolName: symName || String(name || uid || ''),
+            queryForSymbol: symName || String(name || uid || ''),
+        });
+        if (runtimeChainVerifyMode === 'on-demand') {
+            result.runtime_claim = await verifyRuntimeClaimOnDemand({
                 repoPath: repo.repoPath,
                 executeParameterized: (query, queryParams) => executeParameterized(repo.id, query, queryParams || {}),
+                queryText: name,
                 symbolName: symName,
                 symbolFilePath: symFilePath,
+                resourceSeedPath: seedPath,
+                mappedSeedTargets,
                 resourceBindings: Array.isArray(result.resourceBindings) ? result.resourceBindings : [],
+                rulesRoot: path.join(repo.repoPath, '.gitnexus', 'rules'),
+                minimumEvidenceSatisfied: result.evidence_meta?.minimum_evidence_satisfied !== false,
             });
+            if (hydrationPolicy === 'strict' && result.hydrationMeta?.fallbackToCompact && result.runtime_claim) {
+                if (result.runtime_claim.status === 'verified_full') {
+                    result.runtime_claim.status = 'verified_partial';
+                }
+                if (result.runtime_claim.evidence_level === 'verified_chain' || result.runtime_claim.status === 'verified_partial') {
+                    result.runtime_claim.evidence_level = 'verified_segment';
+                }
+            }
+            if (result.runtime_claim?.reason === 'rule_matched_but_evidence_missing'
+                && (!Array.isArray(result.runtime_claim.gaps) || result.runtime_claim.gaps.length === 0)) {
+                result.runtime_claim.gaps = [
+                    {
+                        segment: 'runtime',
+                        reason: 'missing verifier evidence',
+                        next_command: result.runtime_claim.next_action || `gitnexus context --repo "${repo.name}" --runtime-chain-verify on-demand`,
+                    },
+                ];
+            }
+            if (result.runtime_claim) {
+                result.runtime_chain = {
+                    status: result.runtime_claim.status,
+                    evidence_level: result.runtime_claim.evidence_level,
+                    hops: Array.isArray(result.runtime_claim.hops) ? result.runtime_claim.hops : [],
+                    gaps: Array.isArray(result.runtime_claim.gaps) ? result.runtime_claim.gaps : [],
+                };
+            }
         }
         return result;
     }
@@ -2088,7 +3032,13 @@ export class LocalBackend {
     async queryProcessDetail(name, repoName) {
         const repo = await this.resolveRepo(repoName);
         await this.ensureInitialized(repo.id);
-        const processes = await executeParameterized(repo.id, `
+        const byId = await executeParameterized(repo.id, `
+      MATCH (p:Process)
+      WHERE p.id = $processName
+      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 });
+        const processes = byId.length > 0 ? byId : 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.processSubtype AS processSubtype, p.runtimeChainConfidence AS runtimeChainConfidence, p.stepCount AS stepCount