@veewo/gitnexus 1.5.0 → 1.5.1

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

@@ -14,15 +14,16 @@ import { runUnityUiTrace } from '../../core/unity/ui-trace.js';
 import { loadUnityContext } from './unity-enrichment.js';
 import { buildMissingEvidenceFromHydrationMeta, hydrateUnityForSymbol } from './unity-runtime-hydration.js';
 import { buildUnityEvidenceView } from './unity-evidence-view.js';
+import { buildSlimContextResult, buildSlimQueryResult, resolveResponseProfile, } from './agent-safe-response.js';
 import { deriveEvidenceFingerprint, mergeProcessEvidence } from './process-evidence.js';
 import { buildProcessRef } from './process-ref.js';
 import { verifyRuntimeClaimOnDemand, } from './runtime-chain-verify.js';
+import { adjustRuntimeClaimForPolicy } from './runtime-claim.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';
@@ -140,9 +141,7 @@ function aggregateProcessConfidence(rows) {
 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';
+    return 'method_projected';
 }
 function selectVerificationHint(rows) {
     return rows.find((row) => row.verification_hint)?.verification_hint;
@@ -170,6 +169,16 @@ export function extractUnityResourcePaths(text) {
     }
     return out;
 }
+export function computeVerifierMinimumEvidenceSatisfied(input) {
+    if (input.truncated || input.filterExhausted)
+        return false;
+    if (!Array.isArray(input.evidenceMetaRows) || input.evidenceMetaRows.length === 0)
+        return false;
+    return input.evidenceMetaRows.every((row) => (row?.truncated !== true
+        && row?.filter_exhausted !== true
+        && row?.minimum_evidence_satisfied !== false
+        && row?.verifier_minimum_evidence_satisfied !== false));
+}
 export function resolveSeedPath(input) {
     const explicit = normalizePath(String(input.resourcePathPrefix || '').trim());
     if (explicit && isUnityResourcePath(explicit)) {
@@ -206,6 +215,113 @@ function parseSeedRelationReason(rawReason) {
         return {};
     }
 }
+async function loadSeedUnityResourceChains(input) {
+    const seedPath = normalizePath(String(input.seedPath || '').trim());
+    if (!seedPath)
+        return [];
+    const targetSymbols = (input.targetSymbols || [])
+        .map((symbol) => ({
+        id: String(symbol?.id || '').trim(),
+        name: String(symbol?.name || '').trim(),
+        filePath: normalizePath(String(symbol?.filePath || '').trim()),
+        requireExact: Boolean(symbol?.requireExact),
+    }))
+        .filter((symbol) => symbol.id || symbol.name || symbol.filePath);
+    let rows = [];
+    try {
+        rows = await executeParameterized(input.repoId, `
+      MATCH (source:File {filePath: $seedPath})-[r1:CodeRelation {type: 'UNITY_ASSET_GUID_REF'}]->(intermediate:File)-[r2:CodeRelation {type: 'UNITY_GRAPH_NODE_SCRIPT_REF'}]->(target)
+      RETURN source.filePath AS sourceResourcePath,
+             r1.type AS relationType,
+             r1.reason AS relationReason,
+             intermediate.filePath AS intermediateResourcePath,
+             r2.type AS nextRelationType,
+             r2.reason AS nextRelationReason,
+             target.id AS targetUid,
+             target.name AS targetName,
+             labels(target)[0] AS targetKind,
+             target.filePath AS targetFilePath
+      LIMIT 200
+    `, { seedPath });
+    }
+    catch (e) {
+        logQueryError('unity-resource-chains:seed-second-hop', e);
+        return [];
+    }
+    const seen = new Set();
+    const chains = rows
+        .map((row, index) => {
+        const targetUid = String(row?.targetUid || row?.[6] || '').trim();
+        const targetName = String(row?.targetName || row?.[7] || '').trim();
+        const targetFilePath = normalizePath(String(row?.targetFilePath || row?.[9] || '').trim());
+        const chain = {
+            sourceResourcePath: normalizePath(String(row?.sourceResourcePath || row?.[0] || '').trim()),
+            relationType: 'UNITY_ASSET_GUID_REF',
+            relationReason: String(row?.relationReason || row?.[2] || '').trim() || undefined,
+            intermediateResourcePath: normalizePath(String(row?.intermediateResourcePath || row?.[3] || '').trim()),
+            nextRelationType: 'UNITY_GRAPH_NODE_SCRIPT_REF',
+            nextRelationReason: String(row?.nextRelationReason || row?.[5] || '').trim() || undefined,
+            targetSymbol: {
+                ...(targetUid ? { uid: targetUid } : {}),
+                ...(targetName ? { name: targetName } : {}),
+                kind: String(row?.targetKind || row?.[8] || '').trim() || undefined,
+                ...(targetFilePath ? { filePath: targetFilePath } : {}),
+            },
+        };
+        return {
+            chain,
+            index,
+            score: scoreUnityResourceChainTarget(chain, targetSymbols),
+        };
+    })
+        .filter(({ chain, score }) => {
+        if (!chain.sourceResourcePath || !chain.intermediateResourcePath || !chain.targetSymbol?.name)
+            return false;
+        if (targetSymbols.length > 0 && score <= 0)
+            return false;
+        const key = `${chain.sourceResourcePath}->${chain.intermediateResourcePath}->${chain.targetSymbol.uid || chain.targetSymbol.name}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    })
+        .sort((a, b) => (b.score - a.score) || (a.index - b.index))
+        .slice(0, 20)
+        .map((entry) => entry.chain);
+    return chains;
+}
+function scoreUnityResourceChainTarget(chain, targetSymbols) {
+    if (targetSymbols.length === 0)
+        return 1;
+    const activeTargetSymbols = targetSymbols.some((symbol) => symbol.requireExact)
+        ? targetSymbols.filter((symbol) => symbol.requireExact)
+        : targetSymbols;
+    const targetUid = String(chain.targetSymbol?.uid || '').trim();
+    const targetName = String(chain.targetSymbol?.name || '').trim();
+    const targetFilePath = normalizePath(String(chain.targetSymbol?.filePath || '').trim());
+    let best = 0;
+    for (const symbol of activeTargetSymbols) {
+        let score = 0;
+        const exactMatched = Boolean((targetUid && symbol.id && targetUid === symbol.id)
+            || (targetName && symbol.name && targetName === symbol.name));
+        if (targetUid && symbol.id && targetUid === symbol.id)
+            score += 100;
+        if (targetFilePath && symbol.filePath && targetFilePath === symbol.filePath)
+            score += 60;
+        if (targetName && symbol.name && targetName === symbol.name)
+            score += 30;
+        if (symbol.requireExact && !exactMatched)
+            score = 0;
+        best = Math.max(best, score);
+    }
+    return best;
+}
+function exactResourceChainQuerySymbol(queryText) {
+    const trimmed = String(queryText || '').trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed))
+        return undefined;
+    return { name: trimmed, requireExact: true };
+}
 function scoreSeedTargetCandidate(seedPath, candidate) {
     const targetPath = normalizePath(candidate.targetPath);
     if (!targetPath)
@@ -291,6 +407,54 @@ export function pickVerificationTarget(input) {
     // Balanced mode fallback only; strict mode is handled above and never falls back to first binding.
     return normalizedBindings[0] || input.fallback;
 }
+export function pickVerifierSymbolAnchor(input) {
+    const rows = [
+        ...input.processSymbols,
+        ...input.definitions,
+    ];
+    const evidenceModeRank = (row) => {
+        const mode = String(row?.process_evidence_mode || row?.evidence_mode || '').trim().toLowerCase();
+        if (mode === 'direct_step')
+            return 3;
+        if (mode === 'method_projected')
+            return 2;
+        if (mode === 'resource_heuristic')
+            return 1;
+        return 0;
+    };
+    const confidenceRank = (row) => {
+        const confidence = String(row?.process_confidence || row?.confidence || '').trim().toLowerCase();
+        if (confidence === 'high')
+            return 3;
+        if (confidence === 'medium')
+            return 2;
+        if (confidence === 'low')
+            return 1;
+        return 0;
+    };
+    const preferredStructuredSymbol = rows
+        .map((row, index) => ({ row, index }))
+        .filter(({ row }) => evidenceModeRank(row) >= 2 && confidenceRank(row) >= 2)
+        .sort((a, b) => {
+        const modeDiff = evidenceModeRank(b.row) - evidenceModeRank(a.row);
+        if (modeDiff !== 0)
+            return modeDiff;
+        const confidenceDiff = confidenceRank(b.row) - confidenceRank(a.row);
+        if (confidenceDiff !== 0)
+            return confidenceDiff;
+        return a.index - b.index;
+    })[0]?.row;
+    const resourceAnchoredSymbol = rows.find((row) => Array.isArray(row?.resourceBindings) && row.resourceBindings.length > 0);
+    const lowerQuery = String(input.queryText || '').toLowerCase();
+    const firstMatchInQuery = rows.find((row) => lowerQuery.includes(String(row?.name || '').toLowerCase()));
+    const anchor = preferredStructuredSymbol || resourceAnchoredSymbol || input.processSymbols[0] || firstMatchInQuery || input.definitions[0];
+    const symbolName = String(anchor?.name || '').trim();
+    const symbolFilePath = normalizePath(String(anchor?.filePath || '').trim());
+    return {
+        ...(symbolName ? { symbolName } : {}),
+        ...(symbolFilePath ? { symbolFilePath } : {}),
+    };
+}
 export function buildNextHops(input) {
     const hops = [];
     const seen = new Set();
@@ -317,12 +481,12 @@ export function buildNextHops(input) {
     const shouldSuppressRawResourceHops = !input.seedPath
         && mappedIntersectBindings.length === 0
         && currentSymbolMatchesRetrievalScope === false;
-    const candidateResources = shouldSuppressRawResourceHops ? [] : [
-        ...mappedIntersectBindings,
-        ...mappedRemainder,
-        ...(input.seedPath ? [normalizePath(input.seedPath)] : []),
-        ...bindingPaths,
-    ].filter(Boolean);
+    const candidateResources = shouldSuppressRawResourceHops ? [] : rankCandidateResources([
+        ...(input.seedPath ? [{ target: normalizePath(input.seedPath), bucket: 0 }] : []),
+        ...mappedIntersectBindings.map((target) => ({ target, bucket: 1 })),
+        ...mappedRemainder.map((target) => ({ target, bucket: 2 })),
+        ...bindingPaths.map((target) => ({ target, bucket: 3 })),
+    ]);
     const repoArg = input.repoName ? ` --repo "${input.repoName}"` : '';
     const withRepoInCommand = (command) => {
         const trimmed = String(command || '').trim();
@@ -367,6 +531,54 @@ export function buildNextHops(input) {
     });
     return hops.slice(0, 5);
 }
+function rankCandidateResources(candidates) {
+    const deduped = new Map();
+    for (const candidate of candidates) {
+        const target = normalizePath(String(candidate.target || '').trim());
+        if (!target)
+            continue;
+        const next = {
+            target,
+            bucket: candidate.bucket,
+            noisePenalty: scoreResourcePathNoise(target),
+        };
+        const existing = deduped.get(target);
+        if (!existing) {
+            deduped.set(target, next);
+            continue;
+        }
+        if (next.bucket < existing.bucket)
+            existing.bucket = next.bucket;
+        if (next.noisePenalty < existing.noisePenalty)
+            existing.noisePenalty = next.noisePenalty;
+    }
+    return [...deduped.values()]
+        .sort((a, b) => {
+        const bucketDiff = a.bucket - b.bucket;
+        if (bucketDiff !== 0)
+            return bucketDiff;
+        const noiseDiff = a.noisePenalty - b.noisePenalty;
+        if (noiseDiff !== 0)
+            return noiseDiff;
+        return a.target.localeCompare(b.target);
+    })
+        .map((entry) => entry.target);
+}
+function scoreResourcePathNoise(resourcePath) {
+    const haystack = normalizePath(String(resourcePath || '').trim()).toLowerCase();
+    let penalty = 0;
+    if (!haystack)
+        return penalty;
+    if (haystack.includes('/test') || haystack.includes('testgraphs'))
+        penalty += 5;
+    if (haystack.includes('debug'))
+        penalty += 4;
+    if (haystack.includes('测试'))
+        penalty += 6;
+    if (haystack.includes('标记'))
+        penalty += 6;
+    return penalty;
+}
 async function resolveRetrievalRuleHint(input) {
     const bundle = await loadCompiledRuleBundle(input.repoPath, 'retrieval_rules');
     if (!bundle)
@@ -387,27 +599,35 @@ export function pickRetrievalRuleHintFromBundle(input) {
     const rank = (rule) => {
         let score = 0;
         let matchedTrigger = false;
+        let matchedEvidence = false;
         for (const token of rule.trigger_tokens || []) {
             const normalized = String(token || '').trim().toLowerCase();
             if (!normalized)
                 continue;
             if (haystack.includes(normalized)) {
                 matchedTrigger = true;
+                matchedEvidence = 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))
+            if (normalized && haystack.includes(normalized)) {
+                matchedEvidence = true;
                 score += 20 + normalized.length;
+            }
         }
         for (const token of rule.resource_types || []) {
             const normalized = String(token || '').trim().toLowerCase();
-            if (normalized && haystack.includes(normalized))
+            if (normalized && haystack.includes(normalized)) {
+                matchedEvidence = true;
                 score += 4 + normalized.length;
+            }
         }
+        if (!matchedEvidence)
+            return Number.NEGATIVE_INFINITY;
+        if (!matchedTrigger)
+            score -= 3;
         return score;
     };
     const matched = [...input.rules]
@@ -459,9 +679,7 @@ function aggregateRuntimeChainEvidenceLevel(rows) {
 function toProcessRefOrigin(mode) {
     if (mode === 'direct_step')
         return 'step_in_process';
-    if (mode === 'method_projected')
-        return 'method_projected';
-    return 'resource_heuristic';
+    return 'method_projected';
 }
 function confidenceRank(confidence) {
     if (confidence === 'high')
@@ -854,8 +1072,6 @@ 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':
@@ -902,25 +1118,6 @@ 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();
@@ -1098,6 +1295,7 @@ export class LocalBackend {
         const evidenceBindingKind = String(params.binding_kind || '').trim() || undefined;
         const searchQuery = params.query.trim();
         const runtimeChainVerifyMode = String(params.runtime_chain_verify || 'off').trim().toLowerCase();
+        const responseProfile = resolveResponseProfile(params.response_profile);
         let mappedSeedTargets = [];
         if (seedPath) {
             try {
@@ -1340,37 +1538,6 @@ export class LocalBackend {
                 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
-                    : [];
-                const needsParityRetry = Boolean(symbolEntry.hydrationMeta?.needsParityRetry);
-                const hasPartialUnityEvidence = resourceBindings.length > 0 || needsParityRetry;
-                if (hasPartialUnityEvidence) {
-                    const verificationTarget = pickVerificationTarget({
-                        seedMode: resourceSeedMode,
-                        seedPath,
-                        mappedSeedTargets,
-                        resourceBindings,
-                        fallback: String(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);
@@ -1492,15 +1659,33 @@ export class LocalBackend {
             process_symbols: dedupedSymbols,
             definitions: definitions.slice(0, 20), // cap standalone definitions
         };
+        if (unityResourcesMode !== 'off' && seedPath) {
+            result.resource_chains = await loadSeedUnityResourceChains({
+                repoId: repo.id,
+                seedPath,
+                targetSymbols: [
+                    exactResourceChainQuerySymbol(searchQuery),
+                    ...[...dedupedSymbols, ...definitions].map((row) => ({
+                        id: row?.id,
+                        name: row?.name,
+                        filePath: row?.filePath,
+                    })),
+                ].filter(Boolean),
+            });
+        }
         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()))
+        const verifierAnchor = pickVerifierSymbolAnchor({
+            queryText: searchQuery,
+            processSymbols: dedupedSymbols,
+            definitions,
+        });
+        const firstSymbolForHops = dedupedSymbols.find((row) => String(row?.name || '') === verifierAnchor.symbolName)
+            || definitions.find((row) => String(row?.name || '') === verifierAnchor.symbolName)
             || dedupedSymbols[0]
             || definitions[0];
         const firstVerificationHint = processes.find((row) => row?.verification_hint)?.verification_hint;
@@ -1523,6 +1708,12 @@ export class LocalBackend {
             symbolName: String(firstSymbolForHops?.name || searchQuery),
             queryForSymbol: String(firstSymbolForHops?.name || searchQuery),
         });
+        const queryStrictAnchorMode = Boolean(evidenceResourcePathPrefix);
+        result.decision_context = {
+            strict_anchor_mode: queryStrictAnchorMode,
+            anchor_symbol_name: String(firstSymbolForHops?.name || verifierAnchor.symbolName || searchQuery),
+            anchor_resource_path: evidenceResourcePathPrefix || seedPath || mappedSeedTargets[0] || null,
+        };
         const missingEvidenceRows = [...dedupedSymbols, ...definitions]
             .flatMap((row) => (Array.isArray(row?.missing_evidence) ? row.missing_evidence : []));
         result.missing_evidence = [...new Set(missingEvidenceRows)];
@@ -1555,7 +1746,11 @@ export class LocalBackend {
                 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),
+                verifier_minimum_evidence_satisfied: computeVerifierMinimumEvidenceSatisfied({
+                    evidenceMetaRows,
+                    truncated,
+                    filterExhausted,
+                }),
             };
             if (filterDiagnostics.length > 0) {
                 result.filter_diagnostics = [...new Set(filterDiagnostics)];
@@ -1578,20 +1773,20 @@ export class LocalBackend {
             result.runtime_claim = await verifyRuntimeClaimOnDemand({
                 repoPath: repo.repoPath,
                 executeParameterized: (query, queryParams) => executeParameterized(repo.id, query, queryParams || {}),
-                queryText: searchQuery,
+                queryText: searchQuery || verifierAnchor.symbolName || seedPath,
+                symbolName: verifierAnchor.symbolName,
+                symbolFilePath: verifierAnchor.symbolFilePath,
                 resourceSeedPath: seedPath,
                 mappedSeedTargets,
                 resourceBindings,
-                rulesRoot: path.join(repo.repoPath, '.gitnexus', 'rules'),
-                minimumEvidenceSatisfied: result.evidence_meta?.verifier_minimum_evidence_satisfied !== false,
+                minimumEvidenceSatisfied: result.evidence_meta?.verifier_minimum_evidence_satisfied === true,
             });
-            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) {
+                result.runtime_claim = adjustRuntimeClaimForPolicy({
+                    claim: result.runtime_claim,
+                    hydrationPolicy,
+                    fallbackToCompact: Boolean(result.hydrationMeta?.fallbackToCompact),
+                });
             }
             if (result.runtime_claim?.reason === 'rule_matched_but_evidence_missing'
                 && (!Array.isArray(result.runtime_claim.gaps) || result.runtime_claim.gaps.length === 0)) {
@@ -1612,7 +1807,13 @@ export class LocalBackend {
                 };
             }
         }
-        return result;
+        if (responseProfile === 'full') {
+            return result;
+        }
+        return buildSlimQueryResult(result, {
+            repoName: repo.name,
+            queryText: searchQuery,
+        });
     }
     /**
      * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results
@@ -1893,6 +2094,7 @@ 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 responseProfile = resolveResponseProfile(params.response_profile);
         const confidenceFieldsEnabled = true;
         let unityResourcesMode = 'off';
         let unityHydrationMode = 'compact';
@@ -2207,36 +2409,6 @@ export class LocalBackend {
                     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 verificationTarget = pickVerificationTarget({
-                        seedMode: resourceSeedMode,
-                        seedPath,
-                        mappedSeedTargets,
-                        resourceBindings,
-                        fallback: 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) => {
             const rawPid = String(r.pid || r[0] || '');
@@ -2278,6 +2450,18 @@ export class LocalBackend {
         });
         const topVerificationHint = result.processes.find((row) => row?.verification_hint)?.verification_hint;
         const contextResourceBindings = Array.isArray(result.resourceBindings) ? result.resourceBindings : [];
+        if (unityResourcesMode !== 'off' && seedPath) {
+            result.resource_chains = await loadSeedUnityResourceChains({
+                repoId: repo.id,
+                seedPath,
+                targetSymbols: [{
+                        id: symNodeId,
+                        name: symName,
+                        filePath: symFilePath,
+                        requireExact: true,
+                    }],
+            });
+        }
         const retrievalRule = await resolveRetrievalRuleHint({
             repoPath: repo.repoPath,
             queryText: name,
@@ -2294,26 +2478,30 @@ export class LocalBackend {
             symbolName: symName || String(name || uid || ''),
             queryForSymbol: symName || String(name || uid || ''),
         });
+        const contextStrictAnchorMode = Boolean(uid || file_path || evidenceResourcePathPrefix);
+        result.decision_context = {
+            strict_anchor_mode: contextStrictAnchorMode,
+            anchor_symbol_name: symName || String(name || uid || ''),
+            anchor_resource_path: evidenceResourcePathPrefix || seedPath || mappedSeedTargets[0] || null,
+        };
         if (runtimeChainVerifyMode === 'on-demand') {
             result.runtime_claim = await verifyRuntimeClaimOnDemand({
                 repoPath: repo.repoPath,
                 executeParameterized: (query, queryParams) => executeParameterized(repo.id, query, queryParams || {}),
-                queryText: name,
+                queryText: name || symName || uid || seedPath,
                 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,
+                minimumEvidenceSatisfied: result.evidence_meta?.verifier_minimum_evidence_satisfied === true,
             });
-            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) {
+                result.runtime_claim = adjustRuntimeClaimForPolicy({
+                    claim: result.runtime_claim,
+                    hydrationPolicy,
+                    fallbackToCompact: Boolean(result.hydrationMeta?.fallbackToCompact),
+                });
             }
             if (result.runtime_claim?.reason === 'rule_matched_but_evidence_missing'
                 && (!Array.isArray(result.runtime_claim.gaps) || result.runtime_claim.gaps.length === 0)) {
@@ -2334,7 +2522,13 @@ export class LocalBackend {
                 };
             }
         }
-        return result;
+        if (responseProfile === 'full') {
+            return result;
+        }
+        return buildSlimContextResult(result, {
+            repoName: repo.name,
+            symbolName: symName || String(name || uid || ''),
+        });
     }
     /**
      * Legacy explore — kept for backwards compatibility with resources.ts.

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

@@ -1,4 +1,4 @@
-export type ProcessEvidenceMode = 'direct_step' | 'method_projected' | 'resource_heuristic';
+export type ProcessEvidenceMode = 'direct_step' | 'method_projected';
 export type ProcessConfidence = 'high' | 'medium' | 'low';
 export interface VerificationHint {
     action: 'rerun_parity_hydration' | 'manual_asset_meta_verification';
@@ -8,7 +8,6 @@ export interface VerificationHint {
 export interface DeriveConfidenceInput {
     evidenceMode: ProcessEvidenceMode;
     processSubtype?: string;
-    hasPartialUnityEvidence?: boolean;
 }
 export interface BuildVerificationHintInput {
     confidence: ProcessConfidence;

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

@@ -1,7 +1,4 @@
 export function deriveConfidence(input) {
-    if (input.evidenceMode === 'resource_heuristic') {
-        return 'low';
-    }
     if (input.evidenceMode === 'method_projected') {
         return 'medium';
     }